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

Funcions d'Activació

Següent ►
►

Les funcions d'activació són components essencials en les xarxes neuronals, ja que introdueixen no-linealitat en el model, permetent que la xarxa aprengui relacions complexes entre les dades d'entrada i sortida. En aquesta secció, explorarem les funcions d'activació més comunes utilitzades en les xarxes neuronals.

Objectius d'Aprenentatge

  • Comprendre la importància de les funcions d'activació.
  • Conèixer les funcions d'activació més utilitzades.
  • Implementar funcions d'activació en PyTorch.

  1. Importància de les Funcions d'Activació

Les funcions d'activació transformen la sortida lineal d'una neurona en una sortida no-lineal. Sense aquestes funcions, una xarxa neuronal, independentment del nombre de capes, es comportaria com un model lineal. Les funcions d'activació permeten que la xarxa aprengui patrons complexos i no-lineals.

  1. Funcions d'Activació Comunes

2.1. Sigmoid

La funció sigmoid és una funció logística que mapeja qualsevol valor real a un rang entre 0 i 1.

Matemàticament: \[ \sigma(x) = \frac{1}{1 + e^{-x}} \]

Propietats:

  • Sortida entre 0 i 1.
  • Bona per a la sortida de probabilitats.
  • Pot patir de gradients que desapareixen.

Implementació en PyTorch:

import torch
import torch.nn as nn

sigmoid = nn.Sigmoid()
x = torch.tensor([-1.0, 0.0, 1.0])
output = sigmoid(x)
print(output)

2.2. Tanh

La funció tanh (tangent hiperbòlica) mapeja qualsevol valor real a un rang entre -1 i 1.

Matemàticament: \[ \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} \]

Propietats:

  • Sortida entre -1 i 1.
  • Centrada en zero, el que pot ajudar a la convergència.
  • També pot patir de gradients que desapareixen.

Implementació en PyTorch:

tanh = nn.Tanh()
output = tanh(x)
print(output)

2.3. ReLU (Rectified Linear Unit)

La funció ReLU és una de les funcions d'activació més utilitzades en xarxes neuronals profundes.

Matemàticament: \[ \text{ReLU}(x) = \max(0, x) \]

Propietats:

  • Simple i eficient.
  • No pateix de gradients que desapareixen.
  • Pot patir de neurones mortes (valors que queden a zero).

Implementació en PyTorch:

relu = nn.ReLU()
output = relu(x)
print(output)

2.4. Leaky ReLU

La funció Leaky ReLU és una variant de la ReLU que permet un petit gradient quan l'entrada és negativa.

Matemàticament: \[ \text{Leaky ReLU}(x) = \begin{cases} x & \text{si } x > 0
\alpha x & \text{si } x \leq 0 \end{cases} \]

Propietats:

  • Evita el problema de neurones mortes.
  • \(\alpha\) és un petit valor positiu (per exemple, 0.01).

Implementació en PyTorch:

leaky_relu = nn.LeakyReLU(0.01)
output = leaky_relu(x)
print(output)

2.5. Softmax

La funció Softmax es sol utilitzar a la capa de sortida per a problemes de classificació multiclasse.

Matemàticament: \[ \text{Softmax}(x_i) = \frac{e^{x_i}}{\sum_{j} e^{x_j}} \]

Propietats:

  • Converteix les sortides en probabilitats.
  • La suma de les sortides és 1.

Implementació en PyTorch:

softmax = nn.Softmax(dim=0)
output = softmax(x)
print(output)

  1. Implementació en una Xarxa Neuronal

Vegem com utilitzar aquestes funcions d'activació en una xarxa neuronal simple amb PyTorch.

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.relu = nn.ReLU()
        self.fc2 = nn.Linear(50, 1)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.sigmoid(x)
        return x

# Creem una instància de la xarxa
model = SimpleNN()

# Definim una pèrdua i un optimitzador
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Exemple de dades d'entrada
inputs = torch.randn(1, 10)
labels = torch.tensor([1.0])

# Forward pass
outputs = model(inputs)
loss = criterion(outputs, labels)

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

print(f'Sortida: {outputs.item()}, Pèrdua: {loss.item()}')

Exercicis Pràctics

  1. Implementa una xarxa neuronal amb la funció d'activació Tanh en lloc de ReLU.
  2. Experimenta amb Leaky ReLU canviant el valor de \(\alpha\). Observa com afecta l'entrenament.
  3. Utilitza la funció Softmax en una xarxa per a un problema de classificació multiclasse.

Solucions

Exercici 1: Implementació amb Tanh

class SimpleNN_Tanh(nn.Module):
    def __init__(self):
        super(SimpleNN_Tanh, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.tanh = nn.Tanh()
        self.fc2 = nn.Linear(50, 1)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.tanh(x)
        x = self.fc2(x)
        x = self.sigmoid(x)
        return x

Exercici 2: Experimentació amb Leaky ReLU

class SimpleNN_LeakyReLU(nn.Module):
    def __init__(self, alpha=0.01):
        super(SimpleNN_LeakyReLU, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.leaky_relu = nn.LeakyReLU(alpha)
        self.fc2 = nn.Linear(50, 1)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.leaky_relu(x)
        x = self.fc2(x)
        x = self.sigmoid(x)
        return x

Exercici 3: Classificació Multiclasse amb Softmax

class SimpleNN_Softmax(nn.Module):
    def __init__(self):
        super(SimpleNN_Softmax, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(50, 3)  # Suposem 3 classes
        self.softmax = nn.Softmax(dim=1)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x

Resum

En aquesta secció, hem après sobre les funcions d'activació més comunes utilitzades en les xarxes neuronals, incloent Sigmoid, Tanh, ReLU, Leaky ReLU i Softmax. Hem vist com implementar-les en PyTorch i com utilitzar-les en una xarxa neuronal simple. Les funcions d'activació són crucials per introduir no-linealitat en el model i permetre que la xarxa aprengui relacions complexes.

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