El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquest tema, aprendrem a construir una Xarxa Neuronal Convolucional (CNN) des de zero utilitzant PyTorch. Les CNNs són especialment efectives per a tasques de visió per computador, com la classificació d'imatges, la detecció d'objectes i la segmentació d'imatges.

Objectius

Entendre l'arquitectura bàsica d'una CNN.
Aprendre a implementar una CNN utilitzant PyTorch.
Entrenar la CNN amb un conjunt de dades d'imatges.
Avaluar el rendiment de la CNN.

Arquitectura Bàsica d'una CNN

Una CNN típica consta de les següents capes:

Capes Convolucionals: Extreuen característiques de les imatges.
Capes de Pooling: Redueixen la dimensionalitat de les característiques.
Capes Completament Connectades: Fan la classificació final.

Exemples de Capes

Convolucional: nn.Conv2d
ReLU: nn.ReLU
Max Pooling: nn.MaxPool2d
Completament Connectada: nn.Linear

Implementació d'una CNN amb PyTorch

2.1. Importar Llibreries Necessàries

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets, transforms

2.2. Definir la Xarxa Neuronal

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 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, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

2.3. Preparar les Dades

Utilitzarem el conjunt de dades MNIST per a la classificació de dígits.

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

train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, download=True, transform=transform)

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)

2.4. Entrenar la Xarxa

def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.cross_entropy(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} ({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')

2.5. Avaluar la Xarxa

def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.cross_entropy(output, target, reduction='sum').item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.0f}%)\n')

2.6. Executar l'Entrenament i la Prova

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleCNN().to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(1, 11):
    train(model, device, train_loader, optimizer, epoch)
    test(model, device, test_loader)

Exercicis Pràctics

Modifica la Xarxa: Afegeix una tercera capa convolucional i observa com canvia el rendiment.
Canvia el Conjunt de Dades: Utilitza un altre conjunt de dades, com CIFAR-10, i adapta la xarxa per treballar amb imatges RGB.
Ajusta els Hiperparàmetres: Experimenta amb diferents valors de batch_size, learning_rate i optimizer.

Conclusió

En aquesta secció, hem après a construir una CNN des de zero utilitzant PyTorch. Hem cobert la definició de l'arquitectura, la preparació de les dades, l'entrenament i l'avaluació del model. Aquestes habilitats són fonamentals per a qualsevol projecte de visió per computador. En el següent tema, explorarem l'aprenentatge per transferència amb models preentrenats per millorar encara més el rendiment de les nostres xarxes neuronals.

Construcció d'una CNN des de Zero

Objectius

Arquitectura Bàsica d'una CNN

Exemples de Capes

Implementació d'una CNN amb PyTorch

2.1. Importar Llibreries Necessàries

2.2. Definir la Xarxa Neuronal

2.3. Preparar les Dades

2.4. Entrenar la Xarxa

2.5. Avaluar la Xarxa

2.6. Executar l'Entrenament i la Prova

Exercicis Pràctics

Conclusió

PyTorch: De Principiant a Avançat

Mòdul 1: Introducció a PyTorch

Mòdul 2: Construcció de Xarxes Neuronals

Mòdul 3: Entrenament de Xarxes Neuronals

Mòdul 4: Xarxes Neuronals Convolucionals (CNNs)

Mòdul 5: Xarxes Neuronals Recurrents (RNNs)

Mòdul 6: Temes Avançats

Mòdul 7: Estudis de Cas i Projectes