[PYTHON] J'ai essayé de classer les nombres de mnist par apprentissage non supervisé [PCA, t-SNE, k-means]

introduction

L'apprentissage non supervisé est généralement moins précis que l'apprentissage supervisé, mais au prix de nombreux avantages. Plus précisément, en tant que scène où l'apprentissage non supervisé est utile

** - Données dont le modèle n'est pas bien compris --Données variant dans le temps --Données non étiquetées **

Etc.

Dans l'apprentissage non supervisé, vous apprenez la structure derrière les données à partir des données elles-mêmes. Cela vous permet de tirer parti de plus de données non étiquetées, ce qui peut ouvrir la voie à de nouvelles applications.

Dans cet article, je présenterai un exemple d'implémentation ** de classification des données mnist par apprentissage non supervisé. La méthode utilise l'analyse en composantes principales et la méthode t-SNE, k-means. Dans l'article suivant, je voudrais contester la classification à l'aide de l'encodeur automatique.

Que faire dans cet article

** - Classer les données mnist par apprentissage non supervisé --Mise en œuvre et évaluation de la classification par la méthode PCA + k-means

• Mise en œuvre et évaluation de la classification par méthode PCA + t-SNE + k-means **

Importer la bibliothèque

python

import random
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.metrics import confusion_matrix
from sklearn.manifold import TSNE

Préparation des données

python

mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
#Normalisation
train_images = (train_images - train_images.min()) / (train_images.max() - train_images.min())
test_images = (test_images - test_images.min()) / (test_images.max() - test_images.min())

train_images.shape,test_images.shape

Je vais le visualiser pour le moment. Ce sont des chiffres familiers.

python

#Visualisation aléatoire
fig, ax = plt.subplots(4,5,figsize=[8,6])
ax_f = ax.flatten()
for ax_i in ax_f:
    idx = random.choice(range(train_images.shape[0]))
    ax_i.imshow(train_images[idx,:,:])
    ax_i.grid(False)
    ax_i.tick_params(labelbottom=False,labelleft=False)

Classification des images par analyse en composantes principales

Les données de mnist sont 28 * 28 = 784 dimensions. Il semble que la méthode k-means puisse être appliquée telle quelle, mais elle est efficace pour ** réduire les dimensions avant de classer. Ce faisant, il est possible de réduire la quantité de calcul.

** L'analyse des composants principaux (ACP) est utilisée comme méthode de réduction des dimensions. Ensuite, la méthode des k-means est appliquée aux données dont les dimensions ont été réduites par PCA pour classer les données. ** **

Effectuer une analyse des composants principaux

python

df_train = pd.DataFrame(train_images.reshape(train_images.shape[0],28*28))

pca = PCA()
pca.fit(df_train)
feature = pca.transform(df_train)

#Visualisation en deux dimensions
plt.scatter(feature[:,0],feature[:,1],alpha=0.8,c=train_labels)

Voici le résultat de la visualisation avec le premier composant et le deuxième composant du composant principal. Il est codé en couleur par 10 groupes de 0 à 9. On dirait qu'ils peuvent être catégorisés d'une manière ou d'une autre, mais ... il y a de nombreuses parties qui se chevauchent.

Ensuite, réfléchissons au nombre de composants à appliquer k-means. Par conséquent, le taux de cotisation de chaque composante est visualisé.

python

#Changement du taux de cotisation
ev_ratio = pca.explained_variance_ratio_
ev_ratio = np.hstack([0,ev_ratio.cumsum()])

df_ratio = pd.DataFrame({"components":range(len(ev_ratio)), "ratio":ev_ratio})

plt.plot(ev_ratio)
plt.xlabel("components")
plt.ylabel("explained variance ratio")
plt.xlim([0,50])

plt.scatter(range(len(ev_ratio)),ev_ratio)

En regardant les résultats, nous pouvons voir que 90% ou plus des données peuvent être restaurées jusqu'au 100e composant. Comme vous pouvez le voir à partir de diverses expériences, 10 composants suffisaient lors de la classification. (J'ai expérimenté la méthode d'évaluation décrite ci-dessous) À partir de là, classons en appliquant la méthode k-means en utilisant jusqu'au 10e composant. Plus le nombre de dimensions est petit, plus le nombre de calculs est petit, il est donc préférable d'avoir un nombre plus petit.

Classification par la méthode des k-moyennes

Tout d'abord, appliquez la méthode des k-moyennes. Nous savons qu'il y a 10 groupes, alors classons-les d'abord en 10.

python

KM = KMeans(n_clusters = 10)
result = KM.fit(feature[:,:9])

Évaluation des résultats de classification

Tout d'abord, le résultat de la classification est affiché sous forme de matrice de confusion.

python

df_eval = pd.DataFrame(confusion_matrix(train_labels,result.labels_))
df_eval.columns = df_eval.idxmax()
df_eval = df_eval.sort_index(axis=1)

df_eval

L'étiquette de réponse correcte, qui était la plus fréquemment classée dans la grappe, a été utilisée comme étiquette prédictive. Par exemple, si le cluster n ° 0 contient 100 0, 20 1 et 10 4, cela prédit 0.

En regardant les résultats, vous pouvez voir qu'il y a deux clusters qui devraient être 0 et un qui devrait être 1. En d'autres termes, on considère qu'il était difficile de classer en 10 nombres ** par l'analyse en composantes principales et la méthode des k-moyennes **.

Maintenant, réfléchissons au ** nombre de clusters qu'il est préférable de classer **. Évidemment, s'il y a de nombreux clusters, il y en aura de nombreux similaires dans le cluster, mais ce sera difficile à interpréter. En revanche, s'il est petit, il est facile à interpréter, mais le cluster contiendra diverses données.

Donc, ** le nombre de clusters est petit, mais il vaut mieux classer avec des données similaires autant que possible **. Étant donné que nous connaissons les données de réponse correctes ici, nous aimerions trouver le nombre de groupes qui a le plus grand nombre d'étiquettes de réponse correcte, avec les étiquettes de réponse les plus correctes comme étiquettes de réponse correctes.

Par conséquent, l'indice d'évaluation est ** le nombre d'étiquettes correctes / le nombre total **.

python

#Recherchez le nombre de clusters avec le plus grand nombre de données dans le cluster comme étiquette correcte.
eval_acc_list=[]

for i in range(5,15):
    KM = KMeans(n_clusters = i)
    result = KM.fit(feature[:,:9])
    df_eval = pd.DataFrame(confusion_matrix(train_labels,result.labels_))
    eval_acc = df_eval.max().sum()/df_eval.sum().sum()
    eval_acc_list.append(eval_acc)

plt.plot(range(5,15),eval_acc_list)
plt.xlabel("The number of cluster")
plt.ylabel("accuracy")

C'est le résultat lorsque le nombre de clusters passe de 5 à 15. À mesure que le nombre de grappes augmente, l'homogénéité augmente et la précision augmente. ** Ce qui est le mieux dépend de l'objectif, mais environ 10 groupes semblent être bons compte tenu de l'interprétabilité. ** **

En d'autres termes, il était difficile de le diviser en 10 étiquettes avec le PCA seul. Alors, ensuite, je voudrais combiner une méthode appelée t-SNE.

Classification par PCA + t-SNE

Exécution de t-SNE

** Il était difficile de classer en 10 avec le PCA seul, donc je vais essayer de classer en combinant PCA et t-SNE. ** ** t-SNE est une méthode dont le principe semble difficile (je ne le comprends pas bien). Je mettrai le site avec des explications détaillées dans la référence.

Étant donné que t-SNE est une méthode qui prend beaucoup de temps de calcul, elle classe 10000 éléments de données à 10 dimensions réduites par PCA. Lorsqu'il est visualisé, je pense que cela peut être classé comme un sentiment juste.

python

tsne = TSNE(n_components=2).fit_transform(feature[:10000,:9])
#Visualisation
for i in range(10):
  idx = np.where(train_labels[:10000]==i)
  plt.scatter(tsne[idx,0],tsne[idx,1],label=i)
plt.legend(loc='upper left',bbox_to_anchor=(1.05,1))

Classification et évaluation par k-means

Ensuite, classez par la méthode des k-moyennes et affichez la matrice de confusion.

python

#Classer tsne par kmeans
KM = KMeans(n_clusters = 10)
result = KM.fit(tsne)

df_eval = pd.DataFrame(confusion_matrix(train_labels[:10000],result.labels_))
df_eval.columns = df_eval.idxmax()
df_eval = df_eval.sort_index(axis=1)

df_eval

** Comme cela peut arriver, il est bien divisé en 10 étiquettes. C'était bon. ** ** En regardant ce tableau, vous pouvez voir que «4» et «9» sont souvent mal classés. Même si vous regardez le diagramme de dispersion qui visualise réellement les résultats du t-SNE, 4 et 9 sont proches l'un de l'autre.

Vous pouvez voir que 4 et 9 apprennent à être similaires dans cette méthode d'apprentissage. Je ne sais pas pourquoi ils pensent qu'ils sont similaires, mais c'est intéressant.

Enfin, évaluez la précision de chaque nombre de grappes. Lorsque le nombre de clusters est de 10, la précision est de 0,6. Le résultat est un peu plus élevé que lorsque seul le PCA est utilisé.

python

#Recherchez le nombre de clusters avec le plus grand nombre de données dans le cluster comme étiquette correcte.
eval_acc_list=[]

for i in range(5,15):
    KM = KMeans(n_clusters = i)
    result = KM.fit(feature[:,:9])
    df_eval = pd.DataFrame(confusion_matrix(train_labels,result.labels_))
    eval_acc = df_eval.max().sum()/df_eval.sum().sum()
    eval_acc_list.append(eval_acc)

plt.plot(range(5,15),eval_acc_list)
plt.xlabel("The number of cluster")
plt.ylabel("accuracy")

À la fin

En utilisant mnist comme thème, nous avons implémenté la réduction et la visualisation de dimension par PCA et t-SNE, et la classification et l'évaluation par k-means. Les données non étiquetées sont abondantes dans le monde, donc cela semble être une méthode très utile.

Si vous le trouvez utile, il serait encourageant d'utiliser LGTM, etc.

Références

Livre: ["Apprendre sans professeur par python"](url https://www.amazon.co.jp/Python%E3%81%A7%E3%81%AF%E3%81%98%E3%82%81 % E3% 82% 8B% E6% 95% 99% E5% B8% AB% E3% 81% AA% E3% 81% 97% E5% AD% A6% E7% BF% 92-% E2% 80% 95% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 81% AE% E5% 8F% AF% E8% 83% BD% E6% 80% A7% E3% 82% 92% E5% BA% 83% E3% 81% 92% E3% 82% 8B% E3% 83% A9% E3% 83% 99% E3% 83% AB% E3% 81% AA% E3% 81% 97% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 88% A9% E7% 94% A8-Ankur-Patel / dp / 4873119103)

Introduction de la méthode de compression dimensionnelle utilisant t-SNE https://blog.albert2005.co.jp/2015/12/02/tsne/

Comprendre t-SNE et améliorer la visualisation https://qiita.com/g-k/items/120f1cf85ff2ceae4aba