Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Δομημένη εξαγωγή οντοτήτων

Μάθημα 13 / 16 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Δομημένη εξαγωγή οντοτήτων
  2. Βασικός αγωγός εξαγωγής
  3. Παράδειγμα 1: Εξαγωγή βιογραφικού
  4. Παράδειγμα 2: Εξαγωγή εμπορικού e-mail
  5. Εξαγωγή κατά παρτίδες
  6. Αξιολόγηση της ποιότητας της εξαγωγής
  7. Χτίστε την αναφορά σας πριν βελτιστοποιήσετε
  8. Βασικά σημεία

Μάθημα ενημερώθηκε στις 3 Νοεμβρίου 2026 βάσει της τεκμηρίωσης της OpenAI: τα temperature και top_p γίνονται δεκτά μόνο με reasoning effort none, ενώ τα μοντέλα GPT-5.6 συλλογίζονται από προεπιλογή (medium). Οι κλήσεις που ορίζουν αυτές τις παραμέτρους πρέπει λοιπόν να καθορίζουν reasoning={"effort": "none"} (Responses API) ή reasoning_effort="none" (Chat Completions). Πηγές: Χρήση του GPT-6 · GPT-5.6 Terra.

Δομημένη εξαγωγή οντοτήτων

Η δομημένη εξαγωγή οντοτήτων είναι μία από τις πιο πολυζήτητες περιπτώσεις χρήσης στην παραγωγή: ο μετασχηματισμός ελεύθερου κειμένου (e-mail, έγγραφα, ιστοσελίδες) σε δεδομένα που η εφαρμογή σας μπορεί όντως να χρησιμοποιήσει. Συνδυάζοντας τη δομημένη έξοδο με εξειδικευμένα prompts, μπορείτε να χτίσετε αξιόπιστους αγωγούς εξαγωγής χωρίς να εκπαιδεύσετε ένα αφιερωμένο μοντέλο NER.

Βασικός αγωγός εξαγωγής

Η όλη ιδιαιτερότητα της εξαγωγής βρίσκεται στο system prompt της παρακάτω συνάρτησης, και αξίζει να το διαβάσετε προσεκτικά. Τρεις εντολές συμπλέκονται εδώ: εξάγετε μόνο ό,τι υπάρχει στο κείμενο, χρησιμοποιήστε null όπου λείπουν δεδομένα, και μην εξάγετε ποτέ συμπέρασμα για πληροφορία που δεν αναφέρεται ρητά.

Αυτή η τελευταία πρόταση είναι στην πράξη η πιο σημαντική. Αφημένο στον αυτόματο, ένα μοντέλο δεν θα διστάσει να συμπληρώσει έναν πιθανολογούμενο αριθμό εταιρικού μητρώου ή να μαντέψει μια πόλη από ένα τηλεφωνικό πρόθεμα, με τις καλύτερες προθέσεις. Σε εξαγωγή που προορίζεται για επαγγελματικό σύστημα, αυτή η εξυπνάδα είναι σοβαρό ελάττωμα: μόλις τα δεδομένα μπουν στη βάση, δεν υπάρχει τρόπος να ξεχωρίσετε τι διαβάστηκε από τι υποτέθηκε. Η ρύθμιση του temperature στο 0.0 εξυπηρετεί τον ίδιο σκοπό — σε δύο εκτελέσεις του ίδιου εγγράφου θέλετε την ίδια ακριβώς έξοδο, έστω και για να αναπαράγετε ένα περιστατικό.

import json
from openai import OpenAI

client = OpenAI()

def extract_entities(text: str, schema: dict,
                     instructions: str = "") -> dict:
    """Extracts structured entities from free text."""
    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: Εξαγωγή βιογραφικού

Το βιογραφικό είναι εξαιρετικό πεδίο δοκιμής, γιατί συνδυάζει σταθερές ενότητες με εντελώς ελεύθερη διάταξη. Το παρακάτω σχήμα ομαδοποιεί τα στοιχεία επαφής σε ένα αντικείμενο identity όπου σχεδόν κάθε πεδίο είναι nullable — ένας υποψήφιος μπορεί να μην δώσει τηλέφωνο, και αν το κάνατε υποχρεωτική παράμετρο, ουσιαστικά θα προσκαλούσατε το μοντέλο να επινοήσει έναν αριθμό.

Οι δεξιότητες δεν είναι απλές συμβολοσειρές αλλά αντικείμενα με τρία γνωρίσματα, κάτι που σας επιτρέπει να διατηρείτε το δηλωμένο επίπεδο και να κατηγοριοποιείτε κάθε δεξιότητα. Χωρίς αυτά τα enums, το «Scrum» και η «Python» θα κατέληγαν δίπλα-δίπλα στην ίδια επίπεδη λίστα, άχρηστα για φίλτρο που προσπαθεί να απομονώσει τις γλώσσες. Σημειώστε επίσης το πεδίο end_date στις εμπειρίες, που είναι nullable ενώ το start_date δεν είναι: έτσι κωδικοποιείτε μια τρέχουσα θέση χωρίς να επινοήσετε δική σας σύμβαση όπως «present» ή «9999». Στο βιογραφικό δοκιμής, αυτή η λεπτότητα παίζεται στη γραμμή της TechCorp.

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: Εξαγωγή εμπορικού e-mail

Το δεύτερο παράδειγμα αλλάζει φύση: δεν αντιγράφουμε πια απλώς πληροφορίες, ζητάμε από το μοντέλο να ερμηνεύσει. Τα intent και urgency είναι κρίσεις — καμία φράση στο e-mail δεν λέει «πρόκειται για αίτημα προσφοράς, υψηλής προτεραιότητας». Αυτό ακριβώς δεν μπορεί να κάνει ένας κλασικός αγωγός εξαγωγής που βασίζεται σε κανόνες ή σε κανονικές εκφράσεις, και είναι ακριβώς αυτό που δικαιολογεί τη χρήση ενός LLM εδώ αντί αλλού.

Τα υπόλοιπα του σχήματος επιστρέφουν σε ελέγξιμα γεγονότα: αναφερόμενα προϊόντα, ποσά με το πλαίσιο τους, ημερομηνίες με τη σημασία τους, απαιτούμενες ενέργειες. Το πεδίο summary κλείνει το αντικείμενο και εξυπηρετεί τον άνθρωπο που θα επιθεωρεί την ουρά, όχι τον κώδικα. Ένα σημείο προσοχής με αυτό το μικτό σχήμα: ένα σφάλμα κρίσης στο urgency δεν ακυρώνει τα ποσά, αλλά μπορεί να συμβεί το αντίστροφο, γιατί ένα μοντέλο που παρεξηγεί την πρόθεση μερικές φορές διαβάζει τα υπόλοιπα μέσα από αυτή την παρεξήγηση. Αν η ταξινόμηση είναι κρίσιμη για τη δρομολόγησή σας, χωρίστε τη σε ξεχωριστή κλήση.

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
}

Εξαγωγή κατά παρτίδες

Για μεγάλους όγκους, παραλληλοποιήστε τις εξαγωγές σας. Ένας διαδοχικός βρόχος σε χίλια έγγραφα περνά τον περισσότερο χρόνο του περιμένοντας το δίκτυο· με το asyncio, αυτές οι αναμονές επικαλύπτονται και η παρτίδα ολοκληρώνεται σε ένα κλάσμα του χρόνου.

Το semaphore δεν είναι διακοσμητική λεπτομέρεια. Χωρίς αυτό, το ξεκίνημα χιλίων εργασιών ταυτόχρονα θα εξαντλήσει το όριο αιτημάτων σας και θα πυροδοτήσει σφάλματα rate limit που κοστίζουν σε επαναλήψεις περισσότερα από όσα κερδίζουν σε ταχύτητα. Ορίστε την τιμή max_concurrent παρατηρώντας τα δικά σας όρια, με το δέκα ως επιφυλακτικό σημείο εκκίνησης. Σημειώστε επίσης το return_exceptions=True: εμποδίζει ένα και μοναδικό στρεβλό έγγραφο να καταστρέψει ολόκληρη την παρτίδα, αφήνοντάς σας να ξεδιαλύνετε τις αποτυχίες εκ των υστέρων.

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 extraction with concurrency control."""
    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)

Αξιολόγηση της ποιότητας της εξαγωγής

Ένας αγωγός εξαγωγής χωρίς σύνολο δοκιμής με επισημαγμένες περιπτώσεις είναι αγωγός του οποίου την αξιοπιστία δεν γνωρίζει κανείς, και η εντύπωση από τρία παραδείγματα διαβασμένα με το μάτι αποδεικνύεται σχεδόν πάντα υπερβολικά αισιόδοξη. Η παρακάτω συνάρτηση συγκρίνει πεδίο προς πεδίο μια παραγόμενη εξαγωγή με μια αναφορά συνταγμένη στο χέρι, και επιστρέφει τη συνολική ακρίβεια μαζί με την ανάλυση των αποκλίσεων.

Αυτή η ανάλυση είναι το χρήσιμο μέρος: τα σφάλματα σχεδόν ποτέ δεν είναι ομοιόμορφα κατανεμημένα. Ένα πεδίο συγκεντρώνει τα προβλήματα — συχνά μια διφορούμενη ημερομηνία, ένα σιωπηρό επίπεδο δεξιότητας ή μια κακοορισμένη κατηγορία — και μία μόνο πρόταση που προστίθεται στο system prompt το διορθώνει. Χωρίς αυτόν τον μετρητή, θα πειράζατε το prompt στην τύχη, με κίνδυνο να επιδεινώσετε ένα πεδίο που ήδη δούλευε.

def evaluate_extraction(expected: dict, obtained: dict,
                       fields: list[str]) -> dict:
    """Compares obtained extraction with the reference."""
    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
    }

Χτίστε την αναφορά σας πριν βελτιστοποιήσετε

Επιλέξτε έναν τύπο εγγράφου από τον χώρο σας — συμβόλαια, τιμολόγια, αναφορές — και ορίστε ένα σχήμα εξαγωγής με τουλάχιστον δέκα πεδία, αναμειγνύοντας σκόπιμα εύκολα πεδία με άλλα που γνωρίζετε ότι είναι διφορούμενα. Συνθέστε πέντε παράδειγμα εγγράφων με τις αναμενόμενες εξαγωγές τους, γραμμένες στο χέρι: αυτό το βήμα είναι κουραστικό, παίρνει μία ώρα, και είναι αυτό που δίνει αξία σε όλη τη συνέχεια.

Στη συνέχεια τρέξτε τον αγωγό, μετρήστε την ακρίβεια και διαβάστε τη λίστα σφαλμάτων πεδίο προς πεδίο. Το πιο προβληματικό πεδίο θα σας πει τι να διορθώσετε στο prompt· ένας δεύτερος μετρημός θα σας πει αν η διόρθωση βοήθησε όντως — ή αν επιδείνωσε παράλληλα κάποιο άλλο πεδίο, κάτι που συμβαίνει συχνότερα από ό,τι νομίζετε μόλις μια πρόσθετη εντολή μετατοπίσει την προσοχή του μοντέλου.

Βασικά σημεία

  • Η δομημένη εξαγωγή αντικαθιστά τα αφιερωμένα μοντέλα NER στις περισσότερες περιπτώσεις χρήσης
  • Χρησιμοποιήστε temperature=0.0 για μέγιστη συνοχή
  • Κάντε nullable, όχι προαιρετικά, τα πεδία που μπορεί να λείπουν
  • Παραλληλοποιήστε με το asyncio για μεγάλους όγκους
  • Αξιολογείτε συστηματικά την ποιότητα με ένα σύνολο δοκιμής με επισημαγμένες περιπτώσεις
  • Οι οδηγίες του system prompt κατευθύνουν το περιεχόμενο, το σχήμα περιορίζει τη δομή