El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Introducció a les CNNs

Següent ►
►

Què són les Xarxes Neuronals Convolucionals (CNNs)?

Les Xarxes Neuronals Convolucionals (CNNs) són un tipus especial de xarxa neuronal dissenyada específicament per processar dades amb una estructura de graella, com ara imatges. Les CNNs han demostrat ser extremadament efectives en tasques de visió per computador, com ara la classificació d'imatges, la detecció d'objectes i la segmentació d'imatges.

Característiques Clau de les CNNs

  1. Convolucions:

    • Les convolucions són operacions matemàtiques que combinen dues funcions per produir una tercera funció. En el context de les CNNs, les convolucions s'utilitzen per extreure característiques de les imatges.
    • Les convolucions es realitzen mitjançant filtres (o kernels) que es desplacen sobre la imatge d'entrada per produir mapes de característiques.

  2. Capas de Pooling:

    • Les capes de pooling redueixen la dimensionalitat dels mapes de característiques, mantenint les característiques més importants.
    • Els tipus més comuns de pooling són el max pooling i l'average pooling.

  3. Capas Completament Connectades:

    • Després de diverses capes convolucionals i de pooling, les CNNs solen tenir una o més capes completament connectades (fully connected layers) que fan la classificació final.

  4. ReLU (Rectified Linear Unit):

    • La funció d'activació ReLU s'utilitza per introduir no linealitat en el model, permetent que la xarxa aprengui relacions no lineals.

Arquitectura Bàsica d'una CNN

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

  1. Capa d'Entrada:

    • Rep la imatge d'entrada, que normalment és una matriu de píxels.

  2. Capas Convolucionals:

    • Apliquen filtres a la imatge d'entrada per extreure mapes de característiques.

  3. Capas de Pooling:

    • Redueixen la dimensionalitat dels mapes de característiques.

  4. Capas Completament Connectades:

    • Fan la classificació final basant-se en les característiques extretes.

  5. Capa de Sortida:

    • Proporciona la predicció final del model.

Exemple Pràctic: Construcció d'una CNN Simple amb PyTorch

A continuació, construirem una CNN simple utilitzant PyTorch per classificar imatges del dataset MNIST.

Pas 1: Importar les Llibreries Necessàries

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

Pas 2: Definir la Xarxa Neuronal

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        self.relu = nn.ReLU()

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

Pas 3: Preparar les Dades

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

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

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

Pas 4: Entrenar la Xarxa

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

for epoch in range(10):  # nombre d'epochs
    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 % 100 == 99:  # imprimir cada 100 mini-batches
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0

print('Entrenament completat')

Pas 5: Provar la Xarxa

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'Precisió de la xarxa en les 10000 imatges de test: {100 * correct / total:.2f}%')

Resum

En aquesta secció, hem introduït les Xarxes Neuronals Convolucionals (CNNs) i hem explorat les seves característiques clau, com les convolucions, les capes de pooling i les capes completament connectades. També hem construït una CNN simple utilitzant PyTorch per classificar imatges del dataset MNIST. En el següent tema, aprofundirem en la construcció d'una CNN des de zero, explorant més detalls i tècniques avançades.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats