code: from __future__ import division
  from __future__ import print_function
  from __future__ import absolute_import
  
  import os
  
  import numpy as np
  import tensorflow as tf
  from gym import utils
  from gym.envs.mujoco import mujoco_env
  from meta_mb.meta_envs.base import MetaEnv
  
  
  class SwimmerEnv(MetaEnv, mujoco_env.MujocoEnv, utils.EzPickle):
  
      def __init__(self, frame_skip=4):
          self.prev_qpos = None
          dir_path = os.path.dirname(os.path.abspath(__file__))
          mujoco_env.MujocoEnv.__init__(
              self, '%s/assets/swimmer.xml' % dir_path, frame_skip=frame_skip
          )
          utils.EzPickle.__init__(self)
  
      def step(self, action):
          old_ob = self._get_obs()
          self.do_simulation(action, self.frame_skip)
  
          if getattr(self, 'action_space', None):
              action = np.clip(action, self.action_space.low,
                               self.action_space.high)
          ob = self._get_obs()
  
          reward_ctrl = -0.0001 * np.square(action).sum()
          reward_run = old_ob[3]
          reward = reward_run + reward_ctrl
  
          done = False
          return ob, reward, done, {}
  
      def _get_obs(self):
          return np.concatenate([
              # (self.model.data.qpos.flat[:1] - self.prev_qpos[:1]) / self.dt,
              # self.get_body_comvel("torso")[:1],
              self.sim.data.qpos.flat[2:],
              self.sim.data.qvel.flat,
          ])
  
      def reset_model(self):
          self.set_state(
              self.init_qpos + self.np_random.uniform(low=-.1, high=.1, size=self.model.nq),
              self.init_qvel + self.np_random.uniform(low=-.1, high=.1, size=self.model.nv)
          )
          self.prev_qpos = np.copy(self.sim.data.qpos.flat)
          return self._get_obs()
  
      def reward(self, obs, acts, next_obs):
          assert obs.ndim == 2
          assert obs.shape == next_obs.shape
          assert obs.shape[0] == acts.shape[0]
          reward_ctrl = -0.0001 * np.sum(np.square(acts), axis=1)
          reward_run = obs[:, 3]
          reward = reward_run + reward_ctrl
          return reward
  
      def tf_reward(self, obs, acts, next_obs):
          reward_ctrl = -0.0001 * tf.reduce_sum(tf.square(acts), axis=1)
          reward_run = obs[:, 3]
          reward = reward_run + reward_ctrl
          return reward
  
  if __name__ == "__main__":
      env = SwimmerEnv()
      env.reset()
      for _ in range(1000):
          _ = env.render()
          ob, rew, done, info = env.step(env.action_space.sample())  # take a random action
  
apis: numpy.copy numpy.clip tensorflow.square numpy.concatenate numpy.square