Estrazione delle funzionalità del codificatore automatico per la regressione

L'autoencoder è un tipo di rete neurale che può essere utilizzata per apprendere una rappresentazione compressa di dati grezzi.

Un autoencoder è composto da sottomodelli di codificatore e decodificatore. Il codificatore comprime l'input e il decodificatore tenta di ricreare l'input dalla versione compressa fornita dal codificatore. Dopo l'addestramento, il modello del codificatore viene salvato e il decodificatore viene scartato.

Il codificatore può quindi essere utilizzato come tecnica di preparazione dei dati per eseguire l'estrazione di funzionalità su dati grezzi che possono essere utilizzati per addestrare un diverso modello di machine learning.

In questo tutorial scoprirai come sviluppare e valutare un codificatore automatico per la predizione della regressione

Dopo aver completato questo tutorial, saprai:

• Un codificatore automatico è un modello di rete neurale che può essere utilizzato per apprendere una rappresentazione compressa di dati grezzi.
• Come addestrare un modello di codifica automatica su un set di dati di addestramento e salvare solo la parte codificatrice del modello.
• Come utilizzare il codificatore come fase di preparazione dei dati durante l'addestramento di un modello di machine learning.

Cominciamo.

Panoramica dell'esercitazione

Questo tutorial è diviso in tre parti; sono:

1. Codificatori automatici per l'estrazione di funzionalità
2. Codificatore automatico per la regressione
3. Codificatore automatico come preparazione dei dati

Codificatori automatici per l'estrazione di funzionalità

Un autocodificatore è un modello di rete neurale che cerca di apprendere una rappresentazione compressa di un input.

Un codificatore automatico è una rete neurale addestrata a tentare di copiare il proprio input nel proprio output.

— Pagina 502, Apprendimento profondo, 2016.

Sono un metodo di apprendimento non supervisionato, anche se tecnicamente vengono formati utilizzando metodi di apprendimento supervisionato, denominati autosupervisionati. In genere vengono addestrati come parte di un modello più ampio che tenta di ricreare l'input.

Per esempio:

• X=modello.prevedere(X)

La progettazione del modello di codifica automatica rende volutamente questo compito impegnativo limitando l'architettura a un collo di bottiglia nel punto centrale del modello, da cui viene eseguita la ricostruzione dei dati di input.

Esistono molti tipi di codificatori automatici e il loro utilizzo varia, ma forse l'uso più comune è come modello di estrazione di funzionalità apprese o automatiche.

In questo caso, una volta adattato il modello, è possibile scartare l'aspetto ricostruttivo del modello e utilizzare il modello fino al punto del collo di bottiglia. L'output del modello in corrispondenza del collo di bottiglia è un vettore di lunghezza fissa che fornisce una rappresentazione compressa dei dati di input.

Di solito sono limitati in modo da consentire loro di copiare solo approssimativamente e di copiare solo l'input che assomiglia ai dati di training. Poiché il modello è costretto a stabilire la priorità degli aspetti dell'input da copiare, spesso apprende proprietà utili dei dati.

— Pagina 502, Apprendimento profondo, 2016.

I dati di input dal dominio possono quindi essere forniti al modello e l'output del modello al collo di bottiglia può essere utilizzato come vettore di caratteristiche in un modello di apprendimento supervisionato, per la visualizzazione o, più in generale, per la riduzione della dimensionalità.

Successivamente, esploriamo come potremmo sviluppare un codificatore automatico per l'estrazione di caratteristiche su un problema di modellazione predittiva di regressione.

Codificatore automatico per la regressione

In questa sezione svilupperemo un codificatore automatico per apprendere una rappresentazione compressa delle caratteristiche di input per un problema di modellazione predittiva di regressione.

Innanzitutto, definiamo un problema di modellazione predittiva di regressione.

Utilizzeremo la funzione make_regression() scikit-learn per definire un'attività di regressione sintetica con 100 funzionalità di input (colonne) e 1.000 esempi (righe). È importante sottolineare che definiremo il problema in modo tale che la maggior parte delle variabili di input siano ridondanti (90 su 100 o 90%), consentendo successivamente all'autocodificatore di apprendere un'utile rappresentazione compressa.

L'esempio seguente definisce il set di dati e ne riassume la forma.

# synthetic regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

L'esecuzione dell'esempio definisce il set di dati e stampa la forma degli array, confermando il numero di righe e colonne.

(1000, 100) (1000,)

Successivamente, svilupperemo un modello di codifica automatica Multilayer Perceptron (MLP).

Il modello prenderà tutte le colonne di input, quindi restituirà gli stessi valori. Imparerà a ricreare esattamente il modello di input.

L'autoencoder è composto da due parti: l'encoder e il decoder. Il codificatore impara come interpretare l'input e comprimerlo in una rappresentazione interna definita dallo strato del collo di bottiglia. Il decodificatore prende l'output del codificatore (lo strato del collo di bottiglia) e tenta di ricreare l'input.

Una volta addestrato l'autocodificatore, la decodifica viene scartata e manteniamo solo il codificatore e lo utilizziamo per comprimere esempi di input in vettori di output dallo strato del collo di bottiglia.

In questo primo codificatore automatico, non comprimeremo affatto l'input e utilizzeremo uno strato di collo di bottiglia della stessa dimensione dell'input. Dovrebbe trattarsi di un problema semplice che il modello apprenderà quasi perfettamente e ha lo scopo di confermare che il nostro modello è implementato correttamente.

Definiremo il modello utilizzando l'API funzionale. Se ti è nuovo, ti consiglio questo tutorial:

• Come utilizzare l'API funzionale Keras per il deep learning

Prima di definire e adattare il modello, divideremo i dati in set di training e test e scaleremo i dati di input normalizzando i valori nell'intervallo 0-1, una buona pratica con gli MLP.

...
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)

Definiremo il codificatore in modo che abbia un livello nascosto con lo stesso numero di nodi presenti nei dati di input con normalizzazione batch e attivazione ReLU.

Questo è seguito da uno strato di collo di bottiglia con lo stesso numero di nodi quante sono le colonne nei dati di input, ad es. nessuna compressione.

...
# define encoder
visible = Input(shape=(n_inputs,))
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = ReLU()(e)
# define bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)

Il decoder sarà definito con la stessa struttura.

Avrà un livello nascosto con normalizzazione batch e attivazione ReLU. Il livello di output avrà lo stesso numero di nodi quante sono le colonne nei dati di input e utilizzerà una funzione di attivazione lineare per restituire valori numerici.

...
# define decoder
d = Dense(n_inputs*2)(bottleneck)
d = BatchNormalization()(d)
d = ReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')

Il modello sarà adattato utilizzando la versione efficiente di Adam della discesa del gradiente stocastico e minimizzerà l'errore quadratico medio, dato che la ricostruzione è un tipo di problema di regressione multi-uscita.

...
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')

Possiamo tracciare i livelli nel modello di codifica automatica per avere un'idea di come i dati fluiscono attraverso il modello.

...
# plot the autoencoder
plot_model(model, 'autoencoder.png', show_shapes=True)

L'immagine seguente mostra un grafico dell'autoencoder.

Successivamente, possiamo addestrare il modello a riprodurre l'input e tenere traccia delle prestazioni del modello sul set di test di controllo. Il modello è addestrato per 400 epoche e una dimensione batch di 16 esempi.

...
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=400, batch_size=16, verbose=2, validation_data=(X_test,X_test))

Dopo l'addestramento, possiamo tracciare le curve di apprendimento per il treno e i set di test per confermare che il modello ha appreso bene il problema di ricostruzione.

...
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()

Infine, se lo desideriamo, possiamo salvare il modello dell'encoder per utilizzarlo in seguito.

...
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

Come parte del salvataggio del codificatore, tracceremo anche il modello per avere un'idea della forma dell'output dello strato del collo di bottiglia, ad es. un vettore di 100 elementi.

Un esempio di questo grafico è fornito di seguito.

Mettendo insieme tutto questo, di seguito è elencato l'esempio completo di un codificatore automatico per ricostruire i dati di input per un set di dati di regressione senza alcuna compressione nello strato del collo di bottiglia.

# train autoencoder for regression with no compression in the bottleneck layer
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import ReLU
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import plot_model
from matplotlib import pyplot
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# number of input columns
n_inputs = X.shape[1]
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# scale data
t = MinMaxScaler()
t.fit(X_train)
X_train = t.transform(X_train)
X_test = t.transform(X_test)
# define encoder
visible = Input(shape=(n_inputs,))
e = Dense(n_inputs*2)(visible)
e = BatchNormalization()(e)
e = ReLU()(e)
# define bottleneck
n_bottleneck = n_inputs
bottleneck = Dense(n_bottleneck)(e)
# define decoder
d = Dense(n_inputs*2)(bottleneck)
d = BatchNormalization()(d)
d = ReLU()(d)
# output layer
output = Dense(n_inputs, activation='linear')(d)
# define autoencoder model
model = Model(inputs=visible, outputs=output)
# compile autoencoder model
model.compile(optimizer='adam', loss='mse')
# plot the autoencoder
plot_model(model, 'autoencoder.png', show_shapes=True)
# fit the autoencoder model to reconstruct input
history = model.fit(X_train, X_train, epochs=400, batch_size=16, verbose=2, validation_data=(X_test,X_test))
# plot loss
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()
# define an encoder model (without the decoder)
encoder = Model(inputs=visible, outputs=bottleneck)
plot_model(encoder, 'encoder.png', show_shapes=True)
# save the encoder to file
encoder.save('encoder.h5')

L'esecuzione dell'esempio si adatta al modello e segnala le perdite sul treno e sui set di test lungo il percorso.

Nota: se hai problemi nella creazione dei grafici del modello, puoi commentare l'importazione e chiamare la funzione plot_model().

Nota: i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione o delle differenze nella precisione numerica. Considera l'idea di eseguire l'esempio alcune volte e confrontare il risultato medio.

In questo caso, vediamo che la perdita diminuisce ma non va a zero (come ci saremmo aspettati) senza compressione nello strato del collo di bottiglia. Forse è necessaria un'ulteriore messa a punto dell'architettura del modello o l'apprendimento degli iperparametri.

...
Epoch 393/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0024
Epoch 394/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0021
Epoch 395/400
42/42 - 0s - loss: 0.0023 - val_loss: 0.0021
Epoch 396/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0023
Epoch 397/400
42/42 - 0s - loss: 0.0024 - val_loss: 0.0022
Epoch 398/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0021
Epoch 399/400
42/42 - 0s - loss: 0.0026 - val_loss: 0.0022
Epoch 400/400
42/42 - 0s - loss: 0.0025 - val_loss: 0.0024

Viene creato un grafico delle curve di apprendimento che mostra che il modello raggiunge un buon adattamento nella ricostruzione dell'input, che rimane stabile durante tutta la formazione, senza adattarsi eccessivamente.

Fin qui tutto bene. Sappiamo come sviluppare un codificatore automatico senza compressione.

Il codificatore addestrato viene salvato nel file “encoder.h5” che possiamo caricare e utilizzare in seguito.

Successivamente, esploriamo come potremmo utilizzare il modello di codificatore addestrato.

Codificatore automatico come preparazione dei dati

In questa sezione utilizzeremo il modello di codificatore addestrato dal modello di codificatore automatico per comprimere i dati di input e addestrare un modello predittivo diverso.

Innanzitutto, stabiliamo una linea di base per le prestazioni su questo problema. Questo è importante poiché se le prestazioni di un modello non vengono migliorate dalla codifica compressa, allora la codifica compressa non aggiunge valore al progetto e non dovrebbe essere utilizzata.

Possiamo addestrare un modello di regressione vettoriale di supporto (SVR) direttamente sul set di dati di addestramento e valutare le prestazioni del modello sul set di test di controllo.

Come è buona pratica, ridimensioneremo sia le variabili di input che la variabile di destinazione prima di adattare e valutare il modello.

L'esempio completo è elencato di seguito.

# baseline in performance with support vector regression model
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_absolute_error
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# reshape target variables so that we can transform them
y_train = y_train.reshape((len(y_train), 1))
y_test = y_test.reshape((len(y_test), 1))
# scale input data
trans_in = MinMaxScaler()
trans_in.fit(X_train)
X_train = trans_in.transform(X_train)
X_test = trans_in.transform(X_test)
# scale output data
trans_out = MinMaxScaler()
trans_out.fit(y_train)
y_train = trans_out.transform(y_train)
y_test = trans_out.transform(y_test)
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train, y_train)
# make prediction on test set
yhat = model.predict(X_test)
# invert transforms so we can calculate errors
yhat = yhat.reshape((len(yhat), 1))
yhat = trans_out.inverse_transform(yhat)
y_test = trans_out.inverse_transform(y_test)
# calculate error
score = mean_absolute_error(y_test, yhat)
print(score)

L'esecuzione dell'esempio adatta un modello SVR al set di dati di training e lo valuta sul set di test.

Nota: i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione o delle differenze nella precisione numerica. Considera l'idea di eseguire l'esempio alcune volte e confrontare il risultato medio.

In questo caso, possiamo vedere che il modello raggiunge un errore medio assoluto (MAE) di circa 89.

Ci auguriamo e ci aspettiamo che un modello SVR si adatti a una versione codificata dell'input per ottenere un errore inferiore affinché la codifica sia considerata utile.

89.51082036130629

Possiamo aggiornare l'esempio per codificare prima i dati utilizzando il modello di codificatore addestrato nella sezione precedente.

Innanzitutto, possiamo caricare il modello di codificatore addestrato dal file.

...
# load the model from file
encoder = load_model('encoder.h5')

Possiamo quindi utilizzare il codificatore per trasformare i dati di input grezzi (ad esempio 100 colonne) in vettori del collo di bottiglia (ad esempio 100 vettori di elementi).

Questo processo può essere applicato al training e al test dei set di dati.

...
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)

Possiamo quindi utilizzare questi dati codificati per addestrare e valutare il modello SVR, come prima.

...
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train_encode, y_train)
# make prediction on test set
yhat = model.predict(X_test_encode)

Mettendo insieme tutto questo, l'esempio completo è elencato di seguito.

# support vector regression performance with encoded input
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.svm import SVR
from sklearn.metrics import mean_absolute_error
from tensorflow.keras.models import load_model
# define dataset
X, y = make_regression(n_samples=1000, n_features=100, n_informative=10, noise=0.1, random_state=1)
# split into train test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)
# reshape target variables so that we can transform them
y_train = y_train.reshape((len(y_train), 1))
y_test = y_test.reshape((len(y_test), 1))
# scale input data
trans_in = MinMaxScaler()
trans_in.fit(X_train)
X_train = trans_in.transform(X_train)
X_test = trans_in.transform(X_test)
# scale output data
trans_out = MinMaxScaler()
trans_out.fit(y_train)
y_train = trans_out.transform(y_train)
y_test = trans_out.transform(y_test)
# load the model from file
encoder = load_model('encoder.h5')
# encode the train data
X_train_encode = encoder.predict(X_train)
# encode the test data
X_test_encode = encoder.predict(X_test)
# define model
model = SVR()
# fit model on the training dataset
model.fit(X_train_encode, y_train)
# make prediction on test set
yhat = model.predict(X_test_encode)
# invert transforms so we can calculate errors
yhat = yhat.reshape((len(yhat), 1))
yhat = trans_out.inverse_transform(yhat)
y_test = trans_out.inverse_transform(y_test)
# calculate error
score = mean_absolute_error(y_test, yhat)
print(score)

L'esecuzione dell'esempio prima codifica il set di dati utilizzando il codificatore, quindi adatta un modello SVR al set di dati di addestramento e lo valuta sul set di test.

Nota: i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione o delle differenze nella precisione numerica. Considera l'idea di eseguire l'esempio alcune volte e confrontare il risultato medio.

In questo caso, possiamo vedere che il modello raggiunge un MAE di circa 69.

Si tratta di un MAE migliore rispetto allo stesso modello valutato sul set di dati grezzi, suggerendo che la codifica è utile per il modello e il cablaggio di test scelti.

69.45890939600503

Ulteriori letture

Questa sezione fornisce più risorse sull'argomento se desideri approfondire.

Tutorial

• Una breve introduzione agli autoencoder LSTM
• Come utilizzare l'API funzionale Keras per il deep learning
• Tutorial su TensorFlow 2: inizia a utilizzare il deep learning con tf.keras

Libri

• Apprendimento profondo, 2016.

API

• API sklearn.datasets.make_regression.
• API sklearn.model_selection.train_test_split.

Articoli

• Codificatore automatico, Wikipedia.

Riepilogo

In questo tutorial hai scoperto come sviluppare e valutare un codificatore automatico per la modellazione predittiva della regressione.

Nello specifico, hai imparato:

• Un codificatore automatico è un modello di rete neurale che può essere utilizzato per apprendere una rappresentazione compressa di dati grezzi.
• Come addestrare un modello di codifica automatica su un set di dati di addestramento e salvare solo la parte codificatrice del modello.
• Come utilizzare il codificatore come fase di preparazione dei dati durante l'addestramento di un modello di machine learning.

Hai qualche domanda?
Poni le tue domande nei commenti qui sotto e farò del mio meglio per rispondere.