evolvepy.evaluator package

Submodules

evolvepy.evaluator.aggregator module

class evolvepy.evaluator.aggregator.FitnessAggregator(evaluator: Evaluator, mode: int = 2, weights: int | float | complex | str | bytes | generic | Sequence[int | float | complex | str | bytes | generic] | Sequence[Sequence[Any]] | _SupportsArray | None = None)[source]

Bases: EvaluationStage

Aggregates multiple individual scores into a final fitness.

This stage must always be present in the case of evaluations with multiple fitness.

MAX = 0
MEAN = 2
MEDIAN = 3
MIN = 1
MODE_NAMES = ['MAX', 'MIN', 'MEAN', 'MEDIAN']
__init__(evaluator: Evaluator, mode: int = 2, weights: int | float | complex | str | bytes | generic | Sequence[int | float | complex | str | bytes | generic] | Sequence[Sequence[Any]] | _SupportsArray | None = None)[source]

FitnessAggregator constructor.

Parameters:

  • evaluator (Evaluator) – Evaluator used to evaluate the individuals.

  • mode (int, optional) – How scores will be aggregated. Defaults to FitnessAggregator.MEAN. Available modes: MAX, MIN, MEAN, MEDIAN.

  • weights (Union[ArrayLike, None], optional) – Weight to be used for each score. In the case of None, consider each score with the same weight. Defaults to None.

call(population: ndarray) → ndarray[source]

Evaluates a population aggregating the scores.

Parameters:

population (np.ndarray) – Population to be evaluated.

Returns:

Population fitness.

Return type:

np.ndarray

func: List[Callable] = [<function amax>, <function amin>, <function mean>, <function median>]

evolvepy.evaluator.cache module

class evolvepy.evaluator.cache.FitnessCache(evaluator: Evaluator, n_generation: int | None = None, max_decimals: int | None = None)[source]

Bases: EvaluationStage

Evaluations cache.

It allows recovering the previous evaluation of an already evaluated individual, increasing the performance.

__init__(evaluator: Evaluator, n_generation: int | None = None, max_decimals: int | None = None)[source]

FitnessCache constructor.

Parameters:

  • evaluator (Evaluator) – Evaluator used to evaluate the individuals.

  • n_generation (int, optional) – Amounts of generations to wait before deleting an old rating. Defaults to None (never deletes).

  • max_decimals (int, optional) – Decimal places to consider when comparing two individuals. Defaults to None (all places).

call(population: ndarray) → ndarray[source]

Returns the stored fitness of individuals, or evaluates them if it doesn’t have it.

Parameters:

population (np.ndarray) – Population to be evaluated.

Returns:

Population fitness.

Return type:

np.ndarray

get_individual_representation(individual: ndarray) → bytes[source]

Generates the byte representation of an individual, considering the precision in decimal places.

Parameters:

individual (np.ndarray) – Individual who will have representation generated.

Returns:

Generated representation.

Return type:

bytes

evolvepy.evaluator.evaluator module

class evolvepy.evaluator.evaluator.EvaluationStage(evaluator: Evaluator, parameters: Dict[str, object] | None = None, dynamic_parameters: Dict[str, bool] | None = None)[source]

Bases: Evaluator

An evaluation stage. Allows you to modify the behavior of an evaluator.

Can be chained with other stages.

__init__(evaluator: Evaluator, parameters: Dict[str, object] | None = None, dynamic_parameters: Dict[str, bool] | None = None) → None[source]

EvaluationStage constructor.

Parameters:

  • evaluator (Evaluator) – Evaluator that will be modified.

  • parameters (Dict[str, object], optional) – Evaluator parameters. Defaults to None.

  • dynamic_parameters (Dict[str, bool], optional) – Evaluator dynamic parameters description. Defaults to None.

call(population: ndarray) → ndarray[source]
class evolvepy.evaluator.evaluator.Evaluator(n_scores: int = 1, individual_per_call: int = 1, other_parameters: Dict[str, object] | None = None, dynamic_parameters: Dict[str, bool] | None = None, name: str | None = None)[source]

Bases: Configurable, ABC

Base evaluator class.

Must be inherited to be used.

__init__(n_scores: int = 1, individual_per_call: int = 1, other_parameters: Dict[str, object] | None = None, dynamic_parameters: Dict[str, bool] | None = None, name: str | None = None) → None[source]

Evalutor constructor.

Parameters:

  • n_scores (int, optional) – Number of scores generated when evaluating an individual. Defaults to 1.

  • individual_per_call (int, optional) – Number of individuals that are evaluated at each call. Defaults to 1.

  • other_parameters (Dict[str,object], optional) – Other parameters defined by the inheritor class. Defaults to None.

  • dynamic_parameters (Dict[str,bool], optional) – Other dynamic parameters defined by the inheritor class. Defaults to None.

abstract call(population: ndarray) → ndarray[source]
property scores: ndarray

Scores of the last evaluated individuals.

evolvepy.evaluator.function_evaluator module

class evolvepy.evaluator.function_evaluator.FunctionEvaluator(function: Callable[[ndarray], int | float | complex | str | bytes | generic | Sequence[int | float | complex | str | bytes | generic] | Sequence[Sequence[Any]] | _SupportsArray], n_scores: int = 1, mode: int = 2, individual_per_call: int = 1, name: str | None = None, n_thread: int | None = None)[source]

Bases: Evaluator

Evaluates individuals using a simple function.

JIT = 1
JIT_PARALLEL = 3
NJIT = 2
NJIT_PARALLEL = 4
PYTHON = 0
__init__(function: Callable[[ndarray], int | float | complex | str | bytes | generic | Sequence[int | float | complex | str | bytes | generic] | Sequence[Sequence[Any]] | _SupportsArray], n_scores: int = 1, mode: int = 2, individual_per_call: int = 1, name: str | None = None, n_thread: int | None = None) → None[source]

FunctionEvaluator constructor.

Parameters:

  • function (Callable[[np.ndarray], ArrayLike]) – Function that will be used to evaluate individuals.

  • n_scores (int, optional) – Number of scores generated for each individual. Defaults to 1.

  • mode (int, optional) – In which compilation mode to use the fitness function. Defaults to FunctionEvaluator.NJIT. One of the class constants can be used: PYTHON: No JIT compilation JIT: With Numba JIT compilation NJIT: With Numba No Python mode. JIT_PARALLEL: With JIT and parallel assessments. NJIT_PARALLEL: With NJIT and parallel assessments.

  • individual_per_call (int, optional) – Number of individuals that are evaluated at each function call. Defaults to 1.

call(population: ndarray) → ndarray[source]

Evaluates a population using the fitness function.

Parameters:

population (np.ndarray) – Population to be evaluated.

Returns:

Population fitness.

Return type:

np.ndarray

static static_call(function: Callable, individual_per_call: int, n_scores: int, population: ndarray) → ndarray[source]

Call the fitness function in the desired mode.

Static method to enable just-in-time compilation using Numba.

Parameters:

  • function (Callable) – Function that will be used to evaluate individuals.

  • individual_per_call (int) – Number of individuals that are evaluated at each function call.

  • n_scores (int) – Number of scores generated for each individual.

  • population (np.ndarray) – Population to be evaluated

Returns:

Population fitness

Return type:

np.ndarray

evolvepy.evaluator.multiple module

class evolvepy.evaluator.multiple.MultipleEvaluation(evaluator: ~evolvepy.evaluator.evaluator.Evaluator, n_evaluation: int = 1, agregator: ~typing.Callable[[~numpy.ndarray, int], ~numpy.ndarray] = <function mean>, discard_min=False, discard_max=False)[source]

Bases: EvaluationStage

Evaluates the same individual several times to avoid noise.

__init__(evaluator: ~evolvepy.evaluator.evaluator.Evaluator, n_evaluation: int = 1, agregator: ~typing.Callable[[~numpy.ndarray, int], ~numpy.ndarray] = <function mean>, discard_min=False, discard_max=False) → None[source]

MultipleEvaluation constructor.

Parameters:

  • evaluator (Evaluator) – Evaluator used to evaluate the individuals.

  • n_evaluation (int, optional) – Number of evaluations to be carried out. Defaults to 1.

  • agregator (Callable[[np.ndarray, int], np.ndarray], optional) – Function that will aggregate the fitness of the evaluations. Defaults to np.mean.

  • discard_min (bool, optional) – Whether it should discard the lower fitness assessment. Defaults to False.

  • discard_max (bool, optional) – Whether it should discard the higher fitness assessment. Defaults to False.

call(population: ndarray) → ndarray[source]

Evaluates the population several times, aggregating the evaluations

Parameters:

population (np.ndarray) – Population to be evaluated.

Returns:

Population aggregated fitness.

Return type:

np.ndarray

evolvepy.evaluator.process_evaluator module

class evolvepy.evaluator.process_evaluator.ProcessEvaluator(fitness_function: Type[ProcessFitnessFunction], n_process: int | None = None, timeout: int | None = None, n_scores: int = 1, individual_per_call: int = 1, args: Dict[str, object] | None = None, name: str | None = None)[source]

Bases: Evaluator

Evaluates individuals using multiple process.

__init__(fitness_function: Type[ProcessFitnessFunction], n_process: int | None = None, timeout: int | None = None, n_scores: int = 1, individual_per_call: int = 1, args: Dict[str, object] | None = None, name: str | None = None) → None[source]

ProcessEvaluator constructor.

Parameters:

  • fitness_function (Type[ProcessFitnessFunction]) – Class that will be used to evaluate individuals.

  • n_process (int, optional) – Number of process to use. Defaults to None (same number as cpu_count).

  • timeout (int, optional) – Maximum time to wait for a new evaluation. Defaults to None (infinity).

  • n_scores (int, optional) – Number of scores generated by fitness function. Defaults to 1.

  • individual_per_call (int, optional) – Number of individuals that the fitness function receives. Defaults to 1.

  • args (Dict[str, object], optional) – Other arguments for the fitness_function constructor. Defaults to None.

call(population: ndarray) → ndarray[source]

Evaluates the population

Parameters:

population (np.ndarray) – Population to be evaluated.

Raises:

RuntimeError – Raised if population size is not divisible by individual_per_call.

Returns:

Population fitness.

Return type:

np.ndarray

class evolvepy.evaluator.process_evaluator.ProcessFitnessFunction(reset: bool = False)[source]

Bases: ABC

Base class of fitness function to be used to evaluate individuals in parallel with multiple processes.

It must be inherited in a class that will implement the evaluation.

__init__(reset: bool = False) → None[source]

ProcessFitnessFunction constructor.

Parameters:

reset (bool, optional) – Whether to reset the evaluator status at each evaluation. Defaults to False.

abstract evaluate(individuals: ndarray) → ndarray[source]

Implements the evaluation of individuals.

Must be implemented by the inheriting class.

Parameters:

population (np.ndarray) – Individuals to be evaluated.

Returns:

Individuals fitness.

Return type:

np.ndarray

abstract setup() → None[source]

Method that prepares the evaluator to evaluate individuals.

Called before the first evaluation, and before all evaluations if “reset” is true.

Must be implemented by the inheriting class.

evolvepy.evaluator.process_evaluator.evaluate_forever(fitness_function: Type[ProcessFitnessFunction], individuals_queue: Queue, scores_queue: Queue, args: Dict[str, object])[source]

Prepared the cost function to evaluate the individuals, waits for the receipt of individuals and returns the scores.

Parameters:

  • fitness_function (Type[ProcessFitnessFunction]) – Class to be used to evaluate individuals.

  • individuals_queue (mp.Queue) – Queue in which individuals who need to be evaluated will arrive.

  • scores_queue (mp.Queue) – Queue in which the generated scores will be placed.

  • args (Dict[str, object]) – Other evaluator class constructor arguments.

Module contents

EvolvePy’s evaluators. Objects used to evaluate individuals.