rename bullet envs for consistency

examples/pybullet/gym/pybullet_envs/__init__.py

@@ -55,51 +55,51 @@ register(
 )
 
 register(
-    id='MinitaurExtendedEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurExtendedEnv',
+    id='MinitaurExtendedBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurExtendedBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 
 register(
-    id='MinitaurReactiveEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurReactiveEnv',
+    id='MinitaurReactiveBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurReactiveBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 register(
-    id='MinitaurBallGymEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurBallGymEnv',
+    id='MinitaurBallGymBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurBallGymBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 register(
-    id='MinitaurTrottingEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurTrottingEnv',
+    id='MinitaurTrottingBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurTrottingBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 register(
-    id='MinitaurStandGymEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurStandGymEnv',
+    id='MinitaurStandGymBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurStandGymBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 register(
-    id='MinitaurAlternatingLegsEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurAlternatingLegsEnv',
+    id='MinitaurAlternatingLegsBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurAlternatingLegsBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
 
 register(
-    id='MinitaurFourLegStandEnv-v0',
-    entry_point='pybullet_envs.minitaur.envs:MinitaurFourLegStandEnv',
+    id='MinitaurFourLegStandBulletEnv-v0',
+    entry_point='pybullet_envs.minitaur.envs:MinitaurFourLegStandBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )
@@ -133,8 +133,8 @@ register(
 )
 
 register(
-    id='KukaDiverseObjectGrasping-v0',
-    entry_point='pybullet_envs.bullet:KukaDiverseObjectEnv',
+    id='KukaDiverseObjectBulletEnv-v0',
+    entry_point='pybullet_envs.bullet:KukaDiverseObjectBulletEnv',
     max_episode_steps=1000,
     reward_threshold=5.0,
 )

examples/pybullet/gym/pybullet_envs/baselines/enjoy_kuka_diverse_object_grasping.py

@@ -1,4 +1,4 @@
-"""Runs a random policy for the random object KukaDiverseObjectEnv.
+"""Runs a random policy for the random object KukaDiverseObjectBulletEnv.
 """
 
 import os, inspect
@@ -9,7 +9,7 @@ parentdir = os.path.dirname(os.path.dirname(currentdir))
 os.sys.path.insert(0, parentdir)
 
 import gym
-from pybullet_envs.bullet.kuka_diverse_object_gym_env import KukaDiverseObjectEnv
+from pybullet_envs.bullet.kuka_diverse_object_gym_env import KukaDiverseObjectBulletEnv
 from gym import spaces
 
 
@@ -37,7 +37,7 @@ class ContinuousDownwardBiasPolicy(object):
 
 def main():
 
-  env = KukaDiverseObjectEnv(renders=True, isDiscrete=False)
+  env = KukaDiverseObjectBulletEnv(renders=True, isDiscrete=False)
   policy = ContinuousDownwardBiasPolicy()
 
   while True:

examples/pybullet/gym/pybullet_envs/bullet/kuka_diverse_object_gym_env.py

@@ -14,7 +14,7 @@ from pkg_resources import parse_version
 import gym
 
 
-class KukaDiverseObjectEnv(KukaGymEnv):
+class KukaDiverseObjectBulletEnv(KukaGymEnv):
   """Class for Kuka environment with diverse objects.
 
   In each episode some objects are chosen from a set of 1000 diverse objects.
@@ -36,7 +36,7 @@ class KukaDiverseObjectEnv(KukaGymEnv):
                height=48,
                numObjects=5,
                isTest=False):
-    """Initializes the KukaDiverseObjectEnv.
+    """Initializes the KukaDiverseObjectBulletEnv.
 
     Args:
       urdfRoot: The diretory from which to load environment URDF's.

examples/pybullet/gym/pybullet_envs/minitaur/envs/__init__.py

@@ -1,7 +1,7 @@
-from pybullet_envs.minitaur.envs.minitaur_alternating_legs_env import MinitaurAlternatingLegsEnv
-from pybullet_envs.minitaur.envs.minitaur_ball_gym_env import MinitaurBallGymEnv
+from pybullet_envs.minitaur.envs.minitaur_alternating_legs_env import MinitaurAlternatingLegsBulletEnv
+from pybullet_envs.minitaur.envs.minitaur_ball_gym_env import MinitaurBallGymBulletEnv
 #from pybullet_envs.minitaur.envs.minitaur_randomize_terrain_gym_env import MinitaurRandomizeTerrainGymEnv
-from pybullet_envs.minitaur.envs.minitaur_reactive_env import MinitaurReactiveEnv
-from pybullet_envs.minitaur.envs.minitaur_stand_gym_env import MinitaurStandGymEnv
-from pybullet_envs.minitaur.envs.minitaur_trotting_env import MinitaurTrottingEnv
-from pybullet_envs.minitaur.envs.minitaur_four_leg_stand_env import MinitaurFourLegStandEnv
+from pybullet_envs.minitaur.envs.minitaur_reactive_env import MinitaurReactiveBulletEnv
+from pybullet_envs.minitaur.envs.minitaur_stand_gym_env import MinitaurStandGymBulletEnv
+from pybullet_envs.minitaur.envs.minitaur_trotting_env import MinitaurTrottingBulletEnv
+from pybullet_envs.minitaur.envs.minitaur_four_leg_stand_env import MinitaurFourLegStandBulletEnv

examples/pybullet/gym/pybullet_envs/minitaur/envs/env_randomizers/minitaur_alternating_legs_env_randomizer.py

@@ -20,15 +20,15 @@ BATTERY_VOLTAGE_RANGE = (14.8, 16.8)
 MOTOR_VISCOUS_DAMPING_RANGE = (0, 0.01)
 
 
-class MinitaurAlternatingLegsEnvRandomizer(env_randomizer_base.EnvRandomizerBase):
+class MinitaurAlternatingLegsBulletEnvRandomizer(env_randomizer_base.EnvRandomizerBase):
   """A randomizer that changes the minitaur_gym_alternating_leg_env."""
 
   def __init__(self,
                perturb_swing_bound=0.1,
                perturb_extension_bound=0.1,
                perturb_desired_pitch_bound=0.01):
-    super(MinitaurAlternatingLegsEnvRandomizer, self).__init__()
-    self.perturb_swing_bound = perturb_swing_bound
+    super(MinitaurAlternatingLegsBulletEnvRandomizer, self).__init__()
+    se.perturb_swing_bound = perturb_swing_bound
     self.perturb_extension_bound = perturb_extension_bound
     self.perturb_desired_pitch_bound = perturb_desired_pitch_bound
 

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_alternating_legs_env.py

@@ -21,7 +21,7 @@ STEP_PERIOD = 1.0 / 3.0  # Three steps per second.
 STEP_AMPLITUDE = 0.75
 
 
-class MinitaurAlternatingLegsEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurAlternatingLegsBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The gym environment for the minitaur.
 
   It simulates the locomotion of a minitaur, a quadruped robot. The state space
@@ -78,7 +78,7 @@ class MinitaurAlternatingLegsEnv(minitaur_gym_env.MinitaurGymEnv):
     # _swing_offset and _extension_offset is to mimick the bent legs.
     self._swing_offset = np.zeros(NUM_LEGS)
     self._extension_offset = np.zeros(NUM_LEGS)
-    super(MinitaurAlternatingLegsEnv,
+    super(MinitaurAlternatingLegsBulletEnv,
           self).__init__(urdf_version=urdf_version,
                          accurate_motor_model_enabled=True,
                          motor_overheat_protection=True,
@@ -118,7 +118,8 @@ class MinitaurAlternatingLegsEnv(minitaur_gym_env.MinitaurGymEnv):
         INIT_EXTENSION_POS + self._extension_offset[3]
     ]
     initial_motor_angles = self._convert_from_leg_model(init_pose)
-    super(MinitaurAlternatingLegsEnv, self).reset(initial_motor_angles=initial_motor_angles,
+    super(MinitaurAlternatingLegsBulletEnv, self).reset(
+        initial_motor_angles=initial_motor_angles,
                                                   reset_duration=0.5)
     return self._get_observation()
 

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_alternating_legs_env_example.py

@@ -73,8 +73,8 @@ def hand_tuned_balance_example(log_path=None):
   steps = 1000
   episodes = 5
 
-  randomizer = randomizer_lib.MinitaurAlternatingLegsEnvRandomizer()
-  environment = minitaur_alternating_legs_env.MinitaurAlternatingLegsEnv(
+  randomizer = randomizer_lib.MinitaurAlternatingLegsBulletEnvRandomizer()
+  environment = minitaur_alternating_legs_env.MinitaurAlternatingLegsBulletEnv(
       urdf_version=minitaur_gym_env.DERPY_V0_URDF_VERSION,
       render=True,
       num_steps_to_log=steps,

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_ball_gym_env.py

@@ -22,7 +22,7 @@ INIT_BALL_DISTANCE = 5.0
 ACTION_EPS = 0.01
 
 
-class MinitaurBallGymEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurBallGymBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The gym environment for the minitaur and a ball.
 
   It simulates a minitaur (a quadruped robot) and a ball. The state space
@@ -52,7 +52,7 @@ class MinitaurBallGymEnv(minitaur_gym_env.MinitaurGymEnv):
         that its walking gait is clearer to visualize.
       render: Whether to render the simulation.
     """
-    super(MinitaurBallGymEnv, self).__init__(urdf_root=urdf_root,
+    super(MinitaurBallGymBulletEnv, self).__init__(urdf_root=urdf_root,
                                              self_collision_enabled=self_collision_enabled,
                                              pd_control_enabled=pd_control_enabled,
                                              leg_model_enabled=leg_model_enabled,
@@ -66,7 +66,7 @@ class MinitaurBallGymEnv(minitaur_gym_env.MinitaurGymEnv):
 
   def reset(self):
     self._ball_id = 0
-    super(MinitaurBallGymEnv, self).reset()
+    super(MinitaurBallGymBulletEnv, self).reset()
     self._init_ball_theta = random.uniform(-INIT_BALL_ANGLE, INIT_BALL_ANGLE)
     self._init_ball_distance = INIT_BALL_DISTANCE
     self._ball_pos = [

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_ball_gym_env_example.py

@@ -10,7 +10,7 @@ import minitaur_ball_gym_env
 
 def FollowBallManualPolicy():
   """An example of a minitaur following a ball."""
-  env = minitaur_ball_gym_env.MinitaurBallGymEnv(render=True,
+  env = minitaur_ball_gym_env.MinitaurBallGymBulletEnv(render=True,
                                                  pd_control_enabled=True,
                                                  on_rack=False)
   observation = env.reset()

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_extended_env.py

@@ -8,10 +8,10 @@ the experimental branch.
 from gym import spaces
 import numpy as np
 
-from pybullet_envs.minitaur.envs.minitaur_reactive_env import MinitaurReactiveEnv
+from pybullet_envs.minitaur.envs.minitaur_reactive_env import MinitaurReactiveBulletEnv
 
 
-class MinitaurExtendedEnv(MinitaurReactiveEnv):
+class MinitaurExtendedBulletEnv(MinitaurReactiveBulletEnv):
   """The 'extended' environment for Markovian property.
 
   This class implements to include prior actions and observations to the
@@ -72,7 +72,7 @@ class MinitaurExtendedEnv(MinitaurReactiveEnv):
     self._past_actions = np.zeros((self.MAX_BUFFER_SIZE, self.ACTION_DIM))
     self._counter = 0
 
-    super(MinitaurExtendedEnv, self).__init__(**kwargs)
+    super(MinitaurExtendedBulletEnv, self).__init__(**kwargs)
     self.action_space = spaces.Box(-1.0, 1.0, self.action_space.shape)
     self.observation_space = spaces.Box(-np.inf, np.inf,
                                         self._get_observation().shape)
@@ -82,7 +82,8 @@ class MinitaurExtendedEnv(MinitaurReactiveEnv):
 
   def _get_observation(self):
     """Maybe concatenate motor velocity and torque into observations."""
-    parent_observation = super(MinitaurExtendedEnv, self)._get_observation()
+    parent_observation = super(MinitaurExtendedBulletEnv,
+                               self)._get_observation()
     parent_observation = np.array(parent_observation)
     # Base class might require this.
     self._observation = parent_observation
@@ -142,7 +143,7 @@ class MinitaurExtendedEnv(MinitaurReactiveEnv):
     self._past_actions = np.zeros((self.MAX_BUFFER_SIZE, self.ACTION_DIM))
     self._counter = 0
 
-    return np.array(super(MinitaurExtendedEnv, self).reset())
+    return np.array(super(MinitaurExtendedBulletEnv, self).reset())
 
   def step(self, action):
     """Step function wrapper can be used to add shaping terms to the reward.
@@ -162,7 +163,7 @@ class MinitaurExtendedEnv(MinitaurReactiveEnv):
     self._past_actions[self._counter] = action
     self._counter += 1
 
-    next_obs, _, done, info = super(MinitaurExtendedEnv, self).step(action)
+    next_obs, _, done, info = super(MinitaurExtendedBulletEnv, self).step(action)
 
     reward = self.reward()
     info.update(base_reward=reward)
@@ -171,7 +172,7 @@ class MinitaurExtendedEnv(MinitaurReactiveEnv):
 
   def terminate(self):
     """The helper function to terminate the environment."""
-    super(MinitaurExtendedEnv, self)._close()
+    super(MinitaurExtendedBulletEnv, self)._close()
 
   def _termination(self):
     """Determines whether the env is terminated or not.

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_four_leg_stand_env.py

@@ -23,7 +23,7 @@ DERPY_V0_URDF_VERSION = minitaur_gym_env.DERPY_V0_URDF_VERSION
 RAINBOW_DASH_V0_URDF_VERSION = minitaur_gym_env.RAINBOW_DASH_V0_URDF_VERSION
 
 
-class MinitaurFourLegStandEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurFourLegStandBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The gym environment for the minitaur.
 
   It simulates the a minitaur standing with four legs. The state space
@@ -98,7 +98,7 @@ class MinitaurFourLegStandEnv(minitaur_gym_env.MinitaurGymEnv):
     self._extension_offset = np.zeros(NUM_LEGS)
     self._use_angular_velocity_in_observation = use_motor_angle_in_observation
     self._use_motor_angle_in_observation = use_motor_angle_in_observation
-    super(MinitaurFourLegStandEnv,
+    super(MinitaurFourLegStandBulletEnv,
           self).__init__(urdf_version=urdf_version,
                          control_time_step=control_time_step,
                          action_repeat=action_repeat,
@@ -144,7 +144,8 @@ class MinitaurFourLegStandEnv(minitaur_gym_env.MinitaurGymEnv):
     ]
     initial_motor_angles = self._convert_from_leg_model(init_pose)
     self._pybullet_client.resetBasePositionAndOrientation(0, [0, 0, 0], [0, 0, 0, 1])
-    super(MinitaurFourLegStandEnv, self).reset(initial_motor_angles=initial_motor_angles,
+    super(MinitaurFourLegStandBulletEnv, self).reset(
+      initial_motor_angles=initial_motor_angles,
                                                reset_duration=0.5)
     return self._get_observation()
 

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_four_leg_stand_env_example.py

@@ -22,7 +22,7 @@ def feed_forward_only_control_example(log_path=None):
   steps = 1000
   episodes = 1
 
-  environment = minitaur_four_leg_stand_env.MinitaurFourLegStandEnv(
+  environment = minitaur_four_leg_stand_env.MinitaurFourLegStandBulletEnv(
       on_rack=False,
       log_path=log_path,
       urdf_version=minitaur_four_leg_stand_env.RAINBOW_DASH_V0_URDF_VERSION,

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_logging.py

@@ -19,7 +19,8 @@ import datetime
 import os
 import time
 
-import tf.compat.v1 as tf
+import tensorflow
+import tensorflow.compat.v1 as tf
 from pybullet_envs.minitaur.envs import minitaur_logging_pb2
 
 NUM_MOTORS = 8

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_reactive_env.py

@@ -24,7 +24,7 @@ MinitaurPose = collections.namedtuple(
     "extension_angle_4")
 
 
-class MinitaurReactiveEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurReactiveBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The gym environment for the minitaur.
 
   It simulates the locomotion of a minitaur, a quadruped robot. The state space
@@ -92,7 +92,7 @@ class MinitaurReactiveEnv(minitaur_gym_env.MinitaurGymEnv):
     """
     self._use_angle_in_observation = use_angle_in_observation
 
-    super(MinitaurReactiveEnv,
+    super(MinitaurReactiveBulletEnv,
           self).__init__(urdf_version=urdf_version,
                          energy_weight=energy_weight,
                          accurate_motor_model_enabled=accurate_motor_model_enabled,
@@ -132,7 +132,8 @@ class MinitaurReactiveEnv(minitaur_gym_env.MinitaurGymEnv):
                              extension_angle_4=INIT_EXTENSION_POS)
     # TODO(b/73734502): Refactor input of _convert_from_leg_model to namedtuple.
     initial_motor_angles = self._convert_from_leg_model(list(init_pose))
-    super(MinitaurReactiveEnv, self).reset(initial_motor_angles=initial_motor_angles,
+    super(MinitaurReactiveBulletEnv, self).reset(
+        initial_motor_angles=initial_motor_angles,
                                            reset_duration=0.5)
     return self._get_observation()
 

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_stand_gym_env.py

@@ -20,7 +20,7 @@ RANGE_OF_LEG_MOTION = 0.7
 LIMIT_FALLEN = 0.7
 
 
-class MinitaurStandGymEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurStandGymBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The gym environment for the minitaur and a ball.
 
   It simulates the standing up behavior of a minitaur, a quadruped robot. The
@@ -50,7 +50,7 @@ class MinitaurStandGymEnv(minitaur_gym_env.MinitaurGymEnv):
       pd_control_enabled: Whether to use PD controller for each motor.
       render: Whether to render the simulation.
     """
-    super(MinitaurStandGymEnv, self).__init__(urdf_root=urdf_root,
+    super(MinitaurStandGymBulletEnv, self).__init__(urdf_root=urdf_root,
                                               action_repeat=action_repeat,
                                               observation_noise_stdev=observation_noise_stdev,
                                               self_collision_enabled=self_collision_enabled,
@@ -103,7 +103,7 @@ class MinitaurStandGymEnv(minitaur_gym_env.MinitaurGymEnv):
     # returning the current state and reward.
     if self._env_step_counter < 1:
       return self._stand_up()
-    return super(MinitaurStandGymEnv, self).step(action)
+    return super(MinitaurStandGymBulletEnv, self).step(action)
 
   def _reward(self):
     """Reward function for standing up pose.

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_stand_gym_env_example.py

@@ -13,7 +13,7 @@ from pybullet_envs.minitaur.envs import minitaur_stand_gym_env
 def StandUpExample():
   """An example that the minitaur stands up."""
   steps = 1000
-  environment = minitaur_stand_gym_env.MinitaurStandGymEnv(render=True,
+  environment = minitaur_stand_gym_env.MinitaurStandGymBulletEnv(render=True,
                                                            motor_velocity_limit=np.inf)
   action = [0.5]
   _, _, done, _ = environment.step(action)

examples/pybullet/gym/pybullet_envs/minitaur/envs/minitaur_trotting_env.py

@@ -11,7 +11,7 @@ NUM_LEGS = 4
 NUM_MOTORS = 2 * NUM_LEGS
 
 
-class MinitaurTrottingEnv(minitaur_gym_env.MinitaurGymEnv):
+class MinitaurTrottingBulletEnv(minitaur_gym_env.MinitaurGymEnv):
   """The trotting gym environment for the minitaur.
 
   In this env, Minitaur performs a trotting style locomotion specified by
@@ -109,7 +109,7 @@ class MinitaurTrottingEnv(minitaur_gym_env.MinitaurGymEnv):
     self._swing_amplitude = swing_amplitude
     self._use_signal_in_observation = use_signal_in_observation
     self._use_angle_in_observation = use_angle_in_observation
-    super(MinitaurTrottingEnv,
+    super(MinitaurTrottingBulletEnv,
           self).__init__(urdf_version=urdf_version,
                          accurate_motor_model_enabled=accurate_motor_model_enabled,
                          motor_overheat_protection=True,
@@ -141,7 +141,8 @@ class MinitaurTrottingEnv(minitaur_gym_env.MinitaurGymEnv):
     # [swing leg 1, swing leg 2, swing leg 3, swing leg 4,
     #  extension leg 1, extension leg 2, extension leg 3, extension leg 4]
     initial_motor_angles = self._convert_from_leg_model(self._init_pose)
-    super(MinitaurTrottingEnv, self).reset(initial_motor_angles=initial_motor_angles,
+    super(MinitaurTrottingBulletEnv, self).reset(
+      initial_motor_angles=initial_motor_angles,
                                            reset_duration=0.5)
     return self._get_observation()