Python đo khoảng cách

Tổng quan về kỹ thuật phân cụm

Bạn có thể thực hiện phân cụm bằng nhiều cách tiếp cận khác nhau—thực tế là có rất nhiều loại thuật toán phân cụm. Mỗi loại này đều có điểm mạnh và điểm yếu riêng. Điều này có nghĩa là các thuật toán phân cụm nhất định sẽ dẫn đến việc gán cụm tự nhiên hơn tùy thuộc vào dữ liệu đầu vào

Ghi chú. Nếu bạn muốn tìm hiểu về các thuật toán phân cụm không được đề cập trong phần này, thì hãy xem Khảo sát toàn diện về các thuật toán phân cụm để có đánh giá tuyệt vời về các kỹ thuật phổ biến

Việc chọn một thuật toán phân cụm thích hợp cho tập dữ liệu của bạn thường khó khăn do có nhiều lựa chọn. Một số yếu tố quan trọng ảnh hưởng đến quyết định này bao gồm các đặc điểm của cụm, tính năng của tập dữ liệu, số lượng ngoại lệ và số lượng đối tượng dữ liệu

Bạn sẽ khám phá cách các yếu tố này giúp xác định cách tiếp cận nào phù hợp nhất bằng cách xem xét ba loại thuật toán phân cụm phổ biến

1. phân cụm một phần
2. phân cụm theo thứ bậc
3. Phân cụm dựa trên mật độ

Thật đáng để xem xét các danh mục này ở cấp độ cao trước khi chuyển ngay sang phương tiện k. Bạn sẽ tìm hiểu điểm mạnh và điểm yếu của từng danh mục để cung cấp ngữ cảnh về cách phương tiện k phù hợp với bối cảnh của các thuật toán phân cụm

Phân cụm một phần

Phân cụm từng phần chia các đối tượng dữ liệu thành các nhóm không chồng chéo. Nói cách khác, không có đối tượng nào có thể là thành viên của nhiều hơn một cụm và mỗi cụm phải có ít nhất một đối tượng

Các kỹ thuật này yêu cầu người dùng chỉ định số lượng cụm, được biểu thị bằng biến k. Nhiều thuật toán phân cụm phân vùng hoạt động thông qua một quy trình lặp để gán các tập hợp con của các điểm dữ liệu thành k cụm. Hai ví dụ về thuật toán phân cụm là k-means và k-medoids

Các thuật toán này đều không xác định, có nghĩa là chúng có thể tạo ra các kết quả khác nhau từ hai lần chạy riêng biệt ngay cả khi các lần chạy dựa trên cùng một đầu vào

Phương pháp phân cụm từng phần có một số điểm mạnh

• Chúng hoạt động tốt khi các cụm có dạng hình cầu
• Chúng có thể mở rộng theo độ phức tạp của thuật toán

Họ cũng có một số điểm yếu

• Chúng không phù hợp với các cụm có hình dạng phức tạp và kích thước khác nhau
• Chúng bị hỏng khi được sử dụng với các cụm có mật độ khác nhau

Phân cụm theo cấp bậc

Phân cụm theo cấp bậc xác định các nhiệm vụ của cụm bằng cách xây dựng hệ thống phân cấp. Điều này được thực hiện theo cách tiếp cận từ dưới lên hoặc từ trên xuống

• Phân cụm kết tụ là cách tiếp cận từ dưới lên. Nó hợp nhất hai điểm giống nhau nhất cho đến khi tất cả các điểm được hợp nhất thành một cụm duy nhất

• Phân cụm chia rẽ là cách tiếp cận từ trên xuống. Nó bắt đầu với tất cả các điểm là một cụm và chia nhỏ các cụm ít giống nhau nhất ở mỗi bước cho đến khi chỉ còn lại các điểm dữ liệu duy nhất

Các phương pháp này tạo ra một hệ thống phân cấp các điểm dựa trên cây được gọi là dendrogram. Tương tự như phân cụm theo phân vùng, trong phân cụm theo thứ bậc, số lượng cụm (k) thường được người dùng xác định trước. Các cụm được chỉ định bằng cách cắt dendrogram ở độ sâu xác định dẫn đến k nhóm dendrogram nhỏ hơn

Không giống như nhiều kỹ thuật phân cụm theo phân vùng, phân cụm theo cấp bậc là một quy trình xác định, nghĩa là việc gán cụm sẽ không thay đổi khi bạn chạy một thuật toán hai lần trên cùng một dữ liệu đầu vào

Điểm mạnh của các phương pháp phân cụm theo cấp bậc bao gồm:

• Chúng thường tiết lộ các chi tiết tốt hơn về mối quan hệ giữa các đối tượng dữ liệu
• Họ cung cấp một chương trình dendro có thể hiểu được

Những điểm yếu của phương pháp phân cụm theo thứ bậc bao gồm:

• Chúng đắt tiền về mặt tính toán đối với độ phức tạp của thuật toán
• Họ nhạy cảm với tiếng ồn và ngoại lệ

Phân cụm dựa trên mật độ

Phân cụm dựa trên mật độ xác định phân bổ cụm dựa trên mật độ của các điểm dữ liệu trong một vùng. Các cụm được chỉ định ở nơi có mật độ điểm dữ liệu cao được phân tách bằng các vùng có mật độ thấp

Không giống như các danh mục phân cụm khác, phương pháp này không yêu cầu người dùng chỉ định số lượng cụm. Thay vào đó, có một tham số dựa trên khoảng cách hoạt động như một ngưỡng có thể điều chỉnh. Ngưỡng này xác định mức độ gần các điểm phải được coi là thành viên cụm

Ví dụ về các thuật toán phân cụm dựa trên mật độ bao gồm Phân cụm ứng dụng không gian dựa trên mật độ có nhiễu hoặc DBSCAN và Sắp xếp các điểm để xác định cấu trúc phân cụm hoặc

Điểm mạnh của các phương pháp phân cụm dựa trên mật độ bao gồm:

• Họ xuất sắc trong việc xác định các cụm hình dạng không hình cầu
• Họ có khả năng chống lại các ngoại lệ

Điểm yếu của các phương pháp phân cụm dựa trên mật độ bao gồm:

• Chúng không phù hợp để phân cụm trong không gian nhiều chiều
• Họ gặp khó khăn trong việc xác định các cụm có mật độ khác nhau

Hiểu thuật toán K-Means

Phương tiện k thông thường chỉ cần một vài bước. Bước đầu tiên là chọn ngẫu nhiên k trọng tâm, trong đó k bằng số cụm bạn chọn. Centroid là các điểm dữ liệu đại diện cho trung tâm của một cụm

Yếu tố chính của thuật toán hoạt động theo quy trình gồm hai bước được gọi là tối đa hóa kỳ vọng. Bước kỳ vọng gán từng điểm dữ liệu cho trọng tâm gần nhất của nó. Sau đó, bước tối đa hóa tính toán giá trị trung bình của tất cả các điểm cho từng cụm và đặt trọng tâm mới. Đây là phiên bản thông thường của thuật toán k-means trông như thế nào

Chất lượng của các phép gán cụm được xác định bằng cách tính tổng sai số bình phương (SSE) sau khi các trọng tâm hội tụ hoặc khớp với phép gán của lần lặp trước đó. SSE được định nghĩa là tổng các khoảng cách Euclide bình phương của mỗi điểm đến trọng tâm gần nhất của nó. Vì đây là thước đo lỗi nên mục tiêu của k-means là cố gắng giảm thiểu giá trị này

Hình dưới đây cho thấy các trọng tâm và SSE cập nhật qua năm lần lặp đầu tiên từ hai lần chạy khác nhau của thuật toán k-means trên cùng một tập dữ liệu

Mục đích của hình này là để chỉ ra rằng việc khởi tạo các trọng tâm là một bước quan trọng. Nó cũng nêu bật việc sử dụng SSE làm thước đo hiệu suất phân cụm. Sau khi chọn một số cụm và trọng tâm ban đầu, bước tối đa hóa kỳ vọng được lặp lại cho đến khi các vị trí trọng tâm đạt đến sự hội tụ và không thay đổi

Bước khởi tạo ngẫu nhiên làm cho thuật toán k-mean trở nên không xác định, nghĩa là các phép gán cụm sẽ thay đổi nếu bạn chạy cùng một thuật toán hai lần trên cùng một tập dữ liệu. Các nhà nghiên cứu thường chạy một số lần khởi tạo toàn bộ thuật toán k-means và chọn các phép gán cụm từ lần khởi tạo với SSE thấp nhất

Viết mã phân cụm K-Means đầu tiên của bạn bằng Python

Rất may, có một triển khai mạnh mẽ về phân cụm k-mean trong Python từ gói học máy phổ biến scikit-learn. Bạn sẽ học cách viết triển khai thực tế của thuật toán k-means bằng cách sử dụng

Ghi chú. Nếu bạn muốn hiểu sâu hơn về cách viết thuật toán k-means của riêng mình bằng Python, thì hãy xem Sổ tay khoa học dữ liệu Python

Mã trong hướng dẫn này yêu cầu một số gói Python bên ngoài phổ biến và giả định rằng bạn đã cài đặt Python với Anaconda. Để biết thêm thông tin về cách thiết lập môi trường Python cho máy học trong Windows, hãy đọc qua Thiết lập Python cho máy học trên Windows

Nếu không, bạn có thể bắt đầu bằng cách cài đặt các gói cần thiết

(base) $ conda install matplotlib numpy pandas seaborn scikit-learn ipython
(base) $ conda install -c conda-forge kneed

Mã này được trình bày để bạn có thể theo dõi trong bảng điều khiển

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Tải xuống mã mẫu. Nhấp vào đây để lấy mã bạn sẽ sử dụng để tìm hiểu cách viết đường dẫn phân cụm k-means trong hướng dẫn này

Bước này sẽ nhập các mô-đun cần thiết cho tất cả mã trong phần này

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Bạn có thể tạo dữ liệu từ GIF ở trên bằng cách sử dụng

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

• In [5]: scaler = StandardScaler()
     ...: scaled_features = scaler.fit_transform(features)
  

  1 là tổng số mẫu cần tạo

• In [5]: scaler = StandardScaler()
     ...: scaled_features = scaler.fit_transform(features)
  

  2 là số lượng trung tâm để tạo ra

• In [5]: scaler = StandardScaler()
     ...: scaled_features = scaler.fit_transform(features)
  

  3 là độ lệch chuẩn

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

1. Một mảng NumPy hai chiều với các giá trị x và y cho mỗi mẫu
2. Mảng NumPy một chiều chứa các nhãn cụm cho từng mẫu

Ghi chú. Nhiều thuật toán scikit-learning phụ thuộc rất nhiều vào NumPy trong quá trình triển khai của chúng. Nếu bạn muốn tìm hiểu thêm về mảng NumPy, hãy xem Look Ma, No For-Loops. Lập trình mảng với NumPy

Tạo dữ liệu tổng hợp và nhãn

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Các thuật toán học máy không xác định như phương tiện k rất khó tái tạo. Tham số

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

Dưới đây là năm yếu tố đầu tiên cho mỗi biến được trả về bởi

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Tập dữ liệu thường chứa các đặc điểm số đã được đo bằng các đơn vị khác nhau, chẳng hạn như chiều cao (tính bằng inch) và cân nặng (tính bằng pound). Một thuật toán máy học sẽ coi cân nặng quan trọng hơn chiều cao chỉ vì các giá trị của cân nặng lớn hơn và có độ biến thiên cao hơn từ người này sang người khác

Các thuật toán học máy cần xem xét tất cả các tính năng trên một sân chơi bình đẳng. Điều đó có nghĩa là các giá trị cho tất cả các tính năng phải được chuyển đổi thành cùng một tỷ lệ

Quá trình chuyển đổi các tính năng số để sử dụng cùng một tỷ lệ được gọi là tỷ lệ tính năng. Đây là bước tiền xử lý dữ liệu quan trọng đối với hầu hết các thuật toán học máy dựa trên khoảng cách vì nó có thể tác động đáng kể đến hiệu suất thuật toán của bạn

Có một số cách tiếp cận để thực hiện nhân rộng tính năng. Một cách tuyệt vời để xác định kỹ thuật nào phù hợp với tập dữ liệu của bạn là đọc tài liệu tiền xử lý của scikit-learn

Trong ví dụ này, bạn sẽ sử dụng lớp

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

>>>

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

Hãy xem cách các giá trị đã được chia tỷ lệ trong

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

Bây giờ dữ liệu đã sẵn sàng để được phân cụm. Lớp công cụ ước tính

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

Dưới đây là các tham số được sử dụng trong ví dụ này

• In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  2 kiểm soát kỹ thuật khởi tạo. Phiên bản tiêu chuẩn của thuật toán k-means được triển khai bằng cách đặt

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  2 thành

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  4. Đặt giá trị này thành

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  5 sẽ sử dụng một thủ thuật nâng cao để tăng tốc độ hội tụ mà bạn sẽ sử dụng sau này

• In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  6 đặt k cho bước phân cụm. Đây là thông số quan trọng nhất cho k-means

• In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  7 đặt số lần khởi tạo để thực hiện. Điều này rất quan trọng vì hai lần chạy có thể hội tụ trên các nhiệm vụ cụm khác nhau. Hành vi mặc định cho thuật toán scikit-learning là thực hiện mười lần chạy k-mean và trả về kết quả của lần chạy có SSE thấp nhất

• In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  8 đặt số lần lặp lại tối đa cho mỗi lần khởi tạo thuật toán k-mean

Khởi tạo lớp

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

Tên tham số khớp với ngôn ngữ được sử dụng để mô tả thuật toán k-means trước đó trong hướng dẫn. Bây giờ lớp k-mean đã sẵn sàng, bước tiếp theo là khớp nó với dữ liệu trong

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Số liệu thống kê từ lần chạy khởi tạo với SSE thấp nhất có sẵn dưới dạng thuộc tính của

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

>>>

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

Cuối cùng, các phép gán cụm được lưu trữ dưới dạng mảng NumPy một chiều trong

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

>>>

In [12]: kmeans.labels_[:5]
Out[12]: array([0, 1, 2, 2, 2], dtype=int32)

Lưu ý rằng thứ tự của nhãn cụm cho hai đối tượng dữ liệu đầu tiên đã bị đảo lộn. Thứ tự là

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

Hành vi này là bình thường vì thứ tự của nhãn cụm phụ thuộc vào quá trình khởi tạo. Cụm 0 từ lần chạy đầu tiên có thể được gắn nhãn cụm 1 trong lần chạy thứ hai và ngược lại. Điều này không ảnh hưởng đến các chỉ số đánh giá phân cụm

Chọn số cụm thích hợp

Trong phần này, bạn sẽ xem xét hai phương pháp thường được sử dụng để đánh giá số cụm phù hợp

1. phương pháp khuỷu tay
2. hệ số bóng

Chúng thường được sử dụng như các kỹ thuật đánh giá bổ sung hơn là một kỹ thuật được ưu tiên hơn kỹ thuật kia. Để thực hiện phương pháp khuỷu tay, hãy chạy một số phương tiện k, tăng __32_______0 với mỗi lần lặp và ghi lại SSE

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Khối mã trước đã sử dụng toán tử giải nén từ điển của Python (

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Khi bạn vẽ biểu đồ SSE dưới dạng hàm số lượng cụm, hãy lưu ý rằng SSE tiếp tục giảm khi bạn tăng

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Có một điểm hấp dẫn nơi đường cong SSE bắt đầu uốn cong được gọi là điểm khuỷu tay. Giá trị x của điểm này được cho là sự đánh đổi hợp lý giữa lỗi và số lượng cụm. Trong ví dụ này, khuỷu tay nằm ở vị trí

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Đoạn mã trên tạo ra cốt truyện sau

Xác định điểm khuỷu tay trong đường cong SSE không phải lúc nào cũng đơn giản. Nếu bạn gặp khó khăn khi chọn điểm khuỷu tay của đường cong, thì bạn có thể sử dụng gói Python, kneed, để xác định điểm khuỷu tay theo chương trình

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Hệ số hình bóng là thước đo sự gắn kết và phân tách cụm. Nó định lượng mức độ phù hợp của một điểm dữ liệu với cụm được chỉ định của nó dựa trên hai yếu tố

1. Mức độ gần của điểm dữ liệu với các điểm khác trong cụm
2. Điểm dữ liệu cách các điểm trong các cụm khác bao xa

Giá trị hệ số hình bóng nằm trong khoảng từ

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Trong triển khai scikit-learning của hệ số hình bóng, hệ số hình bóng trung bình của tất cả các mẫu được tóm tắt thành một điểm. Hàm

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Lặp lại các giá trị của

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Vẽ sơ đồ điểm bóng trung bình cho mỗi

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Đoạn mã trên tạo ra cốt truyện sau

Cuối cùng, quyết định của bạn về số lượng cụm sẽ sử dụng phải được hướng dẫn bởi sự kết hợp giữa kiến ​​thức miền và chỉ số đánh giá cụm

Đánh giá hiệu suất phân cụm bằng các kỹ thuật nâng cao

Phương pháp khuỷu tay và hệ số hình bóng đánh giá hiệu suất phân cụm mà không cần sử dụng nhãn sự thật cơ bản. Nhãn sự thật cơ bản phân loại các điểm dữ liệu thành các nhóm dựa trên sự phân công của con người hoặc thuật toán hiện có. Các loại số liệu này cố gắng hết sức để đề xuất số lượng cụm chính xác nhưng có thể gây hiểu nhầm khi sử dụng mà không có ngữ cảnh

Ghi chú. Trong thực tế, rất hiếm khi gặp các bộ dữ liệu có nhãn sự thật cơ bản

Khi so sánh phương tiện k với cách tiếp cận dựa trên mật độ trên các cụm không hình cầu, kết quả từ phương pháp khuỷu tay và hệ số bóng hiếm khi phù hợp với trực giác của con người. Kịch bản này nêu bật lý do tại sao các kỹ thuật đánh giá phân cụm nâng cao là cần thiết. Để trực quan hóa một ví dụ, hãy nhập các mô-đun bổ sung này

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Lần này, hãy sử dụng

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Khớp cả thuật toán k-means và DBSCAN với dữ liệu mới và đánh giá hiệu suất một cách trực quan bằng cách vẽ đồ thị các phép gán cụm với Matplotlib

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In hệ số hình bóng cho mỗi trong hai thuật toán và so sánh chúng. Hệ số hình bóng cao hơn cho thấy các cụm tốt hơn, điều này gây hiểu lầm trong trường hợp này

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Hệ số hình bóng cao hơn đối với thuật toán k-mean. Thuật toán DBSCAN dường như tìm thấy nhiều cụm tự nhiên hơn theo hình dạng của dữ liệu

Điều này gợi ý rằng bạn cần một phương pháp tốt hơn để so sánh hiệu suất của hai thuật toán phân cụm này

Nếu bạn quan tâm, bạn có thể tìm mã cho cốt truyện trên bằng cách mở rộng hộp bên dưới

Lưỡi liềm biểu đồHiển thị/Ẩn

Để tìm hiểu thêm về vẽ đồ thị bằng Matplotlib và Python, hãy xem Vẽ đồ thị bằng Python với Matplotlib (Hướng dẫn). Đây là cách bạn có thể vẽ biểu đồ so sánh hai thuật toán trong ví dụ về trăng lưỡi liềm

>>>

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Vì các nhãn sự thật cơ bản đã được biết, nên có thể sử dụng chỉ số phân cụm để xem xét các nhãn trong đánh giá của nó. Bạn có thể sử dụng chỉ số chung được gọi là chỉ số rand được điều chỉnh (ARI). Không giống như hệ số hình bóng, ARI sử dụng phép gán cụm thực để đo lường sự giống nhau giữa nhãn thực và nhãn dự đoán

So sánh kết quả phân cụm của DBSCAN và k-means sử dụng ARI làm chỉ số hiệu suất

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Các giá trị đầu ra ARI nằm trong khoảng từ

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [8]: kmeans.fit(scaled_features)
Out[8]:
KMeans(init='random', n_clusters=3, random_state=42)

Dựa trên đầu ra ở trên, bạn có thể thấy rằng hệ số hình bóng bị sai lệch. ARI cho thấy DBSCAN là lựa chọn tốt nhất cho ví dụ về lưỡi liềm tổng hợp so với phương tiện k

Có một số số liệu đánh giá chất lượng của các thuật toán phân cụm. Đọc qua sẽ giúp bạn chọn một số liệu đánh giá phân cụm thích hợp

Xây dựng đường ống phân cụm K-Means

Giả sử bạn muốn bắt đầu với một bản mới, hãy nhập tất cả các mô-đun cần thiết để xây dựng và đánh giá quy trình, bao gồm pandas và seaborn để có hình ảnh trực quan nâng cao hơn

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Tải xuống và trích xuất bộ dữ liệu TCGA từ UCI

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Sau khi quá trình tải xuống và giải nén hoàn tất, bạn sẽ có một thư mục giống như thế này

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Lớp

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Kiểm tra ba cột dữ liệu đầu tiên cho năm mẫu đầu tiên cũng như nhãn cho năm mẫu đầu tiên

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Biến

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [12]: kmeans.labels_[:5]
Out[12]: array([0, 1, 2, 2, 2], dtype=int32)

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

Các nhãn là các chuỗi chứa chữ viết tắt của các loại ung thư

• In [12]: kmeans.labels_[:5]
  Out[12]: array([0, 1, 2, 2, 2], dtype=int32)
  

  5. Ung thư biểu mô xâm lấn vú

• In [12]: kmeans.labels_[:5]
  Out[12]: array([0, 1, 2, 2, 2], dtype=int32)
  

  6. ung thư biểu mô tuyến đại tràng

• In [12]: kmeans.labels_[:5]
  Out[12]: array([0, 1, 2, 2, 2], dtype=int32)
  

  7. Ung thư biểu mô tế bào sáng thận thận

• In [12]: kmeans.labels_[:5]
  Out[12]: array([0, 1, 2, 2, 2], dtype=int32)
  

  8. ung thư biểu mô phổi

• In [12]: kmeans.labels_[:5]
  Out[12]: array([0, 1, 2, 2, 2], dtype=int32)
  

  9. ung thư tuyến tiền liệt

Để sử dụng các nhãn này trong các phương pháp đánh giá, trước tiên bạn cần chuyển đổi các chữ viết tắt thành số nguyên với

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Vì

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Trong các quy trình học máy thực tế, dữ liệu thường trải qua nhiều chuỗi biến đổi trước khi đưa vào thuật toán phân cụm. Bạn đã tìm hiểu về tầm quan trọng của một trong các bước chuyển đổi này, nhân rộng tính năng, trước đó trong hướng dẫn này. Một kỹ thuật chuyển đổi dữ liệu quan trọng không kém là giảm kích thước, giúp giảm số lượng các tính năng trong tập dữ liệu bằng cách loại bỏ hoặc kết hợp chúng

Các kỹ thuật giảm kích thước giúp giải quyết vấn đề với các thuật toán học máy được gọi là lời nguyền của kích thước. Nói tóm lại, khi số lượng tính năng tăng lên, không gian tính năng trở nên thưa thớt. Sự thưa thớt này khiến các thuật toán khó tìm các đối tượng dữ liệu gần nhau trong không gian nhiều chiều hơn. Vì tập dữ liệu biểu hiện gen có hơn _______3_______04 tính năng, nên nó đủ điều kiện là một ứng cử viên tuyệt vời cho việc giảm kích thước

Phân tích thành phần chính (PCA) là một trong nhiều kỹ thuật giảm kích thước. PCA biến đổi dữ liệu đầu vào bằng cách chiếu dữ liệu đó vào một số lượng kích thước thấp hơn được gọi là các thành phần. Các thành phần nắm bắt sự thay đổi của dữ liệu đầu vào thông qua sự kết hợp tuyến tính của các tính năng của dữ liệu đầu vào

Ghi chú. Phần mô tả đầy đủ về PCA nằm ngoài phạm vi của hướng dẫn này, nhưng bạn có thể tìm hiểu thêm về nó trong phần

Khối mã tiếp theo giới thiệu cho bạn khái niệm về. Lớp scikit-learning

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Dữ liệu biểu hiện gen của bạn không ở định dạng tối ưu cho lớp

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

In [5]: scaler = StandardScaler()
   ...: scaled_features = scaler.fit_transform(features)

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Bước tiếp theo trong quy trình tiền xử lý của bạn sẽ triển khai lớp

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Bây giờ bạn đã xây dựng một quy trình để xử lý dữ liệu, bạn sẽ xây dựng một quy trình riêng để thực hiện phân cụm k-mean. Bạn sẽ ghi đè các đối số mặc định sau của lớp

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

• trong đó. Bạn sẽ sử dụng

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  5 thay vì

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  4 để đảm bảo rằng các trọng tâm được khởi tạo với khoảng cách giữa chúng. Trong hầu hết các trường hợp, đây sẽ là một cải tiến so với

  In [6]: scaled_features[:5]
  Out[6]:
  array([[ 2.13082109,  0.25604351],
         [-1.52698523,  1.41036744],
         [-1.00130152, -1.56583175],
         [-1.74256891, -1.76832509],
         [-1.29924521, -0.87253446]])
  

  4

• n_init. Bạn sẽ tăng số lần khởi tạo để đảm bảo tìm được giải pháp ổn định

• max_iter. Bạn sẽ tăng số lần lặp lại cho mỗi lần khởi tạo để đảm bảo rằng phương tiện k sẽ hội tụ

Xây dựng quy trình phân cụm k-mean với các đối số do người dùng xác định trong hàm tạo

In [6]: scaled_features[:5]
Out[6]:
array([[ 2.13082109,  0.25604351],
       [-1.52698523,  1.41036744],
       [-1.00130152, -1.56583175],
       [-1.74256891, -1.76832509],
       [-1.29924521, -0.87253446]])

>>>

In [2]: features, true_labels = make_blobs(
   ...:     n_samples=200,
   ...:     centers=3,
   ...:     cluster_std=2.75,
   ...:     random_state=42
   ...: )

Lớp

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Gọi

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

In [9]: # The lowest SSE value
   ...: kmeans.inertia_
Out[9]: 74.57960106819854

In [10]: # Final locations of the centroid
   ...: kmeans.cluster_centers_
Out[10]:
array([[ 1.19539276,  0.13158148],
       [-0.25813925,  1.05589975],
       [-0.91941183, -1.18551732]])

In [11]: # The number of iterations required to converge
   ...: kmeans.n_iter_
Out[11]: 6

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Đường ống thực hiện tất cả các bước cần thiết để thực hiện phân cụm k-means trên dữ liệu biểu hiện gen. Tùy thuộc vào REPL Python của bạn,

In [7]: kmeans = KMeans(
   ...:     init="random",
   ...:     n_clusters=3,
   ...:     n_init=10,
   ...:     max_iter=300,
   ...:     random_state=42
   ...: )

Đánh giá hiệu suất bằng cách tính toán hệ số hình bóng

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Tính cả ARI, vì có sẵn các nhãn cụm sự thật cơ bản

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Như đã đề cập trước đó, thang đo cho từng chỉ số hiệu suất phân cụm này nằm trong khoảng từ -1 đến 1. Hệ số hình bóng bằng 0 cho biết các cụm chồng chéo lên nhau đáng kể và hệ số hình bóng bằng 1 cho biết các cụm được phân tách rõ ràng. Điểm ARI bằng 0 cho biết nhãn cụm được chỉ định ngẫu nhiên và điểm ARI bằng 1 nghĩa là nhãn thực và nhãn dự đoán tạo thành cụm giống hệt nhau

Vì bạn đã chỉ định

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Đây là cốt truyện trông như thế nào

Biểu diễn trực quan của các cụm xác nhận kết quả của hai chỉ số đánh giá phân cụm. Hiệu suất đường ống dẫn của bạn khá tốt. Các cụm chỉ chồng chéo một chút và việc gán cụm tốt hơn nhiều so với ngẫu nhiên

Điều chỉnh đường ống phân cụm K-Means

Quy trình phân cụm k-mean đầu tiên của bạn hoạt động tốt nhưng vẫn còn chỗ cần cải thiện. Đó là lý do tại sao bạn gặp khó khăn khi xây dựng đường ống dẫn. bạn có thể điều chỉnh các tham số để có được kết quả phân cụm mong muốn nhất

Quá trình điều chỉnh tham số bao gồm thay đổi tuần tự một trong các giá trị đầu vào của tham số thuật toán và ghi lại kết quả. Khi kết thúc quá trình điều chỉnh thông số, bạn sẽ có một tập hợp các điểm hiệu suất, một điểm cho mỗi giá trị mới của một thông số nhất định. Điều chỉnh tham số là một phương pháp mạnh mẽ để tối đa hóa hiệu suất từ ​​quy trình phân cụm của bạn

Bằng cách đặt tham số

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Phương sai được giải thích đo lường sự khác biệt giữa dữ liệu được chuyển đổi PCA và dữ liệu đầu vào thực tế. Có thể trực quan hóa trong một biểu đồ để cho bạn biết bạn cần bao nhiêu thành phần trong PCA của mình để nắm bắt một tỷ lệ phần trăm nhất định của phương sai trong dữ liệu đầu vào. Bạn cũng có thể sử dụng các chỉ số hiệu suất phân cụm để đánh giá số lượng thành phần cần thiết để đạt được kết quả phân cụm thỏa đáng

Trong ví dụ này, bạn sẽ sử dụng chỉ số hiệu suất phân cụm để xác định số lượng thành phần thích hợp trong bước PCA. Lớp

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Lặp lại trên một phạm vi

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Vẽ biểu đồ các số liệu đánh giá dưới dạng hàm của

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

>>>

In [3]: features[:5]
Out[3]:
array([[  9.77075874,   3.27621022],
       [ -9.71349666,  11.27451802],
       [ -6.91330582,  -9.34755911],
       [-10.86185913, -10.75063497],
       [ -8.50038027,  -4.54370383]])

In [4]: true_labels[:5]
Out[4]: array([1, 0, 2, 2, 2])

Đoạn mã trên tạo biểu đồ hiển thị số liệu hiệu suất dưới dạng hàm của

In [1]: import matplotlib.pyplot as plt
   ...: from kneed import KneeLocator
   ...: from sklearn.datasets import make_blobs
   ...: from sklearn.cluster import KMeans
   ...: from sklearn.metrics import silhouette_score
   ...: from sklearn.preprocessing import StandardScaler

Có hai điểm rút ra từ con số này

1. Hệ số hình bóng giảm tuyến tính. Hệ số hình bóng phụ thuộc vào khoảng cách giữa các điểm, do đó khi số lượng kích thước tăng lên, độ thưa tăng lên

2. ARI cải thiện đáng kể khi bạn thêm các thành phần. Nó dường như bắt đầu giảm dần sau

   In [1]: import matplotlib.pyplot as plt
      ...: from kneed import KneeLocator
      ...: from sklearn.datasets import make_blobs
      ...: from sklearn.cluster import KMeans
      ...: from sklearn.metrics import silhouette_score
      ...: from sklearn.preprocessing import StandardScaler
   

   33, vì vậy đó sẽ là giá trị được sử dụng để trình bày các kết quả phân cụm tốt nhất từ ​​quy trình này

Giống như hầu hết các quyết định học máy, bạn phải cân bằng việc tối ưu hóa các chỉ số đánh giá phân cụm với mục tiêu của nhiệm vụ phân cụm. Trong các trường hợp có nhãn cụm, như trường hợp của bộ dữ liệu ung thư được sử dụng trong hướng dẫn này, ARI là một lựa chọn hợp lý. ARI định lượng mức độ chính xác mà quy trình của bạn có thể gán lại các nhãn cụm

Mặt khác, hệ số hình bóng là một lựa chọn tốt cho phân cụm khám phá vì nó giúp xác định các phân cụm con. Các nhóm con này đảm bảo điều tra bổ sung, có thể dẫn đến những hiểu biết mới và quan trọng