Enum lfa::basis::Projection

pub enum Projection {
    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 Projection

pub fn is_dense(&self) -> bool

Return true if the projection is the Dense variant.

pub fn is_sparse(&self) -> bool

Return true if the projection is the Sparse variant.

pub fn activity(&self) -> usize

Return the number of active features in the projection.

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

Remove one feature entry from the projection, if present.

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

use lfa::basis::Projection;

let mut dense: Projection = vec![0.0, 0.2, 0.4, 0.4].into();
let mut sparse: Projection = 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: &Vector<f64>) -> f64

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

use lfa::basis::Projection;
use lfa::geometry::Vector;

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

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

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

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

use lfa::basis::Projection;
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!(
    Projection::matmul(&vec![0.1, 0.2, 0.7].into(), &weights).all_close(
        &Vector::from_vec(vec![1.1, 3.2]),
        1e-7 // eps
    )
);
assert_eq!(
    Projection::matmul(&vec![0, 1].into(), &weights),
    Vector::from_vec(vec![3.0, 8.0])
);

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

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

use lfa::basis::Projection;

assert_eq!(
    Projection::expanded(vec![0, 2, 1, 4].into(), 5),
    vec![1.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 projection 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 projection 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 projection; either Dense or Sparse, respectively.

Trait Implementations

impl Approximator<Projection> for ScalarFunction

type Value = f64

fn n_outputs(&self) -> usize

Return the dimensionality of the output value Approximator::Value.

fn evaluate(&self, p: &Projection) -> EvaluationResult<f64>

Evaluate the function and return its value.

fn update(&mut self, p: &Projection, error: f64) -> UpdateResult<()>

Update the approximator's estimate for the given input.

fn adapt(
    &mut self,
    new_features: &HashMap<IndexT, IndexSet>
) -> AdaptResult<usize>

Adapt the approximator in light of newly discovered features.

impl Approximator<Projection> for PairFunction

type Value = (f64, f64)

fn n_outputs(&self) -> usize

Return the dimensionality of the output value Approximator::Value.

fn evaluate(&self, p: &Projection) -> EvaluationResult<(f64, f64)>

Evaluate the function and return its value.

fn update(&mut self, p: &Projection, errors: (f64, f64)) -> UpdateResult<()>

Update the approximator's estimate for the given input.

fn adapt(
    &mut self,
    new_features: &HashMap<IndexT, IndexSet>
) -> AdaptResult<usize>

Adapt the approximator in light of newly discovered features.

impl Approximator<Projection> for TripleFunction

type Value = (f64, f64, f64)

fn n_outputs(&self) -> usize

Return the dimensionality of the output value Approximator::Value.

fn evaluate(&self, p: &Projection) -> EvaluationResult<(f64, f64, f64)>

Evaluate the function and return its value.

fn update(
    &mut self,
    p: &Projection,
    errors: (f64, f64, f64)
) -> UpdateResult<()>

Update the approximator's estimate for the given input.

fn adapt(
    &mut self,
    new_features: &HashMap<IndexT, IndexSet>
) -> AdaptResult<usize>

Adapt the approximator in light of newly discovered features.

impl Approximator<Projection> for VectorFunction

type Value = Vector<f64>

fn n_outputs(&self) -> usize

Return the dimensionality of the output value Approximator::Value.

fn evaluate(&self, p: &Projection) -> EvaluationResult<Vector<f64>>

Evaluate the function and return its value.

fn update(&mut self, p: &Projection, errors: Vector<f64>) -> UpdateResult<()>

Update the approximator's estimate for the given input.

fn adapt(
    &mut self,
    new_features: &HashMap<IndexT, IndexSet>
) -> AdaptResult<usize>

Adapt the approximator in light of newly discovered features.

impl PartialEq<Projection> for Projection

fn eq(&self, rhs: &Projection) -> 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 Projection

fn clone(&self) -> Projection

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 Projection

fn from(activations: DenseT) -> Projection

Performs the conversion.

impl From<Vec<f64>> for Projection

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

Performs the conversion.

impl From<BTreeSet<usize>> for Projection

fn from(indices: SparseT) -> Projection

Performs the conversion.

impl From<Vec<usize>> for Projection

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

Performs the conversion.

impl Add<Projection> for Projection

type Output = Projection

The resulting type after applying the + operator.

fn add(self, rhs: Projection) -> Projection

Performs the + operation.

impl Index<usize> for Projection

type Output = f64

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl FromIterator<f64> for Projection

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

Creates a value from an iterator.

impl FromIterator<usize> for Projection

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

Creates a value from an iterator.

impl Debug for Projection

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

Formats the value using the given formatter.

impl Serialize for Projection

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Projection

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

Deserialize this value from the given Serde deserializer.