SundayTheQuant

Deep Learning con Python: Tu Primer Tutorial Práctico

¡Hola a todos! Soy su guía en el fascinante mundo de la ciencia de datos, y hoy vamos a sumergirnos en uno de los campos más emocionantes y transformadores de la inteligencia artificial: el Deep Learning. En este artículo, mi objetivo es desmitificar el Deep Learning y mostrarles cómo podemos empezar a construir nuestros propios modelos desde cero utilizando Python, el lenguaje de programación por excelencia en este ámbito.

Introducción al Deep Learning con Python

El Deep Learning, o Aprendizaje Profundo, es una subdisciplina del Machine Learning que se inspira en la estructura y función del cerebro humano, utilizando redes neuronales artificiales con múltiples capas (de ahí lo de “profundo”). Esta tecnología ha impulsado avances revolucionarios en áreas como el reconocimiento de imágenes, el procesamiento del lenguaje natural y la robótica, permitiendo a las máquinas aprender de grandes volúmenes de datos y realizar tareas complejas con una precisión asombrosa.

Python se ha consolidado como la herramienta preferida para el Deep Learning debido a su simplicidad, su vasta colección de librerías y frameworks (como TensorFlow y Keras), y su enorme comunidad de desarrolladores. Es un lenguaje que me permite escribir código legible y eficiente, lo cual es crucial cuando estamos experimentando con arquitecturas de redes neuronales complejas.

Terminología Clave para Principiantes

  • Neurona Artificial: La unidad fundamental de una red neuronal, inspirada en las neuronas biológicas. Recibe entradas, realiza un cálculo y produce una salida.
  • Capas: Conjuntos de neuronas artificiales. Una red neuronal típica tiene una capa de entrada, una o más capas ocultas y una capa de salida.
  • Activación (Función de Activación): Una función que decide si una neurona debe “activarse” (o dispararse) y con qué intensidad. Ejemplos comunes son ReLU, Sigmoide y Softmax.
  • Pesos y Sesgos: Parámetros ajustables dentro de la red neuronal que determinan la fuerza de la conexión entre las neuronas y el umbral de activación. El modelo “aprende” ajustando estos valores.
  • Epoch: Una pasada completa hacia adelante y hacia atrás de todo el conjunto de datos de entrenamiento a través de la red neuronal.
  • Tamaño de Lote (Batch Size): El número de ejemplos de entrenamiento utilizados en una sola iteración de entrenamiento.
  • Función de Pérdida (Loss Function): Mide la diferencia entre la salida predicha del modelo y la salida real. El objetivo del entrenamiento es minimizar esta función.
  • Optimizador: Un algoritmo utilizado para ajustar los pesos de la red neuronal con el objetivo de minimizar la función de pérdida. Ejemplos incluyen Adam y SGD.
  • Precisión (Accuracy): Una métrica común para evaluar el rendimiento de clasificación, que mide la proporción de predicciones correctas.

Metodología: Construyendo Nuestro Primer Modelo de Deep Learning

1. Configuración del Entorno de Desarrollo

Antes de escribir la primera línea de código, necesitamos preparar nuestro entorno. Mi recomendación es usar un entorno virtual para mantener las dependencias de los proyectos aisladas.

Instalación de Python

Asegúrate de tener Python 3.8 o superior instalado. Puedes descargarlo desde python.org. Yo usualmente verifico mi versión con:

python --version

Instalación de pip

pip es el gestor de paquetes de Python y viene incluido con las versiones modernas de Python. Si necesitas actualizarlo, puedes hacerlo con:

python -m pip install --upgrade pip

Instalación de Librerías Esenciales

Instalaremos las librerías clave que usaremos en este tutorial: TensorFlow (con Keras), NumPy y Matplotlib.

pip install tensorflow numpy matplotlib

2. Selección y Carga del Conjunto de Datos

Para este tutorial, he elegido el conjunto de datos Fashion MNIST. Es un excelente punto de partida porque es lo suficientemente complejo para demostrar las capacidades del Deep Learning, pero lo suficientemente simple para que el entrenamiento sea rápido. Consta de 70,000 imágenes en escala de grises de 28×28 píxeles de 10 categorías de artículos de moda (camisetas, pantalones, zapatillas, etc.), con 60,000 imágenes para entrenamiento y 10,000 para pruebas. Lo mejor es que TensorFlow lo proporciona directamente.

import tensorflow as tf

# Cargar el conjunto de datos Fashion MNIST
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()

# Nombres de las clases para la visualización (opcional pero útil)
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

print(f"Forma de las imágenes de entrenamiento: {train_images.shape}")
print(f"Forma de las etiquetas de entrenamiento: {train_labels.shape}")
print(f"Forma de las imágenes de prueba: {test_images.shape}")
print(f"Forma de las etiquetas de prueba: {test_labels.shape}")

3. Preprocesamiento de Datos

Los datos de imagen, especialmente los valores de los píxeles, suelen estar en un rango de 0 a 255. Para que nuestras redes neuronales funcionen de manera óptima, es una buena práctica normalizar estos valores a un rango de 0 a 1. Esto ayuda a la convergencia del modelo durante el entrenamiento.

# Normalizar los valores de los píxeles al rango [0, 1]
train_images = train_images / 255.0
test_images = test_images / 255.0

print("Imágenes normalizadas.")

En el caso de las etiquetas, Fashion MNIST ya las proporciona como enteros (0-9), lo cual es adecuado para la función de pérdida sparse_categorical_crossentropy. Si estuviéramos utilizando categorical_crossentropy, necesitaríamos convertir las etiquetas a formato one-hot encoding, pero para este tutorial, mantendremos las etiquetas como están para simplicidad.

4. Construcción de la Red Neuronal Simple con Keras

Ahora, es el momento de construir nuestro modelo de red neuronal. Utilizaré Keras, que viene integrado en TensorFlow, por su facilidad de uso y su enfoque en la construcción rápida de prototipos. Nuestro modelo será una red neuronal densa (Fully Connected).

from tensorflow import keras
from tensorflow.keras import layers

# Definir el modelo secuencial
model = keras.Sequential([
    # Capa de entrada: "aplanar" las imágenes de 28x28 a un vector de 784 píxeles
    layers.Flatten(input_shape=(28, 28)),
    # Primera capa oculta: 128 neuronas con función de activación ReLU
    layers.Dense(128, activation='relu'),
    # Capa de salida: 10 neuronas (una por clase) con función de activación Softmax
    layers.Dense(10, activation='softmax') # Softmax para clasificación multiclase
])

# Compilar el modelo
model.compile(optimizer='adam', # Optimizador Adam es una buena opción por defecto
              loss='sparse_categorical_crossentropy', # Función de pérdida para etiquetas enteras
              metrics=['accuracy']) # Métrica para evaluar el rendimiento

model.summary()

5. Entrenamiento del Modelo

Una vez que el modelo está definido y compilado, el siguiente paso es entrenarlo usando los datos preprocesados. El método model.fit() se encarga de esto. Aquí, la importancia de los epochs (el número de veces que el algoritmo de entrenamiento trabajará a través de todo el conjunto de datos de entrenamiento) y el batch_size (el número de muestras que se propagarán a través de la red antes de que se actualicen los parámetros del modelo) se hace evidente.

# Entrenar el modelo
history = model.fit(train_images, train_labels, epochs=10, batch_size=32,
                    validation_split=0.2) # Usamos 20% de los datos de entrenamiento para validación

print("Modelo entrenado.")

6. Evaluación del Rendimiento del Modelo

Después de entrenar el modelo, es crucial evaluar su rendimiento con datos que no ha visto antes, es decir, el conjunto de datos de prueba. El método model.evaluate() nos proporcionará la pérdida y la precisión en este conjunto.

# Evaluar el modelo con el conjunto de datos de prueba
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print(f'
Precisión en el conjunto de prueba: {test_acc:.4f}')
print(f'Pérdida en el conjunto de prueba: {test_loss:.4f}')

Una alta precisión en el conjunto de prueba indica que nuestro modelo ha aprendido bien y es capaz de generalizar a nuevas imágenes.

7. Visualización del Entrenamiento y Predicciones

Visualizar el progreso del entrenamiento y las predicciones individuales me ayuda a entender mejor cómo se está comportando el modelo.

Visualizar la Precisión y la Pérdida durante el Entrenamiento

import matplotlib.pyplot as plt

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(len(acc))

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Precisión de Entrenamiento')
plt.plot(epochs_range, val_acc, label='Precisión de Validación')
plt.legend(loc='lower right')
plt.title('Precisión de Entrenamiento y Validación')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Pérdida de Entrenamiento')
plt.plot(epochs_range, val_loss, label='Pérdida de Validación')
plt.legend(loc='upper right')
plt.title('Pérdida de Entrenamiento y Validación')
plt.show()

Realizar Predicciones

Podemos usar model.predict() para obtener las probabilidades de clasificación para nuevas imágenes.

import numpy as np

# Hacer predicciones sobre el conjunto de prueba
predictions = model.predict(test_images)

# Mostrar la primera predicción y la etiqueta real
print(f"Predicción para la primera imagen: {np.argmax(predictions[0])}")
print(f"Etiqueta real para la primera imagen: {test_labels[0]}")
print(f"Nombre de clase predicha: {class_names[np.argmax(predictions[0])]}")
print(f"Nombre de clase real: {class_names[test_labels[0]]}")

# Función para graficar imagen y predicción
def plot_image_prediction(i, predictions_array, true_label, img):
    true_label, img = true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img, cmap=plt.cm.binary)

    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel(f"{class_names[predicted_label]} {100*np.max(predictions_array):.2f}% ({class_names[true_label]})",
               color=color)

def plot_value_array(i, predictions_array, true_label):
    true_label = true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

# Graficar varias predicciones
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
    plot_image_prediction(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

Códigos: Script Completo para Deep Learning

Aquí les presento el script completo que integra todos los pasos que hemos cubierto, desde la carga de datos hasta la evaluación y visualización del modelo. Este código está pensado para ser claro y fácil de seguir para cualquier principiante que quiera iniciarse en el Deep Learning con Python.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

print("--- Configuración Inicial y Carga de Datos ---\n")
# 1. Cargar el conjunto de datos Fashion MNIST
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()

# Nombres de las clases para la visualización
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

print(f"Forma de las imágenes de entrenamiento: {train_images.shape}")
print(f"Forma de las etiquetas de entrenamiento: {train_labels.shape}")
print(f"Forma de las imágenes de prueba: {test_images.shape}")
print(f"Forma de las etiquetas de prueba: {test_labels.shape}")

print("\n--- Preprocesamiento de Datos ---\n")
# 2. Normalizar los valores de los píxeles al rango [0, 1]
train_images = train_images / 255.0
test_images = test_images / 255.0

print("Imágenes normalizadas.")

print("\n--- Construcción del Modelo de Red Neuronal ---\n")
# 3. Definir el modelo secuencial
model = keras.Sequential([
    layers.Flatten(input_shape=(28, 28)), # Capa de entrada para aplanar la imagen
    layers.Dense(128, activation='relu'), # Primera capa oculta con 128 neuronas y activación ReLU
    layers.Dense(10, activation='softmax') # Capa de salida con 10 neuronas (una por clase) y activación Softmax
])

# 4. Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.summary()

print("\n--- Entrenamiento del Modelo ---\n")
# 5. Entrenar el modelo
history = model.fit(train_images, train_labels, epochs=10, batch_size=32,
                    validation_split=0.2) # 20% de los datos de entrenamiento para validación

print("\nModelo entrenado.\n")

print("--- Evaluación del Rendimiento del Modelo ---\n")
# 6. Evaluar el modelo con el conjunto de datos de prueba
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print(f'
Precisión en el conjunto de prueba: {test_acc:.4f}')
print(f'Pérdida en el conjunto de prueba: {test_loss:.4f}')

print("\n--- Visualización del Entrenamiento y Predicciones ---\n")
# 7. Visualizar la Precisión y la Pérdida durante el Entrenamiento
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(len(acc))

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Precisión de Entrenamiento')
plt.plot(epochs_range, val_acc, label='Precisión de Validación')
plt.legend(loc='lower right')
plt.title('Precisión de Entrenamiento y Validación')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Pérdida de Entrenamiento')
plt.plot(epochs_range, val_loss, label='Pérdida de Validación')
plt.legend(loc='upper right')
plt.title('Pérdida de Entrenamiento y Validación')
plt.show()

# 8. Realizar Predicciones
predictions = model.predict(test_images)

# Función para graficar imagen y predicción
def plot_image_prediction(i, predictions_array, true_label, img):
    true_label, img = true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img, cmap=plt.cm.binary)

    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel(f"{class_names[predicted_label]} {100*np.max(predictions_array):.2f}% ({class_names[true_label]})",
               color=color)

def plot_value_array(i, predictions_array, true_label):
    true_label = true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

# Graficar varias predicciones
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
    plot_image_prediction(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

Conclusiones

Hemos recorrido un camino emocionante desde la configuración de nuestro entorno hasta la construcción, entrenamiento y evaluación de una red neuronal simple para la clasificación de imágenes. Hemos visto cómo Python, junto con librerías como TensorFlow y Keras, me permite implementar conceptos de Deep Learning de manera intuitiva y efectiva.

Este tutorial es solo el comienzo. El mundo del Deep Learning es vasto y hay mucho más por explorar. Les animo a:

  • Experimentar con diferentes arquitecturas de red, como añadir más capas densas o cambiar el número de neuronas.
  • Probar otras funciones de activación.
  • Explorar conjuntos de datos más complejos.
  • Investigar arquitecturas más avanzadas, como las Redes Neuronales Convolucionales (CNNs) para tareas de visión por computador más sofisticadas o las Redes Neuronales Recurrentes (RNNs) para el procesamiento de secuencias como texto o series temporales.
  • Profundizar en técnicas de regularización para evitar el sobreajuste, como el Dropout.

¡El aprendizaje continuo es la clave en este campo que evoluciona rápidamente!

Promoción

Si te ha gustado este artículo y quieres llevar tus conocimientos en ciencia de datos al siguiente nivel, te invito a explorar mi curso completo de Ciencia de Datos con Python y R. En él, profundizaremos en estos y muchos otros temas, con proyectos prácticos y un enfoque totalmente orientado a que domines las herramientas y técnicas que el mercado laboral demanda.

¡No te quedes atrás y empieza hoy tu camino para convertirte en un experto en datos!

Accede al curso aquí

Recuerda que siempre siempre vas a aprender un bit a la vez!