File size: 10,514 Bytes
483026f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 | # Defining Problems
## Basic Usage
One of the most important components of EvoTorch is the definition of problems. To define problems, we use the [Problem][evotorch.core.Problem] class, which provides various advanced functionality, including vectorization, GPU usage, [Ray](https://www.ray.io/) parallelisation and variable population sizes, out of the box. The most basic usage of the [Problem][evotorch.core.Problem] class is simply to pass to it a function to minimize or maximize. In the following documentation, we will focus on minimization of the Sphere function
\[
f(x) = \sum_{i=1}^d x_i^2.
\]
which is implemented in PyTorch as,
```python
import torch
def sphere(x: torch.Tensor) -> torch.Tensor:
return torch.sum(x.pow(2.0))
```
With only this function definition, we can create an EvoTorch [Problem][evotorch.core.Problem] instance and start learning,
```python
from evotorch import Problem
from evotorch.algorithms import SNES
from evotorch.logging import StdOutLogger
problem = Problem("min", sphere, solution_length=10, initial_bounds=(-1, 1))
searcher = SNES(problem, stdev_init=5)
logger = StdOutLogger(searcher)
searcher.run(10)
```
If we instead want to maximize the function, we can instead instantiate the [Problem][evotorch.core.Problem] instance,
```python
problem = Problem("max", sphere, solution_length=10, initial_bounds=(-1, 1))
```
and if we want to make the instantiation explicit, we can use the keyword arguments `objective_sense` and `objective_func`,
```python
problem = Problem(
objective_sense="min",
objective_func=sphere,
solution_length=10,
initial_bounds=(-1, 1),
)
```
## Vectorizing Problems
One of the most straight-forward ways to accelerate evolution is to use *vectorized* problems. In a typical EA implementation, the population is stored as a list of vectors, so that fitnesses can be evaluated with a simple `for` loop
```python
fitnesses = [f(x) for x in population]
```
In EvoTorch, the population is stored as a `torch` tensor of shape $N \times d$ (or, to use the PyTorch notation, of shape `torch.Size([N, d])`) where $N$ is the population size and $d$ is the problem dimensionality. If it is possible to define a fitness function that can evaluate *all* $N$ solutions at once, as is often possible when the fitness function is defined in terms of PyTorch operators, then significant speedups can be achieved by letting the low-level C implementation of PyTorch do much of the work. To demonstrate this, let's vectorize the `sphere` function from earlier:
```python
from evotorch.decorators import vectorized
@vectorized
def vectorized_sphere(xs: torch.Tensor) -> torch.Tensor:
return torch.sum(xs.pow(2.0), dim=-1)
```
By specifying that we want to sum across the last dimension (via `dim=-1`), we return an $N$ dimensional vector of fitnesses, rather than a single fitness value.
The decorator @[vectorized][evotorch.decorators.vectorized] informs the [Problem][evotorch.core.Problem] instance that this fitness function is vectorized, and therefore expects to receive multiple solutions and returns fitnesses for all those solutions.
We are now ready to make our problem description around our vectorized fitness function:
```python
problem = Problem(
objective_sense="min",
objective_func=vectorized_sphere,
solution_length=10,
initial_bounds=(-1, 1),
)
```
## Creating Custom Problem Classes
While many fitness functions can be expressed as a callable function $f: \mathbb{R}^d \rightarrow \mathbb{R}$ which can be passed to a [Problem][evotorch.core.Problem] instance at instantiation using the `objective_func` keyword-argument, there are also many cases were we wish to create custom [Problem][evotorch.core.Problem] classes which can be stateful and parameterisable. In this case, we can create a new class that inherits from the [Problem][evotorch.core.Problem] class.
To demonstrate this, we will consider the $d$-dimensional Rastrigin problem, where the center of the function is offset by a randomly chosen vector $x'$,
\[
f(x) = Ad + \sum_{i=1}^d z_i^2 - A \cos (2 \pi z_i).
\]
where
\[
z = x - x'
\]
We can create a new class which defines this problem and randomly chooses $x'$ at instantiation. To do this, we only need to define the `__init__` and `_evaluate` methods.
```python
from evotorch import Problem, Solution
import torch
import math
class OffsetRastrigin(Problem):
def __init__(self, d: int = 25, A: int = 10):
super().__init__(
objective_sense="min",
solution_length=d,
initial_bounds=(-1, 1),
)
# Store the A parameter for evaluation
self._A = A
# Generate a random offset with center 0 and standard deviation 1
self._x_prime = self.make_gaussian(d, center=0.0, stdev=1.0)
def _evaluate(self, solution: Solution):
x = solution.values
z = x - self._x_prime
f = (self._A * self.solution_length) + torch.sum(
z.pow(2.0) - self._A * torch.cos(2 * math.pi * z)
)
solution.set_evals(f)
```
This [Problem][evotorch.core.Problem] class can be used just like any other, reparameterising it as needed
```python
from evotorch.algorithms import SNES
from evotorch.logging import StdOutLogger
prob = OffsetRastrigin(d=14, A=5)
searcher = SNES(prob, stdev_init=5)
logger = StdOutLogger(searcher)
searcher.run(10)
```
Let's break down what is happening in the `_evaluate` method definition.
1. This method receives an instance of [Solution][evotorch.core.Solution], the data type used to store and manipulate individual members of the population in EvoTorch.
2. The [Solution][evotorch.core.Solution] instance's `values` method is called, which returns the $d$-dimensional vector `x` that represents the solution.
3. This vector `x` is evaluated according to the above formula to give fitness `f`.
4. The [Solution][evotorch.core.Solution] instance's `set_evals` method is called with argument `f`. This stores the fitness value `f` within the [Solution][evotorch.core.Solution] instance so that it can be used by the `searcher` in the next iteration.
For more detail on interacting with [Solution][evotorch.core.Solution] instances, please refer to [the relevant advanced usage guide](../advanced_usage/solution_batch.md).
## Vectorizing Custom Problems
Much like the base [Problem][evotorch.core.Problem] class, it is straight-forward to introduce fitness vectorization when creating a custom [Problem][evotorch.core.Problem] class. To do this, we simply override the `_evaluate_batch` method, rather than the `_evaluate` method.
```python
from evotorch import SolutionBatch
class VecOffsetRastrigin(Problem):
def __init__(self, d: int = 25, A: int = 10):
super().__init__(
objective_sense="min",
solution_length=d,
initial_bounds=(-1, 1),
)
# Store the A parameter for evaluation
self._A = A
# Generate a random offset with center 0 and standard deviation 1
self._x_prime = self.make_gaussian((1, d), center=0.0, stdev=1.0)
def _evaluate_batch(self, solutions: SolutionBatch):
xs = solutions.values
zs = xs - self._x_prime
fs = (self._A * self.solution_length) + torch.sum(
zs.pow(2.0) - self._A * torch.cos(2 * math.pi * zs), dim=-1
)
solutions.set_evals(fs)
```
All that has changed is that rather than receiving a [Solution][evotorch.core.Solution] instance, we are now receiving a [SolutionBatch][evotorch.core.SolutionBatch] instance which consists of $N$ solutions. The call to `values` instead yields a $N \times d$ tensor `xs`, and by appropriately rewriting the line that computes `fs` so that the result is a $N$-dimensional vector, we can straightforwardly set the fitness values of the entire batch of solutions with `set_evals`.
## Working with Data Types and Devices
The [Problem][evotorch.core.Problem] class supports different `torch` data types and devices, with the `dtype` and `device` keyword arguments, respectively. For example, we can specify that we wish to use 16-bit floating point values on the first available CUDA-capable device in the initialisation of the class.
One way to accelerate solution evaluation is to use CUDA-capable devices to compute the fitness values. In EvoTorch, this can be done easily using the `device` flag. By default, the device flag is set to `'cpu'`, so that the problem (and any searcher attached to it) will run everything on the CPU. Assuming there is at least one CUDA-capable device available, we can instead use,
```python
problem = Problem(
objective_sense="min",
objective_func=vectorized_sphere,
solution_length=10,
initial_bounds=(-1, 1),
dtype=torch.float16,
device="cuda:0",
)
```
When working with different data types and device, EvoTorch searchers will use those data types and devices in their own computations to ensure that everything is compatible when the [Problem][evotorch.core.Problem] instance is called. In practice, particularly in high dimensions and with large population sizes, using a CUDA-capable device can yield significant speedups. A particularly important example of this is in the case of neuroevolution.
Similarly, we can use different data types and devices within custom [Problem][evotorch.core.Problem] classes:
```python
class OffsetRastrigin16(Problem):
def __init__(self, d: int = 25, A: int = 10):
super().__init__(
objective_sense="min",
solution_length=d,
initial_bounds=(-1, 1),
dtype=torch.float16,
device="cuda:0",
)
...
```
For a similar reason, when we are creating `torch` tensors that we will use within the evaluation, it is also important to ensure they share the same data type and device. For this reason, [Problem][evotorch.core.Problem] instances support a number of `torch.Tensor` generation methods out-of-the-box. Earlier, we used the method `make_gaussian` to generate a random center $x'$ for the fitness evaluation to use. This method will generate a sample from a Gaussian distribution with the shape, center and standard deviation specified, but of particular relevance, it will ensure that the generated sample uses the device and data type associated with the [Problem][evotorch.core.Problem] instance. There are a number of similar methods available, which can be found detailed in the [API reference][evotorch].
|