def init(self, params):
        config = self.config

        self.decoder = sequential.from_dict(params["decoder"])
        self.chain_decoder.add_sequence(self.decoder)
        self.chain_decoder.setup_optimizers(config.optimizer,
                                            config.learning_rate,
                                            config.momentum,
                                            config.weight_decay,
                                            config.gradient_clipping)

        self.discriminator = sequential.from_dict(params["discriminator"])
        self.chain_discriminator.add_sequence(self.discriminator)
        self.chain_discriminator.setup_optimizers(config.optimizer,
                                                  config.learning_rate,
                                                  config.momentum,
                                                  config.weight_decay,
                                                  config.gradient_clipping)

        self.generator = sequential.from_dict(params["generator"])
        self.chain_generator.add_sequence(self.generator)
        self.chain_generator.setup_optimizers(config.optimizer,
                                              config.learning_rate,
                                              config.momentum,
                                              config.weight_decay,
                                              config.gradient_clipping)
Beispiel #2
0
    def __init__(self, params):
        self.params = copy.deepcopy(params)
        self.config = to_object(params["config"])
        self.chain_discriminator = sequential.chain.Chain(
            weight_initializer=self.config.weight_initializer,
            weight_std=self.config.weight_std)
        self.chain_generator = sequential.chain.Chain(
            weight_initializer=self.config.weight_initializer,
            weight_std=self.config.weight_std)

        # add decoder
        self.decoder = sequential.from_dict(self.params["decoder"])
        self.chain_discriminator.add_sequence_with_name(
            self.decoder, "decoder")

        # add encoder
        self.encoder = sequential.from_dict(self.params["encoder"])
        self.chain_discriminator.add_sequence_with_name(
            self.encoder, "encoder")

        # add generator
        self.generator = sequential.from_dict(self.params["generator"])
        self.chain_generator.add_sequence_with_name(self.generator,
                                                    "generator")

        # setup optimizer
        self.chain_discriminator.setup_optimizers(self.config.optimizer,
                                                  self.config.learning_rate,
                                                  self.config.momentum)
        self.chain_generator.setup_optimizers(self.config.optimizer,
                                              self.config.learning_rate,
                                              self.config.momentum)
        self._gpu = False
Beispiel #3
0
	def build_energy_model(self):
		params = self.params_energy_model
		self.energy_model = DeepEnergyModel()
		self.energy_model.add_feature_extractor(sequential.from_dict(params["feature_extractor"]))
		self.energy_model.add_experts(sequential.from_dict(params["experts"]))
		self.energy_model.add_b(sequential.from_dict(params["b"]))
		config = self.config_energy_model
		self.energy_model.setup_optimizers(config.optimizer, config.learning_rate, config.momentum, config.weight_decay, config.gradient_clipping)
Beispiel #4
0
 def build_generator(self):
     self.generator = sequential.chain.Chain()
     self.generator.add_sequence(
         sequential.from_dict(self.params_generator["model"]))
     config = self.config_generator
     self.generator.setup_optimizers(config.optimizer, config.learning_rate,
                                     config.momentum)
Beispiel #5
0
	def __init__(self, params):
		super(SDGM, self).__init__(params)
		params = self.params
		config = self.config

		self.p_a_yz = sequential.from_dict(params["p_a_yz"])
		self.chain.add_sequence_with_name(self.p_a_yz, "p_a_yz")
		self.p_x_ayz = sequential.from_dict(params["p_x_ayz"])
		self.chain.add_sequence_with_name(self.p_x_ayz, "p_x_ayz")
		self.q_a_x = sequential.from_dict(params["q_a_x"])
		self.chain.add_sequence_with_name(self.q_a_x, "q_a_x")
		self.q_y_ax = sequential.from_dict(params["q_y_ax"])
		self.chain.add_sequence_with_name(self.q_y_ax, "q_y_ax")
		self.q_z_axy = sequential.from_dict(params["q_z_axy"])
		self.chain.add_sequence_with_name(self.q_z_axy, "q_z_axy")

		self.chain.setup_optimizers(config.optimizer, config.learning_rate, config.momentum, config.weight_decay, config.gradient_clipping)
Beispiel #6
0
	def __init__(self, params):
		super(VAT, self).__init__()
		self.params = copy.deepcopy(params)
		self.config = to_object(params["config"])
		config = self.config
		self.chain = sequential.chain.Chain()
		self.model = sequential.from_dict(params["model"])
		self.chain.add_sequence(self.model)
		self.chain.setup_optimizers(config.optimizer, config.learning_rate, config.momentum, config.weight_decay, config.gradient_clipping)
		self._gpu = False
Beispiel #7
0
 def build_discriminator(self):
     config = self.config_discriminator
     self.discriminator = sequential.chain.Chain(
         weight_initializer=config.weight_initializer,
         weight_std=config.weight_std)
     self.discriminator.add_sequence(
         sequential.from_dict(self.params_discriminator["model"]))
     self.discriminator.setup_optimizers(config.optimizer,
                                         config.learning_rate,
                                         config.momentum)
Beispiel #8
0
    def __init__(self, params):
        super(SDGM, self).__init__(params)
        params = self.params
        config = self.config

        self.p_a_yz = sequential.from_dict(params["p_a_yz"])
        self.chain.add_sequence_with_name(self.p_a_yz, "p_a_yz")
        self.p_x_ayz = sequential.from_dict(params["p_x_ayz"])
        self.chain.add_sequence_with_name(self.p_x_ayz, "p_x_ayz")
        self.q_a_x = sequential.from_dict(params["q_a_x"])
        self.chain.add_sequence_with_name(self.q_a_x, "q_a_x")
        self.q_y_ax = sequential.from_dict(params["q_y_ax"])
        self.chain.add_sequence_with_name(self.q_y_ax, "q_y_ax")
        self.q_z_axy = sequential.from_dict(params["q_z_axy"])
        self.chain.add_sequence_with_name(self.q_z_axy, "q_z_axy")

        self.chain.setup_optimizers(config.optimizer, config.learning_rate,
                                    config.momentum, config.weight_decay,
                                    config.gradient_clipping)
    def __init__(self, params):
        self.params = copy.deepcopy(params)
        self.config = to_object(params["config"])

        self.discriminator = sequential.chain.Chain(
            self.config.weight_initializer, self.config.weight_std)
        self.discriminator.add_sequence(sequential.from_dict(params["model"]))
        self.discriminator.setup_optimizers(self.config.optimizer,
                                            self.config.learning_rate,
                                            self.config.momentum)

        self._gpu = False
Beispiel #10
0
    def __init__(self, params):
        self.params = copy.deepcopy(params)

        config = to_object(params["config"])
        self.classifier = sequential.chain.Chain(
            weight_initializer=config.weight_initializer,
            weight_std=config.weight_std)
        self.classifier.add_sequence(sequential.from_dict(
            self.params["model"]))
        self.classifier.setup_optimizers(config.optimizer,
                                         config.learning_rate, config.momentum)

        self.config = config
        self._gpu = False
Beispiel #11
0
    def init(self, params):
        config = self.config

        self.decoder = sequential.from_dict(params["decoder"])
        self.chain_decoder.add_sequence_with_name(self.decoder, "decoder")
        self.chain_decoder.setup_optimizers(config.optimizer,
                                            config.learning_rate,
                                            config.momentum,
                                            config.weight_decay,
                                            config.gradient_clipping)

        self.discriminator_y = sequential.from_dict(params["discriminator_y"])
        self.discriminator_z = sequential.from_dict(params["discriminator_z"])
        self.chain_discriminator.add_sequence_with_name(
            self.discriminator_y, "y")
        self.chain_discriminator.add_sequence_with_name(
            self.discriminator_z, "z")
        self.chain_discriminator.setup_optimizers(config.optimizer,
                                                  config.learning_rate,
                                                  config.momentum,
                                                  config.weight_decay,
                                                  config.gradient_clipping)

        self.generator_shared = sequential.from_dict(
            params["generator_shared"])
        self.generator_y = sequential.from_dict(params["generator_y"])
        self.generator_z = sequential.from_dict(params["generator_z"])
        self.chain_generator.add_sequence_with_name(self.generator_shared,
                                                    "shared")
        self.chain_generator.add_sequence_with_name(self.generator_y, "y")
        self.chain_generator.add_sequence_with_name(self.generator_z, "z")
        self.chain_generator.setup_optimizers(config.optimizer,
                                              config.learning_rate,
                                              config.momentum,
                                              config.weight_decay,
                                              config.gradient_clipping)

        self.chain_cluster_head = sequential.chain.Chain()
        self.cluster_head = sequential.from_dict(params["cluster_head"])
        self.chain_cluster_head.add_sequence_with_name(self.cluster_head,
                                                       "cluster_head")
        self.chain_cluster_head.setup_optimizers(config.optimizer,
                                                 config.learning_rate,
                                                 config.momentum,
                                                 config.weight_decay,
                                                 config.gradient_clipping)
Beispiel #12
0
	def build_generative_model(self):
		params = self.params_generative_model
		self.generative_model = DeepGenerativeModel()
		self.generative_model.add_sequence(sequential.from_dict(params["model"]))
		config = self.config_generative_model
		self.generative_model.setup_optimizers(config.optimizer, config.learning_rate, config.momentum, config.weight_decay, config.gradient_clipping)