def __init__(self,
n_inputs: int,
instruction_set: Union[InstructionSet, str],
literals: Sequence[Any],
erc_generators: Sequence[Callable],
distribution: DiscreteProbDistrib = "proportional"):
self.n_inputs = n_inputs
self.erc_generators = erc_generators
self.instruction_set = instruction_set
if self.instruction_set == "core":
self.instruction_set = InstructionSet(register_core=True)
self.type_library = self.instruction_set.type_library
self.literals = [
lit if isinstance(lit, Literal) else infer_literal(
lit, self.type_library) for lit in literals
]
if distribution == "proportional":
self.distribution = (DiscreteProbDistrib().add(
GeneTypes.INPUT, self.n_inputs).add(
GeneTypes.INSTRUCTION, len(self.instruction_set)).add(
GeneTypes.CLOSE,
sum([
i.code_blocks
for i in self.instruction_set.values()
])).add(GeneTypes.LITERAL,
len(literals)).add(GeneTypes.ERC,
len(erc_generators)))
else:
self.distribution = distribution
def __init__(self,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib, str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib, str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
verbosity_config: Union[VerbosityConfig, str] = "default",
**kwargs):
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.ext = kwargs
if isinstance(selection, Selector):
self._selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self._selection = selection
else:
selector = get_selector(selection, **self.ext)
self._selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self._variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self._variation = variation
else:
variationOp = get_variation_operator(variation, **self.ext)
self._variation = DiscreteProbDistrib().add(variationOp, 1.0)
if verbosity_config == "default":
self.verbosity_config = DEFAULT_VERBOSITY_LEVELS[0]
else:
self.verbosity_config = verbosity_config
self.verbosity_config._update_log_level()
def __init__(self,
signature: ProgramSignature,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib,
str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib,
str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
parallelism: Union[int, bool] = True,
verbose: int = 0,
**kwargs):
self.signature = signature
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.verbose = verbose
self.ext = kwargs
set_verbosity(self.verbose)
self.parallel_context = None
if isinstance(parallelism, bool):
if parallelism:
self.parallel_context = ParallelContext(spawner, evaluator)
elif parallelism > 1:
self.parallel_context = ParallelContext(spawner, evaluator,
parallelism)
if isinstance(selection, Selector):
self.selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self.selection = selection
else:
selector = get_selector(selection, **self.ext)
self.selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self.variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self.variation = variation
else:
variation_op = get_variation_operator(variation, **self.ext)
self.variation = DiscreteProbDistrib().add(variation_op, 1.0)
def __init__(self,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib,
str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib,
str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
verbosity_config: Union[VerbosityConfig, str] = "default",
**kwargs):
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.ext = kwargs
if isinstance(selection, Selector):
self._selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self._selection = selection
else:
selector = get_selector(selection, **self.ext)
self._selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self._variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self._variation = variation
else:
variationOp = get_variation_operator(variation, **self.ext)
self._variation = DiscreteProbDistrib().add(variationOp, 1.0)
if verbosity_config == "default":
self.verbosity_config = DEFAULT_VERBOSITY_LEVELS[0]
else:
self.verbosity_config = verbosity_config
def __init__(self,
instruction_set: InstructionSet,
literals: Sequence[Union[Literal, Any]],
erc_generators: Sequence[Callable],
distribution: DiscreteProbDistrib = "proportional"):
self.instruction_set = instruction_set
self.literals = [
lit if isinstance(lit, Literal) else Literal(lit)
for lit in literals
]
self.erc_generators = erc_generators
if distribution == "proportional":
self.distribution = (DiscreteProbDistrib().add(
"instruction", len(instruction_set)).add(
"close",
sum([i.code_blocks for i in instruction_set.values()
])).add("literal",
len(literals)).add("erc",
len(erc_generators)))
else:
self.distribution = distribution
class SearchConfiguration:
"""Configuration of an search algorithm.
@todo change to a PClass
Parameters
----------
evaluator : Evaluator
The Evaluator to use when evaluating individuals.
spawning : GeneSpawner
The GeneSpawner to use when producing Genomes during initialization and
variation.
selection : Union[Selector, DiscreteProbDistrib, str], optional
A Selector, or DiscreteProbDistrib of selectors, to use when selecting
parents. The default is lexicase selection.
variation : Union[VariationOperator, DiscreteProbDistrib, str], optional
A VariationOperator, or DiscreteProbDistrib of VariationOperators, to
use during variation. Default is SIZE_NEUTRAL_UMAD.
population_size : int, optional
The number of individuals hold in the population each generation. Default
is 300.
max_generations : int, optional
The number of generations to run the search algorithm. Default is 100.
error_threshold : float, optional
If the search algorithm finds an Individual with a total error less
than this values, stop searching. Default is 0.0.
initial_genome_size : Tuple[int, int], optional
The range of genome sizes to produce during initialization. Default is
(20, 100)
simplification_steps : int, optional
The number of simplification iterations to apply to the best Push program
produced by the search algorithm. Default is 2000.
parallelism : Union[Int, bool], optional
Set the number of processes to spawn for use when performing embarrassingly
parallel tasks. If false, no processes will spawn and compuation will be
serial. Default is true, which spawns one process per available cpu.
verbosity_config : Union[VerbosityConfig, str], optional
A VerbosityConfig controlling what is logged during the search. Default
is no verbosity.
"""
def __init__(self,
signature: ProgramSignature,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib,
str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib,
str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
parallelism: Union[int, bool] = True,
verbose: int = 0,
**kwargs):
self.signature = signature
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.verbose = verbose
self.ext = kwargs
set_verbosity(self.verbose)
self.parallel_context = None
if isinstance(parallelism, bool):
if parallelism:
self.parallel_context = ParallelContext(spawner, evaluator)
elif parallelism > 1:
self.parallel_context = ParallelContext(spawner, evaluator,
parallelism)
if isinstance(selection, Selector):
self.selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self.selection = selection
else:
selector = get_selector(selection, **self.ext)
self.selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self.variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self.variation = variation
else:
variation_op = get_variation_operator(variation, **self.ext)
self.variation = DiscreteProbDistrib().add(variation_op, 1.0)
def get_selector(self):
"""Return a Selector."""
return self.selection.sample()
def get_variation_op(self):
"""Return a VariationOperator."""
return self.variation.sample()
class SearchConfiguration:
"""Configuration of an search algorithm.
Parameters
----------
evaluator : Evaluator
The Evaluator to use when evaluating individuals.
spawning : GeneSpawner
The GeneSpawner to use when producing Genomes during initialization and
variation.
selection : Union[Selector, DiscreteProbDistrib, str], optional
A Selector, or DiscreteProbDistrib of selectors, to use when selecting
parents. The default is lexicase selection.
variation : Union[VariationOperator, DiscreteProbDistrib, str], optional
A VariationOperator, or DiscreteProbDistrib of VariationOperators, to
use during variation. Default is SIZE_NEUTRAL_UMAD.
population_size : int, optional
The number of individuals hold in the population each generation. Default
is 300.
max_generations : int, optional
The number of generations to run the search algorithm. Default is 100.
error_threshold : float, optional
If the search algorithm finds an Individual with a total error less
than this values, stop searching. Default is 0.0.
initial_genome_size : Tuple[int, int], optional
The range of genome sizes to produce during initialization. Default is
(20, 100)
simplification_steps : int, optional
The number of simplification iterations to apply to the best Push program
produced by the search algorithm. Default is 2000.
verbosity_config : Union[VerbosityConfig, str], optional
A VerbosityConfig controling what is logged during the search. Default
is no verbosity.
"""
def __init__(self,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib, str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib, str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
verbosity_config: Union[VerbosityConfig, str] = "default",
**kwargs):
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.ext = kwargs
if isinstance(selection, Selector):
self._selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self._selection = selection
else:
selector = get_selector(selection, **self.ext)
self._selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self._variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self._variation = variation
else:
variationOp = get_variation_operator(variation, **self.ext)
self._variation = DiscreteProbDistrib().add(variationOp, 1.0)
if verbosity_config == "default":
self.verbosity_config = DEFAULT_VERBOSITY_LEVELS[0]
else:
self.verbosity_config = verbosity_config
self.verbosity_config._update_log_level()
def get_selector(self):
"""Return a Selector."""
return self._selection.sample()
def get_variation_op(self):
"""Return a VariationOperator."""
return self._variation.sample()
class SearchConfiguration:
"""Configuration of an search algorithm.
Parameters
----------
evaluator : Evaluator
The Evaluator to use when evaluating individuals.
spawning : GeneSpawner
The GeneSpawner to use when producing Genomes during initialization and
variation.
selection : Union[Selector, DiscreteProbDistrib, str], optional
A Selector, or DiscreteProbDistrib of selectors, to use when selecting
parents. The default is lexicase selection.
variation : Union[VariationOperator, DiscreteProbDistrib, str], optional
A VariationOperator, or DiscreteProbDistrib of VariationOperators, to
use during variation. Default is SIZE_NEUTRAL_UMAD.
population_size : int, optional
The number of individuals hold in the population each generation. Default
is 300.
max_generations : int, optional
The number of generations to run the search algorithm. Default is 100.
error_threshold : float, optional
If the search algorithm finds an Individual with a total error less
than this values, stop searching. Default is 0.0.
initial_genome_size : Tuple[int, int], optional
The range of genome sizes to produce during initialization. Default is
(20, 100)
simplification_steps : int, optional
The number of simplification iterations to apply to the best Push program
produced by the search algorithm. Default is 2000.
verbosity_config : Union[VerbosityConfig, str], optional
A VerbosityConfig controling what is logged during the search. Default
is no verbosity.
"""
def __init__(self,
evaluator: Evaluator,
spawner: GeneSpawner,
selection: Union[Selector, DiscreteProbDistrib,
str] = "lexicase",
variation: Union[VariationOperator, DiscreteProbDistrib,
str] = "umad",
population_size: int = 500,
max_generations: int = 100,
error_threshold: float = 0.0,
initial_genome_size: Tuple[int, int] = (10, 50),
simplification_steps: int = 2000,
verbosity_config: Union[VerbosityConfig, str] = "default",
**kwargs):
self.evaluator = evaluator
self.spawner = spawner
self.population_size = population_size
self.max_generations = max_generations
self.error_threshold = error_threshold
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.ext = kwargs
if isinstance(selection, Selector):
self._selection = DiscreteProbDistrib().add(selection, 1.0)
elif isinstance(selection, DiscreteProbDistrib):
self._selection = selection
else:
selector = get_selector(selection, **self.ext)
self._selection = DiscreteProbDistrib().add(selector, 1.0)
if isinstance(variation, VariationOperator):
self._variation = DiscreteProbDistrib().add(variation, 1.0)
elif isinstance(variation, DiscreteProbDistrib):
self._variation = variation
else:
variationOp = get_variation_operator(variation, **self.ext)
self._variation = DiscreteProbDistrib().add(variationOp, 1.0)
if verbosity_config == "default":
self.verbosity_config = DEFAULT_VERBOSITY_LEVELS[0]
else:
self.verbosity_config = verbosity_config
def get_selector(self):
"""Return a Selector."""
return self._selection.sample()
def get_variation_op(self):
"""Return a VariationOperator."""
return self._variation.sample()