athenna 0.1.2

Athenna is a light weight highly performant neural net framework for creating and using AI's cross platform and language
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


#[derive(Copy, Clone)]
pub enum Activations {
	Sigmoid,
	TanH,
	ReLU,
	LeakyRelu,
	SoftMax,
	Linear
}

pub fn activation_to_string(act:&Activations) -> String {
	match act {
		Activations::Sigmoid => "sigmoid".to_string(),
		Activations::TanH => "tanh".to_string(),
		Activations::ReLU => "relu".to_string(),
		Activations::LeakyRelu => "leakyrelu".to_string(),
		Activations::Linear => "linear".to_string(),
		Activations::SoftMax => "softmax".to_string(),
	}
}

pub fn string_to_activation(val:&str) -> Activations {
	match val {
		"sigmoid" => Activations::Sigmoid,
		"tanh" => Activations::TanH,
		"relu" => Activations::ReLU,
		"leakyrelu" => Activations::LeakyRelu,
		"linear" => Activations::Linear,
		"softmax" => Activations::SoftMax,
		_ => Activations::LeakyRelu
	}
}

pub fn sigmoid(x:f32) -> f32
{
	let k = x.exp();
	k / (1.0 + k)
}

pub fn tanh(x:f32) -> f32
{
	x.tanh()
}

pub fn relu(x:f32) -> f32
{
	match 0.0 >= x {
		true => {0.0},
		false => {x}
	}
}

pub fn leakyrelu(x:f32) -> f32
{
	match 0.0 >= x {
		true => {0.01 * x},
		false => {x}
	}
}

pub fn sigmoid_deriv(x:f32) -> f32
{
	x * (1.0 - x)
}

pub fn tanh_deriv(x:f32) -> f32
{
	1.0 - (x * x)
}

pub fn relu_deriv(x:f32) -> f32
{
	match 0.0 >= x {
		true => {0.0},
		false => {x}
	}
}

pub fn leakyrelu_deriv(x:f32) -> f32
{
	match 0.0 >= x {
		true => {0.01},
		false => {x}
	}
}

pub fn softmax(x:f32) -> f32
{
	x.exp()
}