Implement uniform generational genetic algorithm

docs/Summary.org

@@ -1,143 +0,0 @@
-#+TITLE: Práctica 2
-#+SUBTITLE: Metaheurísticas
-#+AUTHOR: Amin Kasrou Aouam
-#+DATE: 2021-06-22
-#+PANDOC_OPTIONS: template:~/.pandoc/templates/eisvogel.latex
-#+PANDOC_OPTIONS: listings:t
-#+PANDOC_OPTIONS: toc:t
-#+PANDOC_METADATA: lang=es
-#+PANDOC_METADATA: titlepage:t
-#+PANDOC_METADATA: listings-no-page-break:t
-#+PANDOC_METADATA: toc-own-page:t
-#+PANDOC_METADATA: table-use-row-colors:t
-#+PANDOC_METADATA: colorlinks:t
-#+PANDOC_METADATA: logo:/home/coolneng/Photos/Logos/UGR.png
-#+LaTeX_HEADER: \usepackage[ruled, lined, linesnumbered, commentsnumbered, longend]{algorithm2e}
-* Práctica 2
-
-** Introducción
-
-En esta práctica, usaremos distintos algoritmos de búsqueda, basados en poblaciones, para resolver el problema de la máxima diversidad (MDP). Implementaremos:
-
-- Algoritmo genético
-- Algoritmo memético
-
-** Algoritmos
-
-*** Genético
-
-Los algoritmos genéticos se inspiran en la evolución natural y la genética. Generan un conjunto de soluciones inicial (i.e. población), seleccionan un subconjunto de individuos sobre los cuales se opera, hacen operaciones de recombinación y mutación, y finalmente reemplazan la población anterior por una nueva.
-
-El procedimiento general del algoritmo queda ilustrado a continuación:
-
-\begin{algorithm}
-    \KwIn{A list $[a_i]$, $i=1, 2, \cdots, n$, that contains the population of individuals}
-    \KwOut{Processed list}
-
-    $P(t) \leftarrow initializePopulation()$
-    $P(t) \leftarrow evaluatePopulation()$
-
-    \While{$\neg stop  condition $}{
-        $t = t + 1$
-
-        $parents \leftarrow selectParents(P(t-1))$
-
-        $offspring \leftarrow recombine(parents)$
-
-        $offspring \leftarrow mutate(offspring)$
-
-        $P(t) \leftarrow replacePopulation(P(t-1), offspring)$
-
-        $P(t) \leftarrow evaluatePopulation()$
-    }
-    \KwRet{$P(t)$}
-\end{algorithm}
-
-Procedemos a la implementación de 4 variantes distintas, según 2 criterios:
-
-**** Criterio de reemplazamiento
-- *Generacional*: la nueva población reemplaza totalmente a la población anterior
-- *Estacionario*: los dos mejores hijos reemplazan los dos peores individuos en la población anterior
-**** Operador de cruce
-- *Uniforme*: mantiene las posiciones comunes de ambos padres, las demás se eligen de forma aleatoria de cada padre (requiere reparador)
-- *Posición*: mantiene las posiciones comunes de ambos padres, elige el resto de elementos de cada padre y los baraja. Genera 2 hijos.
-
-*** Memético
-
-Los algoritmos meméticos surgen de la hibridación de un algoritmo genético, con un algoritmo de búsqueda local. El resultado es un algoritmo que posee un buen equilibrio entre exploración y explotación.
-
-El procedimiento general del algoritmo queda ilustrado a continuación:
-
-\begin{algorithm}
-    \KwIn{A list $[a_i]$, $i=1, 2, \cdots, n$, that contains the population of individuals}
-    \KwOut{Processed list}
-
-    $P(t) \leftarrow initializePopulation()$
-    $P(t) \leftarrow evaluatePopulation()$
-
-    \While{$\neg stop  condition $}{
-        \If{$certain  iteration$}{
-            $P(t) <- localSearch(P(t-1))$
-        }
-        $t = t + 1$
-
-        $parents \leftarrow selectParents(P(t-1))$
-
-        $offspring \leftarrow recombine(parents)$
-
-        $offspring \leftarrow mutate(offspring)$
-
-        $P(t) \leftarrow replacePopulation(P(t-1), offspring)$
-
-        $P(t) \leftarrow evaluatePopulation()$
-    }
-    \KwRet{$P(t)$}
-\end{algorithm}
-
-Procedemos a la implementación de 3 variantes distintas:
-- Búsqueda local sobre todos los cromosomas
-- Búsqueda local sobre un subconjunto aleatorio de cromosomas
-- Búsqueda local sobre un el subconjunto de los mejores cromosomas
-
-** Implementación
-
-La práctica ha sido implementada en /Python/, usando las siguientes bibliotecas:
-
-- NumPy
-- Pandas
-
-*** Instalación
-
-Para ejecutar el programa es preciso instalar Python, junto con las bibliotecas *Pandas* y *NumPy*.
-
-Se proporciona el archivo shell.nix para facilitar la instalación de las dependencias, con el gestor de paquetes [[https://nixos.org/][Nix]]. Tras instalar la herramienta Nix, únicamente habría que ejecutar el siguiente comando en la raíz del proyecto:
-
-#+begin_src shell
-nix-shell
-#+end_src
-
-** Ejecución
-
-La ejecución del programa se realiza mediante el siguiente comando:
-
-#+begin_src shell
-python src/main.py <dataset> <algoritmo> <parámetros>
-#+end_src
-
-Los parámetros posibles son:
-
-| dataset                              | algoritmo | parámetros                             |
-| Cualquier archivo de la carpeta data | genetic   | uniform/position generation/stationary |
-|                                      | memetic   | all/random/best                        |
-
-También se proporciona un script que ejecuta 1 iteración de cada algoritmo, sobre cada uno de los /datasets/, y guarda los resultados en una hoja de cálculo. Se puede ejecutar mediante el siguiente comando:
-
-#+begin_src shell
-python src/execution.py
-#+end_src
-
-*Nota*: se precisa instalar la biblioteca [[https://xlsxwriter.readthedocs.io/][XlsxWriter]] para la exportación de los resultados a un archivo Excel.
-
-* Análisis de los resultados
-
-Desafortunadamente, debido a un tiempo de ejecución excesivamente alto (incluso tras ajustar los metaparámetros) no podemos proporcionar resultados de la ejecución de los algoritmos.

src/execution.py

@@ -14,67 +14,70 @@ def file_list(path):
 
 
 def create_dataframes():
-    return [DataFrame() for _ in range(7)]
+    greedy = DataFrame()
+    local = DataFrame()
+    return greedy, local
 
 
 def process_output(results):
     distances = []
     time = []
-    for line in results:
+    for element in results:
-        if line.startswith(bytes("Total distance:", encoding="utf-8")):
+        for line in element:
-            line_elements = line.split(sep=bytes(":", encoding="utf-8"))
+            if line.startswith(bytes("Total distance:", encoding="utf-8")):
-            distances.append(float(line_elements[1]))
+                line_elements = line.split(sep=bytes(":", encoding="utf-8"))
-        if line.startswith(bytes("Execution time:", encoding="utf-8")):
+                distances.append(float(line_elements[1]))
-            line_elements = line.split(sep=bytes(":", encoding="utf-8"))
+            if line.startswith(bytes("Execution time:", encoding="utf-8")):
-            time.append(float(line_elements[1]))
+                line_elements = line.split(sep=bytes(":", encoding="utf-8"))
+                time.append(float(line_elements[1]))
     return distances, time
 
 
-def populate_dataframe(df, output_cmd, dataset):
+def populate_dataframes(greedy, local, greedy_list, local_list, dataset):
-    distances, time = process_output(output_cmd)
+    greedy_distances, greedy_time = process_output(greedy_list)
-    data_dict = {
+    local_distances, local_time = process_output(local_list)
+    greedy_dict = {
         "dataset": dataset.removeprefix("data/"),
-        "media distancia": mean(distances),
+        "media distancia": mean(greedy_distances),
-        "desviacion distancia": std(distances),
+        "desviacion distancia": std(greedy_distances),
-        "media tiempo": mean(time),
+        "media tiempo": mean(greedy_time),
-        "desviacion tiempo": std(time),
+        "desviacion tiempo": std(greedy_time),
     }
-    df = df.append(data_dict, ignore_index=True)
+    local_dict = {
-    return df
+        "dataset": dataset.removeprefix("data/"),
+        "media distancia": mean(local_distances),
+        "desviacion distancia": std(local_distances),
+        "media tiempo": mean(local_time),
+        "desviacion tiempo": std(local_time),
+    }
+    greedy = greedy.append(greedy_dict, ignore_index=True)
+    local = local.append(local_dict, ignore_index=True)
+    return greedy, local
 
 
-def script_execution(filenames, df_list):
+def script_execution(filenames, greedy, local, iterations=3):
     script = "src/main.py"
-    parameters = [
-        ["genetic", "uniform", "generational"],
-        ["genetic", "position", "generational"],
-        ["genetic", "uniform", "stationary"],
-        ["genetic", "position", "stationary"],
-        ["memetic", "all"],
-        ["memetic", "random"],
-        ["memetic", "best"],
-    ]
     for dataset in filenames:
         print(f"Running on dataset {dataset}")
-        for index, params in zip(range(4), parameters):
+        greedy_list = []
-            print(f"Running {params} algorithm")
+        local_list = []
-            output_cmd = run(
+        for _ in range(iterations):
-                [executable, script, dataset, *params], capture_output=True
+            greedy_cmd = run(
+                [executable, script, dataset, "greedy"], capture_output=True
             ).stdout.splitlines()
-            df_list[index] = populate_dataframe(df_list[index], output_cmd, dataset)
+            local_cmd = run(
-    return df_list
+                [executable, script, dataset, "local"], capture_output=True
+            ).stdout.splitlines()
+            greedy_list.append(greedy_cmd)
+            local_list.append(local_cmd)
+        greedy, local = populate_dataframes(
+            greedy, local, greedy_list, local_list, dataset
+        )
+    return greedy, local
 
 
-def export_results(df_list):
+def export_results(greedy, local):
-    dataframes = {
+    dataframes = {"Greedy": greedy, "Local search": local}
-        "Generational uniform genetic": df_list[0],
-        "Generational position genetic": df_list[1],
-        "Stationary uniform genetic": df_list[2],
-        "Stationary position genetic": df_list[3],
-        "All genes memetic": df_list[4],
-        "Random genes memetic": df_list[5],
-        "Best genes memetic": df_list[6],
-    }
     writer = ExcelWriter(path="docs/algorithm-results.xlsx", engine="xlsxwriter")
     for name, df in dataframes.items():
         df.to_excel(writer, sheet_name=name, index=False)
@@ -88,9 +91,9 @@ def export_results(df_list):
 
 def main():
     datasets = file_list(path="data/*.txt")
-    df_list = create_dataframes()
+    greedy, local = create_dataframes()
-    populated_df_list = script_execution(datasets, df_list)
+    populated_greedy, populated_local = script_execution(datasets, greedy, local)
-    export_results(populated_df_list)
+    export_results(populated_greedy, populated_local)
 
 
 if __name__ == "__main__":

src/genetic_algorithm.py

@@ -1,11 +1,12 @@
-from numpy import intersect1d, array_equal
+from numpy import sum, append, arange, delete, intersect1d
 from numpy.random import randint, choice, shuffle
 from pandas import DataFrame
 from math import ceil
 from functools import partial
 from multiprocessing import Pool
 from copy import deepcopy
-from itertools import combinations
+
+from preprocessing import parse_file
 
 
 def get_row_distance(source, destination, data):
@@ -36,36 +37,33 @@ def generate_individual(n, m, data):
 
 
 def evaluate_individual(individual, data):
-    fitness = 0
+    fitness = []
-    comb = combinations(individual.index, r=2)
+    genotype = individual.point.values
-    for index in list(comb):
+    distances = data.query(f"source in @genotype and destination in @genotype")
-        elements = individual.loc[index, :]
+    for item in genotype[:-1]:
-        fitness += get_row_distance(
+        element_df = distances.query(f"source == {item} or destination == {item}")
-            source=elements["point"].head(n=1).values[0],
+        max_distance = element_df["distance"].astype(float).max()
-            destination=elements["point"].tail(n=1).values[0],
+        fitness = append(arr=fitness, values=max_distance)
-            data=data,
+        distances = distances.query(f"source != {item} and destination != {item}")
-        )
+    individual["fitness"] = sum(fitness)
-    individual["fitness"] = fitness
     return individual
 
 
 def select_distinct_genes(matching_genes, parents, m):
     first_parent = parents[0].query("point not in @matching_genes")
     second_parent = parents[1].query("point not in @matching_genes")
-    cutoff = randint(m - len(matching_genes) + 1)
+    cutoff = randint(m - len(matching_genes))
     first_parent_genes = first_parent.point.values[cutoff:]
     second_parent_genes = second_parent.point.values[:cutoff]
     return first_parent_genes, second_parent_genes
 
 
-def select_shuffled_genes(matching_genes, parents):
+def select_random_genes(matching_genes, parents, m):
-    first_parent = parents[0].query("point not in @matching_genes")
+    random_parent = parents[randint(len(parents))]
-    second_parent = parents[1].query("point not in @matching_genes")
+    distinct_indexes = delete(arange(m), matching_genes)
-    first_genes = first_parent.point.values
+    genes = random_parent.point.iloc[distinct_indexes].values
-    second_genes = second_parent.point.values
+    shuffle(genes)
-    shuffle(first_genes)
+    return genes
-    shuffle(second_genes)
-    return first_genes, second_genes
 
 
 def select_random_parent(parents):
@@ -77,23 +75,20 @@ def select_random_parent(parents):
     return random_parent
 
 
-def get_best_point(parents, offspring):
-    while True:
-        random_parent = deepcopy(select_random_parent(parents))
-        best_index = random_parent["distance"].idxmax()
-        best_point = random_parent["point"].iloc[best_index]
-        random_parent.drop(index=best_index, inplace=True)
-        if best_point not in offspring.point.values:
-            return best_point
-
-
 def repair_offspring(offspring, parents, m):
     while len(offspring) != m:
         if len(offspring) > m:
             best_index = offspring["distance"].idxmax()
             offspring.drop(index=best_index, inplace=True)
         elif len(offspring) < m:
-            best_point = get_best_point(parents, offspring)
+            # NOTE Refactor into its own function
+            while True:
+                random_parent = select_random_parent(parents)
+                best_index = random_parent["distance"].idxmax()
+                best_point = random_parent["point"].loc[best_index]
+                random_parent.drop(index=best_index, inplace=True)
+                if best_point not in offspring.point.values:
+                    break
             offspring = offspring.append(
                 {"point": best_point, "distance": 0, "fitness": 0}, ignore_index=True
             )
@@ -114,6 +109,7 @@ def populate_offspring(values):
         offspring = offspring.append(aux)
     offspring["distance"] = 0
     offspring["fitness"] = 0
+    offspring = offspring[1:]
     return offspring
 
 
@@ -125,43 +121,21 @@ def uniform_crossover(parents, m):
     return viable_offspring
 
 
-def position_crossover(parents):
+def position_crossover(parents, m):
     matching_genes = get_matching_genes(parents)
-    first_genes, second_genes = select_shuffled_genes(matching_genes, parents)
+    shuffled_genes = select_random_genes(matching_genes, parents, m)
-    first_offspring = populate_offspring(values=[matching_genes, first_genes])
+    first_offspring = populate_offspring(values=[matching_genes, shuffled_genes])
-    second_offspring = populate_offspring(values=[matching_genes, second_genes])
+    second_offspring = populate_offspring(values=[matching_genes, shuffled_genes])
-    return first_offspring, second_offspring
+    return [first_offspring, second_offspring]
 
 
-def group_parents(parents):
+def crossover(mode, parents, m):
-    parent_pairs = []
+    split_parents = zip(*[iter(parents)] * 2)
-    for i in range(0, len(parents), 2):
-        first = parents[i]
-        second = parents[i + 1]
-        if array_equal(first.point.values, second.point.values):
-            random_index = randint(i + 1)
-            second, parents[random_index] = parents[random_index], second
-        parent_pairs.append([first, second])
-    return parent_pairs
-
-
-def crossover(mode, parents, m, probability=0.7):
-    parent_groups = group_parents(parents)
-    offspring = []
     if mode == "uniform":
-        expected_crossovers = int(len(parents) * probability)
+        crossover_func = partial(uniform_crossover, m=m)
-        cutoff = expected_crossovers // 2
-        for element in parent_groups[:cutoff]:
-            offspring.append(uniform_crossover(element, m))
-            offspring.append(uniform_crossover(element, m))
-        for element in parent_groups[cutoff:]:
-            offspring.append(element[0])
-            offspring.append(element[1])
     else:
-        for element in parent_groups:
+        crossover_func = partial(position_crossover, m=m)
-            first_offspring, second_offspring = position_crossover(element)
+    offspring = [*map(crossover_func, split_parents)]
-            offspring.append(first_offspring)
-            offspring.append(second_offspring)
     return offspring
 
 
@@ -177,7 +151,7 @@ def select_new_gene(individual, n):
             return new_gene
 
 
-def mutate(offspring, n, data, probability=0.001):
+def mutate(offspring, data, probability=0.001):
     expected_mutations = len(offspring) * n * probability
     individuals = []
     genes = []
@@ -211,7 +185,7 @@ def tournament_selection(population):
 
 def check_element_population(element, population):
     for item in population:
-        if array_equal(element.point.values, item.point.values):
+        if all(element.point.values) == all(item.point.values):
             return True
     return False
 
@@ -227,36 +201,27 @@ def generational_replacement(prev_population, current_population):
 
 
 def get_best_elements(population):
-    select_population = deepcopy(population)
+    first_element = max(population, key=lambda x: x.fitness.values[0])
-    first_element = max(select_population, key=lambda x: x.fitness.values[0])
+    first_index = get_individual_index(first_element, population)
-    first_index = get_individual_index(first_element, select_population)
+    population.pop(first_index)
-    select_population.pop(first_index)
+    second_element = max(population, key=lambda x: x.fitness.values[0])
-    second_element = max(select_population, key=lambda x: x.fitness.values[0])
+    second_index = get_individual_index(second_element, population)
-    second_index = get_individual_index(second_element, select_population)
     return first_index, second_index
 
 
 def get_worst_elements(population):
-    select_population = deepcopy(population)
+    first_index = population.index(min(population, key=lambda x: all(x.fitness)))
-    first_element = min(select_population, key=lambda x: x.fitness.values[0])
+    population.pop(first_index)
-    first_index = get_individual_index(first_element, select_population)
+    second_index = population.index(min(population, key=lambda x: all(x.fitness)))
-    select_population.pop(first_index)
-    second_element = min(select_population, key=lambda x: x.fitness.values[0])
-    second_index = get_individual_index(second_element, select_population)
     return first_index, second_index
 
 
 def stationary_replacement(prev_population, current_population):
     new_population = prev_population
-    first_worst, second_worst = get_worst_elements(prev_population)
+    worst_indexes = get_worst_elements(prev_population)
-    first_best, second_best = get_best_elements(current_population)
+    best_indexes = get_best_elements(current_population)
-    worst_indexes = [first_worst, second_worst]
-    best_indexes = [first_best, second_best]
     for worst, best in zip(worst_indexes, best_indexes):
-        if (
+        if current_population[best].fitness > prev_population[worst].fitness:
-            current_population[best].fitness.values[0]
-            > prev_population[worst].fitness.values[0]
-        ):
             new_population[worst] = current_population[best]
     return new_population
 
@@ -296,8 +261,19 @@ def genetic_algorithm(n, m, data, select_mode, crossover_mode, max_iterations=10
     for _ in range(max_iterations):
         parents = select_parents(population, n, select_mode)
         offspring = crossover(crossover_mode, parents, m)
-        offspring = mutate(offspring, n, data)
+        offspring = mutate(offspring, data)
         population = replace_population(population, offspring, select_mode)
         population = evaluate_population(population, data)
     best_index, _ = get_best_elements(population)
     return population[best_index]
+
+
+n, m, data = parse_file("data/GKD-c_11_n500_m50.txt")
+genetic_algorithm(
+    n=10,
+    m=4,
+    data=data,
+    select_mode="generational",
+    crossover_mode="uniform",
+    max_iterations=1,
+)

src/local_search.py

@@ -1,64 +0,0 @@
-from numpy.random import choice, seed, randint
-from pandas import DataFrame
-
-
-def get_row_distance(source, destination, data):
-    row = data.query(
-        """(source == @source and destination == @destination) or \
-        (source == @destination and destination == @source)"""
-    )
-    return row["distance"].values[0]
-
-
-def compute_distance(element, solution, data):
-    accumulator = 0
-    distinct_elements = solution.query(f"point != {element}")
-    for _, item in distinct_elements.iterrows():
-        accumulator += get_row_distance(
-            source=element,
-            destination=item.point,
-            data=data,
-        )
-    return accumulator
-
-
-def element_in_dataframe(solution, element):
-    duplicates = solution.query(f"point == {element}")
-    return not duplicates.empty
-
-
-def replace_worst_element(previous, n, data):
-    solution = previous.copy()
-    worst_index = solution["distance"].astype(float).idxmin()
-    random_element = randint(n)
-    while element_in_dataframe(solution=solution, element=random_element):
-        random_element = randint(n)
-    solution["point"].loc[worst_index] = random_element
-    solution["distance"].loc[worst_index] = compute_distance(
-        element=solution["point"].loc[worst_index], solution=solution, data=data
-    )
-    return solution
-
-
-def get_random_solution(previous, n, data):
-    solution = replace_worst_element(previous, n, data)
-    while solution["distance"].sum() <= previous["distance"].sum():
-        solution = replace_worst_element(previous=solution, n=n, data=data)
-    return solution
-
-
-def explore_neighbourhood(element, n, data, max_iterations=100000):
-    neighbourhood = []
-    neighbourhood.append(element)
-    for _ in range(max_iterations):
-        previous_solution = neighbourhood[-1]
-        neighbour = get_random_solution(previous=previous_solution, n=n, data=data)
-        neighbourhood.append(neighbour)
-    return neighbour
-
-
-def local_search(first_solution, n, data):
-    best_solution = explore_neighbourhood(
-        element=first_solution, n=n, data=data, max_iterations=5
-    )
-    return best_solution

src/main.py

@@ -1,57 +1,68 @@
 from preprocessing import parse_file
 from genetic_algorithm import genetic_algorithm
 from memetic_algorithm import memetic_algorithm
+from sys import argv
 from time import time
-from argparse import ArgumentParser
+from itertools import combinations
 
 
-def execute_algorithm(args, n, m, data):
+def execute_algorithm(choice, n, m, data):
-    if args.algorithm == "genetic":
+    if choice == "genetic":
-        return genetic_algorithm(
+        return genetic_algorithm(n, m, data)
-            n,
+    elif choice == "memetic":
-            m,
+        return memetic_algorithm(m, data)
-            data,
+    else:
-            select_mode=args.selection,
+        print("The valid algorithm choices are 'genetic' and 'memetic'")
-            crossover_mode=args.crossover,
+        exit(1)
-            max_iterations=100,
+
-        )
+
-    return memetic_algorithm(
+def get_row_distance(source, destination, data):
-        n,
+    row = data.query(
-        m,
+        """(source == @source and destination == @destination) or \
-        data,
+        (source == @destination and destination == @source)"""
-        hybridation=args.hybridation,
-        max_iterations=100,
     )
+    return row["distance"].values[0]
 
 
-def show_results(solution, time_delta):
+def get_fitness(solutions, data):
-    duplicates = solution.duplicated().any()
+    counter = 0
-    print(solution)
+    comb = combinations(solutions.index, r=2)
-    print(f"Total distance: {solution.fitness.values[0]}")
+    for index in list(comb):
+        elements = solutions.loc[index, :]
+        counter += get_row_distance(
+            source=elements["point"].head(n=1).values[0],
+            destination=elements["point"].tail(n=1).values[0],
+            data=data,
+        )
+    return counter
+
+
+def show_results(solutions, fitness, time_delta):
+    duplicates = solutions.duplicated().any()
+    print(solutions)
+    print(f"Total distance: {fitness}")
     if not duplicates:
         print("No duplicates found")
     print(f"Execution time: {time_delta}")
 
 
-def parse_arguments():
+def usage(argv):
-    parser = ArgumentParser()
+    print(f"Usage: python {argv[0]} <file> <algorithm choice>")
-    parser.add_argument("file", help="dataset of choice")
+    print("algorithm choices:")
-    subparsers = parser.add_subparsers(dest="algorithm")
+    print("genetic: genetic algorithm")
-    parser_genetic = subparsers.add_parser("genetic")
+    print("memetic: memetic algorithm")
-    parser_memetic = subparsers.add_parser("memetic")
+    exit(1)
-    parser_genetic.add_argument("crossover", choices=["uniform", "position"])
-    parser_genetic.add_argument("selection", choices=["generational", "stationary"])
-    parser_memetic.add_argument("hybridation", choices=["all", "random", "best"])
-    return parser.parse_args()
 
 
 def main():
-    args = parse_arguments()
+    if len(argv) != 3:
-    n, m, data = parse_file(args.file)
+        usage(argv)
+    n, m, data = parse_file(argv[1])
     start_time = time()
-    solutions = execute_algorithm(args, n, m, data)
+    solutions = execute_algorithm(choice=argv[2], n=n, m=m, data=data)
     end_time = time()
-    show_results(solutions, time_delta=end_time - start_time)
+    fitness = get_fitness(solutions, data)
+    show_results(solutions, fitness, time_delta=end_time - start_time)
 
 
 if __name__ == "__main__":

src/memetic_algorithm.py

@@ -1,59 +1,50 @@
-from genetic_algorithm import *
+from numpy.random import choice, seed
-from local_search import local_search
-from copy import deepcopy
 
 
-def get_best_indices(n, population):
+def get_first_random_solution(m, data):
-    select_population = deepcopy(population)
+    seed(42)
-    best_elements = []
+    random_indexes = choice(len(data.index), size=m, replace=False)
-    for _ in range(n):
+    return data.loc[random_indexes]
-        best_index, _ = get_best_elements(select_population)
-        best_elements.append(best_index)
-        select_population.pop(best_index)
-    return best_elements
 
 
-def replace_elements(current_population, new_population, indices):
+def element_in_dataframe(solution, element):
-    for item in indices:
+    duplicates = solution.query(
-        current_population[item] = new_population[item]
+        f"(source == {element.source} and destination == {element.destination}) or (source == {element.destination} and destination == {element.source})"
-    return current_population
+    )
+    return not duplicates.empty
 
 
-def run_local_search(n, data, population, mode, probability=0.1):
+def replace_worst_element(previous, data):
+    solution = previous.copy()
+    worst_index = solution["distance"].astype(float).idxmin()
+    random_element = data.sample().squeeze()
+    while element_in_dataframe(solution=solution, element=random_element):
+        random_element = data.sample().squeeze()
+    solution.loc[worst_index] = random_element
+    return solution, worst_index
+
+
+def get_random_solution(previous, data):
+    solution, worst_index = replace_worst_element(previous, data)
+    previous_worst_distance = previous["distance"].loc[worst_index]
+    while solution.distance.loc[worst_index] <= previous_worst_distance:
+        solution, _ = replace_worst_element(previous=solution, data=data)
+    return solution
+
+
+def explore_neighbourhood(element, data, max_iterations=100000):
     neighbourhood = []
-    if mode == "all":
+    neighbourhood.append(element)
-        for individual in population:
+    for _ in range(max_iterations):
-            neighbourhood.append(local_search(individual, n, data))
+        previous_solution = neighbourhood[-1]
-        new_population = neighbourhood
+        neighbour = get_random_solution(previous=previous_solution, data=data)
-    elif mode == "random":
+        neighbourhood.append(neighbour)
-        expected_individuals = len(population) * probability
+    return neighbour
-        indices = []
-        for _ in range(expected_individuals):
-            random_index = randint(len(population))
-            random_individual = population[random_index]
-            neighbourhood.append(local_search(random_individual, n, data))
-            indices.append(random_index)
-        new_population = replace_elements(population, neighbourhood, indices)
-    else:
-        expected_individuals = len(population) * probability
-        best_indices = get_best_indices(n=expected_individuals, population=population)
-        for element in best_indices:
-            neighbourhood.append(local_search(population[element], n, data))
-        new_population = replace_elements(population, neighbourhood, best_indices)
-    return new_population
 
 
-def memetic_algorithm(n, m, data, hybridation, max_iterations=100000):
+def memetic_algorithm(m, data):
-    population = [generate_individual(n, m, data) for _ in range(n)]
+    first_solution = get_first_random_solution(m=m, data=data)
-    population = evaluate_population(population, data)
+    best_solution = explore_neighbourhood(
-    for i in range(max_iterations):
+        element=first_solution, data=data, max_iterations=100
-        if i % 10 == 0:
+    )
-            population = run_local_search(n, data, population, mode=hybridation)
+    return best_solution
-            i += 5
-        parents = select_parents(population, n, mode="stationary")
-        offspring = crossover(mode="position", parents=parents, m=m)
-        offspring = mutate(offspring, n, data)
-        population = replace_population(population, offspring, mode="stationary")
-        population = evaluate_population(population, data)
-    best_index, _ = get_best_elements(population)
-    return population[best_index]