Sekvensmodeller före transformers

Före transformers behandlades sekvenser med RNN: ett dolt tillstånd h som uppdateras för varje element.

hₜ = tanh(W·xₜ + U·hₜ₋₁ + b)

All information om det förflutna måste rymmas i h — en vektor av fast storlek. Två problem följer:

1. Försvinnande gradient. Gradienten från steg 50 tillbaka till steg 1 multipliceras med U femtio gånger. Är faktorerna < 1 dör den; är de > 1 exploderar den. Långa beroenden lärs aldrig.
2. Ingen parallellisering. hₜ kräver hₜ₋₁. Hela sekvensen måste behandlas i ordning — dödläge på GPU.

LSTM (1997) löste delvis det första med grindar: en cellstatus som information kan passera nästan oförändrad genom, plus glöm-, in- och utgrind som lär sig vad som ska sparas. Det räckte för maskinöversättning i flera år.

Men problem 2 kvarstod. Attention löste båda: varje position når varje annan direkt (en «hoppdistans»), och allt kan räknas parallellt.

import torch, torch.nn as nn

# RNN: sekventiell, dolt tillstånd av fast storlek
rnn = nn.RNN(input_size=16, hidden_size=32, batch_first=True)
x = torch.randn(8, 100, 16)          # (batch, tid, features)
ut, h = rnn(x)
print(ut.shape, h.shape)              # (8, 100, 32) (1, 8, 32)

# LSTM: samma gränssnitt, men cellstatus + grindar
lstm = nn.LSTM(16, 32, batch_first=True)
ut, (h, c) = lstm(x)

# Illustration av försvinnande gradient: produkten av 50 faktorer
import numpy as np
for faktor in (0.9, 1.0, 1.1):
    print(faktor, round(faktor ** 50, 6))
# 0.9  0.005154   ← gradienten har praktiskt taget försvunnit
# 1.0  1.0
# 1.1  117.39     ← exploderar

Var RNN fortfarande används: mycket långa strömmar med små resurser (inbyggda system), och i moderna tillståndsmodeller (Mamba, RWKV) som återupptar idén om ett löpande tillstånd — men med konstruktioner som går att parallellisera vid träning.