From 7ec593b0197911a4a335a5d61bbbf573896c4a3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicente=20P=C3=A9rez=20Soloviev?= Date: Thu, 11 Jun 2020 11:50:28 +0200 Subject: [PATCH 1/4] univariate tests and bug fix --- EDAspy/optimization/univariate/continuous.py | 2 +- EDAspy/optimization/univariate/discrete.py | 2 - {tests => EDAspy/tests}/__init__.py | 0 EDAspy/tests/univariate_continuous_tests.py | 233 +++++++++++++++++++ EDAspy/tests/univariate_discrete_tests.py | 179 ++++++++++++++ README.md | 1 + setup.py | 2 +- 7 files changed, 415 insertions(+), 4 deletions(-) rename {tests => EDAspy/tests}/__init__.py (100%) create mode 100644 EDAspy/tests/univariate_continuous_tests.py create mode 100644 EDAspy/tests/univariate_discrete_tests.py diff --git a/EDAspy/optimization/univariate/continuous.py b/EDAspy/optimization/univariate/continuous.py index e0ae8ab..abc0175 100644 --- a/EDAspy/optimization/univariate/continuous.py +++ b/EDAspy/optimization/univariate/continuous.py @@ -166,7 +166,7 @@ def update_vector(self): """ for var in self.variables: - array = self.generation[var].values + array = list(self.generation[var].values) # calculate mu and std from data from scipy.stats import norm diff --git a/EDAspy/optimization/univariate/discrete.py b/EDAspy/optimization/univariate/discrete.py index 75693b1..a5483fa 100644 --- a/EDAspy/optimization/univariate/discrete.py +++ b/EDAspy/optimization/univariate/discrete.py @@ -24,8 +24,6 @@ class UMDAd: :type cost_function: callable function which receives a dictionary as input and returns a numeric value :raises Exception: cost function is not callable - - """ MAX_IT = -1 diff --git a/tests/__init__.py b/EDAspy/tests/__init__.py similarity index 100% rename from tests/__init__.py rename to EDAspy/tests/__init__.py diff --git a/EDAspy/tests/univariate_continuous_tests.py b/EDAspy/tests/univariate_continuous_tests.py new file mode 100644 index 0000000..99fd766 --- /dev/null +++ b/EDAspy/tests/univariate_continuous_tests.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python +# coding: utf-8 + + +def test__compare_costs__(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + EDA.best_MAE_global = 10.0 + assert EDA.__compare_costs__(8.0) is True, "Should be True" + + +def test_check_individual_(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + individual = {'param1': 5.1, 'param2': 1.0, 'param3': 6.9} + assert EDA.__check_individual__(individual) == 13.0, "Should be 13.0" + + +def test_check_generation(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 + gen = gen.append(individual, True) + + expected_output = [1, 1, 2, 1, 2, 2, 3, 0] + + EDA.generation = gen + EDA.check_generation() + real_output = list(EDA.generation['cost'].values) + + assert real_output == expected_output, "Should be True" + + +def test_individuals_selection(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + expected_output = expected_output.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + expected_output = expected_output.append(individual, True) + + EDA.generation = gen + EDA.truncation() + EDA.generation = EDA.generation.reset_index() + del EDA.generation['index'] + + output = expected_output == EDA.generation + for col in list(expected_output.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + + +def test_update_vector(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + + EDA.generation = gen + EDA.update_vector() + + expected_output = pd.DataFrame(columns=vector.columns) + expected_output['data'] = ['mu', 'std', 'min', 'max'] + expected_output = expected_output.set_index('data') + + from scipy.stats import norm + for col in list(expected_output.columns): + mu, std = norm.fit(list(gen[col].values)) + expected_output.loc['mu', col] = mu + if std < 1: + std = 1 + expected_output.loc['std', col] = std + + expected_output.loc['min'] = 0 + expected_output.loc['max'] = 100 + + output = expected_output == EDA.vector + + for col in list(vector.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + + +if __name__ == "__main__": + test__compare_costs__() + test_check_individual_() + test_check_generation() + test_individuals_selection() + test_update_vector() + + print("Everything passed") diff --git a/EDAspy/tests/univariate_discrete_tests.py b/EDAspy/tests/univariate_discrete_tests.py new file mode 100644 index 0000000..eca7185 --- /dev/null +++ b/EDAspy/tests/univariate_discrete_tests.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python +# coding: utf-8 + + +def test__compare_costs__(): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, + aim='minimize') + + EDA.best_MAE_global = 10 + assert EDA.__compare_costs__(8) is True, "Should be True" + + +def test_check_individual_(): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, + aim='minimize') + + individual = {'param1': 1, 'param2': 0, 'param3': 1} + assert EDA.__check_individual__(individual) == 2, "Should be 2" + + +def test_check_generation(): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, + aim='minimize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 + gen = gen.append(individual, True) + + expected_output = [1, 1, 2, 1, 2, 2, 3, 0] + + EDA.generation = gen + EDA.check_generation() + real_output = list(EDA.generation['cost'].values) + + assert real_output == expected_output, "Should be True" + + +def test_individuals_selection(): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + expected_output = expected_output.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + expected_output = expected_output.append(individual, True) + + EDA.generation = gen + EDA.individuals_selection() + + output = expected_output == EDA.generation + for col in list(expected_output.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + + +def test_update_vector(): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + expected_output.loc[0] = [3/4, 3/4, 3/4] + + EDA.generation = gen + EDA.update_vector() + output = expected_output == EDA.vector + + for col in list(vector.columns): + assert list(output[col]) == [True], "Should be True" + + +if __name__ == "__main__": + test__compare_costs__() + test_check_individual_() + test_check_generation() + test_individuals_selection() + test_update_vector() + + print("Everything passed") diff --git a/README.md b/README.md index 5cc58d8..d208217 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,6 @@ [![PyPI version fury.io](https://badge.fury.io/py/EDAspy.svg)](https://pypi.python.org/pypi/EDAspy/) [![PyPI license](https://img.shields.io/pypi/l/EDAspy.svg)](https://pypi.python.org/pypi/EDAspy/) + # EDAspy ## Description diff --git a/setup.py b/setup.py index 8d85ee1..30c8ead 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,7 @@ packages=setuptools.find_packages(), classifiers=[ 'Development Status :: 5 - Production/Stable', - "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.6", "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)", "Operating System :: OS Independent", ], From 011f51f79872cd928e6a60fbf78d59991621f806 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicente=20P=C3=A9rez=20Soloviev?= Date: Thu, 11 Jun 2020 12:44:30 +0200 Subject: [PATCH 2/4] tests --- EDAspy/tests/test___matrix.py | 53 +++++ EDAspy/tests/test_continuous.py | 224 +++++++++++++++++++ EDAspy/tests/test_discrete.py | 172 +++++++++++++++ EDAspy/tests/univariate_continuous_tests.py | 233 -------------------- EDAspy/tests/univariate_discrete_tests.py | 179 --------------- 5 files changed, 449 insertions(+), 412 deletions(-) create mode 100644 EDAspy/tests/test___matrix.py create mode 100644 EDAspy/tests/test_continuous.py create mode 100644 EDAspy/tests/test_discrete.py delete mode 100644 EDAspy/tests/univariate_continuous_tests.py delete mode 100644 EDAspy/tests/univariate_discrete_tests.py diff --git a/EDAspy/tests/test___matrix.py b/EDAspy/tests/test___matrix.py new file mode 100644 index 0000000..69aeee4 --- /dev/null +++ b/EDAspy/tests/test___matrix.py @@ -0,0 +1,53 @@ +from unittest import TestCase + + +class Test1(TestCase): + def test_normalizacion(self): + from EDAspy.optimization.multivariate.__matrix import normalizacion + totest = [0.20, 0.60, 0.2, 0.60] + expected_output = [0.125, 0.375, 0.125, 0.375] + + assert normalizacion(totest) == expected_output, "Should be True" + print("EDAspy.optimization.multivariate.__matrix.normalizacion test passed") + + +class Test2(TestCase): + def test_is_pd(self): + from EDAspy.optimization.multivariate.__matrix import isPD + import numpy as np + + matrix1 = np.array([[1, 2, 3], [4, 5, 6], [1, 2, 3]]) + matrix3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + + assert isPD(matrix1) == False, "Should be False" + assert isPD(matrix3) == True, "Should be True" + print("EDAspy.optimization.multivariate.__matrix.isPD test passed") + + +class Test3(TestCase): + def test_nearest_pd(self): + from EDAspy.optimization.multivariate.__matrix import nearestPD + import numpy as np + + matrix1 = np.array([[1, 2, 3], [4, 5, 6], [1, 2, 3]]) + expected_output = np.array([[1.42710507, 2.71987509, 2.07349008], + [2.71987509, 5.1837252, 3.95180015], + [2.07349008, 3.95180015, 3.01264511]]).round(decimals=4) + + output = nearestPD(matrix1).round(decimals=4) + + assert output.all() == expected_output.all(), "Should be True" + print("EDAspy.optimization.multivariate.__matrix.nearestPD test passed") + + +class Test4(TestCase): + def test_is_invertible(self): + from EDAspy.optimization.multivariate.__matrix import is_invertible + import numpy as np + + matrix1 = np.array([[1, 2, 3], [4, 5, 6], [1, 2, 3]]) + matrix2 = np.array([[1, 2, 3], [4, 5, 6], [1, 2, 4]]) + + assert is_invertible(matrix1) is not True, "Should be False" + assert is_invertible(matrix2) == True, "Should be True" + print("EDAspy.optimization.multivariate.__matrix.is_invertible test passed") \ No newline at end of file diff --git a/EDAspy/tests/test_continuous.py b/EDAspy/tests/test_continuous.py new file mode 100644 index 0000000..e86ce4b --- /dev/null +++ b/EDAspy/tests/test_continuous.py @@ -0,0 +1,224 @@ +from unittest import TestCase + + +class TestUMDAc(TestCase): + def test_truncation(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + expected_output = expected_output.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + expected_output = expected_output.append(individual, True) + + EDA.generation = gen + EDA.truncation() + EDA.generation = EDA.generation.reset_index() + del EDA.generation['index'] + + output = expected_output == EDA.generation + for col in list(expected_output.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + print("EDAspy.optimization.univariate.continuous.individuals_selection test passed") + + def test_check_generation(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 + gen = gen.append(individual, True) + + expected_output = [1, 1, 2, 1, 2, 2, 3, 0] + + EDA.generation = gen + EDA.check_generation() + real_output = list(EDA.generation['cost'].values) + + assert real_output == expected_output, "Should be True" + print("EDAspy.optimization.univariate.continuous.check_generation test passed") + + def test_update_vector(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + + EDA.generation = gen + EDA.update_vector() + + expected_output = pd.DataFrame(columns=vector.columns) + expected_output['data'] = ['mu', 'std', 'min', 'max'] + expected_output = expected_output.set_index('data') + + from scipy.stats import norm + for col in list(expected_output.columns): + mu, std = norm.fit(list(gen[col].values)) + expected_output.loc['mu', col] = mu + if std < 1: + std = 1 + expected_output.loc['std', col] = std + + expected_output.loc['min'] = 0 + expected_output.loc['max'] = 100 + + output = expected_output == EDA.vector + + for col in list(vector.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + print("EDAspy.optimization.univariate.continuous.update_vector test passed") + + def test_compare_costs_(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + EDA.best_MAE_global = 10.0 + assert EDA.__compare_costs__(8.0) is True, "Should be True" + print("EDAspy.optimization.univariate.continuous.__compare_costs__ test passed") + + def test_check_individual(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.continuous import UMDAc as EDAc + import pandas as pd + + def cost_function(dictionary): + function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if function < 0: + return 9999999 + return function + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector['data'] = ['mu', 'std', 'min', 'max'] + vector = vector.set_index('data') + vector.loc['mu'] = [5, 8, 1] + vector.loc['std'] = 20 + vector.loc['min'] = 0 + vector.loc['max'] = 100 + + EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, + aim='minimize') + + individual = {'param1': 5.1, 'param2': 1.0, 'param3': 6.9} + assert EDA.__check_individual__(individual) == 13.0, "Should be 13.0" + print("EDAspy.optimization.univariate.continuous._check_individual_ test passed") diff --git a/EDAspy/tests/test_discrete.py b/EDAspy/tests/test_discrete.py new file mode 100644 index 0000000..25eeccf --- /dev/null +++ b/EDAspy/tests/test_discrete.py @@ -0,0 +1,172 @@ +from unittest import TestCase + + +class TestUMDAd(TestCase): + def test_check_generation(self): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, + aim='minimize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 + gen = gen.append(individual, True) + + expected_output = [1, 1, 2, 1, 2, 2, 3, 0] + + EDA.generation = gen + EDA.check_generation() + real_output = list(EDA.generation['cost'].values) + + assert real_output == expected_output, "Should be True" + print("EDAspy.optimization.univariate.continuous.check_generation test passed") + + def test_individuals_selection(self): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + expected_output = expected_output.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + expected_output = expected_output.append(individual, True) + + EDA.generation = gen + EDA.individuals_selection() + + output = expected_output == EDA.generation + for col in list(expected_output.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + print("EDAspy.optimization.univariate.continuous.individuals_selection test passed") + + def test_update_vector(self): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, + aim='maximize') + + gen = pd.DataFrame(columns=vector.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=vector.columns) + expected_output.loc[0] = [3 / 4, 3 / 4, 3 / 4] + + EDA.generation = gen + EDA.update_vector() + output = expected_output == EDA.vector + + for col in list(vector.columns): + assert list(output[col]) == [True], "Should be True" + print("EDAspy.optimization.univariate.continuous.update_vector test passed") + + def test_check_individual(self): + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, + cost_function=check_solution_in_model, + aim='minimize') + + individual = {'param1': 1, 'param2': 0, 'param3': 1} + assert EDA.__check_individual__(individual) == 2, "Should be 2" + print("EDAspy.optimization.univariate.continuous._check_individual_ test passed") + + def test_compare_costs(self): + # assert sum((1, 2, 2)) == 6, "Should be 6" + from EDAspy.optimization.univariate.discrete import UMDAd as EDAd + import pandas as pd + + def check_solution_in_model(dictionary): + cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + return cost + + vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) + vector.loc[0] = 0.5 + + EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, + cost_function=check_solution_in_model, + aim='minimize') + + EDA.best_MAE_global = 10 + assert EDA.__compare_costs__(8) is True, "Should be True" + print("EDAspy.optimization.univariate.continuous.__compare_costs__ test passed") diff --git a/EDAspy/tests/univariate_continuous_tests.py b/EDAspy/tests/univariate_continuous_tests.py deleted file mode 100644 index 99fd766..0000000 --- a/EDAspy/tests/univariate_continuous_tests.py +++ /dev/null @@ -1,233 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - - -def test__compare_costs__(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.continuous import UMDAc as EDAc - import pandas as pd - - def cost_function(dictionary): - function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - if function < 0: - return 9999999 - return function - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector['data'] = ['mu', 'std', 'min', 'max'] - vector = vector.set_index('data') - vector.loc['mu'] = [5, 8, 1] - vector.loc['std'] = 20 - vector.loc['min'] = 0 - vector.loc['max'] = 100 - - EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, - aim='minimize') - - EDA.best_MAE_global = 10.0 - assert EDA.__compare_costs__(8.0) is True, "Should be True" - - -def test_check_individual_(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.continuous import UMDAc as EDAc - import pandas as pd - - def cost_function(dictionary): - function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - if function < 0: - return 9999999 - return function - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector['data'] = ['mu', 'std', 'min', 'max'] - vector = vector.set_index('data') - vector.loc['mu'] = [5, 8, 1] - vector.loc['std'] = 20 - vector.loc['min'] = 0 - vector.loc['max'] = 100 - - EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=cost_function, - aim='minimize') - - individual = {'param1': 5.1, 'param2': 1.0, 'param3': 6.9} - assert EDA.__check_individual__(individual) == 13.0, "Should be 13.0" - - -def test_check_generation(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.continuous import UMDAc as EDAc - import pandas as pd - - def cost_function(dictionary): - function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - if function < 0: - return 9999999 - return function - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector['data'] = ['mu', 'std', 'min', 'max'] - vector = vector.set_index('data') - vector.loc['mu'] = [5, 8, 1] - vector.loc['std'] = 20 - vector.loc['min'] = 0 - vector.loc['max'] = 100 - - EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=cost_function, - aim='minimize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 - gen = gen.append(individual, True) - - expected_output = [1, 1, 2, 1, 2, 2, 3, 0] - - EDA.generation = gen - EDA.check_generation() - real_output = list(EDA.generation['cost'].values) - - assert real_output == expected_output, "Should be True" - - -def test_individuals_selection(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.continuous import UMDAc as EDAc - import pandas as pd - - def cost_function(dictionary): - function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - if function < 0: - return 9999999 - return function - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector['data'] = ['mu', 'std', 'min', 'max'] - vector = vector.set_index('data') - vector.loc['mu'] = [5, 8, 1] - vector.loc['std'] = 20 - vector.loc['min'] = 0 - vector.loc['max'] = 100 - - EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, - aim='maximize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 - gen = gen.append(individual, True) - - expected_output = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - expected_output = expected_output.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - expected_output = expected_output.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - expected_output = expected_output.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - expected_output = expected_output.append(individual, True) - - EDA.generation = gen - EDA.truncation() - EDA.generation = EDA.generation.reset_index() - del EDA.generation['index'] - - output = expected_output == EDA.generation - for col in list(expected_output.columns): - assert list(output[col]) == [True, True, True, True], "Should be True" - - -def test_update_vector(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.continuous import UMDAc as EDAc - import pandas as pd - - def cost_function(dictionary): - function = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - if function < 0: - return 9999999 - return function - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector['data'] = ['mu', 'std', 'min', 'max'] - vector = vector.set_index('data') - vector.loc['mu'] = [5, 8, 1] - vector.loc['std'] = 20 - vector.loc['min'] = 0 - vector.loc['max'] = 100 - - EDA = EDAc(MAX_ITER=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=cost_function, - aim='maximize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - gen = gen.append(individual, True) - - EDA.generation = gen - EDA.update_vector() - - expected_output = pd.DataFrame(columns=vector.columns) - expected_output['data'] = ['mu', 'std', 'min', 'max'] - expected_output = expected_output.set_index('data') - - from scipy.stats import norm - for col in list(expected_output.columns): - mu, std = norm.fit(list(gen[col].values)) - expected_output.loc['mu', col] = mu - if std < 1: - std = 1 - expected_output.loc['std', col] = std - - expected_output.loc['min'] = 0 - expected_output.loc['max'] = 100 - - output = expected_output == EDA.vector - - for col in list(vector.columns): - assert list(output[col]) == [True, True, True, True], "Should be True" - - -if __name__ == "__main__": - test__compare_costs__() - test_check_individual_() - test_check_generation() - test_individuals_selection() - test_update_vector() - - print("Everything passed") diff --git a/EDAspy/tests/univariate_discrete_tests.py b/EDAspy/tests/univariate_discrete_tests.py deleted file mode 100644 index eca7185..0000000 --- a/EDAspy/tests/univariate_discrete_tests.py +++ /dev/null @@ -1,179 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - - -def test__compare_costs__(): - # assert sum((1, 2, 2)) == 6, "Should be 6" - from EDAspy.optimization.univariate.discrete import UMDAd as EDAd - import pandas as pd - - def check_solution_in_model(dictionary): - cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - return cost - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector.loc[0] = 0.5 - - EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, - aim='minimize') - - EDA.best_MAE_global = 10 - assert EDA.__compare_costs__(8) is True, "Should be True" - - -def test_check_individual_(): - from EDAspy.optimization.univariate.discrete import UMDAd as EDAd - import pandas as pd - - def check_solution_in_model(dictionary): - cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - return cost - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector.loc[0] = 0.5 - - EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=40, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, - aim='minimize') - - individual = {'param1': 1, 'param2': 0, 'param3': 1} - assert EDA.__check_individual__(individual) == 2, "Should be 2" - - -def test_check_generation(): - from EDAspy.optimization.univariate.discrete import UMDAd as EDAd - import pandas as pd - - def check_solution_in_model(dictionary): - cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - return cost - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector.loc[0] = 0.5 - - EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.6, vector=vector, cost_function=check_solution_in_model, - aim='minimize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 - gen = gen.append(individual, True) - - expected_output = [1, 1, 2, 1, 2, 2, 3, 0] - - EDA.generation = gen - EDA.check_generation() - real_output = list(EDA.generation['cost'].values) - - assert real_output == expected_output, "Should be True" - - -def test_individuals_selection(): - from EDAspy.optimization.univariate.discrete import UMDAd as EDAd - import pandas as pd - - def check_solution_in_model(dictionary): - cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - return cost - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector.loc[0] = 0.5 - - EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, - aim='maximize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 - gen = gen.append(individual, True) - - expected_output = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - expected_output = expected_output.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - expected_output = expected_output.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - expected_output = expected_output.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - expected_output = expected_output.append(individual, True) - - EDA.generation = gen - EDA.individuals_selection() - - output = expected_output == EDA.generation - for col in list(expected_output.columns): - assert list(output[col]) == [True, True, True, True], "Should be True" - - -def test_update_vector(): - from EDAspy.optimization.univariate.discrete import UMDAd as EDAd - import pandas as pd - - def check_solution_in_model(dictionary): - cost = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] - return cost - - vector = pd.DataFrame(columns=['param1', 'param2', 'param3']) - vector.loc[0] = 0.5 - - EDA = EDAd(MAX_IT=20, DEAD_ITER=10, SIZE_GEN=8, ALPHA=0.5, vector=vector, cost_function=check_solution_in_model, - aim='maximize') - - gen = pd.DataFrame(columns=vector.columns) - - individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 - gen = gen.append(individual, True) - individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 - gen = gen.append(individual, True) - individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 - gen = gen.append(individual, True) - - expected_output = pd.DataFrame(columns=vector.columns) - expected_output.loc[0] = [3/4, 3/4, 3/4] - - EDA.generation = gen - EDA.update_vector() - output = expected_output == EDA.vector - - for col in list(vector.columns): - assert list(output[col]) == [True], "Should be True" - - -if __name__ == "__main__": - test__compare_costs__() - test_check_individual_() - test_check_generation() - test_individuals_selection() - test_update_vector() - - print("Everything passed") From 7bd61dcfd2c81f66354ba47417da477c7d4ed1c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicente=20P=C3=A9rez=20Soloviev?= Date: Thu, 11 Jun 2020 14:06:50 +0200 Subject: [PATCH 3/4] tests EDA_multivairate_gaussian --- .../tests/test_EDA_multivariate_gaussian.py | 214 ++++++++++++++++++ 1 file changed, 214 insertions(+) create mode 100644 EDAspy/tests/test_EDA_multivariate_gaussian.py diff --git a/EDAspy/tests/test_EDA_multivariate_gaussian.py b/EDAspy/tests/test_EDA_multivariate_gaussian.py new file mode 100644 index 0000000..6161ed8 --- /dev/null +++ b/EDAspy/tests/test_EDA_multivariate_gaussian.py @@ -0,0 +1,214 @@ +from unittest import TestCase + + +class TestEDA_multivariate_gaussian(TestCase): + def test_truncation(self): + import pandas as pd + from EDAspy.optimization.multivariate import EDA_multivariate_gaussian as EDAmg + + def cost_function(dictionary): + suma = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if suma < 0: + return 999999999 + return suma + + mus = pd.DataFrame(columns=['param1', 'param2', 'param3']) + mus.loc[0] = [10, 8, 5] + + sigma = pd.DataFrame(columns=['param1', 'param2', 'param3']) + sigma.loc[0] = 5 + + EDA = EDAmg(SIZE_GEN=8, MAX_ITER=20, DEAD_ITER=10, ALPHA=0.5, aim='maximize', + cost_function=cost_function, mus=mus, sigma=sigma) + + gen = pd.DataFrame(columns=sigma.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1, 'cost': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0, 'cost': 1} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0, 'cost': 1} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0, 'cost': 0} # 8 + gen = gen.append(individual, True) + + expected_output = pd.DataFrame(columns=sigma.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + expected_output = expected_output.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + expected_output = expected_output.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + expected_output = expected_output.append(individual, True) + + EDA.generation = gen + EDA.truncation() + EDA.generation = EDA.generation.reset_index() + del EDA.generation['index'] + + output = expected_output == EDA.generation + for col in list(expected_output.columns): + assert list(output[col]) == [True, True, True, True], "Should be True" + print("EDAspy.optimization.multivariate.EDA_multivariate.truncation test passed") + + def test_check_generation(self): + import pandas as pd + from EDAspy.optimization.multivariate import EDA_multivariate_gaussian as EDAmg + + def cost_function(dictionary): + suma = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if suma < 0: + return 999999999 + return suma + + mus = pd.DataFrame(columns=['param1', 'param2', 'param3']) + mus.loc[0] = [10, 8, 5] + + sigma = pd.DataFrame(columns=['param1', 'param2', 'param3']) + sigma.loc[0] = 5 + + EDA = EDAmg(SIZE_GEN=8, MAX_ITER=20, DEAD_ITER=10, ALPHA=0.5, aim='maximize', + cost_function=cost_function, mus=mus, sigma=sigma) + + gen = pd.DataFrame(columns=sigma.columns) + + individual = {'param1': 0, 'param2': 0, 'param3': 1} # 1 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 0} # 2 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 0} # 4 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0} # 6 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 1} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 0, 'param3': 0} # 8 + gen = gen.append(individual, True) + + expected_output = [1, 1, 2, 1, 2, 2, 3, 0] + + EDA.generation = gen + EDA.check_generation() + real_output = list(EDA.generation['cost'].values) + + assert real_output == expected_output, "Should be True" + print("EDAspy.optimization.multivariate.EDA_multivariate.check_generation test passed") + + def test_update_vector(self): + import pandas as pd + from EDAspy.optimization.multivariate import EDA_multivariate_gaussian as EDAmg + + def cost_function(dictionary): + suma = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if suma < 0: + return 999999999 + return suma + + mus = pd.DataFrame(columns=['param1', 'param2', 'param3']) + mus.loc[0] = [10, 8, 5] + + sigma = pd.DataFrame(columns=['param1', 'param2', 'param3']) + sigma.loc[0] = 5 + + EDA = EDAmg(SIZE_GEN=8, MAX_ITER=20, DEAD_ITER=10, ALPHA=0.5, aim='maximize', + cost_function=cost_function, mus=mus, sigma=sigma) + + gen = pd.DataFrame(columns=sigma.columns) + + individual = {'param1': 1, 'param2': 1, 'param3': 1, 'cost': 3} # 7 + gen = gen.append(individual, True) + individual = {'param1': 0, 'param2': 1, 'param3': 1, 'cost': 2} # 3 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 0, 'param3': 1, 'cost': 2} # 5 + gen = gen.append(individual, True) + individual = {'param1': 1, 'param2': 1, 'param3': 0, 'cost': 2} # 6 + gen = gen.append(individual, True) + + EDA.generation = gen + EDA.update_vector() + + expected_sigma = pd.DataFrame(columns=sigma.columns) + expected_sigma['vars'] = sigma.columns + expected_sigma = expected_sigma.set_index('vars') + expected_sigma.loc['param1'] = [1.0000, -0.0833, -0.0833] + expected_sigma.loc['param2'] = [-0.0833, 1.0000, -0.0833] + expected_sigma.loc['param3'] = [-0.0833, -0.0833, 1.0000] + + for var in list(sigma.columns): + for varj in list(sigma.columns): + # print(float(expected_sigma.round(decimals=4).loc[var, var]), + # float(EDA.sigma.round(decimals=4).loc[var, var])) + + assert float(expected_sigma.round(decimals=4).loc[var, varj]) == \ + float(EDA.sigma.round(decimals=4).loc[var, varj]), "Should be True" + + expected_mus = pd.DataFrame(columns=sigma.columns) + expected_mus.loc[0] = 0.75 + + for var in list(sigma.columns): + assert float(expected_mus[var]) == float(EDA.mus[var]), "Should be True" + print("EDAspy.optimization.multivariate.EDA_multivariate.update_vector test passed") + + def test_compare_costs(self): + import pandas as pd + from EDAspy.optimization.multivariate import EDA_multivariate_gaussian as EDAmg + + def cost_function(dictionary): + suma = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if suma < 0: + return 999999999 + return suma + + mus = pd.DataFrame(columns=['param1', 'param2', 'param3']) + mus.loc[0] = [10, 8, 5] + + sigma = pd.DataFrame(columns=['param1', 'param2', 'param3']) + sigma.loc[0] = 5 + + EDA = EDAmg(SIZE_GEN=8, MAX_ITER=20, DEAD_ITER=10, ALPHA=0.5, aim='minimize', + cost_function=cost_function, mus=mus, sigma=sigma) + + EDA.best_mae_global = 10 + EDA.__compare_costs__(8) + + assert EDA.__compare_costs__(8) is True, "Should be True" + print("EDAspy.optimization.multivariate.EDA_multivariate.__compare_costs__ test passed") + + def test_check_individual(self): + import pandas as pd + from EDAspy.optimization.multivariate import EDA_multivariate_gaussian as EDAmg + + def cost_function(dictionary): + suma = dictionary['param1'] + dictionary['param2'] + dictionary['param3'] + if suma < 0: + return 999999999 + return suma + + mus = pd.DataFrame(columns=['param1', 'param2', 'param3']) + mus.loc[0] = [10, 8, 5] + + sigma = pd.DataFrame(columns=['param1', 'param2', 'param3']) + sigma.loc[0] = 5 + + EDA = EDAmg(SIZE_GEN=8, MAX_ITER=20, DEAD_ITER=10, ALPHA=0.5, aim='minimize', + cost_function=cost_function, mus=mus, sigma=sigma) + + individual = {'param1': 5.1, 'param2': 1.0, 'param3': 6.9} + assert EDA.__check_individual__(individual) == 13.0, "Should be 13.0" + print("EDAspy.optimization.multivariate.EDA_multivariate._check_individual_ test passed") + + From d488931910fb33091321eab2573f58a63384b964 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicente=20P=C3=A9rez=20Soloviev?= Date: Thu, 11 Jun 2020 14:32:32 +0200 Subject: [PATCH 4/4] update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d208217..cef724a 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,6 @@ [![PyPI version fury.io](https://badge.fury.io/py/EDAspy.svg)](https://pypi.python.org/pypi/EDAspy/) [![PyPI license](https://img.shields.io/pypi/l/EDAspy.svg)](https://pypi.python.org/pypi/EDAspy/) +[![PyPI license](https://img.shields.io/pypi/dm/EDAspy)](https://pypi.python.org/pypi/EDAspy/) # EDAspy