Conferencia en la nube

Hola,

los próximos 3 días puedes seguir las charlas en torno a los lenguajes Perl y Raku (perl6) en https://tpc20cic.sched.com. Puedes verlas en directo, con la diferencia horaria de EEUU, en https://www.youtube.com/yapcna , o más tarde cuando te venga bien, puesto que serán grabadas, como las de otros años,

hasta luego,

Bruno

Entrenando una red neuronal keras en linux

Hola,

tras la última entrada creo que ha llegado el momento de comenzar a programar redes neuronales profundas con la ayuda del libro Deep Learning Illustrated. En este caso el autor ha programado sus ejemplos en python, uno de los lenguajes más utilizados en este campo, y por tanto deberás crearte un ecosistema adecuado con todas las herramientas y dependencias necesarias, en este caso tensorflow y su interfaz keras. En un sistema CentOS Linux lo hice de la siguiente manera, con pyenv:

sudo curl -L https://raw.githubusercontent.com/yyuu/pyenv-installer/master/bin/pyenv-installer | bash

# agrego pyenv a .bashrc
export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

# instalo python 3.6 y actualizo pip
pyenv install 3.6.0
pyenv local 3.6.0
pip install --upgrade pip
pip install jupyter

# creo un ecosistema/virtualenv al que llamo DL
pyenv virtualenv 3.6.0 DL
pyenv shell DL

# instalo las dependencias del libro de Jon Krohn
# en mi caso tuve que poner TMPDIR=/particion_grande/ antes de pip
# porque se llenaba la particion /tmp
pip install tensorflow
pip install keras

# otra librería de aprendizaje prodfundo alternativa a keras & tensorflow
pip install mxnet 

Y ya está, ahora cuando quiero usar este ecosistema  solamente tengo que hacer:

$ pyenv shell DL

Todos los ejemplos de libro están disponibles en https://github.com/the-deep-learners/deep-learning-illustrated, en forma de cuadernos jupyter que puedes explorar directamente desde GitHub o en tu navegador. Si quieres probarlos directamente en el terminal deberás convertirlos a scripts .py y luego ejecutarlos:

jupyter nbconvert --to script deep-learning-illustrated/notebooks/regression_in_keras.ipynb

python deep-learning-illustrated/notebooks/regression_in_keras.py

En este caso obtendremos la siguiente salida, que resume la arquitectura de la red especificada en regression_in_keras.ipynb y su entrenamiento a lo largo de 32 épocas:

Model: "sequential_1"

_________________________________________________________________

Layer (type)                 Output Shape              Param #

=================================================================

dense_1 (Dense)              (None, 32)                448

_________________________________________________________________

batch_normalization_1 (Batch (None, 32)                128

_________________________________________________________________

dense_2 (Dense)              (None, 16)                528

_________________________________________________________________

batch_normalization_2 (Batch (None, 16)                64

_________________________________________________________________

dropout_1 (Dropout)          (None, 16)                0

_________________________________________________________________

dense_3 (Dense)              (None, 1)                 17

=================================================================

Total params: 1,185

Trainable params: 1,089

Non-trainable params: 96

Train on 404 samples, validate on 102 samples

Epoch 1/32

  8/404 [..............................] - ETA: 30s - loss: 865.3292

 80/404 [====>.........................] - ETA: 2s - loss: 720.8563

152/404 [==========>...................] - ETA: 1s - loss: 644.4068

232/404 [================>.............] - ETA: 0s - loss: 602.0502

304/404 [=====================>........] - ETA: 0s - loss: 578.7887

376/404 [==========================>...] - ETA: 0s - loss: 588.8638

404/404 [==============================] - 1s 2ms/step - loss: 583.1135 - val_loss: 786.3666

....

  8/404 [..............................] - ETA: 0s - loss: 18.8216

 88/404 [=====>........................] - ETA: 0s - loss: 34.8777

168/404 [===========>..................] - ETA: 0s - loss: 37.6842

248/404 [=================>............] - ETA: 0s - loss: 48.3836

328/404 [=======================>......] - ETA: 0s - loss: 45.0179

404/404 [==============================] - 0s 761us/step - loss: 43.5160 - val_loss: 133.9931

Hasta pronto,

Bruno

Sobreentrenamiento de una red neuronal

Hola,

en la última entrada repasé como aprende una red neuronal y cómo se calcula el coste en un conjunto de entrenamiento. Hoy me detengo en el problema del sobreentrenamiento (overfitting en la literatura), para lo cual necesitamos un conjunto de datos independiente, que llamamos conjunto de validación.

Primero definiré el sobreentrenamiento con las palabras de J Krohn: "es la situación en la que el coste de entrenamiento desciende a la vez que aumenta en el conjunto de validación". El objetivo del entrenamiento debe ser obtener un modelo general, y el sobreentrenamiento es por tanto un obstáculo, porque al sobreentrenar lo que ocurre es que el modelo se particulariza para tu conjunto de entrenamiento.

Figura 9.5 de Krohn J (2019) Deep Learning Illustrated

En la figura se ilustran 4 modelos ajustados a los mismos datos. Arriba a la izquierda un modelo como un solo parámetro, con un ajuste muy pobre. A su derecha un modelo parabólico con con dos parámetros se ajusta bastante bien. Abajo se muestran un modelo multiparamétrico que sobreajustan los datos y que no generaliza bien cuando se agregan nuevos datos (abajo derecho). El sobreentrenamiento es un problema de sobreajuste.

En su libro, J Krohn presenta ideas para limitar el sobreentrenamiento. En primer lugar, habla del número de épocas que debemos entrenar una red:

• Si el coste de entrenamiento en un conjunto de datos de validación alcanza el mínimo en la última época es buena idea agregar más épocas al entrenamiento.
• Si el coste empieza a aumentar a partir de una época de entrenamiento, es normalmente un indicio de sobreentrenamiento

En segundo lugar, describe la técnica de eliminación neuronas (dropout) al azar en capas ocultas durante el proceso de entrenamiento:

Figura 9.6 de Krohn J (2019) Deep Learning Illustrated

El próximo día programaremos las primeras redes,

Bruno

Siguiente entrada: Entrenando una red neuronal keras en Linux

Entrenamiento de una red neuronal

Hola,
hoy voy a hablar sobre el entrenamiento de una red neuronal, que es el proceso por el que  presentamos a la red un conjunto de ejemplos de los que sabemos cuál debería ser la respuesta de la red. El ejemplo de la figura es una imagen de 28x28 píxeles en escala de grises que representa el número 3 y pertenece al conjunto MNIST de números manuscritos.

Figura 5.2 de Krohn J (2019) Deep Learning Illustrated

El proceso de entrenamiento consiste en presentar a la red el conjunto de entrenamiento varias veces seguidas (épocas en la jerga) con el fin de que vaya aprendiendo. Al final de cada época podemos calcular el error que comete la red al clasificar las instancias presentadas, que se calcula comparando las salidas obtenidas con las esperadas . El objetivo del entrenamiento es minimizar el error. Por tanto, deberemos definir una función de coste con el objeto de optimizarla frente a un conjunto de entrenamiento lo más grande y realista posible.

La función coste (loss function en la literatura) se calculaba inicialmente como el coste cuadrático promedio. El valor obtenido es siempre positivo y penaliza más las grandes diferencias que las pequeñas. Es el RMSD que se emplea por ejemplo para comparar estructuras de proteínas similares. Sin embargo, tiene el inconveniente de ser poco sensible a cambios en los pesos de las neuronas cerca de sus valores extremos, y por tanto, ralentiza el aprendizaje. Por esa razón se sustituye habitualmente por una función basada en logaritmos de coste entrópico, tomada de la teoría de información:



El último paso de una época de aprendizaje es la retro-propagación, es decir, la optimización de los pesos y umbrales de activación de las neuronas para minimizar el error. Para ello se emplea el algoritmo clásico del gradiente descendiente capa a capa, en sentido contrario a la propagación, empezando por la capa inmediatamente anterior a la capa de salida. El proceso completo se resume en el siguiente diagrama de flujo, donde se observa que los datos de entrenamiento se reparten en lotes (batches):

Figura 8.6 de Krohn J (2019) Deep Learning Illustrated

Dos de los parámetros más importantes durante el aprendizaje son:

1) la tasa de aprendizaje , que es la pendiente que aplica el algoritmo del gradiente descendiente para descender por el gradiente de coste. J Krohn recomienda valores de 0.01 u 0.001 para empezar.

2) El tamaño de los lotes, que nos permitirá entrenar con conjuntos de datos más grandes que la RAM de nuestro sistema de cálculo.

Al comparar los costes entre épocas es posible calcular la velocidad de aprendizaje. La siguiente figura muestra que la velocidad de aprendizaje es diferente para las diferentes capas de una red profunda. En concreto, las capas aprenden más lentamente cuánto más lejos de la capa de salida:

Figura 8.8 de Krohn J (2019) Deep Learning Illustrated

Esta es la razón más importante para restringir el número de capas ocultas de una red profunda. Hasta la próxima,

Bruno

Siguiente entrada: Sobreentrenamiento de una red neuronal

Propagación en una red neuronal

Hola,
tras la reciente entrada sobre las capas de una red neuronal podemos ya aprender cómo se propaga la computación en la red, lo que la literatura se conoce como forward propagation. Para ello nada mejor que ver la red con salida binaria de la entrada anterior, con las neuronas numeradas:

Figura 7.2 de Krohn J (2019) Deep Learning Illustrated

Supongamos que las neuronas de input toman los siguientes valores reales, por ejemplo medidas físicas en un experimento:



Recordemos ahora que las neuronas de las capas ocultas son de tipo ReLU, que tienen la siguiente función de activación (alfa):



Ahora detallaré cómo calculamos las activaciones capa a capa, y por tanto, cómo se propaga la información en la red.

Empezaré por la neurona a1. Supongamos que sus dos pesos toman valores reales de -0.5 y 1.5 y su umbral de activación es 0.9:
z1 = -0.5 x 4.0 + 1.5 x 3.0 - 0.9  = -2 + 4.5 -  0.9 = 1.6
alfa1 = max(1.6 , 0) = 1.6

Sustituyendo los pesos y umbrales correspondientes, que son los valores que se optimizan en el periodo de entranamiento, podemos calcular de la misma manera la activación de a2 y a3. Así tendríamos ya la primera capa oculta completa y podríamos pasar a la siguiente, formada por las neuronas a4 y a5.

Finalmente llegamos a la neurona de output, que en la entrada anterior quedamos era de tipo sigmoidea. Ésta recibe las activaciones 2.5 y 2.0, con pesos respectivos de 1.0 y 0.5 y un umbral 5.5.

z(output) = 1.0 x 2.5 + 0.5 x 2.0 - 5.5 = -2.0

Ahora usaremos la función sigmoidea para calcular el estado (activación) de la neurona output:


En el contexto de un clasificador binario, para reconocer por ejemplo objetos de una cierta clase, la salida se interpreta como que la probabilidad de que la instancia (4.0, 3.0) sea de esa clase es 0.1192

Hasta pronto,
Bruno

Siguiente entrada: Entrenamiento de una red neuronal