Skip to content

frequency_mix_style

Frequency Mix Style Layer API

This module provides classes to perform frequency mix style augmentation.

Classes:

Classes

FrequencyMixStyle2D 

FrequencyMixStyle2D(probability: float = 0.5, alpha: float = 1.0, epsilon: float = 1e-06, **kwargs)

Apply frequency mix style augmentation to the 2D input.

Parameters:

  • probability

    (float, default: 0.5 ) –

    Probability of applying the augmentation.

  • alpha

    (float, default: 1.0 ) –

    Mixup alpha value.

  • epsilon

    (float, default: 1e-06 ) –

    Epsilon value for numerical stability.

Example:

    x = np.random.rand(4, 4, 3)
    lyr = FrequencyMixStyle2D(probability=1.0, alpha=1.0)
    y = lyr(x, training=True)
Source code in neuralspot_edge/layers/preprocessing/frequency_mix_style.py 
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
def __init__(
    self,
    probability: float = 0.5,
    alpha: float = 1.0,
    epsilon: float = 1e-6,
    **kwargs,
):
    """Apply frequency mix style augmentation to the 2D input.

    Args:
        probability (float): Probability of applying the augmentation.
        alpha (float): Mixup alpha value.
        epsilon (float): Epsilon value for numerical stability.

    Example:

    ```python
        x = np.random.rand(4, 4, 3)
        lyr = FrequencyMixStyle2D(probability=1.0, alpha=1.0)
        y = lyr(x, training=True)
    ```
    """

    super().__init__(**kwargs)
    self.probability, _ = parse_factor([None, probability], min_value=0.0, max_value=1.0, param_name="probability")
    self.alpha, _ = parse_factor([None, alpha], min_value=0.0, max_value=None, param_name="alpha")
    self.epsilon, _ = parse_factor([None, epsilon], min_value=0.0, max_value=None, param_name="epsilon")

Functions

get_random_transformations 
get_random_transformations(input_shape: tuple[int, int, int]) -> dict

Generate noise distortion tensor

Parameters:

  • input_shape
    (tuple[int, ...]) –

    Input shape.

Returns:

  • dict ( dict ) –

    Dictionary containing the noise tensor.

Source code in neuralspot_edge/layers/preprocessing/frequency_mix_style.py 
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
def get_random_transformations(self, input_shape: tuple[int, int, int]) -> dict:
    """Generate noise distortion tensor

    Args:
        input_shape (tuple[int, ...]): Input shape.

    Returns:
        dict: Dictionary containing the noise tensor.
    """
    batch_size = input_shape[0]
    skip_augment = keras.random.uniform(
        shape=(),
        minval=0.0,
        maxval=1.0,
        dtype="float32",
        seed=self.random_generator
    )
    lmda = keras.random.beta(
        shape=(batch_size, 1, 1, 1),
        alpha=self.alpha,
        beta=self.alpha,
        seed=self.random_generator
    )
    perm = keras.random.shuffle(
        keras.ops.arange(batch_size),
        seed=self.random_generator
    )
    return {"lmda": lmda, "perm": perm, "skip_augment": skip_augment}
apply_mixstyle 
apply_mixstyle(x, lmda, perm)

Apply mixstyle augmentation

Parameters:

  • x
    (Tensor) –

    Input tensor

  • lmda
    (Tensor) –

    Lambda tensor

  • perm
    (Tensor) –

    Permutation tensor

Returns:

  • –

    tf.Tensor: Augmented tensor

Source code in neuralspot_edge/layers/preprocessing/frequency_mix_style.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def apply_mixstyle(self, x, lmda, perm):
    """Apply mixstyle augmentation

    Args:
        x (tf.Tensor): Input tensor
        lmda (tf.Tensor): Lambda tensor
        perm (tf.Tensor): Permutation tensor

    Returns:
        tf.Tensor: Augmented tensor
    """
    f_mu = keras.ops.mean(x, axis=[2, 3], keepdims=True)
    f_var = keras.ops.var(x, axis=[2, 3], keepdims=True)
    f_sig = keras.ops.sqrt(f_var + self.epsilon)

    x_normed = (x - f_mu) / f_sig
    f_mu_perm = keras.ops.take(f_mu, perm, axis=0)
    f_sig_perm = keras.ops.take(f_sig, perm, axis=0)
    x_perm = keras.ops.take(x_normed, perm, axis=0)
    x_mix = lmda * x_normed + (1 - lmda) * x_perm
    x_mix = x_mix * f_sig_perm + f_mu_perm
    return x_mix
augment_samples 
augment_samples(inputs) -> keras.KerasTensor

Augment samples

Parameters:

  • inputs
    (Tensor) –

    Input tensor

Returns:

  • KerasTensor –

    tf.Tensor: Augmented tensor

Source code in neuralspot_edge/layers/preprocessing/frequency_mix_style.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def augment_samples(self, inputs) -> keras.KerasTensor:
    """Augment samples

    Args:
        inputs (tf.Tensor): Input tensor

    Returns:
        tf.Tensor: Augmented tensor
    """

    samples = inputs[self.SAMPLES]
    transforms = inputs[self.TRANSFORMS]
    skip_augment = transforms["skip_augment"]
    if self.training:
        lmda = transforms["lmda"]
        perm = transforms["perm"]
        return keras.ops.cond(
            skip_augment > self.probability,
            lambda: samples,
            lambda: self.apply_mixstyle(samples, lmda, perm)
        )
    return samples