Introducció
En aquest tema, explorarem els fonaments del perceptró i el perceptró multicapa (MLP), que són els blocs bàsics de les xarxes neuronals. Entendre aquests conceptes és crucial per avançar en l'estudi de les xarxes neuronals més complexes.
Perceptró
Què és un Perceptró?
Un perceptró és la unitat bàsica d'una xarxa neuronal artificial. És un model matemàtic inspirat en les neurones biològiques. Un perceptró pren diverses entrades, les combina linealment i aplica una funció d'activació per produir una sortida.
Components del Perceptró
- Entrades (x1, x2, ..., xn): Els valors d'entrada que el perceptró processa.
- Peses (w1, w2, ..., wn): Els coeficients que multipliquen les entrades. Determinen la importància de cada entrada.
- Biaix (b): Un valor constant que s'afegeix a la combinació lineal de les entrades.
- Funció d'Activació (f): Una funció que transforma la combinació lineal de les entrades en la sortida.
Fórmula del Perceptró
La sortida d'un perceptró es calcula com:
\[ y = f\left(\sum_{i=1}^{n} w_i x_i + b\right) \]
Exemples de Funcions d'Activació
- Funció escaló: Retorna 1 si l'entrada és positiva i 0 en cas contrari.
- Funció sigmoide: Transforma l'entrada en un valor entre 0 i 1.
- Funció ReLU (Rectified Linear Unit): Retorna l'entrada si és positiva, i 0 en cas contrari.
Exemple Pràctic
Considerem un perceptró amb dues entrades \(x_1\) i \(x_2\), amb peses \(w_1 = 0.5\) i \(w_2 = -0.6\), i un biaix \(b = 0.1\). Utilitzem una funció d'activació escaló.
def perceptron(x1, x2):
w1, w2, b = 0.5, -0.6, 0.1
linear_combination = w1 * x1 + w2 * x2 + b
return 1 if linear_combination > 0 else 0
# Exemple d'ús
print(perceptron(1, 1)) # Sortida: 0
print(perceptron(2, -1)) # Sortida: 1Perceptró Multicapa (MLP)
Què és un Perceptró Multicapa?
Un perceptró multicapa (MLP) és una xarxa neuronal composta per múltiples capes de perceptrons. Inclou una capa d'entrada, una o més capes ocultes i una capa de sortida.
Arquitectura del MLP
- Capa d'Entrada: Rep les dades d'entrada.
- Capes Ocultes: Processen les dades d'entrada a través de múltiples perceptrons. Cada capa oculta aplica una funció d'activació.
- Capa de Sortida: Genera la sortida final de la xarxa.
Propagació cap Endavant
En un MLP, les dades es propaguen des de la capa d'entrada fins a la capa de sortida passant per les capes ocultes. Cada capa aplica una combinació lineal de les entrades seguit d'una funció d'activació.
Exemple Pràctic
Considerem un MLP amb una capa d'entrada de dues neurones, una capa oculta de dues neurones i una capa de sortida d'una neurona. Utilitzem la funció d'activació sigmoide.
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def mlp(x1, x2):
# Peses i biaixos de la capa oculta
w11, w12, b1 = 0.5, -0.6, 0.1
w21, w22, b2 = -0.3, 0.8, -0.2
# Peses i biaix de la capa de sortida
w_out1, w_out2, b_out = 0.7, -0.4, 0.2
# Sortides de la capa oculta
h1 = sigmoid(w11 * x1 + w12 * x2 + b1)
h2 = sigmoid(w21 * x1 + w22 * x2 + b2)
# Sortida de la capa de sortida
output = sigmoid(w_out1 * h1 + w_out2 * h2 + b_out)
return output
# Exemple d'ús
print(mlp(1, 1)) # Sortida: 0.645656
print(mlp(2, -1)) # Sortida: 0.668187Exercicis Pràctics
Exercici 1: Implementar un Perceptró
Implementa un perceptró amb tres entrades \(x_1, x_2, x_3\), amb peses \(w_1 = 0.2\), \(w_2 = -0.4\), \(w_3 = 0.6\) i un biaix \(b = -0.1\). Utilitza una funció d'activació escaló.
def perceptron(x1, x2, x3):
w1, w2, w3, b = 0.2, -0.4, 0.6, -0.1
linear_combination = w1 * x1 + w2 * x2 + w3 * x3 + b
return 1 if linear_combination > 0 else 0
# Exemple d'ús
print(perceptron(1, 0, 1)) # Esperat: 1
print(perceptron(0, 1, 0)) # Esperat: 0Exercici 2: Implementar un MLP
Implementa un MLP amb una capa d'entrada de dues neurones, una capa oculta de tres neurones i una capa de sortida d'una neurona. Utilitza la funció d'activació sigmoide.
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def mlp(x1, x2):
# Peses i biaixos de la capa oculta
w11, w12, b1 = 0.5, -0.6, 0.1
w21, w22, b2 = -0.3, 0.8, -0.2
w31, w32, b3 = 0.2, 0.4, 0.3
# Peses i biaix de la capa de sortida
w_out1, w_out2, w_out3, b_out = 0.7, -0.4, 0.5, 0.2
# Sortides de la capa oculta
h1 = sigmoid(w11 * x1 + w12 * x2 + b1)
h2 = sigmoid(w21 * x1 + w22 * x2 + b2)
h3 = sigmoid(w31 * x1 + w32 * x2 + b3)
# Sortida de la capa de sortida
output = sigmoid(w_out1 * h1 + w_out2 * h2 + w_out3 * h3 + b_out)
return output
# Exemple d'ús
print(mlp(1, 1)) # Esperat: 0.668187
print(mlp(2, -1)) # Esperat: 0.645656Conclusió
En aquesta secció, hem après sobre el perceptró i el perceptró multicapa (MLP), que són els fonaments de les xarxes neuronals. Hem vist com es calculen les sortides d'aquestes unitats i hem implementat exemples pràctics per consolidar els conceptes. En el següent tema, explorarem les funcions d'activació en més detall.
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