Thefittest

https://sherstpasha.github.io/thefittest
Admin
Thefittest is an open-source Python library for classical evolutionary algorithms and their...
Tokens:22,149
Snippets:116
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Python Random Weighted Sampling without Replacement

Source: https://sherstpasha.github.io/thefittest/modules/utils/random

This example demonstrates weighted sampling from indices without replacement using random weights. It requires a weights array and quantity parameter as inputs, outputting a list of sampled indices. The function is useful for probabilistic selections but may have performance limitations for very large arrays.

```python
# Example without replacement
sampled_indices_no_replace = random_weighted_sample(weights, quantity=2, replace=False)
print("Sampled Indices (No Replace):", sampled_indices_no_replace)
```

--------------------------------

### SamplingGrid Fit API

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

The `fit` method initializes and configures the SamplingGrid based on specified borders, number of variables, and either step size or bits per variable.

```APIDOC
## POST /api/samplinggrid/fit

### Description
Fits the sampling grid using specified parameters.

### Method
POST

### Endpoint
/api/samplinggrid/fit

### Parameters
#### Query Parameters
- **left_border** (Union[float, NDArray[np.float64]]) - Required - Left border values for each variable.
- **right_border** (Union[float, NDArray[np.float64]]) - Required - Right border values for each variable.
- **num_variables** (int) - Required - Number of variables.
- **h_per_variable** (Optional[Union[float, NDArray[np.float64]]]) - Optional - Step size values for each variable. Either h_per_variable or bits_per_variable should be provided.
- **bits_per_variable** (Optional[Union[int, NDArray[np.int64]]]) - Optional - Number of bits per variable. Either h_per_variable or bits_per_variable should be provided.

### Request Example
```json
{
  "left_border": 0.0,
  "right_border": 1.0,
  "num_variables": 3,
  "h_per_variable": 0.1
}
```

### Response
#### Success Response (200)
- **SamplingGrid** (SamplingGrid) - The fitted SamplingGrid instance.

#### Response Example
```json
{
  "message": "SamplingGrid fitted successfully"
}
```

#### Error Handling
- **AssertionError**: If neither `h_per_variable` nor `bits_per_variable` is provided, or if input validation fails.
```

--------------------------------

### SamplingGrid: Fitting and Transforming Binary Population

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Initializes and fits a SamplingGrid with borders, variables, and step size, then generates a random binary population and transforms it to floating-point. Based on NumPy; inputs define the grid parameters, outputs are floating-point values discretized by the grid, with potential rounding limitations.

```python
import numpy as np
from thefittest.utils.transformations import SamplingGrid

# Fit the sampling grid
grid = SamplingGrid()
grid.fit(left_border=-5.0, right_border=5.0, num_variables=3, h_per_variable=0.1)
<thefittest.utils.transformations.SamplingGrid object at ...>
# Generate a binary population
string_length = grid.get_bits_per_variable().sum()
binary_population = np.random.randint(2, size=(5, string_length), dtype=np.int8)
# Transform the binary population to a floating-point array
```

--------------------------------

### Perform current-to-pbest-1-archive Mutation with Dynamic p_min (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/mutations

Implements current-to-pbest-1-archive mutation with a dynamically adjusted p_min parameter for differential evolution. This strategy also involves combining individuals and considering best solutions, with p_min adapting to population size. Dependencies: NumPy.

```python
from thefittest.utils.mutations import current_to_pbest_1_archive_p_min
import numpy as np

# Example
current_individual = np.array([0.5, 0.3, 0.8], dtype=np.float64)
population = np.array([[0.2, 0.1, 0.5], [0.8, 0.6, 0.9], [0.3, 0.7, 0.4], [0.9, 0.5, 0.2]], dtype=np.float64)
pbest_indices = np.array([1, 3], dtype=np.int64)
mutation_scale_factor = 0.7
pop_archive = np.array([[0.1, 0.3, 0.6], [0.7, 0.4, 0.8], [0.4, 0.2, 0.5]], dtype=np.float64)
mutated_individual = current_to_pbest_1_archive_p_min(current_individual, population, pbest_indices, mutation_scale_factor, pop_archive)
print("Current Individual:", current_individual)
print("Mutated Individual:", mutated_individual)
```

--------------------------------

### Fitting Sampling Grid with Parameters in Python

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

The fit method initializes a sampling grid based on left/right borders, number of variables, and either step size (h_per_variable) or bits (bits_per_variable). It calculates the counterpart parameter using powers of 2 and stores grid properties. Inputs include numpy arrays for borders and parameters; outputs are the fitted object with accessible properties via getters. Limitations: Assumes uniform powers of 2; handles multi-dimensional arrays.

```python
import numpy as np
from thefittest.utils.transformations import SamplingGrid

grid = SamplingGrid()
grid.fit(left_border=0.0, right_border=1.0, num_variables=3, h_per_variable=0.1)
print("Grid Left Border:", grid.get_left_border())
print("Grid Right Border:", grid.get_right_border())
print("Number of Variables:", grid.get_num_variables())
print("Step Size per Variable:", grid.get_h_per_variable())
print("Bits per Variable:", grid.get_bits_per_variable())

grid = SamplingGrid()
grid.fit(left_border=-1.0, right_border=1.0, num_variables=2, bits_per_variable=4)
print("Grid Left Border:", grid.get_left_border())
print("Grid Right Border:", grid.get_right_border())
print("Number of Variables:", grid.get_num_variables())
print("Step Size per Variable:", grid.get_h_per_variable())
print("Bits per Variable:", grid.get_bits_per_variable())

grid = SamplingGrid()
grid.fit(
    left_border=np.array([-1.0, 0.5, -2.0], dtype=np.float64),
    right_border=np.array([1.0, 5.0, 2.0], dtype=np.float64),
    num_variables=3,
    h_per_variable=np.array([0.05, 1.0, 0.1], dtype=np.float64),
)
print("Grid Left Border:", grid.get_left_border())
print("Grid Right Border:", grid.get_right_border())
print("Number of Variables:", grid.get_num_variables())
print("Step Size per Variable:", grid.get_h_per_variable())
print("Bits per Variable:", grid.get_bits_per_variable())

grid = SamplingGrid()
grid.fit(
    left_border=np.array([-3.5, -2.0, 10.0, 0.9], dtype=np.float64),
    right_border=np.array([3.5, 7.0, 25.0, 1.5], dtype=np.float64),
    num_variables=4,
    bits_per_variable=np.array([8, 16, 3, 40], dtype=np.int64),
)
print("Grid Left Border:", grid.get_left_border())
print("Grid Right Border:", grid.get_right_border())
print("Number of Variables:", grid.get_num_variables())
print("Step Size per Variable:", grid.get_h_per_variable())
print("Bits per Variable:", grid.get_bits_per_variable())
```

--------------------------------

### Fit Sampling Grid with Parameters (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Fits the SamplingGrid instance with specified parameters including borders, number of variables, and step size or bits per variable. Requires numpy and the SamplingGrid class.

```python
import numpy as np
from thefittest.utils.transformations import SamplingGrid

grid = SamplingGrid()
grid.fit(left_border=0.0, right_border=1.0, num_variables=3, h_per_variable=0.1)
```

--------------------------------

### Inverse Transform Floating-Point to Binary (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Inverse transforms a floating-point population into a binary array using the SamplingGrid parameters. Requires numpy and the SamplingGrid class from thefittest.utils.transformations.

```python
print("Inverse Transformed Population:", grid.inverse_transform(floating_population))
```

--------------------------------

### Initialize GeneticProgrammingNeuralNetClassifier in Python

Source: https://sherstpasha.github.io/thefittest/modules/classifiers

Creates a genetic programming neural net classifier with parameters for controlling network architecture, optimization, and training process. Suitable for complex classification tasks combining neural networks and genetic algorithms.

```python
class thefittest.classifiers.GeneticProgrammingNeuralNetClassifier(*, n_iter: int = 15, pop_size: int = 50, input_block_size: int = 1, max_hidden_block_size: int = 9, offset: bool = True, test_sample_ratio: float = 0.5, optimizer: ~typing.Type[~thefittest.optimizers._selfcgp.SelfCGP] | ~typing.Type[~thefittest.optimizers._geneticprogramming.GeneticProgramming] = <class 'thefittest.optimizers._selfcgp.SelfCGP'>, optimizer_args: dict[str, ~typing.Any] | None = None, weights_optimizer: ~typing.Type[~thefittest.optimizers._differentialevolution.DifferentialEvolution] | ~typing.Type[~thefittest.optimizers._jde.jDE] | ~typing.Type[~thefittest.optimizers._shade.SHADE] | ~typing.Type[~thefittest.optimizers._geneticalgorithm.GeneticAlgorithm] | ~typing.Type[~thefittest.optimizers._selfcga.SelfCGA] | ~typing.Type[~thefittest.optimizers._shaga.SHAGA] = <class 'thefittest.optimizers._shade.SHADE'>, weights_optimizer_args: dict[str, ~typing.Any] | None = None, net_size_penalty: float = 0.0, random_state: int | ~numpy.random.mtrand.RandomState | None = None)
```

--------------------------------

### PDPGP Optimizer

Source: https://sherstpasha.github.io/thefittest/modules/optimizers

Parameter-less Population-based Genetic Programming with adaptive operator probabilities. Implements genetic programming with automatic parameter adaptation.

```APIDOC
## PDPGP Optimizer

### Description
Parameter-less Population-based Genetic Programming with adaptive operator probabilities. Implements genetic programming with automatic parameter adaptation.

### Method
Constructor

### Endpoint
thefittest.optimizers.PDPGP

### Parameters
#### Required Parameters
- **fitness_function** (Callable) - Required - Function to evaluate individual fitness
- **uniset** (UniversalSet) - Required - Universal set for GP
- **iters** (int) - Required - Number of iterations
- **pop_size** (int) - Required - Population size

#### Optional Parameters
- **tour_size** (int) - Optional - Tournament size, default 2
- **mutation_rate** (float) - Optional - Mutation rate, default 0.05
- **parents_num** (int) - Optional - Number of parents, default 2
- **elitism** (bool) - Optional - Enable elitism, default True
- **max_level** (int) - Optional - Maximum tree level, default 16
- **init_level** (int) - Optional - Initial tree level, default 4

### Methods
- **binary_string_population** - Generate binary string population
- **fit** - Execute optimization process
- **get_fittest** - Get best individual
- **get_remains_calls** - Get remaining function calls
- **get_stats** - Get optimization statistics
- **half_and_half** - Generate population with half-and-half method
```

--------------------------------

### PDPGA Optimizer

Source: https://sherstpasha.github.io/thefittest/modules/optimizers

Parameter-less Population-based Genetic Algorithm with adaptive operator probabilities. Implements the PDPGA optimization algorithm for binary string optimization problems.

```APIDOC
## PDPGA Optimizer

### Description
Parameter-less Population-based Genetic Algorithm with adaptive operator probabilities. Implements the PDPGA optimization algorithm for binary string optimization problems.

### Method
Constructor

### Endpoint
thefittest.optimizers.PDPGA

### Parameters
#### Required Parameters
- **fitness_function** (Callable) - Required - Function to evaluate individual fitness
- **iters** (int) - Required - Number of iterations
- **pop_size** (int) - Required - Population size
- **str_len** (int) - Required - Length of binary strings

#### Optional Parameters
- **tour_size** (int) - Optional - Tournament size, default 2
- **mutation_rate** (float) - Optional - Mutation rate, default 0.05
- **parents_num** (int) - Optional - Number of parents, default 2
- **elitism** (bool) - Optional - Enable elitism, default True

### Methods
- **binary_string_population** - Generate binary string population
- **fit** - Execute optimization process
- **get_fittest** - Get best individual
- **get_remains_calls** - Get remaining function calls
- **get_stats** - Get optimization statistics
```

--------------------------------

### GrayCode: Inverse Transforming Floating-Point to Gray Code

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Generates a random floating-point population and uses the fitted GrayCode grid to inverse transform it into gray code representation. Relies on NumPy for random generation and array handling. Inputs are floating-point arrays; outputs are binary gray code arrays, limited to the fitted grid bounds.

```python
# Generate a floating-point population
floating_population = np.random.rand(5, 3)
print("Floating-point Population:", floating_population)
Floating-point Population: ...

# Inverse transform the floating-point population to a gray code array
inverse_transformed_population = grid.inverse_transform(floating_population)
print("Inverse Transformed Population (Gray Code):", inverse_transformed_population)
Inverse Transformed Population (Gray Code): ...
```

--------------------------------

### Initialize GeneticProgrammingClassifier in Python

Source: https://sherstpasha.github.io/thefittest/modules/classifiers

Creates a genetic programming classifier with customizable parameters including number of iterations, population size, functional set, and optimizer. This is used for classification tasks using genetic programming techniques.

```python
class thefittest.classifiers.GeneticProgrammingClassifier(*, n_iter: int = 300, pop_size: int = 1000, functional_set_names: ~typing.Tuple[str, ...] = ('cos', 'sin', 'add', 'sub', 'mul', 'div'), optimizer: ~typing.Type[~thefittest.optimizers._selfcgp.SelfCGP] | ~typing.Type[~thefittest.optimizers._geneticprogramming.GeneticProgramming] = <class 'thefittest.optimizers._selfcgp.SelfCGP'>, optimizer_args: dict[str, ~typing.Any] | None = None, random_state: int | ~numpy.random.mtrand.RandomState | None = None)
```

--------------------------------

### Uniform Rank Crossover for Genetic Programming

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Implements uniform rank crossover for genetic programming trees. Combines genetic material from multiple parent trees where selection probability is proportional to rank values. Takes fitness, rank arrays, and maximum depth constraint. Returns a new Tree offspring representing the crossover result. Used in symbolic regression with tree-based genetic programming.

```python
import numpy as np
from thefittest.utils.crossovers import uniform_rank_crossover_GP
from thefittest.base import Tree
from thefittest.base import init_symbolic_regression_uniset

# Example

X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
functional_set_names = ("add", "mul")
max_tree_level = 5

# Initialize Universal Set for Symbolic Regression
universal_set = init_symbolic_regression_uniset(X, functional_set_names)

parent1 = Tree.random_tree(universal_set, max_tree_level)
parent2 = Tree.random_tree(universal_set, max_tree_level)
parent3 = Tree.random_tree(universal_set, max_tree_level)

fitness_values = np.array([0.5, 0.8, 0.6], dtype=np.float64)
ranks = np.array([2.0, 1.0, 3.0], dtype=np.float64)
max_depth = 7  # Set the maximum allowed depth

# Perform uniform rank crossover
offspring = uniform_rank_crossover_GP(np.array([parent1, parent2, parent3]), fitness_values, ranks, max_depth)

# Display results
print("Parent 1:", parent1)
Parent 1: ...
print("Parent 2:", parent2)
Parent 2: ...
print("Parent 3:", parent3)
Parent 3: ...
print("Offspring After Uniform Rank Crossover:", offspring)
Offspring After Uniform Rank Crossover: ...
```

--------------------------------

### SamplingGrid Inverse Transform API

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Inverse transforms a floating-point population into a binary array based on the SamplingGrid parameters.

```APIDOC
## POST /api/samplinggrid/inverse_transform

### Description
Inverse transform a floating-point population into a binary array based on the SamplingGrid parameters.

### Method
POST

### Endpoint
/api/samplinggrid/inverse_transform

### Parameters
#### Request Body
- **population** (NDArray[np.float64]) - Required - The floating-point population to transform.

### Request Example
```json
{
  "population": [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]]
}
```

### Response
#### Success Response (200)
- **inverse_transformed_population** (NDArray[np.int8]) - The inverse transformed binary array.

#### Response Example
```json
{
  "inverse_transformed_population": [[1, 0, 1], [0, 1, 1]]
}
```
```

--------------------------------

### Inverse Transform Floating-Point Population to Binary Array with SamplingGrid

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Performs an inverse transformation of a floating-point population matrix into a binary array. This method uses the SamplingGrid parameters set during the 'fit' method to encode floating-point values back into their binary equivalents.

```python
import numpy as np
from thefittest.utils.transformations import SamplingGrid

# Fit the sampling grid
grid = SamplingGrid()
grid.fit(left_border=0.0, right_border=1.0, num_variables=3, h_per_variable=0.1)

# Generate a floating-point population
floating_population = np.random.rand(5, 3)
print("Floating-point Population:", floating_population)

# Inverse transform the floating-point population to a binary array
print("Inverse Transformed Population:", grid.inverse_transform(floating_population))
```

--------------------------------

### SamplingGrid Transform API

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Transforms a binary population into a floating-point array based on the SamplingGrid parameters.

```APIDOC
## POST /api/samplinggrid/transform

### Description
Transform a binary population into a floating-point array based on the SamplingGrid parameters.

### Method
POST

### Endpoint
/api/samplinggrid/transform

### Parameters
#### Request Body
- **population** (NDArray[np.int8]) - Required - The binary population to transform.

### Request Example
```json
{
  "population": [[1, 0, 1], [0, 1, 1]]
}
```

### Response
#### Success Response (200)
- **transformed_population** (NDArray[np.float64]) - The transformed floating-point array.

#### Response Example
```json
{
  "transformed_population": [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]]
}
```
```

--------------------------------

### Perform current-to-pbest-1-archive Mutation (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/mutations

Applies the current-to-pbest-1-archive mutation strategy for differential evolution. It combines the current individual with a scaled difference involving best individuals and randomly chosen individuals from the population and archive. Dependencies: NumPy.

```python
from thefittest.utils.mutations import current_to_pbest_1_archive
import numpy as np

# Example
current_individual = np.array([0.5, 0.3, 0.8], dtype=np.float64)
population = np.array([[0.2, 0.1, 0.5], [0.8, 0.6, 0.9], [0.3, 0.7, 0.4], [0.9, 0.5, 0.2]], dtype=np.float64)
pbest_indices = np.array([1, 3], dtype=np.int64)
mutation_scale_factor = 0.7
pop_archive = np.array([[0.1, 0.3, 0.6], [0.7, 0.4, 0.8], [0.4, 0.2, 0.5]], dtype=np.float64)
mutated_individual = current_to_pbest_1_archive(current_individual, population, pbest_indices, mutation_scale_factor, pop_archive)
print("Current Individual:", current_individual)
print("Mutated Individual:", mutated_individual)
```

--------------------------------

### Transform Binary Population to Floating-Point (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Transforms a binary population into a floating-point array using the SamplingGrid parameters. Requires numpy and the SamplingGrid class from thefittest.utils.transformations.

```python
print("Transformed Population:", grid.transform(binary_population))
```

--------------------------------

### GrayCode: Static Binary to Gray Code Conversion

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Converts a 2D binary array to gray code using the static bit_to_gray method. Each row represents a binary number transformed bit-wise. No external dependencies beyond NumPy; inputs are byte arrays, outputs are equivalent gray code arrays with single-bit differences between successors.

```python
import numpy as np
from thefittest.utils.transformations import GrayCode

# Example: Convert binary array to gray code array using GrayCode.bit_to_gray method
binary_array = np.array([[1, 0, 1], [0, 1, 0]], dtype=np.byte)
result = GrayCode.bit_to_gray(binary_array)
print("Converted Gray Code Array:", result)
Converted Gray Code Array: ...
```

--------------------------------

### SHADE Optimizer

Source: https://sherstpasha.github.io/thefittest/modules/optimizers

Success-history based parameter adaptation for Differential Evolution. Implements the SHADE algorithm for continuous optimization problems.

```APIDOC
## SHADE Optimizer

### Description
Success-history based parameter adaptation for Differential Evolution. Implements the SHADE algorithm for continuous optimization problems.

### Method
Constructor

### Endpoint
thefittest.optimizers.SHADE

### Parameters
#### Required Parameters
- **fitness_function** (Callable) - Required - Function to evaluate individual fitness
- **iters** (int) - Required - Number of iterations
- **pop_size** (int) - Required - Population size
- **left_border** (float|int|ndarray) - Required - Left boundary for search space
- **right_border** (float|int|ndarray) - Required - Right boundary for search space
- **num_variables** (int) - Required - Number of variables

#### Optional Parameters
- **elitism** (bool) - Optional - Enable elitism, default True

### Methods
- **fit** - Execute optimization process
- **float_population** - Generate float population
- **get_fittest** - Get best individual
- **get_remains_calls** - Get remaining function calls
- **get_stats** - Get optimization statistics
```

--------------------------------

### SamplingGrid Static Bit to Integer Conversion API

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Converts a binary array to an integer array using specified powers, or calculates powers if not provided.

```APIDOC
## POST /api/samplinggrid/bit_to_int

### Description
Convert a binary array to an integer array using specified powers. If powers are not provided, they will be calculated.

### Method
POST

### Endpoint
/api/samplinggrid/bit_to_int

### Parameters
#### Request Body
- **bit_array** (NDArray[np.int64]) - Required - 2D array where each row represents a binary number.
- **powers** (Optional[NDArray[np.int64]]) - Optional - 1D array of powers of 2 corresponding to the binary places. If provided, avoids recalculation.

### Request Example
```json
{
  "bit_array": [[1, 0, 1], [0, 1, 1]]
}
```

### Response
#### Success Response (200)
- **integer_array** (NDArray[np.int64]) - 1D array representing the integer values converted from binary.

#### Response Example
```json
{
  "integer_array": [5, 3]
}
```
```

--------------------------------

### BreastCancerDataset

Source: https://sherstpasha.github.io/thefittest/modules/benchmarks

Provides breast cancer diagnostic dataset containing cell nucleus measurements.

```APIDOC
## _class_ thefittest.benchmarks.BreastCancerDataset

### Description
Breast Cancer Wisconsin (Diagnostic) dataset from UCI ML Repository. Contains features computed from digitized images of fine needle aspirate of breast masses.

### Methods
- `get_X()` - Get feature matrix
- `get_X_names()` - Get feature names
- `get_y()` - Get target values
- `get_y_names()` - Get target names
```

--------------------------------

### Python Sattolo Shuffle for 1D Array

Source: https://sherstpasha.github.io/thefittest/modules/utils/random

Performs in-place Sattolo’s algorithm to shuffle a 1D array, generating a random cyclic permutation. Inputs an int64 array, outputs the shuffled array using numba for JIT compilation. Suitable for generating permutations but modifies the input array directly.

```python
from numba import jit
import numpy as np
from thefittest.utils.random import sattolo_shuffle
# Example of using Sattolo's shuffle
arr = np.array([1, 2, 3, 4, 5], dtype = np.int64)
print("Shuffled Array:", sattolo_shuffle(arr))
```

--------------------------------

### Uniform Tournament Crossover (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

This code snippet showcases the uniform tournament crossover operation using Python, NumPy, and the custom Tree data structure. It takes multiple parent trees, their fitness values, ranks, and a maximum depth as input. The output is an offspring tree resulting from the crossover process.

```python
>>> import numpy as np
>>> from thefittest.utils.crossovers import uniform_tournament_crossover_GP
>>> from thefittest.base import Tree
>>> from thefittest.base import init_symbolic_regression_uniset
>>>
>>> # Example
>>>
>>> X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
>>> functional_set_names = ("add", "mul")
>>> max_tree_level = 5
>>>
>>> # Initialize Universal Set for Symbolic Regression
>>> universal_set = init_symbolic_regression_uniset(X, functional_set_names)
>>>
>>> parent1 = Tree.random_tree(universal_set, max_tree_level)
>>> parent2 = Tree.random_tree(universal_set, max_tree_level)
>>> parent3 = Tree.random_tree(universal_set, max_tree_level)
>>>
>>> fitness_values = np.array([0.5, 0.8, 0.6], dtype=np.float64)
>>> ranks = np.array([2.0, 1.0, 3.0], dtype=np.float64)
>>> max_depth = 7  # Set the maximum allowed depth
>>>
>>> # Perform uniform tournament crossover
>>> offspring = uniform_tournament_crossover_GP(np.array([parent1, parent2, parent3]), fitness_values, ranks, max_depth)
>>>
>>> # Display results
>>> print("Parent 1:", parent1)
>>> print("Parent 2:", parent2)
>>> print("Parent 3:", parent3)
>>> print("Offspring After Uniform Tournament Crossover:", offspring)
```

--------------------------------

### Growing mutation in Python

Source: https://sherstpasha.github.io/thefittest/modules/utils/mutations

Performs growing mutation for trees in genetic programming. Replaces nodes with new subtrees based on probability. Requires numpy and thefittest Tree class.

```Python
>>> import numpy as np
>>> from thefittest.base import Tree
>>> from thefittest.base import init_symbolic_regression_uniset
>>> from thefittest.utils.mutations import growing_mutation
>>> # Example Parameters
>>> X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
>>> functional_set_names = ("add", "mul")
>>> max_tree_level = 4
>>> mutation_probability = 0.5
>>> # Initialize Universal Set for Symbolic Regression
>>> universal_set = init_symbolic_regression_uniset(X, functional_set_names)
>>> # Generate a Random Tree
>>> tree = Tree.random_tree(universal_set, max_tree_level)
>>> # Perform Growing Mutation
>>> mutated_tree = growing_mutation(tree, universal_set, mutation_probability, max_tree_level)
>>> print("Original Tree:", tree)
Original Tree: ...
>>> print("Mutated Tree:", mutated_tree)
Mutated Tree: ...
```

--------------------------------

### Transform Binary Population to Floating-Point Array with SamplingGrid

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Transforms a binary population matrix into a floating-point array based on SamplingGrid parameters. It decodes binary representations to integers and then calculates corresponding floating-point values.

```python
import numpy as np
from thefittest.utils.transformations import SamplingGrid

# Fit the sampling grid
grid = SamplingGrid()
grid.fit(left_border=-5.0, right_border=5.0, num_variables=3, h_per_variable=0.1)

# Generate a binary population
string_length = grid.get_bits_per_variable().sum()
binary_population = np.random.randint(2, size=(5, string_length), dtype=np.int8)

# Transform the binary population to a floating-point array
print("Transformed Population:", grid.transform(binary_population))
```

--------------------------------

### Perform one-point crossover for genetic programming

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Execute a one-point crossover operation for genetic programming. This function selects a common region between two parent trees and exchanges genetic material at a randomly chosen point within this region. The function takes individuals, fitness values, ranks, and maximum level as inputs, but only uses the individuals for the operation. The resulting offspring is a combination of genetic material from both parents.

```python
>>> import numpy as np
>>> from thefittest.utils.crossovers import one_point_crossoverGP
>>> from thefittest.base import Tree
>>> from thefittest.base import init_symbolic_regression_uniset
>>>
>>> # Example
>>>
>>> X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
>>> functional_set_names = ("add", "mul")
>>> max_tree_level = 5
>>>
>>> # Initialize Universal Set for Symbolic Regression
>>> universal_set = init_symbolic_regression_uniset(X, functional_set_names)
>>>
>>> parent1 = Tree.random_tree(universal_set, max_tree_level)
>>> parent2 = Tree.random_tree(universal_set, max_tree_level)
>>>
>>> fitness_values = np.array([0.5, 0.8], dtype=np.float64)
>>> ranks = np.array([2.0, 1.0], dtype=np.float64)
>>> max_depth = 7
>>>
>>> # Perform one-point crossover
>>> offspring = one_point_crossoverGP(np.array([parent1, parent2]), fitness_values, ranks, max_depth)
>>>
```

--------------------------------

### Perform one-point crossover for genetic algorithm

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Execute a one-point crossover operation for genetic algorithms. This function randomly selects a crossover point and swaps genetic material between two parent chromosomes beyond this point. The function requires individuals, fitness values, and ranks as inputs but only uses the individuals for the crossover operation. One of the two resulting offspring is returned randomly.

```python
>>> import numpy as np
>>> from thefittest.utils.crossovers import one_point_crossover
>>>
>>> # Example
>>> # Define the parents, fitness values, and ranks
>>> parents = np.array([[1, 0, 1], [0, 1, 1]], dtype=np.byte)  # First and second parent
>>> fitness_values = np.array([0.5, 0.8], dtype=np.float64)
>>> ranks = np.array([2.0, 1.0], dtype=np.float64)
>>>
>>> # Perform one_point crossover
>>> offspring = one_point_crossover(parents, fitness_values, ranks)
>>>
>>> # Display results
>>> print("Original Individuals:", parents)
Original Individuals: ...
>>> print("Offspring After Empty Crossover:", offspring)
Offspring After Empty Crossover: ...
```

--------------------------------

### GrayCode: Static Gray Code to Binary Conversion

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Reverses gray code to binary using the static gray_to_bit method on a 2D array. Ensures proper decoding for genetic representations. Inputs are byte gray code arrays; outputs are binary arrays, with limitations to valid gray code inputs to avoid errors.

```python
import numpy as np
from thefittest.utils.transformations import GrayCode

# Example: Convert gray code array to binary array using GrayCode.gray_to_bit method
gray_array = np.array([[1, 0, 1], [0, 1, 0]], dtype=np.byte)
result = GrayCode.gray_to_bit(gray_array)
print("Converted Binary Array:", result)
Converted Binary Array: ...
```

--------------------------------

### Ackley Benchmark Function

Source: https://sherstpasha.github.io/thefittest/modules/benchmarks

Provides the Ackley benchmark function for optimization testing. The function is commonly used to test optimization algorithms.

```APIDOC
## _class_ thefittest.benchmarks.Ackley

### Description
Ackley benchmark function for optimization algorithms. Tests algorithm performance on a multimodal landscape with many local minima.

### Methods
- `__call__(x)` - Call self as a function
- `build_grid()` - Build evaluation grid
- `f(x)` - Evaluate Ackley function

### Parameters
#### Function Input
- **x** (ndarray[Any, dtype[float64]]) - Required - Input vector to evaluate

### Returns
- **ndarray[Any, dtype[float64]]** - Function evaluation result
```

--------------------------------

### Point mutation in Python

Source: https://sherstpasha.github.io/thefittest/modules/utils/mutations

Performs point mutation for trees in genetic programming. Replaces nodes with random nodes from universal set based on probability. Requires numpy and thefittest Tree class.

```Python
>>> import numpy as np
>>> from thefittest.base import Tree
>>> from thefittest.base import init_symbolic_regression_uniset
>>> from thefittest.utils.mutations import point_mutation
>>> # Example Parameters
>>> X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
>>> functional_set_names = ("add", "mul")
>>> max_tree_level = 4
>>> mutation_probability = 0.5
>>> # Initialize Universal Set for Symbolic Regression
>>> universal_set = init_symbolic_regression_uniset(X, functional_set_names)
>>> # Generate a Random Tree
>>> tree = Tree.random_tree(universal_set, max_tree_level)
>>> # Perform Point Mutation
>>> mutated_tree = point_mutation(tree, universal_set, mutation_probability, max_tree_level)
>>> print("Original Tree:", tree)
Original Tree: ...
>>> print("Mutated Tree:", mutated_tree)
Mutated Tree: ...
```

--------------------------------

### Perform empty crossover for genetic programming

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Execute an empty crossover operation that returns a copy of the first parent individual. This function is primarily used for testing or as a baseline comparison. The function takes individuals, fitness values, ranks, and maximum tree level as inputs but only uses the individuals for the operation.

```python
>>> import numpy as np
>>> from thefittest.utils.crossovers import empty_crossoverGP
>>> from thefittest.base import Tree
>>> from thefittest.base import init_symbolic_regression_uniset
>>>
>>> # Example
>>> X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
>>> functional_set_names = ("add", "mul")
>>> max_tree_level = 5
>>>
>>> # Initialize Universal Set for Symbolic Regression
>>> universal_set = init_symbolic_regression_uniset(X, functional_set_names)
>>>
>>> # Define the parents, fitness values, ranks, and maximum allowed depth
>>> parents = np.array([Tree.random_tree(universal_set, max_tree_level)], dtype=object)
>>> fitness_values = np.array([0.8], dtype=np.float64)
>>> ranks = np.array([1.0], dtype=np.float64)
>>> max_depth = 7
>>>
>>> # Perform empty crossover for genetic programming
>>> offspring = empty_crossoverGP(parents, fitness_values, ranks, max_depth)
>>>
>>> print("Original Individual:", parents[0])
Original Individual: ...
>>> print("Offspring After Empty Crossover (GP):", offspring)
Offspring After Empty Crossover (GP): ...
```

--------------------------------

### Perform Uniform Crossover (Python)

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

This function executes a uniform crossover, where each gene in the offspring is inherited from either parent with a certain probability (typically 0.5). It's a common method for creating diverse offspring in genetic algorithms.

```python
import numpy as np
from thefittest.utils.crossovers import uniform_crossover

parents = np.array([[1, 0, 1, 0], [0, 1, 1, 1]], dtype=np.byte)  # First and second parent
fitness_values = np.array([0.5, 0.8], dtype=np.float64)
ranks = np.array([2.0, 1.0], dtype=np.float64)

offspring = uniform_crossover(parents, fitness_values, ranks)

print("Original Individuals:", parents)
print("Offspring After Uniform Crossover:", offspring)
```

--------------------------------

### Binomial Crossover (SHAGA)

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Implements binomial crossover for the Genetic Algorithm with Success History based Parameter Adaptation (SHAGA). It operates on binary chromosomes and returns offspring based on the crossover probability.  It takes two binary individuals and a crossover probability as input.

```python
>>> import numpy as np
>>> from thefittest.utils.crossovers import binomialGA
>>>
>>> # Example
>>> # Define a binary individual, a binary mutant, and the crossover probability
>>> individ = np.array([1, 0, 1, 0, 1], dtype=np.int8)
>>> mutant = np.array([0, 1, 0, 1, 0], dtype=np.int8)
>>> CR = 0.8
>>>
>>> # Perform binomial crossover for SHAGA
>>> offspring = binomialGA(individ, mutant, CR)
>>>
>>> # Display results
>>> print("Original Binary Individual:", individ)
>>> print("Mutant Binary Individual:", mutant)
>>> print("Offspring After Binomial Crossover (SHAGA):", offspring)
```

--------------------------------

### Perform uniform rank crossover in genetic algorithms

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

This function performs a uniform rank crossover operation for genetic algorithms. It randomly selects genetic material from parents for each gene, with selection probability proportional to rank values. Requires numpy arrays of individuals, fitness values, and ranks.

```Python
import numpy as np
from thefittest.utils.crossovers import uniform_rank_crossover

parents = np.array([[1, 0, 1, 0], [0, 1, 1, 1]], dtype=np.byte)
fitness_values = np.array([0.5, 0.8], dtype=np.float64)
ranks = np.array([2.0, 1.0], dtype=np.float64)

offspring = uniform_rank_crossover(parents, fitness_values, ranks)
```

--------------------------------

### Perform uniform proportional crossover in genetic algorithm

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

This function performs a uniform proportional crossover operation where the probability of selecting genetic material from a parent is proportional to its fitness value. It takes parents, fitness values, and ranks as input, returning a new offspring chromosome.

```Python
>>> import numpy as np
>>> from thefittest.utils.crossovers import uniform_proportional_crossover
>>>
>>> # Example
>>> # Define the parents, fitness values, and ranks
>>> parents = np.array([[1, 0, 1, 0], [0, 1, 1, 1]], dtype=np.byte)  # First and second parent
>>> fitness_values = np.array([0.5, 0.8], dtype=np.float64)
>>> ranks = np.array([2.0, 1.0], dtype=np.float64)
>>>
>>> # Perform uniform proportional crossover
>>> offspring = uniform_proportional_crossover(parents, fitness_values, ranks)
>>>
>>> # Display results
>>> print("Original Individuals:", parents)
Original Individuals: ...
>>> print("Offspring After Uniform Proportional Crossover:", offspring)
Offspring After Uniform Proportional Crossover: ...
```

--------------------------------

### Generate random integers with thefittest.utils.random.randint

Source: https://sherstpasha.github.io/thefittest/modules/utils/random

Produces an ndarray of random integers from a discrete uniform distribution between low (inclusive) and high (exclusive). Accepts size to control output length. Returns a NumPy int64 array.

```python
from numba import jit
import numpy as np
from thefittest.utils.random import randint

# Example of generating random integers
result = randint(low=1, high=10, size=5)
print("Random Integers:", result)
```

--------------------------------

### GrayCode: Fitting Sampling Grid and Transforming Gray Code Population

Source: https://sherstpasha.github.io/thefittest/modules/utils/transformations

Fits a GrayCode sampling grid with specified borders, variables, and step size, then generates a random gray code population and transforms it to floating-point values. Depends on NumPy for array operations. Inputs include borders and step size; outputs are transformed floating-point arrays within the defined grid.

```python
import numpy as np
from thefittest.utils.transformations import GrayCode

# Fit the sampling grid with gray code transformation
grid = GrayCode()
grid.fit(left_border=-5.0, right_border=5.0, num_variables=3, h_per_variable=0.1)
<thefittest.utils.transformations.GrayCode object at ...>
# Generate a binary population using gray code
string_length = grid.get_bits_per_variable().sum()
gray_population = np.random.randint(2, size=(5, string_length), dtype=np.byte)
print("Gray Code Population:", gray_population)
Gray Code Population: ...
# Transform the gray code population to a floating-point array
print("Transformed Population:", grid.transform(gray_population))
Transformed Population: ...
```

--------------------------------

### Uniform Tournament Crossover for Genetic Programming

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

Implements uniform tournament crossover for genetic programming tree structures. Applies tournament selection to tree-based genetic programming where parent selection for each gene/position is determined by fitness-based tournament competition. Takes parent tree array, fitness values, rank values (not used), and maximum tree depth. Returns Tree offspring. Used in tree-based genetic programming for symbolic regression and expression evolution.

```python
import numpy as np
from thefittest.utils.crossovers import uniform_tournament_crossover_GP

# Initialize parameters
X = np.array([[0.3, 0.7], [0.3, 1.1], [3.5, 11.0]], dtype=np.float64)
functional_set_names = ("add", "mul", "sin", "cos")
max_tree_level = 5

# Create parent trees (pseudo-code, actual implementation would use Tree class)
# parent1 = Tree.random_tree(universal_set, max_tree_level)
# parent2 = Tree.random_tree(universal_set, max_tree_level)

parents = np.array([parent1, parent2])
fitness_values = np.array([0.5, 0.8], dtype=np.float64)
ranks = np.array([2.0, 1.0], dtype=np.float64)
max_depth = 7

# Perform uniform tournament crossover for GP
offspring = uniform_tournament_crossover_GP(parents, fitness_values, ranks, max_depth)

print("Parent 1:", parent1)
print("Parent 2:", parent2)
print("Offspring:", offspring)
```

--------------------------------

### Python Sattolo Shuffle for 2D Array Rows

Source: https://sherstpasha.github.io/thefittest/modules/utils/random

Applies Sattolo’s algorithm to shuffle rows in a 2D array in-place, producing a cyclic permutation of rows. Takes a 2D int64 array as input and returns the shuffled array. Relies on numba JIT; ideal for row permutations in matrices but alters the original array.

```python
from numba import jit
import numpy as np
from thefittest.utils.random import sattolo_shuffle_2d
# Example of using Sattolo's shuffle for a 2D array
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Shuffled 2D Array:", sattolo_shuffle_2d(arr_2d))
```

--------------------------------

### Flip mutation in Python

Source: https://sherstpasha.github.io/thefittest/modules/utils/mutations

Performs flip mutation on binary representations in genetic algorithms. Randomly flips bits based on given probability. Requires numpy for array operations.

```Python
>>> from thefittest.utils.mutations import flip_mutation
>>> import numpy as np
>>>
>>> # Example
>>> original_individual = np.array([0, 1, 1, 0, 1], dtype=np.byte)
>>> mutation_probability = 0.1
>>> mutated_individual = flip_mutation(original_individual, mutation_probability)
>>> print("Original Individual:", original_individual)
Original Individual: [0 1 1 0 1]
>>> print("Mutated Individual:", mutated_individual)
Mutated Individual: ...
```

--------------------------------

### Set score request metadata in Python

Source: https://sherstpasha.github.io/thefittest/modules/classifiers

Configures metadata routing for the score method in genetic programming classifiers. Essential when using these classifiers within scikit-learn pipelines with metadata routing enabled.

```python
set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') -> GeneticProgrammingClassifier
```

```python
set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') -> GeneticProgrammingNeuralNetClassifier
```

--------------------------------

### Perform uniform crossover in genetic algorithm

Source: https://sherstpasha.github.io/thefittest/modules/utils/crossovers

This function performs a uniform crossover operation between two parents in a genetic algorithm. Each gene of the offspring is randomly selected from one of the parents. The function takes parents, fitness values, and ranks as input and returns a new offspring chromosome.

```Python
>>> import numpy as np
>>> from thefittest.utils.crossovers import uniform_crossover
>>>
>>> # Example
>>> # Define the parents, fitness values, and ranks
>>> parents = np.array([[1, 0, 1, 0], [0, 1, 1, 1]], dtype=np.byte)  # First and second parent
>>> fitness_values = np.array([0.5, 0.8], dtype=np.float64)
>>> ranks = np.array([2.0, 1.0], dtype=np.float64)
>>>
>>> # Perform uniform crossover
>>> offspring = uniform_crossover(parents, fitness_values, ranks)
>>>
>>> # Display results
>>> print("Original Individuals:", parents)
Original Individuals: ...
>>> print("Offspring After Uniform Crossover:", offspring)
Offspring After Uniform Crossover: ...
```

--------------------------------

### Python Uniform Random Sample Generation

Source: https://sherstpasha.github.io/thefittest/modules/utils/random

Generates an array of random samples from a uniform distribution within specified bounds. Requires low, high, and size parameters; returns a 1D numpy float64 array. Useful for simulations but ensures all values are within the interval inclusively.

```python
from thefittest.utils.random import uniform
# Example of generating random samples
result = uniform(low=0.0, high=1.0, size=5)
print("Random Samples:", result)
```
Tokens:
Raw