CNTK - Modello di regressione

Qui studieremo la misurazione delle prestazioni rispetto a un modello di regressione.

Nozioni di base sulla convalida di un modello di regressione

Come sappiamo, i modelli di regressione sono diversi dai modelli di classificazione, nel senso che non esiste una misura binaria di giusto o sbagliato per i campioni individuali. Nei modelli di regressione, vogliamo misurare quanto la previsione è vicina al valore effettivo. Più il valore di previsione è vicino all'output previsto, migliori saranno le prestazioni del modello.

Qui, misureremo le prestazioni di NN utilizzato per la regressione utilizzando diverse funzioni di tasso di errore.

Calcolo del margine di errore

Come discusso in precedenza, durante la convalida di un modello di regressione, non possiamo dire se una previsione è giusta o sbagliata. Vogliamo che la nostra previsione sia il più vicino possibile al valore reale. Ma qui è accettabile un piccolo margine di errore.

La formula per calcolare il margine di errore è la seguente:

Qui,

Predicted value = indicato y da un cappello

Real value = previsto da y

Innanzitutto, dobbiamo calcolare la distanza tra il valore previsto e il valore reale. Quindi, per ottenere un tasso di errore complessivo, dobbiamo sommare queste distanze al quadrato e calcolare la media. Questo è chiamatomean squared funzione di errore.

Ma, se vogliamo dati sulle prestazioni che esprimano un margine di errore, abbiamo bisogno di una formula che esprima l'errore assoluto. La formula permean absolute la funzione di errore è la seguente:

La formula sopra prende la distanza assoluta tra il valore previsto e il valore reale.

Utilizzo di CNTK per misurare le prestazioni di regressione

Qui, vedremo come utilizzare le diverse metriche, abbiamo discusso in combinazione con CNTK. Useremo un modello di regressione, che prevede miglia per gallone per le auto utilizzando i passaggi indicati di seguito.

Fasi di implementazione -

Step 1 - Innanzitutto, dobbiamo importare i componenti richiesti da cntk pacchetto come segue -

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu

Step 2 - Successivamente, dobbiamo definire una funzione di attivazione predefinita utilizzando il file default_optionsfunzioni. Quindi, crea un nuovo set di livelli sequenziali e fornisci due livelli densi con 64 neuroni ciascuno. Quindi, aggiungiamo un ulteriore livello Denso (che fungerà da livello di output) al set di livelli sequenziali e forniamo 1 neurone senza attivazione come segue:

with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])

Step 3- Una volta creata la rete, dobbiamo creare una funzione di input. Dobbiamo assicurarci che abbia la stessa forma delle caratteristiche che useremo per l'allenamento.

features = input_variable(X.shape[1])

Step 4 - Ora, dobbiamo crearne un altro input_variable con dimensione 1. Verrà utilizzato per memorizzare il valore atteso per NN.

target = input_variable(1)
z = model(features)

Ora, dobbiamo addestrare il modello e per farlo, suddivideremo il set di dati ed eseguiremo la preelaborazione utilizzando i seguenti passaggi di implementazione:

Step 5−In primo luogo, importa StandardScaler da sklearn.preprocessing per ottenere i valori compresi tra -1 e +1. Questo ci aiuterà a contrastare i problemi di gradiente esplosivo in NN.

from sklearn.preprocessing import StandardScalar

Step 6 - Successivamente, importa train_test_split da sklearn.model_selection come segue -

from sklearn.model_selection import train_test_split

Step 7 - Lascia cadere il file mpg colonna dal set di dati utilizzando il dropmetodo. Infine, dividere il set di dati in un set di addestramento e convalida utilizzando iltrain_test_split funzionare come segue:

x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Step 8 - Ora, dobbiamo creare un'altra input_variable con dimensione 1. Verrà utilizzata per memorizzare il valore atteso per NN.

target = input_variable(1)
z = model(features)

Abbiamo suddiviso e preelaborato i dati, ora dobbiamo addestrare NN. Come nelle sezioni precedenti durante la creazione del modello di regressione, dobbiamo definire una combinazione di una perdita emetric funzione per addestrare il modello.

import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
   loss = squared_error(output, target)
   metric = absolute_error(output, target)
   return loss, metric

Ora, diamo un'occhiata a come utilizzare il modello addestrato. Per il nostro modello, useremo criterio_fattoria come combinazione di perdita e metrica.

from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

Esempio di implementazione completo

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu
with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])
features = input_variable(X.shape[1])
target = input_variable(1)
z = model(features)
from sklearn.preprocessing import StandardScalar
from sklearn.model_selection import train_test_split
x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
target = input_variable(1)
z = model(features)
import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
loss = squared_error(output, target)
metric = absolute_error(output, target)
return loss, metric
from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

Produzione

-------------------------------------------------------------------
average  since   average   since  examples
loss     last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.001
690       690     24.9     24.9       16
654       636     24.1     23.7       48
[………]

Per convalidare il nostro modello di regressione, dobbiamo assicurarci che il modello gestisca i nuovi dati esattamente come fa con i dati di addestramento. Per questo, dobbiamo invocare iltest metodo loss e metric combinazione con i dati di prova come segue:

loss.test([X_test, y_test])

Uscita−

{'metric': 1.89679785619, 'samples': 79}