Lære Challenge: Implementering af Feed-Forward Netværk | Opbygning af Transformer-Komponenter

Sektion 2. Kapitel 3

single

Stryg for at vise menuen

Når du udforsker Transformer-arkitekturen til naturlig sprogbehandling, støder du på en afgørende komponent i hvert Transformer-blok: position-wise feed-forward netværket (FFN). Efter at self-attention-mekanismen har behandlet inputrepræsentationerne, transformerer FFN yderligere disse repræsentationer på hver position i sekvensen, uafhængigt af de andre positioner. Dette betyder, at for hvert token i en sætning anvendes det samme lille neurale netværk, hvilket gør det muligt for modellen at indføre yderligere ikke-linearitet og lære mere komplekse mønstre fra teksten. FFN er essentiel for at fange relationer og forfine den information, der er kodet af self-attention, især når der arbejdes med nuancer og tvetydigheder i menneskeligt sprog.


              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 ovenfor ses en simpel implementering af et position-wise feed-forward netværk ved brug af numpy. Netværket består af to lineære transformationer (matrixmultiplikationer), adskilt af en ReLU aktiveringsfunktion.

Definition

ReLU aktiveringsfunktion: ReLU (Rectified Linear Unit) aktiveringen er defineret som relu(x) = max(0, x). Den sætter alle negative værdier til nul og lader positive værdier være uændrede. ReLU bruges i feed-forward-netværket til at introducere ikke-linearitet, hvilket gør det muligt for netværket at lære mere komplekse mønstre fra dataene.

Det første lineære lag projicerer input fra d_model dimensioner (størrelsen af hver tokens embedding) til et højere-dimensionelt rum d_ff, hvilket gør det muligt for modellen at opfange mere komplekse træk. Det andet lineære lag projicerer resultatet tilbage til den oprindelige d_model størrelse. Bemærk, at dette netværk anvendes uafhængigt på hver position i sekvensen, hvilket betyder, at transformationen for én token ikke direkte påvirker andre. Denne uafhængighed hjælper modellen med at behandle hver tokens repræsentation parallelt, hvilket gør Transformers meget effektive til tekstdata.

Opgave

Swipe to start coding

Implementér en positionsvis feed-forward netværksfunktion ved hjælp af numpy.

Definér en funktion position_wise_ffn(x, W1, b1, W2, b2) der tager: