Struct syntaxdot_encoders::categorical::CategoricalEncoder

pub struct CategoricalEncoder<E, V, M>where
    V: Clone + Eq + Hash,
    M: Number<V>,{ /* private fields */ }

An encoder wrapper that encodes/decodes to a categorical label.

Implementations

impl<E, V, M> CategoricalEncoder<E, V, M>where
    V: Clone + Eq + Hash,
    M: Number<V>,

pub fn new(encoder: E, numberer: Numberer<V>) -> Self

impl<D, M> CategoricalEncoder<D, D::Encoding, M>where
    D: SentenceDecoder,
    D::Encoding: Clone + Eq + Hash + ToOwned,
    M: Number<D::Encoding>,

pub fn decode_without_inner<S>(
    &self,
    labels: &[S]
) -> Vec<Vec<EncodingProb<D::Encoding>>>where
    S: AsRef<[EncodingProb<usize>]>,

Decode without applying the inner decoder.

impl<E, V, M> CategoricalEncoder<E, V, M>where
    V: Clone + Eq + Hash,
    M: Number<V>,

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

Trait Implementations

impl<'de, E, V, M> Deserialize<'de> for CategoricalEncoder<E, V, M>where
    V: Clone + Eq + Hash,
    M: Number<V>,
    E: Deserialize<'de>,
    M: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<D, M> SentenceDecoder for CategoricalEncoder<D, D::Encoding, M>where
    D: SentenceDecoder,
    D::Encoding: Clone + Eq + Hash,
    M: Number<D::Encoding>,

type Encoding = usize

type Error = <D as SentenceDecoder>::Error

The decoding error type.

fn decode<S>(
    &self,
    labels: &[S],
    sentence: &mut Sentence
) -> Result<(), Self::Error>where
    S: AsRef<[EncodingProb<Self::Encoding>]>,

impl<E, M> SentenceEncoder for CategoricalEncoder<E, E::Encoding, M>where
    E: SentenceEncoder,
    E::Encoding: Clone + Eq + Hash,
    M: Number<E::Encoding>,

type Encoding = usize

type Error = <E as SentenceEncoder>::Error

The encoding error type.

fn encode(&self, sentence: &Sentence) -> Result<Vec<Self::Encoding>, Self::Error>

Encode the given sentence.

impl<E, V, M> Serialize for CategoricalEncoder<E, V, M>where
    V: Clone + Eq + Hash,
    M: Number<V>,
    E: Serialize,
    M: Serialize,

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

Serialize this value into the given Serde serializer.