Impara Challenge: Implementazione di Reti Feed-Forward | Costruire Componenti Dei Transformer

Sezione 2. Capitolo 3

single

Scorri per mostrare il menu

Esplorando l'architettura Transformer per l'elaborazione del linguaggio naturale, si incontra un componente fondamentale all'interno di ogni blocco Transformer: la rete feed-forward position-wise (FFN). Dopo che il meccanismo di self-attention ha elaborato le rappresentazioni in ingresso, la FFN trasforma ulteriormente queste rappresentazioni in ogni posizione della sequenza, in modo indipendente dalle altre posizioni. Questo significa che per ogni token in una frase viene applicata la stessa piccola rete neurale, permettendo al modello di introdurre ulteriore non linearità e apprendere schemi più complessi dal testo. La FFN è essenziale per catturare le relazioni e affinare le informazioni codificate dalla self-attention, soprattutto quando si affrontano le sottigliezze e le ambiguità del linguaggio umano.


              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)

Nel codice sopra è presentata una semplice implementazione di una rete feed-forward position-wise utilizzando numpy. La rete è composta da due trasformazioni lineari (moltiplicazioni di matrici), separate da una funzione di attivazione ReLU.

Definizione

Funzione di attivazione ReLU: L'attivazione ReLU (Rectified Linear Unit) è definita come relu(x) = max(0, x). Imposta tutti i valori negativi a zero e mantiene invariati quelli positivi. ReLU viene utilizzata nella rete feed-forward per introdurre non linearità, consentendo alla rete di apprendere schemi più complessi dai dati.

Il primo strato lineare proietta l'input da d_model dimensioni (la dimensione dell'embedding di ciascun token) a uno spazio a dimensionalità superiore d_ff, permettendo al modello di catturare caratteristiche più complesse. Il secondo strato lineare riporta il risultato alla dimensione originale d_model. Si noti che questa rete viene applicata indipendentemente a ciascuna posizione nella sequenza, il che significa che la trasformazione di un token non influisce direttamente sugli altri. Questa indipendenza aiuta il modello a elaborare la rappresentazione di ciascun token in parallelo, rendendo i Transformer altamente efficienti per i dati testuali.

Compito

Scorri per iniziare a programmare

Implementazione di una funzione di rete feed-forward position-wise utilizzando numpy.

Definire una funzione position_wise_ffn(x, W1, b1, W2, b2) che accetta: