SYMBOL INDEX (465 symbols across 55 files)

FILE: bayesmark/abstract_optimizer.py
  class AbstractOptimizer (line 21) | class AbstractOptimizer(ABC):
    method __init__ (line 28) | def __init__(self, api_config, **kwargs):
    method get_version (line 39) | def get_version(cls):
    method suggest (line 53) | def suggest(self, n_suggestions):
    method observe (line 71) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/hyperopt_optimizer.py
  function dummy_f (line 27) | def dummy_f(x):
  function only (line 31) | def only(x):
  class HyperoptOptimizer (line 36) | class HyperoptOptimizer(AbstractOptimizer):
    method __init__ (line 39) | def __init__(self, api_config, random=np_random):
    method hashable_dict (line 61) | def hashable_dict(d):
    method get_hyperopt_dimensions (line 78) | def get_hyperopt_dimensions(api_config):
    method get_trial (line 132) | def get_trial(self, trial_id):
    method cleanup_guess (line 142) | def cleanup_guess(self, x_guess):
    method _suggest (line 157) | def _suggest(self):
    method suggest (line 175) | def suggest(self, n_suggestions=1):
    method observe (line 212) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/nevergrad_optimizer.py
  class NevergradOptimizer (line 24) | class NevergradOptimizer(AbstractOptimizer):
    method __init__ (line 27) | def __init__(self, api_config, tool, budget):
    method get_nvg_dimensions (line 46) | def get_nvg_dimensions(api_config):
    method prewarp (line 102) | def prewarp(self, xx):
    method postwarp (line 125) | def postwarp(self, xxw):
    method suggest (line 146) | def suggest(self, n_suggestions=1):
    method observe (line 171) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/opentuner_optimizer.py
  function ClippedParam (line 73) | def ClippedParam(cls, epsilon=1e-5):
  class OpentunerOptimizer (line 106) | class OpentunerOptimizer(AbstractOptimizer):
    method __init__ (line 109) | def __init__(self, api_config, techniques=DEFAULT_TECHNIQUES, n_sugges...
    method hashable_dict (line 176) | def hashable_dict(d):
    method build_manipulator (line 193) | def build_manipulator(api_config):
    method suggest (line 241) | def suggest(self, n_suggestions=1):
    method observe (line 305) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/pysot_optimizer.py
  class PySOTOptimizer (line 28) | class PySOTOptimizer(AbstractOptimizer):
    method __init__ (line 31) | def __init__(self, api_config):
    method create_opt_prob (line 49) | def create_opt_prob(self):
    method start (line 61) | def start(self, max_evals):
    method suggest (line 91) | def suggest(self, n_suggestions=1):
    method _observe (line 141) | def _observe(self, x, y):
    method observe (line 150) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/random_optimizer.py
  class RandomOptimizer (line 19) | class RandomOptimizer(AbstractOptimizer):
    method __init__ (line 23) | def __init__(self, api_config, random=np_util.random):
    method suggest (line 36) | def suggest(self, n_suggestions=1):
    method observe (line 54) | def observe(self, X, y):

FILE: bayesmark/builtin_opt/scikit_optimizer.py
  class ScikitOptimizer (line 22) | class ScikitOptimizer(AbstractOptimizer):
    method __init__ (line 25) | def __init__(self, api_config, base_estimator="GP", acq_func="gp_hedge...
    method get_sk_dimensions (line 65) | def get_sk_dimensions(api_config, transform="normalize"):
    method suggest (line 116) | def suggest(self, n_suggestions=1):
    method observe (line 143) | def observe(self, X, y):

FILE: bayesmark/cmd_parse.py
  class CmdArgs (line 40) | class CmdArgs(IntEnum):
  function arg_to_str (line 87) | def arg_to_str(arg):
  function namespace_to_dict (line 93) | def namespace_to_dict(args_ns):
  function serializable_dict (line 99) | def serializable_dict(args):
  function unserializable_dict (line 105) | def unserializable_dict(args_str):
  function add_argument (line 111) | def add_argument(parser, arg, **kwargs):
  function filepath (line 117) | def filepath(value):
  function filename (line 125) | def filename(value):
  function uuid (line 130) | def uuid(val_str):
  function positive_int (line 137) | def positive_int(val_str):
  function joinable (line 145) | def joinable(val_str):
  function load_rev_number (line 154) | def load_rev_number():
  function base_parser (line 197) | def base_parser():
  function launcher_parser (line 211) | def launcher_parser(description):
  function experiment_parser (line 246) | def experiment_parser(description):
  function agg_parser (line 266) | def agg_parser(description):
  function general_parser (line 278) | def general_parser(description):
  function parse_args (line 284) | def parse_args(parser, argv=None):
  function _cleanup (line 309) | def _cleanup(filename_str):
  function infer_settings (line 315) | def infer_settings(opt_root, opt_pattern="**/optimizer.py"):
  function load_optimizer_settings (line 333) | def load_optimizer_settings(opt_root):
  function cmd_str (line 346) | def cmd_str():

FILE: bayesmark/data.py
  class ProblemType (line 27) | class ProblemType(IntEnum):
  function get_problem_type (line 50) | def get_problem_type(dataset_name):
  function _csv_loader (line 75) | def _csv_loader(dataset_name, return_X_y, data_root, clip_x=100):  # pra...
  function load_data (line 133) | def load_data(dataset_name, data_root=None):  # pragma: io

FILE: bayesmark/expected_max.py
  function get_expected_max_weights (line 20) | def get_expected_max_weights(n, m):
  function expected_max (line 53) | def expected_max(x, m):
  function expected_min (line 88) | def expected_min(x, m):

FILE: bayesmark/experiment.py
  function _build_test_problem (line 47) | def _build_test_problem(model_name, dataset, scorer, path):
  function run_study (line 77) | def run_study(optimizer, test_problem, n_calls, n_suggestions, n_obj=1, ...
  function run_sklearn_study (line 187) | def run_sklearn_study(
  function get_objective_signature (line 248) | def get_objective_signature(model_name, dataset, scorer, data_root=None):
  function build_eval_ds (line 277) | def build_eval_ds(function_evals, objective_names):
  function build_timing_ds (line 306) | def build_timing_ds(suggest_time, eval_time, observe_time):
  function build_suggest_ds (line 342) | def build_suggest_ds(suggest_log):
  function load_optimizer_kwargs (line 376) | def load_optimizer_kwargs(optimizer_name, opt_root):  # pragma: io
  function _setup_seeds (line 402) | def _setup_seeds(hex_str):  # pragma: main
  function experiment_main (line 423) | def experiment_main(opt_class, args=None):  # pragma: main
  function _get_opt_class (line 569) | def _get_opt_class(opt_name):
  function main (line 609) | def main():  # pragma: main

FILE: bayesmark/experiment_aggregate.py
  function validate_time (line 35) | def validate_time(all_time):
  function validate_perf (line 44) | def validate_perf(perf_da):
  function validate_agg_perf (line 52) | def validate_agg_perf(perf_da, min_trial=1):
  function summarize_time (line 61) | def summarize_time(all_time):
  function concat_experiments (line 89) | def concat_experiments(all_experiments, ravel=False):
  function load_experiments (line 169) | def load_experiments(uuid_list, db_root, dbid):  # pragma: io
  function main (line 231) | def main():

FILE: bayesmark/experiment_analysis.py
  function get_perf_array (line 62) | def get_perf_array(evals, evals_visible):
  function compute_aggregates (line 96) | def compute_aggregates(perf_da, baseline_ds, visible_perf_da=None):
  function main (line 237) | def main():

FILE: bayesmark/experiment_baseline.py
  function validate (line 42) | def validate(baseline_ds):
  function compute_baseline (line 57) | def compute_baseline(perf_da):
  function do_baseline (line 145) | def do_baseline(args):  # pragma: io
  function main (line 170) | def main():

FILE: bayesmark/experiment_db_init.py
  function main (line 28) | def main():

FILE: bayesmark/experiment_launcher.py
  function _is_arg_safe (line 46) | def _is_arg_safe(ss):
  function arg_safe_str (line 54) | def arg_safe_str(val):
  function gen_commands (line 62) | def gen_commands(args, opt_file_lookup, run_uuid):
  function dry_run (line 149) | def dry_run(args, opt_file_lookup, run_uuid, fp, random=np_random):
  function real_run (line 204) | def real_run(args, opt_file_lookup, run_uuid, timeout=None):  # pragma: io
  function main (line 241) | def main():

FILE: bayesmark/np_util.py
  function random_seed (line 25) | def random_seed(random=random):
  function shuffle_2d (line 45) | def shuffle_2d(X, random=random):
  function strat_split (line 62) | def strat_split(X, n_splits, inplace=False, random=random):
  function isclose_lte (line 99) | def isclose_lte(x, y):
  function clip_chk (line 122) | def clip_chk(x, lb, ub, allow_nan=False):
  function snap_to (line 159) | def snap_to(x, fixed_val=None):
  function linear_rescale (line 186) | def linear_rescale(X, lb0, ub0, lb1, ub1, enforce_bounds=True):
  function argmin_2d (line 230) | def argmin_2d(X):
  function cummin (line 238) | def cummin(x_val, x_key):

FILE: bayesmark/path_util.py
  function abspath (line 20) | def abspath(path, verify=True):  # pragma: io
  function absopen (line 41) | def absopen(path, mode):  # pragma: io
  function _join_safe (line 61) | def _join_safe(*args):  # pragma: io
  function join_safe_r (line 76) | def join_safe_r(*args):  # pragma: io
  function join_safe_w (line 94) | def join_safe_w(*args):  # pragma: io

FILE: bayesmark/quantiles.py
  function ensure_shape (line 22) | def ensure_shape(x, y):
  function order_stats (line 33) | def order_stats(X):
  function _quantile (line 60) | def _quantile(n, q):
  function quantile (line 65) | def quantile(X, q):
  function _quantile_CI (line 97) | def _quantile_CI(n, q, alpha):
  function quantile_CI (line 117) | def quantile_CI(X, q, alpha=0.05):
  function max_quantile_CI (line 153) | def max_quantile_CI(X, q, m, alpha=0.05):
  function min_quantile_CI (line 200) | def min_quantile_CI(X, q, m, alpha=0.05):
  function quantile_and_CI (line 248) | def quantile_and_CI(X, q, alpha=0.05):

FILE: bayesmark/random_search.py
  function suggest_dict (line 22) | def suggest_dict(X, y, meta, n_suggestions=1, random=np_util.random):
  function _check_x_y (line 61) | def _check_x_y(X, y, allow_impute=False):  # pragma: validator
  function _check_bounds (line 87) | def _check_bounds(bounds, n_params):  # pragma: validator

FILE: bayesmark/serialize.py
  class Serializer (line 45) | class Serializer(ABC):
    method init_db (line 51) | def init_db(db_root, keys, db=None, exist_ok=True):
    method get_keys (line 74) | def get_keys(db_root, db):
    method get_derived_keys (line 93) | def get_derived_keys(db_root, db):
    method get_uuids (line 112) | def get_uuids(db_root, db, key):
    method save (line 133) | def save(data, meta, db_root, db, key, uuid_):
    method load (line 140) | def load(db_root, db, key, uuid_):
    method save_derived (line 147) | def save_derived(data, meta, db_root, db, key):
    method load_derived (line 154) | def load_derived(db_root, db, key):
  class XRSerializer (line 160) | class XRSerializer(Serializer):
    method init_db (line 164) | def init_db(db_root, keys, db=None, exist_ok=True):  # pragma: io
    method init_db_manual (line 183) | def init_db_manual(db_root, keys, db):
    method get_keys (line 208) | def get_keys(db_root, db):  # pragma: io
    method get_derived_keys (line 216) | def get_derived_keys(db_root, db):  # pragma: io
    method get_uuids (line 223) | def get_uuids(db_root, db, key):  # pragma: io
    method save (line 230) | def save(data, meta, db_root, db, key, uuid_):  # pragma: io
    method load (line 255) | def load(db_root, db, key, uuid_):  # pragma: io
    method save_derived (line 284) | def save_derived(data, meta, db_root, db, key):  # pragma: io
    method load_derived (line 307) | def load_derived(db_root, db, key):  # pragma: io
    method logging_path (line 334) | def logging_path(db_root, db, uuid_):  # pragma: io
    method _fname_to_uuid (line 358) | def _fname_to_uuid(fname):
    method _uuid_to_fname (line 362) | def _uuid_to_fname(uuid_):
    method _key_to_fname (line 368) | def _key_to_fname(key):
    method _fname_to_key (line 372) | def _fname_to_key(fname):
    method _validate (line 376) | def _validate(db_root, keys=(), db=None):
  function _dump_xr (line 387) | def _dump_xr(f, ds, meta):  # pragma: io
  function _load_xr (line 406) | def _load_xr(f):  # pragma: io

FILE: bayesmark/signatures.py
  function get_func_signature (line 28) | def get_func_signature(f, api_config):
  function analyze_signatures (line 57) | def analyze_signatures(signatures):
  function analyze_signature_pair (line 101) | def analyze_signature_pair(signatures, signatures_ref):

FILE: bayesmark/sklearn_funcs.py
  class TestFunction (line 209) | class TestFunction(ABC):
    method __init__ (line 213) | def __init__(self):
    method evaluate (line 222) | def evaluate(self, params):
    method get_api_config (line 226) | def get_api_config(self):
  class SklearnModel (line 238) | class SklearnModel(TestFunction):
    method __init__ (line 253) | def __init__(self, model, dataset, metric, shuffle_seed=0, data_root=N...
    method evaluate (line 309) | def evaluate(self, params):
    method test_case_str (line 359) | def test_case_str(model, dataset, scorer):
    method inverse_test_case_str (line 365) | def inverse_test_case_str(test_case):
  class SklearnSurrogate (line 372) | class SklearnSurrogate(TestFunction):
    method __init__ (line 379) | def __init__(self, model, dataset, scorer, path):
    method evaluate (line 417) | def evaluate(self, params):

FILE: bayesmark/space.py
  function unravel_index (line 42) | def unravel_index(dims):
  function encode (line 74) | def encode(X, labels, assume_sorted=False, dtype=bool, assume_valid=False):
  function decode (line 113) | def decode(Y, labels, assume_sorted=False):
  function _error (line 142) | def _error(msg, pre=False):  # pragma: validator
  function check_array (line 153) | def check_array(
  function identity (line 247) | def identity(x):
  function bilog (line 264) | def bilog(x):
  function biexp (line 284) | def biexp(x):
  class Space (line 309) | class Space(object):
    method __init__ (line 313) | def __init__(self, dtype, default_round, warp="linear", values=None, r...
    method validate (line 386) | def validate(self, X, pre=False):
    method validate_warped (line 400) | def validate_warped(self, X, pre=False):
    method warp (line 409) | def warp(self, X):
    method unwarp (line 433) | def unwarp(self, X_w):
    method get_bounds (line 457) | def get_bounds(self):
    method grid (line 471) | def grid(self, max_interp=N_GRID_DEFAULT):
  class Real (line 500) | class Real(Space):
    method __init__ (line 504) | def __init__(self, warp="linear", values=None, range_=None):
  class Integer (line 523) | class Integer(Space):
    method __init__ (line 527) | def __init__(self, warp="linear", values=None, range_=None):
  class Boolean (line 546) | class Boolean(Space):
    method __init__ (line 550) | def __init__(self, warp=None, values=None, range_=None):
  class Categorical (line 576) | class Categorical(Space):
    method __init__ (line 580) | def __init__(self, warp=None, values=None, range_=None):
    method _encode (line 612) | def _encode(self, x):
    method _decode (line 615) | def _decode(self, x):
    method warp (line 618) | def warp(self, X):
    method unwarp (line 643) | def unwarp(self, X_w):
  class JointSpace (line 676) | class JointSpace(object):
    method __init__ (line 680) | def __init__(self, meta):
    method validate (line 707) | def validate(self, X):
    method warp (line 718) | def warp(self, X):
    method unwarp (line 753) | def unwarp(self, X_w, fixed_vals={}):
    method get_bounds (line 787) | def get_bounds(self):
    method grid (line 801) | def grid(self, max_interp=N_GRID_DEFAULT):

FILE: bayesmark/stats.py
  function robust_standardize (line 20) | def robust_standardize(X, q_level=0.5):
  function t_EB (line 60) | def t_EB(x, alpha=0.05, axis=-1):

FILE: bayesmark/util.py
  function in_or_none (line 19) | def in_or_none(x, L):
  function all_unique (line 24) | def all_unique(L):
  function strict_sorted (line 41) | def strict_sorted(L):
  function range_str (line 59) | def range_str(stop):
  function str_join_safe (line 83) | def str_join_safe(delim, str_vec, append=False):
  function shell_join (line 129) | def shell_join(argv, delim=" "):
  function chomp (line 152) | def chomp(str_val, ext="\n"):
  function preimage_func (line 175) | def preimage_func(f, x):

FILE: bayesmark/xr_util.py
  function is_simple_coords (line 25) | def is_simple_coords(coords, min_side=0, dims=None):
  function ds_like (line 58) | def ds_like(ref, vars_, dims, fill=np.nan):
  function ds_like_mixed (line 88) | def ds_like_mixed(ref, vars_, dims, fill=np.nan):
  function only_dataarray (line 120) | def only_dataarray(ds):
  function coord_compat (line 140) | def coord_compat(da_seq, dims):
  function da_to_string (line 169) | def da_to_string(da):
  function da_concat (line 187) | def da_concat(da_dict, dims):
  function ds_concat (line 230) | def ds_concat(ds_dict, dims):

FILE: example_opt_root/flaky_optimizer.py
  class FlakyOptimizer (line 9) | class FlakyOptimizer(AbstractOptimizer):
    method __init__ (line 10) | def __init__(self, api_config, random=np_util.random):
    method suggest (line 24) | def suggest(self, n_suggestions=1):
    method observe (line 51) | def observe(self, X, y):

FILE: example_opt_root/hyperopt_optimizer.py
  function dummy_f (line 15) | def dummy_f(x):
  function only (line 19) | def only(x):
  class HyperoptOptimizer (line 24) | class HyperoptOptimizer(AbstractOptimizer):
    method __init__ (line 27) | def __init__(self, api_config, random=np_random):
    method hashable_dict (line 49) | def hashable_dict(d):
    method get_hyperopt_dimensions (line 66) | def get_hyperopt_dimensions(api_config):
    method get_trial (line 120) | def get_trial(self, trial_id):
    method cleanup_guess (line 130) | def cleanup_guess(self, x_guess):
    method _suggest (line 145) | def _suggest(self):
    method suggest (line 163) | def suggest(self, n_suggestions=1):
    method observe (line 200) | def observe(self, X, y):

FILE: example_opt_root/nevergrad_optimizer.py
  class NevergradOptimizer (line 12) | class NevergradOptimizer(AbstractOptimizer):
    method __init__ (line 15) | def __init__(self, api_config, tool="OnePlusOne", budget=300):
    method get_nvg_dimensions (line 34) | def get_nvg_dimensions(api_config):
    method prewarp (line 90) | def prewarp(self, xx):
    method postwarp (line 113) | def postwarp(self, xxw):
    method suggest (line 134) | def suggest(self, n_suggestions=1):
    method observe (line 159) | def observe(self, X, y):

FILE: example_opt_root/opentuner_optimizer.py
  function ClippedParam (line 61) | def ClippedParam(cls, epsilon=1e-5):
  class OpentunerOptimizer (line 94) | class OpentunerOptimizer(AbstractOptimizer):
    method __init__ (line 97) | def __init__(self, api_config, techniques=DEFAULT_TECHNIQUES, n_sugges...
    method hashable_dict (line 164) | def hashable_dict(d):
    method build_manipulator (line 181) | def build_manipulator(api_config):
    method suggest (line 229) | def suggest(self, n_suggestions=1):
    method observe (line 293) | def observe(self, X, y):

FILE: example_opt_root/pysot_optimizer.py
  class PySOTOptimizer (line 16) | class PySOTOptimizer(AbstractOptimizer):
    method __init__ (line 19) | def __init__(self, api_config):
    method create_opt_prob (line 37) | def create_opt_prob(self):
    method start (line 49) | def start(self, max_evals):
    method suggest (line 79) | def suggest(self, n_suggestions=1):
    method _observe (line 129) | def _observe(self, x, y):
    method observe (line 138) | def observe(self, X, y):

FILE: example_opt_root/random_optimizer.py
  class RandomOptimizer (line 7) | class RandomOptimizer(AbstractOptimizer):
    method __init__ (line 11) | def __init__(self, api_config, random=np_util.random):
    method suggest (line 24) | def suggest(self, n_suggestions=1):
    method observe (line 42) | def observe(self, X, y):

FILE: example_opt_root/scikit_optimizer.py
  class ScikitOptimizer (line 10) | class ScikitOptimizer(AbstractOptimizer):
    method __init__ (line 13) | def __init__(self, api_config, base_estimator="GP", acq_func="gp_hedge...
    method get_sk_dimensions (line 49) | def get_sk_dimensions(api_config, transform="normalize"):
    method suggest (line 100) | def suggest(self, n_suggestions=1):
    method observe (line 127) | def observe(self, X, y):

FILE: setup.py
  function read_requirements (line 23) | def read_requirements(name):

FILE: test/data_test.py
  function test_get_problem_type (line 23) | def test_get_problem_type(dataset_name):

FILE: test/expected_max_test.py
  function test_get_expected_max_weights (line 21) | def test_get_expected_max_weights(n, m):
  function test_expected_max (line 27) | def test_expected_max(x, m):
  function test_expected_min (line 33) | def test_expected_min(x, m):

FILE: test/experiment_aggregate_test.py
  function data_to_concat (line 37) | def data_to_concat():
  function time_datasets (line 94) | def time_datasets():
  function perf_dataarrays (line 102) | def perf_dataarrays():
  function test_summarize_time (line 110) | def test_summarize_time(all_time):
  function test_concat_experiments (line 117) | def test_concat_experiments(all_experiments):

FILE: test/experiment_analysis_test.py
  function test_get_perf_array (line 25) | def test_get_perf_array(args):
  function test_compute_aggregates (line 42) | def test_compute_aggregates(perf_da):
  function test_compute_aggregates_with_aux (line 61) | def test_compute_aggregates_with_aux(perf_da):

FILE: test/experiment_baseline_test.py
  function test_compute_baseline (line 24) | def test_compute_baseline(perf_da):

FILE: test/experiment_db_init_test.py
  function test_main (line 17) | def test_main():

FILE: test/experiment_launcher_test.py
  function filepaths (line 44) | def filepaths():
  function filenames (line 57) | def filenames(suffix=""):
  function joinables (line 70) | def joinables():
  function datasets (line 75) | def datasets():
  function launcher_args (line 79) | def launcher_args(opts, min_jobs=0):
  function launcher_args_and_config (line 101) | def launcher_args_and_config(min_jobs=0):
  function test_is_arg_safe_empty (line 114) | def test_is_arg_safe_empty():
  function test_gen_commands (line 122) | def test_gen_commands(args, run_uuid):
  function test_dry_run (line 144) | def test_dry_run(args, run_uuid, seed):

FILE: test/experiment_test.py
  class RandomOptimizer (line 34) | class RandomOptimizer(AbstractOptimizer):
    method __init__ (line 38) | def __init__(self, api_config, random=np_util.random, flaky=False):
    method suggest (line 43) | def suggest(self, n_suggestions=1):
    method observe (line 49) | def observe(self, X, y):
  class OutOfBoundsOptimizer (line 55) | class OutOfBoundsOptimizer(AbstractOptimizer):
    method __init__ (line 56) | def __init__(self, api_config, random=np_util.random):
    method suggest (line 61) | def suggest(self, n_suggestions=1):
    method observe (line 78) | def observe(self, X, y):
  class FlakyProblem (line 82) | class FlakyProblem(TestFunction):
    method __init__ (line 83) | def __init__(self, api_config, random):
    method evaluate (line 88) | def evaluate(self, params):
  function test_run_study (line 102) | def test_run_study(model_name, dataset, scorer, n_calls, n_suggestions, ...
  function test_run_study_bounds_fail (line 120) | def test_run_study_bounds_fail(model_name, dataset, scorer, n_calls, n_s...
  function test_run_study_callback (line 148) | def test_run_study_callback(model_name, dataset, scorer, n_calls, n_sugg...
  function test_run_study_flaky (line 184) | def test_run_study_flaky(api_config, n_calls, n_suggestions, seed1, seed2):
  function test_run_sklearn_study (line 203) | def test_run_sklearn_study(api_config, model_name, dataset, scorer, n_ca...
  function test_run_sklearn_study_real (line 220) | def test_run_sklearn_study_real(api_config, model_name, dataset, scorer,...
  function test_get_objective_signature (line 235) | def test_get_objective_signature(model_name, dataset, scorer):
  function test_build_eval_ds (line 243) | def test_build_eval_ds(args):
  function test_build_timing_ds (line 249) | def test_build_timing_ds(args):
  function test_build_suggest_ds (line 261) | def test_build_suggest_ds(suggest_ds):
  function test_get_opt_class_module (line 278) | def test_get_opt_class_module():

FILE: test/hypothesis_util.py
  function identity (line 20) | def identity(x):
  function seeds (line 25) | def seeds():
  function probs (line 29) | def probs():
  function mfloats (line 33) | def mfloats():
  function gufunc_floats (line 37) | def gufunc_floats(signature, min_side=0, max_side=5, unique=False, **kwa...
  function close_enough (line 43) | def close_enough(x, y, equal_nan=False, rtol=1e-5, atol=1e-8):
  function broadcasted (line 61) | def broadcasted(
  function broadcast_tester (line 179) | def broadcast_tester(
  function multi_broadcast_tester (line 230) | def multi_broadcast_tester(

FILE: test/np_util_test.py
  function test_random_seed (line 23) | def test_random_seed(seed):
  function test_shuffle_2d (line 29) | def test_shuffle_2d(X, seed):
  function test_strat_split (line 35) | def test_strat_split(X, n_splits, seed):
  function test_isclose_lte_pass (line 46) | def test_isclose_lte_pass(args):
  function test_isclose_lte_fail (line 53) | def test_isclose_lte_fail(args):
  function test_isclose_broadcast (line 65) | def test_isclose_broadcast():
  function test_clip_chk_pass (line 70) | def test_clip_chk_pass(args):
  function test_clip_chk_pass_nan (line 81) | def test_clip_chk_pass_nan(args):
  function test_snap_to_pass (line 92) | def test_snap_to_pass(args):
  function test_linear_rescale_bounds (line 101) | def test_linear_rescale_bounds(args):
  function test_linear_rescale_inner (line 119) | def test_linear_rescale_inner(args):
  function test_linear_rescale_inverse (line 138) | def test_linear_rescale_inverse(args):
  function test_linear_rescale_bound_modes (line 161) | def test_linear_rescale_bound_modes(args):
  function pair_sort (line 179) | def pair_sort(X, Y):
  function test_linear_rescale_broadcast (line 187) | def test_linear_rescale_broadcast():
  function test_isclose (line 217) | def test_isclose(x, y):
  function test_isclose_2 (line 251) | def test_isclose_2():
  function test_argmin_2d_no_nan (line 261) | def test_argmin_2d_no_nan(args):
  function test_argmin_2d_nan (line 269) | def test_argmin_2d_nan(args):
  function test_cummin (line 277) | def test_cummin(args):
  function test_cummin_nan (line 294) | def test_cummin_nan(args):

FILE: test/quantiles_test.py
  function order_stats_trim (line 35) | def order_stats_trim(X):
  function test_order_stats (line 50) | def test_order_stats(args):
  function test_quantile (line 69) | def test_quantile(args):
  function test_quantile_to_np (line 84) | def test_quantile_to_np(args):
  function test_quantile_CI (line 98) | def test_quantile_CI(args):
  function test_quantile_CI_monotone_x (line 116) | def test_quantile_CI_monotone_x(args):
  function test_quantile_CI_monotone_q (line 137) | def test_quantile_CI_monotone_q(args):
  function test_quantile_CI_monotone_alpha (line 150) | def test_quantile_CI_monotone_alpha(args):
  function test_max_quantile_CI (line 167) | def test_max_quantile_CI(args):
  function test_min_quantile_CI (line 189) | def test_min_quantile_CI(args):
  function test_min_quantile_CI_to_max (line 211) | def test_min_quantile_CI_to_max(args):
  function test_quantile_and_CI (line 234) | def test_quantile_and_CI(args):
  function test_order_stats_broadcast (line 250) | def test_order_stats_broadcast():
  function test_quantile_broadcast_0 (line 254) | def test_quantile_broadcast_0():
  function test_quantile_broadcast_1 (line 260) | def test_quantile_broadcast_1():
  function test_quantile_CI_broadcast_0 (line 266) | def test_quantile_CI_broadcast_0():
  function test_quantile_CI_broadcast_1 (line 277) | def test_quantile_CI_broadcast_1():
  function test_max_quantile_CI_broadcast_0 (line 288) | def test_max_quantile_CI_broadcast_0():
  function test_max_quantile_CI_broadcast_1 (line 299) | def test_max_quantile_CI_broadcast_1():
  function test_min_quantile_CI_broadcast_0 (line 310) | def test_min_quantile_CI_broadcast_0():
  function test_min_quantile_CI_broadcast_1 (line 321) | def test_min_quantile_CI_broadcast_1():
  function test_quantile_and_CI_broadcast_0 (line 332) | def test_quantile_and_CI_broadcast_0():
  function test_quantile_and_CI_broadcast_1 (line 343) | def test_quantile_and_CI_broadcast_1():
  function mc_test_quantile_CI (line 354) | def mc_test_quantile_CI(mc_runs=1000, n=2000, q=0.5, alpha=0.05, random=...
  function mc_test_max_quantile_CI (line 367) | def mc_test_max_quantile_CI(mc_runs=1000, n=2000, q=0.5, m=100, alpha=0....
  function mc_test_min_quantile_CI (line 381) | def mc_test_min_quantile_CI(mc_runs=1000, n=2000, q=0.5, m=100, alpha=0....
  function test_all_mc (line 395) | def test_all_mc():

FILE: test/random_search_test.py
  function test_random_search_suggest_sanity (line 27) | def test_random_search_suggest_sanity(api_args, n_suggest, seed):
  function test_random_search_suggest_diff (line 68) | def test_random_search_suggest_diff(api_args, n_suggest, seed):

FILE: test/serialize_test.py
  function filepaths (line 24) | def filepaths():
  function filenames (line 37) | def filenames(suffix=""):
  function test_init_db_manual (line 51) | def test_init_db_manual(db_root, keys, db):
  function test_uuid_to_fname (line 56) | def test_uuid_to_fname(uu):
  function test_key_to_fname (line 66) | def test_key_to_fname(key):
  function test_validate (line 73) | def test_validate(db_root, keys, db):

FILE: test/signatures_test.py
  function bsigs (line 29) | def bsigs():
  function sigs (line 34) | def sigs():
  function sig_pair (line 39) | def sig_pair():
  function some_mock_f (line 59) | def some_mock_f(x):
  function test_get_func_signature (line 68) | def test_get_func_signature(api_config):
  function test_analyze_signatures (line 75) | def test_analyze_signatures(signatures):
  function test_analyze_signature_pair (line 82) | def test_analyze_signature_pair(args):

FILE: test/sklearn_funcs_test.py
  function test_sklearn_model (line 31) | def test_sklearn_model(model, dataset, metric, shuffle_seed, rs_seed):
  function test_inverse_test_case_str (line 48) | def test_inverse_test_case_str(model, dataset, scorer):
  function test_sklearn_model_surr (line 59) | def test_sklearn_model_surr(model, dataset, metric, model_seed, rs_seed):

FILE: test/space_test.py
  function encoder_gen (line 35) | def encoder_gen(args):
  function decoder_gen (line 45) | def decoder_gen(args):
  function decoder_gen_broadcast (line 54) | def decoder_gen_broadcast(args):
  function test_encode_decode (line 77) | def test_encode_decode(args):
  function test_encoder_to_sklearn (line 106) | def test_encoder_to_sklearn(args):
  function test_decode_encode (line 128) | def test_decode_encode(args):
  function test_decode_to_sklearn (line 151) | def test_decode_to_sklearn(args):
  function test_encode_broadcast_bool (line 166) | def test_encode_broadcast_bool():
  function test_encode_broadcast_int (line 180) | def test_encode_broadcast_int():
  function test_encode_broadcast_float (line 194) | def test_encode_broadcast_float():
  function test_decode_broadcast_bool (line 208) | def test_decode_broadcast_bool():
  function test_decode_broadcast_int (line 222) | def test_decode_broadcast_int():
  function test_decode_broadcast_float (line 236) | def test_decode_broadcast_float():
  function test_bilog_props (line 251) | def test_bilog_props(args):
  function test_bilog_monotonic (line 262) | def test_bilog_monotonic(args):
  function test_bilog_biexp (line 271) | def test_bilog_biexp(args):
  function test_bilog_broadcast (line 277) | def test_bilog_broadcast():
  function test_biexp_broadcast (line 281) | def test_biexp_broadcast():
  function test_real_values_warp_unwarp (line 286) | def test_real_values_warp_unwarp(warp, args):
  function test_real_range_warp_unwarp (line 325) | def test_real_range_warp_unwarp(warp, args):
  function test_real_range_unwarp_warp (line 363) | def test_real_range_unwarp_warp(warp, args):
  function test_int_values_warp_unwarp (line 404) | def test_int_values_warp_unwarp(warp, args):
  function test_log_int_values_warp_unwarp (line 435) | def test_log_int_values_warp_unwarp(args):
  function test_int_range_warp_unwarp (line 468) | def test_int_range_warp_unwarp(warp, args):
  function test_bool_warp_unwarp (line 511) | def test_bool_warp_unwarp(args):
  function test_cat_warp_unwarp (line 544) | def test_cat_warp_unwarp(args):
  function test_joint_space_unwarp_warp (line 574) | def test_joint_space_unwarp_warp(args):
  function test_joint_space_warp_missing (line 595) | def test_joint_space_warp_missing(args):
  function test_joint_space_warp_fixed_vars (line 623) | def test_joint_space_warp_fixed_vars(args):
  function test_joint_grid (line 651) | def test_joint_grid(args, max_interp):
  function test_unravel_index_empty (line 694) | def test_unravel_index_empty():
  function test_unravel_index_empty_2 (line 699) | def test_unravel_index_empty_2(dims):

FILE: test/stats_test.py
  function t_test_ (line 25) | def t_test_(x):
  function test_robust_standardize_to_sklearn (line 56) | def test_robust_standardize_to_sklearn(args):
  function test_robust_standardize_broadcast (line 71) | def test_robust_standardize_broadcast():
  function test_t_EB_zero_var (line 93) | def test_t_EB_zero_var(N, val, alpha):
  function test_t_EB_inf (line 103) | def test_t_EB_inf(N, val, alpha):
  function test_t_EB_coverage (line 115) | def test_t_EB_coverage(seed, alpha, N):
  function test_t_test_to_EB (line 135) | def test_t_test_to_EB(x):

FILE: test/util.py
  function _easy_text (line 39) | def _easy_text():
  function _hashable (line 45) | def _hashable():
  function space_vars (line 60) | def space_vars(draw, max_values=5):
  function space_configs (line 105) | def space_configs(draw, max_vars=5, max_len=5, allow_missing=False, uniq...
  function perf_dataarrays (line 138) | def perf_dataarrays(min_trial=1):

FILE: test/util_test.py
  function some_mock_f (line 24) | def some_mock_f(x):
  function test_in_or_none (line 33) | def test_in_or_none(x, L):
  function test_in_or_none_on_none (line 41) | def test_in_or_none_on_none(x):
  function test_in_or_none_self (line 48) | def test_in_or_none_self(L):
  function test_all_unique (line 56) | def test_all_unique(L):
  function test_strict_sorted (line 61) | def test_strict_sorted(L):
  function test_range_str (line 66) | def test_range_str(stop):
  function test_str_join_safe (line 71) | def test_str_join_safe(delim, str_vec):
  function test_str_join_safe_append (line 77) | def test_str_join_safe_append(delim, str_vec0, str_vec):
  function test_shell_join (line 86) | def test_shell_join(argv):
  function test_chomp (line 93) | def test_chomp(str_val, ext):
  function test_preimage_func (line 98) | def test_preimage_func(x):

FILE: test/xr_util_test.py
  function intersect_seq (line 36) | def intersect_seq(L):
  function ds_vars_dims (line 46) | def ds_vars_dims():
  function ds_vars_dims_mixed (line 61) | def ds_vars_dims_mixed():
  function test_is_simple_coords (line 82) | def test_is_simple_coords(da, min_side):
  function test_is_simple_coords_pass (line 87) | def test_is_simple_coords_pass(da):
  function test_ds_like (line 93) | def test_ds_like(args, fill):
  function test_ds_like_mixed (line 100) | def test_ds_like_mixed(args, fill):
  function test_only_dataarray (line 107) | def test_only_dataarray(var_, da):
  function test_coord_compat (line 116) | def test_coord_compat(ds):
  function test_coord_compat_false (line 126) | def test_coord_compat_false(ds):
  function test_da_to_string (line 142) | def test_da_to_string(da):
  function test_da_concat (line 148) | def test_da_concat(da, n):
  function da_split (line 158) | def da_split(da, n):
  function test_ds_concat (line 173) | def test_ds_concat(ds, n):