CNTK: entrenamiento de la red neuronal

Aquí, entenderemos cómo entrenar la red neuronal en CNTK.

Entrenando un modelo en CNTK

En la sección anterior, definimos todos los componentes del modelo de aprendizaje profundo. Ahora es el momento de entrenarlo. Como comentamos anteriormente, podemos entrenar un modelo NN en CNTK usando la combinación delearner y trainer.

Elegir un alumno y organizar la formación

En esta sección, definiremos el learner. CNTK ofrece varioslearnersPara escoger de. Para nuestro modelo, definido en secciones anteriores, usaremosStochastic Gradient Descent (SGD) learner.

Para entrenar la red neuronal, configuremos el learner y trainer con la ayuda de los siguientes pasos:

Step 1 - Primero, necesitamos importar sgd función de cntk.lerners paquete.

from cntk.learners import sgd

Step 2 - A continuación, necesitamos importar Trainer función de cntk.train.paquete de entrenador.

from cntk.train.trainer import Trainer

Step 3 - Ahora, necesitamos crear un learner. Se puede crear invocandosgd función junto con proporcionar los parámetros del modelo y un valor para la tasa de aprendizaje.

learner = sgd(z.parametrs, 0.01)

Step 4 - Por fin, necesitamos inicializar el trainer. Debe proporcionarse la red, la combinación de losloss y metric junto con learner.

trainer = Trainer(z, (loss, error_rate), [learner])

La tasa de aprendizaje que controla la velocidad de optimización debe ser un número pequeño entre 0,1 y 0,001.

Elegir un alumno y configurar la formación: ejemplo completo

from cntk.learners import sgd
from cntk.train.trainer import Trainer
learner = sgd(z.parametrs, 0.01)
trainer = Trainer(z, (loss, error_rate), [learner])

Alimentando datos al entrenador

Una vez que elegimos y configuramos el entrenador, es hora de cargar el conjunto de datos. Hemos salvado eliris conjunto de datos como.CSV archivo y usaremos el paquete de lucha de datos llamado pandas para cargar el conjunto de datos.

Pasos para cargar el conjunto de datos desde el archivo .CSV

Step 1 - Primero, necesitamos importar el pandas paquete.

from import pandas as pd

Step 2 - Ahora, necesitamos invocar la función llamada read_csv función para cargar el archivo .csv desde el disco.

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, 
‘petal_length’, ‘petal_width’, index_col=False)

Una vez que cargamos el conjunto de datos, debemos dividirlo en un conjunto de características y una etiqueta.

Pasos para dividir el conjunto de datos en características y etiquetas

Step 1- Primero, debemos seleccionar todas las filas y las primeras cuatro columnas del conjunto de datos. Se puede hacer usandoiloc función.

x = df_source.iloc[:, :4].values

Step 2- A continuación, debemos seleccionar la columna de especies del conjunto de datos de iris. Usaremos la propiedad de valores para acceder al subyacentenumpy formación.

x = df_source[‘species’].values

Pasos para codificar la columna de especies en una representación vectorial numérica

Como discutimos anteriormente, nuestro modelo se basa en la clasificación, requiere valores de entrada numéricos. Por lo tanto, aquí necesitamos codificar la columna de especies en una representación vectorial numérica. Veamos los pasos para hacerlo -

Step 1- Primero, necesitamos crear una expresión de lista para iterar sobre todos los elementos de la matriz. Luego, busque en el diccionario label_mapping para cada valor.

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 2- A continuación, convierta este valor numérico convertido en un vector codificado en caliente. Nosotros usaremosone_hot funciona de la siguiente manera:

def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result

Step 3 - Por fin, necesitamos convertir esta lista convertida en una numpy formación.

y = np.array([one_hot(label_mapping[v], 3) for v in y])

Pasos para detectar el sobreajuste

La situación, cuando su modelo recuerda muestras pero no puede deducir reglas de las muestras de entrenamiento, es sobreajuste. Con la ayuda de los siguientes pasos, podemos detectar el sobreajuste en nuestro modelo:

Step 1 - Primero, desde sklearn paquete, importa el train_test_split función de la model_selection módulo.

from sklearn.model_selection import train_test_split

Step 2 - A continuación, necesitamos invocar la función train_test_split con las características xy las etiquetas y de la siguiente manera -

x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0-2, 
stratify=y)

Especificamos un test_size de 0.2 para reservar el 20% de los datos totales.

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Pasos para alimentar el conjunto de entrenamiento y el conjunto de validación a nuestro modelo

Step 1 - Para entrenar nuestro modelo, primero, invocaremos el train_minibatchmétodo. Luego, dele un diccionario que asigne los datos de entrada a la variable de entrada que hemos utilizado para definir el NN y su función de pérdida asociada.

trainer.train_minibatch({ features: X_train, label: y_train})

Step 2 - Siguiente, llamar train_minibatch usando el siguiente bucle for -

for _epoch in range(10):
trainer.train_minbatch ({ feature: X_train, label: y_train})
print(‘Loss: {}, Acc: {}’.format(
trainer.previous_minibatch_loss_average,
trainer.previous_minibatch_evaluation_average))

Introducir datos en el entrenador: ejemplo completo

from import pandas as pd
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, index_col=False)
x = df_source.iloc[:, :4].values
x = df_source[‘species’].values
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result
y = np.array([one_hot(label_mapping[v], 3) for v in y])
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0-2, stratify=y)
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
trainer.train_minibatch({ features: X_train, label: y_train})
for _epoch in range(10):
trainer.train_minbatch ({ feature: X_train, label: y_train})
print(‘Loss: {}, Acc: {}’.format(
trainer.previous_minibatch_loss_average,
trainer.previous_minibatch_evaluation_average))

Midiendo el desempeño de NN

Para optimizar nuestro modelo NN, cada vez que pasamos datos a través del entrenador, mide el rendimiento del modelo a través de la métrica que configuramos para el entrenador. Dicha medición del rendimiento del modelo NN durante el entrenamiento se basa en los datos de entrenamiento. Pero, por otro lado, para un análisis completo del rendimiento del modelo, también necesitamos usar datos de prueba.

Entonces, para medir el desempeño del modelo usando los datos de prueba, podemos invocar el test_minibatch método en el trainer como sigue -

trainer.test_minibatch({ features: X_test, label: y_test})

Haciendo predicciones con NN

Una vez que entrenó un modelo de aprendizaje profundo, lo más importante es hacer predicciones usando eso. Para hacer una predicción a partir del NN entrenado anteriormente, podemos seguir los pasos dados:

Step 1 - Primero, necesitamos elegir un elemento aleatorio del conjunto de prueba usando la siguiente función -

np.random.choice

Step 2 - A continuación, debemos seleccionar los datos de muestra del conjunto de prueba utilizando sample_index.

Step 3 - Ahora, para convertir la salida numérica a la NN en una etiqueta real, cree un mapeo invertido.

Step 4 - Ahora, use el seleccionado sampledatos. Haga una predicción invocando NN z como función.

Step 5- Ahora, una vez que obtenga la salida prevista, tome el índice de la neurona que tiene el valor más alto como valor predicho. Se puede hacer usando elnp.argmax función de la numpy paquete.

Step 6 - Por último, convierta el valor del índice en la etiqueta real usando inverted_mapping.

Hacer predicciones con NN - Ejemplo completo

sample_index = np.random.choice(X_test.shape[0])
sample = X_test[sample_index]
inverted_mapping = {
   1:’Iris-setosa’,
   2:’Iris-versicolor’,
   3:’Iris-virginica’
}
prediction = z(sample)
predicted_label = inverted_mapping[np.argmax(prediction)]
print(predicted_label)

Salida

Después de entrenar el modelo de aprendizaje profundo anterior y ejecutarlo, obtendrá el siguiente resultado:

Iris-versicolor