The code snippet below does not produce a plot when using ssh on a linux computer:

import neorl.benchmarks
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 100)
y = x**2

plt.plot(x, y)
plt.show()

These two code snippets do produce the plot:

import neorl
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 100)
y = x**2

plt.plot(x, y)
plt.show()

import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 100)
y = x**2

plt.plot(x, y)
plt.show()
import neorl.benchmarks

joblib does not conserve the global variables during multi-processing. In my environment, I utilized some. As a workaround, I used pathos, which seemed to not have any issue. See for instance within ES:
core_list=[]
for key in pop:
core_list.append(pop[key][0])

        #with joblib.Parallel(n_jobs=self.ncores) as parallel:
        #    fitness=parallel(joblib.delayed(self.fit_worker)(item) for item in core_list)
        try:
            with joblib.Parallel(n_jobs=self.ncores) as parallel:#, prefer="threads" , require='sharedmem'
                fitness=parallel(joblib.delayed(self.fit_worker)(item) for item in core_list)
        except:
            p=pathos.multiprocessing.Pool(processes = self.ncores)
            fitness = p.map(self.fit_worker, core_list)
            p.close()
            p.join()  

However, after some number of samples generated (it could be 10,000 as it could be 30,000), the optimization stops running without throwing errors. It happened with ES, SA, TS and multi-objective variants I implemented.

My workaround right now is to re-initialize all global variables before each candidate evaluation, but it eats some computing time.

I encountered this error:

When looking at the code for neorl/evolu/pso.py

It looks like on lines 366 and 367, the population solutions are sorted and then the best is assigned to self.swm_pos. Then, in line 253 of self.UpdateParticle, this self.swm_pos is used for some kind of division.

I think the problem is that if the best member perfectly hits that 0.00000 a divide by zero error is encountered. I am honestly not sure if this is correct.

In example 5, in the first code snippet:
import neorl.benchmarks.cec17 as functions

needs to be
import neorl.benchmarks.cec17 as all_functions

I think

Aranha, C., Camacho Villalón, C.L., Campelo, F., Dorigo, M., Ruiz, R., Sevaux, M., Sörensen, K. and Stützle, T., 2022. Metaphor-based metaheuristics, a call for action: The elephant in the room. Swarm Intelligence, 16(1), pp.1-6.

When ncores is set to more than one, then the logo 'NEORL' will show three times rather than only once.

For Evolutionary Strategies, in the online documentation notes section, one bullet says "Total number of cost evaluations for ES is npop * ngen.".

This is incorrect, it should read "Total number of cost evaluations for ES is lambda*(ngen+1).".

I have a large optimization problem I'd like to run and it should be parallelizable. I started testing with ex2_ackerly and increased ncores to any number > 1. My CPU has plenty of threads, so this shouldn't be an issue.

However, it seems like there is a huge overhead penalty when running cases in parallel. Increasing to four threads resulted in nearly 4x runtime.

Are you aware of this problem? It seems to defeat the purpose of parallelization. Could you provide an example when parallelization helps?

Problem with discrete testing: Originally posted by @mradaideh in #31 (comment)

For Random Search, Bayesian Search and Evolutionary search, parameter descriptions are missing in the online documentation.

On line 106 and 107 of neorl/evolu/mfo.py, there are print statements that cannot be suppressed with verbosity = False. I feel that these should be suppressible.

I am not sure what the purpose of this script but it is throwing in stray print on some imports.

In neorl/neorl/evolu/hho.py, line 44: " :param nhawks: (int): number of the grey wolves in the group". Should be number of hawks in the group.

Hello, I followed the instructions in the readthedocs,

> conda create --name neorl python=3.7
> conda activate neorl
> pip install neorl

and got the following error during neorl --test:

Traceback (most recent call last):
  File "/Users/4ib/anaconda3/envs/neorl/bin/neorl", line 5, in <module>
    from neorl.scripts import main
  File "/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/neorl/scripts.py", line 42, in <module>
    from neorl.tune.runners.gridtune import GRIDTUNE
  File "/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/neorl/tune/__init__.py", line 2, in <module>
    from neorl.tune.bayestune import BAYESTUNE
  File "/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/neorl/tune/bayestune.py", line 30, in <module>
    from skopt import gp_minimize
  File "/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/skopt/__init__.py", line 55, in <module>
    from .searchcv import BayesSearchCV
  File "/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/skopt/searchcv.py", line 16, in <module>
    from sklearn.utils.fixes import MaskedArray
ImportError: cannot import name 'MaskedArray' from 'sklearn.utils.fixes' (/Users/4ib/anaconda3/envs/neorl/lib/python3.7/site-packages/sklearn/utils/fixes.py)

Seemed like it was a scikit-learn version problem:

Output of conda list:

scikit-learn              1.0.1                    pypi_0    pypi
scikit-optimize           0.8.1                    pypi_0    pypi

so I downgraded scikit-learn:

conda install scikit-learn=0.24.2

and now all the tests pass.

I'm not sure if this is an issue so feel free to close it, but I thought this might help someone :)

In third bullet point in "notes" section of SSA, the equation is missing a squared in the exponent:
Currently:
2e^{-4g/ngen}

It should be
2e^{-(4g/ngen)^2}

Hello, thank you for your code. I was inspired by it and attempted to use the PPOES algorithm to solve the Flexible Job Shop Scheduling Problem with Transportation (FJSP-T). However, I encountered an issue with defining the boundaries.

In the FJSP-T problem, the schedule sequence is represented by a string like [1, 2, 1, 2], where the numbers 1 and 2 represent job IDs. The first 1 represents the first operation of the first job, and the second 1 represents the second operation of the first job. During the iterations, the number of 1s and 2s in the schedule sequence must remain unchanged.

How can such boundaries be defined in NEORL? Which part of the code should I refer to?🌹

Hi Majdi, after installing neorl1.6, if I input neorl for a test, an error will occur show that sklearn has not MaskedArray.

Traceback (most recent call last):
File "/usr/local/bin/neorl", line 5, in
from neorl.scripts import main
File "/usr/local/lib/python3.7/dist-packages/neorl/scripts.py", line 42, in
from neorl.tune.runners.gridtune import GRIDTUNE
File "/usr/local/lib/python3.7/dist-packages/neorl/tune/init.py", line 2, in
from neorl.tune.bayestune import BAYESTUNE
File "/usr/local/lib/python3.7/dist-packages/neorl/tune/bayestune.py", line 30, in
from skopt import gp_minimize
File "/root/.local/lib/python3.7/site-packages/skopt/init.py", line 55, in
from .searchcv import BayesSearchCV
File "/root/.local/lib/python3.7/site-packages/skopt/searchcv.py", line 16, in
from sklearn.utils.fixes import MaskedArray
ImportError: cannot import name 'MaskedArray' from 'sklearn.utils.fixes' (/root/.local/lib/python3.7/site-packages/sklearn/utils/fixes.py)

The reason is that the sklearn was installed a version of 1.0 in default. A solution to this issue is to downgrade the sklearn version to 0.24.2:
pip install scikit-learn==0.24.2
It will be good to set sklearn to 0.24.2 in requirement.txt.

In at least WOA, the seed is being set with:

if seed:  
    random.seed(seed) 
    np.random.seed(seed)

if the user chooses the seed to be 0, no seed will be set. I feel that this is unexpected behavior.

when using ES, hist['last_pop'] ends with the number of individuals equal to mu. I believe the number of individuals should be equal to lambda. See minimal working example here:

import numpy as np
import matplotlib.pyplot as plt

from neorl import ES
from math import exp, sqrt, cos, pi
np.random.seed(50)

#---------------------------------
# Fitness function
#---------------------------------
def ACKLEY(individual):
    #Ackley objective function.
    d = len(individual)
    f=20 - 20 * exp(-0.2*sqrt(1.0/d * sum(x**2 for x in individual))) \
            + exp(1) - exp(1.0/d * sum(cos(2*pi*x) for x in individual))
    return f

 24 #---------------------------------
# Parameter Space
#---------------------------------
#Setup the parameter space (d=8)
d=3
lb=-32
ub=32
BOUNDS={}
for i in range(1,d+1):
    BOUNDS['x'+str(i)]=['float', lb, ub]

#---------------------------------
# ES
#---------------------------------
es = ES(mode='min', fit=ACKLEY, bounds=BOUNDS, lambda_ = 12, mu = 6)
x_best, y_best, hist=es.evolute(120)
print(hist["last_pop"])

There is a debug statement which prints even when verbose = 0 in GWO which reads:

'--debug: grid parameter type is found in the space'

I believe this should either be removed or only included if verbose is true.

Currently, GWO, WOA and PESA2 print a lot of information to stdout by default. Consider changing this to be consistent with the other algorithms.

Many algorithms may require multiple identical evaluations of the objective functions due to members of a population remaining the same between generations. Consider looking into automatic cacheing of objective function calls. See here for an example.

When a PSO optimization search is initialized with .evolute and a x0 option is supplied to initialize the population, a message is printed to the screen reading:

The first particle provided by the user: [0.11819554538464994, -0.3116788303975989]
The last particle provided by the user: [0.1007965766526148, -3.3361796084992505]

I feel that this print statement should be suppressed when the used selects the verbose=False option in the initialization of the class.

This post is for users who may encounter:
-bash: fork: retry: Resource temporarily unavailable
or
Segmentation fault (core dumped) nohup python de_expl.py
errors.

On linux computers, users often have a maximum number of processes they are allowed to have running on a computer. This can be checked with the ulimit -a command under the max user processes row. For example:

>> ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 1028858
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

A user can check how many processes (in total) they have running with the command: ps --no-headers auxwwwm | awk '$2 == "-" { print $1 }' | sort | uniq -c | sort -n. If a user wants to see the specific listing: ps --no-headers auxwwwm.

A typical Python program may start <50 processes. I am not exactly sure why this is the case but I checked a few different random scripts I had lying around and this is the conclusion I came to.

For some reason, when running NEORL in serial, around 300 processes are started. I think this has something to do with parallelization. Most of the processes are sleeping, for whatever reason.

This becomes a problem if a user wants to run multiple independent python programs which use NEORL. Regardless of computer size, the process limit is quickly reached. A fix to this is to simply raise the max number of user processes: ulimit -u ####. But this cannot be done without sudo access.

I do not think this is an urgent problem for NEORL as it only comes up in a specific use case but I wanted to post this to provide information to users who encounter the same problem.

Possibly relevant links:
https://stackoverflow.com/questions/20614309/find-reason-for-sleeping-python-process
https://stackoverflow.com/questions/31193449/python-multiprocessing-big-data-turn-process-into-sleep
https://stackoverflow.com/questions/1032813/dump-stacktraces-of-all-active-threads/7317379#7317379