CODEWITHSUNDEEP
pythonoptimizationparallel-processingpygmo
gondo
gondo

Reputation: 37

Pygmo2: migration between islands in an archipelago during evolution

I'm trying to use the Python library Pygmo2 (https://esa.github.io/pagmo2/index.html) to parallelize an optimization problem.

To my understanding, parallelization can be achieved with an archipelago of islands (in this case, mp_island).

As a minimal working example, one of the tutorials from the official site can serve: https://esa.github.io/pagmo2/docs/python/tutorials/using_archipelago.html

I extracted the code:

class toy_problem:
    def __init__(self, dim):
        self.dim = dim

    def fitness(self, x):
        return [sum(x), 1 - sum(x*x), - sum(x)]

    def gradient(self, x):
        return pg.estimate_gradient(lambda x: self.fitness(x), x)

    def get_nec(self):
        return 1

    def get_nic(self):
        return 1

    def get_bounds(self):
        return ([-1] * self.dim, [1] * self.dim)

    def get_name(self):
        return "A toy problem"

    def get_extra_info(self):
        return "\tDimensions: " + str(self.dim)

import pygmo as pg
a_cstrs_sa = pg.algorithm(pg.cstrs_self_adaptive(iters=1000))
p_toy = pg.problem(toy_problem(50))
p_toy.c_tol = [1e-4, 1e-4]
archi = pg.archipelago(n=32,algo=a_cstrs_sa, prob=p_toy, pop_size=70)

print(archi)
archi.evolve()
print(archi)

Looking at the documentation of the old version of the library (http://esa.github.io/pygmo/documentation/migration.html), migration between islands seems to be an essential feature of the island parallelization model. Also, to my understanding, optimization algorithms like evolutionary algorithms could not work without it.

However, in the documentation of Pygmo2, I can nowhere find how to perform migration.

Is it happening automatically in an archipelago?

Does it depend on the selected algorithm?

Is it not yet implemented in Pygmo2?

Is the documentation on this yet missing or did I just not find it?

Can somebody enlighten me?

Upvotes: 3

Views: 909

Answers (3)

Dario Izzo
Dario Izzo

Reputation: 310

pagmo2 is now implementing migration since v2.11, the PR has benn completed and merged into master. Almost all capabilities present in pagmo1.x are restored. We will still add more topologies in the future, but they can already be implemented manually. Refer to docs here: https://esa.github.io/pagmo2/docs/cpp/cpp_docs.html

Tutorial and example are missing and will be added in the near future (help is welcome)

Upvotes: 1

user3666197
user3666197

Reputation: 1

IMHO, the PyGMO2/pagmo documentation is confirming the migration feature to be present.

The archipelago class is the main parallelization engine of pygmo. It essentially is a container of island able to initiate evolution (optimization tasks) in each island asynchronously while keeping track of the results and of the information exchange (migration) between the tasks ...

With an exception of thread_island-s ( where some automated inference may take place and enforce 'em for thread-safe UDI-s ), all other island types - { mp_island | ipyparallel_island }-s do create a GIL-independent form of a parallelism, yet the computing is performed via an async-operated .evolve() method

In original PyGMO, the archipelago class was auto .__init__()-ed with attribute topology = unconnected(), unless specified explicitly, as documented in PyGMO, having a tuple of call-interfaces for archipelago.__init__() method ( showing just the matching one ):

 __init__( <PyGMO.algorithm> algo,
           <PyGMO.problem>   prob,
           <int>             n_isl,
           <int>             n_ind [, topology            = unconnected(),
                                      distribution_type   = point_to_point,
                                      migration_direction = destination
                                      ]
           )

But, adding that, one may redefine the default, so as to meet one's PyGMO evolutionary process preferences:

topo = topology.erdos_renyi( nodes = 100,
                             p     = 0.03
                             )              # Erdos-Renyi ( random ) topology

enter image description here

or
set a Clustered Barabási-Albert, with ageing vertices graph topology:

topo = topology.clustered_ba( m0    =    3,
                              m     =    3,
                              p     =    0.5,
                              a     = 1000,
                              nodes =    0
                              )            # clustered Barabasi-Albert,
   #                                       # with Ageing vertices topology

enter image description here

or:

topo = topology.watts_strogatz( nodes = 100,
                                p     =   0.1
                                )             # Watts-Strogatz ( circle
                                              #                + links ) topology

enter image description here

and finally, set it by assignment into the class-instance attribute:

archi = pg.archipelago( n        = 32,
                        algo     = a_cstrs_sa,
                        prob     = p_toy,
                        pop_size = 70
                        )              # constructs an archipelago
archi.topology = topo                  # sets the topology to the
#                                      # above selected, pre-defined <topo>

Upvotes: 0

bluescarni
bluescarni

Reputation: 3997

The migration framework has not been fully ported from pagmo1 to pagmo2 yet. There is a long-standing PR open here:

https://github.com/esa/pagmo2/pull/102

We will complete the implementation of the migration framework in the next few months, hopefully by the beginning of the summer.

Upvotes: 0

Related Questions