[PYTHON] Classer les numéros mnist par keras sans apprentissage par l'enseignant [Auto Encoder Edition]

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 comme une 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.

La dernière fois, nous avons classé par apprentissage non supervisé en utilisant PCA et t-SNE. https://qiita.com/nakanakana12/items/af08b9f605a48cad3e4e

Mais après tout, je veux utiliser l'apprentissage profond à la mode, donc dans cet article ** Apprentissage non supervisé avec encodeur automatique ** tenir. Une explication détaillée du codeur automatique lui-même est omise. Veuillez vous référer aux références.

Importer la bibliothèque

python

import keras
import random
import matplotlib.pyplot as plt
from matplotlib import cm
import seaborn as sns
import pandas as pd
import numpy as np
import plotly.express as px
import os

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


from keras import backend as K
from keras.models import Sequential, Model, clone_model
from keras.layers import Activation, Dense, Dropout, Conv2D,MaxPooling2D,UpSampling2D
from keras import callbacks

from keras.layers import BatchNormalization, Input, Lambda
from keras import regularizers
from keras.losses import mse, binary_crossentropy

sns.set("talk")

Préparation des données

Téléchargez les données mnist et effectuez le prétraitement. Lors du prétraitement, la normalisation et l'ajustement de la position du canal sont effectués.

python

fashion_mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = fashion_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())

print(train_images.shape,test_images.shape)

#Réglage de la position du canal
image_height, image_width = 28,28
train_images = train_images.reshape(train_images.shape[0],28*28)
test_images = test_images.reshape(test_images.shape[0],28*28)
print(train_images.shape, test_images.shape)

Créer un encodeur automatique

Créez un modèle de l'encodeur automatique. J'ai été impressionné par le très petit nombre de codes.

Ici, nous allons créer un encodeur automatique ** qui se compresse à ** 36 dimensions. En connectant simplement deux couches entièrement connectées, la première couche se comprime à 36 dimensions et la deuxième couche reprend sa taille d'origine. En d'autres termes, la première couche est le codeur et la deuxième couche est le décodeur.

Le style d'écriture ici est le même que celui de l'apprentissage supervisé ordinaire.

python

model = Sequential()

#Encodeur
model.add(Dense(36, activation="relu", input_shape=(28*28,)))
#décodeur
model.add(Dense(28*28,activation="sigmoid"))

model.compile(optimizer="adam",loss="binary_crossentropy")
model.summary()

Apprentissage de l'encodeur automatique

Ensuite, entraînons l'encodeur automatique. ** Le point ici est que les données de réponse correctes utilisent des données d'image au lieu d'étiquettes. ** ** L'apprentissage a été achevé à l'époque 156 dans mon environnement.

python

fit_callbacks = [
    callbacks.EarlyStopping(monitor='val_loss',
                            patience=5,
                            mode='min')
]

#Former le modèle
#S'entraîner à corriger les données de réponse_Utiliser des images
model.fit(train_images, train_images,
          epochs=200,
          batch_size=2024,
          shuffle=True,
          validation_data=(test_images, test_images),
          callbacks=fit_callbacks,
          )

Vérifions le résultat de l'apprentissage. Vous pouvez voir que la perte a convergé vers une certaine valeur.

python

#Vérifier la perte des données de test
score = model.evaluate(test_images, test_images, verbose=0)
print('test xentropy:', score)

#Visualisez la perte de données de test
score = model.evaluate(test_images, test_images, verbose=0)
print('test xentropy:', score)

Création de modèle d'encodeur automatique

Ensuite, retirez uniquement la partie encodeur du modèle précédent et créez un modèle.

#Modèle à compresser
encoder = clone_model(model)
encoder.compile(optimizer="adam", loss="binary_crossentropy")
encoder.set_weights(model.get_weights())
#Supprimer le dernier calque
encoder.pop()

Visualisez les données en 36 dimensions à l'aide de l'encodeur automatique extrait. ** Le calque du milieu est une image en 36 dimensions, mais vous pouvez voir que les données d'origine ont été restaurées dans le calque de sortie. ** ** C'est un peu étrange.

python

#Sélectionnez 10 points parmi les données de test et visualisez

p = np.random.randint(0, len(test_images), 10)
x_test_sampled = test_images[p]

#Exécutez l'échantillon sélectionné sur AutoEncoder
x_test_sampled_pred = model.predict(x_test_sampled,verbose=0)
#Appeler uniquement l'encodeur
x_test_sampled_enc = encoder.predict(x_test_sampled,verbose=0)

#Visualisez les résultats du traitement
fig, ax = plt.subplots(3, 10,figsize=[20,10])
for i, label in enumerate(test_labels[p]):
    #L'image originale
    img = x_test_sampled[i].reshape(image_height, image_width)
    ax[0][i].imshow(img, cmap=cm.gray_r)
    ax[0][i].axis('off')
    #Image compressée par AutoEncoder
    enc_img = x_test_sampled_enc[i].reshape(6, 6)
    ax[1][i].imshow(enc_img, cmap=cm.gray_r)
    ax[1][i].axis('off')
    #Image restaurée par AutoEncoder
    pred_img = x_test_sampled_pred[i].reshape(image_height, image_width)
    ax[2][i].imshow(pred_img, cmap=cm.gray_r)
    ax[2][i].axis('off')

Classification des images par k-means

Enfin, la classification par k-means est effectuée à l'aide de données à 36 dimensions. Il est classé en 10 clusters et le nombre le plus élevé pour chaque cluster est utilisé comme étiquette de prédiction.

python

#Création de données dimensionnellement réduites
x_test_enc = encoder.predict(train_images)
print(x_test_enc.shape)

#k-Classification par menas
KM = KMeans(n_clusters = 10)
result = KM.fit(x_test_enc)

#Évaluation par matrice de confusion
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

Quand j'ai vérifié la matrice de confusion, il semble que je ne pouvais pas bien la classer en 10.

Visualisons maintenant l'image de chaque cluster.

python

#Afficher 5 images de chaque cluster

fig, ax = plt.subplots(5,10,figsize=[15,8])
for col_i in range(10):
  idx_list = random.sample(set(np.where(result.labels_ == col_i)[0]), 5)
  ax[0][col_i].set_title("cluster:" + str(col_i), fontsize=12)
  for row_i, idx_i in enumerate(idx_list):
      ax[row_i][col_i].imshow((train_images[idx_i].reshape(image_height, image_width)), cmap=cm.gray_r)
      ax[row_i][col_i].axis('off')

** Si vous regardez chaque cluster, vous pouvez voir qu'ils ont des caractéristiques similaires dans l'image même si les nombres sont différents. ** ** Par exemple, le cluster 0 est épais et le cluster 4 est mince. À partir de là, on peut voir que ** les données ne sont pas représentées uniquement par l'étiquette, mais les caractéristiques sont bien tirées de l'image elle-même **.

Il est intéressant de pouvoir classer par information en dehors de l'étiquette. Cela signifie que vous pouvez ajouter de nouvelles étiquettes.

À la fin

Cette fois, j'ai utilisé un encodeur automatique pour classer les nombres mnist sans supervision. ** Je ne pouvais pas classer selon les données sur l'étiquette, mais quand j'ai visualisé le cluster, les informations en dehors de l'étiquette sont devenues apparentes **.

L'avantage de l'apprentissage non supervisé est que vous pouvez obtenir des informations en dehors du label.

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

Références

Qu'est-ce qu'un encodeur automatique? Expliquez le mécanisme de pré-apprentissage et comment l'utiliser maintenant! !! https://it-trend.jp/development_tools/article/32-0024

AutoEncoder avec Keras https://qiita.com/fukuit/items/2f8bdbd36979fff96b07

Python: écrire AutoEncoder dans Keras https://blog.amedama.jp/entry/keras-auto-encoder