El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Funciones de Activación

Siguiente ►
►

Las funciones de activación son un componente crucial en las redes neuronales, ya que introducen no linealidades en el modelo, permitiendo que la red aprenda y represente relaciones complejas en los datos. En esta sección, exploraremos las funciones de activación más comunes utilizadas en PyTorch, sus características y cómo implementarlas.

Objetivos de Aprendizaje

Al final de esta sección, deberías ser capaz de:

  1. Comprender el propósito de las funciones de activación en las redes neuronales.
  2. Conocer las funciones de activación más comunes y sus propiedades.
  3. Implementar funciones de activación en PyTorch.

  1. ¿Qué es una Función de Activación?

Una función de activación es una función matemática que se aplica a la salida de una neurona en una red neuronal. Su propósito principal es introducir no linealidades en el modelo, lo que permite a la red neuronal aprender y modelar relaciones complejas en los datos.

Propiedades Clave de las Funciones de Activación

  • No linealidad: Permite que la red neuronal aprenda funciones complejas.
  • Derivabilidad: La función debe ser diferenciable para permitir la retropropagación.
  • Rango de salida: Algunas funciones de activación tienen un rango de salida específico que puede ser útil en diferentes contextos.

  1. Funciones de Activación Comunes

2.1. Sigmoid

La función Sigmoid es una de las funciones de activación más antiguas y se define como:

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

Características

  • Rango de salida: (0, 1)
  • Ventajas: Suaviza la salida, útil para problemas de clasificación binaria.
  • Desventajas: Problemas de desvanecimiento del gradiente.

Implementación en PyTorch

import torch
import torch.nn as nn

# Definición de la función Sigmoid
sigmoid = nn.Sigmoid()

# Ejemplo de uso
x = torch.tensor([-1.0, 0.0, 1.0])
output = sigmoid(x)
print(output)

2.2. Tanh

La función Tanh es otra función de activación comúnmente utilizada y se define como:

\[ \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} \]

Características

  • Rango de salida: (-1, 1)
  • Ventajas: Centrada en cero, lo que puede ayudar a la convergencia.
  • Desventajas: También sufre de problemas de desvanecimiento del gradiente.

Implementación en PyTorch

# Definición de la función Tanh
tanh = nn.Tanh()

# Ejemplo de uso
output = tanh(x)
print(output)

2.3. ReLU (Rectified Linear Unit)

La función ReLU es una de las funciones de activación más populares en redes neuronales modernas y se define como:

\[ \text{ReLU}(x) = \max(0, x) \]

Características

  • Rango de salida: [0, ∞)
  • Ventajas: Simple y eficiente, ayuda a mitigar el problema del desvanecimiento del gradiente.
  • Desventajas: Problemas de "neurona muerta" donde las neuronas pueden quedar atrapadas en la región de salida cero.

Implementación en PyTorch

# Definición de la función ReLU
relu = nn.ReLU()

# Ejemplo de uso
output = relu(x)
print(output)

2.4. Leaky ReLU

La función Leaky ReLU es una variante de ReLU que intenta resolver el problema de la "neurona muerta" permitiendo un pequeño gradiente cuando la entrada es negativa:

\[ \text{Leaky ReLU}(x) = \max(0.01x, x) \]

Características

  • Rango de salida: (-∞, ∞)
  • Ventajas: Mitiga el problema de la "neurona muerta".
  • Desventajas: Introduce un hiperparámetro adicional (la pendiente para valores negativos).

Implementación en PyTorch

# Definición de la función Leaky ReLU
leaky_relu = nn.LeakyReLU(0.01)

# Ejemplo de uso
output = leaky_relu(x)
print(output)

2.5. Softmax

La función Softmax se utiliza principalmente en la capa de salida de una red neuronal para problemas de clasificación multiclase. Se define como:

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

Características

  • Rango de salida: (0, 1), la suma de todas las salidas es 1.
  • Ventajas: Convierte las salidas en probabilidades.
  • Desventajas: No es adecuada para capas ocultas debido a la falta de no linealidad.

Implementación en PyTorch

# Definición de la función Softmax
softmax = nn.Softmax(dim=0)

# Ejemplo de uso
output = softmax(x)
print(output)

  1. Ejercicio Práctico

Ejercicio

Implementa una red neuronal simple en PyTorch que utilice diferentes funciones de activación en sus capas ocultas. Compara el rendimiento de la red utilizando ReLU y Tanh.

Solución

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Generar datos de ejemplo
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Escalar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Convertir a tensores
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
y_test = torch.tensor(y_test, dtype=torch.long)

# Definir la red neuronal
class SimpleNN(nn.Module):
    def __init__(self, activation_fn):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(2, 10)
        self.activation = activation_fn
        self.fc2 = nn.Linear(10, 2)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.activation(x)
        x = self.fc2(x)
        return x

# Entrenar y evaluar la red
def train_and_evaluate(activation_fn):
    model = SimpleNN(activation_fn)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.01)
    
    # Entrenamiento
    for epoch in range(100):
        optimizer.zero_grad()
        outputs = model(X_train)
        loss = criterion(outputs, y_train)
        loss.backward()
        optimizer.step()
    
    # Evaluación
    with torch.no_grad():
        outputs = model(X_test)
        _, predicted = torch.max(outputs, 1)
        accuracy = (predicted == y_test).float().mean()
        print(f'Accuracy with {activation_fn}: {accuracy.item()}')

# Comparar ReLU y Tanh
train_and_evaluate(nn.ReLU())
train_and_evaluate(nn.Tanh())

Conclusión

En esta sección, hemos explorado las funciones de activación más comunes utilizadas en redes neuronales, sus características y cómo implementarlas en PyTorch. Las funciones de activación juegan un papel crucial en la capacidad de una red neuronal para aprender y modelar relaciones complejas en los datos. En la próxima sección, profundizaremos en las funciones de pérdida y los métodos de optimización, que son esenciales para entrenar redes neuronales de manera efectiva.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados