Så genererar AI svar
Tokenförutsägelse, sannolikhet och varför AI inte tänker som människor.
Så genererar AI svar är en gratis lektion i AI-promptteknik på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för AI-promptteknik, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-promptteknik innehåller totalt 4 lektioner.
Text som ett sannolikhetsproblem
I grunden gör en språkmodell en enda sak: förutsäger nästa token utifrån alla föregående tokens.
En token är en liten textenhet — ungefär ett ord eller en del av ett ord. Modellen tilldelar varje token i sitt vokabulär en sannolikhet och väljer en av dem. Sedan upprepar den processen, token för token, tills den har genererat ett fullständigt svar.
Vad är en token
Tokens är de minsta byggstenarna i LLM:ers textbearbetning. Engelskspråkig text tokeniseras ungefär så här:
- Vanliga ord → 1 token vardera (
the,run) - Mindre vanliga ord → delas upp i 2–3 tokens (
running→run+ning) - Skiljetecken och blanksteg → är ofta egna tokens
Modeller som GPT-4o och Claude använder tokeniserare som hanterar över 100 000 vokabulärposter, inklusive orddelar på många språk.
import tiktoken
encoding = tiktoken.encoding_for_model('gpt-4o')
sentence = 'The temperature parameter controls randomness in token selection.'
tokens = encoding.encode(sentence)
token_strings = [encoding.decode([t]) for t in tokens]
print(f'Sentence: {sentence}')
print(f'Token count: {len(tokens)}')
print(f'Tokens: {token_strings}')Autoregressiv generering
Genereringen är autoregressiv: varje ny token läggs till i indata innan nästa token förutsägs.
När modellen till exempel genererar ”Himlen är blå” gör den så här:
- Ser ”Himlen” → förutsäger ”är”
- Ser ”Himlen är” → förutsäger ”blå”
- Ser ”Himlen är blå” → förutsäger slutet på sekvensen
Därför går genereringen långsammare vid mycket långa utdata — varje token kräver en fullständig framåtpassering genom modellen.
# Simulated autoregressive token-by-token output via streaming
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
stream = client.chat.completions.create(
model='gpt-4o',
stream=True, # receive tokens as they are generated
messages=[{'role': 'user', 'content': 'Name five planets in our solar system.'}]
)
print('Tokens arriving one by one:')
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end='', flush=True)
print() # newline at endTemperatur: styra slumpmässighet
Temperatur är ett tal mellan 0 och 2 som skalar sannolikhetsfördelningen före sampling:
- Temperatur 0: välj alltid den mest sannolika token — deterministiskt och repetitivt
- Temperatur 1: sampla enligt de ursprungliga sannolikheterna — balanserat
- Temperatur 2: jämna ut sannolikheterna — mycket slumpmässigt och ibland osammanhängande
Använd låg temperatur för faktabaserade uppgifter och högre temperatur för kreativt arbete.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
prompt = 'Continue this sentence with one word: The ocean is'
for temp in [0.0, 0.7, 1.5]:
response = client.chat.completions.create(
model='gpt-4o',
temperature=temp,
max_tokens=5,
messages=[{'role': 'user', 'content': prompt}]
)
word = response.choices[0].message.content.strip()
print(f'Temperature {temp}: "{word}"')Varför svar varierar mellan körningar
Även med samma prompt kan två körningar av samma modell ge olika utdata. Det beror på följande:
- Sampling är probabilistisk — modellen drar ett urval från en fördelning, inte från en uppslagstabell
- Små numeriska skillnader i flyttalsberäkningar kan förstärkas steg för steg
- Parallellism i hårdvaran medför icke-determinism
Ange temperature=0 och seed (om det stöds) för att maximera reproducerbarheten.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
prompt = 'Give me a one-word color that feels calm.'
for run in range(3):
response = client.chat.completions.create(
model='gpt-4o',
temperature=1.0, # randomness ON
max_tokens=5,
messages=[{'role': 'user', 'content': prompt}]
)
print(f'Run {run + 1}: {response.choices[0].message.content.strip()}')
# For reproducible outputs use seed + temperature=0
response = client.chat.completions.create(
model='gpt-4o',
temperature=0,
seed=42,
max_tokens=5,
messages=[{'role': 'user', 'content': prompt}]
)
print(f'Deterministic: {response.choices[0].message.content.strip()}')Top-p-sampling
Top-p (nucleus sampling) är ett annat sätt att styra slumpmässighet. I stället för att skala alla sannolikheter begränsar metoden samplingen till den minsta mängd tokens vars kumulativa sannolikhet överstiger p.
top_p=0.1: endast de allra mest sannolika tokensen (konservativt)top_p=0.9: en bredare mängd kandidater (kreativt)top_p=1.0: alla tokens (hela fördelningen)
I praktiken finjusterar de flesta team temperatur och låter top-p vara 1.0.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Conservative generation: top_p=0.1 restricts to high-confidence tokens
response_conservative = client.chat.completions.create(
model='gpt-4o',
top_p=0.1,
max_tokens=30,
messages=[{'role': 'user', 'content': 'What is the capital of Japan?'}]
)
# Creative generation: top_p=0.95 allows broader token pool
response_creative = client.chat.completions.create(
model='gpt-4o',
top_p=0.95,
max_tokens=30,
messages=[{'role': 'user', 'content': 'Write a poetic one-liner about the moon.'}]
)
print('Conservative:', response_conservative.choices[0].message.content)
print('Creative: ', response_creative.choices[0].message.content)Ingen verklig förståelse – mönstermatchning
LLM:er förstår inte språk på samma sätt som människor gör. De är extremt avancerade system för mönstermatchning som har tränats på enorma textkorpusar.
När modellen besvarar frågan 'Vad är fotosyntes?' hämtar den inte ett lagrat faktum – den genererar den sekvens av tokens som statistiskt följer frågemönstret, baserat på att den har sett miljontals liknande dokument under träningen.
# Demonstration: the model can produce plausible-sounding but wrong answers
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Asking about something nonsensical — model may still try to answer
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=128,
messages=[{
'role': 'user',
'content': (
'What is the boiling point of happiness in degrees Celsius? '
'Please just say "I cannot answer this" if the question makes no sense.'
)
}]
)
print(response.content[0].text)Träning kontra inferens
Modellens 'kunskap' frystes under träningen på en stor textkorpus. Vid inferens (när du skickar en prompt) genererar modellen text utifrån denna frysta kunskap – den lär sig inte och söker inte på internet.
Det innebär att den inte kan känna till händelser efter sin kunskapsgräns, inte komma åt URL:er och inte kontrollera om ett faktum har ändrats sedan träningen.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Asking the model about its own knowledge cutoff
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=128,
messages=[{
'role': 'user',
'content': (
'What is your knowledge cutoff date? '
'And can you access the internet right now to look up today\'s news?'
)
}]
)
print(response.content[0].text)Vad som händer under en forward pass
På en övergripande nivå omfattar varje tokenförutsägelse:
- Omvandla alla indatatokens till numeriska embeddingar
- Skicka dem genom många transformerlager (attention + feed-forward)
- Skapa en sannolikhetsfördelning över hela vokabulären
- Sampla en token från den fördelningen
Moderna modeller har miljarder parametrar som formar denna transformation – alla inlärda från mänsklig text under träningen.
# You can inspect logprobs (token probabilities) to see the model's confidence
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
response = client.chat.completions.create(
model='gpt-4o',
max_tokens=5,
logprobs=True,
top_logprobs=3,
messages=[{'role': 'user', 'content': 'The opposite of hot is'}]
)
for token_info in response.choices[0].logprobs.content:
print(f'Chosen token: "{token_info.token}"')
for alt in token_info.top_logprobs:
import math
prob = round(math.exp(alt.logprob) * 100, 1)
print(f' Option "{alt.token}": {prob}% probability')Stoppsekvenser
Stoppsekvenser talar om för modellen att stoppa genereringen när den producerar en viss sträng. Det är användbart för att:
- Hindra modellen från att generera mer än ett svar i en lista
- Stoppa vid en avgränsare som
###eller---END--- - Framtvinga utdata på en enda rad
Utan stoppsekvenser genererar modellen text tills den når max_tokens eller förutsäger en token för sekvensslut.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Stop after the first item in a numbered list
response = client.chat.completions.create(
model='gpt-4o',
max_tokens=64,
stop=['2.'], # halt as soon as '2.' appears
messages=[{
'role': 'user',
'content': 'List 5 programming languages, numbered 1 through 5.'
}]
)
print(response.choices[0].message.content)
print('Stop reason:', response.choices[0].finish_reason)Praktiska konsekvenser för promptförfattare
Om du förstår hur genereringen fungerar kan du skriva bättre prompts:
- Använd temperatur 0 för uppgifter som kräver konsekventa, faktabaserade resultat
- Använd temperatur 0.7-1.0 för kreativt skrivande
- Kontrollera fakta – modellen genererar sannolik text, inte garanterad sanning
- Använd stoppsekvenser för att styra utdatalängden exakt
- Korta prompts → mer kreativt men mindre kontrollerat resultat
- Detaljerade prompts → mer begränsat och fokuserat resultat
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Low temperature for factual classification
fact_response = client.messages.create(
model='claude-opus-4-5',
max_tokens=8,
temperature=0, # deterministic
messages=[{'role': 'user', 'content': 'Is Paris the capital of France? Answer YES or NO only.'}]
)
print('Factual (temp=0):', fact_response.content[0].text.strip())
# Higher temperature for creative tasks
creative_response = client.messages.create(
model='claude-opus-4-5',
max_tokens=64,
temperature=1.0,
messages=[{'role': 'user', 'content': 'Write a surprising one-line poem about code.'}]
)
print('Creative (temp=1):', creative_response.content[0].text.strip())Kunskapskontroll
Nu har du lärt dig hur LLM:er genererar text token för token. Låt oss kontrollera din förståelse av temperatur.
En utvecklare bygger en chatbot för kundsupport som måste ge konsekventa och korrekta svar på fakturafrågor. Vilken temperaturinställning är lämpligast?
Så genererar AI svar – sammanfattning
Du förstår nu mekaniken bakom varje AI-svar:
- Modeller förutsäger nästa token en i taget – autoregressiv generering
- Temperatur styr hur mycket slump som tillförs vid valet av token
- Top-p begränsar sampling till en kärna av tokens med hög sannolikhet
- Modellen förstår inte – den matchar mönster i massiv skala
- Kunskapen är fryst vid träningen – inga realtidsdata, ingen internetåtkomst
- Stoppsekvenser låter dig styra exakt var utdata slutar
Lär dig AI-promptteknik med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 53
- Lektioner
- 199
Vanliga frågor
Är lektionen ”Så genererar AI svar” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen AI-promptteknik, inklusive ”Så genererar AI svar”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i AI-promptteknik innehåller totalt 4 lektioner.
Vad lär jag mig i ”Så genererar AI svar”?
Tokenförutsägelse, sannolikhet och varför AI inte tänker som människor. Ni övar på AI-promptteknik med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig AI-promptteknik?
Du behöver inga förkunskaper. Utbildningen i AI-promptteknik på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Så genererar AI svar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här AI-promptteknik-lektionen?
Ja. Varje AI-promptteknik-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Förstå chattgränssnittet
- Typer av förfrågningar som AI kan hantera
- Så genererar AI svar
- Vad AI inte kan göra