def __init_model__(self):
batch_shape = (
None,
self.train_generator.height,
self.train_generator.width,
self.train_generator.n_channels,
)
input_layer = Input(batch_shape=batch_shape, dtype="uint8")
to_float = Float()(input_layer)
if batch_shape[-1] is 1:
to_float = Concatenate()([to_float] * 3)
if self.backbone in list(MODELS.keys()):
normalized = ImageNetPreprocess(self.backbone)(to_float)
else:
raise ValueError(
"backbone model {} is not supported. Must be one of {}".format(
self.backbone, list(MODELS.keys())))
backbone = MODELS[self.backbone]
if self.backbone in list(MODELS.keys()):
input_shape = (self.train_generator.height,
self.train_generator.width, 3)
if self.backbone.startswith("mobile"):
input_shape = None
backbone = partial(backbone, alpha=self.alpha)
pretrained_model = backbone(include_top=False,
weights=self.weights,
input_shape=input_shape)
pretrained_features = pretrained_model(normalized)
if self.train_generator.downsample_factor is 4:
x = pretrained_features
x_out = Conv2D(self.train_generator.n_output_channels, (1, 1))(x)
elif self.train_generator.downsample_factor is 3:
x = pretrained_features
x_out = Conv2DTranspose(
self.train_generator.n_output_channels,
(3, 3),
strides=(2, 2),
padding="same",
)(x)
elif self.train_generator.downsample_factor is 2:
x = pretrained_features
x = SubPixelUpscaling()(x)
x_out = Conv2DTranspose(
self.train_generator.n_output_channels,
(3, 3),
strides=(2, 2),
padding="same",
)(x)
else:
raise ValueError(
"`downsample_factor={}` is not supported for DeepLabCut. Adjust your TrainingGenerator"
.format(self.train_generator.downsample_factor))
self.train_model = Model(input_layer,
x_out,
name=self.__class__.__name__)
def __init_model__(self):
max_transitions = np.min(
[
image_utils.n_downsample(self.train_generator.height),
image_utils.n_downsample(self.train_generator.width),
]
)
n_transitions = self.n_transitions
if isinstance(n_transitions, (int, np.integer)):
if n_transitions == 0:
raise ValueError("n_transitions cannot equal zero")
if n_transitions < 0:
n_transitions += 1
n_transitions = max_transitions - np.abs(n_transitions)
self.n_transitions = n_transitions
elif 0 < n_transitions <= max_transitions:
self.n_transitions = n_transitions
else:
raise ValueError(
"n_transitions must be in range {0} "
"< n_transitions <= "
"{1}".format(-max_transitions + 1, max_transitions)
)
else:
raise TypeError(
"n_transitions must be integer in range "
"{0} < n_transitions <= "
"{1}".format(-max_transitions + 1, max_transitions)
)
batch_shape = (
None,
self.train_generator.height,
self.train_generator.width,
self.train_generator.n_channels,
)
if self.train_generator.downsample_factor < 2:
raise ValueError(
"StackedDenseNet is only compatible with `downsample_factor` >= 2."
"Adjust the TrainingGenerator or choose a different model."
)
if n_transitions <= self.train_generator.downsample_factor:
raise ValueError(
"`n_transitions` <= `downsample_factor`. Increase `n_transitions` or decrease `downsample_factor`."
" If `n_transitions` is -1 (the default), check that your image resolutions can be repeatedly downsampled (are divisible by 2 repeatedly)."
)
input_layer = Input(batch_shape=batch_shape, dtype="uint8")
to_float = Float()(input_layer)
if self.pretrained:
if batch_shape[-1] is 1:
to_float = Concatenate()([to_float] * 3)
batch_shape = batch_shape[:-1] + (3,)
normalized = ImageNetPreprocess("densenet121")(to_float)
front_outputs = ImageNetFrontEnd(
input_shape=batch_shape[1:],
n_downsample=self.train_generator.downsample_factor
)(normalized)
else:
normalized = ImageNormalization()(to_float)
front_outputs = FrontEnd(
growth_rate=self.growth_rate,
n_downsample=self.train_generator.downsample_factor,
compression_factor=self.compression_factor,
bottleneck_factor=self.bottleneck_factor,
)(normalized)
n_downsample = self.n_transitions - self.train_generator.downsample_factor
outputs = front_outputs
model_outputs = OutputChannels(
self.train_generator.n_output_channels, name="output_0"
)(outputs)
model_outputs_list = [model_outputs]
outputs.append(BatchNormalization()(model_outputs))
for idx in range(self.n_stacks):
outputs = DenseNet(
growth_rate=self.growth_rate,
n_downsample=self.n_transitions
- self.train_generator.downsample_factor,
downsample_factor=self.train_generator.downsample_factor,
compression_factor=self.compression_factor,
bottleneck_factor=self.bottleneck_factor,
)(outputs)
outputs.append(Concatenate()(front_outputs))
outputs.append(BatchNormalization()(model_outputs))
model_outputs = OutputChannels(
self.train_generator.n_output_channels, name="output_" + str(idx + 1)
)(outputs)
model_outputs_list.append(model_outputs)
self.train_model = Model(
input_layer, model_outputs_list, name=self.__class__.__name__
)