PyPI package containing opposition learning operators and population initializers for evolutionary algorithms
Project description
Opposition learning operators and population initializers
pip install OppOpPopInit
PyPI package containing opposition learning operators and population initializers for evolutionary algorithms.
 Opposition learning operators and population initializers
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!
Imports
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
Checklist
There are several operators constructors. Main part of them should use two arguments:
minimums
 numpy array with minimum borders for each dimensionmaximums
 numpy array with maximum borders for each dimension
Checklist:
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 taskOppositionOperators.Discrete.integers_by_order
 it's likeabs
operator but for integer valuesOppositionOperators.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
Examples
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) ] )
Example:
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) oppositions #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 ]])
RandomPartialOppositor
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) ], minimums, maximums, current_dimension_count )
Reflect method
Use OppositionOperators.Reflect(samples, oppositor)
for oppose samples array using some oppositor. samples
argument here is 2Darray 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 isNone
.more_is_better
: logical, optional; The goal  is maximize the function. The default isFalse
.
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 betweenminimums
andmaximums
SampleInitializers.Uniform(minimums, maximums)
 returns function which will return random vectors betweenminimums
andmaximums
from uniform distributionSampleInitializers.Normal(minimums, maximums, sd = None)
 returns function which will return random vectors betweenminimums
andmaximums
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)
.
RandomInteger
Uniform
Normal
Mixed
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.
Filename, size  File type  Python version  Upload date  Hashes 

Filename, size OppOpPopInit1.2.0.tar.gz (9.9 kB)  File type Source  Python version None  Upload date  Hashes View 
Filename, size OppOpPopInit1.2.0py3noneany.whl (10.8 kB)  File type Wheel  Python version py3  Upload date  Hashes View 
Hashes for OppOpPopInit1.2.0py3noneany.whl
Algorithm  Hash digest  

SHA256  6ba7af1242baed58320def73d5863e3f34d3f1003871fa222086a75d235b0b50 

MD5  f27c5544bc30684dd9b6f2247841bd45 

BLAKE2256  a23873ed56e74cd16d3729bb6eec4bf4c0d1ca135e04e618e4046b4f8195b8eb 