# Source code for ribs.emitters._genetic_algorithm_emitter

```
"""Provides the GeneticAlgorithmEmitter."""
import numpy as np
from ribs._utils import check_batch_shape, check_shape
from ribs.emitters._emitter_base import EmitterBase
from ribs.emitters.operators import _get_op
[docs]class GeneticAlgorithmEmitter(EmitterBase):
"""Emits solutions by using operator provided.
If the archive is empty and ``self._initial_solutions`` is set, a call to
:meth:`ask` will return ``self._initial_solutions``. If
``self._initial_solutions`` is not set, we operate on self.x0.
Args:
archive (ribs.archives.ArchiveBase): An archive to use when creating and
inserting solutions. For instance, this can be
:class:`ribs.archives.GridArchive`.
x0 (numpy.ndarray): Initial solution.
operator (str): Internal Operator Class used to Mutate Solutions
in ask method.
operator_kwargs (dict): Additional arguments to pass to the operator.
See :mod:`ribs.emitters.operators` for the arguments allowed by each
operator.
initial_solutions (array-like): An (n, solution_dim) array of solutions
to be used when the archive is empty. If this argument is None, then
solutions will be sampled from a Gaussian distribution centered at
``x0`` with standard deviation ``sigma``.
bounds (None or array-like): Bounds of the solution space. Solutions are
clipped to these bounds. Pass None to indicate there are no bounds.
Alternatively, pass an array-like to specify the bounds for each
dim. Each element in this array-like can be None to indicate no
bound, or a tuple of ``(lower_bound, upper_bound)``, where
``lower_bound`` or ``upper_bound`` may be None to indicate no bound.
batch_size (int): Number of solutions to return in :meth:`ask`.
Raises:
ValueError: There is an error in x0 or initial_solutions.
ValueError: There is an error in the bounds configuration.
"""
def __init__(self,
archive,
*,
x0=None,
initial_solutions=None,
bounds=None,
batch_size=64,
operator_kwargs=None,
operator=None):
self._batch_size = batch_size
self._x0 = x0
self._initial_solutions = None
EmitterBase.__init__(
self,
archive,
solution_dim=archive.solution_dim,
bounds=bounds,
)
if operator is None:
raise ValueError("Operator must be provided.")
if x0 is None and initial_solutions is None:
raise ValueError("Either x0 or initial_solutions must be provided.")
if x0 is not None and initial_solutions is not None:
raise ValueError(
"x0 and initial_solutions cannot both be provided.")
if x0 is not None:
self._x0 = np.array(x0, dtype=archive.dtype)
check_shape(self._x0, "x0", archive.solution_dim,
"archive.solution_dim")
elif initial_solutions is not None:
self._initial_solutions = np.asarray(initial_solutions,
dtype=archive.dtype)
check_batch_shape(self._initial_solutions, "initial_solutions",
archive.solution_dim, "archive.solution_dim")
self._operator = _get_op(operator)(
lower_bounds=self._lower_bounds,
upper_bounds=self._upper_bounds,
**(operator_kwargs if operator_kwargs is not None else {}))
@property
def x0(self):
"""numpy.ndarray: Initial Solution (if initial_solutions is not
set)."""
return self._x0
@property
def initial_solutions(self):
"""numpy.ndarray: The initial solutions which are returned when the
archive is empty (if x0 is not set)."""
return self._initial_solutions
@property
def batch_size(self):
"""int: Number of solutions to return in :meth:`ask`."""
return self._batch_size
[docs] def ask(self):
"""Creates solutions with operator provided.
If the archive is empty and ``self._initial_solutions`` is set, we
return ``self._initial_solutions``. If ``self._initial_solutions`` is
not set and the archive is still empty, we operate on the initial
solution (x0) provided. Otherwise, we sample parents from the archive
to be used as input to the operator
Returns:
numpy.ndarray: If the archive is not empty, ``(batch_size,
solution_dim)`` array -- contains ``batch_size`` new solutions to
evaluate. If the archive is empty, we return
``self._initial_solutions``, which might not have ``batch_size``
solutions.
"""
if self.archive.empty and self._initial_solutions is not None:
return np.clip(self._initial_solutions, self.lower_bounds,
self.upper_bounds)
if self._operator.parent_type == 2:
if self.archive.empty:
parents = np.repeat(self.x0[None],
repeats=2 * self._batch_size,
axis=0)
else:
parents = self.archive.sample_elites(
2 * self._batch_size)["solution"]
return self._operator.ask(
parents=parents.reshape(2, self._batch_size, -1))
else: # self._operator.parent_type == 1, gaussian
if self.archive.empty:
parents = np.repeat(self.x0[None],
repeats=self._batch_size,
axis=0)
else:
parents = self.archive.sample_elites(
self._batch_size)["solution"]
return self._operator.ask(parents=parents)
```