Strukturált entitáskinyerés
Ezen az oldalon
Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a
temperatureés atop_pparaméterek csaknonegondolkodási erőfeszítés mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk areasoning={"effort": "none"}(Responses API) vagyreasoning_effort="none"(Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.
Strukturált entitáskinyerés
A strukturált entitáskinyerés az egyik legkeresettebb használati eset éles környezetben: a szabad szöveg (e-mailek, dokumentumok, weboldalak) olyan adattá alakítása, amelyet az alkalmazásod ténylegesen fel tud használni. A strukturált kimenet és a specializált promptok kombinálásával megbízható kinyerési folyamatokat építhetsz anélkül, hogy külön NER-modellt kellene tanítanod.
Alapvető kinyerési folyamat
A kinyerés teljes sajátossága az alábbi függvény rendszer-promptjában rejlik, és ez alapos figyelmet érdemel. Három utasítás fed itt egymást: csak a jelenlévő információt nyerd ki, használj null értéket a hiányzó adatokhoz, és soha ne következtess olyan információra, amelyet nem említenek explicit módon.
Ez az utolsó mondat a legfontosabb a gyakorlatban. Ha magára hagyjuk, a modell boldogan kitölt egy hihető SIRET-számot, vagy irányítószám alapján kitalál egy várost, a legjobb szándékkal. Egy üzleti rendszerbe szánt kinyerés esetén ez a segítőkészség súlyos hiba: ha az adat egyszer bekerül az adatbázisba, nincs mód megkülönböztetni, mit olvasott ki a modell, és mit feltételezett. A temperature 0.0-ra állítása ugyanerre a célra szolgál: ugyanannak a dokumentumnak két futtatása során ugyanazt a kimenetet akarod kapni, már csak egy incidens reprodukálása érdekében is.
import json
from openai import OpenAI
client = OpenAI()
def extract_entities(text: str, schema: dict,
instructions: str = "") -> dict:
"""Strukturált entitásokat nyer ki szabad szövegből."""
system = (
"You are a specialized entity extractor. "
"Extract ONLY information present in the text. "
"If information is missing, use null. "
"NEVER infer information not explicitly mentioned."
)
if instructions:
system += f"\n\nAdditional instructions: {instructions}"
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=f"Text to analyze:\n\n{text}",
text={
"format": {
"type": "json_schema",
"name": "extraction",
"schema": schema,
"strict": True
}
},
temperature=0.0
)
return json.loads(response.output_text)
1. példa: Önéletrajz kinyerése
Az önéletrajz kiváló tesztterep, mert stabil szakaszokat kombinál teljesen szabad formátumú elrendezéssel. Az alábbi séma az elérhetőségi adatokat egy identity objektumba csoportosítja, ahol szinte minden mező nullable – egy jelölt lehet, hogy nem ad meg telefonszámot, és ha ezt a mezőt kötelezővé tennéd, azzal gyakorlatilag arra ösztönöznéd a modellt, hogy kitaláljon egyet.
A készségek nem egyszerű sztringek, hanem három attribútummal rendelkező objektumok, ami lehetővé teszi a megadott szint megőrzését és az egyes készségek kategorizálását. Ezek nélkül az enum-ok nélkül a „Scrum“ és a „Python“ ugyanabban a lapos listában végezné oldal mellett, ami használhatatlan egy olyan szűrő számára, amely ki akarja izolálni a nyelveket. Figyeld meg továbbá az end_date mezőt a tapasztalatoknál, amely nullable, míg a start_date nem: így kódolhatsz egy jelenlegi pozíciót anélkül, hogy saját konvenciókat találnál ki, mint például a „present“ vagy a „9999“. A teszt önéletrajzon ez a finomság a TechCorp soron jelenik meg.
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)
2. példa: Üzleti e-mail kinyerése
A második példa jellegében más: itt már nem csupán információkat másolunk ki, hanem arra kérjük a modellt, hogy értelmezzen. Az intent (szándék) és az urgency (sürgősség) ítéletek – egyetlen mondat sem állítja az e-mailben, hogy „ez egy árajánlatkérés, magas prioritású“. Pontosan ezt nem tudja megtenni egy szabályokon vagy reguláris kifejezéseken alapuló klasszikus kinyerési folyamat, és pontosan ez indokolja, hogy itt LLM-t használjunk, máshol pedig nem.
A séma többi része vissza tér az ellenőrizhető tényekhez: említett termékek, összegek a kontextusukkal, dátumok és jelentőségük, szükséges műveletek. A summary mező zárja az objektumot, és azt az embert szolgálja, aki átnézi a sort, nem a kódot. Egy figyelmeztetés ennél a vegyes sémánál: egy téves ítélet az urgency tekintetében nem érvényteleníti az összegeket, de fordítva ez megtörténhet, mert egy modell, amely félreérti a szándékot, néha ezen a félreértésen keresztül olvassa a többit is. Ha az osztályozás kritikus a routingod számára, válaszd le egy külön hívásba.
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
}
Kötegelt kinyerés
Nagy mennyiségek feldolgozásához párhuzamosítsd a kinyeréseidet. Ezer dokumentum szekvenciális loopja az idő nagy részét hálózati várakozással tölti; az asyncio segítségével ezek a várakozások átfedik egymást, és a köteg a töredékére csökkenő idő alatt feldolgozódik.
A semaphore nem díszítő elem. Enélkül ezer feladat egyszerre történő indítása telíti a kvótádat, és olyan rate limit hibákat vált ki, amelyek többe kerülnek az újrapróbálkozások miatt, mint amennyit a sebességen spórolsz. A max_concurrent értékét a saját limiteid megfigyelésével állítsd be, ahol a tíz egy óvatos kiindulópont. Figyeld meg továbbá a return_exceptions=True beállítást is: ez megakadályozza, hogy egyetlen rosszul formázott dokumentum az egész köteget összeomlassza, így utólag rendezheted a hibákat.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def extract_batch(texts: list[str], schema: dict,
max_concurrent: int = 10) -> list[dict]:
"""Párhuzamos kinyerés konkurencia-kontrollal."""
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 requires effort none
instructions="Extract entities from the provided text. "
"Use null for missing fields.",
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)
A kinyerés minőségének értékelése
Egy kinyerési folyamat annotált teszt készlet nélkül olyan folyamat, amelynek megbízhatóságát senki sem ismeri, és a kéz által átolvasott három példa által keltett benyomás szinte mindig túl optimistának bizonyul. Az alábbi függvény mezőnként összehasonlítja a kapott kinyerést egy kézzel létrehozott referenciával, visszaadva az általános pontosságot és az eltérések lebontását.
Ez a lebontás a hasznos rész: a hibák szinte sosem oszlanak el egyenletesen. Egyetlen mező koncentrálja a problémákat – gyakran egy félreérthető dátum, egy implicit készségszint vagy egy rosszul definiált kategória –, és a rendszer-promptba írt egyetlen további mondat megoldja ezt. E mérés nélkül véletlenszerűen hangolnád a promptot, esetleg rontva egy olyan mezőn, amely már működött.
def evaluate_extraction(expected: dict, obtained: dict,
fields: list[str]) -> dict:
"""Összehasonlítja a kapott kinyerést a referenciával."""
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
}
Építsd fel a referenciádat az optimalizálás előtt
Válassz egy dokumentumtípust a saját doménedből – szerződések, számlák, jelentések –, és definiálj legalább tíz mezőt tartalmazó kinyerési sémát, szándékosan keverve az egyszerű mezőket olyanokkal, amelyekről tudod, hogy félreérthetőek. Állíts össze öt példadokumentumot a hozzájuk tartozó, kézzel írt várt kinyerésekkel: ez a lépés unalmas, egy órát vesz igénybe, és ez adja meg minden ezt követő munka értékét.
Ezután futtasd le a folyamatot, mérd meg a pontosságot, és olvasd végig a hibalistát mezőnként. A legrosszabbul teljesítő mező megmondja, mit kell javítanod a prompton; egy második mérés pedig megmutatja, hogy a javítás tényleg segített-e – vagy esetleg rontott-e egy másik mezőn a folyamat során, ami gyakrabban fordul elő, mint gondolnád, amint egy további utasítás eltereli a modell figyelmét.
Főbb megállapítások
- A strukturált kinyerés a legtöbb használati esetben kiváltja a dedikált NER modelleket
- Használj
temperature=0.0értéket a konzisztencia maximalizálásához - Tedd nullable-lá az opcionális mezőket, ne csak opcionálissá
- Párhuzamosíts
asynciosegítségével nagy mennyiségek esetén - Rendszeresen értékeld a minőséget annotált teszt készlettel
- A rendszer-prompt utasításai tartalmat irányítanak, a séma a struktúrát kényszeríti ki