Struct CenteringState 

pub struct CenteringState {
    pub utterance_idx: usize,
    pub cf: Vec<ForwardCenter>,
    pub cb: Option<u64>,
    pub cp: Option<u64>,
    pub transition: CenteringTransition,
    pub recency_scores: HashMap<u64, f64>,
}

Centering state for a single utterance.

Captures the centering configuration at one point in the discourse:

• Cf: Forward-looking centers (entities mentioned, ranked by salience)
• Cb: Backward-looking center (what the utterance is “about”)
• Cp: Preferred center (predicted focus for next utterance)

Example

use anno::discourse::centering::{CenteringState, ForwardCenter};

let state = CenteringState::new(0)
    .with_cf(vec![
        ForwardCenter::new(1, "John", 1.0),
        ForwardCenter::new(2, "Mary", 0.8),
    ]);

// Cp is automatically set to the highest-ranked Cf
assert_eq!(state.cp, Some(1));

// Check if an entity is mentioned
assert!(state.mentions(1));
assert!(!state.mentions(99));

Fields

utterance_idx: usize

Index of this utterance in the discourse (0-based).

cf: Vec<ForwardCenter>

Forward-looking centers, ranked by effective salience (highest first). These are the entities mentioned in this utterance that could become the Cb of the next utterance.

cb: Option<u64>

Backward-looking center — the most salient entity from the previous utterance that is realized in this utterance. None for discourse-initial utterances or when no entity carries over.

cp: Option<u64>

Preferred center — the highest-ranked member of Cf. This predicts what the next utterance is likely to be about.

transition: CenteringTransition

Transition from previous utterance

recency_scores: HashMap<u64, f64>

Recency-weighted salience scores (entity_id -> score) This implements CT+recency from Jiang et al. (2022)

Implementations

impl CenteringState

pub fn new(utterance_idx: usize) -> CenteringState

Create a new centering state.

pub fn with_cf(self, cf: Vec<ForwardCenter>) -> CenteringState

Set forward-looking centers.

pub fn mentioned_entities(&self) -> Vec<u64>

Get entity IDs mentioned in this utterance.

pub fn mentions(&self, entity_id: u64) -> bool

Check if an entity is mentioned in this utterance.

pub fn get_fc(&self, entity_id: u64) -> Option<&ForwardCenter>

Get the forward center for an entity.

pub fn coherence_score(&self) -> f64

Get coherence score for this state.

Trait Implementations

impl Clone for CenteringState

fn clone(&self) -> CenteringState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CenteringState

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

Formats the value using the given formatter.

impl Default for CenteringState

fn default() -> CenteringState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CenteringState

fn deserialize<__D>( __deserializer: __D, ) -> Result<CenteringState, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CenteringState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.