def create(self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> Any:
# create input layer
input_layer = self.create_other(
"SingleInputLayer", architecture, metadata,
Configuration({"input_size": architecture.arguments.noise_size}))
# conditional
if "conditional" in architecture.arguments:
# wrap the input layer with a conditional layer
input_layer = ConditionalLayer(
input_layer, metadata, **architecture.arguments.conditional)
# create the hidden layers factory
hidden_layers_factory = self.create_other(
"HiddenLayers", architecture, metadata,
arguments.get("hidden_layers", {}))
# create the output layer factory
output_layer_factory = self.create_output_layer_factory(
architecture, metadata, arguments)
# create the generator
return FeedForward(input_layer,
hidden_layers_factory,
output_layer_factory,
default_hidden_activation=ReLU())
def create_input_layer(self, architecture: Architecture,
metadata: Metadata,
arguments: Configuration) -> InputLayer:
# override the input layer size
return self.create_other(
"SingleInputLayer", architecture, metadata,
Configuration({"input_size": metadata.get_num_features()}))
def create_output_layer_factory(
self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> OutputLayerFactory:
# override the output layer size
output_layer_configuration = {
"output_size": metadata.get_num_features()
}
# copy activation arguments only if defined
if "output_layer" in arguments and "activation" in arguments.output_layer:
output_layer_configuration[
"activation"] = arguments.output_layer.activation
# create the output layer factory
return self.create_other("SingleOutputLayer", architecture, metadata,
Configuration(output_layer_configuration))
def create(self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> Any:
# create input layer
input_layer_configuration = {}
if self.code:
input_layer_configuration[
"input_size"] = architecture.arguments.code_size
else:
input_layer_configuration[
"input_size"] = metadata.get_num_features()
input_layer = self.create_other(
"SingleInputLayer", architecture, metadata,
Configuration(input_layer_configuration))
# conditional
if "conditional" in architecture.arguments:
# wrap the input layer with a conditional layer
input_layer = ConditionalLayer(
input_layer, metadata, **architecture.arguments.conditional)
# mini-batch averaging
if arguments.get("mini_batch_averaging", False):
input_layer = MiniBatchAveraging(input_layer)
# create the hidden layers factory
hidden_layers_factory = self.create_other(
"HiddenLayers", architecture, metadata,
arguments.get("hidden_layers", {}))
# create the output activation
if self.critic:
output_activation = View(-1)
else:
output_activation = Sequential(Sigmoid(), View(-1))
# create the output layer factory
output_layer_factory = SingleOutputLayerFactory(
1, activation=output_activation)
# create the discriminator
return FeedForward(input_layer,
hidden_layers_factory,
output_layer_factory,
default_hidden_activation=LeakyReLU(0.2))
def create(self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> Any:
# separate arguments
noise_layer_arguments = None
autoencoder_arguments = Configuration()
for argument_name, argument_value in arguments.items():
if argument_name == "noise_layer":
noise_layer_arguments = argument_value
else:
autoencoder_arguments[argument_name] = argument_value
noise_layer = self.create_other(
noise_layer_arguments.factory, architecture, metadata,
noise_layer_arguments.get("arguments", {}))
autoencoder = self.create_other(self.factory_name, architecture,
metadata, autoencoder_arguments)
return DeNoisingAutoencoder(noise_layer, autoencoder)
def process(self, inputs: Any) -> None:
AugmentationTask(self).run(Configuration(inputs))