Skip to content

patterns

PatternsGenerator

Bases: GeneratorMixin

Base class for transformers that generate patterns in time-series data

Source code in badgers/generators/time_series/patterns.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class PatternsGenerator(GeneratorMixin):
    """
    Base class for transformers that generate patterns in time-series data
    """

    def __init__(self, random_generator=default_rng(seed=0), n_patterns: int = 10):
        """
        :param random_generator: a random number generator
        :param n_patterns: the number of patterns to generate
        """
        self.random_generator = random_generator
        self.n_patterns = n_patterns
        self.patterns_indices_ = []

    @abc.abstractmethod
    def generate(self, X, y, **params) -> Tuple:
        pass

__init__(random_generator=default_rng(seed=0), n_patterns=10)

:param random_generator: a random number generator :param n_patterns: the number of patterns to generate

Source code in badgers/generators/time_series/patterns.py 
15
16
17
18
19
20
21
22
def __init__(self, random_generator=default_rng(seed=0), n_patterns: int = 10):
    """
    :param random_generator: a random number generator
    :param n_patterns: the number of patterns to generate
    """
    self.random_generator = random_generator
    self.n_patterns = n_patterns
    self.patterns_indices_ = []

RandomConstantPatterns

Bases: PatternsGenerator

Randomly generates constant patterns of constant value

Source code in badgers/generators/time_series/patterns.py 
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
class RandomConstantPatterns(PatternsGenerator):
    """
    Randomly generates constant patterns of constant value
    """

    def __init__(self, random_generator=default_rng(seed=0), n_patterns: int = 10, patterns_width: int = 10,
                 constant_value: float = 0):
        super().__init__(random_generator=random_generator, n_patterns=n_patterns)
        self.patterns_width = patterns_width
        self.constant_value = constant_value

    def generate(self, X, y, **params) -> Tuple:
        # TODO input validation!
        if X.ndim < 2:
            raise ValueError(
                "Expected 2D array. "
                "Reshape your data either using array.reshape(-1, 1) if "
                "your data has a single feature or array.reshape(1, -1) "
                "if it contains a single sample."
            )
        # generate extreme values indices and values
        self.patterns_indices_ = [(x, x + self.patterns_width) for x in
                                  self.random_generator.choice(X.shape[0] - self.patterns_width, size=self.n_patterns,
                                                               replace=False, p=None)]

        for (start, end) in self.patterns_indices_:
            X[start:end, :] = self.constant_value

        return X, y

RandomLinearPatterns

Bases: PatternsGenerator

Randomly generates patterns of constant slope (linear)

Source code in badgers/generators/time_series/patterns.py 
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
class RandomLinearPatterns(PatternsGenerator):
    """
        Randomly generates patterns of constant slope (linear)
        """

    def __init__(self, random_generator=default_rng(seed=0), n_patterns: int = 10, patterns_width: int = 10):
        super().__init__(random_generator=random_generator, n_patterns=n_patterns)
        self.patterns_width = patterns_width

    def generate(self, X, y, **params) -> Tuple:
        # TODO input validation!
        if X.ndim < 2:
            raise ValueError(
                "Expected 2D array. "
                "Reshape your data either using array.reshape(-1, 1) if "
                "your data has a single feature or array.reshape(1, -1) "
                "if it contains a single sample."
            )
        # generate extreme values indices and values
        self.patterns_indices_ = [(x, x + self.patterns_width) for x in
                                  self.random_generator.choice(X.shape[0] - self.patterns_width, size=self.n_patterns,
                                                               replace=False, p=None)]

        for (start, end) in self.patterns_indices_:
            for col in range(X.shape[1]):
                X[start:end, col] = np.linspace(X[start,col],X[end,col], end - start)

        return X, y