# macop.algorithms.multi — macop v1.0.5 documentation

# macop.algorithms.multi

Multi-objetive classes algorithm

Classes

`MOEAD`(mu, T, initializer, evaluator, …[, …]) | Multi-Ojective Evolutionary Algorithm with Scalar Decomposition
`MOSubProblem`(index, weights, initalizer, …) | Specific MO sub problem used into MOEAD

class `macop.algorithms.multi.``MOEAD`(mu, T, initializer, evaluator, operators, policy, validator, maximise=True, parent=None, verbose=True)

  Multi-Ojective Evolutionary Algorithm with Scalar Decomposition

  `mu`

    {int} – number of sub problems

  `T`

    {[float]} – number of neightbors for each sub problem

  `nObjectives`

    {int} – number of objectives (based of number evaluator)

  `initializer`

    {function} – basic function strategy to initialize solution

  `evaluator`

    {[function]} – list of basic function in order to obtained fitness (multiple objectives)

  `operators`

    {[Operator]} – list of operator to use when launching algorithm

  `policy`

    {Policy} – Policy class implementation strategy to select operators

  `validator`

    {function} – basic function to check if solution is valid or not under some constraints

  `maximise`

    {bool} – specify kind of optimisation problem

  `verbose`

    {bool} – verbose or not information about the algorithm

  `population`

    [{Solution}] – population of solution, one for each sub problem

  `pfPop`

    [{Solution}] – pareto front population

  `weights`

    [[{float}]] – random weights used for custom mu sub problems

  `callbacks`

    {[Callback]} – list of Callback class implementation to do some instructions every number of evaluations and load when initializing algorithm

      >>> import random
      >>> # operators import
      >>> from macop.operators.discrete.crossovers import SimpleCrossover
      >>> from macop.operators.discrete.mutators import SimpleMutation
      >>> # policy import
      >>> from macop.policies.classicals import RandomPolicy
      >>> # solution and algorithm
      >>> from macop.solutions.discrete import BinarySolution
      >>> from macop.algorithms.multi import MOEAD
      >>> # evaluator import
      >>> from macop.evaluators.discrete.mono import KnapsackEvaluator
      >>> # evaluator initialization (worths objects passed into data)
      >>> problem_size = 20
      >>> worths1 = [ random.randint(0, 20) for i in range(problem_size) ]
      >>> evaluator1 = KnapsackEvaluator(data={'worths': worths1})
      >>> worths2 = [ random.randint(10, 15) for i in range(problem_size) ]
      >>> evaluator2 = KnapsackEvaluator(data={'worths': worths2})
      >>> # validator specification (based on weights of each objects)
      >>> weights = [ random.randint(5, 30) for i in range(problem_size) ]
      >>> validator = lambda solution: True if sum([weights[i] for i, value in enumerate(solution._data) if value == 1]) < 200 else False
      >>> # initializer function with lambda function
      >>> initializer = lambda x=20: BinarySolution.random(x, validator)
      >>> # operators list with crossover and mutation
      >>> operators = [SimpleCrossover(), SimpleMutation()]
      >>> policy = RandomPolicy(operators)
      >>> # MOEAD use multi-objective, hence list of evaluators with mu=100 and T=10
      >>> algo = MOEAD(20, 5, initializer, [evaluator1, evaluator2], operators, policy, validator, maximise=True, verbose=False)
      >>> # run the algorithm and get the pareto front obtained
      >>> pf_solutions = algo.run(100)
      >>> # check size of expected pareto
      >>> len(pf_solutions)
      33

  `end`()

    Display end message into run method

  `initRun`()

    Method which initialiazes or re-initializes the whole algorithm context specifically for MOEAD

  `progress`()

    Log progress and apply callbacks if necessary

  `run`(evaluations)

    Run the local search algorithm

    Parameters

      evaluations – {int} – number of Local search evaluations

    Returns

      {Solution} – best solution found

class `macop.algorithms.multi.``MOSubProblem`(index, weights, initalizer, evaluator, operators, policy, validator, maximise=True, parent=None, verbose=True)

  Specific MO sub problem used into MOEAD

  `index`

    {int} – sub problem index

  `weights`

    {[float]} – sub problems objectives weights

  `initalizer`

    {function} – basic function strategy to initialize solution

  `evaluator`

    {function} – basic function in order to obtained fitness (mono or multiple objectives)

  `operators`

    {[Operator]} – list of operator to use when launching algorithm

  `policy`

    {Policy} – Policy class implementation strategy to select operators

  `validator`

    {function} – basic function to check if solution is valid or not under some constraints

  `maximise`

    {bool} – specify kind of optimisation problem

  `verbose`

    {bool} – verbose or not information about the algorithm

  `currentSolution`

    {Solution} – current solution managed for current evaluation

  `bestSolution`

    {Solution} – best solution found so far during running algorithm

  `callbacks`

    {[Callback]} – list of Callback class implementation to do some instructions every number of evaluations and load when initializing algorithm

  Example:

      >>> import random
      >>> # operators import
      >>> from macop.operators.discrete.crossovers import SimpleCrossover
      >>> from macop.operators.discrete.mutators import SimpleMutation
      >>> # policy import
      >>> from macop.policies.classicals import RandomPolicy
      >>> # solution and algorithm
      >>> from macop.solutions.discrete import BinarySolution
      >>> from macop.algorithms.multi import MOEAD, MOSubProblem
      >>> # evaluator import
      >>> from macop.evaluators.discrete.mono import KnapsackEvaluator
      >>> # evaluator initialization (worths objects passed into data)
      >>> problem_size = 20
      >>> worths1 = [ random.randint(0, 20) for i in range(problem_size) ]
      >>> evaluator1 = KnapsackEvaluator(data={'worths': worths1})
      >>> worths2 = [ random.randint(10, 15) for i in range(problem_size) ]
      >>> evaluator2 = KnapsackEvaluator(data={'worths': worths2})
      >>> # validator specification (based on weights of each objects)
      >>> weights = [ random.randint(5, 30) for i in range(problem_size) ]
      >>> validator = lambda solution: True if sum([weights[i] for i, value in enumerate(solution._data) if value == 1]) < 200 else False
      >>> # initializer function with lambda function
      >>> initializer = lambda x=20: BinarySolution.random(x, validator)
      >>> # operators list with crossover and mutation
      >>> operators = [SimpleCrossover(), SimpleMutation()]
      >>> policy = RandomPolicy(operators)
      >>> algo = MOEAD(20, 5, initializer, [evaluator1, evaluator2], operators, policy, validator, maximise=True, verbose=False)
      >>> # weights of the sub problem
      >>> sub_problem_weights = [0.4, 0.6]
      >>> sub_evaluator = WeightedSum(data={'evaluators': [evaluator1, evaluator2], 'weights': sub_problem_weights})
      >>> # first parameter is the index of the MOSubProblem
      >>> subProblem = MOSubProblem(0, sub_problem_weights, initializer, sub_evaluator, operators, policy, validator, maximise=True, parent=algo, verbose=False)
      >>> # run the algorithm
      >>> solution = subProblem.run(100)
      >>> solution._score
      133.0

  `run`(evaluations)

    Run the local search algorithm

    Parameters

      evaluations – {int} – number of evaluations

    Returns

      {Solution} – best solution found