AI với Python - Học không giám sát: Phân cụm

Các thuật toán học máy không được giám sát không có bất kỳ người giám sát nào để cung cấp bất kỳ loại hướng dẫn nào. Đó là lý do tại sao chúng liên kết chặt chẽ với cái mà một số người gọi là trí tuệ nhân tạo thực sự.

Trong học tập không có giám sát, sẽ không có câu trả lời chính xác và không có giáo viên hướng dẫn. Các thuật toán cần khám phá mô hình thú vị trong dữ liệu để học.

Phân cụm là gì?

Về cơ bản, nó là một loại phương pháp học tập không giám sát và một kỹ thuật phổ biến để phân tích dữ liệu thống kê được sử dụng trong nhiều lĩnh vực. Phân cụm chủ yếu là nhiệm vụ chia tập hợp các quan sát thành các tập con, được gọi là các cụm, theo cách sao cho các quan sát trong cùng một cụm giống nhau theo một nghĩa và chúng khác với các quan sát trong các cụm khác. Nói một cách dễ hiểu, chúng ta có thể nói rằng mục tiêu chính của phân cụm là nhóm dữ liệu trên cơ sở tương đồng và khác biệt.

Ví dụ: sơ đồ sau đây cho thấy loại dữ liệu tương tự trong các cụm khác nhau:

Các thuật toán để phân cụm dữ liệu

Sau đây là một số thuật toán phổ biến để phân nhóm dữ liệu:

Thuật toán K-Means

Thuật toán phân cụm K-mean là một trong những thuật toán nổi tiếng để phân nhóm dữ liệu. Chúng ta cần giả định rằng số lượng các cụm đã được biết trước. Đây còn được gọi là phân cụm phẳng. Nó là một thuật toán phân cụm lặp đi lặp lại. Các bước đưa ra bên dưới cần được thực hiện cho thuật toán này -

Step 1 - Ta cần xác định số lượng K nhóm con mong muốn.

Step 2- Cố định số lượng các cụm và gán ngẫu nhiên mỗi điểm dữ liệu vào một cụm. Hay nói cách khác, chúng ta cần phân loại dữ liệu của mình dựa trên số lượng các cụm.

Trong bước này, các trọng tâm cụm sẽ được tính toán.

Vì đây là một thuật toán lặp lại, chúng ta cần cập nhật vị trí của K centroid với mỗi lần lặp lại cho đến khi chúng ta tìm thấy optima toàn cục hay nói cách khác là các centroid đạt đến vị trí tối ưu của chúng.

Đoạn mã sau sẽ giúp thực hiện thuật toán phân cụm K-mean trong Python. Chúng tôi sẽ sử dụng mô-đun Scikit-learning.

Hãy để chúng tôi nhập các gói cần thiết -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Dòng mã sau sẽ giúp tạo tập dữ liệu hai chiều, chứa bốn đốm màu, bằng cách sử dụng make_blob từ sklearn.dataset gói hàng.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,
            cluster_std = 0.40, random_state = 0)

Chúng ta có thể hình dung tập dữ liệu bằng cách sử dụng đoạn mã sau:

plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()

Ở đây, chúng tôi đang khởi tạo kmeans thành thuật toán KMeans, với tham số bắt buộc là bao nhiêu cụm (n_clusters).

kmeans = KMeans(n_clusters = 4)

Chúng ta cần đào tạo mô hình K-means với dữ liệu đầu vào.

kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')

centers = kmeans.cluster_centers_

Đoạn mã được đưa ra dưới đây sẽ giúp chúng tôi vẽ biểu đồ và hình dung các phát hiện của máy dựa trên dữ liệu của chúng tôi và cách lắp ráp theo số lượng cụm sẽ được tìm thấy.

plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()

Thuật toán dịch chuyển trung bình

Nó là một thuật toán phân cụm phổ biến và mạnh mẽ khác được sử dụng trong học tập không giám sát. Nó không đưa ra bất kỳ giả định nào do đó nó là một thuật toán phi tham số. Nó còn được gọi là phân cụm phân cấp hoặc phân tích cụm dịch chuyển trung bình. Các bước tiếp theo sẽ là các bước cơ bản của thuật toán này -

• Trước hết, chúng ta cần bắt đầu với các điểm dữ liệu được gán cho một cụm riêng của chúng.

• Bây giờ, nó tính toán các trung tâm và cập nhật vị trí của các trung tâm mới.

• Bằng cách lặp lại quá trình này, chúng tôi di chuyển đến gần đỉnh của cụm tức là về phía vùng có mật độ cao hơn.

• Thuật toán này dừng lại ở giai đoạn mà các centroid không di chuyển nữa.

Với sự trợ giúp của đoạn mã sau, chúng tôi đang triển khai thuật toán phân cụm Mean Shift trong Python. Chúng tôi sẽ sử dụng mô-đun Scikit-learning.

Hãy để chúng tôi nhập các gói cần thiết -

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

Đoạn mã sau sẽ giúp tạo tập dữ liệu hai chiều, chứa bốn đốm màu, bằng cách sử dụng make_blob từ sklearn.dataset gói hàng.

from sklearn.datasets.samples_generator import make_blobs

Chúng ta có thể hình dung tập dữ liệu bằng đoạn mã sau

centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

Bây giờ, chúng ta cần đào tạo mô hình cụm Mean Shift với dữ liệu đầu vào.

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

Đoạn mã sau sẽ in các trung tâm cụm và số lượng cụm dự kiến ​​theo dữ liệu đầu vào:

print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

Đoạn mã được đưa ra dưới đây sẽ giúp vẽ biểu đồ và trực quan hóa các phát hiện của máy dựa trên dữ liệu của chúng tôi, và trang bị theo số lượng cụm sẽ được tìm thấy.

colors = 10*['r.','g.','b.','c.','k.','y.','m.']
   for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
   marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()

Đo lường hiệu suất phân cụm

Dữ liệu thế giới thực không tự nhiên được tổ chức thành một số cụm riêng biệt. Do đó, không dễ hình dung và rút ra suy luận. Đó là lý do tại sao chúng ta cần đo hiệu suất phân cụm cũng như chất lượng của nó. Nó có thể được thực hiện với sự trợ giúp của phân tích hình bóng.

Phân tích Silhouette

Phương pháp này có thể được sử dụng để kiểm tra chất lượng phân cụm bằng cách đo khoảng cách giữa các cụm. Về cơ bản, nó cung cấp một cách để đánh giá các thông số như số lượng cụm bằng cách cho điểm hình bóng. Điểm số này là một số liệu đo lường mức độ gần của mỗi điểm trong một cụm với các điểm trong các cụm lân cận.

Phân tích điểm bóng

Điểm số có phạm vi là [-1, 1]. Sau đây là phân tích về điểm số này -

• Score of +1 - Điểm gần +1 cho biết mẫu ở xa cụm lân cận.

• Score of 0 - Điểm 0 cho biết mẫu nằm trên hoặc rất gần ranh giới quyết định giữa hai cụm lân cận.

• Score of -1 - Điểm âm chỉ ra rằng các mẫu đã được chỉ định vào các cụm sai.

Tính điểm Silhouette

Trong phần này, chúng ta sẽ học cách tính điểm hình bóng.

Điểm Silhouette có thể được tính bằng cách sử dụng công thức sau:

$$ bóng điểm = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$

Đây là khoảng cách trung bình đến các điểm trong cụm gần nhất mà điểm dữ liệu không phải là một phần của nó. Và, là khoảng cách trung bình trong cụm đến tất cả các điểm trong cụm của chính nó.

Để tìm số lượng cụm tối ưu, chúng ta cần chạy lại thuật toán phân nhóm bằng cách nhập metrics mô-đun từ sklearngói hàng. Trong ví dụ sau, chúng tôi sẽ chạy thuật toán phân cụm K-mean để tìm số lượng cụm tối ưu -

Nhập các gói cần thiết như được hiển thị -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Với sự trợ giúp của đoạn mã sau, chúng tôi sẽ tạo tập dữ liệu hai chiều, chứa bốn đốm màu, bằng cách sử dụng make_blob từ sklearn.dataset gói hàng.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)

Khởi tạo các biến như hình:

scores = []
values = np.arange(2, 10)

Chúng ta cần lặp lại mô hình K-mean qua tất cả các giá trị và cũng cần huấn luyện nó với dữ liệu đầu vào.

for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)

Bây giờ, hãy ước tính điểm hình bóng cho mô hình phân cụm hiện tại bằng cách sử dụng số liệu khoảng cách Euclide -

score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))

Dòng mã sau đây sẽ giúp hiển thị số lượng các cụm cũng như điểm số Silhouette.

print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)

Bạn sẽ nhận được kết quả sau:

Number of clusters = 9
Silhouette score = 0.340391138371

num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)

Bây giờ, đầu ra cho số lượng cụm tối ưu sẽ như sau:

Optimal number of clusters = 2

Tìm những người hàng xóm gần nhất

Nếu chúng ta muốn xây dựng hệ thống giới thiệu chẳng hạn như hệ thống giới thiệu phim thì chúng ta cần hiểu khái niệm tìm kiếm những người hàng xóm gần nhất. Đó là bởi vì hệ thống khuyến nghị sử dụng khái niệm về những người hàng xóm gần nhất.

Các concept of finding nearest neighborscó thể được định nghĩa là quá trình tìm kiếm điểm gần nhất với điểm đầu vào từ tập dữ liệu đã cho. Công dụng chính của thuật toán KNN) K-láng giềng gần nhất này là xây dựng các hệ thống phân loại phân loại một điểm dữ liệu về mức độ lân cận của điểm dữ liệu đầu vào với các lớp khác nhau.

Mã Python đưa ra dưới đây giúp tìm K-lân cận gần nhất của một tập dữ liệu nhất định -

Nhập các gói cần thiết như hình dưới đây. Ở đây, chúng tôi đang sử dụngNearestNeighbors mô-đun từ sklearn gói hàng

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors

Bây giờ chúng ta hãy xác định dữ liệu đầu vào -

A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9], 
             [8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])

Bây giờ, chúng ta cần xác định các láng giềng gần nhất -

k = 3

Chúng tôi cũng cần cung cấp dữ liệu thử nghiệm mà từ đó tìm thấy những người hàng xóm gần nhất -

test_data = [3.3, 2.9]

Đoạn mã sau có thể trực quan hóa và vẽ biểu đồ dữ liệu đầu vào do chúng tôi xác định:

plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')

Bây giờ, chúng ta cần xây dựng K Nearest Neighbor. Đối tượng cũng cần được đào tạo

knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])

Bây giờ, chúng ta có thể in K láng giềng gần nhất như sau

print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
   print(str(rank) + " is", A[index])

Chúng ta có thể hình dung các hàng xóm gần nhất cùng với điểm dữ liệu thử nghiệm

plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
   marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
   marker = 'x', s = 100, color = 'k')
plt.show()

Đầu ra

K Nearest Neighbors

1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]

K-Bộ phân loại hàng xóm gần nhất

Bộ phân loại K-Nearest Neighbors (KNN) là một mô hình phân loại sử dụng thuật toán láng giềng gần nhất để phân loại một điểm dữ liệu nhất định. Chúng ta đã thực hiện thuật toán KNN trong phần trước, bây giờ chúng ta sẽ xây dựng bộ phân loại KNN bằng thuật toán đó.

Khái niệm về KNN Classifier

Khái niệm cơ bản của phân loại láng giềng gần nhất K là tìm một số được xác định trước, tức là, 'k' - của các mẫu huấn luyện gần nhất trong khoảng cách với một mẫu mới, mà mẫu này phải được phân loại. Các mẫu mới sẽ được dán nhãn từ chính những người hàng xóm. Các bộ phân loại KNN có một hằng số do người dùng xác định cố định cho số lượng hàng xóm phải được xác định. Đối với khoảng cách, khoảng cách Euclid tiêu chuẩn là lựa chọn phổ biến nhất. KNN Classifier hoạt động trực tiếp trên các mẫu đã học thay vì tạo ra các quy tắc để học. Thuật toán KNN là một trong những thuật toán đơn giản nhất trong tất cả các thuật toán học máy. Nó đã khá thành công trong một số lượng lớn các bài toán phân loại và hồi quy, ví dụ, nhận dạng ký tự hoặc phân tích hình ảnh.

Example

Chúng tôi đang xây dựng bộ phân loại KNN để nhận dạng các chữ số. Đối với điều này, chúng tôi sẽ sử dụng tập dữ liệu MNIST. Chúng tôi sẽ viết mã này trong Máy tính xách tay Jupyter.

Nhập các gói cần thiết như hình dưới đây.

Ở đây chúng tôi đang sử dụng KNeighborsClassifier mô-đun từ sklearn.neighbors gói -

from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np

Đoạn mã sau sẽ hiển thị hình ảnh của chữ số để xác minh hình ảnh mà chúng tôi phải kiểm tra -

def Image_display(i):
   plt.imshow(digit['images'][i],cmap = 'Greys_r')
   plt.show()

Bây giờ, chúng ta cần tải tập dữ liệu MNIST. Trên thực tế có tổng cộng 1797 hình ảnh nhưng chúng tôi đang sử dụng 1600 hình ảnh đầu tiên làm mẫu đào tạo và 197 hình ảnh còn lại sẽ được giữ cho mục đích thử nghiệm.

digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])

Bây giờ, khi hiển thị hình ảnh, chúng ta có thể thấy kết quả như sau:

Image_display(0)

Image_display (0)

Hình ảnh của 0 được hiển thị như sau:

Image_display (9)

Hình ảnh của 9 được hiển thị như sau:

digit.keys ()

Bây giờ, chúng ta cần tạo tập dữ liệu đào tạo và thử nghiệm và cung cấp tập dữ liệu thử nghiệm cho các bộ phân loại KNN.

train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)

Đầu ra sau đây sẽ tạo ra K phương thức khởi tạo bộ phân loại láng giềng gần nhất:

KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
   weights = 'uniform')

Chúng ta cần tạo mẫu thử nghiệm bằng cách cung cấp bất kỳ số tùy ý nào lớn hơn 1600, là các mẫu huấn luyện.

test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)

Image_display (6)

Hình ảnh của 6 được hiển thị như sau:

Bây giờ chúng ta sẽ dự đoán dữ liệu thử nghiệm như sau:

KNN.predict(test1)

Đoạn mã trên sẽ tạo ra kết quả sau:

array([6])

Bây giờ, hãy xem xét những điều sau:

digit['target_names']

Đoạn mã trên sẽ tạo ra kết quả sau:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])