def build_image_processing_stack():
"""
Constructs a ReShape preprocessor to fold the time rank into the batch rank.
Then builds the 2 Conv2D Layers followed by ReLUs.
Then adds: fc(256) + ReLU.
"""
# Collect components for image stack before unfolding time-rank going into main LSTM.
sub_components = list()
# Divide by 255
sub_components.append(Divide(divisor=255, scope="divide-255"))
for i, (num_filters, kernel_size, stride) in enumerate(zip([16, 32], [8, 4], [4, 2])):
# Conv2D plus ReLU activation function.
conv2d = Conv2DLayer(
filters=num_filters, kernel_size=kernel_size, strides=stride, padding="same",
activation="relu", scope="conv2d-{}".format(i)
)
sub_components.append(conv2d)
# A Flatten preprocessor and then an fc block (surrounded by ReLUs) and a time-rank-unfolding.
sub_components.extend([
ReShape(flatten=True, scope="flatten"), # Flattener (to flatten Conv2D output for the fc layer).
DenseLayer(units=256), # Dense layer.
NNLayer(activation="relu", scope="relu-before-lstm"),
])
#stack_before_unfold = <- formerly known as
image_stack = Stack(sub_components, scope="image-stack")
return image_stack
def build_image_processing_stack():
"""
Constructs a ReShape preprocessor to fold the time rank into the batch rank.
Then builds the 3 sequential Conv2D blocks that process the image information.
Each of these 3 blocks consists of:
- 1 Conv2D layer followed by a MaxPool2D
- 2 residual blocks, each of which looks like:
- ReLU + Conv2D + ReLU + Conv2D + element-wise add with original input
Then adds: ReLU + fc(256) + ReLU.
"""
# Collect components for image stack before unfolding time-rank going into main LSTM.
sub_components = list()
# Divide by 255
sub_components.append(Divide(divisor=255, scope="divide-255"))
for i, num_filters in enumerate([16, 32, 32]):
# Conv2D plus MaxPool2D.
conv2d_plus_maxpool = Stack(
Conv2DLayer(filters=num_filters, kernel_size=3, strides=1, padding="same"),
MaxPool2DLayer(pool_size=3, strides=2, padding="same"),
scope="conv-max"
)
# Single unit for the residual layers (ReLU + Conv2D 3x3 stride=1).
residual_unit = Stack(
NNLayer(activation="relu"), # single ReLU
Conv2DLayer(filters=num_filters, kernel_size=3, strides=1, padding="same"),
scope="relu-conv"
)
# Residual Layer.
residual_layer = ResidualLayer(residual_unit=residual_unit, repeats=2)
# Repeat same residual layer 2x.
residual_repeater = RepeaterStack(sub_component=residual_layer, repeats=2)
sub_components.append(Stack(conv2d_plus_maxpool, residual_repeater, scope="conv-unit-{}".format(i)))
# A Flatten preprocessor and then an fc block (surrounded by ReLUs) and a time-rank-unfolding.
sub_components.extend([
ReShape(flatten=True, scope="flatten"), # Flattener (to flatten Conv2D output for the fc layer).
NNLayer(activation="relu", scope="relu-1"), # ReLU 1
DenseLayer(units=256), # Dense layer.
NNLayer(activation="relu", scope="relu-2"), # ReLU 2
])
image_stack = Stack(sub_components, scope="image-stack")
return image_stack