oxits 0.1.0

Time series classification and transformation library 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

"""Generate golden test data for preprocessing module."""

import numpy as np
from pyts.preprocessing import StandardScaler, MinMaxScaler, MaxAbsScaler, RobustScaler
from pyts.preprocessing import KBinsDiscretizer, InterpolationImputer


def generate():
    fixtures = []
    rng = np.random.RandomState(42)

    # StandardScaler
    X = rng.randn(4, 8)
    scaler = StandardScaler()
    result = scaler.transform(X)
    fixtures.append({
        "test_name": "standard_scaler_basic",
        "params": {"with_mean": True, "with_std": True},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # StandardScaler no mean
    scaler = StandardScaler(with_mean=False)
    result = scaler.transform(X)
    fixtures.append({
        "test_name": "standard_scaler_no_mean",
        "params": {"with_mean": False, "with_std": True},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # MinMaxScaler
    scaler = MinMaxScaler()
    result = scaler.transform(X)
    fixtures.append({
        "test_name": "minmax_scaler_basic",
        "params": {"sample_range": [0, 1]},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # MaxAbsScaler
    scaler = MaxAbsScaler()
    result = scaler.transform(X)
    fixtures.append({
        "test_name": "maxabs_scaler_basic",
        "params": {},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # RobustScaler
    scaler = RobustScaler()
    result = scaler.transform(X)
    fixtures.append({
        "test_name": "robust_scaler_basic",
        "params": {"quantile_range": [25, 75]},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # KBinsDiscretizer - uniform
    disc = KBinsDiscretizer(n_bins=4, strategy="uniform")
    result = disc.transform(X)
    fixtures.append({
        "test_name": "discretizer_uniform",
        "params": {"n_bins": 4, "strategy": "uniform"},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # KBinsDiscretizer - quantile
    disc = KBinsDiscretizer(n_bins=3, strategy="quantile")
    result = disc.transform(X)
    fixtures.append({
        "test_name": "discretizer_quantile",
        "params": {"n_bins": 3, "strategy": "quantile"},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # KBinsDiscretizer - normal
    disc = KBinsDiscretizer(n_bins=4, strategy="normal")
    result = disc.transform(X)
    fixtures.append({
        "test_name": "discretizer_normal",
        "params": {"n_bins": 4, "strategy": "normal"},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    return fixtures