def __init__(self, animate=False, sim=None):
if sim is not None:
self.sim = sim
self.model = self.sim.model
else:
self.modelpath = TestEnv.MODELPATH
self.model = mujoco_py.load_model_from_path(self.modelpath)
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.02
self.max_steps = 400
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = self.q_dim + self.qvel_dim
self.act_dim = self.sim.data.actuator_length.shape[0]
# Environent inner parameters
self.viewer = None
self.step_ctr = 0
# Initial methods
if animate:
self.setupcam()
self.reset()
def __init__(self, model_path, frame_skip):
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets",
model_path)
if not path.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
self.frame_skip = frame_skip
self.model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(self.model)
self.data = self.sim.data
self.viewer = None
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
observation, _reward, done, _info = self.step(np.zeros(self.model.nu))
assert not done
self.obs_dim = observation.size
bounds = self.model.actuator_ctrlrange.copy()
low = bounds[:, 0]
high = bounds[:, 1]
self.action_space = spaces.Box(low=low, high=high)
high = np.inf * np.ones(self.obs_dim)
low = -high
self.observation_space = spaces.Box(low, high)
self.seed()
def __init__(self, model_path, num_substeps=75):
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = osp.join(osp.dirname(__file__), "assets", model_path)
if not osp.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
else:
print("Loading model %s" % osp.basename(model_path))
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model, nsubsteps=num_substeps)
self.data = self.sim.data
self.viewer = None
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.seed()
# limits of motion with some safety limits
self.target_range_min = np.array([0.3, 0.0, 0.08]) + 0.05
self.target_range_max = np.array([0.8, 0.6, 0.25]) - 0.05
self.initial_qpos = {
'left_s0': -0.08,
'left_s1': -1.0,
'left_e0': -1.19,
'left_e1': 1.94,
'left_w0': 0.67,
'left_w1': 1.03,
'left_w2': -0.5
}
def __init__(self, model_path, initial_qpos, n_actions, n_substeps):
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets",
model_path)
if not path.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
self.model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(self.model, n_substeps=n_substeps)
self.data = self.sim.data
self.viewer = None
self._viewers = {}
self.metadata = {
'render.modes': ['human', 'rgb_array', 'depth_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.seed()
self._env_setup(initial_qpos=initial_qpos)
self.initial_state = copy.deepcopy(self.sim.get_state())
obs = self._get_obs()
self.action_space = spaces.MultiDiscrete(
list(np.zeros(n_actions) + 11))
self._set_action_space()
action = self.action_space.sample()
observation, _reward, done, _info = self.step(action)
assert not done
self._set_observation_space(observation)
def __init__(self, model_path, frame_skip):
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets", model_path)
if not path.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
self.frame_skip = frame_skip
self.model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(self.model)
self.data = self.sim.data
self.viewer = None
self._viewers = {}
self.metadata = {
'render.modes': ['human', 'rgb_array', 'depth_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
self._set_action_space()
action = self.action_space.sample()
observation, _reward, done, _info = self.step(action)
assert not done
self._set_observation_space(observation)
self.seed()
def __init__(self, animate=False, sim=None):
if sim is not None:
self.sim = sim
self.model = self.sim.model
else:
self.modelpath = QuadFeelersMjc.MODELPATH
self.model = mujoco_py.load_model_from_path(self.modelpath)
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.04
self.N_boxes = 4
self.max_steps = 400
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = self.q_dim + self.qvel_dim - 7 * self.N_boxes - 6 * self.N_boxes + 7 - 2
self.act_dim = self.sim.data.actuator_length.shape[0]
# Environent inner parameters
self.viewer = None
self.step_ctr = 0
self.joints_rads_low = np.array([-0.3, -1.] * 4 + [-1, -1, -1, -1])
self.joints_rads_high = np.array([0.3, 0] * 4 + [1, 1, 1, 1])
self.joints_rads_diff = self.joints_rads_high - self.joints_rads_low
# Initial methods
if animate:
self.setupcam()
self.reset()
def __init__(self, env_list=None, max_n_envs=3):
print("Trossen hexapod envs: {}".format(env_list))
self.modelpath = Hexapod.MODELPATH
self.max_steps = 250
self.episode_reward = 0
self.max_episode_reward = 0
self.episodes = 0
self.joints_rads_low = np.array([-0.3, -1.0, -1.0] * 6)
self.joints_rads_high = np.array([0.3, 0.2, 0.4] * 6)
self.joints_rads_diff = self.joints_rads_high - self.joints_rads_low
self.viewer = None
path = Hexapod.MODELPATH + "gait.xml"
self.model = mujoco_py.load_model_from_path(path)
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.02
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = 18 * 2 + 6 + 4 + 6
self.act_dim = self.sim.data.actuator_length.shape[0]
self.reset()
def __init__(self, model_path, frame_skip):
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets", model_path)
if not path.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
self.frame_skip = frame_skip
self.model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(self.model)
self.data = self.sim.data
self.viewer = None
self._viewers = {}
self.metadata = {
'render.modes': ['human', 'rgb_array', 'depth_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
# self.seed()
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
# self.goal = self._sample_goal()
self._set_action_space()
### because of this, we don't get our defined initial condn so we'll have to enforce them at last in __init__ of env itself
action = self.action_space.sample()
observation, _reward, done, _info = self.step(action)
assert not done
self.set_state(self.init_qpos,self.init_qvel) ### enforcing initial state
self._set_observation_space(observation)
def __init__(self, animate=False):
self.modelpath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets/inverted_double_pendulum.xml")
self.max_steps = 150
self.mem_dim = 0
self.cumulative_environment_reward = None
self.model = mujoco_py.load_model_from_path(self.modelpath)
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.02
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = self.q_dim + self.qvel_dim
self.act_dim = 1
# Environent inner parameters
self.viewer = None
# Reset env variables
self.step_ctr = 0
self.episodes = 0
self.reset()
def try_action(self, an_action):
xml = XML(self.asset_path)
# Note: We need to recreate the entire scene
for ind, prev_action in enumerate(self.xml_actions_taken): # Adding previous actions
prev_action['pos'][-1] = ind * 2
xml.add_mesh(**prev_action)
xml_action = self.model_action_to_xml_action(an_action)
new_name = xml.add_mesh(**xml_action) # Note name is name of action (name of block dropped)
new_names = self.names + [new_name]
xml_str = xml.instantiate()
model = mjc.load_model_from_xml(xml_str)
sim = mjc.MjSim(model)
logger = Logger(xml, sim, steps=self.max_num_objects_dropped + 1, img_dim=self.img_dim)
for a_block in self.names:
self.set_block_info(sim, a_block, self.get_block_info(a_block))
logger.hold_drop_execute([], new_name, 1)
# for act_ind, act in enumerate(new_names[:-1]):
# logger.hold_drop_execute(new_names[act_ind+1:], new_names[act_ind], self.settle_steps)
logger.log(0)
original_logger = self.logger
self.logger = logger
obs = self.get_observation()
self.logger = original_logger
return obs
def __init__(self, max_num_objects_dropped):
self.asset_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'mujoco_data/stl/')
self.img_dim = 64
self.polygons = ['cube', 'horizontal_rectangle', 'tetrahedron']
self.settle_bounds = {
'pos': [ [-.5, .5], [-.5, 0], [1, 2] ],
'hsv': [ [0, 1], [0.5, 1], [0.5, 1] ],
'scale': [ [0.4, 0.4] ],
'force': [ [0, 0], [0, 0], [0, 0] ]
}
self.drop_bounds = {
'pos': [ [-1.75, 1.75], [-.5, 0], [0, 3] ],
}
self.xml = XML(self.asset_path)
xml_str = self.xml.instantiate()
model = mjc.load_model_from_xml(xml_str)
sim = mjc.MjSim(model)
self.max_num_objects_dropped = max_num_objects_dropped
self.logger = Logger(self.xml, sim, steps=max_num_objects_dropped + 1, img_dim=self.img_dim)
self.logger.log(0)
self._blank_observation = self.get_observation() # This can be / is used in the mpc goal acquisition step
self.xml_actions_taken = []
self.names = []
self.env_step = 0
self.settle_steps = 2000
def step(self, an_action):
xml = XML(self.asset_path)
# Note: We need to recreate the entire scene
for ind, prev_action in enumerate(self.xml_actions_taken): # Adding previous actions
prev_action['pos'][-1] = ind * 2
xml.add_mesh(**prev_action)
xml_action = self.model_action_to_xml_action(an_action)
# print("Action to take: ", xml_action)
new_name = xml.add_mesh(**xml_action) # Note name is name of action (name of block dropped)
self.names.append(new_name)
xml_str = xml.instantiate()
model = mjc.load_model_from_xml(xml_str)
sim = mjc.MjSim(model)
logger = Logger(xml, sim, steps=self.max_num_objects_dropped + 1, img_dim=self.img_dim)
#Set previous block states
for a_block in self.names[:-1]:
self.set_block_info(sim, a_block, self.get_block_info(a_block))
logger.hold_drop_execute([], self.names[-1], self.settle_steps)
self.logger = logger
self.logger.log(0)
##Update state information
self.xml_actions_taken.append(xml_action)
self.sim = self.logger.sim
return self.get_observation()
def render_mujoco(model_path):
model = mujoco_py.load_model_from_path(model_path)
sim = mujoco_py.MjSim(model)
viewer = mujoco_py.MjViewer(sim)
while True:
viewer.render()
time.sleep(.01)
def __init__(self, model_path, initial_qpos, n_actions, n_substeps):
if model_path.startswith('/'):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), 'assets', model_path)
if not os.path.exists(fullpath):
raise IOError('File {} does not exist'.format(fullpath))
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model, nsubsteps=n_substeps)
self.viewer = None
self.obs_viewer = None
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.seed()
self._env_setup(initial_qpos=initial_qpos)
self.initial_state = copy.deepcopy(self.sim.get_state())
self.goal = self._sample_goal()
self.visual_goal = self.get_image_obs() # Not the actual visual goal
obs = self._get_obs()
self.action_space = spaces.Box(-1., 1., shape=(n_actions,), dtype='float32')
self.observation_space = spaces.Dict(dict(
desired_goal=spaces.Box(-np.inf, np.inf, shape=obs['achieved_goal'].shape, dtype='float32'),
achieved_goal=spaces.Box(-np.inf, np.inf, shape=obs['achieved_goal'].shape, dtype='float32'),
observation=spaces.Box(-np.inf, np.inf, shape=obs['observation'].shape, dtype='float32'),
))
self.visual_goal = None
def __init__(self, model_path, initial_qpos, n_actions, n_substeps,
training_range, lift_angle_range, flex_angle_range,
time_offset_range, imi_flag, demonstr_idxs,
interaction_t_correction):
if model_path.startswith('/'):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), 'assets',
model_path)
if not os.path.exists(fullpath):
raise IOError('File {} does not exist'.format(fullpath))
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model, nsubsteps=n_substeps)
self.viewer = None
self.step_counter = 0
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
qposs_list = []
for name in DATA_JOINT_NAMES:
qposs_list.append(self.sim.data.get_joint_qpos(name))
self.seed()
self._env_setup(initial_qpos=initial_qpos)
self.initial_state = copy.deepcopy(self.sim.get_state())
self.initial_goal_pos = np.array([
self.sim.data.get_joint_qpos('robot1:HMJX'),
self.sim.data.get_joint_qpos('robot1:HMJY'),
self.sim.data.get_joint_qpos('robot1:HMJZ')
])
ctrlrange = self.sim.model.actuator_ctrlrange
# self.qpos_array = np.clip(np.array(qpos_list,'Float64')[:,:], ctrlrange[-20:, 0], ctrlrange[-20:, 1])
self.goal = self._sample_goal()
obs = self._get_obs()
self.action_space = spaces.Box(-1.,
1.,
shape=(n_actions, ),
dtype='float32')
self.observation_space = spaces.Dict(
dict(
desired_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
achieved_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
observation=spaces.Box(-np.inf,
np.inf,
shape=obs['observation'].shape,
dtype='float32'),
))
def __init__(self, model_path):
# self.model = mujoco_py.load_model_from_xml(model_path)
self.model = dy.make_model(model_path)
self.sim = mujoco_py.MjSim(self.model)
self.viewer = mujoco_py.MjViewer(self.sim)
self.qdim = self.model.nq
self.udim = self.model.nu
self.pdim = 2 * self.qdim + self.udim
def init_sim(self):
self.model = self.load_model(self.path)
self.sim = mujoco_py.MjSim(self.model)
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
self.data = self.sim.data
self._viewers = {}
self.viewer = None
def _setup_render_rgb(sim: mujoco_py.MjSim) -> mujoco_py.MjSim: # create copy of simulation to customize rendering context # flags defined in mjvisualize.h render_sim = mujoco_py.MjSim(sim.model) render_sim.set_state(sim.get_state()) render_ctx = mujoco_py.MjRenderContextOffscreen(render_sim) render_ctx.scn.stereo = 2 # side-by-side rendering return render_sim
def __init__(self, modelName, qPosInit, qVelInit, numAgent, qPosInitNoise=0, qVelInitNoise=0):
model = mujoco.load_model_from_path('../env/xmls/' + modelName + '.xml')
self.simulation = mujoco.MjSim(model)
self.qPosInit = qPosInit
self.qVelInit = qVelInit
self.numAgent = numAgent
self.qPosInitNoise = qPosInitNoise
self.qVelInitNoise = qVelInitNoise
def reset(self, test=False):
if self.episodes % 1000 == 0 and self.episodes > 0:
self.envgen.save()
if not test:
self.envgen.feedback(self.cumulative_environment_reward)
self.envgen.generate()
else:
self.envgen.test_generate()
self.cumulative_environment_reward = 0
try:
self.model = mujoco_py.load_model_from_path(self.modelpath)
except:
print(
"Error, file was not found, backup loaded instead for this episode"
)
self.model = mujoco_py.load_model_from_path(self.backuppath)
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.02
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = self.q_dim + self.qvel_dim - 2 + 6 + self.mem_dim
self.act_dim = self.sim.data.actuator_length.shape[0] + self.mem_dim
# Environent inner parameters
self.viewer = None
# Reset env variables
self.step_ctr = 0
self.episodes += 1
self.ctrl_vecs = []
self.dead_joint_idx = np.random.randint(0, self.act_dim)
self.dead_leg_idx = np.random.randint(0, self.act_dim / 3)
# Sample initial configuration
init_q = np.zeros(self.q_dim, dtype=np.float32)
init_q[0] = np.random.randn() * 0.1
init_q[1] = np.random.randn() * 0.1
init_q[2] = 1.00 + np.random.rand() * 0.1
init_qvel = np.random.randn(self.qvel_dim).astype(np.float32) * 0.1
obs = np.concatenate((init_q[2:], init_qvel)).astype(np.float32)
# Set environment state
self.set_state(init_q, init_qvel)
obs_dict = self.get_obs_dict()
obs = np.concatenate(
(obs, obs_dict["contacts"], np.zeros(self.mem_dim)))
return obs
def __init__(self, model_path, frame_skip, rgb_rendering_tracking=True):
if model_path.startswith('/'):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), 'assets',
model_path)
if not os.path.exists(fullpath):
raise IOError('File {} does not exist'.format(fullpath))
self.frame_skip = frame_skip
self.model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(self.model)
self.data = self.sim.data
self.viewer = None
self.rgb_rendering_tracking = rgb_rendering_tracking
self._viewers = {}
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.goal = self._sample_goal()
obs = self._get_obs()
self.action_space = spaces.Box(-1.,
1.,
shape=(n_actions, ),
dtype='float32')
self.observation_space = spaces.Dict(
dict(
desired_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
achieved_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
observation=spaces.Box(-np.inf,
np.inf,
shape=obs['observation'].shape,
dtype='float32'),
))
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
observation, _reward, done, _info = self.step(np.zeros(self.model.nu))
assert not done
self.obs_dim = observation.size
bounds = self.model.actuator_ctrlrange.copy()
low = bounds[:, 0]
high = bounds[:, 1]
self.action_space = spaces.Box(low=low, high=high, dtype=np.float32)
high = np.inf * np.ones(self.obs_dim)
low = -high
self.seed()
def __init__(self, width, height, frame_skip, rewarding_distance):
self.frame_skip = frame_skip
self.width = width
self.height = height
# Instantiate Mujoco model
model_path = "jaco.xml"
fullpath = os.path.join(os.path.dirname(__file__), "assets",
model_path)
if not os.path.exists(fullpath):
raise IOError("File %s does not exist" % fullpath)
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model)
self.init_state = self.sim.get_state()
self.init_qpos = self.sim.data.qpos.ravel().copy()
self.init_qvel = self.sim.data.qvel.ravel().copy()
# Setup actuators
self.actuator_bounds = self.sim.model.actuator_ctrlrange
self.actuator_low = self.actuator_bounds[:, 0]
self.actuator_high = self.actuator_bounds[:, 1]
self.actuator_ctrlrange = self.actuator_high - self.actuator_low
self.num_actuators = len(self.actuator_low)
self.observation_space = spaces.Box(low=-10, high=10, shape=(21, ))
self.action_space = spaces.Box(low=-3, high=3, shape=(9, ))
# init model_data_ctrl
self.null_action = np.zeros(self.num_actuators)
self.sim.data.ctrl[:] = self.null_action
self.seed()
self.sum_reward = 0
self.rewarding_distance = rewarding_distance
# Target position bounds
self.target_bounds = np.array(((0.3, 0.4), (-0.5, 0.5), (0.05, 0.05)))
self.target_reset_distance = 0.2
#self.reset_target()
self.goal_list = [[0.6, -0.3, 0.3], [0.6, 0.3, 0.3], [0.6, 0., 0.3]]
#self.goal_list = [[0.6, -0.4, 0.5]]
self.episode = 0
# Setup discrete action space
#self.control_values = self.actuator_ctrlrange * control_magnitude
#self.num_actions = 5
# self.action_space = [list(range(self.num_actions))
# ] * self.num_actuators
# self.observation_space = ((0, ), (height, width, 3),
# (height, width, 3))
#self.reset_target()
self.lifted = False
self.reset()
def reset(self):
# Generate environment
hm_fun = np.random.choice(self.hm_fun_list)
hm, info = hm_fun(*self.hm_args)
cv2.imwrite(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"hm.png"), hm)
# Load simulator
while True:
try:
self.model = mujoco_py.load_model_from_path(Quad.MODELPATH)
break
except Exception:
pass
# Set appropriate height according to height map
self.model.hfield_size[0][2] = info["height"]
self.sim = mujoco_py.MjSim(self.model)
self.model.opt.timestep = 0.02
self.viewer = None
# Height field
self.hf_data = self.model.hfield_data
self.hf_ncol = self.model.hfield_ncol[0]
self.hf_nrow = self.model.hfield_nrow[0]
self.hf_column_meters = self.model.hfield_size[0][0] * 2
self.hf_row_meters = self.model.hfield_size[0][1] * 2
self.hf_height_meters = self.model.hfield_size[0][2]
self.pixels_per_column = self.hf_ncol / float(self.hf_column_meters)
self.pixels_per_row = self.hf_nrow / float(self.hf_row_meters)
self.hf_grid = self.hf_data.reshape((self.hf_nrow, self.hf_ncol))
local_grid = self.hf_grid[45:55, 5:15]
max_height = np.max(local_grid) * self.hf_height_meters
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = 12 + 12 + 4 + 6 + 4 # j, jd, quat, pose_velocity, contacts
self.act_dim = self.sim.data.actuator_length.shape[0]
# Set initial position
init_q = np.zeros(self.q_dim, dtype=np.float32)
init_q[0] = 0.0
init_q[1] = 0.0
init_q[2] = max_height + 0.05
init_qvel = np.random.randn(self.qvel_dim).astype(np.float32) * 0.1
# Set environment state
self.set_state(init_q, init_qvel)
self.step_ctr = 0
obs, _, _, _ = self.step(np.zeros(self.act_dim))
return obs
def __init__(self, xml_specification, mesh_specification=None):
ref_angles = {
0: -np.pi / 2,
1: 0,
2: np.pi / 2,
3: -np.pi / 2,
4: np.pi / 2,
5: 0
}
self.ref_angles = ref_angles
self.xml_specification = xml_specification
self.mesh_specification = mesh_specification
if not path.isfile(self.xml_specification):
raise Exception('Missing XML specification at: {}'.format(
self.xml_specification))
if mesh_specification is not None:
if not path.isdir(self.mesh_specification):
raise Exception('Missing mesh specification at: {}'.format(
self.mesh_specification))
print('Arm model is specified at: {}'.format(self.xml_specification))
try:
self.mjc_model = mjc.load_model_from_path(self.xml_specification)
except:
raise Exception('Mujoco was unable to load the model')
# Initializing joint dictionary
joint_ids, joint_names = self.get_joints_info()
joint_positions_addr = [
self.mjc_model.get_joint_qpos_addr(name) for name in joint_names
]
joint_velocity_addr = [
self.mjc_model.get_joint_qvel_addr(name) for name in joint_names
]
self.joint_dict = {}
for i, ii in enumerate(joint_ids):
self.joint_dict[ii] = {
'name': joint_names[i],
'position_address': joint_positions_addr[i],
'velocity_address': joint_velocity_addr[i]
}
if not np.all(np.array(self.mjc_model.jnt_type) ==
3): # 3 stands for revolute joint
raise Exception('Revolute joints are assumed')
self.n_joints = len(self.joint_dict.items())
# Initialize simulator
self.simulation = mjc.MjSim(self.mjc_model)
self.viewer = mjc.MjViewer(self.simulation)
'''
def __init__(self, model_path):
self.model = mjp.load_model_from_path(model_path)
self.sim = mjp.MjSim(self.model)
self._controllable_joints = self.get_controllable_joints()
self._all_joints = [
self.model.joint_name2id(j) for j in self.model.joint_names
]
def create_sim(collision=False):
if collision:
model_filename = 'full_kuka_mesh_collision.xml'
else:
model_filename = 'full_kuka_no_collision.xml'
model_path = os.path.join(kuka_asset_dir(), model_filename)
model = mujoco_py.load_model_from_path(model_path)
sim = mujoco_py.MjSim(model)
return sim
def __init__(self, aliveBonus, deathPenalty, isTerminal):
self.aliveBonus = aliveBonus
self.deathPenalty = deathPenalty
self.isTerminal = isTerminal
modelName = 'inverted_double_pendulum'
model = mujoco.load_model_from_path('xmls/' + modelName + '.xml')
self.simulation = mujoco.MjSim(model)
self.numQPos = len(self.simulation.data.qpos)
self.numQVel = len(self.simulation.data.qvel)
def __init__(self, model_path, initial_qpos, n_actions, n_substeps):
if model_path.startswith('/'):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), 'assets',
model_path)
if not os.path.exists(fullpath):
raise IOError('File {} does not exist'.format(fullpath))
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model, nsubsteps=n_substeps)
#self.viewer = None # comment when using "human"
self.viewer = mujoco_py.MjViewer(
self.sim) #comment when using "rgb_array"
self._viewers = {}
self.modder = TextureModder(self.sim)
self.visual_randomize = True
self.mat_modder = MaterialModder(self.sim)
self.light_modder = LightModder(self.sim)
self.metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': int(np.round(1.0 / self.dt))
}
self.visual_data_recording = True
self._index = 0
self._label_matrix = []
self.seed()
self._env_setup(initial_qpos=initial_qpos)
self.initial_state = copy.deepcopy(self.sim.get_state())
self.goal = self._sample_goal()
obs = self._get_obs()
self.action_space = spaces.Box(-1.,
1.,
shape=(n_actions, ),
dtype='float32')
self.observation_space = spaces.Dict(
dict(
desired_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
achieved_goal=spaces.Box(-np.inf,
np.inf,
shape=obs['achieved_goal'].shape,
dtype='float32'),
observation=spaces.Box(-np.inf,
np.inf,
shape=obs['observation'].shape,
dtype='float32'),
))
if self.viewer:
self._viewer_setup()
def load_env(self, num):
if num < len(self.env_paths):
new_scene = self.env_paths[num]
scene = mujoco_py.load_model_from_path(new_scene)
self.env = mujoco_py.MjSim(scene)
if self.is_vis:
self.viewer = mujoco_py.MjViewer(self.env)
else:
print("Wrong number,")
def __init__(self):
"""Initializes a new Fetch environment."""
initial_qpos = {
"robot0:slide0": 0.4049,
"robot0:slide1": 0.48,
"robot0:slide2": 0.0,
}
model_path = MODEL_XML_PATH
n_substeps = 20
self.target_min = 0.15
self.target_max = 0.2
self.target_range = self.target_max - self.target_min
self.obj_min = 0.05
self.obj_max = 0.1
self.obj_range = self.obj_max - self.obj_min
self.gripper_extra_height = 0.2
self.target_offset = 0.0
self.distance_threshold = 0.05
self.use_penalty = True
if model_path.startswith("/"):
fullpath = model_path
else:
fullpath = os.path.join(os.path.dirname(__file__), "assets",
model_path)
if not os.path.exists(fullpath):
raise IOError("File {} does not exist".format(fullpath))
model = mujoco_py.load_model_from_path(fullpath)
self.sim = mujoco_py.MjSim(model, nsubsteps=n_substeps)
self.viewer = None
self._viewers = {}
self.metadata = {
"render.modes": ["human", "rgb_array"],
"video.frames_per_second": int(np.round(1.0 / self.dt)),
}
self.seed()
self._env_setup(initial_qpos=initial_qpos)
self.initial_state = copy.deepcopy(self.sim.get_state())
self.goal = self._sample_goal()
self.stack_pos = self._sample_stack_pos()
obs = self._get_obs()
self.action_space = spaces.Box(-1.0, 1.0, shape=(3, ), dtype="float32")
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=obs.shape,
dtype="float32")
utils.EzPickle.__init__(self)
