Skip to content

random_crop

Random Crop Layers API

This module provides classes to build random crop layers.

Classes:

Classes

RandomCrop1D 

RandomCrop1D(duration: int, unique_batch: bool = False, **kwargs)

Randomly crop 1D input samples.

Parameters:

  • duration (int) –

    Duration of the output samples.

  • unique_batch (bool, default: False ) –

    If True, each sample in the batch will have a unique crop.

Example:

    duration = 100
    lyr = RandomCrop1D(duration=duration)
    x = np.random.randn(32, 1000, 1)
    y = lyr(x, training=True)
Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def __init__(self, duration: int, unique_batch: bool = False, **kwargs):
    """Randomly crop 1D input samples.

    Args:
        duration (int): Duration of the output samples.
        unique_batch (bool): If True, each sample in the batch will have a unique crop.

    Example:

    ```python
        duration = 100
        lyr = RandomCrop1D(duration=duration)
        x = np.random.randn(32, 1000, 1)
        y = lyr(x, training=True)
    ```
    """

    super().__init__(**kwargs)
    self.duration = duration
    self.unique_batch = unique_batch

Functions

random_crop 
random_crop(sample, start)

Randomly crop single sample

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
43
44
45
46
47
48
def random_crop(self, sample, start):
    """Randomly crop single sample"""
    ch_size = keras.ops.shape(sample)[self.ch_axis]
    if self.data_format == "channels_first":
        return keras.ops.slice(sample, [0, start], [ch_size, self.duration])
    return keras.ops.slice(sample, [start, 0], [self.duration, ch_size])
get_random_transformations 
get_random_transformations(input_shape)

Generate random start indices for cropping.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
def get_random_transformations(self, input_shape):
    """Generate random start indices for cropping."""
    batch_size = input_shape[0]
    duration_size = input_shape[self.data_axis]
    if duration_size < self.duration:
        raise ValueError(f"Input duration ({duration_size}) must be greater than output duration ({self.duration})")

    d_diff = duration_size - self.duration
    if self.unique_batch:
        start = keras.random.randint(
            shape=(batch_size,), minval=0, maxval=int(d_diff + 1), seed=self.random_generator, dtype="int32"
        )
    else:
        start = keras.random.randint(
            shape=(), minval=0, maxval=int(d_diff + 1), seed=self.random_generator, dtype="int32"
        )
        start = keras.ops.broadcast_to(start, [batch_size])
    return {"start": start}
augment_sample 
augment_sample(inputs) -> keras.KerasTensor

Augment single sample with random crop.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
72
73
74
75
76
77
78
79
def augment_sample(self, inputs) -> keras.KerasTensor:
    """Augment single sample with random crop."""
    sample = inputs[self.SAMPLES]
    start = inputs[self.TRANSFORMS]["start"]

    if self.training:
        sample = self.random_crop(sample, start)
    return sample
compute_output_shape 
compute_output_shape(input_shape, *args, **kwargs)

Compute the output shape of the layer.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
81
82
83
84
85
def compute_output_shape(self, input_shape, *args, **kwargs):
    """Compute the output shape of the layer."""
    output_shape = list(input_shape)
    output_shape[self.data_axis] = self.duration
    return tuple(input_shape)
get_config 
get_config()

Serializes the configuration of the layer.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
87
88
89
90
91
92
93
94
95
96
def get_config(self):
    """Serializes the configuration of the layer."""
    config = super().get_config()
    config.update(
        {
            "duration": self.duration,
            "unique_batch": self.unique_batch,
        }
    )
    return config

RandomCrop2D 

RandomCrop2D(height: int, width: int, unique_batch: bool = False, **kwargs)

Randomly crop 2D input samples.

Parameters:

  • height (int) –

    Height of the output samples.

  • width (int) –

    Width of the output samples.

  • unique_batch (bool, default: False ) –

    If True, each sample in the batch will have a unique crop.

Example:

    height = 32
    width = 32
    lyr = RandomCrop2D(height=height, width=width)
    x = np.random.randn(32, 64, 64, 3)
    y = lyr(x, training=True)
Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
def __init__(self, height: int, width: int, unique_batch: bool = False, **kwargs):
    """Randomly crop 2D input samples.

    Args:
        height (int): Height of the output samples.
        width (int): Width of the output samples.
        unique_batch (bool): If True, each sample in the batch will have a unique crop.

    Example:

    ```python
        height = 32
        width = 32
        lyr = RandomCrop2D(height=height, width=width)
        x = np.random.randn(32, 64, 64, 3)
        y = lyr(x, training=True)
    ```
    """

    super().__init__(**kwargs)
    self.height = height
    self.width = width
    self.unique_batch = unique_batch

Functions

random_crop 
random_crop(sample, start_h, start_w)

Randomly crop single sample

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
129
130
131
132
133
def random_crop(self, sample, start_h, start_w):
    """Randomly crop single sample"""
    if self.data_format == "channels_first":
        return keras.ops.slice(sample, [0, start_h, start_w], [-1, self.height, self.width])
    return keras.ops.slice(sample, [start_h, start_w, 0], [self.height, self.width, -1])
get_random_transformations 
get_random_transformations(input_shape)

Generate random start indices for cropping.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
def get_random_transformations(self, input_shape):
    """Generate random start indices for cropping."""
    batch_size = input_shape[0]
    height_size = input_shape[self.height_axis]
    width_size = input_shape[self.width_axis]
    if height_size < self.height:
        raise ValueError(f"Input height ({height_size}) must be greater than output height ({self.height})")
    if width_size < self.width:
        raise ValueError(f"Input width ({width_size}) must be greater than output width ({self.width})")

    h_diff = height_size - self.height
    w_diff = width_size - self.width
    if self.unique_batch:
        start_h = keras.random.randint(
            shape=(batch_size,), minval=0, maxval=int(h_diff + 1), seed=self.random_generator, dtype="int32"
        )
        start_w = keras.random.randint(
            shape=(batch_size,), minval=0, maxval=int(w_diff + 1), seed=self.random_generator, dtype="int32"
        )
    else:
        start_h = keras.random.randint(
            shape=(), minval=0, maxval=int(h_diff + 1), seed=self.random_generator, dtype="int32"
        )
        start_h = keras.ops.broadcast_to(start_h, [batch_size])
        start_w = keras.random.randint(
            shape=(), minval=0, maxval=int(w_diff + 1), seed=self.random_generator, dtype="int32"
        )
        start_w = keras.ops.broadcast_to(start_w, [batch_size])
    return {"start_h": start_h, "start_w": start_w}
augment_sample 
augment_sample(inputs) -> keras.KerasTensor

Augment single sample with random crop.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
166
167
168
169
170
171
172
173
174
def augment_sample(self, inputs) -> keras.KerasTensor:
    """Augment single sample with random crop."""
    sample = inputs[self.SAMPLES]
    start_h = inputs[self.TRANSFORMS]["start_h"]
    start_w = inputs[self.TRANSFORMS]["start_w"]

    if self.training:
        sample = self.random_crop(sample, start_h, start_w)
    return sample
compute_output_shape 
compute_output_shape(input_shape, *args, **kwargs)

Compute the output shape of the layer.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
176
177
178
179
180
181
def compute_output_shape(self, input_shape, *args, **kwargs):
    """Compute the output shape of the layer."""
    output_shape = list(input_shape)
    output_shape[self.height_axis] = self.height
    output_shape[self.width_axis] = self.width
    return tuple(input_shape)
get_config 
get_config()

Serializes the configuration of the layer.

Source code in neuralspot_edge/layers/preprocessing/random_crop.py 
183
184
185
186
187
188
189
190
191
192
193
def get_config(self):
    """Serializes the configuration of the layer."""
    config = super().get_config()
    config.update(
        {
            "height": self.height,
            "width": self.width,
            "unique_batch": self.unique_batch,
        }
    )
    return config