jmetalpy 1.5.4__py2.py3-none-any.whl

examples/experiment/comparison.py

@@ -0,0 +1,84 @@
+from jmetal.algorithm.multiobjective.gde3 import GDE3
+from jmetal.algorithm.multiobjective.nsgaii import NSGAII
+from jmetal.algorithm.multiobjective.smpso import SMPSO
+from jmetal.core.quality_indicator import *
+from jmetal.lab.experiment import Experiment, Job, generate_summary_from_experiment
+from jmetal.operator import PolynomialMutation, SBXCrossover
+from jmetal.problem import ZDT1, ZDT2, ZDT3
+from jmetal.util.archive import CrowdingDistanceArchive
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+
+def configure_experiment(problems: dict, n_run: int):
+    jobs = []
+    max_evaluations = 25000
+
+    for run in range(n_run):
+        for problem_tag, problem in problems.items():
+            jobs.append(
+                Job(
+                    algorithm=NSGAII(
+                        problem=problem,
+                        population_size=100,
+                        offspring_population_size=100,
+                        mutation=PolynomialMutation(
+                            probability=1.0 / problem.number_of_variables, distribution_index=20
+                        ),
+                        crossover=SBXCrossover(probability=1.0, distribution_index=20),
+                        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+                    ),
+                    algorithm_tag="NSGAII",
+                    problem_tag=problem_tag,
+                    run=run,
+                )
+            )
+            jobs.append(
+                Job(
+                    algorithm=GDE3(
+                        problem=problem,
+                        population_size=100,
+                        cr=0.5,
+                        f=0.5,
+                        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+                    ),
+                    algorithm_tag="GDE3",
+                    problem_tag=problem_tag,
+                    run=run,
+                )
+            )
+            jobs.append(
+                Job(
+                    algorithm=SMPSO(
+                        problem=problem,
+                        swarm_size=100,
+                        mutation=PolynomialMutation(
+                            probability=1.0 / problem.number_of_variables, distribution_index=20
+                        ),
+                        leaders=CrowdingDistanceArchive(100),
+                        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+                    ),
+                    algorithm_tag="SMPSO",
+                    problem_tag=problem_tag,
+                    run=run,
+                )
+            )
+
+    return jobs
+
+
+if __name__ == "__main__":
+    # Configure the experiments
+    jobs = configure_experiment(problems={"ZDT1": ZDT1(), "ZDT2": ZDT2(), "ZDT3": ZDT3()}, n_run=2)
+
+    # Run the study
+    output_directory = "data"
+
+    experiment = Experiment(output_dir=output_directory, jobs=jobs)
+    experiment.run()
+
+    # Generate summary file
+    generate_summary_from_experiment(
+        input_dir=output_directory,
+        reference_fronts="resources/reference_front",
+        quality_indicators=[GenerationalDistance(), EpsilonIndicator(), HyperVolume([1.0, 1.0])],
+    )

examples/experiment/generateKolmogorovSmirnovLatexTables.py

@@ -0,0 +1,10 @@
+from jmetal.lab.experiment import (
+    generate_kolmogorov_smirnov_latex_tables,
+)
+
+if __name__ == "__main__":
+    """
+        Generate Latex tables with the results of the Kolmogorov-Smirnov test. The last algorithm is considered as 
+        the reference algorithm, and the cells include a symbol with the p-value < 0.05.
+    """
+    generate_kolmogorov_smirnov_latex_tables(filename="QualityIndicatorSummary.csv")

examples/experiment/generateMedianAndWilcoxonLatexTables.py

@@ -0,0 +1,11 @@
+from jmetal.lab.experiment import (
+     generate_median_and_wilcoxon_latex_tables,
+)
+
+if __name__ == "__main__":
+    """
+        Generate Latex tables including medians and IQRs. Additionally, the last algorithm is considered as the reference
+        algorithm, and the cells include a symbol indicating whether the differences with the reference algorithm
+        are significant or not according to the Wilcoxon rank sum test. 
+    """
+    generate_median_and_wilcoxon_latex_tables(filename="QualityIndicatorSummary.csv")

examples/experiment/statistical_analysis.py

@@ -0,0 +1,75 @@
+from jmetal.lab.experiment import (
+    compute_mean_indicator,
+    compute_wilcoxon,
+    generate_boxplot,
+    generate_latex_tables,
+)
+from jmetal.lab.statistical_test.bayesian import *
+from jmetal.lab.statistical_test.functions import *
+from jmetal.lab.visualization import CDplot, plot_posterior
+
+if __name__ == "__main__":
+    # Generate Median & IQR tables
+    generate_latex_tables(filename="QualityIndicatorSummary.csv")
+
+    # Generate boxplots
+    generate_boxplot(filename="QualityIndicatorSummary.csv")
+
+    # Wilcoxon
+    compute_wilcoxon(filename="QualityIndicatorSummary.csv")
+
+    # Statistical lab
+
+    avg = compute_mean_indicator(filename="QualityIndicatorSummary.csv", indicator_name="HV")
+    print(avg)
+
+    # Non-parametric test
+    print("-------- Sign Test --------")
+    print(sign_test(avg[["NSGAII", "SMPSO"]]))
+    print("-------- Friedman Test --------")
+    print(friedman_test(avg))
+    print("-------- Friedman Aligned Rank Test --------")
+    print(friedman_aligned_rank_test(avg))
+    print("-------- Quade Test --------")
+    print(quade_test(avg))
+
+    # Post-hoc tests
+    print("-------- Friedman Post-Hoc Test --------")
+    z, p_val, adj_pval = friedman_ph_test(avg, control=0, apv_procedure="Bonferroni")
+    print("z values \n", z)
+    print("p-values \n", p_val)
+    print("adjusted p-values \n", adj_pval)
+    print("-------- Friedman Aligned Rank Post-Hoc Test --------")
+    z, p_val, adj_pval = friedman_aligned_ph_test(avg, apv_procedure="Shaffer")
+    print("z values \n", z)
+    print("p-values \n", p_val)
+    print("adjusted p-values \n", adj_pval)
+    print("-------- QuadeTest Post-Hoc Test --------")
+    z, p_val, adj_pval = quade_ph_test(avg, apv_procedure="Holm")
+    print("z values \n", z)
+    print("p-values \n", p_val)
+    print("adjusted p-values \n", adj_pval)
+
+    # Plot critical distance
+
+    CDplot(avg.T, alpha=0.15, higher_is_better=True)
+
+    print("-------- Bayesian Sign Test --------")
+    bst, DProcess = bayesian_sign_test(
+        avg[["NSGAII", "SMPSO"]], rope_limits=[-0.002, 0.002], prior_strength=0.5, return_sample=True
+    )
+    plot_posterior(DProcess, higher_is_better=True, alg_names=["NSGAII", "SMPSO"])
+
+    print("Pr(NSGAII < SMPSO) = %.3f" % bst[0])
+    print("Pr(NSGAII ~= SMPSO) = %.3f" % bst[1])
+    print("Pr(NSGAII > SMPSO) = %.3f" % bst[2])
+
+    print("-------- Bayesian Signed Rank Test --------")
+    bst, DProcess = bayesian_signed_rank_test(
+        avg[["NSGAII", "SMPSO"]], rope_limits=[-0.002, 0.002], prior_strength=0.5, return_sample=True
+    )
+    plot_posterior(DProcess, higher_is_better=True, alg_names=["NSGAII", "SMPSO"])
+
+    print("Pr(NSGAII < SMPSO) = %.3f" % bst[0])
+    print("Pr(NSGAII ~= SMPSO) = %.3f" % bst[1])
+    print("Pr(NSGAII > SMPSO) = %.3f" % bst[2])

examples/multiobjective/gde3/dynamic_gde3.py

@@ -0,0 +1,25 @@
+from jmetal.algorithm.multiobjective.gde3 import DynamicGDE3
+from jmetal.problem.multiobjective.fda import FDA2
+from jmetal.util.observable import TimeCounter
+from jmetal.util.observer import PlotFrontToFileObserver, WriteFrontToFileObserver
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = FDA2()
+
+    time_counter = TimeCounter(delay=1)
+    time_counter.observable.register(problem)
+    time_counter.start()
+
+    algorithm = DynamicGDE3(
+        problem=problem,
+        population_size=100,
+        cr=0.5,
+        f=0.5,
+        termination_criterion=StoppingByEvaluations(max_evaluations=500),
+    )
+
+    algorithm.observable.register(observer=PlotFrontToFileObserver("dynamic_front_vis"))
+    algorithm.observable.register(observer=WriteFrontToFileObserver("dynamic_front"))
+
+    algorithm.run()

examples/multiobjective/gde3/gde3_spark_evaluator.py

@@ -0,0 +1,28 @@
+from jmetal.algorithm.multiobjective.gde3 import GDE3
+from jmetal.problem.multiobjective.zdt import ZDT1Modified
+from jmetal.util.evaluator import SparkEvaluator
+from jmetal.util.solution import print_function_values_to_file, print_variables_to_file
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = ZDT1Modified()
+
+    algorithm = GDE3(
+        problem=problem,
+        population_size=10,
+        cr=0.5,
+        f=0.5,
+        termination_criterion=StoppingByEvaluations(max_evaluations=100),
+        population_evaluator=SparkEvaluator(),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.get_name() + "." + problem.name())
+    print_variables_to_file(front, "VAR." + algorithm.get_name() + "." + problem.name())
+
+    print(f"Algorithm (continuous problem): {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/gde3/gde3_zdt1.py

@@ -0,0 +1,25 @@
+from jmetal.algorithm.multiobjective.gde3 import GDE3
+from jmetal.problem import ZDT1
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByKeyboard
+
+if __name__ == "__main__":
+    problem = ZDT1()
+    problem.reference_front = read_solutions(filename="resources/reference_front/ZDT1.pf")
+
+    algorithm = GDE3(problem=problem, population_size=100, cr=0.5, f=0.5, termination_criterion=StoppingByKeyboard())
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/gde3/ggde3_zdt2.py

@@ -0,0 +1,36 @@
+from jmetal.algorithm.multiobjective.gde3 import GDE3
+from jmetal.problem import ZDT2
+from jmetal.util.comparator import GDominanceComparator
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = ZDT2()
+    problem.reference_front = read_solutions(filename="resources/reference_front/ZDT2.pf")
+
+    max_evaluations = 25000
+    reference_point = [0.2, 0.5]
+
+    algorithm = GDE3(
+        problem=problem,
+        population_size=100,
+        cr=0.5,
+        f=0.5,
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+        dominance_comparator=GDominanceComparator(reference_point),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/hype/hype_zdt1.py

@@ -0,0 +1,42 @@
+from jmetal.algorithm.multiobjective.hype import HYPE
+from jmetal.core.solution import FloatSolution
+from jmetal.operator import PolynomialMutation, SBXCrossover
+from jmetal.problem import ZDT1
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = ZDT1()
+    problem.reference_front = read_solutions(filename="resources/reference_front/ZDT1.pf")
+
+    reference_point = FloatSolution(
+        [0],
+        [1],
+        problem.number_of_objectives(),
+    )
+    reference_point.objectives = [1.0, 1.0]  # Mandatory for HYPE
+
+    algorithm = HYPE(
+        problem=problem,
+        reference_point=reference_point,
+        population_size=100,
+        offspring_population_size=100,
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        crossover=SBXCrossover(probability=1.0, distribution_index=20),
+        termination_criterion=StoppingByEvaluations(25000),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/ibea/ibea_zdt1.py

@@ -0,0 +1,34 @@
+from jmetal.algorithm.multiobjective.ibea import IBEA
+from jmetal.operator import PolynomialMutation, SBXCrossover
+from jmetal.problem import ZDT1
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = ZDT1()
+    problem.reference_front = read_solutions(filename="resources/reference_front/ZDT1.pf")
+
+    algorithm = IBEA(
+        problem=problem,
+        kappa=1.0,
+        population_size=100,
+        offspring_population_size=100,
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        crossover=SBXCrossover(probability=1.0, distribution_index=20),
+        termination_criterion=StoppingByEvaluations(max_evaluations=25000),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/mocell/mocell_zdt1.py

@@ -0,0 +1,38 @@
+from jmetal.algorithm.multiobjective.mocell import MOCell
+from jmetal.operator import PolynomialMutation, SBXCrossover
+from jmetal.problem import ZDT1
+from jmetal.util.archive import CrowdingDistanceArchive
+from jmetal.util.neighborhood import C9
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = ZDT1()
+    problem.reference_front = read_solutions(filename="resources/reference_front/ZDT1.pf")
+
+    max_evaluations = 25000
+    algorithm = MOCell(
+        problem=problem,
+        population_size=100,
+        neighborhood=C9(10, 10),
+        archive=CrowdingDistanceArchive(100),
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        crossover=SBXCrossover(probability=1.0, distribution_index=20),
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/moead/moead_dtlz2.py

@@ -0,0 +1,45 @@
+from jmetal.algorithm.multiobjective.moead import MOEAD
+from jmetal.core.quality_indicator import HyperVolume
+from jmetal.operator import DifferentialEvolutionCrossover, PolynomialMutation
+from jmetal.problem import DTLZ2
+from jmetal.util.aggregation_function import PenaltyBoundaryIntersection
+
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = DTLZ2()
+    problem.reference_front = read_solutions(filename="resources/reference_front/DTLZ2.3D.pf")
+
+    max_evaluations = 50000
+
+    algorithm = MOEAD(
+        problem=problem,
+        population_size=91,
+        crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5),
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        aggregation_function=PenaltyBoundaryIntersection(dimension=problem.number_of_objectives()),
+        neighbor_size=20,
+        neighbourhood_selection_probability=0.9,
+        max_number_of_replaced_solutions=2,
+        weight_files_path="resources/MOEAD_weights",
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    hypervolume = HyperVolume([1.0, 1.0, 1.0])
+    print("Hypervolume: " + str(hypervolume.compute([front[i].objectives for i in range(len(front))])))
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/moead/moead_iepsilon_lircmop1.py

@@ -0,0 +1,41 @@
+from jmetal.algorithm.multiobjective.moead import MOEADIEpsilon
+from jmetal.operator import DifferentialEvolutionCrossover, PolynomialMutation
+from jmetal.problem.multiobjective.lircmop import LIRCMOP2
+from jmetal.util.aggregation_function import Tschebycheff
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = LIRCMOP2()
+
+    problem.reference_front = read_solutions(filename="resources/reference_front/LIRCMOP2.pf")
+
+    max_evaluations = 300000
+
+    algorithm = MOEADIEpsilon(
+        problem=problem,
+        population_size=300,
+        crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5),
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        aggregation_function=Tschebycheff(dimension=problem.number_of_objectives()),
+        neighbor_size=20,
+        neighbourhood_selection_probability=0.9,
+        max_number_of_replaced_solutions=2,
+        weight_files_path="resources/MOEAD_weights",
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/moead/moead_lz09.py

@@ -0,0 +1,41 @@
+from jmetal.algorithm.multiobjective.moead import MOEAD
+from jmetal.operator import DifferentialEvolutionCrossover, PolynomialMutation
+from jmetal.problem import LZ09_F2
+from jmetal.util.aggregation_function import Tschebycheff
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = LZ09_F2()
+
+    problem.reference_front = read_solutions(filename="resources/reference_front/LZ09_F2.pf")
+
+    max_evaluations = 150000
+
+    algorithm = MOEAD(
+        problem=problem,
+        population_size=300,
+        crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5),
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        aggregation_function=Tschebycheff(dimension=problem.number_of_objectives()),
+        neighbor_size=20,
+        neighbourhood_selection_probability=0.9,
+        max_number_of_replaced_solutions=2,
+        weight_files_path="resources/MOEAD_weights",
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.get_name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/moead/moeaddra_lz09.py

@@ -0,0 +1,44 @@
+from jmetal.algorithm.multiobjective.moead import MOEAD_DRA
+from jmetal.core.quality_indicator import HyperVolume
+from jmetal.operator import DifferentialEvolutionCrossover, PolynomialMutation
+from jmetal.problem.multiobjective.lz09 import LZ09_F1
+from jmetal.util.aggregation_function import Tschebycheff
+from jmetal.util.solution import (
+    print_function_values_to_file,
+    print_variables_to_file,
+    read_solutions,
+)
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+if __name__ == "__main__":
+    problem = LZ09_F1()
+    problem.reference_front = read_solutions(filename="resources/reference_front/LZ09_F1.pf")
+
+    max_evaluations = 300000
+
+    algorithm = MOEAD_DRA(
+        problem=problem,
+        population_size=600,
+        crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5),
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables(), distribution_index=20),
+        aggregation_function=Tschebycheff(dimension=problem.number_of_objectives()),
+        neighbor_size=20,
+        neighbourhood_selection_probability=0.9,
+        max_number_of_replaced_solutions=2,
+        weight_files_path="resources/MOEAD_weights",
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    hypervolume = HyperVolume([2.0, 2.0])
+    print("Hypervolume: " + str(hypervolume.compute([front[i].objectives for i in range(len(front))])))
+
+    # Save results to file
+    print_function_values_to_file(front, "FUN." + algorithm.label)
+    print_variables_to_file(front, "VAR." + algorithm.label)
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")

examples/multiobjective/nsgaii/distributed_nsgaii_with_dask.py

@@ -0,0 +1,40 @@
+from dask.distributed import Client
+from distributed import LocalCluster
+
+from jmetal.algorithm.multiobjective.nsgaii import DistributedNSGAII
+from jmetal.operator import PolynomialMutation, SBXCrossover
+from jmetal.problem.multiobjective.zdt import ZDT1Modified
+from jmetal.util.termination_criterion import StoppingByEvaluations
+
+""" 
+Distributed (asynchronous) version of NSGA-II using Dask.
+"""
+
+if __name__ == "__main__":
+    problem = ZDT1Modified()
+
+    # setup Dask client
+    client = Client(LocalCluster(n_workers=24))
+
+    ncores = sum(client.ncores().values())
+    print(f"{ncores} cores available")
+
+    # creates the algorithm
+    max_evaluations = 25000
+
+    algorithm = DistributedNSGAII(
+        problem=problem,
+        population_size=100,
+        mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20),
+        crossover=SBXCrossover(probability=1.0, distribution_index=20),
+        termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
+        number_of_cores=ncores,
+        client=client,
+    )
+
+    algorithm.run()
+    front = algorithm.result()
+
+    print(f"Algorithm: {algorithm.get_name()}")
+    print(f"Problem: {problem.get_name()}")
+    print(f"Computing time: {algorithm.total_computing_time}")