예제 #1
0
def evolui(TIPO, POP, D, Li, Ui, extra, sel, elite, cxTipo, cxProb, mutProb,
           passos, melhorFitLista, mediaFitLista, divParLista, divCentroLista):

    matriz = populacao.geraPop(TIPO, POP, D, Li, Ui, extra)
    fit = ackleyPopBin(matriz, D, Li, Ui, extra)  ##### função ackley
    max = False  #### minimizar ou maximizar

    #populacao.printPop(matriz)

    i = 0
    maior = fitAux.melhorFitFunc(fit, max)
    media = fitAux.mediaFit(fit)
    #s = '{} {} {}\n'.format(i, maior, media)
    #arqFit.write(s)
    melhorFitLista[i] += maior
    mediaFitLista[i] += media

    divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
    divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
    #s = '{} {} {}\n'.format(i, divPar, divCentro)
    #arqDiv.write(s)
    divParLista[i] += divPar
    divCentroLista[i] += divCentro

    melhorFitTotal = maior
    melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])

    c = 1.2
    passosCrescer = selecEscLin.cPassosCrescer(passos, 0.2)
    for i in range(1, passos):

        if (elite == True and max == True):
            eliteInd = fitAux.elitismo(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])
        elif (elite == True and max == False):
            eliteInd = fitAux.elitismoMin(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])

        g = 0.6
        sl, gap = selecEscLin.selecao(matriz, fit, POP, sel, max, c, g)
        cross = crossover.rotinaCrossOver(sl, TIPO, extra, cxTipo, cxProb, Li,
                                          Ui)
        mut = mutacao.rotinaMutacao(cross, TIPO, extra, mutProb, Li, Ui)

        c = selecEscLin.aumentaC(c, i, passosCrescer)

        if (elite == True):
            sub = random.randrange(0, int(POP * g))
            mut[sub] = eliteCod

        matriz = (copy.deepcopy(mut) + gap)
        fit = ackleyPopBin(matriz, D, Li, Ui, extra)  ##### função ackley

        maior = fitAux.melhorFitFunc(fit, max)
        media = fitAux.mediaFit(fit)
        #s = '{} {} {}\n'.format(i, maior, media)
        #arqFit.write(s)
        melhorFitLista[i] += maior
        mediaFitLista[i] += media

        divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
        divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
        #s = '{} {} {}\n'.format(i, divPar, divCentro)
        #arqDiv.write(s)
        divParLista[i] += divPar
        divCentroLista[i] += divCentro

        if (max == True and maior > melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])
            melhorFitTotal = maior
        elif (max == False and maior < melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismoMin(fit)])
            melhorFitTotal = maior

    #melhorInt, result = pesResultadoIndiv(melhorIndTotal, D, Li, Ui, extra)   ###### função da fábrica de rádios

    return melhorIndTotal, melhorFitTotal
예제 #2
0
def evolui(TIPO, POP, D, Li, Ui, extra, sel, elite, cxTipo, cxProb, mutProb,
           passos, melhorFitLista, mediaFitLista, divParLista, divCentroLista):

    matriz = populacao.geraPop(TIPO, POP, D, Li, Ui, extra)
    fit = fitPop(matriz)  ##### 8 rainhas
    max = True  #### minimizar ou maximizar

    i = 0
    maior = fitAux.melhorFitFunc(fit, max)
    media = fitAux.mediaFit(fit)
    #s = '{} {} {}\n'.format(i, maior, media)
    #arqFit.write(s)
    melhorFitLista[i] += maior
    mediaFitLista[i] += media

    divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
    divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
    #s = '{} {} {}\n'.format(i, divPar, divCentro)
    #arqDiv.write(s)
    divParLista[i] += divPar
    divCentroLista[i] += divCentro

    melhorFitTotal = maior
    melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])

    for i in range(1, passos):

        if (elite == True and max == True):
            eliteInd = fitAux.elitismo(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])
        elif (elite == True and max == False):
            eliteInd = fitAux.elitismoMin(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])

        sl = selec.selecao(matriz, fit, POP, sel, max)
        cross = crossover.rotinaCrossOver(sl, TIPO, extra, cxTipo, cxProb, Li,
                                          Ui)
        mut = mutacao.rotinaMutacao(cross, TIPO, extra, mutProb, Li, Ui)

        if (elite == True):
            sub = random.randrange(0, POP)
            mut[sub] = eliteCod

        matriz = copy.deepcopy(mut)
        fit = fitPop(matriz)  ##### 8 rainhas

        maior = fitAux.melhorFitFunc(fit, max)
        media = fitAux.mediaFit(fit)
        #s = '{} {} {}\n'.format(i, maior, media)
        #arqFit.write(s)
        melhorFitLista[i] += maior
        mediaFitLista[i] += media

        divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
        divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
        #s = '{} {} {}\n'.format(i, divPar, divCentro)
        #arqDiv.write(s)
        divParLista[i] += divPar
        divCentroLista[i] += divCentro

        if (max == True and maior > melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])
            melhorFitTotal = maior
        elif (max == False and maior < melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismoMin(fit)])
            melhorFitTotal = maior

    #melhorInt, result = pesResultadoIndiv(melhorIndTotal, D, Li, Ui, extra)   ###### função da fábrica de rádios

    return melhorIndTotal, melhorFitTotal
예제 #3
0
def evolui(TIPO, POP, D, Li, Ui, extra, sel, elite, cxTipo, cxProb, mutProb,
           passos, saida):

    matriz = populacao.geraPop(TIPO, POP, D, Li, Ui, extra)
    fit = fitPop(matriz)  ##### 8 rainhas
    max = True  #### minimizar ou maximizar

    melhorFitLista = [0.0] * passos
    mediaFitLista = [0.0] * passos
    dpmFitLista = [0.0] * passos
    divDPMLista = [0.0] * passos

    i = 0
    maior = fitAux.melhorFitFunc(fit, max)
    media = fitAux.mediaFit(fit)
    dpm = fitAux.desvioPadraoFit(fit, media, POP)

    melhorFitLista[i] += maior
    mediaFitLista[i] += media
    dpmFitLista[i] += dpm

    #divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
    #divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
    divDPM = diversidade.diversidadeDPMedio(TIPO, matriz)
    #s = '{} {} {}\n'.format(i, divPar, divCentro)
    #arqDiv.write(s)
    #divParLista[i] += divPar
    #divCentroLista[i] += divCentro
    divDPMLista[i] += divDPM

    melhorFitTotal = maior
    melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])

    c = 1.2
    passosCrescer = selecEscLin.cPassosCrescer(passos, 0.2)
    g = 0.5
    gapPassos = selecEscLin.genGapPasso(passos)

    for i in range(1, passos):

        if (elite == True and max == True):
            eliteInd = fitAux.elitismo(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])
        elif (elite == True and max == False):
            eliteInd = fitAux.elitismoMin(fit)
            eliteCod = copy.deepcopy(matriz[eliteInd])

        g = selecEscLin.genGapNovo(g, i, passos, gapPassos)
        #if(g>1.0):
        #    print('g maior que 1!')

        sl, gap = selecEscLin.selecao(matriz, fit, POP, sel, max, c, g)
        cross = crossover.rotinaCrossOver(sl, TIPO, extra, cxTipo, cxProb, Li,
                                          Ui)
        mut = mutacao.rotinaMutacao(cross, TIPO, extra, mutProb, Li, Ui)

        c = selecEscLin.aumentaC(c, i, passosCrescer)

        if (elite == True):
            sub = random.randrange(0, int(POP * g))
            mut[sub] = eliteCod

        matriz = (copy.deepcopy(mut) + gap)
        fit = fitPop(matriz)  ##### 8 rainhas

        #pool = mp.Pool(processes=2)
        #fit = pool.map(fitIndiv, matriz)

        #if(fit != fitTeste):
        #    print('nope')

        maior = fitAux.melhorFitFunc(fit, max)
        media = fitAux.mediaFit(fit)
        dpm = fitAux.desvioPadraoFit(fit, media, POP)
        #s = '{} {} {}\n'.format(i, maior, media)
        #arqFit.write(s)
        melhorFitLista[i] += maior
        mediaFitLista[i] += media
        dpmFitLista[i] += dpm

        #divPar = diversidade.diversidadePar(TIPO, matriz, Li, Ui)
        #divCentro = diversidade.diversidadeCentro(TIPO, matriz, Li, Ui)
        divDPM = diversidade.diversidadeDPMedio(TIPO, matriz)
        #s = '{} {} {}\n'.format(i, divPar, divCentro)
        #arqDiv.write(s)
        #divParLista[i] += divPar
        #divCentroLista[i] += divCentro
        divDPMLista[i] += divDPM

        if (max == True and maior > melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismo(fit)])
            melhorFitTotal = maior
        elif (max == False and maior < melhorFitTotal):
            melhorIndTotal = copy.deepcopy(matriz[fitAux.elitismoMin(fit)])
            melhorFitTotal = maior

    #melhorInt, result = pesResultadoIndiv(melhorIndTotal, D, Li, Ui, extra)   ###### função da fábrica de rádios

    saida.put([
        melhorIndTotal, melhorFitTotal, melhorFitLista, mediaFitLista,
        dpmFitLista, divDPMLista
    ])