Solicitações para extração de entidades nomeadas

O que é a extração de entidades nomeadas

Instrução básica para NER

import anthropic, json

client = anthropic.Anthropic(api_key='YOUR_API_KEY')

text = 'Apple CEO Tim Cook met with European Commission President Ursula von der Leyen in Brussels on March 15, 2025 to discuss the Digital Markets Act.'

prompt = f'''
Extract all named entities from the text below.
Return ONLY a JSON object with no other text:
{{
  "people": ["string"],
  "organizations": ["string"],
  "locations": ["string"],
  "dates": ["string"]
}}

Text: {text}
'''

r = client.messages.create(
    model='claude-opus-4-5', max_tokens=300,
    messages=[{'role': 'user', 'content': prompt}]
)
print(json.loads(r.content[0].text))

Adicionando restrições de tipo à extração

prompt_typed = '''
Extract named entities from the text below with type constraints.
Return JSON:
{
  "people": ["Full name as written in text"],
  "organizations": ["Official organization name only, no articles (the, a)"],
  "dates": ["ISO 8601 format if possible: YYYY-MM-DD, else exact text as written"],
  "money": ["Include currency symbol and amount: $4.2B, EUR 500K"],
  "locations": ["City, Country format if applicable"]
}
If a category has no entities, use an empty array [].

Text: {text}
'''

print(prompt_typed[:200])
print('\nConstraints enforce consistent output format per entity type.')

Extração orientada por esquema

ENTITY_SCHEMA = '''
{
  "entities": [
    {
      "text": "exact text as it appears in the document",
      "type": "PERSON | ORG | DATE | LOCATION | MONEY | PRODUCT | EVENT",
      "normalized": "canonical form (e.g., full name, ISO date)",
      "start_char": "integer, character offset in source text",
      "confidence": "high | medium | low"
    }
  ]
}
'''

def extract_entities(text):
    prompt = f'Extract all named entities. Return JSON matching this schema exactly:\n{ENTITY_SCHEMA}\n\nText: {text}'
    r = client.messages.create(
        model='claude-opus-4-5', max_tokens=500,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(r.content[0].text)

result = extract_entities('Tesla stock rose 5% after Elon Musk announced the Cybertruck delivery on December 1.')
print(result['entities'][0])

Lidando com entidades ambíguas

prompt_disambiguation = '''
Extract named entities from the text. For ambiguous entities, use the surrounding
context to determine the correct type. Include your reasoning in an "evidence" field.

Return JSON:
{
  "entities": [
    {
      "text": "string",
      "type": "PERSON | ORG | LOCATION | OTHER",
      "evidence": "brief reason for type assignment"
    }
  ]
}

Text: Jordan and Apple signed a distribution deal for the new Air Jordan shoes.
'''

# Expected output: Jordan = PERSON (context: Air Jordan), Apple = ORG (context: signed a deal)
print(prompt_disambiguation)

Extração com definições de campos

prompt_custom = '''
Extract entities from the medical text below using these custom entity types:

Entity Types:
- MEDICATION: Any drug name, trade name, or generic name
- DOSAGE: Amounts and frequencies (mg, mcg, units/day)
- CONDITION: Diagnoses, symptoms, or medical conditions
- PROCEDURE: Medical tests, surgeries, or treatments
- PROVIDER: Doctor names and medical professionals

Return JSON: {"entities": [{"text": str, "type": str}]}

Text: Dr. Patel prescribed Metformin 500mg twice daily for Type 2 Diabetes.
A follow-up HbA1c test is scheduled for next month.
'''

print(prompt_custom)

Extração de entidades em lote

def batch_extract(documents):
    docs_formatted = '\n'.join(
        f'<document id="{i+1}">\n{doc}\n</document>'
        for i, doc in enumerate(documents)
    )

    prompt = f'''
Extract named entities from each document below.
Return JSON: {{
  "results": [
    {{"doc_id": int, "entities": {{"people": [], "organizations": [], "dates": []}}}}
  ]
}}

{docs_formatted}
'''

    r = client.messages.create(
        model='claude-opus-4-5', max_tokens=1000,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(r.content[0].text)

docs = [
    'Satya Nadella presented at Microsoft Build 2025.',
    'The WHO released guidelines on May 10.'
]
print(batch_extract(docs))

Pós-processamento das entidades extraídas

from datetime import datetime

def normalize_entities(raw_entities):
    normalized = {'people': [], 'organizations': [], 'dates': [], 'money': []}

    for person in raw_entities.get('people', []):
        normalized['people'].append(person.strip().title())

    for org in raw_entities.get('organizations', []):
        normalized['organizations'].append(org.strip())

    for date_str in raw_entities.get('dates', []):
        # Try to parse to ISO format
        for fmt in ['%B %d, %Y', '%Y-%m-%d', '%b %d, %Y']:
            try:
                parsed = datetime.strptime(date_str.strip(), fmt)
                normalized['dates'].append(parsed.strftime('%Y-%m-%d'))
                break
            except ValueError:
                pass
        else:
            normalized['dates'].append(date_str.strip())

    return normalized

raw = {'people': ['tim cook', 'URSULA VON DER LEYEN'], 'dates': ['March 15, 2025']}
print(normalize_entities(raw))

Avaliando a qualidade da extração

def evaluate_extraction(predicted, ground_truth):
    pred_set = set(predicted)
    true_set = set(ground_truth)

    true_positives = len(pred_set & true_set)
    false_positives = len(pred_set - true_set)
    false_negatives = len(true_set - pred_set)

    precision = true_positives / (true_positives + false_positives) if pred_set else 0
    recall = true_positives / (true_positives + false_negatives) if true_set else 0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0

    return {'precision': round(precision, 3), 'recall': round(recall, 3), 'f1': round(f1, 3)}

predicted = ['Tim Cook', 'Apple', 'Brussels', 'March 15 2025']
ground_truth = ['Tim Cook', 'Apple', 'Ursula von der Leyen', 'Brussels', 'March 15, 2025', 'European Commission']
print(evaluate_extraction(predicted, ground_truth))

Reduzindo entidades inventadas

def anti_hallucination_extract(text):
    prompt = f'''
Extract ONLY entities that are explicitly present in the text below.
Do NOT infer, add, or supplement with external knowledge.
For each entity, include the exact quote from the text.

Return JSON: {{"entities": [{{"text": str, "type": str, "quote": str}}]}}

Text: {text}
'''
    r = client.messages.create(model='claude-opus-4-5', max_tokens=400, messages=[{'role': 'user', 'content': prompt}])
    extracted = json.loads(r.content[0].text)

    # Post-process: verify each entity appears in original text
    verified = [e for e in extracted['entities'] if e['text'].lower() in text.lower()]
    return {'entities': verified}

result = anti_hallucination_extract('Google announced a $5B investment in AI infrastructure.')
print(result)

Correferência e vinculação de entidades

coref_prompt = '''
Resolve coreferences in the text below.
For each pronoun or definite reference (he, she, it, the company, the CEO),
identify which named entity it refers to.

Return JSON: {"coreferences": [{"text": str, "refers_to": str, "position": int}]}

Text: Apple released its new chip. The company said it would ship in Q4.
Tim Cook announced that he would present it at the fall event.
'''

print(coref_prompt)

Verificação rápida

Extração de entidades nomeadas — principais conclusões