chela 0.0.2

High-performance Machine Learning, Auto-Differentiation and Tensor Algebra crate for Rust
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

import numpy as np
import torch

from perfprofiler import *

NUMPY_DTYPE = np.float32
TORCH_DTYPE = torch.float32

N = 10000000


class TensorReduceTimingSuite(TimingSuite):
    ID: int

    def __init__(self, shape: tuple[int, ...], method: str):
        self.ndarray: np.ndarray = np.random.rand(*shape).astype(NUMPY_DTYPE)
        self.tensor: torch.Tensor = torch.rand(*shape, dtype=TORCH_DTYPE)
        self.method = method

    @measure_performance("NumPy")
    def run(self):
        getattr(self.ndarray, self.method)()

    @measure_performance("PyTorch CPU")
    def run(self):
        self.tensor.sum()

    @measure_rust_performance("Chela CPU", target="reduce")
    def run(self, executable):
        return run_rust(executable, self.ID)



class TensorReduce0(TensorReduceTimingSuite):
    ID = 0
    name = "Sum"
    
    def __init__(self):
        super().__init__((N, ), "sum")


class TensorReduce1(TensorReduceTimingSuite):
    ID = 1
    name = "Product"

    def __init__(self):
        super().__init__((N, ), "prod")


class TensorReduce2(TensorReduceTimingSuite):
    ID = 2
    name = "Min"

    def __init__(self):
        super().__init__((N, ), "min")


class TensorReduce3(TensorReduceTimingSuite):
    ID = 3
    name = "Max"

    def __init__(self):
        super().__init__((N, ), "max")


class TensorReduce10(TensorReduceTimingSuite):
    ID = 10
    name = "Sum Slice"

    def __init__(self):
        super().__init__((N, 2), "sum")
        self.ndarray = self.ndarray[:, 0]
        self.tensor = self.tensor[:, 0]


class TensorReduce11(TensorReduceTimingSuite):
    ID = 11
    name = "Product Slice"

    def __init__(self):
        super().__init__((N, 2), "prod")
        self.ndarray = self.ndarray[:, 0]
        self.tensor = self.tensor[:, 0]


class TensorReduce12(TensorReduceTimingSuite):
    ID = 12
    name = "Min Slice"

    def __init__(self):
        super().__init__((N, 2), "min")
        self.ndarray = self.ndarray[:, 0]
        self.tensor = self.tensor[:, 0]


class TensorReduce13(TensorReduceTimingSuite):
    ID = 13
    name = "Max Slice"

    def __init__(self):
        super().__init__((N, 2), "max")
        self.ndarray = self.ndarray[:, 0]
        self.tensor = self.tensor[:, 0]


if __name__ == "__main__":
    results = profile_all([
        TensorReduce0,
        TensorReduce10,

        TensorReduce1,
        TensorReduce11,

        TensorReduce2,
        TensorReduce12,

        TensorReduce3,
        TensorReduce13,
    ], n=10)
    plot_barplot(results, "Tensor Reduction Benchmark")