Enum Task 

#[non_exhaustive]
pub enum Task {
    NER,
    NED,
    RelationExtraction,
    IntraDocCoref,
    InterDocCoref,
    AbstractAnaphora,
    DiscontinuousNER,
    EventExtraction,
    TextClassification,
    SentimentAnalysis,
    PosTagging,
    MachineTranslation,
    LanguageModeling,
    Temporal,
    HierarchicalExtraction,
    DiscourseRelations,
    DiscourseCoherence,
    DiscourseSegmentation,
    SpeechActClassification,
}

Information extraction and NLP tasks supported by anno.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NER

Named Entity Recognition: extract entity spans with types

NED

Named Entity Disambiguation: link entities to knowledge bases

RelationExtraction

Relation Extraction: extract entity-relation-entity triples

IntraDocCoref

Intra-document Coreference: resolve mentions within a document

InterDocCoref

Inter-document Coreference: resolve mentions across documents

AbstractAnaphora

Abstract Anaphora: resolve pronouns to events/propositions

DiscontinuousNER

Discontinuous NER: extract non-contiguous entity spans

EventExtraction

Event Extraction: extract event triggers and arguments

TextClassification

Text Classification: classify entire text or spans

SentimentAnalysis

Sentiment analysis (a specialization of text classification)

PosTagging

Part-of-speech tagging

MachineTranslation

Machine translation

LanguageModeling

Language modeling

Temporal

Temporal extraction / temporal information (catalogued from registries).

Note: this is distinct from HierarchicalExtraction. Some registries use “temporal” to mean time expressions, event ordering, or temporal relations; we keep it separate so we don’t mislabel temporal datasets as hierarchical.

HierarchicalExtraction

Hierarchical Structure Extraction: extract nested structures

DiscourseRelations

Discourse relations (e.g., PDTB-style)

DiscourseCoherence

Discourse coherence / coherence modeling

DiscourseSegmentation

Discourse segmentation

SpeechActClassification

Speech act classification (dialogue acts)

Implementations

impl Task

pub fn all() -> &'static [Task]

All supported tasks.

pub fn name(&self) -> &'static str

Human-readable name for this task.

pub fn code(&self) -> &'static str

Short code for this task (for CLI/config).

pub fn from_code(code: &str) -> Option<Self>

Parse task from short code string.

Supports many common aliases used in dataset registry:

• NER: “ner”, “sequence_labeling”, “nested-ner”, “mner”, “pii_detection”, “slot_filling”
• NED: “ned”, “el”, “entity_linking”, “entity-linking”
• RelationExtraction: “re”, “relation_extraction”, “relation-extraction”
• IntraDocCoref: “coref”, “intra-coref”, “intra_coref”
• InterDocCoref: “inter-coref”, “inter_coref”, “cdcr”, “event_coref”
• AbstractAnaphora: “abstract-anaphora”, “abstract_anaphora”, “bridging”, “discourse_deixis”
• DiscontinuousNER: “discontinuous-ner”, “discontinuous_ner”, “dner”
• EventExtraction: “events”, “event_extraction”, “event-extraction”
• TextClassification: “classification”, “text-classification”, “bias_evaluation”, “qa”, “harmonic_analysis”
• Temporal: “temporal”, “timex”
• HierarchicalExtraction: “hierarchical”

pub fn is_ner_family(&self) -> bool

Check if this task is in the NER family (NER, discontinuous NER, NED).

pub fn is_coref_family(&self) -> bool

Check if this task is in the coreference family.

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Task

impl Debug for Task

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Task

impl Hash for Task

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Task

fn eq(&self, other: &Task) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Task

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Task