CNTK - Modelo de regresión

Aquí, estudiaremos sobre la medición del desempeño con respecto a un modelo de regresión.

Conceptos básicos de la validación de un modelo de regresión

Como sabemos, los modelos de regresión son diferentes a los modelos de clasificación, en el sentido de que no existe una medida binaria de lo correcto o incorrecto para las muestras de los individuos. En los modelos de regresión, queremos medir qué tan cerca está la predicción del valor real. Cuanto más se acerque el valor de predicción al resultado esperado, mejor será el rendimiento del modelo.

Aquí, vamos a medir el desempeño de NN usado para la regresión usando diferentes funciones de tasa de error.

Calcular el margen de error

Como se discutió anteriormente, al validar un modelo de regresión, no podemos decir si una predicción es correcta o incorrecta. Queremos que nuestra predicción se acerque lo más posible al valor real. Pero aquí es aceptable un pequeño margen de error.

La fórmula para calcular el margen de error es la siguiente:

Aquí,

Predicted value = indicado y por un sombrero

Real value = predicho por y

Primero, necesitamos calcular la distancia entre el valor predicho y el real. Luego, para obtener una tasa de error general, debemos sumar estas distancias al cuadrado y calcular el promedio. Esto se llamamean squared función de error.

Pero, si queremos cifras de rendimiento que expresen un margen de error, necesitamos una fórmula que exprese el error absoluto. La formula paramean absolute La función de error es la siguiente:

La fórmula anterior toma la distancia absoluta entre el valor predicho y el real.

Usar CNTK para medir el rendimiento de la regresión

Aquí, veremos cómo usar las diferentes métricas, que discutimos en combinación con CNTK. Usaremos un modelo de regresión que predice millas por galón para automóviles siguiendo los pasos que se indican a continuación.

Pasos de implementación

Step 1 - Primero, necesitamos importar los componentes requeridos desde cntk paquete de la siguiente manera -

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

Step 2 - A continuación, necesitamos definir una función de activación predeterminada utilizando el default_optionsfunciones. Luego, cree un nuevo conjunto de capas secuenciales y proporcione dos capas densas con 64 neuronas cada una. Luego, agregamos una capa densa adicional (que actuará como la capa de salida) al conjunto de capas secuenciales y damos 1 neurona sin una activación de la siguiente manera:

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

Step 3- Una vez que se ha creado la red, necesitamos crear una función de entrada. Necesitamos asegurarnos de que tenga la misma forma que las funciones que vamos a utilizar para el entrenamiento.

features = input_variable(X.shape[1])

Step 4 - Ahora, necesitamos crear otro input_variable con tamaño 1. Se utilizará para almacenar el valor esperado para NN.

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

Ahora, necesitamos entrenar el modelo y, para hacerlo, vamos a dividir el conjunto de datos y realizar el preprocesamiento mediante los siguientes pasos de implementación:

Step 5−Primero, importe StandardScaler de sklearn.preprocessing para obtener los valores entre -1 y +1. Esto nos ayudará a evitar la explosión de problemas de gradientes en la NN.

from sklearn.preprocessing import StandardScalar

Step 6 - A continuación, importe train_test_split de sklearn.model_selection de la siguiente manera

from sklearn.model_selection import train_test_split

Step 7 - Suelta el mpg columna del conjunto de datos utilizando el dropmétodo. Por último, divida el conjunto de datos en un conjunto de entrenamiento y validación utilizando eltrain_test_split funciona de la siguiente manera:

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 - Ahora, necesitamos crear otra variable_entrada con tamaño 1. Se usará para almacenar el valor esperado para NN.

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

Hemos dividido y preprocesado los datos, ahora necesitamos entrenar a la NN. Como hicimos en secciones anteriores al crear el modelo de regresión, necesitamos definir una combinación de pérdida ymetric función para entrenar el modelo.

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

Ahora, echemos un vistazo a cómo usar el modelo entrenado. Para nuestro modelo, usaremos Criterion_factory como la combinación de pérdidas y métricas.

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)

Ejemplo de implementación 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)

Salida

-------------------------------------------------------------------
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
[………]

Para validar nuestro modelo de regresión, debemos asegurarnos de que el modelo maneja los datos nuevos tan bien como lo hace con los datos de entrenamiento. Para esto, necesitamos invocar eltest método en loss y metric combinación con los datos de prueba de la siguiente manera:

loss.test([X_test, y_test])

Salida−

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