def setUp(self):
self.dimension = 20
rng = default_rng()
self.x = rng.uniform(-100, 100, self.dimension)
self.task = Task(max_evals=230, max_iters=np.inf, problem=MyProblem(self.dimension))
self.s1 = Individual(x=self.x, e=False)
self.s2 = Individual(task=self.task, rng=rng)
self.s3 = Individual(task=self.task)
def setUp(self):
self.D, self.nFES, self.nGEN = 10, 10, 10
self.Lower, self.Upper = [2, 1, 1], [10, 10, 5]
self.task = Task(dimension=self.D,
lower=self.Lower,
upper=self.Upper,
problem='sphere',
max_evals=self.nFES,
max_iters=self.nGEN,
cutoff_value=0.0)
class IndividualTestCase(TestCase):
r"""Test case for testing Individual class.
Date:
April 2019
Author:
Klemen Berkovič
See Also:
* :class:`niapy.algorithms.Individual`
"""
def setUp(self):
self.dimension = 20
rng = default_rng()
self.x = rng.uniform(-100, 100, self.dimension)
self.task = Task(max_evals=230,
max_iters=np.inf,
problem=MyProblem(self.dimension))
self.s1 = Individual(x=self.x, e=False)
self.s2 = Individual(task=self.task, rng=rng)
self.s3 = Individual(task=self.task)
def test_generate_solution(self):
self.assertTrue(self.task.is_feasible(self.s2))
self.assertTrue(self.task.is_feasible(self.s3))
def test_evaluate(self):
self.s1.evaluate(self.task)
self.assertAlmostEqual(self.s1.f, self.task.eval(self.x))
def test_repair(self):
s = Individual(x=np.full(self.dimension, 100))
self.assertFalse(self.task.is_feasible(s.x))
def test_eq(self):
self.assertFalse(self.s1 == self.s2)
self.assertTrue(self.s1 == self.s1)
s = Individual(x=self.s1.x)
self.assertTrue(s == self.s1)
def test_str(self):
self.assertEqual(str(self.s1), '%s -> %s' % (self.x, np.inf))
def test_getitem(self):
for i in range(self.dimension):
self.assertEqual(self.s1[i], self.x[i])
def test_len(self):
self.assertEqual(len(self.s1), len(self.x))
def test_init_population_individual(self):
r"""Test if custom generation initialization works ok."""
a = Algorithm(population_size=10, initialization_function=init_pop_individual, individual_type=Individual)
t = Task(problem=MyProblem(dimension=20))
i = Individual(x=np.zeros(t.dimension), task=t)
pop, fpop, d = a.init_population(t)
for e in pop:
self.assertEqual(i, e)
def setUp(self):
self.D, self.F, self.CR = 10, 0.9, 0.3
self.x, self.task = default_rng().uniform(
10, 50, self.D), Task(problem=MyProblem(self.D))
self.s1, self.s2 = SolutionJDE(task=self.task, e=False), SolutionJDE(
differential_weight=self.F,
crossover_probability=self.CR,
x=self.x)
def test_init_population_numpy(self):
r"""Test if custom generation initialization works ok."""
a = Algorithm(population_size=10,
initialization_function=init_pop_numpy)
t = Task(problem=MyProblem(dimension=20))
self.assertTrue(
np.array_equal(np.zeros((10, t.dimension)),
a.init_population(t)[0]))
def task_factory(self, name):
r"""Create optimization task.
Args:
name (str): Problem name.
Returns:
Task: Optimization task to use.
"""
return Task(max_evals=self.max_evals,
dimension=self.dimension,
problem=name)
def fit(self, x, y):
r"""Fit NiaClass.
Arguments:
x (pandas.core.frame.DataFrame): n samples to classify.
y (pandas.core.series.Series): n classes of the samples in the x array.
Returns:
None
"""
feats = []
for col in x:
if is_numeric_dtype(x[col]):
feats.append(_FeatureInfo(1, None, x[col].min(), x[col].max()))
else:
feats.append(_FeatureInfo(0, x[col].unique(), None, None))
preprocessed_data = self.__preprocess_dataset(x, y, feats)
algo = get_algorithm(self.__algo)
algo.set_parameters(**self.__algo_args)
problem = _NiaClassProblem(
feats,
y.unique(),
x,
y,
preprocessed_data,
self.__score_func_name,
self.__classify,
)
task = Task(problem, max_evals=self.__num_evals)
algo.run(task)
self.__rules = problem.get_rules()
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import BacterialForagingOptimization
from niapy.task import Task
from niapy.problems import Griewank
# we will run Bacterial Foraging Optimization Algorithm for 5 independent runs
for i in range(5):
task = Task(problem=Griewank(dimension=10, lower=-100.0, upper=100.0),
max_iters=800,
enable_logging=True)
algo = BacterialForagingOptimization()
best = algo.run(task)
print('%s -> %s' % (best[0], best[1]))
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import ComprehensiveLearningParticleSwarmOptimizer
from niapy.problems import Sphere
from niapy.task import Task
# we will run ParticleSwarmAlgorithm for 5 independent runs
algo = ComprehensiveLearningParticleSwarmOptimizer(population_size=50,
c1=.3,
c2=1.0,
m=5,
w=0.86,
min_velocity=-2,
max_velocity=2)
for i in range(5):
task = Task(problem=Sphere(dimension=25), max_evals=20000)
best = algo.run(task=task)
print('%s -> %f' % (best[0], best[1]))
print(algo.get_parameters())
# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import ParticleSwarmAlgorithm
from niapy.task import Task
from niapy.problems import Griewank
# we will run ParticleSwarmAlgorithm for 5 independent runs
algo = ParticleSwarmAlgorithm(population_size=100,
min_velocity=-4.0,
max_velocity=4.0)
for i in range(5):
task = Task(problem=Griewank(dimension=10, lower=-600, upper=600),
max_evals=10000)
best = algo.run(task=task)
print('%s -> %f' % (best[0], best[1]))
print(algo.get_parameters())
# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.problems import Sphere
from niapy.algorithms.basic import DynamicFireworksAlgorithm
# we will run Fireworks Algorithm for 5 independent runs
algo = DynamicFireworksAlgorithm(population_size=70,
amplitude_init=0.1,
amplitude_final=0.9)
for i in range(5):
task = Task(problem=Sphere(dimension=10), max_iters=80)
best = algo.run(task)
print('%s -> %s' % (best[0], best[1]))
print(algo.get_parameters())
# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3
def test_BA_iters_to_fes(self):
task = Task(max_iters=1000, problem=Sphere(10))
algo = BatAlgorithm(population_size=10)
algo.run_task(task)
evals = task.evals
self.assertEqual(10010, evals)
sys.path.append('../')
import numpy as np
from niapy.task import Task
from niapy.problems import Problem
from niapy.algorithms.basic import GreyWolfOptimizer
# our custom problem class
class MyProblem(Problem):
def __init__(self, dimension, lower=-10, upper=10, *args, **kwargs):
super().__init__(dimension, lower, upper, *args, **kwargs)
def _evaluate(self, x):
return np.sum(x ** 2)
# we will run 10 repetitions of Grey Wolf Optimizer against our custom MyProblem problem.
my_problem = MyProblem(20)
for i in range(10):
task = Task(problem=my_problem, max_iters=100)
# parameter is population size
algo = GreyWolfOptimizer(population_size=20)
# running algorithm returns best found minimum
best = algo.run(task)
# printing best minimum
print(best[-1])
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.problems import Sphere
from niapy.algorithms.basic import CatSwarmOptimization
task = Task(problem=Sphere(dimension=10), max_evals=1000, enable_logging=True)
algo = CatSwarmOptimization()
best = algo.run(task=task)
print('%s -> %s' % (best[0], best[1]))
# plot a convergence graph
task.plot_convergence(x_axis='evals')
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
import numpy as np
from niapy.task import Task
from niapy.problems import Problem
from niapy.algorithms.basic import ParticleSwarmAlgorithm
class MyProblem(Problem):
def __init__(self, dimension, lower=-10, upper=10, *args, **kwargs):
super().__init__(dimension, lower, upper, *args, **kwargs)
def _evaluate(self, x):
return np.sum(x**2)
# we will run Particle Swarm Algorithm on custom problem
task = Task(problem=MyProblem(dimension=10), max_iters=1000)
algo = ParticleSwarmAlgorithm(population_size=40,
c1=2.0,
c2=2.0,
w=0.7,
min_velocity=-4,
max_velocity=4)
best = algo.run(task=task)
print('%s -> %s ' % (best[0], best[1]))
def test_FA_iters(self):
task = Task(max_iters=1000, problem=Sphere(10))
algo = FireflyAlgorithm(population_size=10)
algo.run_task(task)
iters = task.iters
self.assertEqual(1000, iters)
def test_FA_evals(self):
task = Task(max_evals=1000, problem=Sphere(10))
algo = FireflyAlgorithm(population_size=10)
algo.run_task(task)
evals = task.evals
self.assertEqual(1000, evals)
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.problems import Sphere
from niapy.algorithms.basic import CatSwarmOptimization
task = Task(problem=Sphere(dimension=10), max_evals=1000, enable_logging=True)
algo = CatSwarmOptimization()
best = algo.run(task=task)
print('%s -> %s' % (best[0], best[1]))
# plot a convergence graph
task.plot()
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.algorithms.basic import DifferentialEvolution
from niapy.problems import Sphere
# 1 Number of function evaluations (nFES) as a stopping criteria
for i in range(10):
task = Task(problem=Sphere(dimension=10), max_evals=10000)
algo = DifferentialEvolution(population_size=40,
crossover_probability=0.9,
differential_weight=0.5)
best = algo.run(task)
print('%s -> %s' % (best[0], best[1]))
print('---------------------------------------')
# 2 Number of generations (iterations) as a stopping criteria
for i in range(10):
task = Task(problem=Sphere(dimension=10), max_iters=1000)
algo = DifferentialEvolution(population_size=40,
crossover_probability=0.9,
differential_weight=0.5)
best = algo.run(task)
print('%s -> %s' % (best[0], best[1]))
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.modified import SelfAdaptiveDifferentialEvolution
from niapy.task import Task
from niapy.problems import Griewank
# we will run jDE algorithm for 5 independent runs
algo = SelfAdaptiveDifferentialEvolution(f_lower=0.0,
f_upper=2.0,
tao1=0.9,
tao2=0.45,
population_size=40,
differential_weight=0.5,
crossover_probability=0.5)
for i in range(5):
task = Task(problem=Griewank(dimension=10, lower=-600, upper=600),
max_evals=10000,
enable_logging=True)
best = algo.run(task)
print('%s -> %s' % (best[0], best[1]))
print(algo.get_parameters())
def test_DE_iters(self):
task = Task(max_iters=1000, problem=Sphere(10))
algo = DifferentialEvolution(population_size=10, CR=0.9, F=0.5)
algo.run_task(task)
iters = task.iters
self.assertEqual(1000, iters)
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.problems import Sphere
from niapy.algorithms.other import RandomSearch
task = Task(problem=Sphere(dimension=5), max_iters=5000)
algo = RandomSearch()
best = algo.run(task=task)
print(best)
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import GreyWolfOptimizer
from niapy.task import Task, OptimizationType
from niapy.problems import Pinter
# initialize Pinter problem with custom bound
pinter = Pinter(20, -5, 5)
# we will run 10 repetitions of Grey Wolf Optimizer against Pinter problem
for i in range(10):
task = Task(problem=pinter, max_iters=100)
# parameter is population size
algo = GreyWolfOptimizer(population_size=20)
# running algorithm returns best found minimum
best = algo.run(task)
# printing best minimum
print(best[-1])
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import ParticleSwarmAlgorithm
from niapy.task import Task, OptimizationType
from niapy.problems import Sphere
# we will run ParticleSwarmAlgorithm for 5 independent runs
for i in range(5):
task = Task(problem=Sphere(dimension=10),
max_evals=10000,
optimization_type=OptimizationType.MAXIMIZATION)
algo = ParticleSwarmAlgorithm(population_size=40,
c1=2.0,
c2=2.0,
w=0.7,
min_velocity=-4,
max_velocity=4)
best = algo.run(task=task)
print(best[-1])
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.task import Task
from niapy.problems import Sphere
from niapy.algorithms.basic import DifferentialEvolution
# Storing improvements during the evolutionary cycle
task = Task(max_evals=10000, problem=Sphere(dimension=10))
algo = DifferentialEvolution(population_size=40, crossover_probability=0.9, differential_weight=0.5)
best = algo.run(task)
evals, x_f = task.convergence_data(x_axis='evals')
print(evals) # print function evaluations
print(x_f) # print values
def setUp(self):
self.D = 20
self.x, self.task = default_rng().uniform(-2, 2, self.D), Task(problem=MyProblem(self.D))
self.sol1, self.sol2, self.sol3 = MkeSolution(x=self.x, e=False), MkeSolution(task=self.task), MkeSolution(
x=self.x, e=False)
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import GreyWolfOptimizer
from niapy.task import Task
# we will run 10 repetitions of Grey Wolf Optimizer against Pinter problem
for i in range(10):
task = Task(problem='pinter', dimension=10, max_evals=1000)
algorithm = GreyWolfOptimizer(population_size=20)
best = algorithm.run(task)
print(best[-1])
# encoding=utf8
# This is temporary fix to import module from parent folder
# It will be removed when package is published on PyPI
import sys
sys.path.append('../')
# End of fix
from niapy.algorithms.basic import EvolutionStrategyMp1
from niapy.task import Task
from niapy.problems import Sphere
# we will run Differential Evolution for 5 independent runs
for i in range(5):
task = Task(problem=Sphere(dimension=10), max_evals=10000)
algo = EvolutionStrategyMp1()
best = algo.run(task)
print('%s -> %f' % (best[0], best[1]))
class TaskTestCase(TestCase):
r"""Test case for testing the Task class.
Date:
April 2019
Author:
Klemen Berkovič
See Also:
* :class:`niapy.util.Task`
"""
def setUp(self):
self.D, self.nFES, self.nGEN = 10, 10, 10
self.Lower, self.Upper = [2, 1, 1], [10, 10, 5]
self.task = Task(dimension=self.D,
lower=self.Lower,
upper=self.Upper,
problem='sphere',
max_evals=self.nFES,
max_iters=self.nGEN,
cutoff_value=0.0)
def test_dim_ok(self):
self.assertEqual(self.D, self.task.dimension)
self.assertEqual(self.D, self.task.dimension)
def test_lower(self):
self.assertTrue(
np.array_equal(full_array(self.Lower, self.D), self.task.lower))
self.assertTrue(
np.array_equal(full_array(self.Lower, self.D), self.task.lower))
def test_upper(self):
self.assertTrue(
np.array_equal(full_array(self.Upper, self.D), self.task.upper))
self.assertTrue(
np.array_equal(full_array(self.Upper, self.D), self.task.upper))
def test_range(self):
self.assertTrue(
np.array_equal(
full_array(self.Upper, self.D) -
full_array(self.Lower, self.D), self.task.range))
self.assertTrue(
np.array_equal(
full_array(self.Upper, self.D) -
full_array(self.Lower, self.D), self.task.range))
def test_max_iters(self):
self.assertEqual(self.nGEN, self.task.max_iters)
def test_max_evals(self):
self.assertEqual(self.nFES, self.task.max_evals)
def test_is_feasible(self):
x = np.full(self.D, 2)
self.assertTrue(self.task.is_feasible(x))
x = np.full(self.D, 3)
self.assertTrue(self.task.is_feasible(x))
x = default_rng().uniform(self.task.lower, self.task.upper, self.D)
self.assertTrue(self.task.is_feasible(x))
x = np.full(self.D, -20)
self.assertFalse(self.task.is_feasible(x))
x = np.full(self.D, 20)
self.assertFalse(self.task.is_feasible(x))
def test_next_iter(self):
for i in range(self.nGEN):
self.assertFalse(self.task.stopping_condition())
self.task.next_iter()
self.assertTrue(self.task.stopping_condition())
def test_stop_cond_iter(self):
for i in range(self.nGEN):
self.assertFalse(self.task.stopping_condition_iter(),
msg='Error at %s iteration!!!' % i)
self.assertTrue(self.task.stopping_condition_iter())
def test_eval(self):
x = np.ones(self.D)
for i in range(self.nFES):
self.assertAlmostEqual(self.task.eval(x),
self.D,
msg='Error at %s iteration!!!' % i)
self.assertTrue(self.task.stopping_condition())
def test_eval_over_max_evals(self):
x = np.ones(self.D)
for i in range(self.nFES):
self.task.eval(x)
self.assertEqual(np.inf, self.task.eval(x))
self.assertTrue(self.task.stopping_condition())
def test_eval_over_max_iters(self):
x = np.ones(self.D)
for i in range(self.nGEN):
self.task.next_iter()
self.assertEqual(np.inf, self.task.eval(x))
self.assertTrue(self.task.stopping_condition())
def test_evals_count(self):
x = np.ones(self.D)
for i in range(self.nFES):
self.task.eval(x)
self.assertEqual(self.task.evals, i + 1,
'Error at %s. evaluation' % (i + 1))
def test_iters_count(self):
for i in range(self.nGEN):
self.task.next_iter()
self.assertEqual(self.task.iters, i + 1,
'Error at %s. iteration' % (i + 1))
def test_stop_cond_evals(self):
x = np.ones(self.D)
for i in range(self.nFES - 1):
self.task.eval(x)
self.assertFalse(self.task.stopping_condition())
self.task.eval(x)
self.assertTrue(self.task.stopping_condition())
def test_stop_cond_iters(self):
for i in range(self.nGEN - 1):
self.task.next_iter()
self.assertFalse(self.task.stopping_condition())
self.task.next_iter()
self.assertTrue(self.task.stopping_condition())
def test_stop_cond_cutoff_value(self):
x = np.ones(self.D)
for i in range(self.nGEN - 5):
self.assertFalse(self.task.stopping_condition())
self.assertEqual(self.D, self.task.eval(x))
self.task.next_iter()
x = np.zeros(self.D)
self.assertEqual(0, self.task.eval(x))
self.assertTrue(self.task.stopping_condition())
self.assertEqual(self.nGEN - 5, self.task.iters)
def test_print_conv_one(self):
r1, r2 = [], []
for i in range(self.nFES):
x = np.full(self.D, 10 - i)
r1.append(i + 1), r2.append(self.task.eval(x))
t_r1, t_r2 = self.task.return_conv()
self.assertTrue(np.array_equal(r1, t_r1))
self.assertTrue(np.array_equal(r2, t_r2))
def test_print_conv_two(self):
r1, r2 = [], []
for i in range(self.nFES):
x = np.full(self.D, 10 - i if i not in (3, 4, 5) else 4)
r1.append(i + 1), r2.append(self.task.eval(x))
t_r1, t_r2 = self.task.return_conv()
self.assertTrue(np.array_equal(r2, t_r2))
self.assertTrue(np.array_equal(r1, t_r1))
