Hướng dẫn gaussian mixture model opencv python - mô hình hỗn hợp gaussian opencv python

Mô hình phân cụm K-Means được khám phá trong phần trước rất đơn giản và tương đối dễ hiểu, nhưng tính đơn giản của nó dẫn đến những thách thức thực tế trong ứng dụng của nó. Cụ thể, bản chất không xác định của K-MEAN và việc sử dụng trung tâm từ xa từ cụm từ xa đơn giản để gán thành viên cụm dẫn đến hiệu suất kém cho nhiều tình huống trong thế giới thực. Trong phần này, chúng tôi sẽ xem xét các mô hình hỗn hợp Gaussian (GMM), có thể được xem như là một phần mở rộng của các ý tưởng đằng sau K-MEAN, nhưng cũng có thể là một công cụ mạnh mẽ để ước tính vượt quá phân cụm đơn giản.

Chúng tôi bắt đầu với nhập khẩu tiêu chuẩn:

In [1]:

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np

Động lực GMM: Điểm yếu của K-Means¶

Chúng ta hãy xem một số điểm yếu của K-MEAN và suy nghĩ về cách chúng ta có thể cải thiện mô hình cụm. Như chúng ta đã thấy trong phần trước, được cung cấp dữ liệu đơn giản, được phân tách tốt, K-MEANS tìm thấy kết quả phân cụm phù hợp.

Ví dụ: nếu chúng ta có những đốm dữ liệu đơn giản, thuật toán K-MEAN có thể nhanh chóng gắn nhãn các cụm đó theo cách phù hợp với những gì chúng ta có thể làm bằng mắt:

In [2]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

In [3]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Từ quan điểm trực quan, chúng ta có thể hy vọng rằng việc gán phân cụm cho một số điểm chắc chắn hơn những điểm khác: ví dụ, dường như có một sự chồng chéo rất nhỏ giữa hai cụm giữa, do đó chúng ta có thể không hoàn toàn tự tin trong việc điều chỉnh cụm của các điểm giữa họ. Thật không may, mô hình K-MEAN không có thước đo nội tại về xác suất hoặc độ không đảm bảo của các bài tập cụm (mặc dù có thể sử dụng phương pháp bootstrap để ước tính độ không đảm bảo này). Đối với điều này, chúng ta phải suy nghĩ về việc khái quát hóa mô hình.

Một cách để suy nghĩ về mô hình K-Mean là nó đặt một vòng tròn (hoặc, theo kích thước cao hơn, một hình cầu siêu) ở trung tâm của mỗi cụm, với bán kính được xác định bởi điểm xa nhất trong cụm. Bán kính này hoạt động như một điểm cắt cứng cho gán cụm trong tập huấn luyện: bất kỳ điểm nào bên ngoài vòng tròn này không được coi là thành viên của cụm. Chúng ta có thể trực quan hóa mô hình cụm này với chức năng sau:

In [4]:

from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist

def plot_kmeans(kmeans, X, n_clusters=4, rseed=0, ax=None):
    labels = kmeans.fit_predict(X)

    # plot the input data
    ax = ax or plt.gca()
    ax.axis('equal')
    ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis', zorder=2)

    # plot the representation of the KMeans model
    centers = kmeans.cluster_centers_
    radii = [cdist(X[labels == i], [center]).max()
             for i, center in enumerate(centers)]
    for c, r in zip(centers, radii):
        ax.add_patch(plt.Circle(c, r, fc='#CCCCCC', lw=3, alpha=0.5, zorder=1))

In [5]:

kmeans = KMeans(n_clusters=4, random_state=0)
plot_kmeans(kmeans, X)

Một quan sát quan trọng đối với K-MEAN là các mô hình cụm này phải là hình tròn: K-Means không có cách tính toán tích hợp cho các cụm hình chữ hoặc hình elip. Vì vậy, ví dụ, nếu chúng ta lấy cùng một dữ liệu và biến đổi nó, các bài tập của cụm cuối cùng trở nên bị rối:

In [6]:

rng = np.random.RandomState(13)
X_stretched = np.dot(X, rng.randn(2, 2))

kmeans = KMeans(n_clusters=4, random_state=0)
plot_kmeans(kmeans, X_stretched)

Bằng mắt, chúng tôi nhận ra rằng các cụm biến đổi này là không mạch, và do đó các cụm tròn sẽ phù hợp. Tuy nhiên, K-Means không đủ linh hoạt để giải thích cho việc này và cố gắng buộc dữ liệu thành bốn cụm tròn. Điều này dẫn đến sự pha trộn của các bài tập cụm trong đó các vòng tròn kết quả chồng chéo: đặc biệt là xem đặc biệt là dưới cùng bên phải của cốt truyện này. Người ta có thể tưởng tượng giải quyết tình huống cụ thể này bằng cách tiền xử lý dữ liệu với PCA (xem theo chiều sâu: Phân tích thành phần chính), nhưng trong thực tế không có gì đảm bảo rằng hoạt động toàn cầu như vậy sẽ tròn dữ liệu riêng lẻ.

Hai nhược điểm này của K-MEANS, thiếu tính linh hoạt trong hình dạng cụm và thiếu sự gán cụm xác suất, có nghĩa là đối với nhiều bộ dữ liệu (đặc biệt là bộ dữ liệu chiều thấp) nó có thể không thực hiện cũng như bạn có thể hy vọng.

Bạn có thể tưởng tượng giải quyết các điểm yếu này bằng cách khái quát hóa mô hình K-MEANS: ví dụ, bạn có thể đo lường sự không chắc chắn trong gán cụm bằng cách so sánh khoảng cách của từng điểm với tất cả các trung tâm cụm, thay vì tập trung vào gần nhất. Bạn cũng có thể tưởng tượng cho phép các ranh giới cụm là hình elip hơn là các vòng tròn, để giải thích cho các cụm không tròn. Hóa ra đây là hai thành phần thiết yếu của một loại mô hình phân cụm khác nhau, các mô hình hỗn hợp Gaussian.

Tổng quát hóa ETHER M: Mô hình hỗn hợp Gaussian

Một mô hình hỗn hợp Gaussian (GMM) cố gắng tìm một hỗn hợp các phân phối xác suất Gaussian đa chiều mà mô hình hóa tốt nhất bất kỳ bộ dữ liệu đầu vào nào. Trong trường hợp đơn giản nhất, GMMS có thể được sử dụng để tìm các cụm theo cách tương tự như K-MEANS:

In [7]:

from sklearn.mixture import GMM
gmm = GMM(n_components=4).fit(X)
labels = gmm.predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Nhưng vì GMM chứa một mô hình xác suất dưới mui xe, nên cũng có thể tìm thấy các phân công cụm xác suất, trong Scikit-learn, điều này được thực hiện bằng phương pháp

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

In [8]:

probs = gmm.predict_proba(X)
print(probs[:5].round(3))

________số 8

Chúng ta có thể hình dung sự không chắc chắn này bằng cách, ví dụ, làm cho kích thước của từng điểm tỷ lệ thuận với sự chắc chắn của dự đoán của nó; Nhìn vào hình sau đây, chúng ta có thể thấy rằng chính xác là các điểm ở ranh giới giữa các cụm phản ánh sự không chắc chắn này của phân công cụm:

In [9]:

size = 50 * probs.max(1) ** 2  # square emphasizes differences
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=size);

Dưới mui xe, một mô hình hỗn hợp Gaussian rất giống với K-MEANS: nó sử dụng phương pháp tối đa hóa kỳ vọng mà thực hiện một cách định tính như sau:

1. Chọn khởi đầu dự đoán cho vị trí và hình dạng

2. Lặp lại cho đến khi hội tụ:

   1. E-Step: Đối với mỗi điểm, tìm trọng số mã hóa xác suất thành viên trong mỗi cụm
   2. M-bước: Đối với mỗi cụm, cập nhật vị trí của nó, chuẩn hóa và hình dạng dựa trên tất cả các điểm dữ liệu, sử dụng các trọng số

Kết quả của điều này là mỗi cụm được liên kết không phải với một quả cầu cứng, mà với mô hình Gaussian mượt mà. Giống như trong phương pháp tối đa hóa kỳ vọng của K-MEANS, thuật toán này đôi khi có thể bỏ lỡ giải pháp tối ưu toàn cầu, và do đó trong thực tế nhiều khởi tạo ngẫu nhiên được sử dụng.

Chúng ta hãy tạo một hàm sẽ giúp chúng ta trực quan hóa các vị trí và hình dạng của các cụm GMM bằng cách vẽ các hình elip dựa trên đầu ra GMM:

In [10]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Với điều này, chúng ta có thể xem xét những gì GMM bốn thành phần cung cấp cho chúng ta cho dữ liệu ban đầu của chúng ta:

In [11]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Tương tự, chúng ta có thể sử dụng phương pháp GMM để phù hợp với bộ dữ liệu kéo dài của chúng ta; Cho phép một hiệp phương sai đầy đủ, mô hình sẽ phù hợp với các cụm rất hình chữ nhật, kéo dài:

In [12]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Điều này cho thấy rõ rằng GMM giải quyết hai vấn đề thực tế chính với K-Means gặp phải trước đó.

Chọn loại hiệp phương sai

Nếu bạn nhìn vào các chi tiết của các phù hợp trước đó, bạn sẽ thấy rằng tùy chọn

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist

def plot_kmeans(kmeans, X, n_clusters=4, rseed=0, ax=None):
    labels = kmeans.fit_predict(X)

    # plot the input data
    ax = ax or plt.gca()
    ax.axis('equal')
    ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis', zorder=2)

    # plot the representation of the KMeans model
    centers = kmeans.cluster_centers_
    radii = [cdist(X[labels == i], [center]).max()
             for i, center in enumerate(centers)]
    for c, r in zip(centers, radii):
        ax.add_patch(plt.Circle(c, r, fc='#CCCCCC', lw=3, alpha=0.5, zorder=1))

Chúng ta có thể thấy một biểu diễn trực quan của ba lựa chọn này cho một cụm duy nhất trong hình sau:

GMM như ước tính mật độ

Mặc dù GMM thường được phân loại là một thuật toán phân cụm, về cơ bản nó là một thuật toán để ước tính mật độ. Điều đó có nghĩa là, kết quả của GMM phù hợp với một số dữ liệu về mặt kỹ thuật không phải là một mô hình phân cụm, mà là một mô hình xác suất tổng quát mô tả sự phân phối của dữ liệu.

Ví dụ, hãy xem xét một số dữ liệu được tạo từ chức năng

from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist

def plot_kmeans(kmeans, X, n_clusters=4, rseed=0, ax=None):
    labels = kmeans.fit_predict(X)

    # plot the input data
    ax = ax or plt.gca()
    ax.axis('equal')
    ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis', zorder=2)

    # plot the representation of the KMeans model
    centers = kmeans.cluster_centers_
    radii = [cdist(X[labels == i], [center]).max()
             for i, center in enumerate(centers)]
    for c, r in zip(centers, radii):
        ax.add_patch(plt.Circle(c, r, fc='#CCCCCC', lw=3, alpha=0.5, zorder=1))

In & nbsp; [13]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Nếu chúng ta cố gắng phù hợp với điều này với GMM hai thành phần được xem như một mô hình phân cụm, kết quả không đặc biệt hữu ích:

In [14]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Nhưng nếu chúng ta thay vào đó sử dụng nhiều thành phần hơn và bỏ qua các nhãn cụm, chúng ta sẽ thấy một sự phù hợp gần với dữ liệu đầu vào hơn nhiều:

In [15]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Ở đây, hỗn hợp của 16 Gaussian phục vụ không tìm thấy các cụm dữ liệu được phân tách, mà là để mô hình hóa phân phối tổng thể của dữ liệu đầu vào. Đây là một mô hình tổng quát của phân phối, có nghĩa là GMM cung cấp cho chúng ta công thức để tạo dữ liệu ngẫu nhiên mới được phân phối tương tự như đầu vào của chúng tôi. Ví dụ: đây là 400 điểm mới được rút ra từ GMM 16 thành phần này phù hợp với dữ liệu gốc của chúng tôi:

In [16]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

GMM thuận tiện như một phương tiện linh hoạt để mô hình hóa phân phối dữ liệu đa chiều tùy ý.

Có bao nhiêu thành phần? ¶

Thực tế là GMM là một mô hình tổng quát cung cấp cho chúng ta một phương tiện tự nhiên để xác định số lượng thành phần tối ưu cho một bộ dữ liệu nhất định. Một mô hình tổng quát vốn là phân phối xác suất cho bộ dữ liệu và do đó chúng ta có thể chỉ cần đánh giá khả năng dữ liệu theo mô hình, sử dụng xác thực chéo để tránh khớp quá mức. Một phương tiện khác để sửa chữa quá mức là điều chỉnh khả năng mô hình bằng cách sử dụng một số tiêu chí phân tích như Tiêu chí Thông tin Akaike (AIC) hoặc Tiêu chí Thông tin Bayes (BIC). Công cụ ước tính

from sklearn.cluster import KMeans
from scipy.spatial.distance import cdist

def plot_kmeans(kmeans, X, n_clusters=4, rseed=0, ax=None):
    labels = kmeans.fit_predict(X)

    # plot the input data
    ax = ax or plt.gca()
    ax.axis('equal')
    ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis', zorder=2)

    # plot the representation of the KMeans model
    centers = kmeans.cluster_centers_
    radii = [cdist(X[labels == i], [center]).max()
             for i, center in enumerate(centers)]
    for c, r in zip(centers, radii):
        ax.add_patch(plt.Circle(c, r, fc='#CCCCCC', lw=3, alpha=0.5, zorder=1))

Chúng ta hãy xem AIC và BIC là một hàm như số lượng thành phần GMM cho bộ dữ liệu mặt trăng của chúng ta:

In [17]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Số lượng cụm tối ưu là giá trị giảm thiểu AIC hoặc BIC, tùy thuộc vào mức độ xấp xỉ nào chúng ta muốn sử dụng. AIC cho chúng ta biết rằng sự lựa chọn 16 thành phần của chúng ta ở trên có lẽ là quá nhiều: khoảng 8-12 thành phần sẽ là một lựa chọn tốt hơn. Như là điển hình với loại vấn đề này, BIC khuyến nghị một mô hình đơn giản hơn.

Lưu ý điểm quan trọng: Sự lựa chọn số lượng thành phần này đo lường mức độ hoạt động của GMM như một công cụ ước tính mật độ, chứ không phải nó hoạt động tốt như thế nào như một thuật toán phân cụm. Tôi khuyến khích bạn nghĩ về GMM chủ yếu là công cụ ước tính mật độ và chỉ sử dụng nó để phân cụm khi được bảo hành trong các bộ dữ liệu đơn giản.

Ví dụ: GMM để tạo dữ liệu mới

Chúng tôi chỉ thấy một ví dụ đơn giản về việc sử dụng GMM làm mô hình dữ liệu tổng quát để tạo các mẫu mới từ phân phối được xác định bởi dữ liệu đầu vào. Ở đây chúng tôi sẽ chạy với ý tưởng này và tạo ra các chữ số viết tay mới từ kho mục tiêu tiêu chuẩn mà chúng tôi đã sử dụng trước đây.

Để bắt đầu, hãy tải dữ liệu chữ số bằng các công cụ dữ liệu của Scikit-LEARN:

In [18]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Tiếp theo, chúng ta hãy vẽ 100 trong số này để nhớ lại chính xác những gì chúng ta đang xem:

In [19]:

# Generate some data
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4,
                       cluster_std=0.60, random_state=0)
X = X[:, ::-1] # flip axes for better plotting

Chúng tôi có gần 1.800 chữ số trong 64 chiều và chúng tôi có thể xây dựng một GMM trên đỉnh này để tạo ra nhiều hơn. GMM có thể gặp khó khăn trong việc hội tụ trong một không gian chiều cao như vậy, vì vậy chúng tôi sẽ bắt đầu với một thuật toán giảm kích thước không thể đảo ngược trên dữ liệu. Ở đây chúng tôi sẽ sử dụng PCA đơn giản, yêu cầu nó bảo tồn 99% phương sai trong dữ liệu dự kiến:

In [20]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Kết quả là 41 chiều, giảm gần 1/3 mà hầu như không mất thông tin. Với dữ liệu dự kiến ​​này, chúng ta hãy sử dụng AIC để có được thước đo cho số lượng thành phần GMM chúng ta nên sử dụng:

In [21]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Dường như khoảng 110 thành phần giảm thiểu AIC; Chúng tôi sẽ sử dụng mô hình này. Hãy nhanh chóng phù hợp với dữ liệu này và xác nhận rằng nó đã hội tụ:

In [22]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Bây giờ chúng ta có thể vẽ các mẫu gồm 100 điểm mới trong không gian dự kiến ​​41 chiều này, sử dụng GMM làm mô hình tổng quát:

In [23]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Cuối cùng, chúng ta có thể sử dụng biến đổi nghịch đảo của đối tượng PCA để xây dựng các chữ số mới:

In [24]:

# Plot the data with K Means Labels
from sklearn.cluster import KMeans
kmeans = KMeans(4, random_state=0)
labels = kmeans.fit(X).predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap='viridis');

Kết quả cho hầu hết các phần trông giống như các chữ số hợp lý từ bộ dữ liệu!

Hãy xem xét những gì chúng tôi đã làm ở đây: Đưa ra một mẫu các chữ số viết tay, chúng tôi đã mô hình hóa phân phối dữ liệu đó theo cách mà chúng tôi có thể tạo ra các mẫu chữ số mới từ dữ liệu: đó là "chữ số viết tay" không riêng Xuất hiện trong bộ dữ liệu ban đầu, nhưng thay vào đó nắm bắt các tính năng chung của dữ liệu đầu vào theo mô hình của mô hình hỗn hợp. Một mô hình tổng thể của các chữ số như vậy có thể chứng minh rất hữu ích như là một thành phần của một phân loại tổng quát Bayes, như chúng ta sẽ thấy trong phần tiếp theo.