AI Prompt Engineering · Lekcja

Jak AI generuje odpowiedzi

Przewidywanie tokenów, prawdopodobieństwo i wyjaśnienie, dlaczego AI nie „myśli” jak człowiek.

Jak AI generuje odpowiedzi to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Tekst jako problem probabilistyczny

W swojej istocie model językowy wykonuje jedną czynność: przewiduje następny token na podstawie wszystkich poprzedzających go tokenów.

Token to mała jednostka tekstu — mniej więcej słowo lub fragment słowa. Model przypisuje prawdopodobieństwo każdemu tokenowi w swoim słowniku i wybiera jeden. Następnie powtarza ten proces token po tokenie, aż wygeneruje kompletną odpowiedź.

Czym jest token?

Tokeny są atomami przetwarzania tekstu przez LLM. Tekst angielski dzieli się na tokeny w przybliżeniu następująco:

częste słowa → po 1 tokenie (the, run)
mniej popularne słowa → podział na 2–3 tokeny (running → run + ning)
znaki interpunkcyjne i spacje → często osobne tokeny

Modele takie jak GPT-4o i Claude korzystają z tokenizatorów obsługujących ponad 100 tys. elementów słownika, w tym podwyrazy w wielu językach.

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}')

Generowanie autoregresywne

Generowanie ma charakter autoregresywny: każdy nowy token jest dołączany do danych wejściowych przed przewidzeniem kolejnego.

Podczas generowania zdania „Niebo jest niebieskie” model:

Widząc „Niebo” → przewiduje „jest”
Widząc „Niebo jest” → przewiduje „niebieskie”
Widząc „Niebo jest niebieskie” → przewiduje koniec sekwencji

Dlatego generowanie bardzo długich odpowiedzi zwalnia — każdy token wymaga pełnego przejścia w przód.

# 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 end

Temperatura: sterowanie losowością

Temperatura to liczba od 0 do 2, która skaluje rozkład prawdopodobieństwa przed próbkowaniem:

Temperatura 0: zawsze wybierany jest najbardziej prawdopodobny token — wynik jest deterministyczny i powtarzalny
Temperatura 1: próbkowanie zgodnie z surowymi prawdopodobieństwami — zachowana równowaga
Temperatura 2: spłaszczenie prawdopodobieństw — bardzo losowe, czasem niespójne wyniki

Niskiej temperatury należy używać do zadań faktograficznych, a wyższej — do pracy kreatywnej.

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}"')

Dlaczego odpowiedzi różnią się między uruchomieniami

Nawet przy tym samym prompcie dwa uruchomienia tego samego modelu mogą wygenerować różne wyniki. Dzieje się tak, ponieważ:

próbkowanie ma charakter probabilistyczny — model losuje z rozkładu, a nie korzysta z tabeli wyszukiwania
niewielkie różnice numeryczne w arytmetyce zmiennoprzecinkowej mogą się kumulować
równoległość sprzętowa wprowadza niedeterminizm

Ustawienie temperature=0 i seed (jeśli są obsługiwane) pozwala maksymalnie zwiększyć powtarzalność.

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()}')

Próbkowanie top-p

Top-p (próbkowanie jądrowe) to kolejny sposób kontrolowania losowości. Zamiast skalować wszystkie prawdopodobieństwa, ogranicza próbkowanie do najmniejszego zbioru tokenów, którego łączne prawdopodobieństwo przekracza p.

top_p=0.1: tylko tokeny o najwyższym prawdopodobieństwie (zachowawczo)
top_p=0.9: szerszy zbiór (kreatywnie)
top_p=1.0: wszystkie tokeny (pełny rozkład)

W praktyce większość zespołów dostraja temperature, pozostawiając top-p na poziomie 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)

Brak prawdziwego rozumienia — dopasowywanie wzorców

LLM-y nie rozumieją języka tak jak ludzie. Są niezwykle zaawansowanymi mechanizmami dopasowywania wzorców, trenowanymi na ogromnych korpusach tekstów.

Gdy model odpowiada na pytanie „Czym jest fotosynteza?”, nie pobiera zapisanej informacji — generuje sekwencję tokenów, która statystycznie następuje po danym wzorcu pytania, na podstawie milionów podobnych dokumentów poznanych podczas trenowania.

# 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)

Trenowanie a inferencja

„Wiedza” modelu została zamrożona podczas trenowania na dużym korpusie tekstów. Podczas inferencji (gdy wysyłają Państwo prompt) model generuje tekst na podstawie tej zamrożonej wiedzy — nie uczy się ani nie przeszukuje internetu.

Oznacza to, że nie może wiedzieć o wydarzeniach, które nastąpiły po dacie granicznej trenowania, uzyskiwać dostępu do adresów URL ani sprawdzać, czy dana informacja zmieniła się od czasu trenowania.

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)

Co dzieje się podczas przejścia w przód

W dużym uproszczeniu przewidywanie każdego tokena obejmuje:

Konwersję wszystkich tokenów wejściowych na osadzenia liczbowe
Przepuszczenie ich przez wiele warstw transformera (mechanizm uwagi + sieć jednokierunkowa)
Utworzenie rozkładu prawdopodobieństwa dla całego słownika
Wylosowanie jednego tokena z tego rozkładu

Współczesne modele mają miliardy parametrów, które kształtują tę transformację — wszystkie zostały wyuczone podczas trenowania na tekstach napisanych przez ludzi.

# 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')

Sekwencje zatrzymania

Sekwencje zatrzymania informują model, aby przerwał generowanie po utworzeniu określonego ciągu znaków. Jest to przydatne do:

Zapobiegania generowaniu przez model więcej niż jednej odpowiedzi na liście
Zatrzymywania generowania na separatorze, takim jak ### lub ---END---
Wymuszania wyników składających się z jednego wiersza

Bez sekwencji zatrzymania model generuje tekst do momentu osiągnięcia wartości max_tokens albo przewidzenia tokena końca sekwencji.

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)

Praktyczne konsekwencje dla twórców promptów

Zrozumienie mechanizmu generowania pomaga tworzyć lepsze prompty:

Używają Państwo temperatury 0 w zadaniach wymagających spójnych i zgodnych z faktami wyników
Używają Państwo temperatury 0,7–1,0 w kreatywnym pisaniu
Weryfikują Państwo fakty — model generuje tekst, który brzmi wiarygodnie, ale nie gwarantuje jego prawdziwości
Używają Państwo sekwencji zatrzymania, aby precyzyjnie kontrolować długość wyniku
Krótkie prompty → bardziej kreatywne, ale mniej kontrolowane wyniki
Szczegółowe prompty → bardziej ograniczone i skoncentrowane wyniki

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())

Sprawdzenie wiedzy

Dowiedzieli się już Państwo, jak LLM-y generują tekst token po tokenie. Sprawdźmy, czy rozumieją Państwo działanie temperatury.

Programista tworzy chatbota do obsługi klienta, który musi udzielać spójnych i dokładnych odpowiedzi na pytania dotyczące rozliczeń. Które ustawienie temperatury będzie najbardziej odpowiednie?

Jak AI generuje odpowiedzi — podsumowanie

Znają już Państwo mechanizm stojący za każdą odpowiedzią AI:

Modele przewidują następny token pojedynczo — jest to generowanie autoregresywne
Temperatura określa, ile losowości zostanie wprowadzone do wyboru tokena
Top-p ogranicza losowanie do zbioru tokenów o wysokim prawdopodobieństwie
Model nie rozumie — dopasowuje wzorce na ogromną skalę
Wiedza jest zamrożona podczas trenowania — brak danych w czasie rzeczywistym i dostępu do internetu
Sekwencje zatrzymania pozwalają dokładnie kontrolować miejsce zakończenia wyniku

Często zadawane pytania

Czy lekcja „Jak AI generuje odpowiedzi” jest bezpłatna?

Tak — pełny tekst „Jak AI generuje odpowiedzi” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Jak AI generuje odpowiedzi”?

Przewidywanie tokenów, prawdopodobieństwo i wyjaśnienie, dlaczego AI nie „myśli” jak człowiek. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Jak AI generuje odpowiedzi”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do AI Prompt Engineering