def __init__(self,
n_classes,
batch_shape,
depth=4,
dilation=2,
activation="elu",
dense_classifier_activation="tanh",
kernel_size=5,
transition_window=1,
padding="same",
complexity_factor=2,
l2_reg=None,
pools=(10, 8, 6, 4),
data_per_prediction=None,
logger=None,
build=True,
**kwargs):
"""
n_classes (int):
The number of classes to model, gives the number of filters in the
final 1x1 conv layer.
batch_shape (list): Giving the shape of one one batch of data,
potentially omitting the zeroth axis (the batch
size dim)
depth (int):
Number of conv blocks in encoding layer (number of 2x2 max pools)
Note: each block doubles the filter count while halving the spatial
dimensions of the features.
dilation (int):
TODO
activation (string):
Activation function for convolution layers
dense_classifier_activation (string):
TODO
kernel_size (int):
Kernel size for convolution layers
transition_window (int):
TODO
padding (string):
Padding type ('same' or 'valid')
complexity_factor (int/float):
Use int(N * sqrt(complexity_factor)) number of filters in each
convolution layer instead of default N.
l2_reg (float in [0, 1])
L2 regularization on conv weights
pools (int or list of ints):
TODO
data_per_prediction (int):
TODO
logger (MultiPlanarUNet.logging.Logger | ScreenLogger):
MutliViewUNet.Logger object, logging to files or screen.
build (bool):
TODO
"""
super(UTime, self).__init__()
# Set logger or standard print wrapper
self.logger = logger or ScreenLogger()
# Set various attributes
assert len(batch_shape) == 4
self.n_periods = batch_shape[1]
self.input_dims = batch_shape[2]
self.n_channels = batch_shape[3]
self.n_classes = int(n_classes)
self.dilation = int(dilation)
self.cf = complexity_factor
self.init_filters = int(8 * self.cf)
self.kernel_size = int(kernel_size)
self.transition_window = transition_window
self.activation = activation
self.l2_reg = l2_reg
self.depth = depth
self.n_crops = 0
self.pools = [pools] * self.depth if not \
isinstance(pools, (list, tuple)) else pools
if len(self.pools) != self.depth:
raise ValueError("Argument 'pools' must be a single integer or a "
"list of values of length equal to 'depth'.")
self.padding = padding.lower()
if self.padding != "same":
raise ValueError("Currently, must use 'same' padding.")
self.dense_classifier_activation = dense_classifier_activation
self.data_per_prediction = data_per_prediction or self.input_dims
if not isinstance(self.data_per_prediction, (int, np.integer)):
raise TypeError("data_per_prediction must be an integer value")
if self.input_dims % self.data_per_prediction:
raise ValueError("'input_dims' ({}) must be evenly divisible by "
"'data_per_prediction' ({})".format(self.input_dims,
self.data_per_prediction))
if build:
# Build model and init base keras Model class
super().__init__(*self.init_model())
# Compute receptive field
ind = [x.__class__.__name__ for x in self.layers].index("UpSampling2D")
self.receptive_field = compute_receptive_fields(self.layers[:ind])[-1][-1]
# Log the model definition
self.log()
else:
self.receptive_field = [None]
def __init__(self,
n_classes,
dim=None,
n_channels=1,
depth=3,
out_activation="softmax",
activation="relu",
kernel_size=3,
padding="same",
complexity_factor=1,
flatten_output=False,
l2_reg=None,
logger=None, **kwargs):
"""
n_classes (int):
The number of classes to model, gives the number of filters in the
final 1x1 conv layer.
dim (int):
Box dimensionality (on all three axes)
Note that depending on image dims cropping may
be necessary. To avoid this, use image dimensions DxDxD for which
D * (1/2)^n is an integer, where n is the number of (2x2)
max-pooling layers; in this implementation 4.
For n=4, D \in {..., 192, 208, 224, 240, 256, ...} etc.
n_channels (int):
Number of channels in the input image.
depth (int):
Number of conv blocks in encoding layer (number of 2x2x2 max pools)
Note: each block doubles the filter count while halving the spatial
dimensions of the features.
out_activation (string):
Activation function of output 1x1x1 conv layer. Usually one of
'softmax', 'sigmoid' or 'linear'.
activation (string):
Activation function for convolution layers
kernel_size (int):
Kernel size for convolution layers
padding (string):
Padding type ('same' or 'valid')
complexity_factor (int/float):
Use int(N * sqrt(complexity_factor)) number of filters in each
3D convolution layer instead of default N.
l2_reg (float in [0, 1])
L2 regularization on Conv3D weights
logger (mpunet.logging.Logger | ScreenLogger):
MutliViewUNet.Logger object, logging to files or screen.
"""
# Set logger or standard print wrapper
self.logger = logger or ScreenLogger()
# Set various attributes
self.img_shape = (dim, dim, dim, n_channels)
self.n_classes = n_classes
self.cf = np.sqrt(complexity_factor)
self.kernel_size = kernel_size
self.activation = activation
self.out_activation = out_activation
self.l2_reg = l2_reg
self.padding = padding
self.depth = depth
self.flatten_output = flatten_output
# Shows the number of pixels cropped of the input image to the output
self.label_crop = np.array([[0, 0], [0, 0], [0, 0]])
# Build model and init base keras Model class
super().__init__(*self.init_model())
# Compute receptive field
names = [x.__class__.__name__ for x in self.layers]
index = names.index("UpSampling3D")
self.receptive_field = compute_receptive_fields(self.layers[:index])[-1][-1]
# Log the model definition
self.log()