Hi everyone!

During the build of NiaPy rpm package, pytest reported several deprecation warnings.

I am attaching a partial report created by pytest.

=============================== warnings summary =============================== NiaPy/tests/test_aso.py::ASOElitismTestCase::test_custom_works_fine NiaPy/tests/test_aso.py::ASOElitismTestCase::test_griewank_works_fine NiaPy/tests/test_fa.py::FATestCase::test_griewank_works_fine NiaPy/tests/test_fa.py::FATestCase::test_works_fine NiaPy/tests/test_jade.py::CrossRandCurr2pbestTestCase::test_function_fine /usr/lib/python3.9/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray return array(a, dtype, copy=False, order=order) NiaPy/tests/test_es.py: 16660 warnings /builddir/build/BUILD/NiaPy-2.0.0rc13/NiaPy/algorithms/basic/es.py:329: DeprecationWarning: elementwise comparison failed; this will raise an error in the future. if e not in c: k += 1 NiaPy/tests/test_jade.py: 200 warnings /usr/lib/python3.9/site-packages/numpy/core/numeric.py:2378: DeprecationWarning: elementwise comparison failed; this will raise an error in the future. return bool(asarray(a1 == a2).all()) -- Docs: https://docs.pytest.org/en/stable/warnings.html

Is there a possibility to set an initial population manually or define a function which generates an individual from scratch?

I guess it would be modifying NiaPy.algorithms.Individual.generateSolution, but should only replace it for the initial solution candidates. Has anyone tried this?

My problem is binary but feasible candidates have a high 0 : 1 ratio, i suspect random initialization generates roughly the same amounts of 0 and 1 (rounded from float).

I added 2 files ('loa.py', 'run_loa.py'). An implementation of lion optimization algorithm and an example of how to run it. Algorithm steps and formulas are found in an article found on (https://doi.org/10.1016/j.jcde.2015.06.003).

First I created a 'Lion' class that inherits from 'Individual'. Lions are distributed into groups called prides and a group called nomad lions.

Steps of algorithm and progress so far:

• Hunting: Completed.
• Moving towards safe place: completed.
• Roaming: For pride lions is completed, for nomad lions is completed.
• Mating: Creating new pride offspring is completed, mutation on the pride offspring is completed. Creating new nomad offspring is completed, mutation on the nomad offspring is completed.
• Defense: Attacking amongst males in prides is completed, nomad lions attacking the prides is completed
• Migration: Completed
• Population equilibrium: Completed

Function that checks if lion's position has improved since last iteration ('data_correction') is also completed.

Main function ('run_iteration') is also completed.

This is prescriptive and optional, but I personally find this very important. Please follow PEP8 as a prescriptive guide.

• Methods usually have lower-case characters separated by underscores. TournamentSelection should be tournament_selection. Check this.
• The package name should be in lower-case. NiaPy should be niapy. Check this.

This is an issue related to openjournals/joss-reviews#613

Hi,

Thank you very much for your hard working to create the NiaPy which is potential to improve much my research :-))))

Could you please explain the differences between the parameter max_evals and max_iters in the task? And how can I control them? I tried to minimize the mean square error during the feature selection using Firefly Algorithm and CatBoost Regressor. However, when I set the max_evals = 10 as follows: task = Task(problem, max_evals=10, optimization_type=OptimizationType.MINIMIZATION, enable_logging=True) it only ran 5 evaluations:

INFO:niapy.task.Task:evals:1 => 446.13928695170216
INFO:niapy.task.Task:evals:5 => 433.54774275563943
Number of selected features: 21

or set the max_iters = 10 as follows: task = Task(problem, max_iters=10, optimization_type=OptimizationType.MINIMIZATION, enable_logging=True) it ran 2423 evaluations:

INFO:niapy.task.Task:evals:1 => 446.13928695170216
INFO:niapy.task.Task:evals:5 => 433.54774275563943
INFO:niapy.task.Task:evals:11 => 428.94143771504224
INFO:niapy.task.Task:evals:20 => 422.539381286218
INFO:niapy.task.Task:evals:28 => 412.32678534520574
INFO:niapy.task.Task:evals:30 => 412.07734133808253
INFO:niapy.task.Task:evals:109 => 411.98004342657293
INFO:niapy.task.Task:evals:139 => 400.99684114079884
INFO:niapy.task.Task:evals:442 => 393.40534326526745
INFO:niapy.task.Task:evals:1900 => 393.07398868489685
INFO:niapy.task.Task:evals:2423 => 378.8922834335721
Number of selected features: 22

It seems a stopping criteria was set and the algorithm only stopped when it reached to this criteria. Is it correct? And should I use the parameter max_evals or max_iters in case of my problem?

Many thanks, Thang

Thank you for your work first. Could you tell me is there a method to plot the convergence with x axis is iteration numbers and y is the fitness function values?

Summary

• Added python3.9 to integration tests
• Renamed package to lowercase i. e. 'niapy'
• Changed indentation to 4 spaces instead of tabs
• Renamed variables and methods to snake case.
• Fixed typos in docstrings.
• Added missing docstrings and completed incomplete ones.
• Temporarily removed (commented out) algorithms that weren't implemented or weren't working.
• Renamed most of the algorithm parameters to names I think make sense.
• Moved the initialization of algorithm parameters to the init method.
• Removed type_parameters method from all algorithms and all the test cases for it.
• Removed niapy.algorithms.statistics module as I don't think it's particularly useful.
• Removed the utility classes in niapy.task.utility and niapy.algorithms.utility and replaced them with factory functions get_algorithm and get_benchmark in niapy.util.factory.
• Made the task package into a module, since the package only contained one file (task.py) along with init.py.
• Fixed issues #306, #294, #281, #264, #123

Remaining problems:

• I did not apply the code style changes and rules to tests.
• I'm sure I missed some docstrings.
• A lot of algorithms are missing reference papers,
• All algorithms need to be checked if they're implemented correctly, I went through the reference papers for most of them and I think most are correct, I'm not sure about CRO, Krill Herd, and CrowdingDE.
• There are some warnings when building the docs. Also things like the optimization tasks are missing in the docs. I don't know how to add them.
• I'm sure a lot of performance could be gained by using numpy more efficiently, although performance isn't really the main goal of this project, so it's not a problem really.

I'm sorry it took so long :sweat_smile:

Two tests are failing:

• test_Custom_works_fine
• test_griewank_works_fine

More info:

https://src.fedoraproject.org/rpms/python-niapy/blob/master/f/python-niapy.spec#_86

Hello,

I'm struggling about two things recently. First is that I cannot order to stop optimization if the best solution achieves a minimum/maximum value. The stop condition only depends on the function evaluation or generation count.

The other thing is that I want to see the error decreasing over iterations. Since we are not storing the best values in the algorithm, we cannot do this currently.

Is there anything that I'm not aware of, achieves these? I would like to help if these might be added to the library, but with a guidance, since I'm not sure of how big the impact would be.

Thanks as always.

Hi!

OptimizationType.MAXIMIZATION does not work when used, I tried it with GWO but it seems to be buggy also with other algorithms.

Steps to reproduce

requirements.txt

NiaPy==2.0.0rc5

Code - taken from here, changed only the optimization type

# 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 GreyWolfOptimizer
from NiaPy.task import StoppingTask, OptimizationType
from NiaPy.benchmarks import Sphere

# we will run Grey Wolf Optimizer for 5 independent runs
for i in range(5):
    task = StoppingTask(D=10, nFES=10000, optType=OptimizationType.MAXIMIZATION, benchmark=Sphere())
    algo = GreyWolfOptimizer(NP=40)
    best = algo.run(task)
    print(best)

Expected behavior

It should not throw any error.

Actual behavior

TypeError                                 Traceback (most recent call last)
<ipython-input-11-bed1e1b95f2d> in <module>
     14     task = StoppingTask(D=10, nFES=10000, optType=OptimizationType.MAXIMIZATION, benchmark=Sphere())
     15     algo = GreyWolfOptimizer(NP=40)
---> 16     best = algo.run(task)
     17     print(best)

/opt/conda/lib/python3.7/site-packages/NiaPy/algorithms/algorithm.py in run(self, task)
    346         try:
    347             # task.start()
--> 348             r = self.runTask(task)
    349             return r[0], r[1] * task.optType.value
    350         except (FesException, GenException, TimeException, RefException):

/opt/conda/lib/python3.7/site-packages/NiaPy/algorithms/algorithm.py in runTask(self, task)
    326         algo, xb, fxb = self.runYield(task), None, inf
    327         while not task.stopCond():
--> 328             xb, fxb = next(algo)
    329             task.nextIter()
    330         return xb, fxb

/opt/conda/lib/python3.7/site-packages/NiaPy/algorithms/algorithm.py in runYield(self, task)
    306         yield xb, fxb
    307         while True:
--> 308             pop, fpop, dparams = self.runIteration(task, pop, fpop, xb, fxb, **dparams)
    309             xb, fxb = self.getBest(pop, fpop, xb, fxb)
    310             yield xb, fxb

/opt/conda/lib/python3.7/site-packages/NiaPy/algorithms/basic/gwo.py in runIteration(self, task, pop, fpop, xb, fxb, A, A_f, B, B_f, D, D_f, **dparams)
    109                 for i, w in enumerate(pop):
    110                         A1, C1 = 2 * a * self.rand(task.D) - a, 2 * self.rand(task.D)
--> 111                         X1 = A - A1 * fabs(C1 * A - w)
    112                         A2, C2 = 2 * a * self.rand(task.D) - a, 2 * self.rand(task.D)
    113                         X2 = B - A2 * fabs(C2 * B - w)

TypeError: unsupported operand type(s) for *: 'float' and 'NoneType'

System configuration

Using docker jupyter/scipy-notebook.

Hi,

I tried your example of Flower Pollination Algorithm code, but i got an error like this :

     11 for i in range(5):
     12     task = StoppingTask(D=10, nFES=10000, benchmark=Sphere())
---> 13     algo = FlowerPollinationAlgorithm(NP=20, p=0.5)
     14     best = algo.run(task=algo)
     15     print(best)

TypeError: __init__() missing 3 required positional arguments: 'D', 'nFES', and 'benchmark'

Here's the code :

# 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

import random
from NiaPy.algorithms.basic import FlowerPollinationAlgorithm
from NiaPy.task import StoppingTask
from NiaPy.benchmarks import Sphere

#we will run Flower Pollination Algorithm for 5 independent runs
for i in range(5):
    task = StoppingTask(D=10, nFES=10000, benchmark=Sphere())
    algo = FlowerPollinationAlgorithm(NP=20, p=0.5)
    best = algo.run(task=algo)
    print(best)

Hope you can help, thanks!

Hi I used several Optimization Algorithms. RUN Algorithm outperformed most of them. Please add it to NiaPy's Algorithms. Here is the link: https://github.com/aliasgharheidaricom/RUN-Beyond-the-Metaphor-An-Efficient-Optimization-Algorithm-Based-on-Runge-Kutta-Method

Summary

Squirrel Search Algorithm implementation under ssa.py. The code does not have any bugs but the algorithms accuracy needs to be checked. Open Issue #338

Squirrel search algorithm publication is currently the most cited article in SWEVO.

It would be nice to have this algorithm in our collection.

Has anyone time to implement this algorithm?

NiaPy problems which consist of benchmark functions offer an excellent way of benchmarking nature-inspired algorithms quickly. However, many researchers now prefer to evaluate their algorithms also on real-world optimization (e.g. engineering) problems.

Thus, I recommend a new feature which involves the implementations of some popular engineering problems as for example:

• Welded beam design,
• Pressure vessel design,
• Speed reducer design, etc.

Some of these are presented in detail in following paper (Appendix): http://www.informatica.si/index.php/informatica/article/viewFile/204/201

Many of engineering problems are constrained in its nature. Is it possible to add some of the constraints-handling mechanisms in NiaPy?

GWO has individuals in the type of ndarray, while other algorithms have individuals of type of NiaPy.algorithms.algorithm.Individual.

This is revealed when the runIteration returns the results: pop of GWO is the array of ndarrays and others return array of Individual.