El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este proyecto, aplicaremos los conocimientos adquiridos a lo largo del curso para construir un modelo de clasificación de imágenes utilizando PyTorch. Este proyecto te permitirá consolidar tus habilidades y entender cómo se integran los diferentes componentes de una red neuronal en un caso práctico.

Objetivos del Proyecto

Carga y Preprocesamiento de Datos: Aprender a cargar y preprocesar un conjunto de datos de imágenes.
Construcción del Modelo: Diseñar y construir una red neuronal convolucional (CNN) para la clasificación de imágenes.
Entrenamiento del Modelo: Entrenar la red neuronal utilizando PyTorch.
Evaluación del Modelo: Evaluar el rendimiento del modelo en un conjunto de datos de prueba.
Guardar y Cargar el Modelo: Guardar el modelo entrenado y cargarlo para realizar predicciones.

Paso 1: Carga y Preprocesamiento de Datos

1.1 Importar Librerías Necesarias

import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

1.2 Definir Transformaciones

Las transformaciones se utilizan para preprocesar las imágenes antes de pasarlas a la red neuronal.

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

1.3 Cargar el Conjunto de Datos

Utilizaremos el conjunto de datos CIFAR-10 para este proyecto.

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = DataLoader(testset, batch_size=32, shuffle=False)

Paso 2: Construcción del Modelo

2.1 Definir la Arquitectura de la CNN

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

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 32 * 8 * 8)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

net = SimpleCNN()

Paso 3: Entrenamiento del Modelo

3.1 Definir la Función de Pérdida y el Optimizador

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

3.2 Entrenar la Red Neuronal

for epoch in range(10):  # número de épocas
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 2000 == 1999:  # imprimir cada 2000 mini-batches
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('Finished Training')

Paso 4: Evaluación del Modelo

4.1 Evaluar en el Conjunto de Prueba

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total:.2f}%')

Paso 5: Guardar y Cargar el Modelo

5.1 Guardar el Modelo

torch.save(net.state_dict(), 'simple_cnn.pth')

5.2 Cargar el Modelo

net = SimpleCNN()
net.load_state_dict(torch.load('simple_cnn.pth'))

Ejercicios Prácticos

Ejercicio 1: Mejorar la Precisión del Modelo

Descripción: Intenta mejorar la precisión del modelo ajustando los hiperparámetros, añadiendo más capas, o utilizando técnicas de regularización como Dropout.
Pista: Puedes cambiar la tasa de aprendizaje, el número de épocas, o la arquitectura de la red.

Ejercicio 2: Visualización de Resultados

Descripción: Implementa una función para visualizar algunas imágenes de prueba junto con sus predicciones.
Pista: Utiliza matplotlib para mostrar las imágenes y las etiquetas predichas.

Ejercicio 3: Implementar Data Augmentation

Descripción: Añade técnicas de aumento de datos (Data Augmentation) para mejorar la generalización del modelo.
Pista: Utiliza transformaciones como RandomHorizontalFlip, RandomCrop, etc.

Conclusión

En este proyecto, hemos cubierto el flujo completo de un proyecto de clasificación de imágenes utilizando PyTorch, desde la carga y preprocesamiento de datos hasta la construcción, entrenamiento y evaluación de un modelo de red neuronal convolucional. Este proyecto te proporciona una base sólida para abordar problemas de clasificación de imágenes más complejos y te prepara para explorar técnicas avanzadas en el campo del aprendizaje profundo.

Proyecto de Clasificación de Imágenes