[FEAT]: send whole population (2D matrix) to obj func

[osamimi]

I am currently using scipy’s differential_evolution() which has the option (vectorized=True) to pass the n_variables * n_population_size matrix (in my case around 20 x 200) to the objective function once pee iteration . This allows me to vectorize the math (numba/numpy) and get very good performance, around 50ms per iteration. This ends up being faster than using multiprocessing and dispatching individual solution vectors to multiple cores due to the overheads involved (considering the relatively cheap cost function).

[thieu1995]

Hi @armisamimi,

Indeed, when using whole population to calculate fitness, it will faster like 10X or 100X than calculate each of the agent's fitness. However, it is for benchmark functions only. You can't do it with other problem, for example, training neural network, hybrid with machine learning, hyper-parameter tuning with AI models.
My library is built for general optimization problem, it means you can solve any optimization problem with it, it is not only for benchmark functions. I don't want to limit the usage of this library, that is why I did not choose the way to calculate obj_function like that in the first place.

Also what you did is really wrong, you should not using multiprocessing for benchmark function, the time to start or close a sub-process is longer than the time to run a single obj_function. Therefore, you should use multithreading for benchmark functions. It will be much faster than multiprocessing in this case.

[osamimi]

I have to disagree with your points. - My objective is not a benchmark function. It’s a real world design problem that happens to involve a lot of math that can be vectorized. There are plenty of other real optimization problems out there like that. - Real multi-threading for CPU bound problems is not possible in python due to the global interpreter lock. There is a 3.13 beta that removes this restriction but most packages are not compatible yet. - I don’t spawn new peocesses every time the vectorized object function is evaluated. The executer pool is created once with M processes prior to calling the optimizer and the handle is passed to the object function along with the N trial candidates. Inside the fun I submit N / M vectors to each of M processes in the pool, gathers the results, and returns the N costs. There is some overhead due to serialization and deserialization of objects between processes. But for cost functions that take more than 20ms or so it already becomes worth it.

[thieu1995]

Maybe you don't understand what I'm saying here. Metaheuristic algorithms are simple and fast; most of the computational cost comes from the fitness function. If you design a good and efficient fitness function, your metaheuristic algorithm will also run very quickly. As you mentioned above, your fitness function involves a lot of math and can be vectorized, but that's your specific case, it's not an inherent issue of metaheuristics. Also, if your fitness function only takes 20–50 milliseconds per evaluation, then what's the point of using multithreading or multiprocessing? Just use the normal, single-threaded approach, there's no need to parallelize.

The benchmark functions I mentioned are problems that take a very short amount of time to evaluate, 1 second, 10 seconds, or at most 1 minute. On the other hand, the problems I referred to earlier, like training neural networks or optimizing hyperparameters of machine learning models, usually take much longer, 2 minutes, 5 minutes, or even 1 hour per evaluation. In those cases, it's reasonable to use multithreading or multiprocessing to speed up the process.