El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Creación de una Red Neuronal Simple

Siguiente ►
►

En este tema, aprenderemos a construir una red neuronal simple utilizando PyTorch. Este es un paso fundamental para cualquier persona que desee trabajar con redes neuronales, ya que proporciona una base sólida sobre la cual se pueden construir modelos más complejos.

Objetivos

  • Entender la estructura básica de una red neuronal.
  • Aprender a definir una red neuronal en PyTorch.
  • Implementar una red neuronal simple y entrenarla con datos de ejemplo.

  1. Estructura Básica de una Red Neuronal

Una red neuronal típica consta de:

  • Capas de entrada: Reciben los datos de entrada.
  • Capas ocultas: Procesan los datos mediante operaciones matemáticas.
  • Capas de salida: Producen la salida final del modelo.

  1. Definiendo una Red Neuronal en PyTorch

En PyTorch, las redes neuronales se definen utilizando la clase torch.nn.Module. A continuación, se muestra cómo definir una red neuronal simple con una capa oculta.

Paso 1: Importar las Bibliotecas Necesarias

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

Paso 2: Definir la Red Neuronal

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 128)  # Capa oculta con 128 neuronas
        self.fc2 = nn.Linear(128, 10)   # Capa de salida con 10 neuronas (para 10 clases)

    def forward(self, x):
        x = F.relu(self.fc1(x))  # Función de activación ReLU
        x = self.fc2(x)
        return x

Explicación del Código

  • nn.Linear(784, 128): Define una capa totalmente conectada con 784 entradas y 128 salidas.
  • F.relu: Aplica la función de activación ReLU.
  • nn.Linear(128, 10): Define una capa totalmente conectada con 128 entradas y 10 salidas.

  1. Entrenando la Red Neuronal

Paso 1: Preparar los Datos

Para este ejemplo, utilizaremos el conjunto de datos MNIST, que contiene imágenes de dígitos escritos a mano.

from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

Paso 2: Definir la Función de Pérdida y el Optimizador

model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

Paso 3: Entrenar el Modelo

epochs = 5
for epoch in range(epochs):
    running_loss = 0
    for images, labels in trainloader:
        images = images.view(images.shape[0], -1)  # Aplanar las imágenes

        optimizer.zero_grad()  # Limpiar los gradientes

        output = model(images)  # Forward pass
        loss = criterion(output, labels)  # Calcular la pérdida
        loss.backward()  # Backward pass
        optimizer.step()  # Actualizar los pesos

        running_loss += loss.item()
    print(f"Epoch {epoch+1} - Loss: {running_loss/len(trainloader)}")

Explicación del Código

  • images.view(images.shape[0], -1): Aplana las imágenes de 28x28 a un vector de 784 elementos.
  • optimizer.zero_grad(): Limpia los gradientes acumulados.
  • model(images): Realiza el forward pass.
  • criterion(output, labels): Calcula la pérdida.
  • loss.backward(): Realiza el backward pass.
  • optimizer.step(): Actualiza los pesos del modelo.

Ejercicio Práctico

Ejercicio

Modifica la red neuronal para que tenga dos capas ocultas en lugar de una. La primera capa oculta debe tener 256 neuronas y la segunda 128 neuronas.

Solución

class ModifiedNN(nn.Module):
    def __init__(self):
        super(ModifiedNN, self).__init__()
        self.fc1 = nn.Linear(784, 256)  # Primera capa oculta con 256 neuronas
        self.fc2 = nn.Linear(256, 128)  # Segunda capa oculta con 128 neuronas
        self.fc3 = nn.Linear(128, 10)   # Capa de salida con 10 neuronas

    def forward(self, x):
        x = F.relu(self.fc1(x))  # Función de activación ReLU
        x = F.relu(self.fc2(x))  # Función de activación ReLU
        x = self.fc3(x)
        return x

Conclusión

En esta sección, hemos aprendido a definir y entrenar una red neuronal simple utilizando PyTorch. Hemos cubierto los conceptos básicos de las redes neuronales y cómo implementarlas en código. En el próximo módulo, profundizaremos en las funciones de activación y cómo afectan el rendimiento de nuestras redes neuronales.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados