code stringlengths 17 6.64M |
|---|
class Box(Space):
'\n A box in R^n.\n I.e., each coordinate is bounded.\n '
def __init__(self, low, high, shape=None):
'\n Two kinds of valid input:\n Box(-1.0, 1.0, (3,4)) # low and high are scalars, and shape is provided\n Box(np.array([-1.0,-2.0]), np.array([2... |
class Discrete(Space):
'\n {0,1,...,n-1}\n '
def __init__(self, n):
self._n = n
@property
def n(self):
return self._n
def sample(self):
return np.random.randint(self.n)
def contains(self, x):
x = np.asarray(x)
return ((x.shape == ()) and (x.dty... |
class Product(Space):
def __init__(self, *components):
if isinstance(components[0], (list, tuple)):
assert (len(components) == 1)
components = components[0]
self._components = tuple(components)
dtypes = [c.new_tensor_variable('tmp', extra_dims=0).dtype for c in com... |
def unique(l):
return list(set(l))
|
def flatten(l):
return [item for sublist in l for item in sublist]
|
def load_progress(progress_csv_path):
print(('Reading %s' % progress_csv_path))
entries = dict()
with open(progress_csv_path, 'r') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
for (k, v) in row.items():
if (k not in entries):
... |
def to_json(stub_object):
from rllab.misc.instrument import StubObject
from rllab.misc.instrument import StubAttr
if isinstance(stub_object, StubObject):
assert (len(stub_object.args) == 0)
data = dict()
for (k, v) in stub_object.kwargs.items():
data[k] = to_json(v)
... |
def flatten_dict(d):
flat_params = dict()
for (k, v) in d.items():
if isinstance(v, dict):
v = flatten_dict(v)
for (subk, subv) in flatten_dict(v).items():
flat_params[((k + '.') + subk)] = subv
else:
flat_params[k] = v
return flat_params... |
def load_params(params_json_path):
with open(params_json_path, 'r') as f:
data = json.loads(f.read())
if ('args_data' in data):
del data['args_data']
if ('exp_name' not in data):
data['exp_name'] = params_json_path.split('/')[(- 2)]
return data
|
def lookup(d, keys):
if (not isinstance(keys, list)):
keys = keys.split('.')
for k in keys:
if hasattr(d, '__getitem__'):
if (k in d):
d = d[k]
else:
return None
else:
return None
return d
|
def load_exps_data(exp_folder_paths, disable_variant=False):
exps = []
for exp_folder_path in exp_folder_paths:
exps += [x[0] for x in os.walk(exp_folder_path)]
exps_data = []
for exp in exps:
try:
exp_path = exp
params_json_path = os.path.join(exp_path, 'params... |
def smart_repr(x):
if isinstance(x, tuple):
if (len(x) == 0):
return 'tuple()'
elif (len(x) == 1):
return ('(%s,)' % smart_repr(x[0]))
else:
return (('(' + ','.join(map(smart_repr, x))) + ')')
elif hasattr(x, '__call__'):
return ("__import__(... |
def extract_distinct_params(exps_data, excluded_params=('exp_name', 'seed', 'log_dir'), l=1):
try:
stringified_pairs = sorted(map(eval, unique(flatten([list(map(smart_repr, list(d.flat_params.items()))) for d in exps_data]))), key=(lambda x: (tuple(((0.0 if (it is None) else it) for it in x)),)))
exce... |
class Selector(object):
def __init__(self, exps_data, filters=None, custom_filters=None):
self._exps_data = exps_data
if (filters is None):
self._filters = tuple()
else:
self._filters = tuple(filters)
if (custom_filters is None):
self._custom_fi... |
def hex_to_rgb(hex, opacity=1.0):
if (hex[0] == '#'):
hex = hex[1:]
assert (len(hex) == 6)
return 'rgba({0},{1},{2},{3})'.format(int(hex[:2], 16), int(hex[2:4], 16), int(hex[4:6], 16), opacity)
|
class BatchPolopt(RLAlgorithm):
'\n Base class for batch sampling-based policy optimization methods.\n This includes various policy gradient methods like vpg, npg, ppo, trpo, etc.\n '
def __init__(self, env, policy, baseline, scope=None, n_itr=500, start_itr=0, batch_size=5000, max_path_length=500, ... |
class BatchPolopt(RLAlgorithm):
'\n Base class for batch sampling-based policy optimization methods.\n This includes various policy gradient methods like vpg, npg, ppo, trpo, etc.\n '
def __init__(self, env, policy, baseline, scope=None, n_itr=500, start_itr=0, batch_size=5000, max_path_length=500, ... |
class MAESN_NPO(BatchMAESNPolopt):
'\n Natural Policy Optimization.\n '
def __init__(self, optimizer=None, optimizer_args=None, step_size=0.01, use_maml=True, **kwargs):
assert (optimizer is not None)
if (optimizer is None):
if (optimizer_args is None):
optim... |
class MAESN_TRPO(MAESN_NPO):
'\n Trust Region Policy Optimization\n '
def __init__(self, optimizer=None, optimizer_args=None, **kwargs):
if (optimizer is None):
if (optimizer_args is None):
optimizer_args = dict()
optimizer = ConjugateGradientOptimizer(**... |
class NPO(BatchPolopt):
'\n Natural Policy Optimization.\n '
def __init__(self, optimizer=None, optimizer_args=None, step_size=0.01, **kwargs):
if (optimizer is None):
if (optimizer_args is None):
optimizer_args = dict()
optimizer = PenaltyLbfgsOptimizer(... |
class TRPO(NPO):
'\n Trust Region Policy Optimization\n '
def __init__(self, optimizer=None, optimizer_args=None, **kwargs):
if (optimizer is None):
if (optimizer_args is None):
optimizer_args = dict()
optimizer = ConjugateGradientOptimizer(**optimizer_ar... |
class VPG(BatchPolopt, Serializable):
'\n Vanilla Policy Gradient.\n '
def __init__(self, env, policy, baseline, optimizer=None, optimizer_args=None, **kwargs):
Serializable.quick_init(self, locals())
if (optimizer is None):
default_args = dict(batch_size=None, max_epochs=1)... |
class VPG(BatchPolopt, Serializable):
'\n Vanilla Policy Gradient.\n '
def __init__(self, env, policy, baseline, default_step, **kwargs):
Serializable.quick_init(self, locals())
self.default_step_size = default_step
self.opt_info = None
super(VPG, self).__init__(env=env,... |
class VPG(BatchPolopt, Serializable):
'\n Vanilla Policy Gradient.\n '
def __init__(self, env, policy, baseline, default_step, **kwargs):
Serializable.quick_init(self, locals())
self.default_step_size = default_step
self.opt_info = None
super(VPG, self).__init__(env=env,... |
class LayersPowered(Parameterized):
def __init__(self, output_layers, input_layers=None):
self._output_layers = output_layers
self._input_layers = input_layers
Parameterized.__init__(self)
def get_params_internal(self, **tags):
layers = L.get_all_layers(self._output_layers, t... |
class MLP(LayersPowered, Serializable):
def __init__(self, name, output_dim, hidden_sizes, hidden_nonlinearity, output_nonlinearity, hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer, output_W_init=L.XavierUniformInitializer(), output_b_init=tf.zeros_initializer, input_var=None, inpu... |
class ConvNetwork(LayersPowered, Serializable):
def __init__(self, name, input_shape, output_dim, conv_filters, conv_filter_sizes, conv_strides, conv_pads, hidden_sizes, hidden_nonlinearity, output_nonlinearity, hidden_W_init=L.XavierUniformInitializer(), hidden_b_init=tf.zeros_initializer, output_W_init=L.Xavie... |
class GRUNetwork(object):
def __init__(self, name, input_shape, output_dim, hidden_dim, hidden_nonlinearity=tf.nn.relu, gru_layer_cls=L.GRULayer, output_nonlinearity=None, input_var=None, input_layer=None, layer_args=None):
with tf.variable_scope(name):
if (input_layer is None):
... |
class LSTMNetwork(object):
def __init__(self, name, input_shape, output_dim, hidden_dim, hidden_nonlinearity=tf.nn.relu, lstm_layer_cls=L.LSTMLayer, output_nonlinearity=None, input_var=None, input_layer=None, forget_bias=1.0, use_peepholes=False, layer_args=None):
with tf.variable_scope(name):
... |
class ConvMergeNetwork(LayersPowered, Serializable):
'\n This network allows the input to consist of a convolution-friendly component, plus a non-convolution-friendly\n component. These two components will be concatenated in the fully connected layers. There can also be a list of\n optional layers for th... |
@contextmanager
def suppress_params_loading():
global load_params
load_params = False
(yield)
load_params = True
|
class Parameterized(object):
def __init__(self):
self._cached_params = {}
self._cached_param_dtypes = {}
self._cached_param_shapes = {}
self._cached_assign_ops = {}
self._cached_assign_placeholders = {}
def get_params_internal(self, **tags):
'\n Interna... |
class JointParameterized(Parameterized):
def __init__(self, components):
super(JointParameterized, self).__init__()
self.components = components
def get_params_internal(self, **tags):
params = [param for comp in self.components for param in comp.get_params_internal(**tags)]
r... |
def make_input(shape, input_var=None, name='input', **kwargs):
if (input_var is None):
if (name is not None):
with tf.variable_scope(name):
input_var = tf.placeholder(tf.float32, shape=shape, name='input')
else:
input_var = tf.placeholder(tf.float32, shape=s... |
def _create_param(spec, shape, name, trainable=True, regularizable=True):
if (not hasattr(spec, '__call__')):
assert isinstance(spec, (tf.Tensor, tf.Variable))
return spec
assert hasattr(spec, '__call__')
if regularizable:
regularizer = None
else:
regularizer = (lambda ... |
def add_param(spec, shape, layer_name, name, weight_norm=None, variable_reuse=None, **tags):
with tf.variable_scope(layer_name, reuse=variable_reuse):
tags['trainable'] = tags.get('trainable', True)
tags['regularizable'] = tags.get('regularizable', True)
param = _create_param(spec, shape, ... |
def make_dense_layer(input_shape, num_units, name='fc', W=L.XavierUniformInitializer(), b=tf.zeros_initializer, weight_norm=False, **kwargs):
num_inputs = int(np.prod(input_shape[1:]))
W = add_param(W, (num_inputs, num_units), layer_name=name, name='W', weight_norm=weight_norm)
if (b is not None):
... |
def forward_dense_layer(input, W, b, nonlinearity=tf.identity, batch_norm=False, scope='', reuse=True, is_training=False):
if (input.get_shape().ndims > 2):
input = tf.reshape(input, tf.stack([tf.shape(input)[0], (- 1)]))
activation = tf.matmul(input, W)
if (b is not None):
activation = (a... |
def make_param_layer(num_units, name='', param=tf.zeros_initializer(), trainable=True):
param = add_param(param, (num_units,), layer_name=name, name='param', trainable=trainable)
return param
|
def forward_param_layer(input, param):
ndim = input.get_shape().ndims
param = tf.convert_to_tensor(param)
num_units = int(param.get_shape()[0])
reshaped_param = tf.reshape(param, (((1,) * (ndim - 1)) + (num_units,)))
tile_arg = tf.concat([tf.shape(input)[:(ndim - 1)], [1]], 0)
tiled = tf.tile(... |
class Distribution(object):
@property
def dim(self):
raise NotImplementedError
def kl_sym(self, old_dist_info_vars, new_dist_info_vars):
'\n Compute the symbolic KL divergence of two distributions\n '
raise NotImplementedError
def kl(self, old_dist_info, new_di... |
class Bernoulli(Distribution):
def __init__(self, dim):
self._dim = dim
@property
def dim(self):
return self._dim
def kl_sym(self, old_dist_info_vars, new_dist_info_vars):
old_p = old_dist_info_vars['p']
new_p = new_dist_info_vars['p']
kl = ((old_p * (tf.log(... |
class DiagonalGaussian(Distribution):
def __init__(self, dim):
self._dim = dim
@property
def dim(self):
return self._dim
def kl(self, old_dist_info, new_dist_info):
old_means = old_dist_info['mean']
old_log_stds = old_dist_info['log_std']
new_means = new_dist... |
class RecurrentCategorical(Distribution):
def __init__(self, dim):
self._cat = Categorical(dim)
self._dim = dim
@property
def dim(self):
return self._dim
def kl_sym(self, old_dist_info_vars, new_dist_info_vars):
'\n Compute the symbolic KL divergence of two ca... |
def to_tf_space(space):
if isinstance(space, TheanoBox):
return Box(low=space.low, high=space.high)
elif isinstance(space, TheanoDiscrete):
return Discrete(space.n)
elif isinstance(space, TheanoProduct):
return Product(list(map(to_tf_space, space.components)))
else:
rai... |
class WrappedCls(object):
def __init__(self, cls, env_cls, extra_kwargs):
self.cls = cls
self.env_cls = env_cls
self.extra_kwargs = extra_kwargs
def __call__(self, *args, **kwargs):
return self.cls(self.env_cls(*args, **dict(self.extra_kwargs, **kwargs)))
|
class TfEnv(ProxyEnv):
@cached_property
def observation_space(self):
return to_tf_space(self.wrapped_env.observation_space)
@cached_property
def action_space(self):
return to_tf_space(self.wrapped_env.action_space)
@cached_property
def spec(self):
return EnvSpec(obse... |
class VecTfEnv(object):
def __init__(self, vec_env):
self.vec_env = vec_env
def reset(self, reset_args=None):
return self.vec_env.reset(reset_args=reset_args)
@property
def num_envs(self):
return self.vec_env.num_envs
def step(self, action_n):
return self.vec_en... |
def worker_init_envs(G, alloc, scope, env):
logger.log(('initializing environment on worker %d' % G.worker_id))
if (not hasattr(G, 'parallel_vec_envs')):
G.parallel_vec_envs = dict()
G.parallel_vec_env_template = dict()
G.parallel_vec_envs[scope] = [(idx, pickle.loads(pickle.dumps(env))) f... |
def worker_run_reset(G, flags, scope):
if (not hasattr(G, 'parallel_vec_envs')):
logger.log(('on worker %d' % G.worker_id))
import traceback
for line in traceback.format_stack():
logger.log(line)
logger.log('oops')
for (k, v) in G.__dict__.items():
l... |
def worker_run_step(G, action_n, scope):
assert hasattr(G, 'parallel_vec_envs')
assert (scope in G.parallel_vec_envs)
env_template = G.parallel_vec_env_template[scope]
ids = []
step_results = []
for (idx, env) in G.parallel_vec_envs[scope]:
action = action_n[idx]
ids.append(idx... |
def worker_collect_env_time(G):
return G.env_time
|
class ParallelVecEnvExecutor(object):
def __init__(self, env, n, max_path_length, scope=None):
if (scope is None):
scope = str(uuid.uuid4())
envs_per_worker = int(np.ceil(((n * 1.0) / singleton_pool.n_parallel)))
alloc_env_ids = []
rest_alloc = n
start_id = 0
... |
class VecEnvExecutor(object):
def __init__(self, envs, max_path_length):
self.envs = envs
self._action_space = envs[0].action_space
self._observation_space = envs[0].observation_space
self.ts = np.zeros(len(self.envs), dtype='int')
self.max_path_length = max_path_length
... |
def compile_function(inputs, outputs, log_name=None):
def run(*input_vals):
sess = tf.get_default_session()
return sess.run(outputs, feed_dict=dict(list(zip(inputs, input_vals))))
return run
|
def flatten_tensor_variables(ts):
return tf.concat(axis=0, values=[tf.reshape(x, [(- 1)]) for x in ts])
|
def unflatten_tensor_variables(flatarr, shapes, symb_arrs):
arrs = []
n = 0
for (shape, symb_arr) in zip(shapes, symb_arrs):
size = np.prod(list(shape))
arr = tf.reshape(flatarr[n:(n + size)], shape)
arrs.append(arr)
n += size
return arrs
|
def new_tensor(name, ndim, dtype):
return tf.placeholder(dtype=dtype, shape=([None] * ndim), name=name)
|
def new_tensor_like(name, arr_like):
return new_tensor(name, arr_like.get_shape().ndims, arr_like.dtype.base_dtype)
|
def concat_tensor_list(tensor_list):
return np.concatenate(tensor_list, axis=0)
|
def concat_tensor_dict_list(tensor_dict_list):
keys = list(tensor_dict_list[0].keys())
ret = dict()
for k in keys:
example = tensor_dict_list[0][k]
if isinstance(example, dict):
v = concat_tensor_dict_list([x[k] for x in tensor_dict_list])
else:
v = concat_t... |
def stack_tensor_list(tensor_list):
return np.array(tensor_list)
|
def stack_tensor_dict_list(tensor_dict_list):
'\n Stack a list of dictionaries of {tensors or dictionary of tensors}.\n :param tensor_dict_list: a list of dictionaries of {tensors or dictionary of tensors}.\n :return: a dictionary of {stacked tensors or dictionary of stacked tensors}\n '
keys = li... |
def split_tensor_dict_list(tensor_dict):
keys = list(tensor_dict.keys())
ret = None
for k in keys:
vals = tensor_dict[k]
if isinstance(vals, dict):
vals = split_tensor_dict_list(vals)
if (ret is None):
ret = [{k: v} for v in vals]
else:
f... |
def to_onehot_sym(inds, dim):
return tf.one_hot(inds, depth=dim, on_value=1, off_value=0)
|
def pad_tensor(x, max_len):
return np.concatenate([x, np.tile(np.zeros_like(x[0]), (((max_len - len(x)),) + ((1,) * np.ndim(x[0]))))])
|
def pad_tensor_n(xs, max_len):
ret = np.zeros(((len(xs), max_len) + xs[0].shape[1:]), dtype=xs[0].dtype)
for (idx, x) in enumerate(xs):
ret[idx][:len(x)] = x
return ret
|
def pad_tensor_dict(tensor_dict, max_len):
keys = list(tensor_dict.keys())
ret = dict()
for k in keys:
if isinstance(tensor_dict[k], dict):
ret[k] = pad_tensor_dict(tensor_dict[k], max_len)
else:
ret[k] = pad_tensor(tensor_dict[k], max_len)
return ret
|
class PerlmutterHvp(object):
def __init__(self, num_slices=1):
self.target = None
self.reg_coeff = None
self.opt_fun = None
self._num_slices = num_slices
def update_opt(self, f, target, inputs, reg_coeff):
self.target = target
self.reg_coeff = reg_coeff
... |
class FiniteDifferenceHvp(object):
def __init__(self, base_eps=1e-08, symmetric=True, grad_clip=None, num_slices=1):
self.base_eps = base_eps
self.symmetric = symmetric
self.grad_clip = grad_clip
self._num_slices = num_slices
def update_opt(self, f, target, inputs, reg_coeff)... |
class ConjugateGradientOptimizer(Serializable):
'\n Performs constrained optimization via line search. The search direction is computed using a conjugate gradient\n algorithm, which gives x = A^{-1}g, where A is a second order approximation of the constraint and g is the gradient\n of the loss function.\... |
class FirstOrderOptimizer(Serializable):
'\n Performs (stochastic) gradient descent, possibly using fancier methods like adam etc.\n '
def __init__(self, tf_optimizer_cls=None, tf_optimizer_args=None, max_epochs=1000, tolerance=1e-06, batch_size=32, callback=None, verbose=False, init_learning_rate=None... |
class LbfgsOptimizer(Serializable):
'\n Performs unconstrained optimization via L-BFGS.\n '
def __init__(self, name, max_opt_itr=20, callback=None):
Serializable.quick_init(self, locals())
self._name = name
self._max_opt_itr = max_opt_itr
self._opt_fun = None
sel... |
class PenaltyLbfgsOptimizer(Serializable):
'\n Performs constrained optimization via penalized L-BFGS. The penalty term is adaptively adjusted to make sure that\n the constraint is satisfied.\n '
def __init__(self, name, max_opt_itr=20, initial_penalty=1.0, min_penalty=0.01, max_penalty=1000000.0, i... |
def optimize(surr_obj, surr_obj_latent, inputs):
param_keys = []
param_keys_latent = []
all_keys = list(self.policy.all_params.keys())
all_keys.remove('latent_means_stepsize')
all_keys.remove('latent_stds_stepsize')
for key in all_keys:
if ('latent' not in key):
param_keys.... |
class Policy(Parameterized):
def __init__(self, env_spec):
Parameterized.__init__(self)
self._env_spec = env_spec
def get_action(self, observation):
raise NotImplementedError
def get_actions(self, observations):
raise NotImplementedError
def reset(self, dones=None):... |
class StochasticPolicy(Policy):
@property
def distribution(self):
'\n :rtype Distribution\n '
raise NotImplementedError
def dist_info_sym(self, obs_var, state_info_vars):
'\n Return the symbolic distribution information about the actions.\n :param obs_... |
class CategoricalGRUPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_dim=32, feature_network=None, state_include_action=True, hidden_nonlinearity=tf.tanh, gru_layer_cls=L.GRULayer):
'\n :param env_spec: A spec for the env.\n :param hidden_dim:... |
class CategoricalLSTMPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_dim=32, feature_network=None, prob_network=None, state_include_action=True, hidden_nonlinearity=tf.tanh, forget_bias=1.0, use_peepholes=False, lstm_layer_cls=L.LSTMLayer):
'\n :par... |
class CategoricalMLPPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, prob_network=None):
'\n :param env_spec: A spec for the mdp.\n :param hidden_sizes: list of sizes for the fully connected hidd... |
class GaussianGRUPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_dim=32, feature_network=None, state_include_action=True, hidden_nonlinearity=tf.tanh, gru_layer_cls=L.GRULayer, learn_std=True, init_std=1.0, output_nonlinearity=None):
'\n :param env_... |
class GaussianLSTMPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_dim=32, feature_network=None, state_include_action=True, hidden_nonlinearity=tf.tanh, learn_std=True, init_std=1.0, output_nonlinearity=None, lstm_layer_cls=L.LSTMLayer):
'\n :param e... |
class GaussianMLPPolicy(StochasticPolicy, LayersPowered, Serializable):
def __init__(self, name, env_spec, hidden_sizes=(32, 32), learn_std=True, init_std=1.0, adaptive_std=False, std_share_network=False, std_hidden_sizes=(32, 32), min_std=1e-06, std_hidden_nonlinearity=tf.nn.tanh, hidden_nonlinearity=tf.nn.tanh... |
@contextmanager
def suppress_params_loading():
global load_params
load_params = False
(yield)
load_params = True
|
class CategoricalMLPPolicy(StochasticPolicy, Serializable):
def __init__(self, name, env_spec, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, prob_network=None):
'\n :param env_spec: A spec for the mdp.\n :param hidden_sizes: list of sizes for the fully connected hidden layers\n ... |
@contextmanager
def suppress_params_loading():
global load_params
load_params = False
(yield)
load_params = True
|
class GaussianMLPPolicy(StochasticPolicy, Serializable):
def __init__(self, name, env_spec, hidden_sizes=(32, 32), learn_std=True, init_std=1.0, adaptive_std=False, std_share_network=False, std_hidden_sizes=(32, 32), min_std=1e-06, std_hidden_nonlinearity=tf.nn.tanh, hidden_nonlinearity=tf.nn.tanh, output_nonlin... |
class UniformControlPolicy(Policy, Serializable):
def __init__(self, env_spec):
Serializable.quick_init(self, locals())
super(UniformControlPolicy, self).__init__(env_spec=env_spec)
@property
def vectorized(self):
return True
def get_action(self, observation):
return... |
class BernoulliMLPRegressor(LayersPowered, Serializable):
'\n A class for performing regression (or classification, really) by fitting a bernoulli distribution to each of the\n output units.\n '
def __init__(self, input_shape, output_dim, name, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.relu, ... |
class CategoricalMLPRegressor(LayersPowered, Serializable):
'\n A class for performing regression (or classification, really) by fitting a categorical distribution to the outputs.\n Assumes that the outputs will be always a one hot vector.\n '
def __init__(self, name, input_shape, output_dim, prob_n... |
class DeterministicMLPRegressor(LayersPowered, Serializable):
'\n A class for performing nonlinear regression.\n '
def __init__(self, name, input_shape, output_dim, network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, output_nonlinearity=None, optimizer=None, normalize_inputs=True):
... |
class GaussianMLPRegressor(LayersPowered, Serializable):
'\n A class for performing regression by fitting a Gaussian distribution to the outputs.\n '
def __init__(self, name, input_shape, output_dim, mean_network=None, hidden_sizes=(32, 32), hidden_nonlinearity=tf.nn.tanh, optimizer=None, use_trust_reg... |
def worker_init_tf(G):
G.sess = tf.Session()
G.sess.__enter__()
|
def worker_init_tf_vars(G):
G.sess.run(tf.global_variables_initializer())
|
class BatchSampler(BaseSampler):
def __init__(self, algo, n_envs=1):
super(BatchSampler, self).__init__(algo)
self.n_envs = n_envs
def start_worker(self):
if (singleton_pool.n_parallel > 1):
singleton_pool.run_each(worker_init_tf)
parallel_sampler.populate_task(se... |
class VectorizedSampler(BaseSampler):
def __init__(self, algo, n_envs=None, latent_dim=None):
super(VectorizedSampler, self).__init__(algo)
self.n_envs = n_envs
self.latent_dim = latent_dim
def start_worker(self):
n_envs = self.n_envs
if (n_envs is None):
... |
class VectorizedSamplerNoNoise(BaseSampler):
def __init__(self, algo, n_envs=None, latent_dim=None):
super(VectorizedSamplerNoNoise, self).__init__(algo)
self.n_envs = n_envs
self.latent_dim = latent_dim
def start_worker(self):
n_envs = self.n_envs
if (n_envs is None)... |
class Box(TheanoBox):
def new_tensor_variable(self, name, extra_dims):
return tf.placeholder(tf.float32, shape=(([None] * extra_dims) + [self.flat_dim]), name=name)
|
class Discrete(Space):
'\n {0,1,...,n-1}\n '
def __init__(self, n):
self._n = n
@property
def n(self):
return self._n
def sample(self):
return np.random.randint(self.n)
def sample_n(self, n):
return np.random.randint(low=0, high=self.n, size=n)
de... |
class Product(Space):
def __init__(self, *components):
if isinstance(components[0], (list, tuple)):
assert (len(components) == 1)
components = components[0]
self._components = tuple(components)
dtypes = [c.new_tensor_variable('tmp', extra_dims=0).dtype for c in com... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.