คู่มือสรุปการจัดกลุ่ม K-Means ด้วย Scikit-Learn

บทนำ

K-หมายถึงการจัดกลุ่ม เป็นหนึ่งในอัลกอริธึมแมชชีนเลิร์นนิงที่ไม่มีการควบคุมซึ่งใช้กันอย่างแพร่หลายมากที่สุดซึ่งสร้างคลัสเตอร์ของข้อมูลตามความคล้ายคลึงกันระหว่างอินสแตนซ์ข้อมูล

ในคู่มือนี้ เราจะมาดูตัวอย่างง่ายๆ เพื่อทำความเข้าใจว่าอัลกอริธึม K-Means ทำงานอย่างไรก่อนที่จะใช้งานโดยใช้ Scikit-Learn จากนั้น เราจะหารือถึงวิธีการกำหนดจำนวนคลัสเตอร์ (Ks) ใน K-Means และยังครอบคลุมถึงการวัดระยะทาง ความแปรปรวน และข้อดีข้อเสียของ K-Means

แรงจูงใจ

ลองนึกภาพสถานการณ์ต่อไปนี้ อยู่มาวันหนึ่ง เมื่อเดินไปรอบๆ ละแวกนั้น คุณสังเกตเห็นว่ามีร้านสะดวกซื้อ 10 แห่ง และเริ่มสงสัยว่าร้านใดที่คล้ายคลึงกัน อยู่ใกล้กันในบริเวณใกล้เคียงกัน ขณะค้นหาวิธีตอบคำถามนั้น คุณได้พบแนวทางที่น่าสนใจซึ่งแบ่งร้านค้าออกเป็นกลุ่มตามพิกัดของร้านบนแผนที่

ตัวอย่างเช่น หากร้านหนึ่งตั้งอยู่ 5 กม. ทางตะวันตกและ 3 กม. ทางเหนือ – คุณจะกำหนด (5, 3) พิกัดไปที่มันและแสดงในกราฟ ลองพล็อตจุดแรกนี้เพื่อให้เห็นภาพว่าเกิดอะไรขึ้น:

import matplotlib.pyplot as plt

plt.title("Store With Coordinates (5, 3)")
plt.scatter(x=5, y=3)

นี่เป็นเพียงประเด็นแรก ดังนั้นเราจึงสามารถเข้าใจได้ว่าเราจะเป็นตัวแทนของร้านค้าได้อย่างไร สมมติว่าเรามี 10 พิกัดแล้ว 10 ร้านค้าที่รวบรวมไว้ หลังจากจัดระเบียบไว้ใน a numpy array เรายังสามารถพล็อตตำแหน่งได้:

import numpy as np

points = np.array([[5, 3], [10, 15], [15, 12], [24, 10], [30, 45], [85, 70], [71, 80], [60, 78], [55, 52],[80, 91]])

xs = points[:,0] 
ys = points[:,1]  

plt.title("10 Stores Coordinates")
plt.scatter(x=xs, y=ys)

วิธีการใช้อัลกอริทึม K-Means ด้วยตนเอง

ตอนนี้เราสามารถดูร้านค้า 10 แห่งบนกราฟได้ และปัญหาหลักคือต้องค้นหาว่ามีวิธีใดบ้างที่สามารถแบ่งออกเป็นกลุ่มต่างๆ ตามความใกล้ชิด เพียงแค่ดูกราฟอย่างรวดเร็ว เราก็อาจจะสังเกตได้ สองกลุ่มร้านค้า – จุดหนึ่งเป็นจุดล่างซ้ายล่าง และอีกจุดหนึ่งเป็นจุดบนขวา บางทีเราอาจแยกจุดสองจุดที่อยู่ตรงกลางออกเป็นกลุ่มที่แยกจากกันก็ได้ ดังนั้นจึงสร้าง สามกลุ่มที่แตกต่างกัน.

ในส่วนนี้ เราจะพูดถึงกระบวนการจัดกลุ่มจุดด้วยตนเอง โดยแบ่งเป็นกลุ่มตามจำนวนที่กำหนด ด้วยวิธีนี้ เราจะดำเนินการทุกขั้นตอนของ . อย่างระมัดระวัง อัลกอริทึมการจัดกลุ่ม K-Means. ในตอนท้ายของส่วนนี้ คุณจะได้รับทั้งความเข้าใจโดยสัญชาตญาณและนำไปใช้ได้จริงของขั้นตอนทั้งหมดที่ดำเนินการระหว่างการจัดกลุ่ม K-Means หลังจากนั้น เราจะมอบหมายให้ Scikit-Learn

วิธีใดดีที่สุดในการพิจารณาว่ามีจุดสองหรือสามกลุ่ม วิธีง่ายๆ วิธีหนึ่งคือเพียงแค่เลือกกลุ่มจำนวนหนึ่ง เช่น สองกลุ่ม แล้วพยายามจัดกลุ่มคะแนนตามตัวเลือกนั้น

เอาเป็นว่าเราตัดสินใจว่ามี สองกลุ่ม ของร้านเรา (คะแนน) ตอนนี้ เราต้องหาวิธีทำความเข้าใจว่าคะแนนใดอยู่ในกลุ่มใด สามารถทำได้โดยเลือกหนึ่งจุดเพื่อเป็นตัวแทน กลุ่ม 1 และอีกหนึ่งตัวแทน กลุ่ม 2. จุดเหล่านี้จะใช้เป็นข้อมูลอ้างอิงในการวัดระยะทางจากจุดอื่นๆ ทั้งหมดไปยังแต่ละกลุ่ม

ในลักษณะนั้นพูดชี้ (5, 3) ลงเอยในกลุ่ม 1 และจุด (79, 60) ให้กับกลุ่มที่ 2 เมื่อพยายามกำหนดจุดใหม่ (6, 3) สำหรับกลุ่ม เราต้องวัดระยะห่างจากจุดสองจุดนั้น ในกรณีของจุด (6, 3) is ใกล้ชิด ไป (5, 3)ดังนั้นจึงเป็นของกลุ่มที่แสดงโดยจุดนั้น - กลุ่ม 1. ด้วยวิธีนี้ เราสามารถจัดกลุ่มจุดทั้งหมดออกเป็นกลุ่มที่เกี่ยวข้องกันได้อย่างง่ายดาย

ในตัวอย่างนี้ นอกจากการกำหนดจำนวนกลุ่มแล้ว (กลุ่ม) – เรายังเลือกบางจุดที่จะเป็น การอ้างอิง ระยะทางสำหรับจุดใหม่ของแต่ละกลุ่ม

นั่นคือแนวคิดทั่วไปในการทำความเข้าใจความคล้ายคลึงกันระหว่างร้านค้าของเรา มาปฏิบัติกัน – ก่อนอื่นเราสามารถเลือกจุดอ้างอิงสองจุดได้ที่ สุ่ม. จุดอ้างอิงของ กลุ่ม 1 จะ (5, 3) และจุดอ้างอิงของ กลุ่ม 2 จะ (10, 15). เราสามารถเลือกทั้งสองจุดของเรา numpy อาร์เรย์โดย [0] และ [1] จัดทำดัชนีและเก็บไว้ใน g1 (กลุ่มที่ 1) และ g2 (กลุ่ม 2) ตัวแปร:

g1 = points[0]
g2 = points[1]

หลังจากทำเช่นนี้ เราต้องคำนวณระยะทางจากจุดอื่นๆ ทั้งหมดไปยังจุดอ้างอิงเหล่านั้น สิ่งนี้ทำให้เกิดคำถามสำคัญ – วิธีวัดระยะทางนั้น โดยพื้นฐานแล้วเราสามารถใช้การวัดระยะทางใดก็ได้ แต่สำหรับจุดประสงค์ของคู่มือนี้ ให้ใช้ Euclidean Distance_

อาจเป็นประโยชน์ที่จะรู้ว่าการวัดระยะทางแบบยุคลิดอิงตามทฤษฎีบทพีทาโกรัส:

$$
ค^2 = ก^2 + ข^2
$$

เมื่อปรับให้เข้ากับจุดบนเครื่องบิน – (a1, b1) และ (a2, b2)สูตรก่อนหน้าจะกลายเป็น:

$$
ค^2 = (a2-a1)^2 + (b2-b1)^2
$$

ระยะทางจะเป็นรากที่สองของ cเราจึงเขียนสูตรได้ดังนี้

$$
euclidean_{dist} = sqrt[2][(a2 – a1)^2 + (b2 – b1) ^2)]
$$

จนถึงตอนนี้ เราได้เลือกจุดเพื่อเป็นตัวแทนของกลุ่ม และเรารู้วิธีคำนวณระยะทาง ตอนนี้ มาใส่ระยะทางและกลุ่มกันโดยกำหนดคะแนนร้านค้าที่รวบรวมไว้แต่ละจุดให้กับกลุ่ม

เพื่อให้เห็นภาพได้ดีขึ้น เราจะประกาศสามรายการ คนแรกที่เก็บคะแนนของกลุ่มแรก – points_in_g1. คนที่สองเก็บคะแนนจากกลุ่ม 2 – points_in_g2และอันสุดท้าย— group, To ฉลาก คะแนนเป็นอย่างใดอย่างหนึ่ง 1 (อยู่ในกลุ่มที่ 1) หรือ 2 (อยู่ในกลุ่ม 2):

points_in_g1 = []
points_in_g2 = []
group = []

ตอนนี้เราสามารถวนซ้ำจุดของเราและคำนวณระยะทางแบบยุคลิดระหว่างจุดเหล่านี้กับการอ้างอิงแต่ละกลุ่มของเรา แต่ละจุดจะเป็น ใกล้ชิด ให้กับกลุ่มใดกลุ่มหนึ่งจากสองกลุ่ม – โดยพิจารณาจากกลุ่มที่ใกล้เคียงที่สุด เราจะกำหนดจุดแต่ละจุดให้กับรายการที่เกี่ยวข้อง ในขณะเดียวกันก็เพิ่ม 1 or 2 ไป group รายการ:

for p in points:
    x1, y1 = p[0], p[1]
    euclidean_distance_g1 = np.sqrt((g1[0] - x1)**2 + (g1[1] - y1)**2)
    euclidean_distance_g2 = np.sqrt((g2[0] - x1)**2 + (g2[1] - y1)**2)
    if euclidean_distance_g1 < euclidean_distance_g2:
        points_in_g1.append(p)
        group.append('1')
    else:
        points_in_g2.append(p)
        group.append('2')

ลองดูผลลัพธ์ของการทำซ้ำนี้เพื่อดูว่าเกิดอะไรขึ้น:

print(f'points_in_g1:{points_in_g1}n 
npoints_in_g2:{points_in_g2}n 
ngroup:{group}')

ซึ่งส่งผลให้:

points_in_g1:[array([5, 3])]
 
points_in_g2:[array([10, 15]), array([15, 12]), 
              array([24, 10]), array([30, 45]), 
              array([85, 70]), array([71, 80]),
              array([60, 78]), array([55, 52]), 
              array([80, 91])]
 
group:[1, 2, 2, 2, 2, 2, 2, 2, 2, 2] 

นอกจากนี้เรายังสามารถพล็อตผลลัพธ์การจัดกลุ่มด้วยสีต่างๆ ตามกลุ่มที่กำหนดโดยใช้ Seaborn's scatterplot() กับ group เป็น hue ข้อโต้แย้ง:

import seaborn as sns

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

เห็นได้ชัดว่ามีเพียงจุดแรกของเราเท่านั้นที่ได้รับมอบหมายให้กับกลุ่ม 1 และจุดอื่นๆ ทั้งหมดถูกกำหนดให้กับกลุ่มที่ 2 ผลลัพธ์นั้นแตกต่างจากที่เราคาดไว้ในตอนแรก เมื่อพิจารณาถึงความแตกต่างระหว่างผลลัพธ์ของเรากับความคาดหวังเริ่มต้นของเรา มีวิธีใดบ้างที่เราจะเปลี่ยนแปลงสิ่งนั้นได้ ดูเหมือนว่าจะมี!

วิธีหนึ่งคือการทำซ้ำขั้นตอนและเลือกจุดต่าง ๆ เพื่อเป็นข้อมูลอ้างอิงของกลุ่ม สิ่งนี้จะเปลี่ยนผลลัพธ์ของเรา หวังว่าจะสอดคล้องกับสิ่งที่เราคาดไว้ในตอนเริ่มต้นมากขึ้น ครั้งที่สองนี้ เราสุ่มเลือกไม่ได้เหมือนเมื่อก่อน แต่โดยการได้ หมายความ ของคะแนนที่จัดกลุ่มไว้แล้วทั้งหมดของเรา ด้วยวิธีนี้ จุดใหม่เหล่านั้นจะถูกจัดวางให้อยู่ตรงกลางของกลุ่มที่เกี่ยวข้อง

เช่น ถ้ากลุ่มที่สองมีแต่แต้ม (10, 15), (30, 45). ใหม่ ส่วนกลาง จุดจะเป็น (10 + 30)/2 และ (15+45)/2 – ซึ่งเท่ากับ (20, 30).

เนื่องจากเราได้ใส่ผลลัพธ์ในรายการแล้ว เราจึงสามารถแปลงเป็น . ก่อนได้ numpy อาร์เรย์ เลือก xs, ys แล้วรับ หมายความ:

g1_center = [np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()]
g2_center = [np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()]
g1_center, g2_center

เพื่อช่วยทำซ้ำขั้นตอนด้วยจุดศูนย์กลางใหม่ของเรา ให้แปลงรหัสก่อนหน้าของเราให้เป็นฟังก์ชัน ดำเนินการ และดูว่ามีการเปลี่ยนแปลงใด ๆ ในการจัดกลุ่มจุด:

def assigns_points_to_two_groups(g1_center, g2_center):
    points_in_g1 = []
    points_in_g2 = []
    group = []

    for p in points:
        x1, y1 = p[0], p[1]
        euclidean_distance_g1 = np.sqrt((g1_center[0] - x1)**2 + (g1_center[1] - y1)**2)
        euclidean_distance_g2 = np.sqrt((g2_center[0] - x1)**2 + (g2_center[1] - y1)**2)
        if euclidean_distance_g1 < euclidean_distance_g2:
            points_in_g1.append(p)
            group.append(1)
        else:
            points_in_g2.append(p)
            group.append(2)
    return points_in_g1, points_in_g2, group

เรียกใช้ฟังก์ชันและเก็บผลลัพธ์ใน points_in_g1, points_in_g2และ group ตัวแปร

points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
points_in_g1, points_in_g2, group

และพล็อตแผนภาพด้วยจุดสีเพื่อให้เห็นภาพการแบ่งกลุ่ม:

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

ดูเหมือนว่าการจัดกลุ่มคะแนนของเราคือ ดีขึ้นเรื่อย ๆ. แต่ยังคงมีจุดสองจุดตรงกลางกราฟที่สามารถกำหนดให้กับกลุ่มใดกลุ่มหนึ่งเมื่อพิจารณาความใกล้ชิดกับทั้งสองกลุ่ม อัลกอริธึมที่เราพัฒนาขึ้นจนถึงตอนนี้ได้กำหนดจุดทั้งสองนี้ให้กับกลุ่มที่สอง

ซึ่งหมายความว่าเราอาจทำขั้นตอนนี้ซ้ำได้อีกครั้งโดยใช้ Xs และ Ys เพื่อสร้างจุดศูนย์กลางใหม่สองจุด (เซนทรอยด์) ให้กับกลุ่มของเราและมอบหมายใหม่ตามระยะทาง

มาสร้างฟังก์ชั่นเพื่ออัพเดทเซนทรอยด์กัน กระบวนการทั้งหมดสามารถลดลงเป็นหลายสายของฟังก์ชันนั้นได้:

def updates_centroids(points_in_g1, points_in_g2):
    g1_center = np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()
    g2_center = np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()
    return g1_center, g2_center

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

สังเกตว่าหลังจากการทำซ้ำครั้งที่สามนี้ แต่ละจุดจะอยู่ในคลัสเตอร์ที่แตกต่างกัน ดูเหมือนว่าผลลัพธ์จะดีขึ้น – มาทำอีกครั้งกันเถอะ ตอนนี้กำลังจะไปที่ การทำซ้ำครั้งที่สี่ ของวิธีการของเรา:

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

ครั้งที่สี่นี้เราได้ ผลลัพธ์เดียวกัน เช่นเดียวกับก่อนหน้านี้ ดังนั้นดูเหมือนว่าประเด็นของเราจะไม่เปลี่ยนกลุ่มอีกต่อไป ผลลัพธ์ของเรามีความเสถียรแล้ว – อยู่ในสถานะที่ไม่สามารถเปลี่ยนแปลงได้ หรือ แปรสภาพ. นอกจากนั้น เราได้ผลลัพธ์แบบเดียวกับที่เราคาดไว้สำหรับทั้ง 2 กลุ่ม นอกจากนี้เรายังสามารถดูได้ว่าการแบ่งที่มาถึงนี้เหมาะสมหรือไม่

มาสรุปสิ่งที่เราได้ทำไปแล้วอย่างรวดเร็ว เราได้แบ่งร้านค้า 10 แห่งตามภูมิศาสตร์ออกเป็นสองส่วน โดยร้านหนึ่งอยู่ในภาคตะวันตกเฉียงใต้ตอนล่างและสาขาอื่นๆ ในภาคตะวันออกเฉียงเหนือ การรวบรวมข้อมูลเพิ่มเติมนอกเหนือจากที่เรามีอยู่แล้วอาจเป็นเรื่องที่น่าสนใจ เช่น รายได้ จำนวนลูกค้ารายวัน และอื่นๆ อีกมากมาย ด้วยวิธีนี้ เราจะทำการวิเคราะห์ที่สมบูรณ์ยิ่งขึ้นและอาจสร้างผลลัพธ์ที่น่าสนใจยิ่งขึ้น

การศึกษาคลัสเตอร์ในลักษณะนี้สามารถทำได้เมื่อแบรนด์ที่เป็นที่ยอมรับแล้วต้องการเลือกพื้นที่เพื่อเปิดร้านใหม่ ในกรณีนั้น มีตัวแปรอีกมากมายที่นำมาพิจารณานอกเหนือจากตำแหน่ง

ทั้งหมดนี้เกี่ยวข้องกับอัลกอริทึม K-Means อย่างไร

ในขณะที่ทำตามขั้นตอนเหล่านี้ คุณอาจสงสัยว่ามันเกี่ยวอะไรกับอัลกอริทึม K-Means กระบวนการที่เราได้ดำเนินการไปแล้วคือ อัลกอริทึม K-Means. กล่าวโดยสรุป เราได้กำหนดจำนวนกลุ่ม/คลัสเตอร์ สุ่มเลือกจุดเริ่มต้น และเซ็นทรอยด์ที่อัปเดตในการวนซ้ำแต่ละครั้งจนกระทั่งคลัสเตอร์มาบรรจบกัน โดยพื้นฐานแล้วเราได้ทำอัลกอริธึมทั้งหมดด้วยมือ – ดำเนินการแต่ละขั้นตอนอย่างระมัดระวัง

พื้นที่ K ใน K-Means มาจาก จำนวนคลัสเตอร์ ที่ต้องตั้งค่าก่อนเริ่มกระบวนการวนซ้ำ ในกรณีของเรา เค = 2. ลักษณะนี้บางครั้งถูกมองว่าเป็น เชิงลบ พิจารณาว่ามีวิธีการจัดกลุ่มอื่นๆ เช่น การทำคลัสเตอร์แบบลำดับชั้น ซึ่งไม่จำเป็นต้องมีจำนวนคลัสเตอร์ที่แน่นอนล่วงหน้า

เนื่องจากการใช้วิธีการ K-mean ก็กลายเป็น ไวต่อค่าผิดปกติและค่าสุดขั้ว – ปรับปรุงความแปรปรวนและทำให้เซนทรอยด์ของเรามีส่วนร่วมได้ยากขึ้น ดังนั้น จงมีสติสัมปชัญญะในการปฏิบัติ ค่าสุดขั้วและการวิเคราะห์นอกรีต ก่อนทำคลัสเตอร์โดยใช้อัลกอริทึม K-Means

นอกจากนี้ สังเกตว่าคะแนนของเราถูกแบ่งเป็นส่วนตรง ไม่มีส่วนโค้งเมื่อสร้างคลัสเตอร์ นั่นอาจเป็นข้อเสียของอัลกอริทึม K-Means

K-Means ยังมีอีกมากมาย ข้อได้เปรียบ! มันทำงานได้ดีบน ชุดข้อมูลขนาดใหญ่ ซึ่งอาจจัดการได้ยากหากคุณใช้อัลกอริธึมการจัดกลุ่มแบบลำดับชั้นบางประเภท นอกจากนี้ยัง รับประกันการบรรจบกันและสามารถได้อย่างง่ายดาย พูดคุย และ ปรับ. นอกจากนั้น อาจเป็นอัลกอริธึมการจัดกลุ่มที่ใช้มากที่สุด

ตอนนี้เราได้ทำตามขั้นตอนทั้งหมดที่ดำเนินการในอัลกอริธึม K-Means และเข้าใจข้อดีและข้อเสียของมันแล้ว ในที่สุดเราก็สามารถใช้ K-Means โดยใช้ไลบรารี Scikit-Learn

วิธีการใช้อัลกอริทึม K-Means โดยใช้ Scikit-เรียนรู้

หากต้องการตรวจสอบผลลัพธ์ของเราอีกครั้ง ให้ทำขั้นตอนนี้อีกครั้ง แต่ตอนนี้ใช้โค้ด 3 บรรทัดกับ sklearn:

from sklearn.cluster import KMeans


kmeans = KMeans(n_clusters=2, random_state=42) 
kmeans.fit(points)
kmeans.labels_

ในที่นี้ ป้ายกำกับจะเหมือนกับกลุ่มก่อนหน้าของเรา ลองพล็อตผลลัพธ์อย่างรวดเร็ว:

sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

พล็อตผลลัพธ์จะเหมือนกับพล็อตจากส่วนก่อนหน้า

ด้วย Scikit-Learn คุณยังสามารถเริ่มต้น K-Means เพื่อการบรรจบกันที่เร็วขึ้นด้วยการตั้งค่า init='k-means++' การโต้แย้ง. ในแง่กว้างๆ K-หมายถึง++ ยังคงเลือก k ศูนย์คลัสเตอร์เริ่มต้นแบบสุ่มตามการกระจายแบบสม่ำเสมอ จากนั้น ศูนย์คลัสเตอร์ที่ตามมาแต่ละแห่งจะถูกเลือกจากจุดข้อมูลที่เหลือ ไม่ใช่โดยการคำนวณเฉพาะการวัดระยะทาง แต่โดยใช้ความน่าจะเป็น การใช้ความน่าจะเป็นจะช่วยเพิ่มความเร็วให้กับอัลกอริทึม และมีประโยชน์เมื่อต้องจัดการกับชุดข้อมูลที่มีขนาดใหญ่มาก

วิธีข้อศอก – การเลือกจำนวนกลุ่มที่ดีที่สุด

จนถึงตอนนี้ดีมาก! เราได้จัดกลุ่มร้านค้า 10 แห่งตามระยะห่างแบบยุคลิดระหว่างจุดและเซนทรอยด์ แล้วจุดสองจุดที่อยู่ตรงกลางกราฟที่จัดกลุ่มยากขึ้นหน่อยล่ะ พวกเขาไม่สามารถแยกกลุ่มได้เช่นกัน? เราเลือกผิดจริงๆหรอ K = 2 กลุ่ม? บางทีเราก็มี K = 3 กลุ่ม? เราสามารถมีมากกว่าสามกลุ่มและไม่ได้ตระหนักถึงมัน

คำถามที่ถามอยู่นี้คือ วิธีการกำหนดจำนวนกลุ่ม (K) ใน K-Means. เพื่อตอบคำถามนั้น เราต้องเข้าใจว่าจะมีคลัสเตอร์ที่ "ดีกว่า" สำหรับค่า K ที่ต่างออกไปหรือไม่

วิธีที่ไร้เดียงสาในการค้นหาสิ่งนั้นคือการจัดกลุ่มจุดที่มีค่าต่างๆ ของ Kดังนั้นสำหรับ K=2, K=3, K=4 และอื่นๆ:

for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 

แต่การจัดกลุ่มจุดที่แตกต่างกัน Ks คนเดียว ไม่พอ เพื่อทำความเข้าใจว่าเราได้เลือกค่าในอุดมคติสำหรับ K. เราต้องการวิธีประเมินคุณภาพการจัดกลุ่มสำหรับแต่ละรายการ K เราเลือกแล้ว

การคำนวณ .ด้วยตนเอง ภายใน Cluster Sum of Squares (WCSS)

ที่นี่เป็นสถานที่ที่เหมาะที่จะแนะนำการวัดว่าจุดคลัสเตอร์ของเราอยู่ใกล้กันมากเพียงใด โดยพื้นฐานแล้วจะอธิบายว่า ความแปรปรวน เรามีอยู่ในคลัสเตอร์เดียว วัดนี้เรียกว่า ภายใน Cluster Sum ของ Squares,หรือ วชส สั้น ๆ. ยิ่ง WCSS มีขนาดเล็กเท่าใด แต้มของเราก็ยิ่งใกล้มากขึ้นเท่านั้น ดังนั้นเราจึงมีคลัสเตอร์ที่มีรูปแบบดีกว่า สูตร WCSS สามารถใช้ได้กับคลัสเตอร์จำนวนเท่าใดก็ได้:

$$
WCSS = ผลรวม (Pi_1 – Centroid_1)^2 + cdots + ผลรวม (Pi_n – Centroid_n)^2
$$

ตอนนี้เราสามารถสรุปได้ว่าเราได้เลือกที่จะมีสองคลัสเตอร์และพยายามใช้ WCSS เพื่อให้เข้าใจมากขึ้นว่า WCSS คืออะไรและจะใช้งานอย่างไร ตามที่ระบุในสูตร เราจำเป็นต้องสรุปผลต่างกำลังสองระหว่างจุดคลัสเตอร์และเซนทรอยด์ทั้งหมด ดังนั้น ถ้าจุดแรกของเราจากกลุ่มแรกคือ (5, 3) และเซนทรอยด์สุดท้ายของเรา (หลังจากคอนเวอร์เจนซ์) ของกลุ่มแรกคือ (16.8, 17.0)WCSS จะเป็น:

$$
WCSS = ผลรวม ((5,3) – (16.8, 17.0))^2
$$

$$
WCSS = ผลรวม ((5-16.8) + (3-17.0))^2
$$

$$
WCSS = ผลรวม ((-11.8) + (-14.0))^2
$$

$$
WCSS = ผลรวม ((-25.8))^2
$$

$$
WCSS = 335.24
$$

ตัวอย่างนี้แสดงให้เห็นวิธีที่เราคำนวณ WCSS สำหรับจุดเดียวจากคลัสเตอร์ แต่คลัสเตอร์มักจะมีมากกว่าหนึ่งจุด และเราจำเป็นต้องพิจารณาทั้งหมดเมื่อคำนวณ WCSS เราจะทำอย่างนั้นโดยกำหนดฟังก์ชันที่รับคลัสเตอร์ของจุดและเซนทรอยด์ และส่งกลับผลรวมของกำลังสอง:

def sum_of_squares(cluster, centroid):
    squares = []
    for p in cluster:
        squares.append((p - centroid)**2)
        ss = np.array(squares).sum()
    return ss

ตอนนี้เราสามารถหาผลรวมของช่องสี่เหลี่ยมสำหรับแต่ละคลัสเตอร์ได้:

g1 = sum_of_squares(points_in_g1, g1_center)
g2 = sum_of_squares(points_in_g2, g2_center)

และสรุปผลเพื่อให้ได้ยอดรวม วชส:

g1 + g2

ผลลัพธ์นี้ใน:

2964.3999999999996

ดังนั้น ในกรณีของเรา เมื่อ K เท่ากับ 2 WCSS ทั้งหมดเท่ากับ 2964.39. ตอนนี้ เราสามารถสลับ K และคำนวณ WCSS สำหรับทั้งหมดได้ ด้วยวิธีนี้เราจะสามารถเข้าใจถึงสิ่งที่ K เราควรเลือกให้คลัสเตอร์ของเราทำงานได้ดีที่สุด

คิดเลข วชส การใช้ Scikit-เรียนรู้

โชคดีที่เราไม่จำเป็นต้องคำนวณ WCSS สำหรับแต่ละรายการด้วยตนเอง K. หลังจากดำเนินการจัดกลุ่ม K-Means สำหรับจำนวนคลัสเตอร์ที่กำหนด เราสามารถรับ WCSS ได้โดยใช้ inertia_ คุณลักษณะ. ตอนนี้ เราสามารถกลับไปที่ K-Means . ของเราได้ for วนซ้ำ ใช้เพื่อ swith จำนวนคลัสเตอร์ และแสดงรายการค่า WCSS ที่สอดคล้องกัน:

wcss = [] 
for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 
    wcss.append(kmeans.inertia_)
wcss

สังเกตว่าค่าที่สองในรายการ เหมือนกับที่เราเคยคำนวณมาก่อนสำหรับ K = 2:

[18272.9, # For k=1 
 2964.3999999999996, # For k=2
 1198.75, # For k=3
 861.75,
 570.5,
 337.5,
 175.83333333333334,
 79.5,
 17.0,
 0.0]

เพื่อให้เห็นภาพผลลัพธ์เหล่านั้น เรามาพล็อตของเรา Ks พร้อมกับค่า WCSS:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss)

มีการหยุดชะงักในโครงเรื่องเมื่อ x = 2, จุดต่ำสุดในเส้น, และจุดต่ำสุดเมื่อ x = 3. สังเกตว่ามันทำให้เรานึกถึง รูปร่างของข้อศอก. โดยการวางแผน Ks พร้อมกับ WCSS เรากำลังใช้ วิธีข้อศอก เพื่อเลือกจำนวน Ks และ K ที่เลือกคือจุดศอกต่ำสุดพอดีดังนั้นมันจะเป็น 3 แทน 2ในกรณีของเรา:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss);
plt.axvline(3, linestyle='--', color='r')

เราสามารถเรียกใช้อัลกอริทึมคลัสเตอร์ K-Means อีกครั้งเพื่อดูว่าข้อมูลของเราจะเป็นอย่างไรด้วย สามกลุ่ม:

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(points)
sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

เราพอใจกับสองคลัสเตอร์อยู่แล้ว แต่ตามวิธีข้อศอก สามคลัสเตอร์จะเหมาะสมกว่าสำหรับข้อมูลของเรา ในกรณีนี้ เราจะมีร้านค้าสามประเภทแทนที่จะเป็นสองร้าน ก่อนใช้วิธีข้อศอก เรานึกถึงกลุ่มร้านค้าทางตะวันตกเฉียงใต้และตะวันออกเฉียงเหนือ ตอนนี้เราก็มีร้านค้าตรงกลางด้วย อาจจะเป็นทำเลที่ดีในการเปิดร้านอื่นเพราะใกล้จะมีการแข่งขันน้อยกว่า

มาตรการคุณภาพคลัสเตอร์ทางเลือก

นอกจากนี้ยังมีมาตรการอื่นๆ ที่สามารถใช้ได้เมื่อประเมินคุณภาพของคลัสเตอร์:

• คะแนนเงา – วิเคราะห์ไม่เพียงแต่ระยะห่างระหว่างจุดภายในคลัสเตอร์ แต่ยังรวมถึงระหว่างคลัสเตอร์ด้วย
• ระหว่างคลัสเตอร์ ผลรวมของกำลังสอง (บีซีเอส) – เมตริกเสริม WCSS
• ผลรวมของข้อผิดพลาดกำลังสอง (สสส.)
• รัศมีสูงสุด – วัดระยะทางที่ใหญ่ที่สุดจากจุดหนึ่งไปยังจุดศูนย์กลาง
• รัศมีเฉลี่ย – ผลรวมของระยะทางที่ใหญ่ที่สุดจากจุดหนึ่งไปยังเซนทรอยด์หารด้วยจำนวนกระจุก

ขอแนะนำให้ทำการทดสอบและทำความรู้จักกับแต่ละรายการ เนื่องจากขึ้นอยู่กับปัญหา ทางเลือกบางอย่างอาจมีความเกี่ยวข้องมากกว่าเมตริกที่ใช้กันอย่างแพร่หลายมากที่สุด (WCSS และ Silhouette Score).

ในท้ายที่สุด เช่นเดียวกับอัลกอริธึมวิทยาศาสตร์ข้อมูลจำนวนมาก เราต้องการลดความแปรปรวนภายในแต่ละคลัสเตอร์และเพิ่มความแปรปรวนระหว่างคลัสเตอร์ต่างๆ ให้มากที่สุด ดังนั้นเราจึงมีคลัสเตอร์ที่กำหนดและแยกออกได้มากกว่านี้

การใช้ K-Means กับชุดข้อมูลอื่น

ลองใช้สิ่งที่เราได้เรียนรู้กับชุดข้อมูลอื่น คราวนี้เราจะพยายามหากลุ่มของไวน์ที่คล้ายคลึงกัน

เราเริ่มต้นด้วยการนำเข้า pandas อ่าน wine-clustering CSV (ค่าที่คั่นด้วยจุลภาค) ไฟล์ลงใน a Dataframe โครงสร้าง:

import pandas as pd

df = pd.read_csv('wine-clustering.csv')

หลังจากโหลดแล้ว มาดูข้อมูล XNUMX รายการแรกด้วย head() วิธี:

df.head()

ผลลัพธ์นี้ใน:

	Alcohol 	Malic_Acid 	Ash 	Ash_Alcanity 	Magnesium 	Total_Phenols 	Flavanoids 	Nonflavanoid_Phenols 	Proanthocyanins 	Color_Intensity 	Hue 	OD280 	Proline
0 	14.23 		1.71 		2.43 	15.6 			127 		2.80 			3.06 		0.28 					2.29 				5.64 				1.04 	3.92 	1065
1 	13.20 		1.78 		2.14 	11.2 			100 		2.65 			2.76 		0.26 					1.28 				4.38 				1.05 	3.40 	1050
2 	13.16 		2.36 		2.67 	18.6 			101 		2.80 			3.24 		0.30 					2.81 				5.68 				1.03 	3.17 	1185
3 	14.37 		1.95 		2.50 	16.8 			113 		3.85 			3.49 		0.24 					2.18 				7.80 				0.86 	3.45 	1480
4 	13.24 		2.59 		2.87 	21.0 			118 		2.80 			2.69 		0.39 					1.82 				4.32 				1.04 	2.93 	735

เรามีการวัดปริมาณสารจำนวนมากในไวน์ ในที่นี้ เรายังไม่จำเป็นต้องแปลงคอลัมน์ที่เป็นหมวดหมู่ เนื่องจากคอลัมน์ทั้งหมดเป็นตัวเลข ทีนี้มาดูสถิติเชิงพรรณนากับ describe() วิธี:

df.describe().T 

ตารางอธิบาย:

 						count 	mean 		std 		min 	25% 	50% 	75% 		max
Alcohol 				178.0 	13.000618 	0.811827 	11.03 	12.3625 13.050 	13.6775 	14.83
Malic_Acid 				178.0 	2.336348 	1.117146 	0.74 	1.6025 	1.865 	3.0825 		5.80
Ash 					178.0 	2.366517 	0.274344 	1.36 	2.2100 	2.360 	2.5575 		3.23
Ash_Alcanity 			178.0 	19.494944 	3.339564 	10.60 	17.2000 19.500 	21.5000 	30.00
Magnesium 				178.0 	99.741573 	14.282484 	70.00 	88.0000 98.000 	107.0000 	162.00
Total_Phenols 			178.0 	2.295112 	0.625851 	0.98 	1.7425 	2.355 	2.8000 		3.88
Flavanoids 				178.0 	2.029270 	0.998859 	0.34 	1.2050 	2.135 	2.8750 		5.08
Nonflavanoid_Phenols 	178.0 	0.361854 	0.124453 	0.13 	0.2700 	0.340 	0.4375 		0.66
Proanthocyanins 		178.0 	1.590899 	0.572359 	0.41 	1.2500 	1.555 	1.9500 		3.58
Color_Intensity 		178.0 	5.058090 	2.318286 	1.28 	3.2200 	4.690 	6.2000 		13.00
Hue 					178.0 	0.957449 	0.228572 	0.48 	0.7825 	0.965 	1.1200 		1.71
OD280 					178.0 	2.611685 	0.709990 	1.27 	1.9375 	2.780 	3.1700 		4.00
Proline 				178.0 	746.893258 	314.907474 	278.00 	500.500 673.500 985.0000 	1680.00

ดูจากโต๊ะก็ชัดเจนว่ามี ความแปรปรวนของข้อมูล – สำหรับบางคอลัมน์เช่น Alchool มีมากขึ้นและสำหรับคนอื่น ๆ เช่น Malic_Acid, น้อย. ตอนนี้เราสามารถตรวจสอบว่ามีหรือไม่ null,หรือ NaN ค่าในชุดข้อมูลของเรา:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 13 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   Alcohol               178 non-null    float64
 1   Malic_Acid            178 non-null    float64
 2   Ash                   178 non-null    float64
 3   Ash_Alcanity          178 non-null    float64
 4   Magnesium             178 non-null    int64  
 5   Total_Phenols         178 non-null    float64
 6   Flavanoids            178 non-null    float64
 7   Nonflavanoid_Phenols  178 non-null    float64
 8   Proanthocyanins       178 non-null    float64
 9   Color_Intensity       178 non-null    float64
 10  Hue                   178 non-null    float64
 11  OD280                 178 non-null    float64
 12  Proline               178 non-null    int64  
dtypes: float64(11), int64(2)
memory usage: 18.2 KB

ไม่จำเป็นต้องวางหรือป้อนข้อมูล เนื่องจากไม่มีค่าว่างในชุดข้อมูล เราสามารถใช้ Seaborn pairplot() เพื่อดูการกระจายข้อมูลและตรวจสอบว่าชุดข้อมูลเป็นคู่ของคอลัมน์ที่น่าสนใจสำหรับการจัดกลุ่มหรือไม่:

sns.pairplot(df)

เมื่อดูที่แผนภาพคู่ สองคอลัมน์ดูเหมือนจะมีแนวโน้มดีสำหรับวัตถุประสงค์ในการจัดกลุ่ม – Alcohol และ OD280 (ซึ่งเป็นวิธีการกำหนดความเข้มข้นของโปรตีนในไวน์) ดูเหมือนว่ามี 3 กลุ่มที่แตกต่างกันในแปลงรวมสองกลุ่ม

มีคอลัมน์อื่น ๆ ที่ดูเหมือนจะสัมพันธ์กันเช่นกัน ที่โดดเด่นที่สุด Alcohol และ Total_Phenolsและ Alcohol และ Flavanoids. พวกมันมีความสัมพันธ์เชิงเส้นที่ยอดเยี่ยมซึ่งสามารถสังเกตได้ในแผนภาพคู่

เนื่องจากเรามุ่งเน้นการจัดกลุ่มด้วย K-Means ลองเลือกคอลัมน์หนึ่งคู่กัน พูดว่า Alcohol และ OD280และทดสอบวิธีข้อศอกสำหรับชุดข้อมูลนี้

เรามาพลอต scatterplot โดยให้สองคอลัมน์นั้นตั้งเป็นแกนของมัน เพื่อดูจุดที่เราต้องการแบ่งออกเป็นกลุ่มต่างๆ อย่างละเอียดยิ่งขึ้น:

sns.scatterplot(data=df, x='OD280', y='Alcohol')

ตอนนี้เราสามารถกำหนดคอลัมน์ของเราและใช้วิธีข้อศอกเพื่อกำหนดจำนวนคลัสเตอร์ เราจะเริ่มอัลกอริทึมด้วย kmeans++ เพียงเพื่อให้แน่ใจว่ามาบรรจบกันเร็วขึ้น:

values = df[['OD280', 'Alcohol']]

wcss_wine = [] 
for i in range(1, 11): 
    kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
    kmeans.fit(values) 
    wcss_wine.append(kmeans.inertia_)

เราได้คำนวณ WCSS ดังนั้นเราจึงสามารถพล็อตผลลัพธ์ได้:

clusters_wine = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
plt.plot(clusters_wine, wcss_wine)
plt.axvline(3, linestyle='--', color='r')

ตามวิธีข้อศอกเราควรมี 3 กลุ่มที่นี่ สำหรับขั้นตอนสุดท้าย ให้จัดกลุ่มคะแนนของเราออกเป็น 3 กลุ่มและพล็อตคลัสเตอร์ที่ระบุด้วยสี:

kmeans_wine = KMeans(n_clusters=3, random_state=42)
kmeans_wine.fit(values)
sns.scatterplot(x = values['OD280'], y = values['Alcohol'], hue=kmeans_wine.labels_)

เราเห็นกระจุก 0, 1และ 2 ในกราฟ จากการวิเคราะห์ของเรา กลุ่ม 0 มีไวน์ที่มีปริมาณโปรตีนสูงและแอลกอฮอล์ต่ำ กลุ่ม 1 มีไวน์ที่มีปริมาณแอลกอฮอล์สูงและโปรตีนต่ำ และ กลุ่ม 2 มีทั้งโปรตีนสูงและแอลกอฮอล์สูงในไวน์

นี่เป็นชุดข้อมูลที่น่าสนใจมาก และฉันแนะนำให้คุณทำการวิเคราะห์เพิ่มเติมโดยจัดกลุ่มข้อมูลหลังจากการทำให้เป็นมาตรฐานและ PCA – โดยการตีความผลลัพธ์และค้นหาการเชื่อมต่อใหม่

สรุป

K- หมายถึง การจัดกลุ่มเป็นอัลกอริธึมการเรียนรู้ของเครื่องที่ไม่มีการควบคุมที่เรียบง่ายแต่มีประสิทธิภาพมากสำหรับการจัดกลุ่มข้อมูล มันจัดกลุ่มข้อมูลตามระยะห่างแบบยุคลิดระหว่างจุดข้อมูล อัลกอริทึมการจัดกลุ่ม K-Means มีประโยชน์หลายอย่างสำหรับการจัดกลุ่มเอกสารข้อความ รูปภาพ วิดีโอ และอื่นๆ อีกมากมาย