예제 #1
0
    def genotype(self):
        n, start = 3, 2
        weightsr2 = [F.softmax(beta, dim=-1) for beta in self.beta_reduce[0:2]]
        weightsn2 = [F.softmax(beta, dim=-1) for beta in self.beta_normal[0:2]]

        for i in range(self.n_nodes):
            end = start + n
            tw2 = [
                F.softmax(beta, dim=-1) for beta in self.beta_reduce[start:end]
            ]
            tn2 = [
                F.softmax(beta, dim=-1) for beta in self.beta_normal[start:end]
            ]
            start = end
            n += 1
            weightsr2 = weightsr2 + tw2
            weightsn2 = weightsn2 + tn2

        # normalize edge-leve beta parameters
        gene_normal = gt.parse(self.alpha_normal, weightsn2, k=2)
        gene_reduce = gt.parse(self.alpha_reduce, weightsr2, k=2)
        concat = range(2, 2 + self.n_nodes)  # concat all intermediate nodes

        return gt.Genotype(normal=gene_normal,
                           normal_concat=concat,
                           reduce=gene_reduce,
                           reduce_concat=concat)
예제 #2
0
    def genotype(self):
        gene_normal = gt.parse(self.alpha_normal, k=2)
        gene_reduce = gt.parse(self.alpha_reduce, k=2)
        concat = range(2, 2+self.n_nodes) # concat all intermediate nodes

        return gt.Genotype(normal=gene_normal, normal_concat=concat,
                           reduce=gene_reduce, reduce_concat=concat)
예제 #3
0
    def genotypetoaugment(self, layers_augment=20):
        genotype = {}
        genotype["normal"] = gt.parse(self.alpha_normal, k=2)
        genotype["reduce"] = gt.parse(self.alpha_reduce, k=2)
        for n in range(layers_augment):
            if n == layers_augment // 3 or n == 2 * layers_augment // 3:
                genotype["cell_%d" % n] = genotype["reduce"]
            else:
                genotype["cell_%d" % n] = genotype["normal"]
        genotype["normal_concat"] = range(
            2, 2 + self.n_nodes)  # concat all intermediate nodes
        genotype["reduce_concat"] = range(
            2, 2 + self.n_nodes)  # concat all intermediate nodes

        return genotype
예제 #4
0
    def genotype(self):

        with torch.no_grad():
            gene_normal = parse(weights=F.softmax(self.alphas_normal, dim=-1),
                                num_nodes=self.num_nodes,
                                k_strongest=2)
            gene_reduce = parse(weights=F.softmax(self.alphas_reduce, dim=-1),
                                num_nodes=self.num_nodes,
                                k_strongest=2)

        concat = range(2, self.num_nodes + 2)
        genotype = Genotype(normal=gene_normal,
                            normal_concat=concat,
                            reduce=gene_reduce,
                            reduce_concat=concat)

        return genotype
예제 #5
0
    def DAG(self):
        gene_DAG1 = gt.parse(self.alpha_DAG[0 * self.n_big_nodes:1 *
                                            self.n_big_nodes],
                             k=2)
        gene_DAG2 = gt.parse(self.alpha_DAG[1 * self.n_big_nodes:2 *
                                            self.n_big_nodes],
                             k=2)
        gene_DAG3 = gt.parse(self.alpha_DAG[2 * self.n_big_nodes:3 *
                                            self.n_big_nodes],
                             k=2)

        concat = range(self.n_big_nodes, self.n_big_nodes + 2)

        return gt.Genotype2(DAG1=gene_DAG1,
                            DAG1_concat=concat,
                            DAG2=gene_DAG2,
                            DAG2_concat=concat,
                            DAG3=gene_DAG3,
                            DAG3_concat=concat)
예제 #6
0
    def DAG(self):
        gene_DAG1 = gt.parse(self.alpha_DAG[0 * self.n_big_nodes:1 *
                                            self.n_big_nodes],
                             k=2)
        gene_DAG2 = gt.parse(self.alpha_DAG[1 * self.n_big_nodes:2 *
                                            self.n_big_nodes],
                             k=2)
        gene_DAG3 = gt.parse(self.alpha_DAG[2 * self.n_big_nodes:3 *
                                            self.n_big_nodes],
                             k=2)

        # concat = range(2, 2+self.n_big_nodes)  # concat all intermediate nodes
        # concat = range(2+self.n_big_nodes-2, 2+self.n_big_nodes)
        concat1 = gt.parse_concat(self.alpha_concat[0])
        concat2 = gt.parse_concat(self.alpha_concat[1])
        concat3 = gt.parse_concat(self.alpha_concat[2])

        return gt.Genotype2(DAG1=gene_DAG1,
                            DAG1_concat=concat1,
                            DAG2=gene_DAG2,
                            DAG2_concat=concat2,
                            DAG3=gene_DAG3,
                            DAG3_concat=concat3)
예제 #7
0
    def genotype(self):
        gene_normal = gt.parse(self.alpha_normal, k=2)
        concat = range(1, 1 + self.n_nodes)  # concat all intermediate nodes

        return gt.Genotype(normal=gene_normal, normal_concat=concat)