concision-data 0.3.1

this crate provides additional tools for working with datasets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

/*
    Appellation: trainer <module>
    Contrib: @FL03
*/

mod impl_trainer;

use crate::Records;
use crate::dataset::DatasetBase;
use concision_core::Model;

pub trait ModelTrainer<T> {
    type Model: Model<T>;
    /// returns a model trainer prepared to train the model; this is a convenience method
    /// that creates a new trainer instance and returns it. Trainers are lazily evaluated
    /// meaning that the training process won't begin until the user calls the `begin` method.
    fn trainer<'a, U, V>(
        &mut self,
        dataset: DatasetBase<U, V>,
        model: &'a mut Self::Model,
    ) -> Trainer<'a, Self::Model, T, DatasetBase<U, V>>
    where
        Self: Sized,
        T: Default,
        for<'b> &'b mut Self::Model: Model<T>,
    {
        Trainer::new(model, dataset)
    }
}

/// The [`Trainer`] is a generalized model trainer that works to provide a common interface for
/// training models over datasets.
pub struct Trainer<'a, M, T, R>
where
    M: Model<T>,
    R: Records,
{
    /// the training dataset
    pub(crate) dataset: DatasetBase<R::Inputs, R::Targets>,
    pub(crate) model: &'a mut M,
    /// the accumulated loss
    pub(crate) loss: T,
}

impl<'a, M, T, R> core::ops::Deref for Trainer<'a, M, T, R>
where
    M: Model<T>,
    R: Records,
{
    type Target = M;

    fn deref(&self) -> &Self::Target {
        self.model
    }
}
impl<'a, M, T, R> core::ops::DerefMut for Trainer<'a, M, T, R>
where
    M: Model<T>,
    R: Records,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.model
    }
}