Plug new instrumentation

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## master
 
+- instrumentation names are changed
+
 ### Breaking changes
 
 - `Instrumentation` is now a `Variable` for simplicity and flexibility. The `Variable` API has therefore heavily changed, and more changes are coming. This should only impact custom variables.

nevergrad/instrumentation/multivariables.py

@@ -6,205 +6,6 @@
 import typing as tp
 from nevergrad.parametrization.parameter import Instrumentation as Instrumentation
 from nevergrad.common.typetools import ArrayLike
-#from .variables import _constant, wrap_arg
-#from .core import variable, argskwargs
-
-
-# class NestedVariables(Variable):
-#    """Variable nesting subvariables results
-#
-#    Parameters
-#    ----------
-#    *args:
-#        Any positional argument. Arguments of type Variable (see note) will serve for instrumentation
-#        and others will be kept constant.
-#    **kwargs
-#        Any keyword argument. Arguments of type Variable (see note) will serve for instrumentation
-#        and others will be kept constant.
-#    """
-#
-#    def __init__(self, *args: Any, **kwargs: Any) -> None:
-#        super().__init__()
-#        self.keywords: Tuple[Optional[str], ...] = ()
-#        self.variables: List[Variable] = []
-#        self._set_args_kwargs(args, kwargs)
-#
-#    @property
-#    def args(self) -> Tuple[Variable, ...]:
-#        """List of variables passed as positional arguments
-#        """
-#        return tuple(arg for name, arg in zip(self.keywords, self.variables) if name is None)
-#
-#    @property
-#    def kwargs(self) -> Dict[str, Variable]:
-#        """Dictionary of variables passed as named arguments
-#        """
-#        return {name: arg for name, arg in zip(self.keywords, self.variables) if name is not None}
-#
-#    def _set_args_kwargs(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> None:
-#        self.keywords, arguments = self._make_argument_keywords_and_list(args, kwargs)
-#        self.variables = [_Constant.convert_non_instrument(a) for a in arguments]
-#        num_instru = len(set(id(i) for i in self.variables))
-#        assert len(self.variables) == num_instru, "All instruments must be different (sharing is not supported)"
-#        #
-#        params = [y.name for x, y in zip(self.keywords, self.variables) if x is None]
-#        params += [f"{x}={y.name}" for x, y in zip(self.keywords, self.variables) if x is not None]
-#        name = "NV({})".format(",".join(params))
-#        self._specs.update(
-#            dimension=sum(i.dimension for i in self.variables),
-#            continuous=all(v.continuous for v in self.variables),
-#            noisy=any(v.noisy for v in self.variables),
-#            nargs=len(args),
-#            kwargs_keys=set(kwargs.keys()),
-#            name=name
-#        )
-#
-#    def _set_random_state(self, random_state: np.random.RandomState) -> None:
-#        super()._set_random_state(random_state)
-#        assert self._random_state is not None
-#        if self.variables:
-#            for var in self.variables:
-#                var._random_state = self._random_state
-#
-#    @staticmethod
-#    def _make_argument_keywords_and_list(
-#            args: Tuple[Any, ...],
-#            kwargs: Dict[str, Any]
-#    ) -> Tuple[Tuple[Optional[str], ...], Tuple[Any, ...]]:
-#        """Converts *args and **kwargs to a tuple of keywords (with None for positional),
-#        and the corresponding tuple of values.
-#
-#        Eg:
-#        _make_argument_keywords_and_list(3, z="blublu", machin="truc")
-#        >>> (None, "machin", "z"), (3, "truc", "blublu")
-#        """
-#        keywords: Tuple[Optional[str], ...] = tuple([None] * len(args) + sorted(kwargs))  # type: ignore
-#        arguments: Tuple[Any, ...] = args + tuple(kwargs[x] for x in keywords if x is not None)
-#        return keywords, arguments
-#
-#    def _split_data(self, data: np.ndarray) -> List[np.ndarray]:
-#        """Splits the input data in chunks corresponding to each of the variables in self.variables
-#
-#        Parameters
-#        ----------
-#        data: ArrayLike (list/tuple of floats, np.ndarray)
-#            the data in the optimization space
-#
-#        Returns
-#        -------
-#        List[np.ndarray]
-#            the list of data chunks corresponding to each variable in self.variables
-#        """
-#        # this functions should be tested
-#        data = data.ravel()
-#        data_parts: List[np.ndarray] = []
-#        start, end = 0, 0
-#        for variable in self.variables:
-#            end = start + variable.dimension
-#            data_parts.append(data[start: end])
-#            start = end
-#        assert end == len(data), f"Finished at {end} but expected {len(data)}"
-#        return data_parts
-#
-#    def _data_to_arguments(self, data: np.ndarray, deterministic: bool = True) -> ArgsKwargs:
-#        data_parts = self._split_data(data)
-#        outputs = [var.data_to_arguments(d, deterministic=deterministic) for var, d in zip(self.variables, data_parts)]
-#        args = tuple(arg for name, arg in zip(self.keywords, outputs) if name is None)
-#        kwargs = {name: arg for name, arg in zip(self.keywords, outputs) if name is not None}
-#        return args, kwargs
-#
-#    def _arguments_to_data(self, *args: Any, **kwargs: Any) -> np.ndarray:
-#        keywords, arguments = self._make_argument_keywords_and_list(args, kwargs)
-#        assert keywords == self.keywords, (f"Passed argument pattern (positional Vs named) was:\n{keywords}\n"
-#                                           f"but expected:\n{self.keywords}")
-#        data = list(itertools.chain.from_iterable([var.arguments_to_data(*vargs, **vkwargs)
-#                                                   for var, (vargs, vkwargs) in zip(self.variables, arguments)]))
-#        return np.array(data)
-#
-#    def instrument(self, function: Callable[..., Any]) -> "InstrumentedFunction":
-#        return InstrumentedFunction(function, *self.args, **self.kwargs)
-#
-#    def __repr__(self) -> str:
-#        ivars = [x.name if isinstance(x, _Constant) else x for x in self.variables]  # hide constants
-#        params = [f"{y}" for x, y in zip(self.keywords, ivars) if x is None]
-#        params += [f"{x}={y}" for x, y in zip(self.keywords, ivars) if x is not None]
-#        return "{}({})".format(self.__class__.__name__, ", ".join(params))
-#
-#    def get_summary(self, data: ArrayLike) -> Any:
-#        """Provides the summary string corresponding to the provided data
-#
-#        Note
-#        ----
-#        This is impractical for large arrays
-#        """
-#        strings = []
-#        splitted_data = self._split_data(np.asarray(data))
-#        for k, (keyword, var, d) in enumerate(zip(self.keywords, self.variables, splitted_data)):
-#            if not isinstance(var, _Constant):
-#                explanation = var.get_summary(d)
-#                sname = f"arg #{k + 1}" if keyword is None else f'kwarg "{keyword}"'
-#                strings.append(f"{sname}: {explanation}")
-#        return " - " + "\n - ".join(strings)
-#
-#
-# class Instrumentation(NestedVariables):
-#    """Class handling arguments instrumentation, and providing conversion to and from data.
-#
-#    Parameters
-#    ----------
-#    *args:
-#        Any positional argument. Arguments of type Variable (see note) will serve for instrumentation
-#        and others will be kept constant.
-#    **kwargs
-#        Any keyword argument. Arguments of type Variable (see note) will serve for instrumentation
-#        and others will be kept constant.
-#
-#    Note
-#    ----
-#    * Core Variable classes are:
-#
-#        - `SoftmaxCategorical(items)`: converts a list of `n` (unordered) categorial items into an `n`-dimensional space. The returned
-#          element will be sampled as the softmax of the values on these dimensions. Be cautious: this process is non-deterministic
-#          and makes the function evaluation noisy.
-#        - `OrderedDiscrete(items)`: converts a list of (ordered) discrete items into a 1-dimensional variable. The returned value will
-#          depend on the value on this dimension: low values corresponding to first elements of the list, and high values to the last.
-#        - `Gaussian(mean, std)`: normalizes a `n`-dimensional variable with independent Gaussian priors (1-dimension per value).
-#        - `Array(dim1, ...)`: casts the data from the optimization space into a np.ndarray of any shape,
-#          to which some transforms can be applied (see `asscalar`, `affined`, `exponentiated`, `bounded`).
-#          This is therefore a very flexible type of variable.
-#        - `Scalar(dtype)`: casts the data from the optimization space into a float or an int. It is equivalent to `Array(1).asscalar(dtype)`
-#          and all `Array` methods are therefore available
-#        - `Log(a_min, a_max)`: for log distributed data between two bounds. Under the hood this uses an `Scalar` with an
-#          appropriate set of transforms (including clipping for the bounds).
-#    * Depending on the variables, `Instrumentation` can be noisy (`SoftmaxCategorical` in non-deterministic mode), and not continuous
-#      (`SoftmaxCategorical` in deterministic mode, `OrderedDiscrete`, `Array` with int casting). Some optimizers may not be able
-#      to deal with these cases properly.
-#    * Since instrumentation can have a stochastic behavior, it is responsible of holding the random state which optimizers
-#      pull from. This random state is initialized lazily, and can be modified
-#    """
-#
-#    def __init__(self, *args: Any, **kwargs: Any) -> None:
-#        super().__init__()
-#        self.keywords: Tuple[Optional[str], ...] = ()
-#        self.variables: List[Variable] = []
-#        self._set_args_kwargs(args, kwargs)
-#
-#    def _set_args_kwargs(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> None:
-#        super()._set_args_kwargs(args, kwargs)
-#        assert all(v.nargs == 1 and not v.kwargs_keys for v in self.variables), "Not yet supported"
-#        assert self.name.startswith("NV(")
-#        self._specs.update(
-#            nargs=len(args),
-#            kwargs_keys=set(kwargs.keys()),
-#            name=self.name[3:-1]
-#        )
-#
-#    def _data_to_arguments(self, data: np.ndarray, deterministic: bool = True) -> ArgsKwargs:
-#        nested_args, nested_kwargs = super()._data_to_arguments(data, deterministic=deterministic)
-#        return tuple(a[0][0] for a in nested_args), {key: a[0][0] for key, a in nested_kwargs.items()}
-#
-#    def _arguments_to_data(self, *args: Any, **kwargs: Any) -> np.ndarray:
-#        return super()._arguments_to_data(*(wrap_arg(x) for x in args), **{k: wrap_arg(x) for k, x in kwargs.items()})
 
 
 class InstrumentedFunction:

nevergrad/optimization/test_base.py

@@ -5,11 +5,10 @@
 
 import warnings
 from pathlib import Path
-from typing import List, Tuple, Any, Optional, Union
+import typing as tp
 import pytest
 import numpy as np
 from ..common import testing
-from ..instrumentation import Instrumentation
 from . import optimizerlib
 from . import test_optimizerlib
 from . import base
@@ -32,7 +31,7 @@ class LoggingOptimizer(base.Optimizer):
 
     def __init__(self, num_workers: int = 1) -> None:
         super().__init__(instrumentation=1, budget=5, num_workers=num_workers)
-        self.logs: List[str] = []
+        self.logs: tp.List[str] = []
 
     def _internal_ask(self) -> base.ArrayLike:
         self.logs.append(f"s{self._num_ask}")  # s for suggest
@@ -49,7 +48,7 @@ def _internal_tell(self, x: base.ArrayLike, value: float) -> None:
     w3_steady=(3, False, ['s0', 's1', 's2', 'u0', 'u1', 'u2', 's3', 's4', 'u3', 'u4']),  # not really steady TODO change this behavior
     # w3_steady=(3, False, ['s0', 's1', 's2', 'u0', 's3', 'u1', 's4', 'u2', 'u3', 'u4']),  # This is what we would like
 )
-def test_batch_and_steady_optimization(num_workers: int, batch_mode: bool, expected: List[Tuple[str, float]]) -> None:
+def test_batch_and_steady_optimization(num_workers: int, batch_mode: bool, expected: tp.List[tp.Tuple[str, float]]) -> None:
     # tests the suggestion (s) and update (u) patterns
     # the w3_steady is unexpected. It is designed to be efficient with a non-sequential executor, but because
     # of it, it is acting like batch mode when sequential...
@@ -72,7 +71,7 @@ def test_batch_and_steady_optimization(num_workers: int, batch_mode: bool, expec
     complex_val=(1j, True),
     object_val=(object(), True),
 )
-def test_tell_types(value: Any, error: bool) -> None:
+def test_tell_types(value: tp.Any, error: bool) -> None:
     optim = LoggingOptimizer(num_workers=1)
     x = optim.ask()
     if error:
@@ -84,7 +83,7 @@ def test_tell_types(value: Any, error: bool) -> None:
 def test_base_optimizer() -> None:
     zeroptim = optimizerlib.Zero(instrumentation=2, budget=4, num_workers=1)
     representation = repr(zeroptim)
-    assert "instrumentation=A(2)" in representation, f"Unexpected representation: {representation}"
+    assert "instrumentation=Instrumentation(Tuple(A(2)),Dict())" in representation, f"Unexpected representation: {representation}"
     np.testing.assert_equal(zeroptim.ask().data, [0, 0])
     zeroptim.tell(zeroptim.create_candidate.from_data([0., 0]), 0)
     zeroptim.tell(zeroptim.create_candidate.from_data([1., 1]), 1)
@@ -116,12 +115,12 @@ def test_optimize_and_dump(tmp_path: Path) -> None:
     np.testing.assert_almost_equal(optimizer2.provide_recommendation().data[0], 1, decimal=2)
 
 
-def test_compare(tmp_path: Path) -> None:
+def test_compare() -> None:
     optimizer = optimizerlib.CMA(instrumentation=3, budget=1000, num_workers=5)
     optimizerlib.addCompare(optimizer)
-    for i in range(1000):
-        x: List[Any] = []
-        for j in range(6):
+    for _ in range(1000):  # TODO make faster test
+        x: tp.List[tp.Any] = []
+        for _ in range(6):
             x += [optimizer.ask()]
         winners = sorted(x, key=lambda x_: np.linalg.norm(x_.data - np.array((1., 1., 1.))))
         optimizer.compare(winners[:3], winners[3:])  # type: ignore
@@ -132,7 +131,7 @@ def test_compare(tmp_path: Path) -> None:
 
 class StupidFamily(base.OptimizerFamily):
 
-    def __call__(self, instrumentation: Parameter, budget: Optional[int] = None, num_workers: int = 1) -> base.Optimizer:
+    def __call__(self, instrumentation: Parameter, budget: tp.Optional[int] = None, num_workers: int = 1) -> base.Optimizer:
         class_ = base.registry["Zero"] if self._kwargs.get("zero", True) else base.registry["StupidRandom"]
         run = class_(instrumentation=instrumentation, budget=budget, num_workers=num_workers)
         run.name = self._repr
@@ -156,7 +155,8 @@ def test_deprecation_warning() -> None:
 def test_naming() -> None:
     optf = StupidFamily(zero=True)
     opt = optf(instrumentation=2, budget=4, num_workers=1)
-    np.testing.assert_equal(repr(opt), "Instance of StupidFamily(zero=True)(instrumentation=A(2), budget=4, num_workers=1)")
+    instru_str = "Instrumentation(Tuple(A(2)),Dict())"
+    np.testing.assert_equal(repr(opt), f"Instance of StupidFamily(zero=True)(instrumentation={instru_str}, budget=4, num_workers=1)")
     optf.with_name("BlubluOptimizer", register=True)
     opt = base.registry["BlubluOptimizer"](instrumentation=2, budget=4, num_workers=1)
-    np.testing.assert_equal(repr(opt), "Instance of BlubluOptimizer(instrumentation=A(2), budget=4, num_workers=1)")
+    np.testing.assert_equal(repr(opt), f"Instance of BlubluOptimizer(instrumentation={instru_str}, budget=4, num_workers=1)")

nevergrad/parametrization/core.py

@@ -430,8 +430,6 @@ def _sanity_check(self, parameters: t.List[Parameter]) -> None:
         """  # TODO: this is first order, in practice we would need to test all the different parameter levels together
         if parameters:
             assert all(isinstance(p, Parameter) for p in parameters)
-            print("params", parameters)
-            print([type(x) for x in parameters])
             ids = {id(p) for p in parameters}
             if len(ids) != len(parameters):
                 raise ValueError("Don't repeat twice the same parameter")