Fine-Grained Entity Typing (FET)

The structured taxonomy of semantic labels that defines the target space for FET. Unlike flat NER schemas, these ontologies organize types in a directed acyclic graph, enabling a single mention to receive multiple labels at varying levels of specificity.

• Example: A mention of 'Tesla' might be typed as /organization → /organization/company → /organization/company/automotive_manufacturer.
• Key Ontologies: FIGER (112 types), TypeNet (2,000+ types), and Ultra-Fine Entity Typing (10,000+ types).
• Granularity: Types can range from coarse (Person) to ultra-fine (AwardWinner, MilitaryCommander).

The standard metric for FET that computes the harmonic mean of precision and recall, requiring an exact match on both the mention span boundaries and the assigned fine-grained type.

• Strict Accuracy: A prediction is only correct if the span and the full set of types match the ground truth exactly.
• Loose Macro/Micro: Variants that average performance across types to account for the long-tail distribution of rare categories.
• Hierarchical Penalty: Some evaluations use a weighted loss that penalizes distant ontological errors more heavily than near-miss parent types.

The core architectural input for modern FET systems. Instead of classifying a single token, the model constructs a fixed-width vector representing the entire entity span by aggregating token-level outputs from a Transformer encoder.

• Max Pooling: Takes the element-wise maximum across the span's token vectors.
• Attention-Based Aggregation: Uses a learned query vector to attend to the most relevant tokens within the span.
• Boundary Concatenation: Concatenates the hidden states of the start and end tokens with a summary vector, as popularized by the SpanBERT architecture.

An extreme variant of FET that operates on a massive, free-form type space derived from head words and phrases rather than a fixed ontology. This moves the task from multi-class classification to a zero-shot or open-vocabulary generation problem.

• Scale: Systems like Ultra-Fine Entity Typing (Choi et al., 2018) define over 10,000 types.
• Label Noise: Training data is often generated via distant supervision, requiring robust denoising architectures.
• Generative Approach: Modern LLMs treat FET as a constrained generation task, prompting the model to output a list of types directly.

Techniques that explicitly model the correlations between fine-grained types to prevent impossible predictions (e.g., a single entity cannot be both a Person and a Location). This is crucial because FET labels are not mutually exclusive.

• Conditional Random Fields (CRF): Used in sequence-level FET to enforce valid transitions between types.
• Graph Neural Networks: Propagate information between label nodes in the ontology graph to capture hierarchical dependencies.
• Masked Softmax: Applies a hard constraint mask during inference to zero out logically inconsistent type combinations.

A data generation strategy that automatically aligns entity mentions in a raw text corpus with type labels from a knowledge base like Freebase or Wikidata. This creates large-scale but noisy training datasets.

• Heuristic Alignment: Links a text span to a KB entry via string matching, then inherits all KB types.
• Noise Mitigation: Requires specialized loss functions (e.g., partial-label loss) because the absence of a type in the KB does not guarantee it is truly negative.
• Scale vs. Accuracy: Enables training on millions of examples but introduces systematic label noise that must be managed.