def get_hp_space():
        super_space = Model_lop.get_hp_space()

        space = {
            'n_hidden':
            hp.choice('n_hidden', [
                [
                    hopt_wrapper.qloguniform_int('n_hidden_1_' + str(i),
                                                 log(100), log(5000), 10)
                    for i in range(1)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_2_' + str(i),
                                                 log(100), log(5000), 10)
                    for i in range(2)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_3_' + str(i),
                                                 log(100), log(5000), 10)
                    for i in range(3)
                ],
            ]),
        }

        space.update(super_space)
        return space
    def get_hp_space():
        super_space = Model_lop.get_hp_space()

        space = {
            'n_hidden': hopt_wrapper.qloguniform_int('n_hidden', log(100), log(5000), 10),
            'n_factor': hopt_wrapper.qloguniform_int('n_factor', log(200), log(1000), 10),
        }

        space.update(super_space)
        return space
Example #3
0
    def get_hp_space():
        super_space = Model_lop.get_hp_space()

        space = {
            'num_filter_piano':
            list_hopt_fixedSized([(20, 30, 1), (10, 20, 1)],
                                 'num_filter_piano'),
            'kernel_size_piano':
            list_hopt_fixedSized([(12, 24, 1), (12, 24, 1)],
                                 "kernel_size_piano"),
            'num_filter_orch':
            list_hopt_fixedSized([(30, 50, 1), (10, 20, 1)],
                                 'num_filter_orch'),
            'kernel_size_orch':
            list_hopt_fixedSized([(12, 24, 1), (12, 24, 1)],
                                 "kernel_size_orch"),
            'embeddings_size':
            qloguniform_int("embeddings_size", log(500), log(2000), 10),
            'mlp_pred':
            list_log_hopt(500, 2000, 10, 1, 3, "mlp_pred"),
            'gru_orch':
            list_log_hopt(500, 2000, 10, 0, 2, "gru_orch"),
        }
        space.update(super_space)
        return space
    def get_hp_space():
        super_space = MLFPP.get_hp_space()

        space = {
            'hs_piano': list_log_hopt(500, 2000, 10, 0, 2, 'hs_piano'),
            'hs_orch': list_log_hopt(500, 2000, 10, 0, 2, 'hs_orch'),
            'embeddings_size': qloguniform_int('hs_orch', log(500), log(1000), 10),
        }

        space.update(super_space)
        return space
    def get_hp_space():
        super_space = MLFPP.get_hp_space()

        space = {
            'recurrent_orch':
            hp.choice('n_hidden', [
                [
                    hopt_wrapper.qloguniform_int('n_hidden_1_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(1)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_2_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(2)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_3_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(3)
                ],
            ]),
            'recurrent_piano':
            hp.choice('n_hidden', [
                [
                    hopt_wrapper.qloguniform_int('n_hidden_1_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(1)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_2_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(2)
                ],
            ]),
            'mlp_piano':
            hp.choice('n_hidden', [
                [
                    hopt_wrapper.qloguniform_int('n_hidden_1_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(1)
                ],
                [
                    hopt_wrapper.qloguniform_int('n_hidden_2_' + str(i),
                                                 log(500), log(3000), 10)
                    for i in range(2)
                ],
            ])
        }

        space.update(super_space)
        return space
    def get_hp_space():
        space_training = {
            'temporal_order':
            hopt_wrapper.qloguniform_int('temporal_order', log(3), log(20), 1)
        }

        space_regularization = {
            'dropout_probability':
            hp.choice('dropout',
                      [0.0, hp.normal('dropout_probability', 0.5, 0.1)]),
            'weight_decay_coeff':
            hp.choice('weight_decay_coeff',
                      [0.0, hp.uniform('a', 1e-4, 1e-4)]),
        }

        space_training.update(space_regularization)
        return space_training
    def get_hp_space():
        space_training = {
            # 'temporal_order': hopt_wrapper.qloguniform_int('temporal_order', log(2), log(7), 1),
            'temporal_order':
            hopt_wrapper.qloguniform_int('temporal_order', log(5), log(5), 1),
            'tn_weight':
            1 / 10,
            'sparsity_coeff':
            0,
        }

        space_regularization = {
            'dropout_probability': hp.choice('dropout', [0.0]),
            'weight_decay_coeff': hp.choice('weight_decay_coeff', [0.0])
        }

        space_training.update(space_regularization)
        return space_training
	def get_hp_space():
		super_space = Model_lop.get_hp_space()
		space = {
			'n_hidden_embedding': hp.choice('n_hidden_embedding', [
                [hopt_wrapper.qloguniform_int('n_hidden_embedding_'+str(i), log(1500), log(3000), 10) for i in range(1)],
                [hopt_wrapper.qloguniform_int('n_hidden_embedding_'+str(i), log(1500), log(3000), 10) for i in range(2)],
                [hopt_wrapper.qloguniform_int('n_hidden_embedding_'+str(i), log(1500), log(3000), 10) for i in range(3)],
            ]),
            'n_hidden_NADE': hp.choice('n_hidden_NADE', [
                [hopt_wrapper.qloguniform_int('n_hidden_NADE_'+str(i), log(1500), log(3000), 10) for i in range(1)],
                [hopt_wrapper.qloguniform_int('n_hidden_NADE_'+str(i), log(1500), log(3000), 10) for i in range(2)],
                [hopt_wrapper.qloguniform_int('n_hidden_NADE_'+str(i), log(1500), log(3000), 10) for i in range(3)],
            ]),
			'num_ordering': quniform_int('num_ordering', 5, 10, 1)
		}
		space.update(super_space)
		return space
def list_log_hopt(min_unit, max_unit, step, min_num_layer, max_num_layer,
                  name):
    return hp.choice(name, [
        [qloguniform_int(name+'_'+str(i), log(min_unit), log(max_unit), step) for i in range(num_layer)] \
            for num_layer in range(min_num_layer, max_num_layer)
            ])