[PYTHON] Klassifizieren Sie Mnist-Zahlen nach Keras, ohne dass der Lehrer etwas lernt [Auto Encoder Edition]

Einführung

Unbeaufsichtigtes Lernen ist im Allgemeinen weniger genau als überwachtes Lernen, geht jedoch zu Lasten vieler Vorteile. Insbesondere als Szene, in der unbeaufsichtigtes Lernen nützlich ist

** - Daten, deren Muster nicht gut verstanden wird

• Zeitlich variierende Daten
• Unbeschriftete Daten **

Und so weiter.

Beim unbeaufsichtigten Lernen lernen Sie die Struktur hinter den Daten aus den Daten selbst. Auf diese Weise können Sie mehr unbeschriftete Daten nutzen, was den Weg für neue Anwendungen ebnen kann.

Letztes Mal haben wir durch unbeaufsichtigtes Lernen mit PCA und t-SNE klassifiziert. https://qiita.com/nakanakana12/items/af08b9f605a48cad3e4e

Aber schließlich möchte ich das trendige Deep Learning nutzen, also in diesem Artikel ** Unüberwachtes Lernen mit Auto Encoder ** halten. Eine ausführliche Erläuterung des Auto-Encoders selbst entfällt. Bitte beachten Sie die Referenzen.

Bibliothek importieren

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

Datenaufbereitung

Laden Sie die wichtigsten Daten herunter und führen Sie die Vorverarbeitung durch. In der Vorverarbeitung werden Normalisierung und Kanalpositionseinstellung durchgeführt.

python

fashion_mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

#Normalisierung
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)

#Kanalposition einstellen
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)

Auto-Encoder erstellen

Erstellen Sie ein Modell des Auto-Encoders. Ich war beeindruckt von der extrem geringen Anzahl an Codes.

Hier erstellen wir einen Auto-Encoder **, der auf ** 36 Dimensionen komprimiert wird. Durch einfaches Verbinden von zwei vollständig verbundenen Schichten wird die erste Schicht auf 36 Dimensionen komprimiert und die zweite Schicht kehrt zur ursprünglichen Größe zurück. Mit anderen Worten ist die erste Schicht der Codierer und die zweite Schicht ist der Decodierer.

Der Schreibstil hier ist der gleiche wie beim normalen überwachten Lernen.

python

model = Sequential()

#Encoder
model.add(Dense(36, activation="relu", input_shape=(28*28,)))
#Decoder
model.add(Dense(28*28,activation="sigmoid"))

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

Auto Encoder lernen

Als nächstes trainieren wir den Auto-Encoder. ** Der Punkt hier ist, dass die richtigen Antwortdaten Bilddaten anstelle von Beschriftungen verwenden. ** ** ** Das Lernen wurde in meiner Umgebung in 156 Epochen abgeschlossen.

python

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

#Trainiere das Modell
#Trainiere, um die Antwortdaten zu korrigieren_Verwenden Sie Bilder
model.fit(train_images, train_images,
          epochs=200,
          batch_size=2024,
          shuffle=True,
          validation_data=(test_images, test_images),
          callbacks=fit_callbacks,
          )

Lassen Sie uns das Lernergebnis überprüfen. Sie können sehen, dass der Verlust auf einen bestimmten Wert konvergiert hat.

python

#Überprüfen Sie den Verlust von Testdaten
score = model.evaluate(test_images, test_images, verbose=0)
print('test xentropy:', score)

#Visualisieren Sie den Verlust von Testdaten
score = model.evaluate(test_images, test_images, verbose=0)
print('test xentropy:', score)

Automatische Encoder-Modellerstellung

Nehmen Sie als Nächstes nur das Encoderteil aus dem Vorgängermodell heraus und erstellen Sie ein Modell.

#Modell zum Komprimieren
encoder = clone_model(model)
encoder.compile(optimizer="adam", loss="binary_crossentropy")
encoder.set_weights(model.get_weights())
#Letzte Ebene löschen
encoder.pop()

Visualisieren Sie 36-dimensionale Daten mit dem extrahierten Auto-Encoder. ** Die mittlere Ebene ist ein 36-dimensionales Bild, aber Sie können sehen, dass die Originaldaten in der Ausgabeebene wiederhergestellt wurden. ** ** ** Es ist irgendwie seltsam.

python

#Wählen Sie 10 Punkte aus den Testdaten und visualisieren Sie

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

#Führen Sie das ausgewählte Beispiel auf AutoEncoder aus
x_test_sampled_pred = model.predict(x_test_sampled,verbose=0)
#Nur Encoder aufrufen
x_test_sampled_enc = encoder.predict(x_test_sampled,verbose=0)

#Verarbeiten Sie die Verarbeitungsergebnisse
fig, ax = plt.subplots(3, 10,figsize=[20,10])
for i, label in enumerate(test_labels[p]):
    #Das Originalbild
    img = x_test_sampled[i].reshape(image_height, image_width)
    ax[0][i].imshow(img, cmap=cm.gray_r)
    ax[0][i].axis('off')
    #Mit AutoEncoder komprimiertes Bild
    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')
    #Von AutoEncoder wiederhergestelltes Bild
    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')

Klassifizierung von Bildern mit k-Mitteln

Schließlich wird die Klassifizierung durch k-Mittel unter Verwendung von 36-dimensionalen Daten durchgeführt. Es wird in 10 Cluster klassifiziert und die höchste Zahl für jeden Cluster wird als Vorhersageetikett verwendet.

python

#Dimensional reduzierte Daten erstellen
x_test_enc = encoder.predict(train_images)
print(x_test_enc.shape)

#k-Klassifizierung nach Menas
KM = KMeans(n_clusters = 10)
result = KM.fit(x_test_enc)

#Auswertung durch Verwirrungsmatrix
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

Als ich die Verwirrungsmatrix überprüfte, schien es, dass ich sie nicht gut in 10 einordnen konnte.

Lassen Sie uns nun das Bild jedes Clusters visualisieren.

python

#Zeigen Sie 5 Bilder aus jedem Cluster an

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

** Wenn Sie sich die einzelnen Cluster ansehen, sehen Sie, dass sie ähnliche Funktionen im Bild haben, auch wenn die Zahlen unterschiedlich sind. ** ** ** Beispielsweise ist Cluster 0 dick und Cluster 4 dünn. Daraus ist ersichtlich, dass ** die Daten nicht nur durch das Etikett dargestellt werden, sondern die Merkmale gut aus dem Bild selbst stammen **.

Es ist interessant, nach Informationen außerhalb des Etiketts klassifizieren zu können. Dies bedeutet, dass Sie neue Beschriftungen hinzufügen können.

Am Ende

Dieses Mal habe ich einen Auto-Encoder verwendet, um Mnist-Nummern ohne Aufsicht zu klassifizieren. ** Ich konnte nicht anhand der Daten auf dem Etikett klassifizieren, aber als ich den Cluster visualisierte, wurden die Informationen außerhalb des Etiketts sichtbar **.

Das Tolle am unbeaufsichtigten Lernen ist, dass Sie Informationen außerhalb des Etiketts erhalten können.

Wenn Sie es hilfreich finden, wäre es ermutigend, wenn Sie LGTM verwenden könnten.

Verweise

Was ist ein Auto-Encoder? Erklären Sie den Mechanismus des Vorlernens und wie Sie es jetzt verwenden können! !! https://it-trend.jp/development_tools/article/32-0024

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

Python: Schreiben Sie AutoEncoder in Keras https://blog.amedama.jp/entry/keras-auto-encoder