Evalúe el Rendimiento de los Modelos de Deep Learning

Hay muchas decisiones que tomar al diseñar sus modelos de Deep Learning. La mayoría de estas decisiones deben ser resueltas empíricamente a través de ensayo/error y la evaluación con datos reales. Como tal, es de vital importancia contar con una forma sólida de evaluar el rendimiento de su red neuronal y modelos de Deep Learning.

Evaluar empíricamente las configuraciones de red

Hay una gran cantidad de decisiones que usted debe tomar al diseñar y configurar sus modelos de Deep Learning. Muchas de estas decisiones pueden resolverse copiando la estructura de las redes de otras personas y utilizando la heurística. En última instancia, la mejor técnica es diseñar experimentos pequeños y evaluar empíricamente las opciones utilizando datos reales. Esto incluye decisiones de alto nivel como el número, tamaño y tipo de capas en su red. También incluye las decisiones de nivel inferior como la elección de la función de pérdida, funciones de activación, procedimiento de optimización y número de epochs.

El Deep Learning se utiliza a menudo en problemas que tienen conjuntos de datos muy grandes. Es decir, decenas de miles o cientos de miles de casos. Como tal, necesita tener un arnés de prueba robusto que le permita estimar el rendimiento de una configuración dada en datos no vistos, y comparar de forma fiable el rendimiento con otras configuraciones.

División de datos

La gran cantidad de datos y la complejidad de los modelos requieren tiempos de entrenamientos muy largos. Como tal, es típico utilizar una simple separación de datos en conjuntos de datos de formación y de pruebas o conjuntos de datos de formación y validación. Keras proporciona dos maneras convenientes de evaluar su aprendizaje profundo de esta manera:

1. Utilice un conjunto de datos de verificación automática.
2. Utilice un conjunto de datos de verificación manual.

Utilizar un conjunto de datos de verificación automática

Keras puede separar una parte de sus datos de entrenamiento en un conjunto de datos de validación y evaluar el rendimiento de su modelo en ese conjunto de datos de validación en cada epoch. Puede hacerlo configurando la opción argumento de validation_split en la función fit() a un porcentaje del tamaño de su entrenamiento de un conjunto de datos. Por ejemplo, un valor razonable podría ser 0.2 o 0.33 para el 20% o 33% de su entrenamiento de datos retenidos para la validación. El siguiente ejemplo demuestra el uso de un sistema automático de
de los indios Pima sobre el inicio de la diabetes.

# MLP un conjunto de datos de verificación automática

from keras.models import Sequential
from keras.layers import Dense
import numpy
# Fija las semillas aleatorias para la reproducibilidad
seed=7
numpy.random.seed(7)
# carga los datos
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# dividido en variables de entrada (X) y salida (Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# crea el modelo
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compila el modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# ajusta el modelo
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10)

Al ejecutar el ejemplo, puede ver que la salida epoch muestra la pérdida y la precisión tanto en el conjunto de datos de formación como en el conjunto de datos de validación.

Epoch 144/150
514/514 [==============================] - 0s 105us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 145/150
514/514 [==============================] - 0s 109us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 146/150
514/514 [==============================] - 0s 103us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 147/150
514/514 [==============================] - 0s 105us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 148/150
514/514 [==============================] - 0s 101us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 149/150
514/514 [==============================] - 0s 105us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732
Epoch 150/150
514/514 [==============================] - 0s 103us/step - loss: 5.8013 - acc: 0.6401 - val_loss: 5.2669 - val_acc: 0.6732

Utilizar un conjunto de datos de verificación manual

Keras también le permite especificar manualmente el conjunto de datos a utilizar para la validación durante el entrenamiento. En este ejemplo usamos la práctica función de train_test_split() de la biblioteca de machine learning de scikit-learn de Python para separar nuestros datos en un conjunto de datos de entrenamiento y prueba. Utilizamos el 67% para la formación y el 33% restante de los datos para la validación. El conjunto de datos de validación se puede especificar a la función fit() en Keras mediante el argumento validation_data. Toma una tupla de los conjuntos de datos de entrada y salida.

# MLP un conjunto de datos de verificación automática

from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
import numpy
# Fija las semillas aleatorias para la reproducibilidad
seed=7
numpy.random.seed(7)
# carga los datos
dataset = numpy.loadtxt("pima.csv", delimiter=",")
# dividido en variables de entrada (X) y salida (Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# dividido en un 67% para el entrenamiento y un 33% para las pruebas
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)
# crea el modelo
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compila el modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# ajusta el modelo
model.fit(X_train, y_train, validation_data=(X_test,y_test), epochs=150, batch_size=10)

Como antes, al ejecutar el ejemplo se obtienen resultados del entrenamiento que incluyen la pérdida y la precisión del modelo en los conjuntos de datos de entrenamiento y validación de cada epoch.

Epoch 144/150
514/514 [==============================] - 0s 107us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 145/150
514/514 [==============================] - 0s 111us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 146/150
514/514 [==============================] - 0s 107us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 147/150
514/514 [==============================] - 0s 109us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 148/150
514/514 [==============================] - 0s 107us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 149/150
514/514 [==============================] - 0s 109us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378
Epoch 150/150
514/514 [==============================] - 0s 109us/step - loss: 5.5190 - acc: 0.6576 - val_loss: 5.8381 - val_acc: 0.6378

Manual k-Fold con Validacion Cruzada

El estándar de oro para la evaluación de modelos de aprendizaje de máquinas es la validación cruzada k-fold. Proporciona una estimación sólida del rendimiento de un modelo sobre datos no vistos. Para ello, divide el conjunto de datos de formación en subconjuntos k y se turna en modelos de formación de todos los subconjuntos excepto uno que se ofrece, y evalúa el rendimiento del modelo en el conjunto de datos de validación que se ofrece. El proceso se repite hasta que todos los subconjuntos tengan la oportunidad de ser el conjunto de validación retenido. La medida de rendimiento es entonces promediada a través de todos los modelos que son creados.

La validación cruzada a menudo no se utiliza para evaluar modelos de Deep Learning debido al mayor gasto computacional. Por ejemplo, la validación cruzada k-fold en k se utiliza a menudo con 5 ó 10 pliegues (fold). Como tal, deben construirse y evaluarse 5 ó 10 modelos, lo que aumenta considerablemente el tiempo de evaluación de un modelo. Sin embargo, cuando el problema es lo suficientemente pequeño o si usted tiene una computación suficiente, la validación cruzada de k-fold puede proporcionarle una estimación mas precisa.
En el siguiente ejemplo usamos la práctica StratifiedKFold class de la biblioteca de machine learning scikit-learn para dividir el conjunto de datos de entrenamiento en 10 pliegues. Los pliegues están estratificados, lo que significa que el algoritmo intenta equilibrar el número de instancias de cada clase en cada pliegue. El ejemplo crea y evalúa 10 modelos utilizando las 10 divisiones de los datos y recoge todas las puntuaciones. La salida verbose (como puedes ver en los códigos a veces utilizamos verbose, con verbose podemos sacar datos en la consola para tener idea de los valores lo que estamos calculando) para cada epoch se convierte en o pasando verbose=0 a las funciones fit() y evaluate() en el modelo. El promedio y la desviación estándar del rendimiento del modelo se imprimen al final de la ejecución para proporcionar una estimación sólida de la precisión del modelo.

# MLP con 10-pliegues de validacion cruzada

from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import StratifiedKFold
import numpy
# Fija las semillas aleatorias para la reproducibilidad
seed=7
numpy.random.seed(7)
# carga los datos
dataset = numpy.loadtxt("pima.csv", delimiter=",")
# dividido en variables de entrada (X) y salida (Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# define 10-pliegues con validacion cruzada test harness
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
cvscores = []
for train, test in kfold.split(X, Y):
  # crea el modelo
  model = Sequential()
  model.add(Dense(12, input_dim=8, activation='relu'))
  model.add(Dense(8, activation='relu'))
  model.add(Dense(1, activation='sigmoid'))
  # Compila el modelo
  model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
  # Fit el modelo
  model.fit(X[train], Y[train], epochs=150, batch_size=10, verbose=0)
  # evalua el modelo
  scores = model.evaluate(X[test], Y[test], verbose=0)
  print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
  cvscores.append(scores[1] * 100)
print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores)))

La ejecución del ejemplo tomará menos de un minuto y producirá la siguiente salida:

acc: 64.94%
acc: 74.03%
acc: 68.83%
acc: 80.52%
acc: 77.92%
acc: 64.94%
acc: 66.23%
acc: 64.94%
acc: 65.79%
acc: 68.42%
69.65% (+/- 5.49%)

Nótese que tuvimos que recrear el modelo de cada bucle para luego hacer el fit y evaluarlo con los datos para el pliegue. En la siguiente lección veremos cómo podemos usar los modelos de Keras de forma nativa con la biblioteca de machine learning de scikit-learn.

Resumen

En esta lección usted descubrió la importancia de tener una manera robusta de estimar el rendimiento de tus modelos de aprendizaje profundo en datos ocultos. Usted aprendió tres maneras en las que puede estimar el rendimiento de sus modelos de aprendizaje profundo en Python utilizando la biblioteca Keras:

• División automática de un conjunto de datos de formación en conjuntos de datos de formación y validación.
• Denegación manual y explícita de un conjunto de datos de formación y validación.
• Evaluación del rendimiento mediante la validación cruzada de k-fold -> la técnica estándar de oro.

➡ ¿Quieres aprender mas de Deep Learning? Ingresa a nuestro curso:

Curso de Deep Learning