def __init_model__(self):
max_transitions = np.min([
image_utils.n_downsample(self.data_generator.height),
image_utils.n_downsample(self.data_generator.width),
])
n_transitions = self.n_transitions
if isinstance(self.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.data_generator.height,
self.data_generator.width,
self.data_generator.n_channels,
)
input_layer = Input(batch_shape=batch_shape, dtype="uint8")
to_float = Float()(input_layer)
normalized = ImageNormalization()(to_float)
n_downsample = self.data_generator.downsample_factor
front_module = FrontModule(self.filters, n_downsample,
self.bottleneck_factor)
front_output = front_module(normalized)
n_transitions = self.n_transitions - n_downsample
x = front_output
outputs = []
for idx in range(self.n_stacks):
x = Hourglass(self.filters, self.bottleneck_factor,
n_transitions)(x)
outputs_x, x = Output(self.data_generator.n_output_channels,
self.filters)(x)
outputs.append(outputs_x)
self.train_model = Model(input_layer,
outputs,
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(self.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)
)
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)."
)
normalized = ImageNormalization()(self.inputs)
n_downsample = self.train_generator.downsample_factor
front_module = FrontModule(self.filters, n_downsample, self.bottleneck_factor)
front_output = front_module(normalized)
n_transitions = self.n_transitions - n_downsample
x = front_output
outputs = []
for idx in range(self.n_stacks):
x = Hourglass(self.filters, self.bottleneck_factor, n_transitions)(x)
outputs_x, x = Output(self.train_generator.n_output_channels, self.filters)(
x
)
outputs.append(outputs_x)
self.train_model = Model(self.inputs, outputs, 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__
)