Enum lfa::core::Features

pub enum Features {
    Dense(DenseT),
    Sparse(SparseT),
}

Projected feature vector representation.

Variants

Dense(DenseT)

Dense, floating-point activation vector.

Sparse(SparseT)

Sparse, index-based activation vector.

Note: it is taken that all active indices have implied activation of 1.

Methods

impl Features

pub fn is_dense(&self) -> bool

Return true if the features is the Dense variant.

pub fn is_sparse(&self) -> bool

Return true if the features is the Sparse variant.

pub fn activity(&self) -> usize

Return the number of active features.

pub fn remove(&mut self, idx: usize)

Remove one feature entry from the features, if present.

For the Features::Dense variant, the feature is set to zero, and for the Features::Sparse variant, the feature index is removed entirely.

use lfa::basis::Features;

let mut dense: Features = vec![0.0, 0.2, 0.4, 0.4].into();
let mut sparse: Features = vec![0, 10, 15].into();

dense.remove(1);
sparse.remove(10);

assert_eq!(dense, vec![0.0, 0.0, 0.4, 0.4].into());
assert_eq!(sparse, vec![0, 15].into());

pub fn dot(&self, weights: &VectorView<f64>) -> f64

Apply the dot product operation between the Features and some other Vector, typically a set of weights.

use lfa::basis::Features;
use lfa::geometry::Vector;

let weights = Vector::from_vec(vec![2.0, 5.0, 1.0]);

assert_eq!(Features::dot(&vec![0.0, 0.2, 0.8].into(), &weights.view()), 1.8);
assert_eq!(Features::dot(&vec![0, 1].into(), &weights.view()), 7.0);

pub fn dot_dense(activations: &DenseT, weights: &VectorView<f64>) -> f64

pub fn dot_sparse(indices: &SparseT, weights: &VectorView<f64>) -> f64

pub fn matmul(&self, weights: &MatrixView<f64>) -> Vector<f64>

Apply the dot product operation between the Features and some other Vector, typically a set of weights.

use lfa::basis::Features;
use lfa::geometry::{Matrix, Vector};

let weights = Matrix::from_shape_vec((3, 2), vec![2.0, 5.0, 1.0, 3.0, 1.0, 3.0]).unwrap();

assert!(
    Features::matmul(&vec![0.1, 0.2, 0.7].into(), &weights.view()).all_close(
        &Vector::from_vec(vec![1.1, 3.2]),
        1e-7 // eps
    )
);
assert_eq!(
    Features::matmul(&vec![0, 1].into(), &weights.view()),
    Vector::from_vec(vec![3.0, 8.0])
);

pub fn expanded(&self, dim: usize) -> DenseT

Expand the features and convert it into a raw, dense vector.

use lfa::basis::Features;

assert_eq!(
    Features::expanded(&vec![0, 2, 1, 4].into(), 5),
    vec![1.0, 1.0, 1.0, 0.0, 1.0].into()
);

pub fn stack(self, d1: usize, other: Features, d2: usize) -> Features

Stack two feature vectors together, maintaining sparsity where possible.

use lfa::basis::Features;

assert_eq!(
    Features::stack(vec![0.0, 1.0].into(), 2, vec![1.0, 0.0, 1.0].into(), 3),
    vec![0.0, 1.0, 1.0, 0.0, 1.0].into()
);

pub fn map_dense<F, T>(self, f: impl FnOnce(DenseT) -> T) -> Option<T>

Apply the function f to the features if the Dense variant or return None.

pub fn map_sparse<F, T>(self, f: impl FnOnce(SparseT) -> T) -> Option<T>

Apply the function f to the features if the Sparse variant or return None.

pub fn map_either<T>(
    self,
    f_dense: impl FnOnce(DenseT) -> T,
    f_sparse: impl FnOnce(SparseT) -> T
) -> T

Apply the function f or g depending on the contents of the features; either Dense or Sparse, respectively.

Trait Implementations

impl PartialEq<Features> for Features

fn eq(&self, rhs: &Features) -> bool

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

#[must_use]

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

This method tests for !=.

impl Clone for Features

fn clone(&self) -> Features

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for Features

fn from(activations: DenseT) -> Features

Performs the conversion.

impl From<Vec<f64>> for Features

fn from(activations: Vec<ActivationT>) -> Features

Performs the conversion.

impl From<BTreeSet<usize>> for Features

fn from(indices: SparseT) -> Features

Performs the conversion.

impl From<Vec<usize>> for Features

fn from(indices: Vec<IndexT>) -> Features

Performs the conversion.

impl Debug for Features

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

Formats the value using the given formatter.

impl Index<usize> for Features

type Output = f64

The returned type after indexing.

fn index(&self, idx: usize) -> &f64

Performs the indexing (container[index]) operation.

impl FromIterator<f64> for Features

fn from_iter<I: IntoIterator<Item = ActivationT>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<usize> for Features

fn from_iter<I: IntoIterator<Item = IndexT>>(iter: I) -> Self

Creates a value from an iterator.