Cómo inicializar los pesos de un MLP utilizando un autocodificador # 2ª parte – Autoencoder profundo # 3ª parte – Autoencoder astackdo

He construido un autocodificador (1 codificador 8: 5, 1 decodificador 5: 8) que toma el conjunto de datos Pima-Indian-Diabetes ( https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes. data.csv ) y reduce su dimensión (de 8 a 5). Ahora me gustaría usar estas funciones reducidas para clasificar los datos usando un mlp. Ahora, aquí, tengo algunos problemas con la comprensión básica de la architecture. ¿Cómo uso los pesos del autocodificador y los inserto en el mlp? He comprobado estos hilos: https://github.com/keras-team/keras/issues/91 y https://www.codementor.io/nitinsurya/how-to-re-initialize-keras-model-weights- et41zre2g . La pregunta aquí es qué matriz de peso debo considerar? el de la parte del codificador o la parte del decodificador? Cuando agrego las capas para el mlp, ¿cómo puedo inicializar los pesos con estos pesos guardados, no obteniendo la syntax exacta? Además, ¿debería mi mlp comenzar con 5 neuronas ya que mi dimensión reducida es 5? ¿Cuáles son las dimensiones posibles del mlp para este problema de clasificación binaria? Si alguien pudiera elaborar por favor?

El código de autoencoder profundo es el siguiente:

# from keras.models import Sequential from keras.layers import Input, Dense from keras.models import Model from sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_split import numpy # Data pre-processing... # load pima indians dataset dataset = numpy.loadtxt("C:/Users/dibsa/Python Codes/pima.csv", delimiter=",") # split into input (X) and output (Y) variables X = dataset[:, 0:8] Y = dataset[:, 8] # Split data into training and testing datasets x_train, x_test, y_train, y_test = train_test_split( X, Y, test_size=0.2, random_state=42) # scale the data within [0-1] range scalar = MinMaxScaler() x_train = scalar.fit_transform(x_train) x_test = scalar.fit_transform(x_test) # Autoencoder code begins here... encoding_dim1 = 5 # size of encoded representations encoding_dim2 = 3 # size of encoded representations in the bottleneck layer # this is our input placeholder input_data = Input(shape=(8,)) # "encoded" is the first encoded representation of the input encoded = Dense(encoding_dim1, activation='relu', name='encoder1')(input_data) # "enc" is the second encoded representation of the input enc = Dense(encoding_dim2, activation='relu', name='encoder2')(encoded) # "dec" is the lossy reconstruction of the input dec = Dense(encoding_dim1, activation='sigmoid', name='decoder1')(enc) # "decoded" is the final lossy reconstruction of the input decoded = Dense(8, activation='sigmoid', name='decoder2')(dec) # this model maps an input to its reconstruction autoencoder = Model(inputs=input_data, outputs=decoded) autoencoder.compile(optimizer='sgd', loss='mse') # training autoencoder.fit(x_train, x_train, epochs=300, batch_size=10, shuffle=True, validation_data=(x_test, x_test)) # need more tuning # test the autoencoder by encoding and decoding the test dataset reconstructions = autoencoder.predict(x_test) print('Original test data') print(x_test) print('Reconstructed test data') print(reconstructions) #The stacked autoencoder code is as follows: # from keras.models import Sequential from keras.layers import Input, Dense from keras.models import Model from sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_split import numpy # Data pre-processing... # load pima indians dataset dataset = numpy.loadtxt("C:/Users/dibsa/Python Codes/pima.csv", delimiter=",") # split into input (X) and output (Y) variables X = dataset[:, 0:8] Y = dataset[:, 8] # Split data into training and testing datasets x_train, x_test, y_train, y_test = train_test_split( X, Y, test_size=0.2, random_state=42) # scale the data within [0-1] range scalar = MinMaxScaler() x_train = scalar.fit_transform(x_train) x_test = scalar.fit_transform(x_test) # Autoencoder code goes here... encoding_dim1 = 5 # size of encoded representations encoding_dim2 = 3 # size of encoded representations in the bottleneck layer # this is our input placeholder input_data1 = Input(shape=(8,)) # the first encoded representation of the input encoded1 = Dense(encoding_dim1, activation='relu', name='encoder1')(input_data1) # the first lossy reconstruction of the input decoded1 = Dense(8, activation='sigmoid', name='decoder1')(encoded1) # this model maps an input to its first layer of reconstructions autoencoder1 = Model(inputs=input_data1, outputs=decoded1) # this is the first encoder model enc1 = Model(inputs=input_data1, outputs=encoded1) autoencoder1.compile(optimizer='sgd', loss='mse') # training autoencoder1.fit(x_train, x_train, epochs=300, batch_size=10, shuffle=True, validation_data=(x_test, x_test)) FirstAEoutput = autoencoder1.predict(x_train) input_data2 = Input(shape=(encoding_dim1,)) # the second encoded representations of the input encoded2 = Dense(encoding_dim2, activation='relu', name='encoder2')(input_data2) # the final lossy reconstruction of the input decoded2 = Dense(encoding_dim1, activation='sigmoid', name='decoder2')(encoded2) # this model maps an input to its second layer of reconstructions autoencoder2 = Model(inputs=input_data2, outputs=decoded2) # this is the second encoder enc2 = Model(inputs=input_data2, outputs=encoded2) autoencoder2.compile(optimizer='sgd', loss='mse') # training autoencoder2.fit(FirstAEoutput, FirstAEoutput, epochs=300, batch_size=10, shuffle=True) # this is the overall autoencoder mapping an input to its final reconstructions autoencoder = Model(inputs=input_data1, outputs=encoded2) # test the autoencoder by encoding and decoding the test dataset reconstructions = autoencoder.predict(x_test) print('Original test data') print(x_test) print('Reconstructed test data') print(reconstructions) 

Muchas preguntas. ¿Qué has intentado hasta ahora? ¿Fragmentos de código?

Si su decodificador está tratando de reconstruir la entrada, entonces no tiene sentido para mí adjuntar su clasificador a su salida. Quiero decir, ¿por qué no simplemente adjuntarlo a la entrada en la primera vez? Entonces, si está configurado para usar un codificador automático, diría que está bastante claro que debe conectar su clasificador a la salida de la tubería del codificador.

No estoy muy seguro de lo que quiere decir con “use los pesos del autoencoder y aliméntelos en el mlp”. No alimenta una capa con los pesos de otra capa, sino con su señal de salida . Esto es bastante fácil de hacer en Keras. Digamos que definió su auto-codificador y lo entrenó como tal:

 from keras Input, Model from keras import backend as K from keras.layers import Dense x = Input(shape=[8]) y = Dense(5, activation='sigmoid' name='encoder')(x) y = Dense(8, name='decoder')(y) ae = Model(inputs=x, outputs=y) ae.compile(loss='mse', ...) ae.fit(x_train, x_train, ...) K.models.save_model(ae, './autoencoder.h5') 

Luego puede adjuntar una capa de clasificación en el codificador y crear un modelo de clasificador con el siguiente código:

 # load the model from the disk if you # are in a different execution. ae = K.models.load_model('./autoencoder.h5') y = ae.get_layer('encoder').output y = Dense(1, activation='sigmoid', name='predictions')(y) classifier = Model(inputs=ae.inputs, outputs=y) classifier.compile(loss='binary_crossentropy', ...) classifier.fit(x_train, y_train, ...) 

Eso es todo, de verdad. El modelo classifier tendrá ahora el primer codificador de capa de incrustación del modelo ae como su primera capa, seguido de una predicción de capa de decisión sigmoid .


Si lo que realmente está tratando de hacer es usar los pesos aprendidos por el auto-codificador para inicializar los pesos desde el clasificador (no estoy seguro, recomiendo este método):

Puede tomar las matrices de peso con la layer#get_weights , layer#get_weights (porque el codificador tiene 5 unidades y el clasificador solo tiene 1) y finalmente establecer los pesos del clasificador. Algo en las siguientes líneas:

 w, b = ae.get_layer('encoder').get_weights() # remove all units except by one. neuron_to_keep = 2 w = w[:, neuron_to_keep:neuron_to_keep + 1] b = b[neuron_to_keep:neuron_to_keep + 1] classifier.get_layer('predictions').set_weights(w, b) 

Idavid, esto es para su referencia – MLP usando características reducidas de Autoencoder . ¿Necesito entender qué figura es la correcta? Lo siento, tuve que subir la imagen como respuesta ya que no había opción de subir una imagen a través de un comentario. Creo que estás diciendo que la figura B es la correcta. Aquí está el fragmento de código para el mismo. Por favor avísame si voy bien.

 # This is a mlp classification code with features reduced by an Autoencoder # from keras.models import Sequential from keras.layers import Input, Dense from keras.models import Model from sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_split import numpy # Data pre-processing... # load pima indians dataset dataset = numpy.loadtxt("C:/Users/dibsa/Python Codes/pima.csv", delimiter=",") # split into input (X) and output (Y) variables X = dataset[:, 0:8] Y = dataset[:, 8] # Split data into training and testing datasets x_train, x_test, y_train, y_test = train_test_split( X, Y, test_size=0.2, random_state=42) # scale the data within [0-1] range scalar = MinMaxScaler() x_train = scalar.fit_transform(x_train) x_test = scalar.fit_transform(x_test) # Autoencoder code goes here... encoding_dim = 5 # size of our encoded representations # this is our input placeholder input_data = Input(shape=(8,)) # "encoded" is the encoded representation of the input encoded = Dense(encoding_dim, activation='relu', name='encoder')(input_data) # "decoded" is the lossy reconstruction of the input decoded = Dense(8, activation='sigmoid', name='decoder')(encoded) # this model maps an input to its reconstruction autoencoder = Model(inputs=input_data, outputs=decoded) autoencoder.compile(optimizer='sgd', loss='mse') # training autoencoder.fit(x_train, x_train, epochs=300, batch_size=10, shuffle=True, validation_data=(x_test, x_test)) # need more tuning # test the autoencoder by encoding and decoding the test dataset reconstructions = autoencoder.predict(x_test) print('Original test data') print(x_test) print('Reconstructed test data') print(reconstructions) # MLP code goes here... # create model x = autoencoder.get_layer('encoder').output # h = Dense(3, activation='relu', name='hidden')(x) y = Dense(1, activation='sigmoid', name='predictions')(x) classifier = Model(inputs=autoencoder.inputs, outputs=y) # Compile model classifier.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Fit the model classifier.fit(x_train, y_train, epochs=250, batch_size=10) print('Now making predictions') predictions = classifier.predict(x_test) # round predictions rounded_predicted_classes = [round(x[0]) for x in predictions] temp = sum(y_test == rounded_predicted_classes) acc = temp/len(y_test) print(acc)