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 les sortides. Sense funcions d'activació, una xarxa neuronal seria simplement una combinació lineal de les seves entrades, limitant la seva capacitat per resoldre problemes complexos.

Tipus de Funcions d'Activació

  1. Funció Sigmoide

La funció sigmoide és una de les funcions d'activació més antigues i utilitzades. Converteix qualsevol valor real en un valor entre 0 i 1.

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

Propietats:

  • Sortida entre 0 i 1.
  • Bona per a problemes de classificació binària.
  • Pot patir el problema del gradient desaparegut.

Exemple de codi:

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

x = np.linspace(-10, 10, 100)
y = sigmoid(x)

plt.plot(x, y)
plt.title('Funció Sigmoide')
plt.xlabel('x')
plt.ylabel('sigmoid(x)')
plt.grid(True)
plt.show()

  1. Funció Tanh (Tangens Hiperbòlic)

La funció tanh és similar a la sigmoide, però la seva sortida està escalada entre -1 i 1.

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

Propietats:

  • Sortida entre -1 i 1.
  • Sovint preferida sobre la sigmoide perquè la seva sortida està centrada en zero.
  • També pot patir el problema del gradient desaparegut.

Exemple de codi:

def tanh(x):
    return np.tanh(x)

y = tanh(x)

plt.plot(x, y)
plt.title('Funció Tanh')
plt.xlabel('x')
plt.ylabel('tanh(x)')
plt.grid(True)
plt.show()

  1. Funció ReLU (Rectified Linear Unit)

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

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

Propietats:

  • Sortida entre 0 i ∞.
  • Resol el problema del gradient desaparegut.
  • Pot patir el problema de "neurones mortes" (valors negatius esdevenen zero permanentment).

Exemple de codi:

def relu(x):
    return np.maximum(0, x)

y = relu(x)

plt.plot(x, y)
plt.title('Funció ReLU')
plt.xlabel('x')
plt.ylabel('ReLU(x)')
plt.grid(True)
plt.show()

  1. Funció Leaky ReLU

La funció Leaky ReLU és una variant de la ReLU que permet un petit gradient per a valors negatius.

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

Propietats:

  • Sortida entre -∞ i ∞.
  • Redueix el problema de "neurones mortes".
  • \(\alpha\) és un petit valor positiu (per exemple, 0.01).

Exemple de codi:

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

y = leaky_relu(x)

plt.plot(x, y)
plt.title('Funció Leaky ReLU')
plt.xlabel('x')
plt.ylabel('Leaky ReLU(x)')
plt.grid(True)
plt.show()

  1. Funció Softmax

La funció Softmax és utilitzada principalment en la capa de sortida per a problemes de classificació multiclasse.

Equació: \[ \text{softmax}(x_i) = \frac{e^{x_i}}{\sum_{j} e^{x_j}} \]

Propietats:

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

Exemple de codi:

def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)

x = np.array([1.0, 2.0, 3.0])
y = softmax(x)

print("Softmax:", y)

Exercicis Pràctics

Exercici 1: Implementar Funcions d'Activació

Implementa les funcions d'activació Sigmoide, Tanh, ReLU i Leaky ReLU en Python i ploteja les seves gràfiques.

Exercici 2: Aplicar Funcions d'Activació en una Xarxa Neuronal

Construeix una xarxa neuronal simple utilitzant TensorFlow i aplica diferents funcions d'activació a les capes ocultes. Observa com afecta el rendiment del model.

Solució de l'Exercici 1:

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def tanh(x):
    return np.tanh(x)

def relu(x):
    return np.maximum(0, x)

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

x = np.linspace(-10, 10, 100)

plt.figure(figsize=(12, 8))

plt.subplot(2, 2, 1)
plt.plot(x, sigmoid(x))
plt.title('Funció Sigmoide')
plt.grid(True)

plt.subplot(2, 2, 2)
plt.plot(x, tanh(x))
plt.title('Funció Tanh')
plt.grid(True)

plt.subplot(2, 2, 3)
plt.plot(x, relu(x))
plt.title('Funció ReLU')
plt.grid(True)

plt.subplot(2, 2, 4)
plt.plot(x, leaky_relu(x))
plt.title('Funció Leaky ReLU')
plt.grid(True)

plt.tight_layout()
plt.show()

Solució de l'Exercici 2:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Generar dades sintètiques
x_train = np.random.rand(1000, 20)
y_train = np.random.randint(2, size=(1000, 1))

# Construir el model
model = Sequential([
    Dense(64, input_dim=20, activation='relu'),
    Dense(64, activation='relu'),
    Dense(1, activation='sigmoid')
])

# Compilar el model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar el model
model.fit(x_train, y_train, epochs=10, batch_size=32)

# Avaluar el model
loss, accuracy = model.evaluate(x_train, y_train)
print(f'Pèrdua: {loss}, Precisió: {accuracy}')

Conclusió

Les funcions d'activació són crucials per al rendiment de les xarxes neuronals, ja que introdueixen no-linealitat i permeten que el model aprengui patrons complexos. Hem explorat diverses funcions d'activació, incloent Sigmoide, Tanh, ReLU, Leaky ReLU i Softmax, i hem vist com implementar-les i utilitzar-les en models de TensorFlow. En el proper tema, ens endinsarem en les funcions de pèrdua i els optimitzadors, components essencials per entrenar xarxes neuronals de manera efectiva.

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