Redes Neuronales Profundas y Aprendizaje de Máquina de Ciencia de Datos

Introducción

El Aprendizaje de Máquina de la Ciencia de Datos (Data Science Machine Learning, DSML) es una disciplina en crecimiento que se centra en el uso de los conjuntos de datos para entender mejor los procesos, predecir mejor resultados futuros y optimizar los sistemas. En esta clase, nos centraremos en el uso de Redes Neuronales Profundas (Deep Neural Networks, DNNs) para el DSML. Las DNNs se han convertido en una herramienta poderosa para el DSML debido a su capacidad para aprender y generalizar patrones complejos en los datos.

Teoría

Las redes neuronales profundas (DNNs) son un tipo de modelo de aprendizaje automático basado en la teoría de redes neuronales biológicas. Estos modelos consisten en capas de neuronas, que se conectan entre sí para formar un grafo de procesamiento de datos, como se muestra en la Figura 1. Las neuronas de una capa están conectadas a las neuronas de la capa siguiente. Estas neuronas se activan cuando reciben una entrada y generan una salida como resultado. El objetivo de una red neuronal profunda es aprender una función que mapea un conjunto de entradas a un conjunto de salidas. Esto se logra a través de un proceso de entrenamiento en el que se optimiza una función de pérdida, que mide el error entre las salidas esperadas y las salidas reales.

Figura 1. Una red neuronal profunda con tres capas.

Las redes neuronales profundas se han utilizado para una variedad de problemas, como la clasificación de imágenes, el procesamiento del habla y el análisis de texto. Estas redes se caracterizan por su capacidad para aprender patrones complejos en los datos a partir de un gran número de parámetros. Esta capacidad hace que sean ideales para problemas de DSML, donde los patrones pueden ser difíciles de identificar mediante el uso de modelos más simples.

Ejemplos Prácticos

A continuación, se presentan tres ejemplos prácticos de DNNs para DSML. Los ejemplos incluyen código en Python y fórmulas matemáticas en LaTeX.

Ejemplo 1: Regresión Lineal

El primer ejemplo es una red neuronal profunda para un problema de regresión lineal. El objetivo del problema es predecir el valor de una variable Y dado un conjunto de variables X. Esto se logra mediante la optimización de una función de pérdida que mide el error entre los valores predichos y los valores reales.

La siguiente es una implementación de una red neuronal profunda para resolver un problema de regresión lineal usando Python y TensorFlow.

«`python
import tensorflow as tf

# Definir las variables de entrada y salida
X = tf.placeholder(tf.float32, shape=[None, n])
y = tf.placeholder(tf.float32, shape=[None, 1])

# Definir la primera capa de la red neuronal
W1 = tf.Variable(tf.random_normal(shape=[n, m]), name=»weights_1″)
b1 = tf.Variable(tf.zeros(shape=[m]), name=»bias_1″)
y1 = tf.nn.relu(tf.matmul(X, W1) + b1)

# Definir la segunda capa de la red neuronal
W2 = tf.Variable(tf.random_normal(shape=[m, 1]), name=»weights_2″)
b2 = tf.Variable(tf.zeros(shape=[1]), name=»bias_2″)
y2 = tf.matmul(y1, W2) + b2

# Definir la función de pérdida
loss = tf.reduce_mean(tf.square(y2 – y))

# Definir un optimizador
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

# Entrenar la red neuronal
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(1000):
_, l = sess.run([optimizer, loss], feed_dict={X: X_train, y: y_train})
if (step % 100 == 0):
print(«Step: {}, Loss: {:.4f}».format(step, l))

# Evaluar el modelo
y_pred = sess.run(y2, feed_dict={X: X_test})
«`

La función de pérdida para este ejemplo es la siguiente:

$$L = \frac{1}{N} \sum_{i=1}^{N} (y_i – \hat{y}_i)^2$$

En esta fórmula, $y_i$ es el valor real de la variable Y para el $i$-ésimo dato de entrada, y $\hat{y}_i$ es el valor predicho para el $i$-ésimo dato de entrada.

Ejemplo 2: Clasificación de Imágenes

El segundo ejemplo es una red neuronal profunda para un problema de clasificación de imágenes. En este problema, el objetivo es clasificar una imagen dada en una de varias categorías. Esto se logra mediante la optimización de una función de pérdida que mide el error entre las clases predichas y las clases reales.

La siguiente es una implementación de una red neuronal profunda para resolver un problema de clasificación de imágenes usando Python y TensorFlow.

«`python
import tensorflow as tf

# Definir las variables de entrada y salida
X = tf.placeholder(tf.float32, shape=[None, n])
y = tf.placeholder(tf.float32, shape=[None, m])

# Definir la primera capa de la red neuronal
W1 = tf.Variable(tf.random_normal(shape=[n, m]), name=»weights_1″)
b1 = tf.Variable(tf.zeros(shape=[m]), name=»bias_1″)
y1 = tf.nn.relu(tf.matmul(X, W1) + b1)

# Definir la segunda capa de la red neuronal
W2 = tf.Variable(tf.random_normal(shape=[m, m]), name=»weights_2″)
b2 = tf.Variable(tf.zeros(shape=[m]), name=»bias_2″)
y2 = tf.matmul(y1, W2) + b2

# Definir la función de pérdida
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y2, labels=y))

# Definir un optimizador
optimizer = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)

# Entrenar la red neuronal
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(1000):
_, l = sess.run([optimizer, loss], feed_dict={X: X_train, y: y_train})
if (step % 100 == 0):
print(«Step: {}, Loss: {:.4f}».format(step, l))

# Evaluar el modelo
y_pred = sess.run(y2, feed_dict={X: X_test})
«`

La función de pérdida para este ejemplo es la siguiente:

$$L = – \frac{1}{N} \sum_{i=1}^{N} \sum_{j=1}^{M} y_{ij} \log \hat{y}_{ij}$$

En esta fórmula, $y_{ij}$ es 1 si el $i$-ésimo dato de entrada está en la clase $j$, y 0 en caso contrario, y $\hat{y}_{ij}$ es la probabilidad predicha de que el $i$-ésimo dato de entrada esté en la clase $j$.

Ejemplo 3: Procesamiento del Habla

El tercer ejemplo es una red neuronal profunda para un problema de procesamiento de habla. En este problema, el objetivo es convertir una secuencia de palabras en una secuencia de caracteres. Esto se logra mediante la optimización de una función de pérdida que mide el error entre las secuencias predichas y las secuencias reales.

La siguiente es una implementación de una red neuronal profunda para resolver un problema de procesamiento del habla usando Python y TensorFlow.

«`python
import tensorflow as tf

# Definir las variables de entrada y salida
X = tf.placeholder(tf.float32, shape=[None, n])
y = tf.placeholder(tf.float32, shape=[None, m])

# Definir la primera capa de la red neuronal
W1 = tf.Variable(tf.random_normal(shape=[n, m]), name=»weights_1″)
b1 = tf.Variable(tf.zeros(shape=[m]), name=»bias_1″)
y1 = tf.nn.relu(tf.matmul(X, W1) + b1)

# Definir la segunda capa de la red neuronal
W2 = tf.Variable(tf.random_normal(shape=[m, m]), name=»weights_2″)
b2 = tf.Variable(tf.zeros(shape=[m]), name=»bias_2″)
y2 = tf.matmul(y1, W2) + b2

# Definir la función de pérdida
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y2, labels=y))

# Definir un optimizador
optimizer = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)

# Entrenar la red neuronal
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(1000):
_, l = sess.run([optimizer, loss], feed_dict={X: X_train, y: y_train})
if (step % 100 == 0):
print(«Step: {}, Loss: {:.4f}».format(step, l))

# Evaluar el modelo
y_pred = sess.run(y2, feed_dict={X: X_test})
«`

La función de pérdida para este ejemplo es la siguiente:

$$L = – \frac{1}{N} \sum_{i=1}^{N} \sum_{j=1}^{M} y_{ij} \log \hat{y}_{ij}$$

En esta fórmula, $y_{ij}$ es 1 si el $i$-ésimo carácter de la secuencia real es el carácter $j$, y 0 en caso contrario, y $\hat{y}_{ij}$ es la probabilidad predicha de que el $i$-ésimo carácter de la secuencia predicha sea el carácter $j$.

Conclusiones

Las redes neuronales profundas son una herramienta poderosa para el Aprendizaje de Máquina de la Ciencia de Datos debido a su capacidad para aprender y generalizar patrones complejos en los datos. Esta clase ha mostrado cómo implementar una red neuronal profunda para tres problemas de aprendizaje automático diferentes: regresión lineal, clasificación de imágenes y procesamiento de habla.

Referencias

Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., & Dean, J. (2013). Distributed representations of words and phrases and their compositionality. En Advances in Neural Information Processing Systems (pp. 3111-3119).

Goodfellow, I., Bengio, Y., & Courville, A. (2014). Deep Learning. MIT Press.

Karpathy, A. (2017). The Unreasonable Effectiveness of Recurrent Neural Networks. En Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 2554-2563).