Struct linfa::dataset::CountedTargets

pub struct CountedTargets<L: Label, P> { /* private fields */ }

Targets with precomputed, counted labels

This extends plain targets with pre-counted labels. The label map is useful when, for example, a prior probability is estimated (e.g. in Naive Bayesian implementation) or the samples are weighted inverse to their occurence.

Fields

• targets: wrapped target field
• labels: counted labels with label-count association

Implementations

impl<L: Label, S: Labels<Elem = L>> CountedTargets<L, S>

pub fn new(targets: S) -> Self

Trait Implementations

impl<L: Label, T: AsTargets<Elem = L>> AsTargets for CountedTargets<L, T>

type Elem = L

type Ix = <T as AsTargets>::Ix

fn as_targets(&self) -> ArrayView<'_, Self::Elem, Self::Ix>

impl<L: Label, T: AsTargetsMut<Elem = L>> AsTargetsMut for CountedTargets<L, T>

type Elem = L

type Ix = <T as AsTargetsMut>::Ix

fn as_targets_mut(&mut self) -> ArrayViewMut<'_, Self::Elem, Self::Ix>

impl<L: Clone + Label, P: Clone> Clone for CountedTargets<L, P>

fn clone(&self) -> CountedTargets<L, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug + Label, P: Debug> Debug for CountedTargets<L, P>

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

Formats the value using the given formatter.

impl<'a, L: Label + 'a, T> FromTargetArray<'a> for CountedTargets<L, T>

where T: FromTargetArray<'a, Elem = L>, T::Owned: Labels<Elem = L>, T::View: Labels<Elem = L>,

type Owned = CountedTargets<L, <T as FromTargetArray<'a>>::Owned>

type View = CountedTargets<L, <T as FromTargetArray<'a>>::View>

fn new_targets(targets: Array<L, T::Ix>) -> Self::Owned

Create self object from new target array

fn new_targets_view(targets: ArrayView<'a, L, T::Ix>) -> Self::View

impl<L: Label, T: AsTargets<Elem = L>> Labels for CountedTargets<L, T>

Counted labels can act as labels

type Elem = L

fn label_count(&self) -> Vec<HashMap<L, usize>>

fn label_set(&self) -> Vec<HashSet<Self::Elem>>

fn labels(&self) -> Vec<Self::Elem>

impl<L: PartialEq + Label, P: PartialEq> PartialEq for CountedTargets<L, P>

fn eq(&self, other: &CountedTargets<L, P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<L: Eq + Label, P: Eq> Eq for CountedTargets<L, P>

impl<L: Label, P> StructuralEq for CountedTargets<L, P>

impl<L: Label, P> StructuralPartialEq for CountedTargets<L, P>