Latente Merkmale des Variational Autoencoder (VAE).
Ich bin neu bei DL und arbeite an VAE für biomedizinische Bilder. Ich muss relevante Merkmale aus dem CT-Scan extrahieren. Also habe ich zuerst einen Autoencoder erstellt und danach einen VAE. Mein Zweifel ist, dass ich nicht weiß, aus welcher Schicht ich Merkmale extrahieren kann. Meine persönliche Idee ist es, Merkmale zu verwenden, die von Schichten extrahiert wurden, die den Mittelwert und die Varianz berechnen (vor dem Neuparametrierungstrick), aber ich denke, dass auch die Schicht davor für den Zweck geeignet ist. Ich habe hier den Code des Encoder-Teils hinterlassen:
class Sampling(tf.keras.layers.Layer):
"""Uses (z_mean, z_log_var) to sample z, the vector encoding a digit."""
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = tf.keras.backend.random_normal(shape=(batch, dim))
return z_mean + tf.exp(0.5 * z_log_var) * epsilon
def Encoder():
inp = tf.keras.Input(shape=(32,256,256,1)) # prima era 64
#enc = tf.keras.layers.Conv3D(8, (2,2,2), activation = 'relu', padding = 'same')(inp)
#enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same')(enc)
enc = tf.keras.layers.Conv3D(16, (2,2,2), activation = 'relu', padding = 'same')(inp)
enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same')(enc)
enc = tf.keras.layers.Conv3D(32, (2,2,2), activation = 'relu', padding = 'same')(enc)
enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same')(enc)
enc = tf.keras.layers.Conv3D(64, (2,2,2), activation = 'relu', padding = 'same')(enc)
enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same') (enc)
enc = tf.keras.layers.Conv3D(32, (2,2,2), activation = 'relu', padding = 'same')(enc)
enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same') (enc)
#enc = tf.keras.layers.Flatten()(enc)
enc = tf.keras.layers.Conv3D(16, (2,2,2), activation = 'relu', padding = 'same')(enc)
enc = tf.keras.layers.MaxPooling3D((2,2,2), padding = 'same') (enc)
'''
# conv 2D
code = tf.keras.layers.Reshape((8,8,96)) (enc)
code = tf.keras.layers.Conv2D(96,(2,2), activation = 'relu', padding = 'same')(code)
code = tf.keras.layers.MaxPooling2D((2,2), padding = 'same') (code)
'''
# latentent code vae
latent_code = tf.keras.layers.Flatten()(enc)
latent_code = tf.keras.layers.Dense(256, activation='relu')(latent_code)
latent_mu = tf.keras.layers.Dense(32, activation='relu')(latent_code) # èprima era 10
latent_sigma = tf.keras.layers.Dense(32, activation='relu')(latent_code) # prima era 10
# Reparameterization trick
#z = tf.keras.layers.Lambda(sample_z, output_shape=(128,), name='z')([latent_mu, latent_sigma])
z = Sampling()([latent_mu, latent_sigma])
encoder = tf.keras.Model(inp, [latent_mu, latent_sigma, z ], name = 'encoder')
#encoder = tf.keras.Model(inp, enc)#[latent_mu, latent_sigma, z ], name = 'encoder')
return encoder
```
Antworten
Die früheren Schichten des neuronalen Netzwerks lernen mehr Funktionen auf niedriger Ebene, während tiefere Schichten kompliziertere, abstrakte Funktionen lernen (siehe Abbildung von Albawi et al., 2017 ).
Autoencoder bestehen aus zwei Netzwerken , einem Encoder , der die Daten in Bezug auf einige latente Variablen (normalerweise von geringerer Dimensionalität, daher können sie zur Dimensionsreduktion verwendet werden ) und einem Decoder , der die latente Darstellung zurück in die ursprüngliche Darstellung der Daten umwandelt, codiert.
Sie können je nach Bedarf eine beliebige Ebene aus Autoencoder verwenden. Da Autoencoder normalerweise symmetrisch sind, würden Sie normalerweise zur Feature-Generierung Schichten aus dem Encoder oder seiner Ausgabe nehmen. Wenn Sie den Autoencoder zur Reduzierung der Dimensionalität verwenden möchten, nehmen Sie lieber die Ausgabe des Encoders mit der kleineren Dimension (siehe Abbildung unten aus dem Artikel von Windrim et al., 2019 ).
Andererseits könnten Sie den Autoencoder genauso wie jedes andere neuronale Netzwerk zum Transferlernen verwenden . In einem solchen Fall würden Sie den Autoencoder trainieren und dann einige Schichten davon als Features für andere Algorithmen extrahieren. Wenn Sie in einem solchen Fall Funktionen auf niedrigerer Ebene wünschen, würden Sie frühere Ebenen verwenden. Wenn Sie abstraktere Merkmale wünschen, würden Sie höhere Schichten nehmen.
Unter Verwendung des Beispiels aus dem ersten Bild würden Sie die erste Netzwerkschicht nehmen, die auf menschlichen Gesichtern trainiert wurde, und sie zum Extrahieren einiger grundlegender Formen und Kanten aus anderen Bildern als menschlichen Gesichtern verwenden. Wenn Sie andererseits Gesichter erkennen müssten, würden Sie tiefere Schichten des Netzwerks nehmen.
Ergänzend zur ausführlichen Antwort von @Tim:
VAE z latent ist stochastisch z, was bedeutet, dass Proben für ein und dasselbe unterschiedlich sein werden$x_i$Probe. Im Idealfall ist Ihre latente Repräsentation ($\mu$oder z) aussagekräftige Informationen enthalten, diese würde ich extrahieren (übrigens in Tensorflow können Sie mehrere Schichten extrahieren ;) ).$\sigma$wird eingerichtet, um als Rauschkomponente zu wirken.
Um sicherzustellen, dass das, was Sie extrahieren, nützlich ist, können Sie einen Interpretierbarkeitstest durchführen.
Die Eingabefunktionen der Ct-Scans sind die Pixel, die Sie haben, ABER gibt es andere Informationen, die Sie nicht verwenden? Da Sie zum Beispiel keine eindeutigen Bezeichnungen angeben, haben Sie ein Scan-Bild eines kranken Patienten? Oder könnten Sie 10 Bilder mit einem bestimmten Merkmal von Hand auswählen, um ein wenig zu interpretieren, welche Neuronen im latenten Raum ausgelöst werden? Wenn ja, was Sie tun können, ist ein Korrelationstest. Dies kann so einfach sein wie Neyman Pearson oder ein 2D-Histogramm, das zeigt, wie korrelierte Merkmale sind. Was Sie in diesem Fall erreichen möchten, ist ein gewisses Gefühl dafür, was aus dem Modell zur Entscheidung verwendet wird.
Leider ist dies für Katzen/Dokumente einfach und für komplexere Datensätze schwieriger, aber Sie müssen dies tun, um keine Blackbox-Maschine zu haben. Viel Glück!