Struktureret enhedsudtrækning
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Struktureret enhedsudtrækning
Struktureret enhedsudtrækning er en af de mest efterspurgte anvendelser i produktion: at omdanne fri tekst (e-mails, dokumenter, websider) til data, som din applikation faktisk kan bruge. Ved at kombinere struktureret output med specialiserede prompts kan du bygge pålidelige udtrækningspipelines uden at træne en dedikeret NER-model.
Grundlæggende udtrækningspipeline
Hele specifikiteten ved udtrækning ligger i systemprompten i funktionen nedenfor, og den fortjener tæt opmærksomhed. Tre instruktioner overlapper her: udtræk kun det, der er til stede, brug null for manglende data, og inferér aldrig information, der ikke er eksplicit nævnt.
Den sidste sætning er den vigtigste i praksis. Overladt til sig selv vil en model gladeligt udfylde et plausibelt SIRET-nummer eller gætte en by ud fra et postnummer med de bedste intentioner. For udtrækning beregnet til et forretningssystem er denne hjælpsomhed en alvorlig fejl: når data først er i databasen, er der ingen måde at skelne mellem, hvad der blev læst, og hvad der blev antaget. At sætte temperature til 0,0 tjener samme formål – på tværs af to kørsler af det samme dokument ønsker du det samme output, om ikke andet for at kunne reproducere en hændelse.
import json
from openai import OpenAI
client = OpenAI()
def extract_entities(text: str, schema: dict,
instructions: str = "") -> dict:
"""Udtrækker strukturerede enheder fra fri tekst."""
system = (
"Du er en specialiseret enhedsudtrækker. "
"Udtræk KUN information, der er til stede i teksten. "
"Hvis information mangler, skal du bruge null. "
"INFERÉR ALDRIG information, der ikke er eksplicit nævnt."
)
if instructions:
system += f"\n\nYderligere instruktioner: {instructions}"
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions=system,
input=f"Tekst til analyse:\n\n{text}",
text={
"format": {
"type": "json_schema",
"name": "extraction",
"schema": schema,
"strict": True
}
},
temperature=0.0
)
return json.loads(response.output_text)
Eksempel 1: CV-udtrækning
Et CV er et fremragende testgrundlag, fordi det kombinerer stabile sektioner med et helt frit layout. Skemaet nedenfor grupperer kontaktoplysninger i et identity-objekt, hvor næsten hvert felt kan være null – en kandidat giver måske ikke et telefonnummer, og at gøre dette felt påkrævet ville i bund og grund invitere modellen til at opfinde et.
Færdigheder er ikke simple strenge, men objekter med tre attributter, hvilket giver dig mulighed for at bevare det angivne niveau og kategorisere hver færdighed. Uden disse enums ville „Scrum” og „Python” ende side om side i samme flade liste, hvilket er ubrugeligt for et filter, der forsøger at isolere sprog. Bemærk også feltet end_date i erfaringer, som kan være null, hvorimod start_date ikke er det: sådan kodere du en nuværende stilling uden at opfinde en hjemmelavet konvention som „present” eller „9999”. På test-cv’et viser denne finesse sig på TechCorp-linjen.
resume_schema = {
"type": "object",
"properties": {
"identity": {
"type": "object",
"properties": {
"full_name": {"type": "string"},
"email": {"type": ["string", "null"]},
"phone": {"type": ["string", "null"]},
"location": {"type": ["string", "null"]},
"linkedin": {"type": ["string", "null"]}
},
"required": ["full_name", "email", "phone",
"location", "linkedin"],
"additionalProperties": False
},
"current_title": {"type": ["string", "null"]},
"years_experience": {"type": ["integer", "null"]},
"skills": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {"type": "string"},
"level": {
"type": "string",
"enum": ["beginner", "intermediate",
"advanced", "expert"]
},
"category": {
"type": "string",
"enum": ["language", "framework", "tool",
"methodology", "soft_skill"]
}
},
"required": ["name", "level", "category"],
"additionalProperties": False
}
},
"experiences": {
"type": "array",
"items": {
"type": "object",
"properties": {
"company": {"type": "string"},
"title": {"type": "string"},
"start_date": {"type": "string"},
"end_date": {"type": ["string", "null"]},
"description": {"type": "string"}
},
"required": ["company", "title", "start_date",
"end_date", "description"],
"additionalProperties": False
}
},
"education": {
"type": "array",
"items": {
"type": "object",
"properties": {
"institution": {"type": "string"},
"degree": {"type": "string"},
"year": {"type": ["string", "null"]}
},
"required": ["institution", "degree", "year"],
"additionalProperties": False
}
},
"languages": {
"type": "array",
"items": {
"type": "object",
"properties": {
"language": {"type": "string"},
"level": {
"type": "string",
"enum": ["a1", "a2", "b1", "b2",
"c1", "c2", "native"]
}
},
"required": ["language", "level"],
"additionalProperties": False
}
}
},
"required": ["identity", "current_title", "years_experience",
"skills", "experiences", "education", "languages"],
"additionalProperties": False
}
resume_text = """
Marie Dupont - Senior Full Stack Developer
Email: [email protected] | Tel: +33 6 12 34 56 78
Paris, France | linkedin.com/in/mariedupont
8 years of experience in web development.
Skills: Python (expert), TypeScript (advanced), React (advanced),
Django (expert), PostgreSQL (advanced), Docker (intermediate),
Scrum (advanced)
Experience:
- TechCorp (2022-present): Lead Full Stack Developer
Principal architect of a B2B SaaS platform, team of 6 devs.
- StartupAI (2019-2022): Senior Developer
Development of ML APIs in Python/FastAPI.
Education:
- EPITECH Paris, Master in Computer Science (2017)
Languages: French (native), English (C1), Spanish (B1)
"""
result = extract_entities(resume_text, resume_schema)
Eksempel 2: Udtrækning af kommercielle e-mails
Det andet eksempel ændrer karakter: vi kopierer ikke længere blot information, vi beder modellen om at fortolke. intent og urgency er vurderinger – ingen sætning i e-mailen siger „dette er en forespørgsel om tilbud, høj prioritet”. Dette er netop det, en klassisk udtrækningspipeline baseret på regler eller regulære udtryk ikke kan gøre, og det er præcis det, der retfærdiggør brugen af en LLM her frem for andre steder.
Resten af skemaet vender tilbage til verificerbare fakta: nævnte produkter, beløb med deres kontekst, datoer og deres betydning, krævede handlinger. Feltet summary afslutter objektet og tjener det menneske, der vil gennemgå køen, ikke koden. Et opmærksomhedspunkt ved dette blandede skema: en vurderingsfejl på urgency invaliderer ikke beløbene, men det modsatte kan ske, fordi en model, der misforstår hensigten, nogle gange læser resten gennem denne misforståelse. Hvis klassificering er kritisk for din routing, bør du adskille den i et dedikeret kald.
email_schema = {
"type": "object",
"properties": {
"intent": {
"type": "string",
"enum": ["quote_request", "complaint", "information",
"order", "partnership", "other"]
},
"urgency": {
"type": "string",
"enum": ["critical", "high", "normal", "low"]
},
"sender": {
"type": "object",
"properties": {
"name": {"type": ["string", "null"]},
"company": {"type": ["string", "null"]},
"email": {"type": ["string", "null"]}
},
"required": ["name", "company", "email"],
"additionalProperties": False
},
"mentioned_products": {
"type": "array",
"items": {"type": "string"}
},
"mentioned_amounts": {
"type": "array",
"items": {
"type": "object",
"properties": {
"value": {"type": "number"},
"currency": {"type": "string"},
"context": {"type": "string"}
},
"required": ["value", "currency", "context"],
"additionalProperties": False
}
},
"key_dates": {
"type": "array",
"items": {
"type": "object",
"properties": {
"date": {"type": "string"},
"significance": {"type": "string"}
},
"required": ["date", "significance"],
"additionalProperties": False
}
},
"required_actions": {
"type": "array",
"items": {"type": "string"}
},
"summary": {"type": "string"}
},
"required": ["intent", "urgency", "sender",
"mentioned_products", "mentioned_amounts",
"key_dates", "required_actions", "summary"],
"additionalProperties": False
}
Batch-udtrækning
For at behandle store volumener skal du parallelisere dine udtrækninger. En sekventiel løkke over tusind dokumenter bruger det meste af tiden på at vente på netværket; med asyncio overlapper disse ventetider, og batchen behandles på en brøkdel af tiden.
Semaphoren er ikke en dekorativ detalje. Uden den vil lancering af tusind opgaver på én gang mætte din kvote og udløse rate limit-fejl, der koster mere i genforsøg, end de sparer i hastighed. Sæt værdien for max_concurrent ved at observere dine egne grænser, hvor ti er et forsigtigt udgangspunkt. Bemærk også return_exceptions=True: det forhindrer, at et enkelt misdannet dokument får hele batchen til at crashe, så du kan sortere fejl bagefter.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def extract_batch(texts: list[str], schema: dict,
max_concurrent: int = 10) -> list[dict]:
"""Parallel udtrækning med styring af samtidighed."""
semaphore = asyncio.Semaphore(max_concurrent)
async def extract_one(text: str) -> dict:
async with semaphore:
response = await async_client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions="Udtræk enheder fra den angivne tekst. "
"Brug null for manglende felter.",
input=text,
text={
"format": {
"type": "json_schema",
"name": "extraction",
"schema": schema,
"strict": True
}
},
temperature=0.0
)
return json.loads(response.output_text)
tasks = [extract_one(t) for t in texts]
return await asyncio.gather(*tasks, return_exceptions=True)
Evaluering af udtrækningskvalitet
En udtrækningspipeline uden et annoteret testsæt er en pipeline, hvis pålidelighed ingen kender, og det indtryk, der efterlades af tre eksempler læst i hånden, viser sig næsten altid at være for optimistisk. Funktionen nedenfor sammenligner et opnået udtrækningsfelt for felt mod en manuelt etableret reference og returnerer samlet præcision sammen med en oversigt over uoverensstemmelser.
Denne oversigt er den nyttige del: fejl er næsten aldrig fordelt ensartet. Ét felt koncentrerer problemerne – ofte en tvetydig dato, et implicit færdighedsniveau eller en dårligt defineret kategori – og en enkelt sætning tilføjet til systemprompten løser det. Uden denne måling ville du justere prompten tilfældigt og muligvis forværre et felt, der allerede fungerede.
def evaluate_extraction(expected: dict, obtained: dict,
fields: list[str]) -> dict:
"""Sammenligner opnået udtrækning med referencen."""
correct = 0
total = len(fields)
errors = []
for field in fields:
val_expected = expected.get(field)
val_obtained = obtained.get(field)
if val_expected == val_obtained:
correct += 1
else:
errors.append({
"field": field,
"expected": val_expected,
"obtained": val_obtained
})
return {
"precision": correct / total if total > 0 else 0,
"correct": correct,
"total": total,
"errors": errors
}
Byg din reference før optimering
Vælg en dokumenttype fra dit domæne – kontrakter, fakturaer, rapporter – og definer et udtrækningsskema på mindst ti felter, hvor du bevidst blander lette felter med nogle, du ved er tvetydige. Saml fem eksempeldokumenter med deres forventede udtrækninger, skrevet i hånden: dette trin er kedeligt, det tager en time, og det er det, der giver alt efterfølgende arbejde sin værdi.
Kør derefter pipeline’en, mål præcisionen, og læs listen over fejl felt for felt. Det mest fejlbehæftede felt vil fortælle dig, hvad du skal rette i prompten; en anden måling vil fortælle dig, om rettelsen faktisk hjalp – eller om den forringede et andet felt i processen, hvilket sker oftere, end du måske tror, så snart en ekstra instruktion flytter modellens opmærksomhed.
Vigtige pointer
- Struktureret udtrækning erstatter dedikerede NER-modeller til de fleste anvendelser
- Brug
temperature=0.0for at maksimere konsistens - Gør valgfrie felter nullable i stedet for optional
- Parallelisér med asyncio ved store volumener
- Evaluer systematisk kvaliteten med et annoteret testsæt
- Instruktioner i systemprompten styrer indholdet, skemaet begrænser strukturen