Python ile Yapay Zeka - Denetimsiz Öğrenme: Kümeleme

Denetimsiz makine öğrenimi algoritmalarında, herhangi bir tür rehberlik sağlayacak bir gözetmen yoktur. Bu nedenle, bazılarının gerçek yapay zeka dediği şeyle yakından uyumlular.

Denetimsiz öğrenmede, rehberlik için doğru cevap ve öğretmen olmayacaktı. Algoritmaların öğrenme için verilerdeki ilginç modeli keşfetmesi gerekir.

Kümeleme nedir?

Temel olarak, bir tür denetimsiz öğrenme yöntemi ve birçok alanda kullanılan istatistiksel veri analizi için yaygın bir tekniktir. Kümeleme, temelde, gözlem kümesini kümeler adı verilen alt kümelere, aynı kümedeki gözlemler bir anlamda benzer olacak ve diğer kümelerdeki gözlemlerden farklı olacak şekilde bölme görevidir. Basit bir ifadeyle, kümelemenin temel amacının verileri benzerlik ve benzeşmezlik temelinde gruplamak olduğunu söyleyebiliriz.

Örneğin, aşağıdaki diyagram, farklı kümelerde benzer türde verileri göstermektedir -

Verileri Kümelemek İçin Algoritmalar

Aşağıda, verileri kümelemek için birkaç yaygın algoritma verilmiştir -

K-Means algoritması

K-ortalamalı kümeleme algoritması, verileri kümelemek için iyi bilinen algoritmalardan biridir. Küme sayısının zaten bilindiğini varsaymalıyız. Buna düz kümeleme de denir. Yinelemeli bir kümeleme algoritmasıdır. Bu algoritma için aşağıda verilen adımların izlenmesi gerekir -

Step 1 - İstenilen sayıda K alt grubu belirlememiz gerekiyor.

Step 2- Küme sayısını düzeltin ve her veri noktasını rastgele bir kümeye atayın. Başka bir deyişle, verilerimizi küme sayısına göre sınıflandırmamız gerekiyor.

Bu adımda, küme ağırlık merkezleri hesaplanmalıdır.

Bu yinelemeli bir algoritma olduğundan, global optimayı bulana kadar veya başka bir deyişle centroidler optimal konumlarına ulaşana kadar her yinelemede K centroidlerin konumlarını güncellememiz gerekir.

Aşağıdaki kod, Python'da K-ortalama kümeleme algoritmasının uygulanmasına yardımcı olacaktır. Scikit-learn modülünü kullanacağız.

Gerekli paketleri ithal edelim -

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

Aşağıdaki kod satırı, kullanarak dört blob içeren iki boyutlu veri kümesinin oluşturulmasına yardımcı olacaktır. make_blob -den sklearn.dataset paketi.

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)

Aşağıdaki kodu kullanarak veri setini görselleştirebiliriz -

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

Burada, kmeans'ı kaç küme (n_küme) için gerekli parametresi ile KMeans algoritması olarak başlatıyoruz.

kmeans = KMeans(n_clusters = 4)

K-ortalama modelini girdi verileriyle eğitmemiz gerekiyor.

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_

Aşağıda verilen kod, verilerimize dayanarak makinenin bulgularını ve bulunacak küme sayısına göre teçhizatı çizmemize ve görselleştirmemize yardımcı olacaktır.

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

Ortalama Kayma Algoritması

Denetimsiz öğrenmede kullanılan bir başka popüler ve güçlü kümeleme algoritmasıdır. Herhangi bir varsayımda bulunmaz, dolayısıyla parametrik olmayan bir algoritmadır. Aynı zamanda hiyerarşik kümeleme veya ortalama kaydırma kümeleme analizi olarak da adlandırılır. Bu algoritmanın temel adımları aşağıdakiler olacaktır -

Öncelikle, kendi kümelerine atanan veri noktaları ile başlamalıyız.
Şimdi, centroidleri hesaplar ve yeni centroidlerin konumunu günceller.
Bu süreci tekrarlayarak, kümenin tepesine, yani daha yüksek yoğunluklu bölgeye yaklaşıyoruz.
Bu algoritma, ağırlık merkezlerinin artık hareket etmediği aşamada durur.

Aşağıdaki kodun yardımıyla Python'da Mean Shift kümeleme algoritması uyguluyoruz. Scikit-learn modülünü kullanacağız.

Gerekli paketleri ithal edelim -

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

Aşağıdaki kod, kullanarak dört blob içeren iki boyutlu veri kümesinin oluşturulmasına yardımcı olacaktır. make_blob -den sklearn.dataset paketi.

from sklearn.datasets.samples_generator import make_blobs

Veri setini aşağıdaki kod ile görselleştirebiliriz

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()

Şimdi, Ortalama Kayma küme modelini girdi verileriyle eğitmemiz gerekiyor.

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

Aşağıdaki kod, küme merkezlerini ve giriş verilerine göre beklenen küme sayısını yazdıracaktır -

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

Aşağıda verilen kod, verilerimize dayalı olarak makinenin bulgularını ve bulunacak küme sayısına göre teçhizatı çizmeye ve görselleştirmeye yardımcı olacaktır.

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()

Kümeleme Performansını Ölçme

Gerçek dünya verileri doğal olarak farklı kümeler halinde düzenlenmemiştir. Bu nedenle görselleştirmek ve çıkarımlar yapmak kolay değildir. Bu nedenle, kümeleme performansını ve kalitesini ölçmemiz gerekiyor. Siluet analizi yardımı ile yapılabilir.

Siluet Analizi

Bu yöntem, kümeler arasındaki mesafeyi ölçerek kümelenme kalitesini kontrol etmek için kullanılabilir. Temel olarak, bir siluet puanı vererek küme sayısı gibi parametreleri değerlendirmenin bir yolunu sağlar. Bu puan, bir kümedeki her noktanın, komşu kümelerdeki noktalara ne kadar yakın olduğunu ölçen bir metriktir.

Siluet skorunun analizi

Skor [-1, 1] aralığına sahiptir. Bu puanın analizi aşağıdadır -

Score of +1 - +1 yakın puan, örneğin komşu kümeden uzakta olduğunu gösterir.
Score of 0 - Skor 0, numunenin iki komşu küme arasındaki karar sınırında veya buna çok yakın olduğunu gösterir.
Score of -1 - Negatif puan, numunelerin yanlış kümelere atandığını gösterir.

Siluet Puanının Hesaplanması

Bu bölümde siluet puanının nasıl hesaplanacağını öğreneceğiz.

Siluet puanı aşağıdaki formül kullanılarak hesaplanabilir -

$$ siluet puanı = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$

Burada, veri noktasının parçası olmadığı en yakın kümedeki noktalara olan ortalama uzaklıktır. Ve kendi kümesindeki tüm noktalara olan ortalama küme içi mesafedir.

En uygun küme sayısını bulmak için, kümeleme algoritmasını yeniden çalıştırmamız gerekir. metrics modülünden sklearnpaketi. Aşağıdaki örnekte, optimum küme sayısını bulmak için K-ortalama kümeleme algoritmasını çalıştıracağız -

Gerekli paketleri gösterildiği gibi içe aktarın -

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

Aşağıdaki kodun yardımıyla, kullanarak dört blob içeren iki boyutlu veri setini oluşturacağız. make_blob -den sklearn.dataset paketi.

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)

Değişkenleri gösterildiği gibi başlatın -

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

K-ortalamaları modelini tüm değerler boyunca yinelememiz ve ayrıca onu girdi verileriyle eğitmemiz gerekir.

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

Şimdi, Öklid mesafe metriğini kullanarak mevcut kümeleme modeli için siluet puanını tahmin edin -

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

Aşağıdaki kod satırı, küme sayısının yanı sıra Silhouette puanının görüntülenmesine yardımcı olacaktır.

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

Aşağıdaki çıktıyı alacaksınız -

Number of clusters = 9
Silhouette score = 0.340391138371

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

Şimdi, optimum küme sayısı için çıktı aşağıdaki gibi olacaktır -

Optimal number of clusters = 2

En Yakın Komşuları Bulmak

Bir film tavsiye sistemi gibi tavsiye sistemleri kurmak istiyorsak, en yakın komşuları bulma konseptini anlamamız gerekir. Bunun nedeni, tavsiye sisteminin en yakın komşular kavramını kullanmasıdır.

concept of finding nearest neighborsVerilen veri setinden giriş noktasına en yakın noktayı bulma süreci olarak tanımlanabilir. Bu KNN) K-en yakın komşular) algoritmasının ana kullanımı, giriş veri noktasının çeşitli sınıflara yakınlığı üzerindeki bir veri noktasını sınıflandıran sınıflandırma sistemleri oluşturmaktır.

Aşağıda verilen Python kodu, belirli bir veri setinin K-en yakın komşularını bulmaya yardımcı olur -

Gerekli paketleri aşağıda gösterildiği gibi içe aktarın. Burada kullanıyoruzNearestNeighbors modülünden sklearn paket

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

Şimdi giriş verilerini tanımlayalım -

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],])

Şimdi, en yakın komşuları tanımlamamız gerekiyor -

k = 3

Ayrıca en yakın komşuların bulunabileceği test verilerini de vermemiz gerekiyor -

test_data = [3.3, 2.9]

Aşağıdaki kod, bizim tarafımızdan tanımlanan giriş verilerini görselleştirebilir ve çizebilir -

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

Şimdi, K En Yakın Komşu'yu inşa etmemiz gerekiyor. Nesnenin de eğitilmesi gerekiyor

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

Şimdi, K en yakın komşuları aşağıdaki gibi yazdırabiliriz

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

En yakın komşuları test veri noktasıyla birlikte görselleştirebiliriz

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()

Çıktı

K Nearest Neighbors

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

K-En Yakın Komşular Sınıflandırıcı

K-En Yakın Komşular (KNN) sınıflandırıcısı, belirli bir veri noktasını sınıflandırmak için en yakın komşu algoritmasını kullanan bir sınıflandırma modelidir. Son bölümde KNN algoritmasını uyguladık, şimdi bu algoritmayı kullanarak bir KNN sınıflandırıcı oluşturacağız.

KNN Sınıflandırıcı Kavramı

K-en yakın komşu sınıflandırmasının temel kavramı, önceden tanımlanmış bir sayı, yani sınıflandırılması gereken yeni bir numuneye en yakın eğitim numunelerinin 'k' - 'sini bulmaktır. Yeni örnekler etiketlerini komşulardan alacak. KNN sınıflandırıcıları, belirlenmesi gereken komşuların sayısı için sabit bir kullanıcı tanımlı sabite sahiptir. Mesafe için, standart Öklid mesafesi en yaygın seçimdir. KNN Sınıflandırıcı, öğrenme kurallarını oluşturmak yerine doğrudan öğrenilen örnekler üzerinde çalışır. KNN algoritması, tüm makine öğrenimi algoritmalarının en basitleri arasındadır. Karakter tanıma veya görüntü analizi gibi çok sayıda sınıflandırma ve regresyon probleminde oldukça başarılı olmuştur.

Example

Rakamları tanımak için bir KNN sınıflandırıcı oluşturuyoruz. Bunun için MNIST veri setini kullanacağız. Bu kodu Jupyter Defterine yazacağız.

Gerekli paketleri aşağıda gösterildiği gibi içe aktarın.

Burada kullanıyoruz KNeighborsClassifier modülünden sklearn.neighbors paket -

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

Aşağıdaki kod, hangi görüntüyü test etmemiz gerektiğini doğrulamak için rakamın görüntüsünü gösterecektir -

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

Şimdi MNIST veri setini yüklememiz gerekiyor. Aslında toplam 1797 görüntü var ancak ilk 1600 görüntüyü eğitim örneği olarak kullanıyoruz ve geri kalan 197 görüntü test amacıyla saklanacak.

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

Şimdi, görüntüleri görüntülerken çıktıyı aşağıdaki gibi görebiliriz -

Image_display(0)

Resim_display (0)

0 görüntüsü aşağıdaki gibi görüntülenir -

Resim_display (9)

9 resmi aşağıdaki gibi gösterilir -

digit.keys ()

Şimdi, eğitim ve test veri setini oluşturmamız ve test veri setini KNN sınıflandırıcılarına sağlamamız gerekiyor.

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

Aşağıdaki çıktı, K en yakın komşu sınıflandırıcı yapıcısını yaratacaktır -

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

Eğitim örnekleri olan 1600'den büyük herhangi bir rastgele sayı sağlayarak test örneğini oluşturmamız gerekiyor.

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

Resim_display (6)

6 resmi aşağıdaki gibi gösterilir -

Şimdi test verilerini şu şekilde tahmin edeceğiz -

KNN.predict(test1)

Yukarıdaki kod aşağıdaki çıktıyı üretecektir -

array([6])

Şimdi şunları düşünün -

digit['target_names']

Yukarıdaki kod aşağıdaki çıktıyı üretecektir -

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