bellande_artificial_intelligence_framework 0.1.0

A comprehensive artificial intelligence and computer vision training framework developed by Bellande AI Research. Provides tools and utilities for machine learning model development, training, and deployment.
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

// Copyright (C) 2024 Bellande Artificial Intelligence Computer Vision Research Innovation Center, Ronaldson Bellande

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use crate::core::{error::BellandeError, tensor::Tensor};

pub trait Activation {
    fn forward(&self, input: &Tensor) -> Result<Tensor, BellandeError>;
    fn backward(&self, grad_output: &Tensor) -> Result<Tensor, BellandeError>;
}

pub struct ReLU {
    mask: Option<Vec<bool>>,
}

impl ReLU {
    pub fn new() -> Self {
        ReLU { mask: None }
    }
}

impl Activation for ReLU {
    fn forward(&self, input: &Tensor) -> Result<Tensor, BellandeError> {
        let mut output = input.data.clone();
        let mask: Vec<bool> = output
            .iter_mut()
            .map(|x| {
                if *x < 0.0 {
                    *x = 0.0;
                    false
                } else {
                    true
                }
            })
            .collect();

        Ok(Tensor::new(
            output,
            input.shape.clone(),
            input.requires_grad,
            input.device.clone(),
            input.dtype,
        ))
    }

    fn backward(&self, grad_output: &Tensor) -> Result<Tensor, BellandeError> {
        if let Some(ref mask) = self.mask {
            let grad = grad_output
                .data
                .iter()
                .zip(mask.iter())
                .map(|(&g, &m)| if m { g } else { 0.0 })
                .collect();

            Ok(Tensor::new(
                grad,
                grad_output.shape.clone(),
                true,
                grad_output.device.clone(),
                grad_output.dtype,
            ))
        } else {
            Err(BellandeError::RuntimeError(
                "Forward pass not called".into(),
            ))
        }
    }
}

pub struct Sigmoid;

impl Activation for Sigmoid {
    fn forward(&self, input: &Tensor) -> Result<Tensor, BellandeError> {
        let output = input
            .data
            .iter()
            .map(|&x| 1.0 / (1.0 + (-x).exp()))
            .collect();

        Ok(Tensor::new(
            output,
            input.shape.clone(),
            input.requires_grad,
            input.device.clone(),
            input.dtype,
        ))
    }

    fn backward(&self, grad_output: &Tensor) -> Result<Tensor, BellandeError> {
        let grad = grad_output
            .data
            .iter()
            .map(|&x| {
                let s = 1.0 / (1.0 + (-x).exp());
                s * (1.0 - s)
            })
            .collect();

        Ok(Tensor::new(
            grad,
            grad_output.shape.clone(),
            true,
            grad_output.device.clone(),
            grad_output.dtype,
        ))
    }
}