Introducció
En aquest tema, explorarem els conceptes d'optimització i funció de pèrdua, que són fonamentals per entrenar xarxes neuronals. La funció de pèrdua mesura com de bé està funcionant el model, mentre que els algoritmes d'optimització ajusten els pesos del model per minimitzar aquesta pèrdua.
Conceptes Clau
Funció de Pèrdua
La funció de pèrdua (o funció de cost) és una mètrica que quantifica la discrepància entre les prediccions del model i els valors reals. L'objectiu de l'entrenament és minimitzar aquesta pèrdua.
Tipus de Funcions de Pèrdua
-
Error Quadràtic Mitjà (MSE): \[ MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 \] Utilitzada principalment en problemes de regressió.
-
Entropia Creuada (Cross-Entropy): \[ L = -\frac{1}{n} \sum_{i=1}^{n} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right] \] Utilitzada en problemes de classificació binària.
-
Entropia Creuada Categòrica: \[ L = -\sum_{i=1}^{n} \sum_{j=1}^{k} y_{ij} \log(\hat{y}_{ij}) \] Utilitzada en problemes de classificació multiclasse.
Algoritmes d'Optimització
Els algoritmes d'optimització ajusten els pesos del model per minimitzar la funció de pèrdua. Els més comuns són:
-
Gradient Descent: \[ \theta = \theta - \alpha \nabla_\theta J(\theta) \] On \(\theta\) són els pesos del model, \(\alpha\) és la taxa d'aprenentatge, i \(\nabla_\theta J(\theta)\) és el gradient de la funció de pèrdua respecte als pesos.
-
Stochastic Gradient Descent (SGD): Actualitza els pesos utilitzant un sol exemple de dades a cada iteració, el que pot accelerar l'entrenament però introduir més variabilitat.
-
Mini-batch Gradient Descent: Una combinació de Gradient Descent i SGD, utilitzant petits lots de dades per actualitzar els pesos.
-
Optimitzadors Avançats:
- Adam: Combina les millors propietats de AdaGrad i RMSProp.
- RMSProp: Ajusta la taxa d'aprenentatge per cada paràmetre.
- AdaGrad: Ajusta la taxa d'aprenentatge basant-se en la freqüència de les actualitzacions dels pesos.
Exemples Pràctics
Implementació de la Funció de Pèrdua i Optimització en Python
import numpy as np
# Funció de pèrdua MSE
def mse_loss(y_true, y_pred):
return np.mean((y_true - y_pred) ** 2)
# Gradient Descent
def gradient_descent(X, y, learning_rate=0.01, epochs=1000):
m, n = X.shape
theta = np.zeros(n)
for epoch in range(epochs):
y_pred = X.dot(theta)
loss = mse_loss(y, y_pred)
gradient = (2/m) * X.T.dot(y_pred - y)
theta -= learning_rate * gradient
if epoch % 100 == 0:
print(f'Epoch {epoch}, Loss: {loss}')
return theta
# Exemple d'ús
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y = np.dot(X, np.array([1, 2])) + 3
theta = gradient_descent(X, y)
print(f'Weights: {theta}')Explicació del Codi
- Funció de pèrdua MSE: Calcula l'error quadràtic mitjà entre les prediccions i els valors reals.
- Gradient Descent: Actualitza els pesos del model per minimitzar la funció de pèrdua. El codi imprimeix la pèrdua cada 100 iteracions per monitoritzar l'entrenament.
- Exemple d'ús: Genera dades sintètiques i aplica Gradient Descent per trobar els pesos òptims.
Exercicis Pràctics
Exercici 1: Implementar la funció de pèrdua d'entropia creuada
Implementa la funció de pèrdua d'entropia creuada per un problema de classificació binària.
def binary_cross_entropy_loss(y_true, y_pred):
epsilon = 1e-15
y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
# Exemple d'ús
y_true = np.array([1, 0, 1, 1])
y_pred = np.array([0.9, 0.1, 0.8, 0.7])
loss = binary_cross_entropy_loss(y_true, y_pred)
print(f'Binary Cross-Entropy Loss: {loss}')Solució
def binary_cross_entropy_loss(y_true, y_pred):
epsilon = 1e-15
y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
# Exemple d'ús
y_true = np.array([1, 0, 1, 1])
y_pred = np.array([0.9, 0.1, 0.8, 0.7])
loss = binary_cross_entropy_loss(y_true, y_pred)
print(f'Binary Cross-Entropy Loss: {loss}')Resum
En aquesta secció, hem après sobre la funció de pèrdua i els algoritmes d'optimització, que són essencials per entrenar xarxes neuronals. Hem explorat diferents tipus de funcions de pèrdua i algoritmes d'optimització, i hem implementat exemples pràctics en Python. Aquests conceptes són fonamentals per comprendre com les xarxes neuronals aprenen i milloren amb el temps.
Curs de Deep Learning
Mòdul 1: Introducció a Deep Learning
- Què és Deep Learning?
- Història i evolució del Deep Learning
- Aplicacions de Deep Learning
- Conceptes bàsics de xarxes neuronals
Mòdul 2: Fonaments de Xarxes Neuronals
- Perceptró i Perceptró Multicapa
- Funció d'activació
- Propagació cap endavant i cap enrere
- Optimització i funció de pèrdua
Mòdul 3: Xarxes Neuronals Convolucionals (CNN)
- Introducció a les CNN
- Capes convolutionals i de pooling
- Arquitectures populars de CNN
- Aplicacions de CNN en reconeixement d'imatges
Mòdul 4: Xarxes Neuronals Recurrentes (RNN)
- Introducció a les RNN
- LSTM i GRU
- Aplicacions de RNN en processament del llenguatge natural
- Seqüències i sèries temporals
Mòdul 5: Tècniques Avançades en Deep Learning
- Xarxes Generatives Adversarials (GAN)
- Autoencoders
- Transfer Learning
- Regularització i tècniques de millora
Mòdul 6: Eines i Frameworks
- Introducció a TensorFlow
- Introducció a PyTorch
- Comparació de frameworks
- Entorns de desenvolupament i recursos addicionals
Mòdul 7: Projectes Pràctics
- Classificació d'imatges amb CNN
- Generació de text amb RNN
- Detecció d'anomalies amb Autoencoders
- Creació d'una GAN per generació d'imatges