# Stor språkmodell

## Vad det är

En stor språkmodell är ett neuralt nätverk som har tränats på en mycket stor
mängd text för att göra en enda sak: att utifrån texten hittills ge varje token
som kan komma härnäst en sannolikhet. En token är en kort textbit, ofta ett helt
ord, ibland en del av ett ord eller ett enskilt tecken. Att skriva ett svar är
samma steg upprepat i en slinga. Programmet väljer en token utifrån
sannolikheterna, lägger den sist i texten och frågar igen, tills modellen ger en
token som betyder stopp eller en längdgräns nås. NIST:s profil för generativ AI,
utgiven i juli 2024, säger det på en rad: stora språkmodeller förutsäger nästa
token eller ord i en mening. Förkortningen LLM, efter engelskans large language
model, betyder samma sak, och det är den form som profilen själv använder på
engelska.

Den uppbyggnad som de senaste årens modeller vilar på heter Transformer och
beskrevs i en artikel om maskinöversättning från 2017. Den gjorde sig av med de
rekurrenta och konvolutionella lager som tidigare modeller var byggda av och
byggde enbart på attention, en mekanism som låter varje position i texten titta
direkt på alla de andra. Det gjorde träningen mycket lättare att fördela över
många processorer, och artikelns modell tränades på betydligt kortare tid än
föregångarna.

”Stor” syftar på antalet parametrar, de vikter som nätverket lär sig under
träningen. En artikel från 2020 beskrev en modell med 175 miljarder av dem, tio
gånger fler än någon tidigare icke-gles språkmodell, och visade att en modell av
den storleken kunde ta sig an en ny uppgift utifrån en handfull genomarbetade
exempel i sina indata, helt utan vidare träning.

En modell som bara har tränats på att fortsätta text gör just det: den
fortsätter texten, och det är inte samma sak som att göra det den blev ombedd
att göra. En artikel från 2022 beskrev steget som gör en sådan modell till en
assistent. Människor skrev de svar de ville ha på en uppsättning förfrågningar,
och modellen finjusterades på dem. Sedan rangordnade människor modellens egna
svar, och den tränades vidare på rangordningarna, en metod som kallas
reinforcement learning from human feedback. I artikelns utvärderingar föredrog
människor svaren från en modell med 1,3 miljarder parametrar, tränad på det
sättet, framför svaren från den ursprungliga modellen med hundra gånger så många
parametrar.

## Varför det spelar roll

En språkmodell kan ta sig an arbete som inga tidigare program klarade med fasta
regler: att sortera ett mejl skrivet i fritext till rätt mapp, att hämta fälten
ur en inskannad följesedel, att skriva ett utkast till svar på kundens eget
språk, att sammanfatta en lång tråd. Arbete som tidigare krävde att en människa
läste varje enskilt ärende kan nu förberedas som utkast av ett program och
kontrolleras av en människa.

Samma egenskap som gör modellen användbar gör den också svår att bygga på.
Utdata dras som regel slumpmässigt ur en sannolikhetsfördelning, så samma indata
kan ge olika svar från körning till körning, och modellen formulerar sig lika
flytande oavsett om den har rätt eller inte. NIST kallar säkert framförda,
felaktiga utdata för konfabulering, mer känt som hallucination, och beskriver
det som en naturlig följd av hur modellerna är byggda: de genererar text som
passar statistiken i texten de tränades på, och den är ofta rätt och ibland
inte. NIST påpekar också att en modell kan konfabulera den motivering eller de
källhänvisningar som ser ut att stödja ett svar. Ett felaktigt svar ser
förvillande likt ut ett riktigt, så det enda sättet att veta hur ofta en modell
har rätt i ditt arbete är att mäta den på ditt arbete.

Det finns inte heller en enda modell att binda sig till. Nya modeller kommer
regelbundet, två av dem kan bete sig ganska olika på samma indata, och det är
leverantören av den modell som ett program anropar som bestämmer när den ändras.
Ett team som bygger på en språkmodell bygger på en del som det inte själv styr,
och det arbete som består är allt runt modellen: fallen som mäter den, verktygen
den får anropa och reglerna för vad den får göra på egen hand.

NIST:s profil nämner tolv riskområden för generativ AI, bland dem konfabulering,
skydd av personuppgifter, informationssäkerhet och immateriella rättigheter. Den
är skriven för organisationer som hanterar risker, mer än för utvecklare, men
den fungerar väl som checklista för ett team som ska avgöra vad en funktion
byggd på en modell får röra.

## Så ser det ut i praktiken

En funktion byggd på en språkmodell börjar med nedskrivna fall, inte med en
prompt. Varje fall består av riktiga indata och det svar som en person som kan
arbetet skulle godkänna, och fallen ligger i en fil under versionshantering
bredvid koden:

```yaml
# cases/delivery-notes.yaml
- id: note-0142
  input: scans/note-0142.txt
  expect:
    supplier: "Example Freight"
    reference: "DN-58213"
    pallets: 6
- id: note-0157
  input: scans/note-0157.txt
  expect:
    supplier: "Sample Haulage"
    reference: "DN-59002"
    pallets: 14
```

Vilken modell som tar vilken typ av uppgift är en inställning, så en liten och
snabb modell kan stå för extraktionen medan en större skriver utkast till de
svar som kräver omdöme:

```yaml
# routing.yaml
jobs:
  extract-delivery-note:
    model: small-fast
    cases: cases/delivery-notes.yaml
  draft-claim-reply:
    model: large
    cases: cases/claim-replies.yaml
```

Varje ändring körs mot alla fall innan den släpps, oavsett om ändringen är en ny
prompt, ett nytt verktyg eller en ny modell, och resultatet är en poäng per
fall, sparad över tid, så att en rättelse för ett fall inte i det tysta kan
förstöra ett annat. När en ny modell kommer behövs bara en ändring på en rad i
`routing.yaml` och en körning mot fallen för att prova den, och beslutet att
byta vilar på poängen och inte på lanseringen.

Så beskriver den här webbplatsen sina
[skräddarsydda AI-agenter för din bransch](/sv/ai-agents/). Valet av modell är
konfiguration, inte kod, med en liten, snabb modell för att sortera och
extrahera och en stor för omdöme. Ett uppdrag börjar med trettio till femtio
riktiga exempel med rätt svar, nedskrivna tillsammans med dem som gör arbetet,
och varje ändring, vare sig det gäller en prompt, ett verktyg eller en modell,
körs mot alla fallen innan den släpps. När en ny modell släpps är det resultatet
mot fallen och inte lanseringen som avgör om man byter. Enligt sidan hålls
modellen utbytbar, och kunden äger koden, fallen och datan, så att agenten
förblir kundens när modellen under den byts ut.

## Var det går fel

**Självsäkra svar som är fel.** En modell som får en fråga om en avtalsklausul
den inte har framför sig kan hitta på en ändå, i samma säkra ton som vid ett
riktigt svar, och kan hänvisa till en källa som inte finns. Ge modellen de
dokument den ska svara utifrån, be den hänvisa till dem och kontrollera i kod
att varje hänvisning pekar på ett dokument och ett stycke som finns. Mät
felfrekvensen på nedskrivna fall, och låt en människa granska svar som får
konsekvenser innan något agerar på dem.

**Instruktioner gömda i data.** Ett program som låter en modell läsa mejl,
webbsidor eller uppladdade filer låter författarna till den texten tala till
modellen. En artikel från 2023 visade detta mot verkliga applikationer:
instruktioner som planterats i innehåll som modellen sannolikt skulle läsa fick
den att läcka data och ändra vad applikationen gjorde, och NIST:s profil nämner
indirekt prompt injection bland säkerhetsriskerna med generativ AI. Behandla
allt modellen läser som indata du inte kan lita på, upprätthåll behörigheter i
verktygen i stället för i prompten, ge verktygen bara de behörigheter som
personen modellen agerar för själv har, och kräv att en människa godkänner varje
handling som inte kan göras ogjord.

**En modell som ändras under dig.** En ny version eller en annan leverantör kan
svara annorlunda på samma indata, och ett svar som klarade sig förra månaden
misslyckas i dag, utan att din egen kod har ändrats. Ange en exakt modellversion
där leverantören erbjuder det, och kör hela fallfilen vid varje ändring, även
ett modellbyte, innan den når användarna.

**Utdata som koden inte kan läsa.** En modell som ombeds svara med JSON
returnerar JSON följt av en vänlig mening, utelämnar ett fält eller skriver ett
tal som en textsträng. Beskriv den förväntade formen i JSON Schema, kontrollera
varje svar mot den och behandla ett svar som inte klarar kontrollen som ett fel
som ska försökas igen eller skickas vidare till en människa, aldrig som data.

**Personuppgifter i prompter och loggar.** Allt som skickas till en modell hos
en leverantör lämnar dina egna system, och en logg över prompter och svar
bevarar personuppgifter långt efter att anropet är klart. NIST tillägger att
modeller kan återge känsligt material ur sina träningsdata, ett problem som har
beskrivits som memorering av data. Skicka bara de fält som en uppgift behöver,
håll promptloggarna under samma regler för bevarande och åtkomst som uppgifterna
i dem, och läs leverantörens villkor om bevarande och träning innan
personuppgifter når den.

## Läs mer

- [NIST AI 600-1: Generative Artificial Intelligence Profile](https://doi.org/10.6028/NIST.AI.600-1)
  — NIST:s tillägg från juli 2024 till sitt AI Risk Management Framework: tolv
  risker med generativ AI, konfabulering bland dem, och föreslagna åtgärder för
  var och en.
- [Attention Is All You Need](https://arxiv.org/abs/1706.03762) — artikeln från
  2017 som introducerade Transformer, som dagens språkmodeller bygger på.
- [Language Models are Few-Shot Learners](https://arxiv.org/abs/2005.14165) —
  artikeln från 2020 om en modell med 175 miljarder parametrar som tar sig an
  nya uppgifter utifrån exempel i indata.
- [Training language models to follow instructions with human feedback](https://arxiv.org/abs/2203.02155)
  — finjustering på nedskrivna svar och rangordnade utdata, steget från
  textförutsägare till assistent.
- [Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection](https://arxiv.org/abs/2302.12173)
  — instruktioner planterade i data som en modell läser, demonstrerade mot
  verkliga applikationer.

<https://engineer.company/sv/glossary/large-language-model/>
