code stringlengths 66 870k | docstring stringlengths 19 26.7k | func_name stringlengths 1 138 | language stringclasses 1
value | repo stringlengths 7 68 | path stringlengths 5 324 | url stringlengths 46 389 | license stringclasses 7
values |
|---|---|---|---|---|---|---|---|
def test_torch_to_np():
"""Test whether tuples of tensors can be converted to np arrays."""
tup = (torch.zeros(1), torch.zeros(1))
np_out_1, np_out_2 = torch_to_np(tup)
assert isinstance(np_out_1, np.ndarray)
assert isinstance(np_out_2, np.ndarray) | Test whether tuples of tensors can be converted to np arrays. | test_torch_to_np | python | rlworkgroup/garage | tests/garage/torch/test_functions.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/test_functions.py | MIT |
def test_as_torch_dict():
"""Test if dict whose values are tensors can be converted to np arrays."""
dic = {'a': np.zeros(1), 'b': np.ones(1)}
as_torch_dict(dic)
for dic_value in dic.values():
assert isinstance(dic_value, torch.Tensor) | Test if dict whose values are tensors can be converted to np arrays. | test_as_torch_dict | python | rlworkgroup/garage | tests/garage/torch/test_functions.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/test_functions.py | MIT |
def test_product_of_gaussians():
"""Test computing mu, sigma of product of gaussians."""
size = 5
mu = torch.ones(size)
sigmas_squared = torch.ones(size)
output = product_of_gaussians(mu, sigmas_squared)
assert output[0] == 1
assert output[1] == 1 / size | Test computing mu, sigma of product of gaussians. | test_product_of_gaussians | python | rlworkgroup/garage | tests/garage/torch/test_functions.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/test_functions.py | MIT |
def get_actions(self, observations):
"""Get actions given observations.
Args:
observations (np.ndarray): Observations from the environment.
Has shape :math:`(B, O)`, where :math:`B` is the batch
dimension and :math:`O` is the observation dimensionality (at
least 2).
Returns:
tuple:
* np.ndarray: Batch of optimal actions.
Has shape :math:`(B, 2)`, where :math:`B` is the batch
dimension.
Optimal action in the environment.
* dict[str, np.ndarray]: Agent info (empty).
"""
return (self.goal[np.newaxis, :].repeat(len(observations), axis=0) -
observations[:, :2]), {} | Get actions given observations.
Args:
observations (np.ndarray): Observations from the environment.
Has shape :math:`(B, O)`, where :math:`B` is the batch
dimension and :math:`O` is the observation dimensionality (at
least 2).
Returns:
tuple:
* np.ndarray: Batch of optimal actions.
Has shape :math:`(B, 2)`, where :math:`B` is the batch
dimension.
Optimal action in the environment.
* dict[str, np.ndarray]: Agent info (empty).
| get_actions | python | rlworkgroup/garage | tests/garage/torch/algos/test_bc.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_bc.py | MIT |
def test_ddpg_pendulum(self):
"""Test DDPG with Pendulum environment.
This environment has a [-3, 3] action_space bound.
"""
deterministic.set_seed(0)
trainer = Trainer(snapshot_config)
env = normalize(GymEnv('InvertedPendulum-v2'))
policy = DeterministicMLPPolicy(env_spec=env.spec,
hidden_sizes=[64, 64],
hidden_nonlinearity=F.relu,
output_nonlinearity=torch.tanh)
exploration_policy = AddOrnsteinUhlenbeckNoise(env.spec,
policy,
sigma=0.2)
qf = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[64, 64],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6))
sampler = LocalSampler(agents=exploration_policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
algo = DDPG(env_spec=env.spec,
policy=policy,
qf=qf,
replay_buffer=replay_buffer,
sampler=sampler,
steps_per_epoch=20,
n_train_steps=50,
min_buffer_size=int(1e4),
exploration_policy=exploration_policy,
target_update_tau=1e-2,
discount=0.9)
trainer.setup(algo, env)
last_avg_ret = trainer.train(n_epochs=10, batch_size=100)
assert last_avg_ret > 10
env.close() | Test DDPG with Pendulum environment.
This environment has a [-3, 3] action_space bound.
| test_ddpg_pendulum | python | rlworkgroup/garage | tests/garage/torch/algos/test_ddpg.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_ddpg.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
self.env = normalize(GymEnv(HalfCheetahDirEnv(),
max_episode_length=100),
expected_action_scale=10.)
task_sampler = SetTaskSampler(lambda: normalize(
GymEnv(HalfCheetahDirEnv()), expected_action_scale=10.))
self.policy = GaussianMLPPolicy(
env_spec=self.env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
self.value_function = GaussianMLPValueFunction(env_spec=self.env.spec,
hidden_sizes=(32, 32))
self.algo = MAMLPPO(env=self.env,
policy=self.policy,
sampler=None,
task_sampler=task_sampler,
value_function=self.value_function,
meta_batch_size=5,
discount=0.99,
gae_lambda=1.,
inner_lr=0.1,
num_grad_updates=1) | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml.py | MIT |
def _test_params(v, m):
"""Test if all parameters of a module equal to a value."""
if isinstance(m, torch.nn.Linear):
assert torch.all(torch.eq(m.weight.data, v))
assert torch.all(torch.eq(m.bias.data, v)) | Test if all parameters of a module equal to a value. | _test_params | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml.py | MIT |
def test_get_exploration_policy(self):
"""Test if an independent copy of policy is returned."""
self.policy.apply(partial(self._set_params, 0.1))
adapt_policy = self.algo.get_exploration_policy()
adapt_policy.apply(partial(self._set_params, 0.2))
# Old policy should remain untouched
self.policy.apply(partial(self._test_params, 0.1))
adapt_policy.apply(partial(self._test_params, 0.2)) | Test if an independent copy of policy is returned. | test_get_exploration_policy | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml.py | MIT |
def test_adapt_policy(self):
"""Test if policy can adapt to samples."""
worker = WorkerFactory(seed=100, max_episode_length=100)
sampler = LocalSampler.from_worker_factory(worker, self.policy,
self.env)
self.policy.apply(partial(self._set_params, 0.1))
adapt_policy = self.algo.get_exploration_policy()
eps = sampler.obtain_samples(0, 100, adapt_policy)
self.algo.adapt_policy(adapt_policy, eps)
# Old policy should remain untouched
self.policy.apply(partial(self._test_params, 0.1))
# Adapted policy should not be identical to old policy
for v1, v2 in zip(adapt_policy.parameters(), self.policy.parameters()):
if v1.data.ne(v2.data).sum() > 0:
break
else:
pytest.fail('Parameters of adapted policy should not be '
'identical to the old policy.') | Test if policy can adapt to samples. | test_adapt_policy | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
self.env = normalize(GymEnv(HalfCheetahDirEnv(),
max_episode_length=100),
expected_action_scale=10.)
self.task_sampler = SetTaskSampler(
HalfCheetahDirEnv,
wrapper=lambda env, _: normalize(GymEnv(env,
max_episode_length=100),
expected_action_scale=10.))
self.policy = GaussianMLPPolicy(
env_spec=self.env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
self.value_function = GaussianMLPValueFunction(env_spec=self.env.spec,
hidden_sizes=(32, 32))
self.sampler = LocalSampler(
agents=self.policy,
envs=self.env,
max_episode_length=self.env.spec.max_episode_length) | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml_ppo.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml_ppo.py | MIT |
def test_maml_trpo_dummy_named_env():
"""Test with dummy environment that has env_name."""
env = normalize(GymEnv(DummyMultiTaskBoxEnv(), max_episode_length=100),
expected_action_scale=10.)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
value_function = GaussianMLPValueFunction(env_spec=env.spec,
hidden_sizes=(32, 32))
task_sampler = SetTaskSampler(
DummyMultiTaskBoxEnv,
wrapper=lambda env, _: normalize(GymEnv(env, max_episode_length=100),
expected_action_scale=10.))
episodes_per_task = 2
max_episode_length = env.spec.max_episode_length
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length)
trainer = Trainer(snapshot_config)
algo = MAMLTRPO(env=env,
policy=policy,
sampler=sampler,
task_sampler=task_sampler,
value_function=value_function,
meta_batch_size=5,
discount=0.99,
gae_lambda=1.,
inner_lr=0.1,
num_grad_updates=1)
trainer.setup(algo, env)
trainer.train(n_epochs=2,
batch_size=episodes_per_task * max_episode_length) | Test with dummy environment that has env_name. | test_maml_trpo_dummy_named_env | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml_trpo.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml_trpo.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
max_episode_length = 100
self.env = normalize(GymEnv(HalfCheetahDirEnv(),
max_episode_length=max_episode_length),
expected_action_scale=10.)
self.task_sampler = SetTaskSampler(
HalfCheetahDirEnv,
wrapper=lambda env, _: normalize(GymEnv(
env, max_episode_length=max_episode_length),
expected_action_scale=10.))
self.policy = GaussianMLPPolicy(
env_spec=self.env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
self.value_function = GaussianMLPValueFunction(env_spec=self.env.spec,
hidden_sizes=(32, 32)) | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_maml_vpg.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_maml_vpg.py | MIT |
def test_mtsac_get_log_alpha(monkeypatch):
"""Check that the private function _get_log_alpha functions correctly.
MTSAC uses disentangled alphas, meaning that
"""
env_names = ['CartPole-v0', 'CartPole-v1']
task_envs = [GymEnv(name, max_episode_length=100) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
num_tasks = 2
buffer_batch_size = 2
mtsac = MTSAC(policy=policy,
qf1=qf1,
qf2=qf2,
sampler=None,
gradient_steps_per_itr=150,
eval_env=[env],
env_spec=env.spec,
num_tasks=num_tasks,
steps_per_epoch=5,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=buffer_batch_size)
monkeypatch.setattr(mtsac, '_log_alpha', torch.Tensor([1., 2.]))
for i, _ in enumerate(env_names):
obs = torch.Tensor([env.reset()[0]] * buffer_batch_size)
log_alpha = mtsac._get_log_alpha(dict(observation=obs))
assert (log_alpha == torch.Tensor([i + 1, i + 1])).all().item()
assert log_alpha.size() == torch.Size([mtsac._buffer_batch_size]) | Check that the private function _get_log_alpha functions correctly.
MTSAC uses disentangled alphas, meaning that
| test_mtsac_get_log_alpha | python | rlworkgroup/garage | tests/garage/torch/algos/test_mtsac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_mtsac.py | MIT |
def test_mtsac_get_log_alpha_incorrect_num_tasks(monkeypatch):
"""Check that if the num_tasks passed does not match the number of tasks
in the environment, then the algorithm should raise an exception.
MTSAC uses disentangled alphas, meaning that
"""
env_names = ['CartPole-v0', 'CartPole-v1']
task_envs = [GymEnv(name, max_episode_length=150) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
buffer_batch_size = 2
mtsac = MTSAC(policy=policy,
qf1=qf1,
qf2=qf2,
sampler=None,
gradient_steps_per_itr=150,
eval_env=[env],
env_spec=env.spec,
num_tasks=4,
steps_per_epoch=5,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=buffer_batch_size)
monkeypatch.setattr(mtsac, '_log_alpha', torch.Tensor([1., 2.]))
error_string = ('The number of tasks in the environment does '
'not match self._num_tasks. Are you sure that you passed '
'The correct number of tasks?')
obs = torch.Tensor([env.reset()[0]] * buffer_batch_size)
with pytest.raises(ValueError, match=error_string):
mtsac._get_log_alpha(dict(observation=obs)) | Check that if the num_tasks passed does not match the number of tasks
in the environment, then the algorithm should raise an exception.
MTSAC uses disentangled alphas, meaning that
| test_mtsac_get_log_alpha_incorrect_num_tasks | python | rlworkgroup/garage | tests/garage/torch/algos/test_mtsac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_mtsac.py | MIT |
def test_mtsac_inverted_double_pendulum():
"""Performance regression test of MTSAC on 2 InvDoublePendulum envs."""
env_names = ['InvertedDoublePendulum-v2', 'InvertedDoublePendulum-v2']
task_envs = [GymEnv(name, max_episode_length=100) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
test_envs = MultiEnvWrapper(task_envs,
sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
trainer = Trainer(snapshot_config=snapshot_config)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
num_tasks = 2
buffer_batch_size = 128
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
mtsac = MTSAC(policy=policy,
qf1=qf1,
qf2=qf2,
sampler=sampler,
gradient_steps_per_itr=100,
eval_env=[test_envs],
env_spec=env.spec,
num_tasks=num_tasks,
steps_per_epoch=5,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=buffer_batch_size)
trainer.setup(mtsac, env)
ret = trainer.train(n_epochs=8, batch_size=128, plot=False)
assert ret > 0 | Performance regression test of MTSAC on 2 InvDoublePendulum envs. | test_mtsac_inverted_double_pendulum | python | rlworkgroup/garage | tests/garage/torch/algos/test_mtsac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_mtsac.py | MIT |
def test_to():
"""Test the torch function that moves modules to GPU.
Test that the policy and qfunctions are moved to gpu if gpu is
available.
"""
env_names = ['CartPole-v0', 'CartPole-v1']
task_envs = [GymEnv(name, max_episode_length=100) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[1, 1],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
num_tasks = 2
buffer_batch_size = 2
mtsac = MTSAC(policy=policy,
qf1=qf1,
qf2=qf2,
sampler=None,
gradient_steps_per_itr=150,
eval_env=[env],
env_spec=env.spec,
num_tasks=num_tasks,
steps_per_epoch=5,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=buffer_batch_size)
set_gpu_mode(torch.cuda.is_available())
mtsac.to()
device = global_device()
for param in mtsac._qf1.parameters():
assert param.device == device
for param in mtsac._qf2.parameters():
assert param.device == device
for param in mtsac._qf2.parameters():
assert param.device == device
for param in mtsac.policy.parameters():
assert param.device == device
assert mtsac._log_alpha.device == device | Test the torch function that moves modules to GPU.
Test that the policy and qfunctions are moved to gpu if gpu is
available.
| test_to | python | rlworkgroup/garage | tests/garage/torch/algos/test_mtsac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_mtsac.py | MIT |
def test_fixed_alpha():
"""Test if using fixed_alpha ensures that alpha is non differentiable."""
env_names = ['InvertedDoublePendulum-v2', 'InvertedDoublePendulum-v2']
task_envs = [GymEnv(name, max_episode_length=100) for name in env_names]
env = MultiEnvWrapper(task_envs, sample_strategy=round_robin_strategy)
test_envs = MultiEnvWrapper(task_envs,
sample_strategy=round_robin_strategy)
deterministic.set_seed(0)
trainer = Trainer(snapshot_config=snapshot_config)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
num_tasks = 2
buffer_batch_size = 128
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
mtsac = MTSAC(policy=policy,
qf1=qf1,
qf2=qf2,
sampler=sampler,
gradient_steps_per_itr=100,
eval_env=[test_envs],
env_spec=env.spec,
num_tasks=num_tasks,
steps_per_epoch=1,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=buffer_batch_size,
fixed_alpha=np.exp(0.5))
if torch.cuda.is_available():
set_gpu_mode(True)
else:
set_gpu_mode(False)
mtsac.to()
assert torch.allclose(torch.Tensor([0.5] * num_tasks),
mtsac._log_alpha.to('cpu'))
trainer.setup(mtsac, env)
trainer.train(n_epochs=1, batch_size=128, plot=False)
assert torch.allclose(torch.Tensor([0.5] * num_tasks),
mtsac._log_alpha.to('cpu'))
assert not mtsac._use_automatic_entropy_tuning | Test if using fixed_alpha ensures that alpha is non differentiable. | test_fixed_alpha | python | rlworkgroup/garage | tests/garage/torch/algos/test_mtsac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_mtsac.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
self.env = normalize(
GymEnv('InvertedDoublePendulum-v2', max_episode_length=100))
self.policy = GaussianMLPPolicy(
env_spec=self.env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
self.value_function = GaussianMLPValueFunction(env_spec=self.env.spec) | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_ppo.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_ppo.py | MIT |
def __call__(self, observation):
"""Dummy forward operation. Returns a dummy distribution."""
action = torch.Tensor([self._action])
return _MockDistribution(action), {} | Dummy forward operation. Returns a dummy distribution. | __call__ | python | rlworkgroup/garage | tests/garage/torch/algos/test_sac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_sac.py | MIT |
def test_sac_inverted_double_pendulum():
"""Test Sac performance on inverted pendulum."""
# pylint: disable=unexpected-keyword-arg
env = normalize(GymEnv('InvertedDoublePendulum-v2',
max_episode_length=100))
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
trainer = Trainer(snapshot_config=snapshot_config)
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
sac = SAC(env_spec=env.spec,
policy=policy,
qf1=qf1,
qf2=qf2,
sampler=sampler,
gradient_steps_per_itr=100,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=64,
reward_scale=1.,
steps_per_epoch=2)
trainer.setup(sac, env)
if torch.cuda.is_available():
set_gpu_mode(True)
else:
set_gpu_mode(False)
sac.to()
ret = trainer.train(n_epochs=12, batch_size=200, plot=False)
# check that automatic entropy tuning is used
assert sac._use_automatic_entropy_tuning
# assert that there was a gradient properly connected to alpha
# this doesn't verify that the path from the temperature objective is
# correct.
assert not torch.allclose(torch.Tensor([1.]), sac._log_alpha.to('cpu'))
# check that policy is learning beyond predecided threshold
assert ret > 80 | Test Sac performance on inverted pendulum. | test_sac_inverted_double_pendulum | python | rlworkgroup/garage | tests/garage/torch/algos/test_sac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_sac.py | MIT |
def test_fixed_alpha():
"""Test if using fixed_alpha ensures that alpha is non differentiable."""
# pylint: disable=unexpected-keyword-arg
env = normalize(GymEnv('InvertedDoublePendulum-v2',
max_episode_length=100))
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
trainer = Trainer(snapshot_config=snapshot_config)
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
sac = SAC(env_spec=env.spec,
policy=policy,
qf1=qf1,
qf2=qf2,
sampler=sampler,
gradient_steps_per_itr=100,
replay_buffer=replay_buffer,
min_buffer_size=100,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=64,
reward_scale=1.,
steps_per_epoch=1,
fixed_alpha=np.exp(0.5))
trainer.setup(sac, env)
sac.to()
trainer.train(n_epochs=1, batch_size=100, plot=False)
assert torch.allclose(torch.Tensor([0.5]), sac._log_alpha.cpu())
assert not sac._use_automatic_entropy_tuning | Test if using fixed_alpha ensures that alpha is non differentiable. | test_fixed_alpha | python | rlworkgroup/garage | tests/garage/torch/algos/test_sac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_sac.py | MIT |
def test_sac_to():
"""Test moving Sac between CPU and GPU."""
env = normalize(GymEnv('InvertedDoublePendulum-v2',
max_episode_length=100))
deterministic.set_seed(0)
policy = TanhGaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=torch.nn.ReLU,
output_nonlinearity=None,
min_std=np.exp(-20.),
max_std=np.exp(2.),
)
qf1 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
qf2 = ContinuousMLPQFunction(env_spec=env.spec,
hidden_sizes=[32, 32],
hidden_nonlinearity=F.relu)
replay_buffer = PathBuffer(capacity_in_transitions=int(1e6), )
trainer = Trainer(snapshot_config=snapshot_config)
sampler = LocalSampler(agents=policy,
envs=env,
max_episode_length=env.spec.max_episode_length,
worker_class=FragmentWorker)
sac = SAC(env_spec=env.spec,
policy=policy,
qf1=qf1,
qf2=qf2,
sampler=sampler,
gradient_steps_per_itr=100,
replay_buffer=replay_buffer,
min_buffer_size=1e3,
target_update_tau=5e-3,
discount=0.99,
buffer_batch_size=64,
reward_scale=1.,
steps_per_epoch=2)
trainer.setup(sac, env)
if torch.cuda.is_available():
set_gpu_mode(True)
else:
set_gpu_mode(False)
sac.to()
trainer.setup(algo=sac, env=env)
trainer.train(n_epochs=1, batch_size=100)
log_alpha = torch.clone(sac._log_alpha).cpu()
set_gpu_mode(False)
sac.to()
assert torch.allclose(log_alpha, sac._log_alpha) | Test moving Sac between CPU and GPU. | test_sac_to | python | rlworkgroup/garage | tests/garage/torch/algos/test_sac.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_sac.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
self.env = normalize(
GymEnv('InvertedDoublePendulum-v2', max_episode_length=100))
self.policy = GaussianMLPPolicy(
env_spec=self.env.spec,
hidden_sizes=(64, 64),
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None,
)
self.value_function = GaussianMLPValueFunction(env_spec=self.env.spec) | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_trpo.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_trpo.py | MIT |
def setup_method(self):
"""Setup method which is called before every test."""
self._env = GymEnv('InvertedDoublePendulum-v2', max_episode_length=100)
self._trainer = Trainer(snapshot_config)
self._policy = GaussianMLPPolicy(env_spec=self._env.spec,
hidden_sizes=[64, 64],
hidden_nonlinearity=torch.tanh,
output_nonlinearity=None)
self._sampler = LocalSampler(
agents=self._policy,
envs=self._env,
max_episode_length=self._env.spec.max_episode_length)
self._params = {
'env_spec': self._env.spec,
'policy': self._policy,
'value_function':
GaussianMLPValueFunction(env_spec=self._env.spec),
'sampler': self._sampler,
'discount': 0.99,
} | Setup method which is called before every test. | setup_method | python | rlworkgroup/garage | tests/garage/torch/algos/test_vpg.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_vpg.py | MIT |
def test_invalid_entropy_config(self, algo_param, error, msg):
"""Test VPG with invalid entropy config."""
self._params.update(algo_param)
with pytest.raises(error, match=msg):
VPG(**self._params) | Test VPG with invalid entropy config. | test_invalid_entropy_config | python | rlworkgroup/garage | tests/garage/torch/algos/test_vpg.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/algos/test_vpg.py | MIT |
def test_tanh_normal_bounds(self):
"""Test to make sure the tanh_normal dist obeys the bounds (-1,1)."""
mean = torch.ones(1) * 100
std = torch.ones(1) * 100
dist = TanhNormal(mean, std)
assert dist.mean <= 1.
del dist
mean = torch.ones(1) * -100
std = torch.ones(1) * 100
dist = TanhNormal(mean, std)
assert dist.mean >= -1. | Test to make sure the tanh_normal dist obeys the bounds (-1,1). | test_tanh_normal_bounds | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_tanh_normal_rsample(self):
"""Test the bounds of the tanh_normal rsample function."""
mean = torch.zeros(1)
std = torch.ones(1)
dist = TanhNormal(mean, std)
sample = dist.rsample()
pre_tanh_action, action = dist.rsample_with_pre_tanh_value()
assert (pre_tanh_action.tanh() == action).all()
assert -1 <= action <= 1.
assert -1 <= sample <= 1.
del dist | Test the bounds of the tanh_normal rsample function. | test_tanh_normal_rsample | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_tanh_normal_log_prob(self):
"""Verify the correctnes of the tanh_normal log likelihood function."""
mean = torch.zeros(1)
std = torch.ones(1)
dist = TanhNormal(mean, std)
pre_tanh_action = torch.Tensor([[2.0960]])
action = pre_tanh_action.tanh()
log_prob = dist.log_prob(action, pre_tanh_action)
log_prob_approx = dist.log_prob(action)
assert torch.allclose(log_prob, torch.Tensor([-0.2798519]))
assert torch.allclose(log_prob_approx, torch.Tensor([-0.2798185]))
del dist | Verify the correctnes of the tanh_normal log likelihood function. | test_tanh_normal_log_prob | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_tanh_normal_expand(self):
"""Test for expand function.
Checks whether expand returns a distribution that has potentially a
different batch size from the already existing distribution.
"""
mean = torch.zeros(1)
std = torch.ones(1)
dist = TanhNormal(mean, std)
new_dist = dist.expand((2, ))
sample = new_dist.sample()
assert sample.shape == torch.Size((2, 1)) | Test for expand function.
Checks whether expand returns a distribution that has potentially a
different batch size from the already existing distribution.
| test_tanh_normal_expand | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_tanh_normal_repr(self):
"""Test that the repr function outputs the class name."""
mean = torch.zeros(1)
std = torch.ones(1)
dist = TanhNormal(mean, std)
assert repr(dist) == 'TanhNormal' | Test that the repr function outputs the class name. | test_tanh_normal_repr | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_tanh_normal_log_prob_of_clipped_action(self):
"""Verify that clipped actions still have a valid log probability."""
mean = torch.zeros(2)
std = torch.ones(2)
dist = TanhNormal(mean, std)
action = torch.Tensor([[1., -1.]])
log_prob_approx = dist.log_prob(action)
assert torch.isfinite(log_prob_approx)
assert log_prob_approx < -20
del dist | Verify that clipped actions still have a valid log probability. | test_tanh_normal_log_prob_of_clipped_action | python | rlworkgroup/garage | tests/garage/torch/distributions/test_tanh_normal_dist.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/distributions/test_tanh_normal_dist.py | MIT |
def test_output_values(self, kernel_sizes, hidden_channels, strides,
paddings):
"""Test output values from CNNBaseModule.
Args:
kernel_sizes (tuple[int]): Kernel sizes.
hidden_channels (tuple[int]): hidden channels.
strides (tuple[int]): strides.
paddings (tuple[int]): value of zero-padding.
"""
module_with_nonlinear_function_and_module = CNNModule(
self.input_spec,
image_format='NCHW',
hidden_channels=hidden_channels,
kernel_sizes=kernel_sizes,
strides=strides,
paddings=paddings,
padding_mode='zeros',
hidden_nonlinearity=torch.relu,
hidden_w_init=nn.init.xavier_uniform_)
module_with_nonlinear_module_instance_and_function = CNNModule(
self.input_spec,
image_format='NCHW',
hidden_channels=hidden_channels,
kernel_sizes=kernel_sizes,
strides=strides,
paddings=paddings,
padding_mode='zeros',
hidden_nonlinearity=nn.ReLU(),
hidden_w_init=nn.init.xavier_uniform_)
output1 = module_with_nonlinear_function_and_module(self.input)
output2 = module_with_nonlinear_module_instance_and_function(
self.input)
current_size = self.input_width
for (filter_size, stride, padding) in zip(kernel_sizes, strides,
paddings):
# padding = float((filter_size - 1) / 2) # P = (F - 1) /2
current_size = int(
(current_size - filter_size + padding * 2) /
stride) + 1 # conv formula = ((W - F + 2P) / S) + 1
flatten_shape = current_size * current_size * hidden_channels[-1]
expected_output = torch.zeros((self.batch_size, flatten_shape))
assert np.array_equal(torch.all(torch.eq(output1, expected_output)),
True)
assert np.array_equal(torch.all(torch.eq(output2, expected_output)),
True) | Test output values from CNNBaseModule.
Args:
kernel_sizes (tuple[int]): Kernel sizes.
hidden_channels (tuple[int]): hidden channels.
strides (tuple[int]): strides.
paddings (tuple[int]): value of zero-padding.
| test_output_values | python | rlworkgroup/garage | tests/garage/torch/modules/test_cnn_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_cnn_module.py | MIT |
def test_output_values_with_unequal_stride_with_padding(
self, hidden_channels, kernel_sizes, strides, paddings):
"""Test output values with unequal stride and padding from CNNModule.
Args:
kernel_sizes (tuple[int]): Kernel sizes.
hidden_channels (tuple[int]): hidden channels.
strides (tuple[int]): strides.
paddings (tuple[int]): value of zero-padding.
"""
model = CNNModule(self.input_spec,
image_format='NCHW',
hidden_channels=hidden_channels,
kernel_sizes=kernel_sizes,
strides=strides,
paddings=paddings,
padding_mode='zeros',
hidden_nonlinearity=torch.relu,
hidden_w_init=nn.init.xavier_uniform_)
output = model(self.input)
current_size = self.input_width
for (filter_size, stride, padding) in zip(kernel_sizes, strides,
paddings):
# padding = float((filter_size - 1) / 2) # P = (F - 1) /2
current_size = int(
(current_size - filter_size + padding * 2) /
stride) + 1 # conv formula = ((W - F + 2P) / S) + 1
flatten_shape = current_size * current_size * hidden_channels[-1]
expected_output = torch.zeros((self.batch_size, flatten_shape))
assert np.array_equal(torch.all(torch.eq(output, expected_output)),
True) | Test output values with unequal stride and padding from CNNModule.
Args:
kernel_sizes (tuple[int]): Kernel sizes.
hidden_channels (tuple[int]): hidden channels.
strides (tuple[int]): strides.
paddings (tuple[int]): value of zero-padding.
| test_output_values_with_unequal_stride_with_padding | python | rlworkgroup/garage | tests/garage/torch/modules/test_cnn_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_cnn_module.py | MIT |
def test_is_pickleable(self, hidden_channels, kernel_sizes, strides):
"""Check CNNModule is pickeable.
Args:
hidden_channels (tuple[int]): hidden channels.
kernel_sizes (tuple[int]): Kernel sizes.
strides (tuple[int]): strides.
"""
model = CNNModule(self.input_spec,
image_format='NCHW',
hidden_channels=hidden_channels,
kernel_sizes=kernel_sizes,
strides=strides)
output1 = model(self.input)
h = pickle.dumps(model)
model_pickled = pickle.loads(h)
output2 = model_pickled(self.input)
assert np.array_equal(torch.all(torch.eq(output1, output2)), True) | Check CNNModule is pickeable.
Args:
hidden_channels (tuple[int]): hidden channels.
kernel_sizes (tuple[int]): Kernel sizes.
strides (tuple[int]): strides.
| test_is_pickleable | python | rlworkgroup/garage | tests/garage/torch/modules/test_cnn_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_cnn_module.py | MIT |
def test_no_head_invalid_settings(self, hidden_nonlinear):
"""Check CNNModule throws exception with invalid non-linear functions.
Args:
hidden_nonlinear (callable or torch.nn.Module): Non-linear
functions for hidden layers.
"""
expected_msg = 'Non linear function .* is not supported'
with pytest.raises(ValueError, match=expected_msg):
CNNModule(self.input_spec,
image_format='NCHW',
hidden_channels=(32, ),
kernel_sizes=(3, ),
strides=(1, ),
hidden_nonlinearity=hidden_nonlinear) | Check CNNModule throws exception with invalid non-linear functions.
Args:
hidden_nonlinear (callable or torch.nn.Module): Non-linear
functions for hidden layers.
| test_no_head_invalid_settings | python | rlworkgroup/garage | tests/garage/torch/modules/test_cnn_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_cnn_module.py | MIT |
def test_output_values(self, input_dim, output_dim, hidden_sizes):
"""Test output values from MLPModule.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
"""
input_val = torch.ones([1, input_dim], dtype=torch.float32)
module_with_nonlinear_function_and_module = MLPModule(
input_dim=input_dim,
output_dim=output_dim,
hidden_nonlinearity=torch.relu,
hidden_sizes=hidden_sizes,
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_,
output_nonlinearity=torch.nn.ReLU)
module_with_nonlinear_module_instance_and_function = MLPModule(
input_dim=input_dim,
output_dim=output_dim,
hidden_nonlinearity=torch.nn.ReLU(),
hidden_sizes=hidden_sizes,
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_,
output_nonlinearity=torch.relu)
output1 = module_with_nonlinear_function_and_module(input_val)
output2 = module_with_nonlinear_module_instance_and_function(input_val)
expected_output = torch.full([1, output_dim],
fill_value=5 * np.prod(hidden_sizes),
dtype=torch.float32)
assert torch.all(torch.eq(expected_output, output1))
assert torch.all(torch.eq(expected_output, output2)) | Test output values from MLPModule.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
| test_output_values | python | rlworkgroup/garage | tests/garage/torch/modules/test_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_mlp_module.py | MIT |
def test_is_pickleable(self, input_dim, output_dim, hidden_sizes):
"""Check MLPModule is pickeable.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
"""
input_val = torch.ones([1, input_dim], dtype=torch.float32)
module = MLPModule(input_dim=input_dim,
output_dim=output_dim,
hidden_nonlinearity=torch.relu,
hidden_sizes=hidden_sizes,
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_,
output_nonlinearity=torch.nn.ReLU)
output1 = module(input_val)
h = pickle.dumps(module)
model_pickled = pickle.loads(h)
output2 = model_pickled(input_val)
assert np.array_equal(torch.all(torch.eq(output1, output2)), True) | Check MLPModule is pickeable.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
| test_is_pickleable | python | rlworkgroup/garage | tests/garage/torch/modules/test_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_mlp_module.py | MIT |
def test_no_head_invalid_settings(self, hidden_nonlinear,
output_nonlinear):
"""Check MLPModule throws exception with invalid non-linear functions.
Args:
hidden_nonlinear (callable or torch.nn.Module): Non-linear
functions for hidden layers.
output_nonlinear (callable or torch.nn.Module): Non-linear
functions for output layer.
"""
expected_msg = 'Non linear function .* is not supported'
with pytest.raises(ValueError, match=expected_msg):
MLPModule(input_dim=3,
output_dim=5,
hidden_sizes=(2, 3),
hidden_nonlinearity=hidden_nonlinear,
output_nonlinearity=output_nonlinear) | Check MLPModule throws exception with invalid non-linear functions.
Args:
hidden_nonlinear (callable or torch.nn.Module): Non-linear
functions for hidden layers.
output_nonlinear (callable or torch.nn.Module): Non-linear
functions for output layer.
| test_no_head_invalid_settings | python | rlworkgroup/garage | tests/garage/torch/modules/test_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_mlp_module.py | MIT |
def test_mlp_with_learnable_non_linear_function(self):
"""Test MLPModule with learnable non-linear functions."""
input_dim, output_dim, hidden_sizes = 1, 1, (3, 2)
input_val = -torch.ones([1, input_dim], dtype=torch.float32)
module = MLPModule(input_dim=input_dim,
output_dim=output_dim,
hidden_nonlinearity=torch.nn.PReLU(init=10.),
hidden_sizes=hidden_sizes,
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_,
output_nonlinearity=torch.nn.PReLU(init=1.))
output = module(input_val)
output.sum().backward()
for tt in module.parameters():
assert torch.all(torch.ne(tt.grad, 0)) | Test MLPModule with learnable non-linear functions. | test_mlp_with_learnable_non_linear_function | python | rlworkgroup/garage | tests/garage/torch/modules/test_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_mlp_module.py | MIT |
def test_multi_headed_mlp_module(input_dim, output_dim, hidden_sizes,
output_w_init_vals, n_heads):
"""Test Multi-headed MLPModule.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
output_w_init_vals (list[int]): Init values for output weights.
n_heads (int): Number of output layers.
"""
module = MultiHeadedMLPModule(n_heads=n_heads,
input_dim=input_dim,
output_dims=output_dim,
hidden_sizes=hidden_sizes,
hidden_nonlinearity=None,
hidden_w_init=nn.init.ones_,
output_nonlinearities=None,
output_w_inits=list(
map(_helper_make_inits,
output_w_init_vals)))
input_value = torch.ones(input_dim)
outputs = module(input_value)
if len(output_w_init_vals) == 1:
output_w_init_vals = list(output_w_init_vals) * n_heads
if len(output_dim) == 1:
output_dim = list(output_dim) * n_heads
for i, output in enumerate(outputs):
expected = input_dim * torch.Tensor(hidden_sizes).prod()
expected *= output_w_init_vals[i]
assert torch.equal(
output, torch.full((output_dim[i], ), expected, dtype=torch.float)) | Test Multi-headed MLPModule.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
output_w_init_vals (list[int]): Init values for output weights.
n_heads (int): Number of output layers.
| test_multi_headed_mlp_module | python | rlworkgroup/garage | tests/garage/torch/modules/test_multi_headed_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_multi_headed_mlp_module.py | MIT |
def test_multi_headed_mlp_module_with_layernorm(input_dim, output_dim,
hidden_sizes,
output_w_init_vals, n_heads):
"""Test Multi-headed MLPModule with layer normalization.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
output_w_init_vals (list[int]): Init values for output weights.
n_heads (int): Number of output layers.
"""
module = MultiHeadedMLPModule(n_heads=n_heads,
input_dim=input_dim,
output_dims=output_dim,
hidden_sizes=hidden_sizes,
hidden_nonlinearity=None,
layer_normalization=True,
hidden_w_init=nn.init.ones_,
output_nonlinearities=None,
output_w_inits=list(
map(_helper_make_inits,
output_w_init_vals)))
input_value = torch.ones(input_dim)
outputs = module(input_value)
if len(output_w_init_vals) == 1:
output_w_init_vals = list(output_w_init_vals) * n_heads
if len(output_dim) == 1:
output_dim = list(output_dim) * n_heads
for i, output in enumerate(outputs):
expected = input_dim * torch.Tensor(hidden_sizes).prod()
expected *= output_w_init_vals[i]
assert torch.equal(output, torch.zeros(output_dim[i])) | Test Multi-headed MLPModule with layer normalization.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
output_w_init_vals (list[int]): Init values for output weights.
n_heads (int): Number of output layers.
| test_multi_headed_mlp_module_with_layernorm | python | rlworkgroup/garage | tests/garage/torch/modules/test_multi_headed_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_multi_headed_mlp_module.py | MIT |
def test_invalid_settings(input_dim, output_dim, hidden_sizes, n_heads,
nonlinearity, w_init, b_init):
"""Test Multi-headed MLPModule with invalid parameters.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
n_heads (int): Number of output layers.
nonlinearity (callable or torch.nn.Module): Non-linear functions for
output layers
w_init (list[callable]): Initializer function for the weight in
output layer.
b_init (list[callable]): Initializer function for the bias in
output layer.
"""
expected_msg_template = ('should be either an integer or a collection of '
'length n_heads')
with pytest.raises(ValueError, match=expected_msg_template):
MultiHeadedMLPModule(n_heads=n_heads,
input_dim=input_dim,
output_dims=output_dim,
hidden_sizes=hidden_sizes,
hidden_nonlinearity=None,
hidden_w_init=nn.init.ones_,
output_nonlinearities=nonlinearity,
output_w_inits=list(
map(_helper_make_inits, w_init)),
output_b_inits=b_init) | Test Multi-headed MLPModule with invalid parameters.
Args:
input_dim (int): Input dimension.
output_dim (int): Ouput dimension.
hidden_sizes (list[int]): Size of hidden layers.
n_heads (int): Number of output layers.
nonlinearity (callable or torch.nn.Module): Non-linear functions for
output layers
w_init (list[callable]): Initializer function for the weight in
output layer.
b_init (list[callable]): Initializer function for the bias in
output layer.
| test_invalid_settings | python | rlworkgroup/garage | tests/garage/torch/modules/test_multi_headed_mlp_module.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/modules/test_multi_headed_mlp_module.py | MIT |
def test_differentiable_sgd():
"""Test second order derivative after taking optimization step."""
policy = torch.nn.Linear(10, 10, bias=False)
lr = 0.01
diff_sgd = DifferentiableSGD(policy, lr=lr)
named_theta = dict(policy.named_parameters())
theta = list(named_theta.values())[0]
meta_loss = torch.sum(theta**2)
meta_loss.backward(create_graph=True)
diff_sgd.step()
theta_prime = list(policy.parameters())[0]
loss = torch.sum(theta_prime**2)
update_module_params(policy, named_theta)
diff_sgd.zero_grad()
loss.backward()
result = theta.grad
dtheta_prime = 1 - 2 * lr # dtheta_prime/dtheta
dloss = 2 * theta_prime # dloss/dtheta_prime
expected_result = dloss * dtheta_prime # dloss/dtheta
assert torch.allclose(result, expected_result) | Test second order derivative after taking optimization step. | test_differentiable_sgd | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_differentiable_sgd.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_differentiable_sgd.py | MIT |
def test_line_search_should_stop(self):
"""Test if line search stops when loss is decreasing, and constraint is satisfied.""" # noqa: E501
p1 = torch.tensor([0.1])
p2 = torch.tensor([0.1])
params = [p1, p2]
optimizer = ConjugateGradientOptimizer(params, 0.01)
expected_num_steps = 1
loss_calls = 0
first_time = True
def f_loss():
nonlocal loss_calls, first_time
if first_time:
first_time = False
else:
loss_calls += 1
return -torch.tensor(loss_calls)
kl_calls = 0
def f_constrint():
nonlocal kl_calls
kl_calls += 1
return -torch.tensor(kl_calls)
descent_step = torch.tensor([0.05, 0.05])
optimizer._backtracking_line_search(params, descent_step, f_loss,
f_constrint)
assert loss_calls == expected_num_steps
assert kl_calls == expected_num_steps | Test if line search stops when loss is decreasing, and constraint is satisfied. | test_line_search_should_stop | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_line_search_step_size_should_decrease(self):
"""Line search step size should always decrease."""
p1 = torch.tensor([0.1])
p2 = torch.tensor([0.1])
params = [p1, p2]
optimizer = ConjugateGradientOptimizer(params, 0.01)
p1_history = []
p2_history = []
loss = 0
first_time = True
def f_loss():
nonlocal loss, first_time
if first_time:
first_time = False
else:
p1_history.append(p1.clone())
p2_history.append(p2.clone())
loss += 1
return torch.tensor(loss)
def f_constrint():
return torch.tensor(0)
descent_step = torch.tensor([0.05, 0.05])
optimizer._backtracking_line_search(params, descent_step, f_loss,
f_constrint)
p1_steps = []
p2_steps = []
for i in range(len(p1_history) - 1):
p1_steps.append(p1_history[i + 1] - p1_history[i])
p2_steps.append(p2_history[i + 1] - p2_history[i])
for i in range(len(p1_steps) - 1):
assert p1_steps[i] > p1_steps[i + 1]
assert p2_steps[i] > p2_steps[i + 1] | Line search step size should always decrease. | test_line_search_step_size_should_decrease | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_cg():
"""Solve Ax = b using Conjugate gradient method."""
a = np.linspace(-np.pi, np.pi, 25).reshape((5, 5))
a = a.T.dot(a) # make sure a is positive semi-definite
def hvp(v):
return torch.tensor(a.dot(v))
b = torch.tensor(np.linspace(-np.pi, np.pi, 5))
x = _conjugate_gradient(hvp, b, 5)
assert np.allclose(a.dot(x), b) | Solve Ax = b using Conjugate gradient method. | test_cg | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_hessian_vector_product():
"""Test Hessian-vector product for a function with one variable."""
a = torch.tensor([5.0])
x = torch.tensor([10.0], requires_grad=True)
def f():
return a * (x**2)
expected_hessian = 2 * a
vector = torch.tensor([10.0])
expected_hvp = (expected_hessian * vector).detach()
f_Ax = _build_hessian_vector_product(f, [x])
computed_hvp = f_Ax(vector).detach()
assert np.allclose(computed_hvp, expected_hvp) | Test Hessian-vector product for a function with one variable. | test_hessian_vector_product | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_hessian_vector_product_2x2(a_val, b_val, x_val, y_val, vector):
"""Test for a function with two variables."""
obs = [torch.tensor([a_val]), torch.tensor([b_val])]
vector = torch.tensor([vector])
x = torch.tensor(x_val, requires_grad=True)
y = torch.tensor(y_val, requires_grad=True)
def f():
a, b = obs[0], obs[1]
return a * (x**2) + b * (y**2)
expected_hessian = compute_hessian(f(), [x, y])
expected_hvp = torch.mm(vector, expected_hessian).detach()
f_Ax = _build_hessian_vector_product(f, [x, y])
hvp = f_Ax(vector[0]).detach()
assert np.allclose(hvp, expected_hvp, atol=1e-6) | Test for a function with two variables. | test_hessian_vector_product_2x2 | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_hessian_vector_product_2x2_non_diagonal(a_val, b_val, x_val, y_val,
vector):
"""Test for a function with two variables and non-diagonal Hessian."""
obs = [torch.tensor([a_val]), torch.tensor([b_val])]
vector = torch.tensor([vector])
x = torch.tensor([x_val], requires_grad=True)
y = torch.tensor([y_val], requires_grad=True)
def f():
a, b = obs[0], obs[1]
kl = a * (x**3) + b * (y**3) + (x**2) * y + (y**2) * x
return kl
expected_hessian = compute_hessian(f(), [x, y])
expected_hvp = torch.mm(vector, expected_hessian).detach()
f_Ax = _build_hessian_vector_product(f, [x, y])
hvp = f_Ax(vector[0]).detach()
assert np.allclose(hvp, expected_hvp) | Test for a function with two variables and non-diagonal Hessian. | test_hessian_vector_product_2x2_non_diagonal | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def compute_hessian(f, params):
"""Compute hessian matrix of given function."""
h = []
for i in params:
h_i = []
for j in params:
grad = torch.autograd.grad(f, j, create_graph=True)
h_ij = torch.autograd.grad(grad,
i,
allow_unused=True,
retain_graph=True)
h_ij = (torch.tensor(0.), ) if h_ij[0] is None else h_ij
h_i.append(h_ij[0])
h_i = torch.stack(h_i)
h.append(h_i)
h = torch.stack(h)
h = h.reshape((len(params), len(params)))
return h | Compute hessian matrix of given function. | compute_hessian | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_pickle_round_trip():
"""Test that pickling works as one would normally expect."""
# pylint: disable=protected-access
p1 = torch.tensor([0.1])
p2 = torch.tensor([0.1])
params = [p1, p2]
optimizer = ConjugateGradientOptimizer(params, 0.01)
optimizer_pickled = pickle.dumps(optimizer)
optimizer2 = pickle.loads(optimizer_pickled)
assert optimizer._max_constraint_value == optimizer2._max_constraint_value
assert optimizer._cg_iters == optimizer2._cg_iters
assert optimizer._max_backtracks == optimizer2._max_backtracks
assert optimizer._backtrack_ratio == optimizer2._backtrack_ratio
assert optimizer._hvp_reg_coeff == optimizer2._hvp_reg_coeff
assert optimizer._accept_violation == optimizer2._accept_violation | Test that pickling works as one would normally expect. | test_pickle_round_trip | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_unpickle_empty_state():
"""Test that pickling works as one would normally expect."""
# pylint: disable=protected-access
p1 = torch.tensor([0.1])
p2 = torch.tensor([0.1])
params = [p1, p2]
optimizer = BrokenPicklingConjugateGradientOptimizer(params, 0.02)
optimizer_pickled = pickle.dumps(optimizer)
optimizer2 = pickle.loads(optimizer_pickled)
assert optimizer2._max_constraint_value == 0.01
# These asserts only pass because they contain the default values.
assert optimizer._cg_iters == optimizer2._cg_iters
assert optimizer._max_backtracks == optimizer2._max_backtracks
assert optimizer._backtrack_ratio == optimizer2._backtrack_ratio
assert optimizer._hvp_reg_coeff == optimizer2._hvp_reg_coeff
assert optimizer._accept_violation == optimizer2._accept_violation | Test that pickling works as one would normally expect. | test_unpickle_empty_state | python | rlworkgroup/garage | tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/optimizers/test_torch_conjugate_gradient_optimizer.py | MIT |
def test_get_action_img_obs(self, hidden_channels, kernel_sizes, strides,
hidden_sizes):
"""Test get_action function with akro.Image observation space."""
env = GymEnv(DummyDiscretePixelEnv(), is_image=True)
policy = CategoricalCNNPolicy(env_spec=env.spec,
image_format='NHWC',
kernel_sizes=kernel_sizes,
hidden_channels=hidden_channels,
strides=strides,
hidden_sizes=hidden_sizes)
env.reset()
obs = env.step(1).observation
action, _ = policy.get_action(obs)
assert env.action_space.contains(action) | Test get_action function with akro.Image observation space. | test_get_action_img_obs | python | rlworkgroup/garage | tests/garage/torch/policies/test_categorical_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_categorical_cnn_policy.py | MIT |
def test_get_actions(self, hidden_channels, kernel_sizes, strides,
hidden_sizes):
"""Test get_actions function with akro.Image observation space."""
env = GymEnv(DummyDiscretePixelEnv(), is_image=True)
policy = CategoricalCNNPolicy(env_spec=env.spec,
image_format='NHWC',
kernel_sizes=kernel_sizes,
hidden_channels=hidden_channels,
strides=strides,
hidden_sizes=hidden_sizes)
env.reset()
obs = env.step(1).observation
actions, _ = policy.get_actions([obs, obs, obs])
for action in actions:
assert env.action_space.contains(action)
torch_obs = torch.Tensor(obs)
actions, _ = policy.get_actions([torch_obs, torch_obs, torch_obs])
for action in actions:
assert env.action_space.contains(action) | Test get_actions function with akro.Image observation space. | test_get_actions | python | rlworkgroup/garage | tests/garage/torch/policies/test_categorical_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_categorical_cnn_policy.py | MIT |
def test_does_not_support_dict_obs_space(self):
"""Test that policy raises error if passed a dict obs space."""
env = GymEnv(DummyDictEnv(act_space_type='discrete'))
with pytest.raises(ValueError,
match=('CNN policies do not support '
'with akro.Dict observation spaces.')):
CategoricalCNNPolicy(env_spec=env.spec,
image_format='NHWC',
kernel_sizes=(3, ),
hidden_channels=(3, )) | Test that policy raises error if passed a dict obs space. | test_does_not_support_dict_obs_space | python | rlworkgroup/garage | tests/garage/torch/policies/test_categorical_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_categorical_cnn_policy.py | MIT |
def test_invalid_action_spaces(self):
"""Test that policy raises error if passed a box obs space."""
env = GymEnv(DummyDictEnv(act_space_type='box'))
with pytest.raises(ValueError):
CategoricalCNNPolicy(env_spec=env.spec,
image_format='NHWC',
kernel_sizes=(3, ),
hidden_channels=(3, )) | Test that policy raises error if passed a box obs space. | test_invalid_action_spaces | python | rlworkgroup/garage | tests/garage/torch/policies/test_categorical_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_categorical_cnn_policy.py | MIT |
def test_obs_unflattened(self, hidden_channels, kernel_sizes, strides,
hidden_sizes):
"""Test if a flattened image obs is passed to get_action
then it is unflattened.
"""
env = GymEnv(DummyDiscretePixelEnv(), is_image=True)
env.reset()
policy = CategoricalCNNPolicy(env_spec=env.spec,
image_format='NHWC',
kernel_sizes=kernel_sizes,
hidden_channels=hidden_channels,
strides=strides,
hidden_sizes=hidden_sizes)
obs = env.observation_space.sample()
action, _ = policy.get_action(env.observation_space.flatten(obs))
env.step(action) | Test if a flattened image obs is passed to get_action
then it is unflattened.
| test_obs_unflattened | python | rlworkgroup/garage | tests/garage/torch/policies/test_categorical_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_categorical_cnn_policy.py | MIT |
def test_get_action_dict_space(self):
"""Test if observations from dict obs spaces are properly flattened."""
env = GymEnv(DummyDictEnv(obs_space_type='box', act_space_type='box'))
policy = DeterministicMLPPolicy(env_spec=env.spec,
hidden_nonlinearity=None,
hidden_sizes=(1, ),
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
obs = env.reset()[0]
action, _ = policy.get_action(obs)
assert env.action_space.shape == action.shape
actions, _ = policy.get_actions(np.array([obs, obs]))
for action in actions:
assert env.action_space.shape == action.shape | Test if observations from dict obs spaces are properly flattened. | test_get_action_dict_space | python | rlworkgroup/garage | tests/garage/torch/policies/test_deterministic_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_deterministic_mlp_policy.py | MIT |
def test_obs_unflattened(self, kernel_sizes, hidden_channels, strides,
paddings):
"""Test if a flattened image obs is passed to get_action
then it is unflattened.
"""
env = GymEnv(DummyDiscretePixelEnv())
env.reset()
policy = DiscreteCNNPolicy(env_spec=env.spec,
image_format='NHWC',
hidden_channels=hidden_channels,
kernel_sizes=kernel_sizes,
strides=strides,
paddings=paddings,
padding_mode='zeros',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
obs = env.observation_space.sample()
action, _ = policy.get_action(env.observation_space.flatten(obs))
env.step(action[0]) | Test if a flattened image obs is passed to get_action
then it is unflattened.
| test_obs_unflattened | python | rlworkgroup/garage | tests/garage/torch/policies/test_discrete_cnn_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_discrete_cnn_policy.py | MIT |
def test_get_action_dict_space(self):
"""Test if observations from dict obs spaces are properly flattened."""
env = GymEnv(DummyDictEnv(obs_space_type='box', act_space_type='box'))
policy = GaussianMLPPolicy(env_spec=env.spec,
hidden_nonlinearity=None,
hidden_sizes=(1, ),
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
obs = env.reset()[0]
action, _ = policy.get_action(obs)
assert env.action_space.shape == action.shape
actions, _ = policy.get_actions(np.array([obs, obs]))
for action in actions:
assert env.action_space.shape == action.shape
actions, _ = policy.get_actions(np.array([obs, obs]))
for action in actions:
assert env.action_space.shape == action.shape | Test if observations from dict obs spaces are properly flattened. | test_get_action_dict_space | python | rlworkgroup/garage | tests/garage/torch/policies/test_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_gaussian_mlp_policy.py | MIT |
def test_get_action(self, hidden_sizes):
"""Test Tanh Gaussian Policy get action function."""
env_spec = GymEnv(DummyBoxEnv())
obs_dim = env_spec.observation_space.flat_dim
act_dim = env_spec.action_space.flat_dim
obs = torch.ones(obs_dim, dtype=torch.float32).unsqueeze(0)
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=hidden_sizes,
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
expected_mean = torch.full((act_dim, ), 1.0, dtype=torch.float)
action, prob = policy.get_action(obs)
assert np.allclose(prob['mean'], expected_mean.numpy(), rtol=1e-3)
assert action.shape == (act_dim, ) | Test Tanh Gaussian Policy get action function. | test_get_action | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_get_action_np(self, hidden_sizes):
"""Test Policy get action function with numpy inputs."""
env_spec = GymEnv(DummyBoxEnv())
obs_dim = env_spec.observation_space.flat_dim
act_dim = env_spec.action_space.flat_dim
obs = np.ones((obs_dim, ), dtype=np.float32)
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=hidden_sizes,
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
expected_mean = torch.full((act_dim, ), 1.0, dtype=torch.float)
action, prob = policy.get_action(obs)
assert np.allclose(prob['mean'], expected_mean.numpy(), rtol=1e-3)
assert action.shape == (act_dim, ) | Test Policy get action function with numpy inputs. | test_get_action_np | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_get_actions(self, batch_size, hidden_sizes):
"""Test Tanh Gaussian Policy get actions function."""
env_spec = GymEnv(DummyBoxEnv())
obs_dim = env_spec.observation_space.flat_dim
act_dim = env_spec.action_space.flat_dim
obs = torch.ones([batch_size, obs_dim], dtype=torch.float32)
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=hidden_sizes,
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
expected_mean = torch.full([batch_size, act_dim],
1.0,
dtype=torch.float)
action, prob = policy.get_actions(obs)
assert np.allclose(prob['mean'], expected_mean.numpy(), rtol=1e-3)
assert action.shape == (batch_size, act_dim) | Test Tanh Gaussian Policy get actions function. | test_get_actions | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_get_actions_np(self, batch_size, hidden_sizes):
"""Test get actions with np.ndarray inputs."""
env_spec = GymEnv(DummyBoxEnv())
obs_dim = env_spec.observation_space.flat_dim
act_dim = env_spec.action_space.flat_dim
obs = np.ones((batch_size, obs_dim), dtype=np.float32)
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=hidden_sizes,
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
expected_mean = torch.full([batch_size, act_dim],
1.0,
dtype=torch.float)
action, prob = policy.get_actions(obs)
assert np.allclose(prob['mean'], expected_mean.numpy(), rtol=1e-3)
assert action.shape == (batch_size, act_dim) | Test get actions with np.ndarray inputs. | test_get_actions_np | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_is_pickleable(self, batch_size, hidden_sizes):
"""Test if policy is unchanged after pickling."""
env_spec = GymEnv(DummyBoxEnv())
obs_dim = env_spec.observation_space.flat_dim
obs = torch.ones([batch_size, obs_dim], dtype=torch.float32)
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=hidden_sizes,
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
output1_action, output1_prob = policy.get_actions(obs)
p = pickle.dumps(policy)
policy_pickled = pickle.loads(p)
output2_action, output2_prob = policy_pickled.get_actions(obs)
assert np.allclose(output2_prob['mean'],
output1_prob['mean'],
rtol=1e-3)
assert output1_action.shape == output2_action.shape | Test if policy is unchanged after pickling. | test_is_pickleable | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_to(self):
"""Test Tanh Gaussian Policy can be moved to cpu."""
env_spec = GymEnv(DummyBoxEnv())
init_std = 2.
policy = TanhGaussianMLPPolicy(env_spec=env_spec,
hidden_sizes=(1, ),
init_std=init_std,
hidden_nonlinearity=None,
std_parameterization='exp',
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
if torch.cuda.is_available():
policy.to(torch.device('cuda:0'))
assert str(next(policy.parameters()).device) == 'cuda:0'
else:
policy.to(None)
assert str(next(policy.parameters()).device) == 'cpu' | Test Tanh Gaussian Policy can be moved to cpu. | test_to | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def test_get_action_dict_space(self):
"""Test if observations from dict obs spaces are properly flattened."""
env = GymEnv(DummyDictEnv(obs_space_type='box', act_space_type='box'))
policy = TanhGaussianMLPPolicy(env_spec=env.spec,
hidden_nonlinearity=None,
hidden_sizes=(1, ),
hidden_w_init=nn.init.ones_,
output_w_init=nn.init.ones_)
obs = env.reset()[0]
action, _ = policy.get_action(obs)
assert env.action_space.shape == action.shape
actions, _ = policy.get_actions(np.array([obs, obs]))
for action in actions:
assert env.action_space.shape == action.shape | Test if observations from dict obs spaces are properly flattened. | test_get_action_dict_space | python | rlworkgroup/garage | tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | https://github.com/rlworkgroup/garage/blob/master/tests/garage/torch/policies/test_tanh_gaussian_mlp_policy.py | MIT |
def enumerate_algo_examples():
"""Return a list of paths for all algo examples.
Returns:
List[str]: list of path strings
"""
exclude = NON_ALGO_EXAMPLES + LONG_RUNNING_EXAMPLES
all_examples = EXAMPLES_ROOT_DIR.glob('**/*.py')
return [str(e) for e in all_examples if e not in exclude] | Return a list of paths for all algo examples.
Returns:
List[str]: list of path strings
| enumerate_algo_examples | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def test_algo_examples(filepath):
"""Test algo examples.
Args:
filepath (str): path string of example
"""
env = os.environ.copy()
env['GARAGE_EXAMPLE_TEST_N_EPOCHS'] = '1'
# Don't use check=True, since that causes subprocess to throw an error
# in case of failure before the assertion is evaluated
assert subprocess.run([filepath], check=False, env=env).returncode == 0 | Test algo examples.
Args:
filepath (str): path string of example
| test_algo_examples | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def test_dqn_pong():
"""Test tf/dqn_pong.py with reduced replay buffer size.
This is to reduced memory consumption.
"""
env = os.environ.copy()
env['GARAGE_EXAMPLE_TEST_N_EPOCHS'] = '1'
assert subprocess.run([
EXAMPLES_ROOT_DIR / 'tf/dqn_pong.py', '--buffer_size', '5',
'--max_episode_length', '5'
],
check=False,
env=env).returncode == 0 | Test tf/dqn_pong.py with reduced replay buffer size.
This is to reduced memory consumption.
| test_dqn_pong | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def test_dqn_atari():
"""Test torch/dqn_atari.py with reduced replay buffer size.
This is to reduced memory consumption.
"""
env = os.environ.copy()
env['GARAGE_EXAMPLE_TEST_N_EPOCHS'] = '1'
assert subprocess.run([
EXAMPLES_ROOT_DIR / 'torch/dqn_atari.py', 'Pong', '--buffer_size', '1',
'--max_episode_length', '1'
],
check=False,
env=env).returncode == 0 | Test torch/dqn_atari.py with reduced replay buffer size.
This is to reduced memory consumption.
| test_dqn_atari | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def test_ppo_memorize_digits():
"""Test tf/ppo_memorize_digits.py with reduced batch size.
This is to reduced memory consumption.
"""
env = os.environ.copy()
env['GARAGE_EXAMPLE_TEST_N_EPOCHS'] = '1'
command = [
EXAMPLES_ROOT_DIR / 'tf/ppo_memorize_digits.py', '--batch_size', '4',
'--max_episode_length', '5'
]
assert subprocess.run(command, check=False, env=env).returncode == 0 | Test tf/ppo_memorize_digits.py with reduced batch size.
This is to reduced memory consumption.
| test_ppo_memorize_digits | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def test_trpo_cubecrash():
"""Test tf/trpo_cubecrash.py with reduced batch size.
This is to reduced memory consumption.
"""
env = os.environ.copy()
env['GARAGE_EXAMPLE_TEST_N_EPOCHS'] = '1'
assert subprocess.run([
EXAMPLES_ROOT_DIR / 'tf/trpo_cubecrash.py', '--batch_size', '4',
'--max_episode_length', '5'
],
check=False,
env=env).returncode == 0 | Test tf/trpo_cubecrash.py with reduced batch size.
This is to reduced memory consumption.
| test_trpo_cubecrash | python | rlworkgroup/garage | tests/integration_tests/test_examples.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_examples.py | MIT |
def interrupt_experiment(experiment_script, lifecycle_stage):
"""Interrupt the experiment and verify no children processes remain."""
args = ['python', experiment_script]
# The pre-executed function setpgrp allows to create a process group
# so signals are propagated to all the process in the group.
proc = subprocess.Popen(args, preexec_fn=os.setpgrp)
launcher_proc = psutil.Process(proc.pid)
# This socket connects with the client in the algorithm, so we're
# notified of the different stages in the experiment lifecycle.
address = ('localhost', 6000)
listener = Listener(address)
conn = listener.accept()
while True:
msg = conn.recv()
if msg == lifecycle_stage:
# Notice that we're asking for the children of the launcher, not
# the children of this test script, since there could be other
# children processes attached to the process running this test
# that are not part of the launcher.
children = launcher_proc.children(recursive=True)
# Remove the semaphore tracker from the list of children, since
# we cannot stop its execution.
for child in children:
if any([
'multiprocessing.semaphore_tracker' in cmd
for cmd in child.cmdline()
]):
children.remove(child)
# We append the launcher to the list of children so later we can
# check it has died.
children.append(launcher_proc)
pgrp = os.getpgid(proc.pid)
os.killpg(pgrp, signal.SIGINT)
conn.close()
break
listener.close()
# Once the signal has been sent, all children should die
_, alive = psutil.wait_procs(children, timeout=6)
# If any, notify the zombie and sleeping processes and fail the test
clean_exit = True
error_msg = ''
for child in alive:
error_msg += (
str(child.as_dict(attrs=['pid', 'name', 'status', 'cmdline'])) +
'\n')
clean_exit = False
error_msg = ("These processes didn't die during %s:\n" %
(lifecycle_stage) + error_msg)
for child in alive:
os.kill(child.pid, signal.SIGINT)
assert clean_exit, error_msg | Interrupt the experiment and verify no children processes remain. | interrupt_experiment | python | rlworkgroup/garage | tests/integration_tests/test_sigint.py | https://github.com/rlworkgroup/garage/blob/master/tests/integration_tests/test_sigint.py | MIT |
def writeFrame(self, data):
"""Write the received frame to a temp image file. Return the image file."""
cachename = CACHE_FILE_NAME + str(self.sessionId) + CACHE_FILE_EXT
file = open(cachename, "wb")
file.write(data)
file.close()
return cachename | Write the received frame to a temp image file. Return the image file. | writeFrame | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def updateMovie(self, imageFile):
"""Update the image file as video frame in the GUI."""
photo = ImageTk.PhotoImage(Image.open(imageFile))
self.label.configure(image = photo, height=288)
self.label.image = photo | Update the image file as video frame in the GUI. | updateMovie | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def connectToServer(self):
"""Connect to the Server. Start a new RTSP/TCP session."""
self.rtspSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.rtspSocket.connect((self.serverAddr, self.serverPort))
except:
tkMessageBox.showwarning('Connection Failed', 'Connection to \'%s\' failed.' %self.serverAddr) | Connect to the Server. Start a new RTSP/TCP session. | connectToServer | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def sendRtspRequest(self, requestCode):
"""Send RTSP request to the server."""
# Setup request
if requestCode == self.SETUP and self.state == self.INIT:
threading.Thread(target=self.recvRtspReply).start()
# Update RTSP sequence number.
self.rtspSeq += 1
# Write the RTSP request to be sent.
request = 'SETUP ' + self.fileName + ' RTSP/1.0\nCSeq: ' + str(self.rtspSeq) + '\nTransport: RTP/UDP; client_port= ' + str(self.rtpPort)
# Keep track of the sent request.
self.requestSent = self.SETUP
# Play request
elif requestCode == self.PLAY and self.state == self.READY:
self.rtspSeq += 1
request = 'PLAY ' + self.fileName + ' RTSP/1.0\nCSeq: ' + str(self.rtspSeq) + '\nSession: ' + str(self.sessionId)
self.requestSent = self.PLAY
# Pause request
elif requestCode == self.PAUSE and self.state == self.PLAYING:
self.rtspSeq += 1
request = 'PAUSE ' + self.fileName + ' RTSP/1.0\nCSeq: ' + str(self.rtspSeq) + '\nSession: ' + str(self.sessionId)
self.requestSent = self.PAUSE
# Teardown request
elif requestCode == self.TEARDOWN and not self.state == self.INIT:
self.rtspSeq += 1
request = 'TEARDOWN ' + self.fileName + ' RTSP/1.0\nCSeq: ' + str(self.rtspSeq) + '\nSession: ' + str(self.sessionId)
self.requestSent = self.TEARDOWN
else:
return
# Send the RTSP request using rtspSocket.
self.rtspSocket.send(request.encode())
print('\nData sent:\n' + request) | Send RTSP request to the server. | sendRtspRequest | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def recvRtspReply(self):
"""Receive RTSP reply from the server."""
while True:
reply = self.rtspSocket.recv(1024)
if reply:
self.parseRtspReply(reply.decode("utf-8"))
# Close the RTSP socket upon requesting Teardown
if self.requestSent == self.TEARDOWN:
self.rtspSocket.shutdown(socket.SHUT_RDWR)
self.rtspSocket.close()
break | Receive RTSP reply from the server. | recvRtspReply | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def parseRtspReply(self, data):
"""Parse the RTSP reply from the server."""
lines = str(data).split('\n')
seqNum = int(lines[1].split(' ')[1])
# Process only if the server reply's sequence number is the same as the request's
if seqNum == self.rtspSeq:
session = int(lines[2].split(' ')[1])
# New RTSP session ID
if self.sessionId == 0:
self.sessionId = session
# Process only if the session ID is the same
if self.sessionId == session:
if int(lines[0].split(' ')[1]) == 200:
if self.requestSent == self.SETUP:
# Update RTSP state.
self.state = self.READY
# Open RTP port.
self.openRtpPort()
elif self.requestSent == self.PLAY:
self.state = self.PLAYING
elif self.requestSent == self.PAUSE:
self.state = self.READY
# The play thread exits. A new thread is created on resume.
self.playEvent.set()
elif self.requestSent == self.TEARDOWN:
self.state = self.INIT
# Flag the teardownAcked to close the socket.
self.teardownAcked = 1 | Parse the RTSP reply from the server. | parseRtspReply | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def openRtpPort(self):
"""Open RTP socket binded to a specified port."""
# Create a new datagram socket to receive RTP packets from the server
self.rtpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Set the timeout value of the socket to 0.5sec
self.rtpSocket.settimeout(0.5)
try:
# Bind the socket to the address using the RTP port given by the client user
self.rtpSocket.bind(("", self.rtpPort))
except:
tkMessageBox.showwarning('Unable to Bind', 'Unable to bind PORT=%d' %self.rtpPort) | Open RTP socket binded to a specified port. | openRtpPort | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def handler(self):
"""Handler on explicitly closing the GUI window."""
self.pauseMovie()
if tkMessageBox.askokcancel("Quit?", "Are you sure you want to quit?"):
self.exitClient()
else: # When the user presses cancel, resume playing.
self.playMovie() | Handler on explicitly closing the GUI window. | handler | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/Client.py | MIT |
def encode(self, version, padding, extension, cc, seqnum, marker, pt, ssrc, payload):
"""Encode the RTP packet with header fields and payload."""
timestamp = int(time())
header = bytearray(HEADER_SIZE)
# Fill the header bytearray with RTP header fields
header[0] = (version << 6) | (padding << 5) | (extension << 4) | cc
header[1] = (marker << 7) | pt
header[2] = (seqnum >> 8) & 255 #upper bits
header[3] = seqnum & 255
header[4] = timestamp >> 24 & 255
header[5] = timestamp >> 16 & 255
header[6] = timestamp >> 8 & 255
header[7] = timestamp & 255
header[8] = ssrc >> 24 & 255
header[9] = ssrc >> 16 & 255
header[10] = ssrc >> 8 & 255
header[11] = ssrc & 255
self.header = header
# Get the payload from the argument
self.payload = payload | Encode the RTP packet with header fields and payload. | encode | python | moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES | Resource/7th-Python-Solution/Solutions/StreamingVideo/RtpPacket.py | https://github.com/moranzcw/Computer-Networking-A-Top-Down-Approach-NOTES/blob/master/Resource/7th-Python-Solution/Solutions/StreamingVideo/RtpPacket.py | MIT |
def __init__(self, tileSize=256):
'''Initialize the TMS Global Mercator pyramid'''
self.tileSize = tileSize
self.initialResolution = 2 * math.pi * 6378137 / self.tileSize
# 156543.03392804062 for tileSize 256 pixels
self.originShift = 2 * math.pi * 6378137 / 2.0
# 20037508.342789244 | Initialize the TMS Global Mercator pyramid | __init__ | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def LatLonToMeters(self, lat, lon):
'''Converts given lat/lon in WGS84 Datum to XY in Spherical Mercator EPSG:900913'''
mx = lon * self.originShift / 180.0
my = math.log(math.tan((90 + lat) * math.pi / 360.0)) \
/ (math.pi / 180.0)
my = my * self.originShift / 180.0
return (mx, my) | Converts given lat/lon in WGS84 Datum to XY in Spherical Mercator EPSG:900913 | LatLonToMeters | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def MetersToLatLon(self, mx, my):
'''Converts XY point from Spherical Mercator EPSG:900913 to lat/lon in WGS84 Datum'''
lon = mx / self.originShift * 180.0
lat = my / self.originShift * 180.0
lat = 180 / math.pi * (2 * math.atan(math.exp(lat * math.pi
/ 180.0)) - math.pi / 2.0)
return (lat, lon) | Converts XY point from Spherical Mercator EPSG:900913 to lat/lon in WGS84 Datum | MetersToLatLon | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def PixelsToMeters(
self,
px,
py,
zoom,
):
'''Converts pixel coordinates in given zoom level of pyramid to EPSG:900913'''
res = self.Resolution(zoom)
mx = px * res - self.originShift
my = py * res - self.originShift
return (mx, my) | Converts pixel coordinates in given zoom level of pyramid to EPSG:900913 | PixelsToMeters | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def MetersToPixels(
self,
mx,
my,
zoom,
):
'''Converts EPSG:900913 to pyramid pixel coordinates in given zoom level'''
res = self.Resolution(zoom)
px = (mx + self.originShift) / res
py = (my + self.originShift) / res
return (px, py) | Converts EPSG:900913 to pyramid pixel coordinates in given zoom level | MetersToPixels | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def PixelsToTile(self, px, py):
'''Returns a tile covering region in given pixel coordinates'''
tx = int(math.ceil(px / float(self.tileSize)) - 1)
ty = int(math.ceil(py / float(self.tileSize)) - 1)
return (tx, ty) | Returns a tile covering region in given pixel coordinates | PixelsToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def PixelsToRaster(
self,
px,
py,
zoom,
):
'''Move the origin of pixel coordinates to top-left corner'''
mapSize = self.tileSize << zoom
return (px, mapSize - py) | Move the origin of pixel coordinates to top-left corner | PixelsToRaster | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def MetersToTile(
self,
mx,
my,
zoom,
):
'''Returns tile for given mercator coordinates'''
(px, py) = self.MetersToPixels(mx, my, zoom)
return self.PixelsToTile(px, py) | Returns tile for given mercator coordinates | MetersToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def TileBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in EPSG:900913 coordinates'''
(minx, miny) = self.PixelsToMeters(tx * self.tileSize, ty
* self.tileSize, zoom)
(maxx, maxy) = self.PixelsToMeters((tx + 1) * self.tileSize,
(ty + 1) * self.tileSize, zoom)
return (minx, miny, maxx, maxy) | Returns bounds of the given tile in EPSG:900913 coordinates | TileBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def TileLatLonBounds(
self,
tx,
ty,
zoom,
):
'''Returns bounds of the given tile in latutude/longitude using WGS84 datum'''
bounds = self.TileBounds(tx, ty, zoom)
(minLat, minLon) = self.MetersToLatLon(bounds[0], bounds[1])
(maxLat, maxLon) = self.MetersToLatLon(bounds[2], bounds[3])
return (minLat, minLon, maxLat, maxLon) | Returns bounds of the given tile in latutude/longitude using WGS84 datum | TileLatLonBounds | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def Resolution(self, zoom):
'''Resolution (meters/pixel) for given zoom level (measured at Equator)'''
# return (2 * math.pi * 6378137) / (self.tileSize * 2**zoom)
return self.initialResolution / 2 ** zoom | Resolution (meters/pixel) for given zoom level (measured at Equator) | Resolution | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def ZoomForPixelSize(self, pixelSize):
'''Maximal scaledown zoom of the pyramid closest to the pixelSize.'''
for i in range(MAXZOOMLEVEL):
if pixelSize > self.Resolution(i):
if i != 0:
return i - 1
else:
return 0 # We don't want to scale up | Maximal scaledown zoom of the pyramid closest to the pixelSize. | ZoomForPixelSize | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def GoogleTile(
self,
tx,
ty,
zoom,
):
'''Converts TMS tile coordinates to Google Tile coordinates'''
# coordinate origin is moved from bottom-left to top-left corner of the extent
return (tx, 2 ** zoom - 1 - ty) | Converts TMS tile coordinates to Google Tile coordinates | GoogleTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def QuadTree(
self,
tx,
ty,
zoom,
):
'''Converts TMS tile coordinates to Microsoft QuadTree'''
quadKey = ''
ty = 2 ** zoom - 1 - ty
for i in range(zoom, 0, -1):
digit = 0
mask = 1 << i - 1
if tx & mask != 0:
digit += 1
if ty & mask != 0:
digit += 2
quadKey += str(digit)
return quadKey | Converts TMS tile coordinates to Microsoft QuadTree | QuadTree | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def LonLatToPixels(
self,
lon,
lat,
zoom,
):
'''Converts lon/lat to pixel coordinates in given zoom of the EPSG:4326 pyramid'''
res = self.resFact / 2 ** zoom
px = (180 + lon) / res
py = (90 + lat) / res
return (px, py) | Converts lon/lat to pixel coordinates in given zoom of the EPSG:4326 pyramid | LonLatToPixels | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def PixelsToTile(self, px, py):
'''Returns coordinates of the tile covering region in pixel coordinates'''
tx = int(math.ceil(px / float(self.tileSize)) - 1)
ty = int(math.ceil(py / float(self.tileSize)) - 1)
return (tx, ty) | Returns coordinates of the tile covering region in pixel coordinates | PixelsToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
def LonLatToTile(
self,
lon,
lat,
zoom,
):
'''Returns the tile for zoom which covers given lon/lat coordinates'''
(px, py) = self.LonLatToPixels(lon, lat, zoom)
return self.PixelsToTile(px, py) | Returns the tile for zoom which covers given lon/lat coordinates | LonLatToTile | python | commenthol/gdal2tiles-leaflet | gdal2tiles-multiprocess.py | https://github.com/commenthol/gdal2tiles-leaflet/blob/master/gdal2tiles-multiprocess.py | MIT |
Subsets and Splits
Django Code with Docstrings
Filters Python code examples from Django repository that contain Django-related code, helping identify relevant code snippets for understanding Django framework usage patterns.
SQL Console for Shuu12121/python-treesitter-filtered-datasetsV2
Retrieves specific code examples from the Flask repository but doesn't provide meaningful analysis or patterns beyond basic data retrieval.
HTTPX Repo Code and Docstrings
Retrieves specific code examples from the httpx repository, which is useful for understanding how particular libraries are used but doesn't provide broader analytical insights about the dataset.
Requests Repo Docstrings & Code
Retrieves code examples with their docstrings and file paths from the requests repository, providing basic filtering but limited analytical value beyond finding specific code samples.
Quart Repo Docstrings & Code
Retrieves code examples with their docstrings from the Quart repository, providing basic code samples but offering limited analytical value for understanding broader patterns or relationships in the dataset.