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

HOME

En aquest tema, aprendrem sobre les funcions de pèrdua i els algoritmes d'optimització, que són components essencials per entrenar xarxes neuronals. Les funcions de pèrdua mesuren com de bé o malament està funcionant el model, mentre que els algoritmes d'optimització ajusten els pesos del model per minimitzar la pèrdua.

Funcions de Pèrdua

1.1. Què és una Funció de Pèrdua?

Una funció de pèrdua (o funció de cost) és una funció que mesura la discrepància entre les prediccions del model i els valors reals. L'objectiu de l'entrenament és minimitzar aquesta pèrdua.

1.2. Tipus de Funcions de Pèrdua

1.2.1. Pèrdua de Regressió

Error Quadràtic Mitjà (MSE): Utilitzat per problemes de regressió. Calcula la mitjana dels quadrats de les diferències entre les prediccions i els valors reals.

import torch
import torch.nn as nn

loss_fn = nn.MSELoss()
predictions = torch.tensor([2.5, 0.0, 2.1, 7.8])
targets = torch.tensor([3.0, -0.5, 2.0, 7.5])
loss = loss_fn(predictions, targets)
print(loss.item())  # Output: 0.0975

1.2.2. Pèrdua de Classificació

Entropia Creuada (Cross-Entropy Loss): Utilitzat per problemes de classificació. Mesura la diferència entre la distribució de probabilitats de les prediccions i la distribució de probabilitats dels valors reals.
```
loss_fn = nn.CrossEntropyLoss()
predictions = torch.tensor([[0.2, 0.8], [0.6, 0.4], [0.4, 0.6]])
targets = torch.tensor([1, 0, 1])
loss = loss_fn(predictions, targets)
print(loss.item())  # Output: 0.7136
```

Algoritmes d'Optimització

2.1. Què és un Algoritme d'Optimització?

Un algoritme d'optimització ajusta els pesos del model per minimitzar la funció de pèrdua. Utilitza el gradient de la funció de pèrdua respecte als pesos per actualitzar-los.

2.2. Tipus d'Algoritmes d'Optimització

2.2.1. Descens del Gradient Estocàstic (SGD)

SGD: Actualitza els pesos utilitzant el gradient de la funció de pèrdua respecte als pesos.

import torch.optim as optim

model = nn.Linear(10, 2)  # Exemple de model
optimizer = optim.SGD(model.parameters(), lr=0.01)

2.2.2. Adam

Adam: Combina les millors propietats de l'SGD amb l'optimització de moment i l'adaptació del pas d'aprenentatge.
```
optimizer = optim.Adam(model.parameters(), lr=0.001)
```

Exemple Pràctic

3.1. Definició del Model

import torch
import torch.nn as nn
import torch.optim as optim

# Definim una xarxa neuronal simple
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNN()

3.2. Definició de la Funció de Pèrdua i l'Optimitzador

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

3.3. Entrenament del Model

# Dades d'exemple
inputs = torch.randn(5, 10)
targets = torch.tensor([1, 0, 1, 0, 1])

# Bucle d'entrenament
for epoch in range(100):
    # Forward pass
    outputs = model(inputs)
    loss = loss_fn(outputs, targets)

    # Backward pass i optimització
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

Exercicis Pràctics

Exercici 1: Implementar una Funció de Pèrdua Personalitzada

Implementa una funció de pèrdua personalitzada que calculi l'error absolut mitjà (MAE).

class MAELoss(nn.Module):
    def __init__(self):
        super(MAELoss, self).__init__()

    def forward(self, predictions, targets):
        return torch.mean(torch.abs(predictions - targets))

# Solució
loss_fn = MAELoss()
predictions = torch.tensor([2.5, 0.0, 2.1, 7.8])
targets = torch.tensor([3.0, -0.5, 2.0, 7.5])
loss = loss_fn(predictions, targets)
print(loss.item())  # Output: 0.35

Exercici 2: Entrenar un Model amb SGD

Entrena un model simple utilitzant l'optimitzador SGD i compara els resultats amb l'optimitzador Adam.

# Definició del model
model = SimpleNN()

# Definició de la funció de pèrdua i l'optimitzador
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Dades d'exemple
inputs = torch.randn(5, 10)
targets = torch.tensor([1, 0, 1, 0, 1])

# Bucle d'entrenament
for epoch in range(100):
    outputs = model(inputs)
    loss = loss_fn(outputs, targets)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')

Conclusió

En aquesta secció, hem après sobre les funcions de pèrdua i els algoritmes d'optimització, que són fonamentals per entrenar xarxes neuronals. Hem vist exemples pràctics de com utilitzar aquestes eines amb PyTorch i hem practicat amb exercicis per reforçar els conceptes apresos. En el següent mòdul, ens endinsarem en el procés d'entrenament de xarxes neuronals, incloent la càrrega i preprocessament de dades, el bucle d'entrenament, la validació i la prova.

Funcions de Pèrdua i Optimització