Lære Utfordring: Implementering av Feed-Forward-nettverk

Seksjon 2. Kapittel 3

single

Sveip for å vise menyen

Når du utforsker Transformer-arkitekturen for naturlig språkprosessering, møter du en avgjørende komponent i hver Transformer-blokk: posisjonsvis feed-forward-nettverk (FFN). Etter at selvoppmerksomhetsmekanismen har behandlet inndatarepresentasjonene, transformerer FFN disse representasjonene videre på hver posisjon i sekvensen, uavhengig av andre posisjoner. Dette betyr at for hvert token i en setning, brukes det samme lille nevrale nettverket, noe som gjør det mulig for modellen å introdusere ekstra ikke-linearitet og lære mer komplekse mønstre fra teksten. FFN er essensiell for å fange opp relasjoner og forbedre informasjonen kodet av selvoppmerksomhet, spesielt når man håndterer nyanser og tvetydigheter i menneskelig 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 over ser du en enkel implementasjon av et posisjonsvis feed-forward-nettverk ved bruk av numpy. Nettverket består av to lineære transformasjoner (matrisemultiplikasjoner), adskilt av en ReLU-aktiveringsfunksjon.

Definisjon

ReLU aktiveringsfunksjon: ReLU (Rectified Linear Unit) aktivering er definert som relu(x) = max(0, x). Den setter alle negative verdier til null og lar positive verdier være uendret. ReLU brukes i det fremovermatede nettverket for å introdusere ikke-linearitet, slik at nettverket kan lære mer komplekse mønstre fra dataene.

Det første lineære laget projiserer input fra d_model dimensjoner (størrelsen på hver tokens embedding) til et høyere-dimensjonalt rom d_ff, noe som gjør at modellen kan fange opp mer komplekse trekk. Det andre lineære laget projiserer resultatet tilbake til den opprinnelige d_model-størrelsen. Merk at dette nettverket brukes uavhengig på hver posisjon i sekvensen, noe som betyr at transformasjonen for én token ikke direkte påvirker andre. Denne uavhengigheten hjelper modellen med å behandle hver tokens representasjon parallelt, noe som gjør Transformere svært effektive for tekstdata.

Oppgave

Sveip for å begynne å kode

Implementer en posisjonsvis feed-forward nettverksfunksjon ved bruk av numpy.

Definer en funksjon position_wise_ffn(x, W1, b1, W2, b2) som tar inn: