def __init__(self, model_param, dimensions):
     MLFPP.__init__(self, model_param, dimensions)
     # Gru piano
     self.mlp_piano = model_param['mlp_piano']
     self.recurrent_piano = model_param["recurrent_piano"]
     self.recurrent_orch = model_param['recurrent_orch']
     # self.last_mlp = model_param['last_mlp']
     return
    def __init__(self, model_param, dimensions):

        MLFPP.__init__(self, model_param, dimensions)

        # Gru piano
        embeddings_size = model_param['embeddings_size']
        temp = model_param['hs_piano']
        self.hs_piano = list(temp)
        self.hs_piano.append(embeddings_size)

        temp = model_param['hs_orch']
        self.hs_orch = list(temp)
        self.hs_orch.append(embeddings_size)

        return
Пример #3
0
    def __init__(self, model_param, dimensions):

        MLFPP.__init__(self, model_param, dimensions)

        # Piano embedding
        self.kernel_size_piano = model_param["kernel_size_piano"] # only pitch_dim, add 1 for temporal conv 
        embeddings_size = model_param['embeddings_size']
        temp = model_param['hs_piano']
        self.hs_piano = list(temp)
        self.hs_piano.append(embeddings_size)

        # Orchestra embedding
        self.kernel_size_orch = model_param["kernel_size_orch"] # only pitch_dim, add 1 for temporal conv 
        temp = model_param['hs_orch']
        self.hs_orch = list(temp)
        self.hs_orch.append(embeddings_size)

        return
    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 name():
     return (MLFPP.name() + "Recurrent_embeddings_0")