Spaces:
Running
Running
# Copyright (c) Microsoft Corporation. | |
# Licensed under the MIT license. | |
import numpy as np | |
from .runtime.env_vars import trial_env_vars | |
from . import trial | |
from . import parameter_expressions as param_exp | |
from .common.nas_utils import classic_mode, enas_mode, oneshot_mode, darts_mode | |
__all__ = [ | |
'choice', | |
'randint', | |
'uniform', | |
'quniform', | |
'loguniform', | |
'qloguniform', | |
'normal', | |
'qnormal', | |
'lognormal', | |
'qlognormal', | |
'function_choice', | |
'mutable_layer' | |
] | |
if trial_env_vars.NNI_PLATFORM is None: | |
def choice(*options, name=None): | |
return param_exp.choice(options, np.random.RandomState()) | |
def randint(lower, upper, name=None): | |
return param_exp.randint(lower, upper, np.random.RandomState()) | |
def uniform(low, high, name=None): | |
return param_exp.uniform(low, high, np.random.RandomState()) | |
def quniform(low, high, q, name=None): | |
assert high > low, 'Upper bound must be larger than lower bound' | |
return param_exp.quniform(low, high, q, np.random.RandomState()) | |
def loguniform(low, high, name=None): | |
assert low > 0, 'Lower bound must be positive' | |
return param_exp.loguniform(low, high, np.random.RandomState()) | |
def qloguniform(low, high, q, name=None): | |
return param_exp.qloguniform(low, high, q, np.random.RandomState()) | |
def normal(mu, sigma, name=None): | |
return param_exp.normal(mu, sigma, np.random.RandomState()) | |
def qnormal(mu, sigma, q, name=None): | |
return param_exp.qnormal(mu, sigma, q, np.random.RandomState()) | |
def lognormal(mu, sigma, name=None): | |
return param_exp.lognormal(mu, sigma, np.random.RandomState()) | |
def qlognormal(mu, sigma, q, name=None): | |
return param_exp.qlognormal(mu, sigma, q, np.random.RandomState()) | |
def function_choice(*funcs, name=None): | |
return param_exp.choice(funcs, np.random.RandomState())() | |
def mutable_layer(): | |
raise RuntimeError('Cannot call nni.mutable_layer in this mode') | |
else: | |
def choice(options, name=None, key=None): | |
return options[_get_param(key)] | |
def randint(lower, upper, name=None, key=None): | |
return _get_param(key) | |
def uniform(low, high, name=None, key=None): | |
return _get_param(key) | |
def quniform(low, high, q, name=None, key=None): | |
return _get_param(key) | |
def loguniform(low, high, name=None, key=None): | |
return _get_param(key) | |
def qloguniform(low, high, q, name=None, key=None): | |
return _get_param(key) | |
def normal(mu, sigma, name=None, key=None): | |
return _get_param(key) | |
def qnormal(mu, sigma, q, name=None, key=None): | |
return _get_param(key) | |
def lognormal(mu, sigma, name=None, key=None): | |
return _get_param(key) | |
def qlognormal(mu, sigma, q, name=None, key=None): | |
return _get_param(key) | |
def function_choice(funcs, name=None, key=None): | |
return funcs[_get_param(key)]() | |
def mutable_layer( | |
mutable_id, | |
mutable_layer_id, | |
funcs, | |
funcs_args, | |
fixed_inputs, | |
optional_inputs, | |
optional_input_size, | |
mode='classic_mode', | |
tf=None): | |
'''execute the chosen function and inputs. | |
Below is an example of chosen function and inputs: | |
{ | |
"mutable_id": { | |
"mutable_layer_id": { | |
"chosen_layer": "pool", | |
"chosen_inputs": ["out1", "out3"] | |
} | |
} | |
} | |
Parameters: | |
--------------- | |
mutable_id: the name of this mutable_layer block (which could have multiple mutable layers) | |
mutable_layer_id: the name of a mutable layer in this block | |
funcs: dict of function calls | |
funcs_args: | |
fixed_inputs: | |
optional_inputs: dict of optional inputs | |
optional_input_size: number of candidate inputs to be chosen | |
tf: tensorflow module | |
''' | |
args = (mutable_id, mutable_layer_id, funcs, funcs_args, fixed_inputs, optional_inputs, optional_input_size) | |
if mode == 'classic_mode': | |
return classic_mode(*args) | |
assert tf is not None, 'Internal Error: Tensorflow should not be None in modes other than classic_mode' | |
if mode == 'enas_mode': | |
return enas_mode(*args, tf) | |
if mode == 'oneshot_mode': | |
return oneshot_mode(*args, tf) | |
if mode == 'darts_mode': | |
return darts_mode(*args, tf) | |
raise RuntimeError('Unrecognized mode: %s' % mode) | |
def _get_param(key): | |
if trial.get_current_parameter() is None: | |
trial.get_next_parameter() | |
return trial.get_current_parameter(key) | |