Creando nuestra primera red convolucional

Clase 4 de 25 • Curso de Redes Neuronales Convolucionales con Python y Keras

Mario Alexander Vargas Celis

student•

Crear tu primera **red convolucional** (CNN) en PyTorch es un gran paso para aprender sobre el uso de las CNN en la visión por computadora. A continuación te mostraré cómo se puede construir una CNN simple para la clasificación de imágenes usando PyTorch.

Este ejemplo usará el conjunto de datos **CIFAR-10**, que es un conjunto estándar para la clasificación de imágenes en 10 categorías (aviones, autos, gatos, etc.).

### 1. Preparar el entorno

Primero, asegúrate de tener las bibliotecas necesarias instaladas. Si no las tienes, puedes instalarlas utilizando pip:


pip install torch torchvision

### 2. Importar las bibliotecas necesarias


import torch

import torch.nn as nn

import torch.optim as optim

import torch.nn.functional as F

from torchvision import datasets, transforms

from torch.utils.data import DataLoader

### 3. Cargar el conjunto de datos (CIFAR-10)

Aquí usamos torchvision para cargar el conjunto de datos CIFAR-10, que se dividirá en conjuntos de entrenamiento y prueba, y se aplicarán algunas transformaciones como la normalización y el redimensionamiento.


\# Definir transformaciones para normalizar y convertir a tensor

transform = transforms.Compose(\[

&#x20;   transforms.ToTensor(),

&#x20;   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

])



\# Descargar el conjunto de datos CIFAR-10

train\_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)

test\_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)



\# Cargar los datos en mini-lotes

train\_loader = DataLoader(train\_dataset, batch\_size=32, shuffle=True)

test\_loader = DataLoader(test\_dataset, batch\_size=32, shuffle=False)

### 4. Definir la arquitectura de la red convolucional

A continuación, definimos nuestra primera red convolucional simple, que incluye varias capas convolucionales, capas de activación ReLU, max pooling y capas completamente conectadas.


class SimpleCNN(nn.Module):

&#x20;   def \_\_init\_\_(self):

&#x20;       super(SimpleCNN, self).\_\_init\_\_()

&#x20;       \# Primera capa convolucional: Conv2d(input\_channels, output\_channels, kernel\_size)

&#x20;       self.conv1 = nn.Conv2d(3, 32, kernel\_size=3, padding=1)

&#x20;       self.conv2 = nn.Conv2d(32, 64, kernel\_size=3, padding=1)

&#x20;      &#x20;

&#x20;       \# Max Pooling layer

&#x20;       self.pool = nn.MaxPool2d(kernel\_size=2, stride=2)

&#x20;      &#x20;

&#x20;       \# Fully connected layers

&#x20;       self.fc1 = nn.Linear(64 \* 8 \* 8, 512)  # CIFAR-10 images are 32x32, so after pooling, they're 8x8

&#x20;       self.fc2 = nn.Linear(512, 10)  # 10 output classes (for CIFAR-10)

&#x20;  &#x20;

&#x20;   def forward(self, x):

&#x20;       \# Aplicar la primera capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv1(x)))

&#x20;      &#x20;

&#x20;       \# Segunda capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv2(x)))

&#x20;      &#x20;

&#x20;       \# Aplanar los datos para conectarlos a las capas completamente conectadas

&#x20;       x = x.view(-1, 64 \* 8 \* 8)

&#x20;      &#x20;

&#x20;       \# Capa completamente conectada seguida de ReLU

&#x20;       x = F.relu(self.fc1(x))

&#x20;      &#x20;

&#x20;       \# Capa de salida (no necesitamos una activación aquí, ya que usaremos CrossEntropyLoss más adelante)

&#x20;       x = self.fc2(x)

&#x20;       return x

### 5. Definir el criterio de pérdida y el optimizador

Usaremos la **pérdida de entropía cruzada** (CrossEntropyLoss) para la clasificación, y el optimizador **Adam**, que es eficiente para entrenar redes neuronales.


model = SimpleCNN()



\# Criterio de pérdida y optimizador

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=0.001)

### 6. Entrenar el modelo

Ahora, escribimos el bucle de entrenamiento para optimizar el modelo sobre el conjunto de datos de entrenamiento.


\# Entrenamiento

num\_epochs = 10  # Número de épocas de entrenamiento



for epoch in range(num\_epochs):

&#x20;   running\_loss = 0.0

&#x20;   for images, labels in train\_loader:

&#x20;       \# Forward pass

&#x20;       outputs = model(images)

&#x20;       loss = criterion(outputs, labels)

&#x20;      &#x20;

&#x20;       \# Backward pass y optimización

&#x20;       optimizer.zero\_grad()

&#x20;       loss.backward()

&#x20;       optimizer.step()

&#x20;      &#x20;

&#x20;       running\_loss += loss.item()

&#x20;  &#x20;

&#x20;   print(f'Epoch \[{epoch + 1}/{num\_epochs}], Loss: {running\_loss/len(train\_loader):.4f}')

### 7. Evaluar el modelo

Después de entrenar, evaluamos el rendimiento del modelo en el conjunto de datos de prueba.


\# Evaluación

correct = 0

total = 0



with torch.no\_grad():

&#x20;   for images, labels in test\_loader:

&#x20;       outputs = model(images)

&#x20;       \_, predicted = torch.max(outputs.data, 1)

&#x20;       total += labels.size(0)

&#x20;       correct += (predicted == labels).sum().item()



print(f'Accuracy: {100 \* correct / total:.2f}%')

### 8. Ejecutar todo el proceso

Este código cargará el conjunto de datos CIFAR-10, entrenará una red convolucional simple durante 10 épocas y calculará la precisión del modelo en los datos de prueba. Con esto, ya tienes una CNN básica implementada en PyTorch.

### Posibles mejoras:

- **Aumentar la profundidad de la red**: Se pueden agregar más capas convolucionales.

- **Ajustar hiperparámetros**: Modificar el tamaño del lote, el número de épocas, o usar técnicas de regularización como el dropout.

- **Entrenar en GPU**: Si tienes acceso a una GPU, puedes mover el modelo y los datos a la GPU usando .to('cuda').

Este es solo el comienzo, y las redes convolucionales tienen muchas aplicaciones avanzadas que puedes explorar conforme te familiarices más con ellas.

Creando nuestra primera red convolucional

Redes convolucionales y su importancia

La importancia del computer vision

¿Qué herramientas usaremos para redes neuronales convolucionales?

¿Qué son las redes convolucionales?

Mi primera red neuronal convolucional

Creando nuestra primera red convolucional

Entrenando nuestra primera red convolucional

Manejo de imágenes

Consejos para el manejo de imágenes

Manejo de imágenes con Python

Fundamentos de redes neuronales convolucionales

Kernel en redes neuronales

El kernel en acción

Padding y Strides

Capa de pooling

Arquitectura de redes convolucionales

Resolviendo un problema de clasificación

Clasificación con redes neuronales convolucionales

Creación de red convolucional para clasificación

Entrenamiento de un modelo de clasificación con redes convolucionales

Optimización de red neuronal convolucional

Data augmentation

Aplicando data augmentation

Callbacks: early stopping y checkpoints

Batch normalization

Optimización de modelo de clasificación

Entrenamiento de nuestro modelo de clasificación optimizado

Resolviendo una competencia de Kaggle

Clasificando entre perros y gatos

Entrenamiento del modelo de clasificación de perros y gatos

Resumen y siguientes pasos

Siguientes pasos con redes neuronales convolucionales

Comparte tu proyecto de clasificación con redes convolucionales y certifícate