tinguely 0.1.1

Machine learning library
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use mathru::algebra::linear::{Vector, Matrix};
use mathru::optimization::{Optim};
use mathru::optimization::Gradient;
use mathru::algebra::abstr::Real;
use crate::model::SupervisedLearn;

/// Linear regression
///
/// For more information: <br>
/// <a href="https://en.wikipedia.org/wiki/Linear_regression">https://en.wikipedia.org/wiki/Linear_regression</a>
///
///
pub struct LinearRegression<T>
{
	beta: Option<Vector<T>>,

	optim: Gradient<T>,
}

impl<T> LinearRegression<T>
	where T: Real
{
	pub fn new(optim: Gradient<T>) -> LinearRegression<T>
	{
		LinearRegression
		{
			beta: None,
			optim: optim
		}
	}

  	pub fn parameters(self: &Self) -> Option<Vector<T>>
  	{
        self.beta.clone()
	}
}


impl<T> SupervisedLearn<Matrix<T>, Vector<T>> for LinearRegression<T>
	where T: Real
{
	fn predict(self: &Self, x: &Matrix<T>) -> Result<Vector<T>, ()>
	{
		let (m, n) : (usize, usize) = x.dim();

		let ones: Matrix<T> = Matrix::<T>::ones(m, n + 1);

		let full_input: Matrix<T> = ones.set_slice( x, 0, 1);

		return match self.beta.clone()
		{
			Some(beta) => Ok(&full_input * &beta),
			None => Err(())
		}

	}

	/// Train the linear regression model.
    ///
    /// # Examples
    ///
    /// ```
    /// //use tinguely::regression::LinearRegression;
    /// //use mathru::algebra::linear::{Vector, Matrix};
    /// //use mathru::optimization::Gradient;
    /// //use tinguely::SupervisedLearn;
    ///
    /// //let optimizer = Gradient::new(0.1, 200);
    /// //let mut lin_mod: LinearRegression<f64> = LinearRegression::new(optimizer);
    /// //let inputs: Matrix<f64> = Matrix::new(3, 1, vec![2.0, 3.0, 4.0]);
    /// //let targets: Vector<f64> = Vector::new_column(3, vec![5.0, 6.0, 7.0]);
    ///
    /// //lin_mod.train(&inputs, &targets);
    /// ```
    fn train(self: &mut Self, x: &Matrix<T>, y: &Vector<T>)
	{
		let (x_m, x_n): (usize, usize) = x.dim();
		let (y_m, _y_n): (usize, usize) = x.dim();

		if x_m != y_m
		{
			panic!("Dimension mismatch")
		}

        let ones: Matrix<T> = Matrix::<T>::ones(x_m, x_n + 1);
        let full_input: Matrix<T> = ones.set_slice( x, 0, 1);

		let beta_0: Vector<T> = Vector::new_column(x_n + 1, vec![T::from_f64(0.1), T::from_f64(1.0)]);

		let base: LeastMeanSquare<T> = LeastMeanSquare::new(y, &full_input);

		let beta: Vector<T> = self.optim.minimize(&base, &beta_0).arg();

		self.beta = Some(beta);
	}
}

pub struct LeastMeanSquare<'a, T>
{
	pub x: &'a Matrix<T>,
	pub y: &'a Vector<T>,
}

impl<'a, T> LeastMeanSquare<'a, T>
	where T: Real
{
	fn new(y: &'a Vector<T>, x: &'a Matrix<T>) -> LeastMeanSquare<'a, T>
	{
		LeastMeanSquare
		{
				y: y,
				x: x
		}
	}
}

impl<'a, T> Optim<T> for LeastMeanSquare<'a, T>
	where T: Real
{
	///
	/// ```math
	/// J(\theta) = X^{T}\theta X - X^{T}\theta
	/// ```
	fn eval(&self, beta: &Vector<T>) -> Vector<T>
	{
		let y_hat: Vector<T> = self.x * &beta.clone();

		let diff: Vector<T> = &y_hat - self.y;

		let k: Vector<T> =  diff.apply(&|&x| {return x * x / T::from(2.0)});

		return Vector::new_column(1, vec![k.dotp(&k)]);
	}

	///
	/// ```math
	/// \nabla J(\theta) = X^T X \theta - X^T y = X^T(X \theta - y)
	///
	/// ```
	fn jacobian(&self, beta: &Vector<T>) -> Matrix<T>
	{
		let y_hat: Vector<T> = self.x * beta;

		let diff: Vector<T> = (&y_hat - self.y).transpose();
		return Matrix::from( &diff * self.x);
	}

	/// Computes the Hessian at the given value x
	fn hessian(&self, _x: &Vector<T>) -> Matrix<T>
	{
		unimplemented!();
	}
}