예제 #1
0
def fitness_optimo(funcion, x_min, x_max, num_bits, dimen):
    """
    Devuelve el mejor fitness posible que se puede obtener con la amplitud
    del intervalo (x_max - x_min) dada y el número de bits usados

    :param funcion: Determina la función que se pretende maximizar
    :param x_min: Inicio del intervalo de maximización para cada dimensión
    :param x_max: Final del intervalo de maximización para cada dimensión
    :param num_bits: número de bits usados para codificar el valor real de la
                     variable xi
    :param dimen: Número de dimensiones de la función a evaluar
    :return: devuelve el mejor fitness posible que se puede obtener con la
            amplitud del intervalo (x_max - x_min) dada y el número de bits
            usados
    """

    delta = (x_max - x_min) / (2**num_bits - 1)

    if funcion == "Esfera":
        optimo = bin(round((-x_min) / delta))
    elif funcion == "Schwefel":
        optimo = bin(round((420.9687 - x_min) / delta))
    else:
        return 1

    gen_optimo = bitarray(optimo[2:])
    genes_optimos = []
    for j in range(dimen):
        genes_optimos.append(gen_optimo)

    indiv_optimo = Individuo(genes_optimos)
    indiv_optimo.set_fitness()
    mejor_posible = indiv_optimo.get_fitness()

    return mejor_posible
예제 #2
0
    def __init__(self,
                 tx_mutacao: int,
                 tx_cross: int,
                 n_individ: int,
                 n_bits: int,
                 interv_min: int = None,
                 interv_max: int = None):
        """
		Instancia uma população com N indivíduos e com as taxas recebidas.

		:param tx_mutacao: Inteiro (entre 0 e 100) que representa a chance de um bit ser alterado.
		:param tx_cross: Inteiro (entre 0 e 100) que representa a chance de ocorrer um crossover.
		:param n_individ: Inteiro positivo. É a quantidade de indivíduos da população.
		:param n_bits: Inteiro positivo. É o tamanho da cadeia genética de cada indivíduo.
		:param interv_min: Valor real que representa o valor mínimo que um código genético pode assumir.
		:param interv_max: Valor real que representa o valor máximo que um código genético pode assumir.
		"""

        # Atualize as propriedades com os valores recebidos
        self.n_ind = n_individ
        self.__taxa_mut = tx_mutacao
        self.__taxa_cross = tx_cross
        self.__n_bits = n_bits

        # Gera os indiviuos da população
        self.individuos: [Individuo] = [
            Individuo(n_bits=n_bits) for i in range(self.n_ind)
        ]
        self.elite = Individuo(self.__n_bits, self.get_best_or_worst().bits)
예제 #3
0
    def gera_nova_populacao(self, shapes = None):
        self.populacao = sorted(self.populacao, key=lambda x: x.avaliacao) 
        nova_populacao = []
        while len(nova_populacao) < len(self):
            p1 = self.seleciona()
            p2 = self.seleciona()

            while p1 == p2:
                p2 = self.seleciona()

            if shapes:
                f1, f2 = Individuo.crossover_rede(p1, p2, shapes)
            else:
                f1, f2 = Individuo.crossover(p1, p2)

            if random() < self.prob_mutacao:
                f1.mutacao()
            if random() < self.prob_mutacao:
                f2.mutacao()

            nova_populacao.append(f1)
            nova_populacao.append(f2)

        while len(nova_populacao) > len(self):
            nova_populacao.remove(nova_populacao[randint(
                0, len(nova_populacao))])

        self.populacao = nova_populacao
        self.geracao += 1
예제 #4
0
파일: test.py 프로젝트: avances123/Codigo
def test6(conn, limite):
    """
    Test movimiento aleatorio total con dos individuos moviendose con memoria
    """
    tipo = "test6"
    # Situamos a los individuos inicialmente
    a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
    b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)

    t1 = Tablero()
    t2 = Tablero()

    # Bucle de busqueda
    exito = False
    while exito == False:

        a.x, a.y = t1.dameCasilla()
        b.x, b.y = t2.dameCasilla()

        if a.x == -1 or b.x == -1:
            break

        a.movimientos += 1
        b.movimientos += 1

        if a.movimientos >= limite:
            break
        if b.movimientos >= limite:
            break

        if a.x == b.x and a.y == b.y:  # Si estan en la misma casilla... exito
            exito = True

    print tipo, ":", a.movimientos
    escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
예제 #5
0
def avaliacao(geracao):
    aux = Individuo()
    aux.avaliacao = 64*64
    melhor_avaliacao = aux
    for individuo in geracao:
        if (individuo.avaliacao <= melhor_avaliacao.avaliacao):
            melhor_avaliacao = individuo
    return melhor_avaliacao
예제 #6
0
 def crearIndividuos(self):
     for i in range(self.poblacion_inicial - 1):
         individuo = Individuo(self.prob_contagio, self.prob_muerte,
                               self.dias_recuperacion)
         self.poblacion.append(individuo)
     individuo_contagiado = Individuo(self.prob_contagio, self.prob_muerte,
                                      self.dias_recuperacion)
     individuo_contagiado.setContagiado()
     self.poblacion.append(individuo_contagiado)
     self.estadisticas.append([1, self.poblacion_inicial - 1,
                               0])  # enfermos, vivos, muertos
예제 #7
0
    def criaPopulacao(self):

        vPos = 0

        for n in range(0, self.POPULACAO_TREINAMENTO):
            indiv = Individuo()

            # TRONCO
            shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))

            tronco = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
            tronco.node().setMass(1.0)
            tronco.node().addShape(shape)
            tronco.setPos(vPos + 2, 0.5, 3)
            tronco.setScale(2, 0.6, 4)
            tronco.setCollideMask(BitMask32.allOn())
            #self.boxNP.node().setDeactivationEnabled(False)
            indiv.tronco = tronco

            self.world.attachRigidBody(tronco.node())

            visualNP = loader.loadModel('models/box.egg')
            visualNP.clearModelNodes()
            visualNP.reparentTo(tronco)
            frameA = TransformState.makePosHpr(Point3(0, 0, -2),
                                               Vec3(0, 0, 90))

            # PÉS
            shape = BulletBoxShape(Vec3(0.5, 1, 0.2))
            posicaoPes = [1, 2]
            for i in range(2):
                for j in range(1):
                    x = i + posicaoPes[i] + vPos
                    y = 0.0
                    z = j
                    pe = self.criaPe(shape, x, y, z)

                    if i == 1:
                        indiv.pe1 = pe
                    else:
                        indiv.pe2 = pe

                    # Cone
                    # frameB = TransformState.makePosHpr(Point3(-5, 0, 0), Vec3(0, 0, 0))

                    # cone = BulletConeTwistConstraint(tronco, pe, frameA, frameB)
                    # cone.setDebugDrawSize(2.0)
                    # cone.setLimit(30, 45, 170, softness=1.0, bias=0.3, relaxation=8.0)
                    # self.world.attachConstraint(cone)

            self.individuos.append(indiv)

            vPos = vPos + 4
예제 #8
0
    def Gera_PopInic(self, caracter, TAM_Pop,
                     NUM_CROM):  # Gera uma população inicial

        for x in range(0, TAM_Pop):  # Laço para
            IND = Individuo(caracter)  # Variável recebe indivíduo
            F = Fitness(
                self.Frase,
                NUM_CROM)  # A Variável F recebe instancia da classe fitness
            self.listPop.append(
                F.Calc_Fitness(IND.Gera_Individuo(NUM_CROM))
            )  # Adiciona o individuo na lista de populações e calcula o Fitness
            print(self.listPop[x])  # imprimi o indivíduo
        return self.listPop  # retorna a lista de indivíduos
예제 #9
0
    def cruzamentoUniforme(self, pais, txCruzamento):
        #declaração dos pais e filhos
        pai1 = pais[0]
        pai2 = pais[1]
        combinacaoPai1 = pai1.getCombinacao()
        combinacaoPai2 = pai2.getCombinacao()
        tam1 = len(combinacaoPai1)
        tam2 = len(combinacaoPai2)
        filhos = pais
        i = 0
        aux = []
        #sorteio dos genes
        while i < tam1:
            aux.append(random.randint(0, 1))
            i = i + 1
        cruz = random.randint(0, 100)
        if cruz < txCruzamento:
            i = 0
            filho1 = Individuo()
            filho2 = Individuo()
            combinacaoFilho1 = []
            combinacaoFilho2 = []

            while i < tam1:
                if aux[i] == 0:
                    combinacaoFilho1.append(combinacaoPai1[i])
                    combinacaoFilho2.append(combinacaoPai2[i])
                elif aux[i] == 1:
                    combinacaoFilho1.append(combinacaoPai2[i])
                    combinacaoFilho2.append(combinacaoPai1[i])
                i = i + 1
            filho1.setCombinacao(combinacaoFilho1)
            filho2.setCombinacao(combinacaoFilho2)
            filhos = [filho1, filho2]
        return filhos
예제 #10
0
    def __apply_elite(self):
        temp_best = self.get_best_or_worst()

        if temp_best.fitness <= self.elite.fitness:
            self.elite = Individuo(self.__n_bits, temp_best.bits)

        # Se o pior individuo tiver o fitness pior que o da elite
        # Coloca a elite no lugar dele
        else:
            worst = self.get_best_or_worst(best=False)

            if worst.fitness > self.elite.fitness:
                idx = self.individuos.index(worst)
                self.individuos[idx] = Individuo(self.__n_bits,
                                                 self.elite.bits)
예제 #11
0
def cruzamento(individuos, primIndice, segIndice, pc, pm):
    probCruzamento = random.random()
    novosFilhos = []
    filhoUm = []
    filhoDois = []

    if probCruzamento <= pc:
        posicaoCruzamento = random.randint(0, TOTAL_GENES - 1)

        for i in range(TOTAL_GENES):
            geneUm = 0
            geneDois = 0
            if i <= posicaoCruzamento:
                geneUm = individuos[primIndice].genes[i]
                geneDois = individuos[segIndice].genes[i]
            else:
                geneUm = individuos[segIndice].genes[i]
                geneDois = individuos[primIndice].genes[i]
            filhoUm.append(geneUm)
            filhoDois.append(geneDois)

        novosFilhos.append(filhoUm)
        novosFilhos.append(filhoDois)

    novosFilhos = mutacao(novosFilhos, pm)

    for i in range(len(novosFilhos)):
        novoFilho = Individuo(novosFilhos[i], 0, 0, 0)
        individuos.append(novoFilho)

    return individuos
예제 #12
0
def sex(tabela, horarios, professores, casais):  # reprodução sexuada
    prole = set()
    contador_de_rejeitados = 0
    for casal in casais:
        combinacao = combinar(casal[0].genes, casal[1].genes)
        try:
            somo_a = Individuo(tabela, horarios, professores, combinacao[0])
            prole.add(somo_a)
        except Exception:
            contador_de_rejeitados += 1
        try:
            somo_b = Individuo(tabela, horarios, professores, combinacao[1])
            prole.add(somo_b)
        except Exception:
            contador_de_rejeitados += 1
    return prole
예제 #13
0
def cromosoma_binario_a_individuo(cromosoma):
    """Se transforma el cromosoma (lista de binarios) en
    un objeto del tipo Individuo.

    Parameters
    ----------
    cromosoma : list of int
        lista de numeros binarios que forman el cromosoma.

    Returns
    -------
    Individuo
        True if successful, False otherwise.
    """
    lista_enteros = []
    numero_de_gen = 0
    gen_binario = ''

    for gen in cromosoma:
        gen_binario += str(gen)
        numero_de_gen += 1

        if numero_de_gen != 0 and numero_de_gen % comidas.BITS_GEN == 0:
            gen_entero = int(gen_binario, 2)
            lista_enteros.append(gen_entero)
            gen_binario = ''

    return Individuo(lista_enteros, cromosoma.fitness)
예제 #14
0
def geraPopulacaoinicial(origem,pontos):

    populacao = []
    qtdIndividuosInicial = len(pontos)*2 # a quantidade de individuos vai depender da quantidade de pontos

    print("-----------------------GERANDO POPULAÇÃO-----------------------------------")
    print("QUANTIDADE INICIAL DE INDIVIDUOS " + str(qtdIndividuosInicial))
    print("\n")
    for i in range(qtdIndividuosInicial):

        print("INDIVIDUO: " + str(i+1))
        pontosEmbaralhado = shuffle(pontos)

        calculo = calculateRoute(origem, pontosEmbaralhado)

        individuo = Individuo(origem, pontosEmbaralhado,
                              calculo["routes"][0]["legs"][0]["duration"]["value"],
                              calculo["routes"][0]["legs"][0]["distance"]["value"],
                              calculo["routes"][0]["legs"][0]["duration"]["text"],
                              calculo["routes"][0]["legs"][0]["distance"]["text"])
        populacao.append(individuo)
        print(str(individuo))
        print("________________________________________________________________________")

    return populacao
예제 #15
0
    def cruzamento(self, piscina: list, geracao: int) -> list:
        nova_populacao = []
        percentual = int(self.size_pop * self.taxa_cruzamento)
        percentual = percentual if percentual % 2 == 0 else percentual + 1
        size = len(piscina)
        for _ in range(percentual):
            indv = piscina[randrange(size)]
            indv2 = piscina[randrange(size)]
            filho1, filho2 = self.cruzamentoUmPonto(indv.cromossomo,
                                                    indv2.cromossomo)
            nova_populacao.append(Individuo(cromossomo=filho1,
                                            geracao=geracao))
            nova_populacao.append(Individuo(cromossomo=filho2,
                                            geracao=geracao))

        return nova_populacao
예제 #16
0
 def __init__(self):
     self.populacao = []
     for i in range(0, sizePopulacao):
         self.populacao.append(Individuo())
     self.calcularFitness()
     self.calcularFitnessPercent()
     self.calcularRangeRoleta()
예제 #17
0
def gerar_populacao(tamanho_populacao):
    populacao = []
    for i in range(tamanho_populacao):
        individuo = Individuo()
        #print (individuo)
        #print (individuo.cromossomo)
        populacao.append(individuo)
    return populacao
예제 #18
0
 def OrdenarPopulacao(self):
     aux = Individuo()
     for i in range(0, sizePopulacao):
         for j in range(0, sizePopulacao):
             if (self.populacao[i].getFitnessPercent() <
                     self.populacao[j].getFitnessPercent()):
                 aux = self.populacao[i]
                 self.populacao[i] = self.populacao[j]
                 self.populacao[j] = aux
예제 #19
0
 def generate_data_set(self):
     for index, player in self.df.iterrows():
         position = self.get_position(player['Preferred Positions'])
         overall = player['Overall']
         price = player['Value']
         name = player['Name']
         individuo = Individuo(overall, price, name, position, 0)
         self.v_positions[self.PLAYERS[individuo.position]].append(
             individuo)
예제 #20
0
파일: test.py 프로젝트: avances123/Codigo
def test3(conn, limite):
    """
    Test movimiento aleatorio a las casillas contiguas con un individuo quieto
    """
    tipo = "test3"
    # Situamos a los individuos inicialmente
    a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
    b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)

    # Bucle de busqueda
    exito = False
    while not exito:
        a.moverAContigua()
        if a.movimientos >= limite:
            break
        if a.x == b.x and a.y == b.y:  # Si estan en la misma casilla... exito
            exito = True

    escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
예제 #21
0
def genera_poblacion_inicial(_long_gen, _num_genes, _mu):
    """
    Devuelve una lista de instancias de la clase Individuo con el número de
    genes y la longitud de estos especificados.
    :param _long_gen: longitud de los genes
    :param _num_genes: número de genes de cada individuo
    :param _mu:
    :return:
    """
    _poblacion = []
    for _i in range(_mu):
        g = genera_genes(_long_gen, _num_genes)  # Genera genes de un nuevo individuo
        indiv = Individuo(g)  # Creacción de individuo
        indiv.set_fitness()  # Cálculo del fitness
        _poblacion.append(indiv)  # Annade nuevo individuo a la población
    _poblacion.sort()

    asigna_probabilidades(_poblacion)  # Asigna las probabilidades a cada individuo
    return _poblacion
예제 #22
0
def assex(somos, tabela, horarios, professores):  # reprodção assexuada
    clones = set()
    for somo in somos:
        try:
            clones.add(
                Individuo(tabela, horarios, professores,
                          shuffle(list(somo.genes))))
        except Exception:
            pass
    return clones
예제 #23
0
파일: test.py 프로젝트: avances123/Codigo
def test4(conn, limite):
    """
    Test movimiento aleatorio total con los dos individuos moviendose
    """
    tipo = "test4"
    # Situamos a los individuos inicialmente
    a = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)
    b = Individuo(random.randrange(1, borde), random.randrange(1, borde), borde)

    # Bucle de busqueda
    exito = False
    while not exito:
        a.moverAContigua()
        b.moverAContigua()
        if a.movimientos >= limite:
            break
        if b.movimientos >= limite:
            break

        if a.x == b.x and a.y == b.y:  # Si estan en la misma casilla... exito
            exito = True

    if exito == False:
        print "Fracaso en test4"
    escribeEnDB(conn, tipo, a.movimientos, b.movimientos, exito)
예제 #24
0
def iniciaPopulacao(listPop: list):
    if len(listPop) == NP:
        return listPop

    for i in range(NP):
        listInd = generateGenes()
        novoIndividuo = Individuo(listInd, 0, 0, 0)
        listPop.append(novoIndividuo)

        for j in range(len(listPop)):
            if listInd == listPop[j].genes and j != 0:
                listPop.remove(novoIndividuo)
            return iniciaPopulacao(listPop)
예제 #25
0
    def make_crossover(self):
        """
		Faz crossover entre individuos pelo método de 1 corte
		"""

        children: [Individuo] = []

        while len(children) <= self.n_ind:
            # Sorteia a taxa de crossover de 0% a 100%
            tax = randint(0, 100)

            # Escolhe aleatoriamente 2 individuos
            ind1: Individuo = choice(self.individuos)
            ind2: Individuo = choice(self.individuos)

            # Se a taxa estiver no valor aceitável
            if tax <= self.__taxa_cross:
                # Sorteia a posição de corte
                cut_pos = randint(1, self.__n_bits - 2)

                # Gera os bits
                bits1 = ind1.bits[:cut_pos] + ind2.bits[cut_pos:]
                bits2 = ind2.bits[:cut_pos] + ind1.bits[cut_pos:]

                # Gera os filhos
                children.append(Individuo(self.__n_bits, bits1))
                children.append(Individuo(self.__n_bits, bits2))

            else:
                # Adiciona os pais como filhos
                children.append(ind1)
                children.append(ind2)

        # Muda os individuos para os filhos gerados
        self.individuos = children

        self.__apply_elite()
예제 #26
0
    def gera_Mutacao(self, Frase):                 # Método para gerar mutação no filhos
        listaTmp = []
        listaFin = []
        listaFinal = []
        TX_Mut_A = round(random.random())          # Número aleatorio entre 0 e 1
        for x in self.lista_Filho:
            
            if(TX_Mut_A  <= self.TX_Mutac):       # Se o número aleatorio for menor e igual que taxa de mutação, o indivíduo sofre a mutação em 2 duas posições aleatorias
                x1 = random.randint(0, self.NUM_CROM-1)  # x1 = valor de posição aleatoria
                x2 = random.randint(0, self.NUM_CROM-1)  # x2 = valor de posição aleatoria
                I = Individuo(self.Caract)               # instancia clase indivíduo
                x[x1] = I.get_caracter()                 # Modifica o caracter na posição x1 por um novo caracter na mesma posição
                x[x2] = I.get_caracter()                 # Modifica o caracter na posição x2 por um novo caracter na mesma posição
                F =  Fitness(Frase, self.NUM_CROM)       # Recalcula o Fitness
                listaTmp.append(F.Calc_Fitness(x))
            else:                                        # Caso a condição não seja aceita
                listaTmp.append(x)                       # Adicione o indivíduo na lista sem alteração

        print('Mutação nos Filhos')                      # imprimi os filhos com ou sem mutação
        for y in listaTmp:
            print(y)

        for z in self.lista_Selec:                      # Adiciona os filhos e pais dentro de uma lista
            listaFin.append(z)
        for z in listaTmp:
            listaFin.append(z)

        listaFin.sort(key=lambda x: x[self.NUM_CROM]) # Ordena a lista de pais e filhos
        for x in range(self.TAM_Pop, len(listaFin)):  # gera uma lista com o melhor dos pais e filhos
            listaFinal.append(listaFin[x])

        print('Nova População')                       # imprimi a lista com os melhores
        for y in listaFinal:
            print(y)

        return listaFinal                             # retorna a lista com nova população
예제 #27
0
def crossover(populacao):

    print("_________________CROSSOVER____________________________\n")

    newPopulacao = []

    for i in populacao: #vou gerar a mesma quantidade de individuos  para a nova geracao

        filho = Individuo()
        filhoParte1 = []
        pai1 = selecaoRoleta(populacao)
        pai2 = selecaoRoleta(populacao)

        #escolho os genes inicial e final para pegarmos do pai1
        gene1 = int(randint(0,len(pai1.pontos)))
        gene2 = int(randint(0, len(pai1.pontos)))

        menor = min(gene1,gene2)
        maior = max(gene1,gene2)

        #print("maior " + str(maior) + "menor " + str(menor))
        for i in range(menor,maior):
            filhoParte1.append(pai1.pontos[i])

        filhoParte2 = [ponto for ponto in pai2.pontos if ponto not in filhoParte1] #pega os pontos restantes que não estão na parte 1

        filho.pontos = filhoParte1 + filhoParte2 #junta as duas partes para formar uma só

        calculo = calculateRoute(pai1.origem, filho.pontos)

        filho.origem = pai1.origem
        filho.duracao = calculo["routes"][0]["legs"][0]["duration"]["value"]
        filho.distancia = calculo["routes"][0]["legs"][0]["distance"]["value"]
        filho.duracaoText = calculo["routes"][0]["legs"][0]["duration"]["text"]
        filho.distanciaText = calculo["routes"][0]["legs"][0]["distance"]["text"]
        newPopulacao.append(filho)

        print("_________________NOVO INDIVIDUO____________________________\n")
        print(str(filho))

    return newPopulacao
    def gerar_individuo(self):

        operador = random.choice(self.operadores)

        raiz = No(operador)

        individuo = Individuo(raiz)

        self.gerar_subarvore(individuo.raiz)

        individuo.altura()
        individuo.fitness(self.altura_maxima)

        return individuo
예제 #29
0
 def cruzamentoUmPonto(self, pais, txCruzamento):
     pai1 = pais[0]
     pai2 = pais[1]
     combinacaoPai1 = pai1.getCombinacao()
     combinacaoPai2 = pai2.getCombinacao()
     tam1 = len(combinacaoPai1)
     tam2 = len(combinacaoPai2)
     filhos = pais
     cruz = random.randint(0, 100)
     if cruz < txCruzamento:
         filho1 = Individuo()
         filho2 = Individuo()
         crossOver = random.randint(1, (tam1 - 2))
         combinacaoFilho1 = [
             *combinacaoPai1[:crossOver], *combinacaoPai2[crossOver:tam2]
         ]
         combinacaoFilho2 = [
             *combinacaoPai2[:crossOver], *combinacaoPai1[crossOver:tam1]
         ]
         filho1.setCombinacao(combinacaoFilho1)
         filho2.setCombinacao(combinacaoFilho2)
         filhos = [filho1, filho2]
     return filhos
    def mutacao(self, populacao):

        tamanho_populacao = len(populacao)

        num_mutacao = int(tamanho_populacao - (tamanho_populacao*self.percentual_mutacao)/100)

        for i in range(0, num_mutacao):
            indece = random.randint(0, (tamanho_populacao-1))

            novo_individual1 = populacao[indece]

            lista_nos1 = self.tree2list(novo_individual1.raiz, [])
            ponto_troca1 = random.randint(1, len(lista_nos1) - 1)

            no_itercambio1 = lista_nos1[ponto_troca1]  # type:No

            operador = random.choice(self.operadores)

            raiz = No(operador)

            novo_individual_gerado = Individuo(raiz)

            self.gerar_subarvore(novo_individual_gerado.raiz)

            pai_aux = no_itercambio1.pai

            novo_individual_gerado.raiz.pai = pai_aux


            if no_itercambio1.pai.esquerdo == pai_aux:
                no_itercambio1.pai.esquerdo = novo_individual_gerado.raiz
            else:
                no_itercambio1.pai.direito = novo_individual_gerado.raiz


            novo_individual1.altura()
            novo_individual1.fitness(self.altura_maxima)

        return populacao
예제 #31
0
파일: index.py 프로젝트: carlhm/retos
from datetime import datetime
from individuo import Individuo
from poblacion import Poblacion
from generacion import Generacion

# Entrada definida
try :
    n = int(sys.argv[1])
except :
    exit()
try :
    k = int(sys.argv[2])
except :
    exit()

k_maxima = Individuo.max_k(n)

# limites iniciales
if k < 0 or k > ((n*(n-1))/2) or k > k_maxima or n < 2 or n > 50 :
    exit()

individuos = int(n**1.6)
poblacion = Poblacion(individuos, n)
generacion = Generacion(poblacion)
h_inicio = datetime.now()

print 'Individuos: %i' % (individuos)
# evoluciona la poblacion hasta alcanzar el fitness
while not poblacion.campeon(k) :
    generacion.ronda(k, 0.30, 0.5, 0.75)
# mostrar mejor individuo
예제 #32
0
def nueva_generacion(_poblacion, _mu, _lambda):
    """
    Función que realiza las operaciones necesarias para crear una nueva generación
    Partiendo de una población inicial con los valores de fitness, probabilidad de
    selección individual para cruze y probabilidad acumulada para cada individuo reliza
    el resto del proceso:
    1. Selección de padres para reproducción usando el algoritmo estocástico universal (SUS)
    2. Cruze
    3. Mutación
    4. Selección hijos (relevo generacional) y Elitismo
    5. Igualmente completa el resto de información para cada individuo:
        - Valor de fitness
        - Probabilidad selección padre y probabilidad acumulada

    :param _poblacion:
    :param _mu:
    :param _lambda:
    :return:
    """
    # ############################## Selección de los padres  ##########################
    seleccion_padres = 0
    indice = 0
    r = random.uniform(0, 1 / _lambda)
    lista_padres = []

    while seleccion_padres < _lambda:
        while r <= _poblacion[indice].get_prob_padre_acumulada():
            lista_padres.append(_poblacion[indice])
            r = r + 1 / _lambda
            seleccion_padres += 1
        indice += 1

    # ############################# CRUZE Y MUTACIÓN       ############################
    random.shuffle(lista_padres)  # Barajamos los padres --> cruze aleatorio
    elite = max(_poblacion)  # Se reserva el mejor para aplicar elitismo
    _poblacion = []  # Reseteo de la población - relevo generacional

    k = 0
    while k < (_mu - 1):
        hijos = lista_padres[k].cruze(lista_padres[k + 1])  # Generamos los hijos (por parejas)
        _poblacion.append(Individuo(hijos[0]))
        _poblacion.append(Individuo(hijos[1]))
        _poblacion[k].mutacion()  # Se muta cada uno
        _poblacion[k + 1].mutacion()  # de los hijos
        _poblacion[k].set_fitness()
        _poblacion[k + 1].set_fitness()
        k += 2

    mejor_hijo = max(_poblacion)

    if elite > mejor_hijo:
        peor_hijo = min(_poblacion)
        _poblacion.remove(peor_hijo)
        _poblacion.append(elite)

    _poblacion.sort()
    pos = 0
    acum = 0
    for _elem in _poblacion:
        _elem.set_prob_lin(pos)
        acum += _elem.get_prob_padre()
        _elem.set_prob_padre_acumulada(acum)
        pos += 1

    return _poblacion
    def Crossover(self, pai, mae):
        novoInd = [0, 0]
        pontoDeCorte = random_value(0, sizeCromossomo)
        paiBuffer = Individuo()
        maeBuffer = Individuo()
        novoInd[self.PAI] = Individuo()
        novoInd[self.MAE] = Individuo()

        for i in range(0, sizeCromossomo):
            paiBuffer.setGene(i, pai.getGene(i))
            maeBuffer.setGene(i, mae.getGene(i))
            novoInd[self.PAI].setGene(i, pai.getGene(i))
            novoInd[self.MAE].setGene(i, mae.getGene(i))

        if (random_value(0, 10) < self.taxaCrossover):
            for i in range(pontoDeCorte, sizeCromossomo):
                novoInd[self.PAI].setGene(i, maeBuffer.getGene(i))
                novoInd[self.MAE].setGene(i, paiBuffer.getGene(i))
        return novoInd
예제 #34
0
    def iniciarOtimizacao(self, hasMapEscolhasUsuario):
        numeroIndividuos = int(
            hasMapEscolhasUsuario[Constantes.numeroIndividuos])
        populacao = [Individuo() for i in range(0, numeroIndividuos)]
        self.melhorIndividuo = MetricasPopulacao.melhorIndividuoPopulacao(
            populacao)
        self.piorIndividuo = MetricasPopulacao.piorIndividuoPopulacao(
            populacao)
        filhos = [1, 2]
        positionPais = []
        for i in range(0,
                       int(hasMapEscolhasUsuario[Constantes.numeroGeracao])):
            populacao = MetricasPopulacao.rankearPopulacao(populacao)

            listaFitness = MetricasPopulacao.getListaFitness(populacao)

            newPopulacao = []
            if (hasMapEscolhasUsuario[Constantes.temElitismo] == "s"):
                j = 2
            else:
                j = 0

            while j < (numeroIndividuos / 2):
                positionPais = []
                #Verificar metodo de selecao:
                if (hasMapEscolhasUsuario[Constantes.tipoSelecao] == "r"):
                    positionPais = self.selecaoDosPaisRoleta(listaFitness)
                else:
                    positionPais.append(
                        self.selecaoDosPaisTorneio(listaFitness))
                    positionPais.append(
                        self.selecaoDosPaisTorneio(listaFitness))

                pais = [populacao[positionPais[0]], populacao[positionPais[1]]]

                #Verificar metodo de cruzamento:
                if (hasMapEscolhasUsuario[Constantes.tipoCruzamento] == "p"):
                    filhos = self.cruzamentoUmPonto(
                        pais, hasMapEscolhasUsuario[Constantes.taxaCruzamento])
                else:
                    filhos = self.cruzamentoUniforme(
                        pais, hasMapEscolhasUsuario[Constantes.taxaCruzamento])

                #verifica tipo mutacao:

                if (hasMapEscolhasUsuario[Constantes.tipoMutacao] == "a"):
                    filhos[0] = self.mutacaoBitAleatorio(
                        filhos[0],
                        hasMapEscolhasUsuario[Constantes.taxaMutacao])
                    filhos[1] = self.mutacaoBitAleatorio(
                        filhos[1],
                        hasMapEscolhasUsuario[Constantes.taxaMutacao])
                else:
                    filhos[0] = self.mutacaoBitABit(
                        filhos[0],
                        hasMapEscolhasUsuario[Constantes.taxaMutacao])
                    filhos[1] = self.mutacaoBitABit(
                        filhos[1],
                        hasMapEscolhasUsuario[Constantes.taxaMutacao])

                newPopulacao.append(filhos[0])
                newPopulacao.append(filhos[1])
                j = j + 1

            populacao = newPopulacao if hasMapEscolhasUsuario[
                Constantes.temElitismo] == "n" else [
                    *populacao[:1], *newPopulacao
                ]

            # def atualizarPopulacao(self, filhos):
            #     newPopulacao=filhos
            #     return newPopulacao

            #metricas
            self.melhorIndividuo = MetricasPopulacao.melhorIndividuoPopulacao(
                populacao)
            self.piorIndividuo = MetricasPopulacao.piorIndividuoPopulacao(
                populacao)
            self.listMelhoresFitness.append(self.melhorIndividuo.getFitness())
            self.listPioresFitness.append(self.piorIndividuo.getFitness())