Beispiel #1
0
def Crossover(populacao, t, vt, taxa_crossover, tempo, tempo_limite):
    novatos = []

    reprodutores = [e for e in populacao if uniform(0, 1) <= taxa_crossover]

    for _ in range(len(reprodutores) // 2):
        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        pai = choice(reprodutores)
        reprodutores.remove(pai)

        mae = choice(reprodutores)
        reprodutores.remove(mae)

        gene = randint(0, len(vt) - 1)

        descendente = pai.copy()
        descendente[gene] = mae[gene]

        if EhValido(descendente, t, vt):
            novatos.append(descendente)

        descendente = mae.copy()
        descendente[gene] = pai[gene]

        if EhValido(descendente, t, vt):
            novatos.append(descendente)

    return novatos
Beispiel #2
0
def Mutacao(populacao, t, vt, taxa_mutacao, tempo, tempo_limite):
    candidatos, mutados = [], []

    for e in populacao:
        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            return populacao

        if uniform(0, 1) <= taxa_mutacao:
            candidatos.append(e)
        else:
            mutados.append(e)

    for candidato in candidatos:
        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        gene = randint(0, len(vt) - 1)

        if candidato[gene] == 0:
            candidato[gene] += 1
        else:
            candidato[gene] += choice([-1, 1])

        if EhValido(candidato, t, vt):
            mutados.append(candidato)

    return mutados
Beispiel #3
0
def HillClimbing(t, vt, tempo_limite):
    tempo = time()

    estado = [0] * len(vt)

    while True:
        vizinhos = VizinhosPositivos(estado)

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        vizinhos = list(filter(lambda e: EhValido(e, t, vt), vizinhos))

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        if len(vizinhos) <= 0:
            break

        estado = max(vizinhos, key=lambda e: Valor(e, vt))

    tempo = time() - tempo

    return estado, Valor(estado, vt), Tamanho(estado, vt), tempo
Beispiel #4
0
def DeepestDescent(t, vt, inicio, tempo, tempo_limite):
    estado = inicio

    while True:
        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        vizinhos = VizinhosPositivos(estado)

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        vizinhos = list(filter(lambda e: EhValido(e, t, vt), vizinhos))

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        continuar = False

        for vizinho in vizinhos:
            # TIMER CHECK
            if (time() - tempo) >= tempo_limite:
                break

            if Valor(vizinho, vt) > Valor(estado, vt):
                estado = vizinho
                continuar = True

        if not continuar:
            break

    return estado, Valor(estado, vt), Tamanho(estado, vt)
Beispiel #5
0
def BeamSearch(t, vt, tempo_limite, m):
    tempo = time()

    estado = [0] * len(vt)

    fila = Queue()
    fila.put(estado)

    while True:
        if (time() - tempo) >= tempo_limite:
            break

        expandidos = []

        for _ in range(fila.qsize()):
            vizinhos = VizinhosPositivos(fila.get())
            vizinhos = list(filter(lambda e: EhValido(e, t, vt), vizinhos))
            expandidos.extend(vizinhos)

        if len(expandidos) <= 0:
            break

        expandidos.sort(key=lambda e: Valor(e, vt), reverse=True)
        melhores = expandidos[:m]

        [fila.put(e) for e in melhores]

    estado = melhores[0]

    tempo = time() - tempo

    return estado, Valor(estado, vt), Tamanho(estado, vt), tempo
def SimulatedAnnealing(t, vt, tempo_limite, iteracoes, temperatura, alpha):
    tempo = time()

    estado = [0] * len(vt)
    aux = [0] * len(vt)

    while temperatura > 0.1:
        if (time() - tempo) >= tempo_limite:
            break

        for _ in range(iteracoes):
            vizinho = VizinhoAleatorio(aux)

            if not EhValido(vizinho, t, vt):
                continue

            if Valor(vizinho, vt) > Valor(aux, vt):
                aux = vizinho

                if Valor(aux, vt) > Valor(estado, vt):
                    estado = aux

            elif AceitaPior(Valor(vizinho, vt), Valor(aux, vt), temperatura):
                aux = vizinho

        temperatura *= alpha

    tempo = time() - tempo

    return estado, Valor(estado, vt), Tamanho(estado, vt), tempo
Beispiel #7
0
def HillClimbing(t, vt, m, tempo, tempo_limite):
    estado = [0] * len(vt)

    while Tamanho(estado, vt) < (t // 2):
        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        vizinhos = VizinhosPositivos(estado)

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        vizinhos = list(filter(lambda e: EhValido(e, t, vt), vizinhos))

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        if len(vizinhos) <= 0:
            break

        vizinhos.sort(key=lambda e: Valor(e, vt), reverse=True)

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

        estado = Roleta(vizinhos[:m], vt, tempo, tempo_limite)

        # TIMER CHECK
        if (time() - tempo) >= tempo_limite:
            break

    return estado, Valor(estado, vt), Tamanho(estado, vt)