Source code for ax.metrics.noisy_function

#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.

from __future__ import annotations

from typing import Any, List, Optional, Callable

import numpy as np
import pandas as pd
from ax.core.base_trial import BaseTrial
from ax.core.data import Data
from ax.core.metric import Metric
from ax.core.types import TParameterization


[docs]class NoisyFunctionMetric(Metric): """A metric defined by a generic deterministic function, with normal noise with mean 0 and mean_sd scale added to the result. """ def __init__( self, name: str, param_names: List[str], noise_sd: Optional[float] = 0.0, lower_is_better: Optional[bool] = None, ) -> None: """ Metric is computed by evaluating a deterministic function, implemented in the `f` method defined on this class. f will expect an array x, which is constructed from the arm parameters by extracting the values of the parameter names given in param_names, in that order. Args: name: Name of the metric param_names: An ordered list of names of parameters to be passed to the deterministic function. noise_sd: Scale of normal noise added to the function result. If None, interpret the function as nosiy with unknown noise level. lower_is_better: Flag for metrics which should be minimized. """ self.param_names = param_names self.noise_sd = noise_sd super().__init__(name=name, lower_is_better=lower_is_better)
[docs] @classmethod def is_available_while_running(cls) -> bool: return True
[docs] def clone(self) -> NoisyFunctionMetric: return self.__class__( name=self._name, param_names=self.param_names, noise_sd=self.noise_sd, lower_is_better=self.lower_is_better, )
[docs] def fetch_trial_data( self, trial: BaseTrial, noisy: bool = True, **kwargs: Any ) -> Data: noise_sd = self.noise_sd if noisy else 0.0 arm_names = [] mean = [] for name, arm in trial.arms_by_name.items(): arm_names.append(name) val = self._evaluate(params=arm.parameters) if noise_sd: val = val + noise_sd * np.random.randn() mean.append(val) # indicate unknown noise level in data if noise_sd is None: noise_sd = float("nan") df = pd.DataFrame( { "arm_name": arm_names, "metric_name": self.name, "mean": mean, "sem": noise_sd, "trial_index": trial.index, "n": 10000 / len(arm_names), "frac_nonnull": mean, } ) return Data(df=df)
def _evaluate(self, params: TParameterization) -> float: x = np.array([params[p] for p in self.param_names]) return self.f(x)
[docs] def f(self, x: np.ndarray) -> float: """The deterministic function that produces the metric outcomes.""" raise NotImplementedError
[docs]class GenericNoisyFunctionMetric(NoisyFunctionMetric): def __init__( self, name: str, f: Callable[[TParameterization], float], noise_sd: Optional[float] = 0.0, lower_is_better: Optional[bool] = None, ) -> None: """ Metric is computed by evaluating a deterministic function, implemented in f. Args: name: Name of the metric. f: A callable accepting a dictionary from parameter names to values and returning a float metric value. noise_sd: Scale of normal noise added to the function result. If None, interpret the function as nosiy with unknown noise level. lower_is_better: Flag for metrics which should be minimized. Note: Since this metric setup uses a generic callable it cannot be serialized and will not play well with storage. """ self._f = f self.noise_sd = noise_sd Metric.__init__(self, name=name, lower_is_better=lower_is_better) @property def param_names(self) -> List[str]: raise NotImplementedError( "GenericNoisyFunctionMetric does not implement a param_names attribute" ) def _evaluate(self, params: TParameterization) -> float: return self._f(params)
[docs] def clone(self) -> GenericNoisyFunctionMetric: return self.__class__( name=self._name, f=self._f, noise_sd=self.noise_sd, lower_is_better=self.lower_is_better, )