AI-promptengineering · Les

Validatie door zelfkritiek

Door het model gecontroleerde uitvoer

Les 4 van 413 stappen

Validatie door zelfkritiek is een gratis AI-promptengineering-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.

Het model als zijn eigen beoordelaar

Zelfkritiek gebruikt een LLM om de uitvoer van een LLM te beoordelen aan de hand van een beoordelingskader of beleid. Hiermee vang je genuanceerde fouten op die deterministische validatiecomponenten niet kunnen vastleggen: feitelijke inconsistenties, toon, behulpzaamheid en subtiele beleidsschendingen.

Het is de modelgebaseerde aanvulling op schema- en regelvalidatiecomponenten.

Scheid de beoordelaar van de auteur

Voer de beoordeling uit als een afzonderlijke aanroep met een eigen prompt, niet als een instructie aan het einde van het genereren. Een beoordelaar met een schone context die alleen om een oordeel wordt gevraagd, is veel betrouwbaarder dan wanneer je de auteur tijdens het genereren zichzelf laat beoordelen; die is dan bevooroordeeld ten gunste van zijn eigen antwoord.

draft = author_model(task_prompt)
verdict = critic_model(
  'You are a strict reviewer. Judge ONLY the answer below against the rubric.\n'
  'Rubric: ' + rubric + '\nAnswer: ' + draft
)

Gestructureerde beoordelingsuitvoer

Laat de beoordelaar gestructureerde oordelen produceren, zodat de verwerkingsketen programmatisch kan handelen. Een beoordeling in vrije tekst kan een machine niet direct verwerken.

CRITIC_SCHEMA = {
  'type': 'object',
  'properties': {
    'pass': {'type': 'boolean'},
    'violations': {'type': 'array', 'items': {'type': 'string'}},
    'severity': {'type': 'string', 'enum': ['none','minor','major','critical']},
    'fix_hint': {'type': 'string'}
  },
  'required': ['pass','violations','severity','fix_hint'],
  'additionalProperties': False
}

Lus voor kritiek en herziening

Koppel de beoordelaar aan een herziener. De beoordelaar vindt problemen, de auteur herziet het antwoord met behulp van de kritiek en dit wordt herhaald totdat het antwoord slaagt of het budget op is. Dit is de modelgebaseerde variant van de herstel-lus.

draft = author_model(task)
for _ in range(2):
    c = critic_model(draft)
    if c['pass']:
        break
    draft = author_model(task + '\nRevise to fix: ' + c['fix_hint'])
final = draft

Beoordelingskaders maken kritiek betrouwbaar

Een vage instructie ('is dit goed?') levert onbetrouwbare oordelen op. Een concreet beoordelingskader met expliciete, controleerbare criteria levert consistente oordelen op. Splits het op in ja/nee-vragen die de beoordelaar afzonderlijk beantwoordt.

RUBRIC = [
  'Does the answer directly address the user question?',
  'Are all factual claims supported by the provided context?',
  'Is any disallowed content present?',
  'Is the response within the requested length?'
]

Bronverankerde kritiek op feitelijkheid

Geef de beoordelaar voor het opsporen van hallucinaties de broncontext en vraag hem elke bewering te markeren die daar niet logisch uit volgt. Zo verandert zelfkritiek in een controle op logische gevolgtrekking, die veel sterker is dan zonder bewijs vragen: 'klopt dit?'.

verdict = critic_model(
  'For each claim in the ANSWER, state whether the CONTEXT entails it. '
  'Flag any unsupported claim.\nCONTEXT:\n' + ctx + '\nANSWER:\n' + draft
)

Faalwijzen van de beoordelaar

De beoordelaar is zelf een LLM en kan falen:

Vleierij — het antwoord van de auteur klakkeloos goedkeuren.
Overmatige kritiek — correcte uitvoer markeren.
Gedeelde blinde vlekken — hetzelfde model mist dezelfde fouten.

Beperk dit met een andere modelfamilie als beoordelaar, een strenge beoordelaarsrol en gekalibreerde drempelwaarden.

Gebruik een goedkopere of andere beoordelaar

De beoordelaar hoeft niet het duurste model te zijn. Vaak is een kleiner model met een strak beoordelingskader een kosteneffectieve poortwachter, en vermindert een andere modelfamilie het aantal gedeelde blinde vlekken. Reserveer het sterkste model voor het schrijven van antwoorden.

Wanneer vertrouwen en wanneer controleren

Zelfkritiek vermindert het aantal fouten, maar is geen bewijs. Voor inhoud met beperkte gevolgen is één beoordelingsronde voldoende. Combineer voor uitvoer met grote gevolgen zelfkritiek met deterministische validatiecomponenten en menselijke beoordeling; laat een model nooit als enige beslisser optreden bij veiligheidskritieke beslissingen.

Kosten, vertraging en cachen

Zelfkritiek verdubbelt ongeveer het aantal aanroepen per verzoek. Beperk dit: voer zelfkritiek pas uit na deterministische controles (beoordeel alleen wat de schema- en regelcontroles heeft doorstaan), bewaar beoordelingen in een cache voor identieke concepten en beperk het aantal herzieningsrondes. Voer de beoordeling waar mogelijk parallel uit met werk dat het antwoord niet blokkeert.

if deterministic_ok(draft):
    verdict = critic_model(draft)   # only spend critique on viable drafts

Kalibreer met menselijke labels

Controleer de beoordelaar voordat je hem vertrouwt. Stel een verzameling door mensen gelabelde uitvoer samen, voer de beoordeling uit en meet de overeenstemming (precisie en volledigheid ten opzichte van menselijke oordelen). Stem het beoordelingskader en de rol af totdat de oordelen van de beoordelaar overeenkomen met die van mensen; controleer dit opnieuw na modelupdates.

agreement = mean(critic(d)['pass'] == human_label[d] for d in eval_set)
assert agreement > 0.9

Korte controle

Je wilt dat de beoordelaar hallucinaties in een RAG-antwoord betrouwbaar opspoort. Wat verbetert de betrouwbaarheid het meest?

Beantwoord dit in de interactieve les

Samenvatting

Validatie door zelfkritiek:

Een afzonderlijke beoordelaar met een schone context beoordeelt de uitvoer van de auteur.
Produceer gestructureerde oordelen en stuur een lus voor kritiek en herziening aan.
Concrete beoordelingskaders en bronverankerde controles op logische gevolgtrekking verhogen de betrouwbaarheid.
Let op vleierij en gedeelde blinde vlekken; gebruik een ander beoordelingsmodel.
Stuur op kosten, combineer met deterministische controles en kalibreer met mensen.

Je hebt de veiligheidsmaatregelen voltooid. Volgende cursus: red-teaming en vijandige evaluatie.

Gratis beginnen

Leer AI-promptengineering met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 53
Lessen: 199

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Validatie door zelfkritiek” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Validatie door zelfkritiek”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.

Wat leer ik in “Validatie door zelfkritiek”?

Door het model gecontroleerde uitvoer Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met AI-promptengineering te beginnen?

Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Validatie door zelfkritiek”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?

Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar AI-promptengineering