TensorFlow Autoencoder: Datensatz mit Deep Learning-Beispiel

Inhaltsverzeichnis:

Anonim

Was ist ein Autoencoder?

Ein Autoencoder ist ein Tool zum effizienten Lernen der Datencodierung auf unbeaufsichtigte Weise. Es handelt sich um eine Art künstliches neuronales Netzwerk, mit dem Sie die Darstellung von Datensätzen zur Reduzierung der Dimensionalität lernen können, indem Sie das neuronale Netzwerk so trainieren, dass das Signalrauschen ignoriert wird. Es ist ein großartiges Werkzeug zum Wiederherstellen einer Eingabe.

Mit einfachen Worten, die Maschine nimmt beispielsweise ein Bild auf und kann ein eng verwandtes Bild erzeugen. Die Eingabe in dieser Art von neuronalen Netzwerken ist unbeschriftet, was bedeutet, dass das Netzwerk ohne Aufsicht lernen kann. Genauer gesagt wird die Eingabe vom Netzwerk codiert, um sich nur auf das kritischste Merkmal zu konzentrieren. Dies ist einer der Gründe, warum Autoencoder für die Reduzierung der Dimensionalität beliebt ist. Außerdem können Autoencoder verwendet werden, um generative Lernmodelle zu erstellen . Beispielsweise kann das neuronale Netzwerk mit einer Reihe von Gesichtern trainiert werden und dann neue Gesichter erzeugen.

In diesem TensorFlow Autoencoder-Tutorial erfahren Sie Folgendes:

  • Was ist ein Autoencoder?
  • Wie funktioniert Autoencoder?
  • Beispiel für einen gestapelten Autoencoder
  • Erstellen Sie mit TensorFlow einen Autoencoder
  • Bildvorverarbeitung
  • Set Dataset Estimator
  • Bauen Sie das Netzwerk auf

Wie funktioniert Autoencoder?

Der Zweck eines Autoencoders besteht darin, eine Annäherung an die Eingabe zu erzeugen, indem nur die wesentlichen Merkmale fokussiert werden. Sie denken vielleicht, warum Sie nicht einfach lernen, wie Sie die Eingabe kopieren und einfügen, um die Ausgabe zu erzeugen. Tatsächlich ist ein Autoencoder eine Reihe von Einschränkungen, die das Netzwerk dazu zwingen, neue Darstellungsweisen für die Daten zu erlernen, die sich vom bloßen Kopieren der Ausgabe unterscheiden.

Ein typischer Autoencoder wird mit einem Eingang, einer internen Darstellung und einem Ausgang (eine Annäherung an den Eingang) definiert. Das Lernen erfolgt in den Ebenen, die der internen Darstellung zugeordnet sind. Tatsächlich gibt es zwei Hauptschichtenblöcke, die wie ein traditionelles neuronales Netzwerk aussehen. Der kleine Unterschied besteht darin, dass die Ebene, die die Ausgabe enthält, gleich der Eingabe sein muss. In der Abbildung unten geht der ursprüngliche Eingang in den ersten Block, der als Encoder bezeichnet wird . Diese interne Darstellung komprimiert (reduziert) die Größe der Eingabe. Im zweiten Block erfolgt die Rekonstruktion der Eingabe. Dies ist die Decodierungsphase.

Funktionieren des Autoencoders

Das Modell aktualisiert die Gewichte durch Minimierung der Verlustfunktion. Das Modell wird bestraft, wenn sich die Rekonstruktionsausgabe von der Eingabe unterscheidet.

Stellen Sie sich konkret ein Bild mit einer Größe von 50 x 50 (dh 250 Pixel) und einem neuronalen Netzwerk mit nur einer verborgenen Schicht aus hundert Neuronen vor. Das Lernen erfolgt auf einer Feature-Map, die zweimal kleiner als die Eingabe ist. Dies bedeutet, dass das Netzwerk einen Weg finden muss, um 250 Pixel mit nur einem Vektor von Neuronen zu rekonstruieren, der 100 entspricht.

Beispiel für einen gestapelten Autoencoder

In diesem Autoencoder-Tutorial erfahren Sie, wie Sie einen gestapelten Autoencoder verwenden. Die Architektur ähnelt einem traditionellen neuronalen Netzwerk. Die Eingabe wird in eine verborgene Ebene verschoben, um komprimiert oder verkleinert zu werden, und erreicht dann die Rekonstruktionsebenen. Ziel ist es, ein Ausgabebild zu erzeugen, das dem Original so nahe kommt. Das Modell muss lernen, wie es seine Aufgabe unter einer Reihe von Einschränkungen, dh mit einer niedrigeren Dimension, erfüllen kann.

Heutzutage werden Autoencoder in Deep Learning hauptsächlich verwendet, um ein Bild zu entrauschen. Stellen Sie sich ein Bild mit Kratzern vor. Ein Mensch kann den Inhalt immer noch erkennen. Die Idee, Autoencoder zu entrauschen, besteht darin, dem Bild Rauschen hinzuzufügen, um das Netzwerk zu zwingen, das Muster hinter den Daten zu lernen.

Die andere nützliche Familie von Autoencoder Deep Learning ist der Variations-Autoencoder. Diese Art von Netzwerk kann neue Bilder erzeugen. Stellen Sie sich vor, Sie trainieren ein Netzwerk mit dem Bild eines Mannes. Ein solches Netzwerk kann neue Gesichter erzeugen.

Erstellen Sie mit TensorFlow einen Autoencoder

In diesem Tutorial erfahren Sie, wie Sie einen gestapelten Autoencoder erstellen, um ein Bild zu rekonstruieren.

Sie verwenden den CIFAR-10-Datensatz, der 60000 32x32-Farbbilder enthält. Der Autoencoder-Datensatz ist bereits zwischen 50000 Bildern für das Training und 10000 zum Testen aufgeteilt. Es gibt bis zu zehn Klassen:

  • Flugzeug
  • Automobil
  • Vogel
  • Katze
  • Hirsch
  • Hund
  • Frosch
  • Pferd
  • Schiff
  • Lastwagen

Sie müssen die Bilder unter dieser URL https://www.cs.toronto.edu/~kriz/cifar.html herunterladen und entpacken. Der Ordner für-10-Batches-Py enthält fünf Datenstapel mit jeweils 10000 Bildern in zufälliger Reihenfolge.

Bevor Sie Ihr Modell erstellen und trainieren, müssen Sie eine gewisse Datenverarbeitung anwenden. Sie werden wie folgt vorgehen:

  1. Importieren Sie die Daten
  2. Konvertieren Sie die Daten in das Schwarzweißformat
  3. Fügen Sie alle Stapel hinzu
  4. Erstellen Sie den Trainingsdatensatz
  5. Erstellen Sie einen Bildvisualisierer

Bildvorverarbeitung

Schritt 1) Importieren Sie die Daten.

Laut der offiziellen Website können Sie die Daten mit dem folgenden Code hochladen. Der Autoencoder-Code lädt die Daten mit den Daten und der Bezeichnung in ein Wörterbuch . Beachten Sie, dass der Code eine Funktion ist.

import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict

Schritt 2) Konvertieren Sie die Daten in das Schwarzweißformat

Der Einfachheit halber konvertieren Sie die Daten in eine Graustufe. Das heißt, mit nur einer Dimension gegen drei für Farbbilder. Der größte Teil des neuronalen Netzwerks funktioniert nur mit einer eindimensionalen Eingabe.

def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Schritt 3) Fügen Sie alle Stapel hinzu

Nachdem beide Funktionen erstellt und das Dataset geladen wurden, können Sie eine Schleife schreiben, um die Daten im Speicher anzuhängen. Wenn Sie dies sorgfältig prüfen, heißt die Entpackungsdatei mit den Daten data_batch_ mit einer Nummer von 1 bis 5. Sie können die Dateien durchlaufen und an Daten anhängen.

Wenn dieser Schritt abgeschlossen ist, konvertieren Sie die Farbdaten in ein Graustufenformat. Wie Sie sehen können, beträgt die Form der Daten 50000 und 1024. Die 32 * 32 Pixel sind jetzt auf 2014 abgeflacht.

# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)

Hinweis: Ändern Sie './cifar-10-batches-py/data_batch_' in den tatsächlichen Speicherort Ihrer Datei. Für Windows-Computer könnte der Pfad beispielsweise Dateiname = 'E: \ cifar-10-batches-py \ data_batch_' + str (i) sein.

Schritt 4) Erstellen Sie den Trainingsdatensatz

Um das Training schneller und einfacher zu machen, trainieren Sie ein Modell nur auf den Pferdebildern. Die Pferde sind die siebte Klasse in den Etikettendaten. Wie in der Dokumentation des CIFAR-10-Datensatzes erwähnt, enthält jede Klasse 5000 Bilder. Sie können die Form der Daten drucken, um zu bestätigen, dass 5.000 Bilder mit 1024 Spalten vorhanden sind, wie im folgenden Beispielschritt für den TensorFlow-Autoencoder gezeigt.

horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)

Schritt 5) Erstellen Sie einen Bildvisualisierer

Schließlich konstruieren Sie eine Funktion zum Zeichnen der Bilder. Sie benötigen diese Funktion, um das rekonstruierte Bild vom Autoencoder zu drucken.

Eine einfache Möglichkeit, Bilder zu drucken, besteht darin, das Objekt imshow aus der matplotlib-Bibliothek zu verwenden. Beachten Sie, dass Sie die Form der Daten von 1024 in 32 * 32 (dh das Format eines Bildes) konvertieren müssen.

# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")

Die Funktion benötigt 3 Argumente:

  • Bild: die Eingabe
  • Form: Liste, die Dimension des Bildes
  • Cmap: Wählen Sie die Farbkarte. Standardmäßig grau

Sie können versuchen, das erste Bild im Datensatz zu zeichnen. Sie sollten einen Mann auf einem Pferd sehen.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Set Dataset Estimator

Nun, da der Datensatz einsatzbereit ist, können Sie mit der Verwendung von Tensorflow beginnen. Bevor Sie das Modell erstellen, verwenden wir den Datensatzschätzer von Tensorflow, um das Netzwerk zu versorgen.

Sie erstellen einen Datensatz mit dem TensorFlow-Schätzer. Um Ihren Geist zu erfrischen, müssen Sie Folgendes verwenden:

  • from_tensor_slices
  • wiederholen
  • Stapel

Der vollständige Code zum Erstellen des Datensatzes lautet:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Beachten Sie, dass x ein Platzhalter mit der folgenden Form ist:

  • [None, n_inputs]: Auf None setzen, da die Anzahl der Image-Feeds zum Netzwerk der Stapelgröße entspricht.

Einzelheiten finden Sie im Tutorial zur linearen Regression.

Danach müssen Sie den Iterator erstellen. Ohne diese Codezeile werden keine Daten durch die Pipeline geleitet.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Nachdem die Pipeline fertig ist, können Sie überprüfen, ob das erste Bild das gleiche wie zuvor ist (dh ein Mann auf einem Pferd).

Sie setzen die Stapelgröße auf 1, da Sie den Datensatz nur mit einem Bild füttern möchten. Sie können die Dimension der Daten mit print (sess.run (features) .shape) anzeigen. Es ist gleich (1, 1024). 1 bedeutet, dass jeweils nur ein Bild mit 1024 eingezogen wird. Wenn die Stapelgröße auf zwei festgelegt ist, werden zwei Bilder durch die Pipeline geleitet. (Ändern Sie nicht die Stapelgröße. Andernfalls wird ein Fehler ausgegeben. Es kann jeweils nur ein Bild zur Funktion plot_image () wechseln.

## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)

Bauen Sie das Netzwerk auf

Es ist Zeit, das Netzwerk aufzubauen. Sie trainieren einen gestapelten Autoencoder, dh ein Netzwerk mit mehreren versteckten Ebenen.

Ihr Netzwerk verfügt über eine Eingabeebene mit 1024 Punkten, dh 32 x 32, der Form des Bildes.

Der Encoderblock hat eine obere verborgene Schicht mit 300 Neuronen, eine zentrale Schicht mit 150 Neuronen. Der Decoderblock ist symmetrisch zum Encoder. Sie können das Netzwerk im Bild unten visualisieren. Beachten Sie, dass Sie die Werte von ausgeblendeten und zentralen Ebenen ändern können.

Aufbau des Netzwerks für Autoencoder

Das Erstellen eines Autoencoders ist jedem anderen Deep-Learning-Modell sehr ähnlich.

Sie erstellen das Modell folgendermaßen:

  1. Definieren Sie die Parameter
  2. Definieren Sie die Ebenen
  3. Definieren Sie die Architektur
  4. Definieren Sie die Optimierung
  5. Führen Sie das Modell aus
  6. Bewerten Sie das Modell

Im vorherigen Abschnitt haben Sie gelernt, wie Sie eine Pipeline erstellen, um das Modell zu versorgen. Sie müssen das Dataset also nicht erneut erstellen. Sie erstellen einen Autoencoder mit vier Schichten. Sie verwenden die Xavier-Initialisierung. Dies ist eine Technik, um die Anfangsgewichte gleich der Varianz sowohl der Eingabe als auch der Ausgabe zu setzen. Schließlich verwenden Sie die Elu-Aktivierungsfunktion. Sie regulieren die Verlustfunktion mit dem L2-Regularizer.

Schritt 1) Definieren Sie die Parameter

Der erste Schritt beinhaltet die Definition der Anzahl von Neuronen in jeder Schicht, der Lernrate und des Hyperparameters des Regularisierers.

Zuvor importieren Sie die Funktion teilweise. Es ist eine bessere Methode, die Parameter der dichten Schichten zu definieren. Der folgende Code definiert die Werte der Autoencoder-Architektur. Wie zuvor aufgeführt, besteht der Autoencoder aus zwei Schichten mit 300 Neuronen in den ersten Schichten und 150 in den zweiten Schichten. Ihre Werte werden in n_hidden_1 und n_hidden_2 gespeichert.

Sie müssen die Lernrate und den L2-Hyperparameter definieren. Die Werte werden in learning_rate und l2_reg gespeichert

from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001

Die Xavier-Initialisierungstechnik wird mit dem Objekt xavier_initializer vom Schätzer Contrib aufgerufen. Im selben Schätzer können Sie den Regularizer mit l2_regularizer hinzufügen

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Schritt 2) Definieren Sie die Ebenen

Alle Parameter der dichten Schichten wurden eingestellt; Sie können alles in die Variable dens_layer packen, indem Sie das Objekt partiell verwenden. dens_layer, das die ELU-Aktivierung, Xavier-Initialisierung und L2-Regularisierung verwendet.

## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)

Schritt 3) Definieren Sie die Architektur

Wenn Sie sich das Bild der Architektur ansehen, stellen Sie fest, dass das Netzwerk drei Schichten mit einer Ausgabeschicht stapelt. Im folgenden Code verbinden Sie die entsprechenden Ebenen. Beispielsweise berechnet die erste Schicht das Punktprodukt zwischen den Eingabematrizenmerkmalen und den Matrizen, die die 300 Gewichte enthalten. Nachdem das Punktprodukt berechnet wurde, geht die Ausgabe an die Elu-Aktivierungsfunktion. Die Ausgabe wird zur Eingabe der nächsten Ebene. Deshalb verwenden Sie sie, um hidden_2 usw. zu berechnen. Die Matrizenmultiplikation ist für jede Ebene gleich, da Sie dieselbe Aktivierungsfunktion verwenden. Beachten Sie, dass die letzte Ebene, die Ausgabe, keine Aktivierungsfunktion anwendet. Dies ist sinnvoll, da dies die rekonstruierte Eingabe ist

## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)

Schritt 4) Definieren Sie die Optimierung

Der letzte Schritt besteht darin, den Optimierer zu erstellen. Sie verwenden den Mean Square Error als Verlustfunktion. Wenn Sie sich an das Lernprogramm zur linearen Regression erinnern, wissen Sie, dass die MSE mit der Differenz zwischen der vorhergesagten Ausgabe und der tatsächlichen Bezeichnung berechnet wird. Hier ist die Beschriftung das Merkmal, da das Modell versucht, die Eingabe zu rekonstruieren. Daher möchten Sie den Mittelwert der Summe der Differenz des Quadrats zwischen vorhergesagter Ausgabe und Eingabe. Mit TensorFlow können Sie die Verlustfunktion wie folgt codieren:

loss = tf.reduce_mean(tf.square(outputs - features))

Dann müssen Sie die Verlustfunktion optimieren. Sie verwenden den Adam-Optimierer, um die Verläufe zu berechnen. Die Zielfunktion besteht darin, den Verlust zu minimieren.

## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Noch eine Einstellung vor dem Training des Modells. Sie möchten eine Stapelgröße von 150 verwenden, dh die Pipeline mit 150 Bildern pro Iteration versorgen. Sie müssen die Anzahl der Iterationen manuell berechnen. Dies ist trivial zu tun:

Wenn Sie jedes Mal 150 Bilder übergeben möchten und wissen, dass der Datensatz 5000 Bilder enthält, entspricht die Anzahl der Iterationen. In Python können Sie die folgenden Codes ausführen und sicherstellen, dass die Ausgabe 33 ist:

BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

Schritt 5) Führen Sie das Modell aus

Zu guter Letzt trainieren Sie das Modell. Sie trainieren das Modell mit 100 Epochen. Das heißt, das Modell sieht das 100-fache der Bilder mit optimierten Gewichten.

Sie kennen bereits die Codes zum Trainieren eines Modells in Tensorflow. Der kleine Unterschied besteht darin, die Daten vor dem Ausführen des Trainings weiterzuleiten. Auf diese Weise trainiert das Modell schneller.

Sie möchten den Verlust nach zehn Epochen drucken, um festzustellen, ob das Modell etwas lernt (dh der Verlust nimmt ab). Das Training dauert je nach Hardware der Maschine 2 bis 5 Minuten.

## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt

Schritt 6) Bewerten Sie das Modell

Nachdem Sie Ihr Modell trainiert haben, ist es Zeit, es zu bewerten. Sie müssen den Test-Sert aus der Datei / cifar-10-batches-py / importieren.

test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])

HINWEIS: Auf einem Windows-Computer lautet der Code test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch").

Sie können versuchen, die Bilder 13 zu drucken, bei denen es sich um ein Pferd handelt

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Um das Modell auszuwerten, verwenden Sie den Pixelwert dieses Bildes und prüfen, ob der Encoder nach dem Verkleinern von 1024 Pixeln dasselbe Bild rekonstruieren kann. Beachten Sie, dass Sie eine Funktion definieren, um das Modell auf verschiedenen Bildern auszuwerten. Das Modell sollte nur bei Pferden besser funktionieren.

Die Funktion akzeptiert zwei Argumente:

  • df: Importieren Sie die Testdaten
  • image_number: Geben Sie an, welches Bild importiert werden soll

Die Funktion ist in drei Teile gegliedert:

  1. Formen Sie das Bild auf die richtige Größe um, dh 1, 1024
  2. Füttere das Modell mit dem unsichtbaren Bild, codiere / decodiere das Bild
  3. Drucken Sie das reale und rekonstruierte Bild
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()

Nachdem die Auswertungsfunktion definiert wurde, können Sie sich die rekonstruierte Bildnummer 13 ansehen

reconstruct_image(df =test_x, image_number = 13) 
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

Zusammenfassung

Der Hauptzweck eines Autoencoders besteht darin, die Eingabedaten zu komprimieren und sie dann in eine Ausgabe zu dekomprimieren, die den Originaldaten sehr ähnlich sieht.

Die Architektur eines Autoencoders, der symmetrisch zu einer Pivot-Schicht ist, die als zentrale Schicht bezeichnet wird.

Sie können den Autoencoder erstellen mit:

  • Teilweise: um die dichten Schichten mit der typischen Einstellung zu erstellen:
  • tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
  • dens_layer (): um die Matrixmultiplikation durchzuführen

Sie können die Verlustfunktion und die Optimierung definieren mit:

loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

Führen Sie zuletzt eine Sitzung aus, um das Modell zu trainieren.