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 approximation module."""

import numpy as np
from pyts.approximation import (
    PiecewiseAggregateApproximation,
    SymbolicAggregateApproximation,
    DiscreteFourierTransform,
    MultipleCoefficientBinning,
    SymbolicFourierApproximation,
)


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

    X = rng.randn(4, 16)

    # PAA (window_size=None required to use output_size in pyts)
    paa = PiecewiseAggregateApproximation(window_size=None, output_size=4)
    result = paa.transform(X)
    fixtures.append({
        "test_name": "paa_basic",
        "params": {"output_size": 4},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # PAA with different output size
    paa = PiecewiseAggregateApproximation(window_size=None, output_size=8)
    result = paa.transform(X)
    fixtures.append({
        "test_name": "paa_8",
        "params": {"output_size": 8},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-10,
    })

    # SAX — convert char output to numeric bin indices (a=0, b=1, ...)
    sax = SymbolicAggregateApproximation(n_bins=4, strategy="normal")
    result = sax.transform(X)
    result_numeric = [[ord(c) - ord('a') for c in row] for row in result.tolist()]
    fixtures.append({
        "test_name": "sax_basic",
        "params": {"n_bins": 4, "strategy": "normal"},
        "input": {"X": X.tolist()},
        "expected": {"output": result_numeric},
        "tolerance": 1e-10,
    })

    # DFT
    dft = DiscreteFourierTransform(n_coefs=6)
    dft.fit(X)
    result = dft.transform(X)
    fixtures.append({
        "test_name": "dft_basic",
        "params": {"n_coefs": 6},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-8,
    })

    # DFT with norm_mean
    dft = DiscreteFourierTransform(n_coefs=6, norm_mean=True)
    dft.fit(X)
    result = dft.transform(X)
    fixtures.append({
        "test_name": "dft_norm_mean",
        "params": {"n_coefs": 6, "norm_mean": True},
        "input": {"X": X.tolist()},
        "expected": {"output": result.tolist()},
        "tolerance": 1e-8,
    })

    # MCB — convert char output to numeric bin indices
    mcb = MultipleCoefficientBinning(n_bins=4, strategy="quantile")
    result = mcb.fit_transform(X)
    result_numeric = [[ord(c) - ord('a') for c in row] for row in result.tolist()]
    fixtures.append({
        "test_name": "mcb_basic",
        "params": {"n_bins": 4, "strategy": "quantile"},
        "input": {"X": X.tolist()},
        "expected": {"output": result_numeric},
        "tolerance": 1e-10,
    })

    # SFA — convert char output to numeric bin indices
    sfa = SymbolicFourierApproximation(n_coefs=4, n_bins=4, strategy="quantile")
    result = sfa.fit_transform(X)
    result_numeric = [[ord(c) - ord('a') for c in row] for row in result.tolist()]
    fixtures.append({
        "test_name": "sfa_basic",
        "params": {"n_coefs": 4, "n_bins": 4, "strategy": "quantile"},
        "input": {"X": X.tolist()},
        "expected": {"output": result_numeric},
        "tolerance": 1e-8,
    })

    return fixtures