Lära Challenge: Implementering av Feed-Forward-Nätverk

Avsnitt 2. Kapitel 3

single

Svep för att visa menyn

När du utforskar Transformer-arkitekturen för naturlig språkbehandling stöter du på en avgörande komponent i varje Transformer-block: positionsvis feed-forward-nätverk (FFN). Efter att självuppmärksamhetsmekanismen har bearbetat inmatningsrepresentationerna, transformerar FFN dessa representationer ytterligare på varje position i sekvensen, oberoende av andra positioner. Detta innebär att för varje token i en mening tillämpas samma lilla neurala nätverk, vilket gör det möjligt för modellen att införa ytterligare icke-linjäritet och lära sig mer komplexa mönster från texten. FFN är avgörande för att fånga relationer och förfina informationen som kodas av självuppmärksamheten, särskilt när det gäller nyanser och tvetydigheter i mänskligt språk.


              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)

I koden ovan ser du en enkel implementation av ett positionsvis feed-forward-nätverk med hjälp av numpy. Nätverket består av två linjära transformationer (matrismultiplikationer), separerade av en ReLU-aktiveringsfunktion.

Definition

ReLU-aktiveringsfunktion: ReLU (Rectified Linear Unit) aktiveringen definieras som relu(x) = max(0, x). Den sätter alla negativa värden till noll och behåller positiva värden oförändrade. ReLU används i det feed-forward-nätverket för att introducera icke-linjäritet, vilket gör det möjligt för nätverket att lära sig mer komplexa mönster från data.

Det första linjära lagret projicerar indata från d_model dimensioner (storleken på varje tokens inbäddning) till ett högre dimensionellt utrymme d_ff, vilket gör att modellen kan fånga mer komplexa egenskaper. Det andra linjära lagret projicerar resultatet tillbaka till den ursprungliga storleken d_model. Observera att detta nätverk tillämpas oberoende på varje position i sekvensen, vilket innebär att transformationen för en token inte direkt påverkar andra. Denna oberoende hjälper modellen att bearbeta varje tokens representation parallellt, vilket gör Transformers mycket effektiva för textdata.

Uppgift

Svep för att börja koda

Implementera en positionsvis feed-forward-nätverksfunktion med hjälp av numpy.

Definiera en funktion position_wise_ffn(x, W1, b1, W2, b2) som tar emot: