def build(self, *args, **kwargs):
""" Must return inputs and outputs. """
self.build_config()
input_nodes, output_nodes = self._build()
Model.__init__(self, input_nodes, output_nodes)
self.compile(loss=self.get('loss', self.config, None),
optimizer=self.get('optimizer', self.config, 'sgd'))
def __init__(
self,
in_shape: Tuple[int, ...],
num_layers: int,
layer_multiplier: float,
bn_momentum: float,
dropout: float,
leaky_relu_alpha: float,
optimizer: Optimizer,
name: str = None,
):
Discriminator.__init__(self, in_shape, 1)
self.num_layers = num_layers
self.layer_multiplier = layer_multiplier
self.bn_momentum = bn_momentum
self.dropout = dropout
self.leaky_relu_alpha = leaky_relu_alpha
x = Input(in_shape)
y = Flatten()(x) if len(x.shape) > 2 else x
y = self.create_mlp_interim(y, num_layers, leaky_relu_alpha, dropout)
y = Reshape((1, *y.shape[1:]))(y)
y = LSTM(numpy.prod(self.in_shape), dropout=dropout, unroll=True)(y)
y = Dense(1, activation="sigmoid")(y)
Model.__init__(self, inputs=x, outputs=y, name=name or self.__class__.__name__)
self.compile(
loss=["binary_crossentropy"], optimizer=optimizer, metrics=["accuracy"]
)
def __init__(self, treatment, **kwargs):
Model.__init__(self, kwargs['inputs'], kwargs['outputs'])
if isinstance(treatment, Treatment):
self.treatment = treatment
else:
raise TypeError("Expected a treatment model of type Treatment. \
Got a model of type %s. Remember to train your\
treatment model first." % type(treatment))
super(Response, self).__init__(**kwargs)
def __init__(self, img_shape=None, inputs=None, outputs=None):
self.dims = len(img_shape) - 1
if self.dims == 3:
self.conv = Conv3D
self.pool = AveragePooling3D
elif self.dims == 2:
self.conv = Conv2D
self.pool = AveragePooling2D
if outputs == None:
model = self.__build(img_shape)
Model.__init__(self, model.inputs, model.outputs)
elif outputs != None:
Model.__init__(self, inputs, outputs)
def __init__(
self,
latent_size: int,
num_classes: int,
out_shape: Tuple[int, ...],
num_layers: int,
layer_multiplier: float,
bn_momentum: float,
leaky_relu_alpha: float,
dropout: float,
name: str = None,
):
EmbeddingGenerator.__init__(self, latent_size, out_shape, num_classes,
name)
self.num_layers = num_layers
self.layer_multiplier = layer_multiplier
self.bn_momentum = bn_momentum
self.leaky_relu_alpha = leaky_relu_alpha
self.dropout = dropout
latent = Input((latent_size, ))
label = Input((1, ), dtype="int32")
label_embedding = Flatten()(Embedding(num_classes, latent_size)(label))
x = multiply([latent, label_embedding])
y = self.create_mlp_interim(
x,
num_layers,
layer_multiplier,
bn_momentum,
leaky_relu_alpha,
dropout,
)
y = Reshape((1, *y.shape[1:]))(y)
y = LSTM(numpy.prod(out_shape), dropout=dropout, unroll=True)(y)
y = Dense(numpy.prod(out_shape), activation="tanh")(y)
y = Reshape(out_shape)(y)
Model.__init__(
self,
inputs=[latent, label],
outputs=y,
name=name or self.__class__.__name__,
)
def __init__(self, img_rows, img_cols, n_classes, out_activation="softmax",
complexity_factor=1, l1_reg=None, l2_reg=None,
base_model=None, logger=None, **kwargs):
self.img_shape = (img_rows, img_cols, 1)
self.n_classes = n_classes
self.cf = np.sqrt(complexity_factor)
# Shows the number of pixels cropped of the input image to the output
self.label_crop = np.array([[0, 0], [0, 0]])
# Build model and init base keras Model class
if not base_model:
# New training session
Model.__init__(self, *self.init_model(out_activation, l1_reg,
l2_reg, **kwargs))
else:
# Resumed training
Model.__init__(self, base_model.input, base_model.output)
def __init__(
self,
in_shape: Tuple[int, ...],
num_classes: int,
num_layers: int,
layer_multiplier: float,
bn_momentum: float,
dropout: float,
leaky_relu_alpha: float,
optimizer: Optimizer,
name: str = None,
):
LabelingDiscriminator.__init__(self, in_shape, num_classes)
self.num_layers = num_layers
self.layer_multiplier = layer_multiplier
self.bn_momentum = bn_momentum
self.dropout = dropout
self.leaky_relu_alpha = leaky_relu_alpha
data = Input(self.in_shape)
flat_data = Flatten()(data)
features = self.create_mlp_interim(
flat_data, num_layers, leaky_relu_alpha, dropout
)
discrimination = Dense(1, activation="sigmoid")(features)
label = Dense(self.num_classes, activation="softmax")(features)
Model.__init__(
self,
inputs=data,
outputs=[discrimination, label],
name=name or self.__class__.__name__,
)
self.compile(
loss=["binary_crossentropy", "sparse_categorical_crossentropy"],
optimizer=optimizer,
metrics=["accuracy"],
)
def __init__(
self,
in_shape: Tuple[int, ...],
num_classes: int,
num_layers: int,
layer_multiplier: float,
bn_momentum: float,
dropout: float,
leaky_relu_alpha: float,
optimizer: Optimizer,
name: str = None,
):
EmbeddingDiscriminator.__init__(self, in_shape, num_classes)
self.num_layers = num_layers
self.layer_multiplier = layer_multiplier
self.bn_momentum = bn_momentum
self.dropout = dropout
self.leaky_relu_alpha = leaky_relu_alpha
data = Input(in_shape)
label = Input((1,), dtype="int32")
label_embedding = Flatten()(
Embedding(self.num_classes, numpy.prod(self.in_shape))(label)
)
flat_data = Flatten()(data)
x = multiply([flat_data, label_embedding])
y = self.create_mlp_interim(x, num_layers, leaky_relu_alpha, dropout)
y = Reshape((1, *y.shape[1:]))(y)
y = LSTM(numpy.prod(self.in_shape), dropout=dropout, unroll=True)(y)
y = Dense(1, activation="sigmoid")(y)
Model.__init__(
self, inputs=[data, label], outputs=y, name=name or self.__class__.__name__,
)
self.compile(
loss=["binary_crossentropy"], optimizer=optimizer, metrics=["accuracy"]
)
def __init__(self,
inputs,
start_img_shape=(8, 8, 8, 1),
outputs=None,
**kwargs):
self.start_img_shape = start_img_shape
self.dims = len(self.start_img_shape) - 1
if self.dims == 3:
self.conv = Conv3DTranspose
self.upsample = UpSampling3D
elif self.dims == 2:
self.conv = Conv2DTranspose
self.upsample = UpSampling2D
if outputs == None:
model = self.__build(inputs)
Model.__init__(self, model.inputs, model.outputs)
elif outputs != None:
Model.__init__(self, inputs, outputs)
def __init__(
self,
latent_size: int,
out_shape: Tuple[int, ...],
num_layers: int,
layer_multiplier: float,
bn_momentum: float,
leaky_relu_alpha: float,
dropout: float,
name: str = None,
):
Generator.__init__(self, latent_size, out_shape)
self.num_layers = num_layers
self.layer_multiplier = layer_multiplier
self.bn_momentum = bn_momentum
self.leaky_relu_alpha = leaky_relu_alpha
self.dropout = dropout
x = Input((latent_size, ))
y = self.create_mlp_interim(
x,
num_layers,
layer_multiplier,
bn_momentum,
leaky_relu_alpha,
dropout,
)
y = Reshape((1, *y.shape[1:]))(y)
y = LSTM(numpy.prod(out_shape), dropout=dropout, unroll=True)(y)
y = Dense(numpy.prod(out_shape), activation="tanh")(y)
y = Reshape(out_shape)(y)
Model.__init__(self,
inputs=x,
outputs=y,
name=name or self.__class__.__name__)
def __init__(self):
Model.__init__(self, Sequential)
def __init__(self):
Model.__init__(self)
def __init__(self, input_shape):
self.input_image = Input(shape=input_shape)
self.decoded = self.build(self.input_image)
Model.__init__(self, self.input_image, self.decoded)
def __init__(self, inputs, outputs, name):
Model.__init__(self, inputs=inputs, outputs=outputs)
Wrapper.__init__(self, name)
def __init__(self, generator, discriminator):
discriminator.trainable = False
model = self.__build(generator, discriminator)
Model.__init__(self, model.inputs, model.outputs)
self.compile(loss='binary_crossentropy', optimizer=opt)
def __init__(self, config):
Model.__init__(self, config)