tessl/pypi-nevergrad
A Python toolbox for performing gradient-free optimization with unified interfaces for optimization algorithms and parameter handling.
—
Pending
parametrization.mddocs/
Parametrization System
Comprehensive parameter handling system that supports scalar values, arrays, discrete choices, hierarchical structures, and constraints. The parametrization module provides the foundation for defining optimization search spaces with sophisticated parameter types and transformations.
Capabilities
Core Parameter Base Class
The fundamental Parameter class that all parameter types inherit from, providing common functionality for mutation, sampling, and value management.
class Parameter:
"""
Abstract base class for all parameter types.
Properties:
- value: The main value property (Any)
- losses: Multi-objective losses (ArrayLike)
- args: Positional arguments (Tuple[Any, ...])
- kwargs: Keyword arguments (Dict[str, Any])
- dimension: Parameter dimension (int)
- generation: Current generation (int)
- random_state: Random state (np.random.RandomState)
"""
value: Any
losses: ArrayLike
args: Tuple[Any, ...]
kwargs: Dict[str, Any]
dimension: int
generation: int
random_state: np.random.RandomState
def mutate(self) -> None:
"""Mutate parameter in place."""
def sample(self) -> 'Parameter':
"""Create new sample."""
def recombine(self, *others) -> 'Parameter':
"""Recombine with other parameters."""
def get_standardized_data(self, *, reference) -> np.ndarray:
"""Get standardized representation."""
def set_standardized_data(self, data: np.ndarray, *, reference=None) -> None:
"""Set from standardized data."""
def get_value_hash(self) -> str:
"""Get value hash."""
def satisfies_constraints(self, ref=None, no_tabu=False) -> bool:
"""Check constraints."""
def spawn_child(self, new_value=None) -> 'Parameter':
"""Create child parameter."""
def copy(self) -> 'Parameter':
"""Create parameter copy."""
def freeze(self) -> 'Parameter':
"""Freeze parameter (immutable)."""
class Constant(Parameter):
"""Parameter with constant, unchanging value."""
class MultiobjectiveReference(Constant):
"""Reference parameter for multi-objective optimization scenarios."""Data Parameter Types
Fundamental parameter types for continuous optimization including scalars, arrays, and log-scale parameters with support for bounds and constraints.
class Data(Parameter):
"""
Base class for continuous data parameters.
Properties:
- bounds: Parameter bounds (Tuple[float, float])
- sigma: Mutation sigma parameter (float)
- integer: Integer-valued flag (bool)
"""
bounds: Tuple[float, float]
sigma: float
integer: bool
def set_bounds(self, lower: float, upper: float, method: str = "clipping") -> 'Data':
"""Set parameter bounds."""
def set_mutation(self, sigma: float = None) -> 'Data':
"""Configure mutation parameters."""
def set_integer_casting(self) -> 'Data':
"""Enable integer casting."""
class Array(Data):
"""
Multi-dimensional array parameter for vector/matrix optimization.
Parameters:
- shape: Array shape (tuple)
- init: Initialization method
"""
class Scalar(Data):
"""
Single scalar parameter for single-valued optimization.
Parameters:
- init: Initial value (float)
"""
class Log(Scalar):
"""
Log-scale scalar parameter for log-distributed values.
Parameters:
- init: Initial value (float)
- lower: Lower bound (float)
- upper: Upper bound (float)
"""Container Parameter Types
Hierarchical parameter containers that organize multiple parameters into structured collections with dictionary and tuple semantics.
class Container(Parameter):
"""Base class for parameter containers."""
class Dict(Container):
"""
Dictionary-like parameter container.
Methods provide dictionary-like access to contained parameters.
"""
def keys(self) -> KeysView:
"""Get parameter keys."""
def items(self) -> ItemsView:
"""Get parameter items."""
def values(self) -> ValuesView:
"""Get parameter values."""
class Tuple(Container):
"""Tuple-like parameter container for ordered collections."""
class Instrumentation(Tuple):
"""
Special tuple for function instrumentation with positional and keyword arguments.
Automatically handles conversion between parameter values and function arguments.
"""Choice Parameter Types
Discrete choice parameters for categorical variables and selection from finite sets with support for uniform and weighted selection probabilities.
class BaseChoice(Container):
"""Base class for discrete choice parameters."""
class Choice(BaseChoice):
"""
Discrete choice parameter with uniform selection probabilities.
Parameters:
- choices: Available choices (list or iterable)
"""
class TransitionChoice(BaseChoice):
"""
Choice parameter with configurable transition probabilities.
Parameters:
- choices: Available choices (list)
- transitions: Transition probability matrix
"""Special Parameter Types
Specialized parameter types for specific domains including angular parameters and constraint handling.
class Angles:
"""
Angular parameter handling for circular/periodic variables.
Handles wrap-around behavior and appropriate distance metrics
for angular/periodic optimization variables.
"""Mutation System
Comprehensive mutation operators that define how parameters change during optimization, supporting various probability distributions and crossover strategies.
class Mutation:
"""Base mutation class."""
class DataMutation(Mutation):
"""Mutation operators for data parameters."""
class MutationChoice:
"""Choice-based mutation operators."""
class Cauchy(Mutation):
"""Cauchy distribution mutation."""
class Crossover(Mutation):
"""Crossover recombination operator."""
class RavelCrossover(Crossover):
"""Ravel-based crossover operation."""
class Translation(Mutation):
"""Translation mutation operator."""
class Jumping(Mutation):
"""Jumping mutation for exploration."""
class LocalGaussian(Mutation):
"""Local Gaussian mutation operator."""Helper Functions
Utility functions for parameter analysis, manipulation, and deterministic sampling that assist in parameter structure analysis and optimization debugging.
def flatten(parameter: Parameter) -> List[Data]:
"""
Flatten parameter structure to list.
Args:
parameter: Parameter to flatten
Returns:
List of all Data parameters in the structure
"""
def list_data(parameter: Parameter) -> List[Data]:
"""
List all data parameters.
Args:
parameter: Parameter to analyze
Returns:
List of Data parameters
"""
def analyze(parameter: Parameter) -> Dict:
"""
Analyze parameter structure.
Args:
parameter: Parameter to analyze
Returns:
Analysis dictionary with structure information
"""
def deterministic_sampling(parameter: Parameter) -> Iterator:
"""
Deterministic sampling iterator.
Args:
parameter: Parameter to sample
Returns:
Iterator yielding deterministic samples
"""Usage Examples
Creating Basic Parameters
import nevergrad as ng
# Scalar parameter with bounds
scalar = ng.p.Scalar(init=1.0).set_bounds(-10, 10)
# Array parameter with shape
array = ng.p.Array(shape=(5, 3))
# Log-scale parameter
log_param = ng.p.Log(init=0.01, lower=1e-6, upper=1.0)
# Choice parameter
choice = ng.p.Choice(["option1", "option2", "option3"])Creating Complex Parameter Structures
# Dictionary parameter with mixed types
param_dict = ng.p.Dict({
"learning_rate": ng.p.Log(init=0.01, lower=1e-5, upper=1.0),
"batch_size": ng.p.Choice([16, 32, 64, 128]),
"layers": ng.p.Array(shape=(3,)).set_bounds(1, 1000).set_integer_casting()
})
# Function instrumentation
def train_model(lr, batch_size, epochs=100, optimizer="adam"):
return lr * batch_size + epochs
# Create instrumentation for the function
instrum = ng.p.Instrumentation(
lr=ng.p.Log(init=0.01, lower=1e-5, upper=1.0),
batch_size=ng.p.Choice([16, 32, 64]),
epochs=ng.p.Scalar(init=100).set_bounds(10, 1000).set_integer_casting(),
optimizer=ng.p.Choice(["adam", "sgd", "rmsprop"])
)Parameter Mutation and Sampling
# Create parameter and sample variations
param = ng.p.Array(shape=(10,))
# Get a sample
sample = param.sample()
# Mutate in place
param.mutate()
# Create child with new value
child = param.spawn_child()
# Recombine parameters
param1 = ng.p.Scalar(init=1.0)
param2 = ng.p.Scalar(init=2.0)
combined = param1.recombine(param2)Install with Tessl CLI
npx tessl i tessl/pypi-nevergrad