Apprendre Challenge: Implémentation des Réseaux Feed-Forward | Construction des Composants de Transformer

Section 2. Chapitre 3

single

Glissez pour afficher le menu

En explorant l’architecture Transformer pour le traitement du langage naturel, vous rencontrez un composant essentiel à l’intérieur de chaque bloc Transformer : le réseau feed-forward positionnel (FFN). Après que le mécanisme d’auto-attention a traité les représentations d’entrée, le FFN transforme davantage ces représentations à chaque position de la séquence, indépendamment des autres positions. Cela signifie que pour chaque jeton d’une phrase, le même petit réseau de neurones est appliqué, permettant au modèle d’introduire une non-linéarité supplémentaire et d’apprendre des motifs plus complexes à partir du texte. Le FFN est essentiel pour capturer les relations et affiner l’information encodée par l’auto-attention, en particulier lors du traitement des subtilités et ambiguïtés du langage humain.


              123456789101112131415161718192021222324252627282930313233
            
import numpy as np

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

class PositionWiseFeedForward:
    def __init__(self, d_model, d_ff):
        # Initialize weights and biases for two linear layers
        self.W1 = np.random.randn(d_model, d_ff) * 0.01
        self.b1 = np.zeros((1, d_ff))
        self.W2 = np.random.randn(d_ff, d_model) * 0.01
        self.b2 = np.zeros((1, d_model))
    
    def __call__(self, x):
        # x shape: (batch_size, seq_len, d_model)
        # Apply first linear layer and ReLU activation
        out1 = relu(np.matmul(x, self.W1) + self.b1)
        # Apply second linear layer
        out2 = np.matmul(out1, self.W2) + self.b2
        return out2

# Example usage:
batch_size = 2
seq_len = 4
d_model = 8
d_ff = 16

# Example input: random tensor simulating text representations
x = np.random.randn(batch_size, seq_len, d_model)

ffn = PositionWiseFeedForward(d_model, d_ff)
output = ffn(x)
print("Output shape:", output.shape)

Dans le code ci-dessus, vous voyez une implémentation simple d’un réseau feed-forward positionnel utilisant numpy. Le réseau se compose de deux transformations linéaires (multiplications de matrices), séparées par une fonction d’activation ReLU.

Définition

Fonction d'activation ReLU : L'activation ReLU (Rectified Linear Unit) est définie comme relu(x) = max(0, x). Elle remplace toutes les valeurs négatives par zéro et conserve les valeurs positives inchangées. ReLU est utilisée dans le réseau feed-forward pour introduire de la non-linéarité, permettant ainsi au réseau d'apprendre des motifs plus complexes à partir des données.

La première couche linéaire projette l'entrée depuis les dimensions d_model (la taille de l'embedding de chaque token) vers un espace de dimension supérieure d_ff, permettant au modèle de capturer des caractéristiques plus complexes. La seconde couche linéaire projette le résultat vers la taille d'origine d_model. Il est important de noter que ce réseau est appliqué indépendamment à chaque position dans la séquence, ce qui signifie que la transformation d'un token n'affecte pas directement les autres. Cette indépendance aide le modèle à traiter la représentation de chaque token en parallèle, rendant les Transformers très efficaces pour les données textuelles.

Tâche

Glissez pour commencer à coder

Implémentation d'une fonction de réseau feed-forward positionnel à l'aide de numpy.

Définir une fonction position_wise_ffn(x, W1, b1, W2, b2) qui prend en entrée :

x : un tableau numpy de forme (batch_size, seq_len, d_model) ;
W1 : un tableau numpy de forme (d_model, d_ff) ;
b1 : un tableau numpy de forme (1, d_ff) ;
W2 : un tableau numpy de forme (d_ff, d_model) ;
b2 : un tableau numpy de forme (1, d_model).

Pour chaque position dans la séquence, appliquer :

Une transformation linéaire : out1 = x @ W1 + b1 ;
Une activation ReLU : out1 = relu(out1) ;
Une seconde transformation linéaire : out2 = out1 @ W2 + b2.

Retourner le tableau de sortie out2 de forme (batch_size, seq_len, d_model).

Solution

Passez à un bureau pour une pratique réelleContinuez d'où vous êtes en utilisant l'une des options ci-dessous

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 3

single

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion