Class solver::Murex

Multi-Objective Replica Exchange "murex".

This solver implements a replica exchange approach whereby, in addition to the variables ("spins"), the parameters are at different quenched values at every node. As a result, the method explores the lowest cost value that can be achieved at different "mixing rates" of the parameters. The (currently hard-coded) arrangement of the nodes is in a triangle such that the temperature of nodes in each diagonal agrees, while the parameters x and y are swept from (1,0) to (0,1) in equal steps. position weights 5 j ( 0, 1) 2 4 ↖ ( 0, 1) (.5,.5) 0 1 3 (.5,.5) ( 1, 0) ( 1, 0) → i This setup is intended to analyze the effect of a multi-objective model with different weights assigned to each objective:

 \mathcal{H} = -x\mathcal{H}_x(\vec{s}) -y\mathcal{H}_y(\vec{s})

Replica exchanges happen between neighboring nodes (vertically and horizontally) and take place at a rate which take into consideration that the cost of the swapped states are modified by virtue of being placed at a new node (and, thus, new set of parameters).

Note

The solver requires the model being simulated to support parameters and have exactly two parameters (which are selected as x and y). They do not necessarily need to split the cost function as described. [At the time of this writing, only "poly" supports this].

Inheritance
solver::SteppingSolver
solver::Murex
Inherited Members
run

Constructors

Murex()

Declaration
solver::Murex<Model_T>::Murex()

Murex()

Declaration
solver::Murex<Model_T>::Murex(const Murex&)=delete

Methods

operator=()

Declaration
Murex&solver::Murex<Model_T>::operator=(const Murex&)=delete

get_identifier()

Get the identifier of this solver. This identifier is denoted as the target in the request.

Declaration
std::string solver::Murex<Model_T>::get_identifier() const override

init_memory_check_error_message()

Declaration
std::string solver::Murex<Model_T>::init_memory_check_error_message() const override

target_number_of_states()

Declaration
size_t solver::Murex<Model_T>::target_number_of_states() const override

init()

Initialize the solver.

Initialization entails creating the graph of nodes and initializing a replica (a metropolis walker containing a state) at each node. The set of nodes is currently hard coded do consist of nT diagonals with 1..nT nodes, respectively. Each of them is assigned a set of mixing weights such that the starting point (on the x axis) is [1,0] and the end point on the y axis is [0,1], with linear interpolation of the mixing weights in between: position weights 5 j ( 0, 1) 2 4 ↖ ( 0, 1) (.5,.5) 0 1 3 (.5,.5) ( 1, 0) ( 1, 0) → i The temperature is highest in the lower left corner and decreases by one temperature step until the lowest on the furthest diagonal. We use the i index to refer to the diagonal and the j index for the position on that diagnoal. As such, the results for the pareto front are found on the last nT nodes in the node list, which represent the diagonal at i=nT-1, j=[0..nT].

Declaration
void solver::Murex<Model_T>::init() override

make_step()

Make a step.

A step constitutes performing individual metropolis updates on the nodes, followed by measurements and replica exchange moves. We update exchange moves from even (odd) diagonals in even (odd) steps and switch the direction every 2 steps.

Declaration
void solver::Murex<Model_T>::make_step(uint64_t step) override

get_solutions()

Return the solutions found.

As the solution we return the lowest_cost found in the furthest diagonal (i.e., at lowest temperature) and the states corresponding to this lowest cost.

Declaration
utils::Structure solver::Murex<Model_T>::get_solutions() const override

configure()

Check the identifier and version against the configuraiton.

Declaration
void solver::Murex<Model_T>::configure(const utils::Json&json) override