Promptteknik til AI · Lektion

Diagnosticér uventede output

Klassificér fejltyper: forkert svar, forkert format, uden for emnet eller hallucination.

Lektion 1 af 413 trin

Diagnosticér uventede output er en gratis Promptteknik til AI-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Promptteknik til AI, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Når prompts fejler

Selv om prompts er omhyggeligt udformet, giver de forkerte resultater. Diagnosticering af fejl kræver en taksonomi — en klassifikation af, hvilken type fejl der er opstået. Uden klassifikation bliver fejlfinding gætteri. De fire vigtigste fejlkategorier er: forkert svar, forkert format, svar uden for emnet og hallucination.

Fejltype 1: Forkert svar

Et forkert svar er en faktuel fejl — modellen gav et svar i det korrekte format og om det korrekte emne, men indholdet er forkert.

Eksempler: datoer, statistikker, navne og kode med en logisk fejl. Det er den sværeste fejl at opdage automatisk, fordi resultatet ser korrekt ud ved første øjekast.

Årsag: skæringsdatoen for træningsdata, en sjælden kendsgerning eller en fejl i ræsonnement i flere trin
Registrering: sammenligning med facit, menneskelig gennemgang eller et LLM-kald til verifikation

# Example: wrong answer failure
prompt = 'What year was Python first released?'
response = 'Python was first released in 1994.'  # Wrong — it was 1991

# Ground truth check
GROUND_TRUTH = '1991'
correct = GROUND_TRUTH in response
print(f'Correct: {correct}')  # False

Fejltype 2: Forkert format

En fejl med forkert format opstår, når modellen besvarede det rigtige spørgsmål med de rigtige oplysninger, men ignorerede formateringsinstruktionen.

Eksempler: returnerede almindelig tekst, da der blev bedt om JSON, tilføjede Markdown, da der krævedes almindelig tekst, eller returnerede en liste, da der blev bedt om en enkelt værdi.

Årsag: formateringsinstruktionen er begravet i en lang prompt, modstridende instruktioner eller modellen ignorerer instruktioner med lav prioritet
Registrering: fejl ved fortolkning af JSON, uoverensstemmelse med et regulært udtryk eller fejl i skemavalidering

import json

response_text = 'Sure! Here is the result: {"name": "Alice", "age": 30}'

try:
    data = json.loads(response_text)
    print('Format OK:', data)
except json.JSONDecodeError as e:
    print(f'FORMAT FAILURE: {e}')
    # 'Sure! Here is the result:' prefix broke JSON parsing

Fejltype 3: Svar uden for emnet

En fejl uden for emnet betyder, at modellen besvarede et andet spørgsmål end det, der blev stillet. Svaret kan være faktuelt korrekt og have et godt format, men det adresserer ikke brugerens egentlige hensigt.

Eksempler: Du bad om en Python-funktion, men modtog en JavaScript-funktion; du bad om et svar på én linje, men modtog en hel afhandling; du bad om at rette en fejl, men modtog en forklaring på fejlen i stedet for rettelsen.

Årsag: tvetydig instruktion, modstridende kontekst eller opgaven ændrer gradvist karakter i lange samtaler

# Off-topic example
prompt = 'Write a Python function that reverses a list.'
response = '''
In JavaScript, you can reverse an array like this:
const reversed = arr.reverse();
'''

# Detection: check that output contains the correct language keyword
def check_language(response, expected_lang='def '):
    if expected_lang not in response:
        print(f'OFF-TOPIC FAILURE: expected {expected_lang} in response')
        return False
    return True

check_language(response)  # False — no Python def

Fejltype 4: Hallucination

Hallucination er den farligste fejl: modellen opfinder fakta, der ikke findes. De virker plausible og selvsikre, hvilket gør dem svære at opdage.

Eksempler: opdigtede kildehenvisninger (titlen på artiklen lyder ægte, men artiklen findes ikke), opfundne API-slutpunkter, falske statistikker og ikkeeksisterende personer.

Årsag: modellen udfylder huller i sin viden med sandsynlig tekst, der er matchet ud fra mønstre
Registrering: faktatjek mod autoritative kilder, krydstjek af kildehenvisninger eller test af API-kald

# Hallucination detection via external verification
import requests

def verify_doi(doi):
    url = f'https://doi.org/{doi}'
    resp = requests.head(url, allow_redirects=True, timeout=5)
    return resp.status_code == 200

# Model claimed this paper exists:
fabricated_doi = '10.1234/fake.paper.2023.99999'
if not verify_doi(fabricated_doi):
    print('HALLUCINATION DETECTED: DOI does not exist')

Fejltaksonomien i praksis

Når du opdager en fejl, skal du først klassificere den, før du forsøger at rette den. Fejltypen afgør strategien for løsningen:

Forkert svar: tilføj kontekst, brug informationshentning, eller skift til en mere kapabel model
Forkert format: styrk formateringsinstruktionen, tilføj eksempler på resultater, eller brug strukturerede resultater / funktionskald
Svar uden for emnet: omskriv instruktionen, så den bliver mere specifik, og forenkl prompten
Hallucination: tilføj forankrende kontekst, instruér modellen i at sige »Jeg ved det ikke«, og aktivér kildehenvisninger

Struktureret fejllogning

Registrer hver fejl med dens klassifikation. Med tiden viser der sig mønstre: Et bestemt afsnit i en prompt medfører de fleste fejl med forkert format, eller et bestemt emne udløser hyppige hallucinationer. Strukturerede logfiler muliggør datadrevet fejlfinding.

import json
from datetime import datetime

def log_failure(prompt, response, failure_type, details=''):
    entry = {
        'timestamp': datetime.utcnow().isoformat(),
        'failure_type': failure_type,  # wrong_answer | wrong_format | off_topic | hallucination
        'prompt_hash': hash(prompt),
        'response_snippet': response[:200],
        'details': details
    }
    with open('prompt_failures.jsonl', 'a') as f:
        f.write(json.dumps(entry) + '\n')

log_failure(
    prompt=my_prompt,
    response=bad_response,
    failure_type='wrong_format',
    details='JSON prefix text broke parsing'
)

Automatisk fejlklassifikation

Ved test i stor skala kan du bruge et klassificerende LLM-kald til automatisk at mærke hvert svar med en fejltype. Det muliggør samlet evaluering af hundredvis af testtilfælde.

def classify_failure(prompt, expected, actual):
    classification_prompt = (
        f'You are a QA evaluator for LLM outputs.\n'
        f'Prompt: {prompt}\n'
        f'Expected behavior: {expected}\n'
        f'Actual output: {actual}\n\n'
        'Classify the failure as one of: CORRECT, WRONG_ANSWER, WRONG_FORMAT, OFF_TOPIC, HALLUCINATION.\n'
        'Reply with only the label.'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': classification_prompt}]
    )
    return resp.choices[0].message.content.strip()

Alvorlighedsmatrix

Ikke alle fejl har samme konsekvenser. En alvorlighedsmatrix hjælper med at prioritere rettelser:

Hallucination i medicinsk eller juridisk kontekst: kritisk — ret straks
Forkert format i et internt værktøj: høj — ødelægger fortolkningen i efterfølgende trin
Forkert svar i et sjældent særtilfælde: middel — overvåg hyppigheden
Svar uden for emnet ved tvetydige inddata: lav — acceptabelt, hvis det forekommer sjældent

Følg fejlprocenterne for hver type pr. uge. En stigning i en kategori signalerer en regression, der kræver opmærksomhed.

Opbygning af et fejloverblik

Et enkelt fejloverblik læser fejlloggen og rapporterer antal efter type og promptafsnit:

import json
from collections import Counter

def failure_report(log_path='prompt_failures.jsonl'):
    entries = []
    with open(log_path) as f:
        for line in f:
            entries.append(json.loads(line))

    counts = Counter(e['failure_type'] for e in entries)
    total = len(entries)

    print(f'Total failures: {total}')
    for ftype, count in counts.most_common():
        pct = 100 * count / total
        print(f'  {ftype}: {count} ({pct:.1f}%)')

failure_report()

Forebyggelse af fejl

Forebyggende strategier til at reducere hver fejltype, før den opstår:

Forkert svar: tilføj referencetekst i prompten (RAG), og bed modellen angive sin kilde
Forkert format: brug JSON-tilstand eller funktionskald, og giv et eksempel på formatet i prompten
Svar uden for emnet: gør opgaven til den første sætning, og undgå lange indledninger, der udvander hensigten
Hallucination: instruér »Brug kun oplysningerne nedenfor«, og tilføj »Hvis du er i tvivl, skal du sige, at du ikke ved det«

Videnstest

Hvilken fejltype opstår, når modellen opfinder fakta, der ikke findes, f.eks. en opdigtet kildehenvisning eller et ikkeeksisterende API-slutpunkt?

Besvar den i den interaktive lektion

Opsummering: Diagnosticering af uventede resultater

De fire LLM-fejltyper og deres vigtigste kendetegn:

Forkert svar: korrekt format, korrekt emne, forkert indhold — faktatjek mod facit
Forkert format: korrekt indhold, ignorerede formateringsinstruktionen — skemavalidering opdager dette
Svar uden for emnet: korrekt format, besvarede et andet spørgsmål — kontrollér overensstemmelsen mellem sprog og opgave
Hallucination: opfundne fakta — kontrollér mod eksterne kilder

Registrer og klassificer hver fejl. Følg fejlprocenterne for hver type over tid. Næste lektion: årsagsanalyse for at finde den del af prompten, der forårsagede fejlen.

Gratis at komme i gang

Lær Promptteknik til AI med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 53
Lektioner: 199

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Diagnosticér uventede output” gratis?

Ja — alle 3 lektioner i læringssporet Promptteknik til AI, inklusive “Diagnosticér uventede output”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Diagnosticér uventede output”?

Klassificér fejltyper: forkert svar, forkert format, uden for emnet eller hallucination. Du øver dig i Promptteknik til AI med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Promptteknik til AI?

Der kræves ingen tidligere erfaring. Promptteknik til AI på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Diagnosticér uventede output”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Promptteknik til AI-lektion?

Ja. Alle Promptteknik til AI-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Promptteknik til AI