Skip to main content

PyPI package containing opposition learning operators and population initializers for evolutionary algorithms

Project description

Opposition learning operators and population initializers

PyPI version Downloads Downloads Downloads

pip install OppOpPopInit

PyPI package containing opposition learning operators and population initializers for evolutionary algorithms.

About opposition operators

In several evolutionary algorithms it can be useful to create the opposite of some part of current population to explore searching space better. Usually it uses at the begging of searching process (with first population initialization) and every few generations with decreasing probability F. Also it's better to create oppositions of worse objects from populations. See this article for more information.

This package provides several operators for creating oppositions (opposition operators) and methods for creating start population using different distribution functions and opposition operators for each dimension!


What can u import from this package:

from OppOpPopInit import OppositionOperators # available opposition operators
from OppOpPopInit import SampleInitializers # available population initializers
from OppOpPopInit import init_population # function to initialize population using pop. initializers and several oppositors

Available opposition operators


There are several operators constructors. Main part of them should use two arguments:

  • minimums -- numpy array with minimum borders for each dimension
  • maximums -- numpy array with maximum borders for each dimension


  • OppositionOperators.Continual.abs
  • OppositionOperators.Continual.modular
  • OppositionOperators.Continual.quasi
  • OppositionOperators.Continual.quasi_reflect
  • OppositionOperators.Continual.over
  • OppositionOperators.Continual.Partial -- for using different opposition operators for each dimension with continual task
  • OppositionOperators.Discrete.integers_by_order -- it's like abs operator but for integer values
  • OppositionOperators.PartialOppositor -- for using different opposition operators for each dimension with continual or mixed task. See example below

U can create your own oppositor using pattern:

def oppositor(sample_as_array):
    # some code
    return new_sample_as_array

There are also OppositionOperators.Discrete.index_by_order and OppositionOperators.Discrete.value_by_order constructors for very special discrete tasks with available sets of valid values (like [-1, 0, 1, 5, 15]), but it's highly recommended to convert this task to indexes array task (and use OppositionOperators.Discrete.integers_by_order) like below:

# available values
vals = np.array([1, 90. -45, 3, 0.7, 3.4, 12])

valid_array_example = np.array([1,1,1,3,-45])

# function
def optimized_func(arr):
    #some code
    return result

# recommented way for optimization algorithm
indexes = np.arange(vals.size)

def new_optimized_functio(new_arr):
    arr = np.array([vals[i] for i in new_arr])
    return optimized_func(arr)

# and forth u are using indexes format for your population


abs oppositor


modular oppositor


quasi oppositor


quasi_reflect oppositor


over oppositor


integers_by_order oppositor


More examples

Partial oppositor

Create Partial oppositor using this structure:

oppositor = OppositionOperators.PartialOppositor(
        (numpy_array_of_indexes, oppositor_for_this_dimentions),
        (numpy_array_of_indexes, oppositor_for_this_dimentions),
        (numpy_array_of_indexes, oppositor_for_this_dimentions)


import numpy as np
from OppOpPopInit import OppositionOperators

# 5 dim population

min_bound = np.array([-8, -3, -5.7, 0, 0])
max_bound = np.array([5, 4, 4, 9, 9])

# population points
points = np.array([
    [1, 2, 3, 4, 7.5],
    [1.6, -2, 3.9, 0.4, 5],
    [1.1, 3.2, -3, 4, 5],
    [4.1, 2, 3, -4, 0.5]

# saved indexes for oppositors
first_op_indexes = np.array([0, 2])
second_op_indexes = np.array([1, 3])

oppositor = OppositionOperators.PartialOppositor(
        (first_op_indexes, OppositionOperators.Continual.abs(
            minimums= min_bound[first_op_indexes],
            maximums= max_bound[first_op_indexes],
        (second_op_indexes, OppositionOperators.Continual.over(
            minimums= min_bound[second_op_indexes],
            maximums= max_bound[second_op_indexes],

# as u see, it's not necessary to oppose population by all dimensions, here we won't oppose by last dimension

oppositions = OppositionOperators.Reflect(points, oppositor)


#array([[-4.        ,  1.84589799, -4.7       ,  5.04795851,  7.5       ],
#       [-4.6       , -0.74399971, -5.6       ,  7.49178902,  5.        ],
#       [-4.1       ,  0.54619162,  1.3       ,  6.14214043,  5.        ],
#       [-7.1       , -2.59648698, -4.7       ,  0.95770904,  0.5       ]])

Another example code


Create RandomPartialOppositor oppositor using this structure:

oppositor = OppositionOperators.RandomPartialOppositor(
        (count_of_random_dimensions, repeate_config_during_steps, oppositor_creator),
        (count_of_random_dimensions, repeate_config_during_steps, oppositor_creator),
        (count_of_random_dimensions, repeate_config_during_steps, oppositor_creator)

See simplest example of using

Reflect method

Use OppositionOperators.Reflect(samples, oppositor) for oppose samples array using some oppositor. samples argument here is 2D-array with size samples*dimension.

Reflection with selection best

There is OppositionOperators.ReflectWithSelectionBest(population_samples, oppositor, eval_func, samples_scores = None, more_is_better = False) method for reflect population (with size N) and select best N objects from existing 2N objects. It has parameters:

  • population_samples : 2D numpy array; reflected population.
  • oppositor : function; applying oppositor.
  • eval_func : function; optimized function of population/task.
  • samples_scores : None/1D numpy array, optional; scores for reflected population (if calculated -- it's not necessary to calculate it again). The default is None.
  • more_is_better : logical, optional; The goal -- is maximize the function. The default is False.

See example

Population initializers

Simple random populations

Like oppositors operators there are some constructors for creating start population:

  • SampleInitializers.RandomInteger(minimums, maximums) -- returns function which will return random integer vectors between minimums and maximums
  • SampleInitializers.Uniform(minimums, maximums) -- returns function which will return random vectors between minimums and maximums from uniform distribution
  • SampleInitializers.Normal(minimums, maximums, sd = None) -- returns function which will return random vectors between minimums and maximums from normal distribution

U can create your initializer function:

def func():
    # code
    return valid_sample_array 

There is also SampleInitializers.Combined(minimums, maximums, list_of_indexes, list_of_initializers_creators) for generate population with different constructors for each dimension!

Use creator for initialize population with k objects using SampleInitializers.CreateSamples(creator, k).









Populations with oppositions

Use init_population(total_count, creator, oppositors = None) to create population of size total_count where some objects are constructed by creator and other objects are constructed by applying each oppositor from oppositors to start objects.


Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for OppOpPopInit, version 1.2.0
Filename, size File type Python version Upload date Hashes
Filename, size OppOpPopInit-1.2.0.tar.gz (9.9 kB) File type Source Python version None Upload date Hashes View
Filename, size OppOpPopInit-1.2.0-py3-none-any.whl (10.8 kB) File type Wheel Python version py3 Upload date Hashes View

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor NVIDIA NVIDIA PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page