def __init__(self, verbose=0):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.slowness = 0
"""
Action Space:
1) Steer: Discrete 3 - NOOP[0], Left[1], Right[2] - params: min: 0, max: 2
2) Gas: Discrete 2 - NOOP[0], Go[1] - params: min: 0, max: 1
3) Brake: Discrete 2 - NOOP[0], Brake[1] - params: min: 0, max: 1
Observation Space:
1) Speed: SPEED_INTERVALS + 1 discrete speeds
2) Sensors: RAY_CAST_INTERVALS * NUM_SENSORS
3) Wheel off or not ( for each wheel): 2
4) Steering: STEER_INTERVALS
"""
self.set_action_space()
self.set_observation_space()
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.terrain_y_values = np.array([
8.2805, 4.7387, 6.4994, 6.6547, 3.3333, 3.3333, 3.3333, 2.2976,
6.0295, 7.0200, 5.5859
]) # self.np_random.uniform(0, 400/60, size=(12,) )
self.goal_x = len(self.terrain_y_values) // 2
self.lander_initial_x = VIEWPORT_W / SCALE / 2
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(8, ),
dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
gaussian = np.random.normal(FRICTION, 0.2, 1000)
self.friction_values = gaussian[(gaussian > 0.1) & (gaussian < 1.0)]
self.friction_change = random.randrange(5, 15) / 10.0
#plt.hist(self.friction_values, 10)
#plt.show()
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self, verbose=0, obstacles = False):
EzPickle.__init__(self)
self.SI = SI(env = self, car_shape = (4,8), image_shape = (STATE_W, STATE_H), render_distance = 40, road_width = 40/6, fill = True, interpolate = True, obstacles = obstacles)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.steps = 0
self.n_obstacles = 10
self.obstacles = obstacles
self.dim_obstacles = (0.5,0.5)
self.collision_threshold = 0.1 #1m distance between obstacle and vehicle
self.COLLISION = False
self.fd_tile = fixtureDef(shape=polygonShape(vertices=[(0, 0), (1, 0), (1, -1), (0, -1)])) # The fd_tile variable defines the fixture with the shape defined as a rectangle with coordinates
# [(0, 0) | (1, 0)]
# [(0,-1) | (1,-1)]
self.action_space = spaces.Box(np.array([-1, 0, 0]), np.array([+1, +1, +1]), dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
self.R = lambda x,y,angle: [x*np.cos(angle) - y*np.sin(angle), y*np.cos(angle) + x*np.sin(angle)]
def __init__(self, verbose=1, lap_complete_percent=0.95):
EzPickle.__init__(self)
pygame.init()
self.contactListener_keepref = FrictionDetector(
self, lap_complete_percent)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.screen = None
self.clock = None
self.isopen = True
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.new_lap = False
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
# This will throw a warning in tests/envs/test_envs in utils/env_checker.py as the space is not symmetric
# or normalised however this is not possible here so ignore
self.action_space = spaces.Box(
np.array([-1, 0, 0]).astype(np.float32),
np.array([+1, +1, +1]).astype(np.float32),
) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(8,), dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2,), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self, verbose=1, **kwargs):
EzPickle.__init__(self)
self.seed()
self.road_color = ROAD_COLOR[:]
self.grass_color = [0.4, 0.8, 0.4, 1]
if 'modification' in kwargs:
self._modification_type = kwargs['modification']
else:
self._modification_type = ''
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(
shape = polygonShape(vertices=
[(0, 0),(1, 0),(1, -1),(0, -1)]))
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]), dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
self.step_cnt = 0
def __init__(self, n=8):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.n = n
# N sensors
self.observation_space = spaces.Box(-np.inf,
+np.inf,
shape=(n, ),
dtype=np.float32)
# N effecotrs
self.action_space = spaces.Box(0, self.OMAX, (n, ), dtype=np.float32)
# Set up so that index 0 corresponds to position 1 in Figure 7a
self.angles = 2 * np.pi / n * np.array([n] + list(range(1, n)))
# Set up relative endpoints for rangefinders
self.rangefinder_points = [
self._polar_to_rect(self.WORLD_SIZE, angle)
for angle in self.angles
]
self.reset()
def __init__(self, continuous: bool = False):
EzPickle.__init__(self)
self.screen = None
self.clock = None
self.isopen = True
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
self.continuous = continuous
self.lift_off = False
self.time_horizont = 1000
self.step_counter = 0
self.minimal_distance = 0.3
self.np_random = np.random
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(8, ),
dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
def __init__(self,
goal_reward=10,
actuation_cost_coeff=30.0,
distance_cost_coeff=1.0,
init_sigma=0.1):
EzPickle.__init__(**locals())
self.dynamics = PointDynamics(dim=2, sigma=0)
self.init_mu = np.zeros(2, dtype=np.float32)
self.init_sigma = init_sigma
self.goal_positions = np.array(
(
(5, 0),
(-5, 0),
(0, 5),
(0, -5)
),
dtype=np.float32)
self.goal_threshold = 0.1 #1.0
self.goal_reward = goal_reward
self.action_cost_coeff = actuation_cost_coeff
self.distance_cost_coeff = distance_cost_coeff
self.xlim = (-7, 7)
self.ylim = (-7, 7)
self.vel_bound = 1.
self.reset()
self.observation = None
self._ax = None
self._env_lines = []
self.fixed_plots = None
self.dynamic_plots = []
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.track_steps = 0
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.car_actions = (
np.array([-1.0, 0.0, 0.0]), # 1. Full Left
np.array([+1.0, 0.0, 0.0]), # 2. Full Right
np.array([-0.5, +0.5, 0.0]), # 3. Half Left, Half Acceleration
np.array([+0.5, +0.5, 0.0]), # 4. Half Right, Half Acceleration
np.array([0.0, +1.0, 0.0]), # 5. Full Acceleration
np.array([0.0, +0.5, 0.0]), # 6. Half Acceleration
# np.array([0.0, 0.0, 0.6]), # 7. 60% Brake
np.array([0.0, 0.0, 0.3]), # 8. 30% Brake
)
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self, hardcore: bool = False):
EzPickle.__init__(self)
self.screen = None
self.isopen = True
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.hardcore = hardcore
self.fd_polygon = fixtureDef(
shape=polygonShape(vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]),
friction=FRICTION,
)
self.fd_edge = fixtureDef(
shape=edgeShape(vertices=[(0, 0), (1, 1)]),
friction=FRICTION,
categoryBits=0x0001,
)
high = np.array([np.inf] * 24).astype(np.float32)
self.action_space = spaces.Box(
np.array([-1, -1, -1, -1]).astype(np.float32),
np.array([1, 1, 1, 1]).astype(np.float32),
)
self.observation_space = spaces.Box(-high, high)
def __init__(self, action, reward_type="sparse", **kwargs):
from ml_logger import logger
logger.upload_file(__file__)
self.action = action
self.initial_qpos = {
'robot0:slide0': 0.405,
'robot0:slide1': 0.48,
'robot0:slide2': 0.0,
'bin:joint': [1.25, 0.53, 0.4, 0, 0., 0., 0.],
# use same location to correct set the target height
'object0:joint': [1.25, 0.53, 0.6, 0, 0., 0., 0.],
# 'object0:joint': [1.25, 0.95 if "place" in action else 0.53, 1, 1, 0., 0., 0.],
}
_kwargs = dict(
obj_keys=("bin", "object0"),
obs_keys=("object0",),
goal_key="object0",
block_gripper=False, n_substeps=20,
gripper_extra_height=0.2,
target_in_the_air=True,
target_offset=0.0,
obj_range=0.15,
target_range=0.15,
distance_threshold=0.05,
initial_qpos=self.initial_qpos,
reward_type=reward_type
)
_kwargs.update(kwargs)
fetch_env.FetchEnv.__init__(self, "bin.xml", **_kwargs)
EzPickle.__init__(self)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.fd_polygon = fixtureDef(
shape=polygonShape(vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]),
friction=FRICTION)
self.fd_edge = fixtureDef(
shape=edgeShape(vertices=[(0, 0), (1, 1)]),
friction=FRICTION,
categoryBits=0x0001,
)
self.reset()
high = np.array([np.inf] * 24)
self.action_space = spaces.Box(np.array([-1, -1, -1, -1]),
np.array([1, 1, 1, 1]),
dtype=np.float32)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(
np.array([-1, 0, 0]).astype(np.float32),
np.array([+1, +1, +1]).astype(np.float32)) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self, gene, World):
EzPickle.__init__(self)
self.seed()
self.world = World.world
self.steps = 0
self.prev_loc = None
self.MOTORS_TORQUE, self.SPEED_HIP, self.SPEED_KNEE, self.HULL_H, self.HULL_W = gene
self.FACE_H = self.HULL_H * FACE_HULL_SCALE
self.FACE_W = self.HULL_W * FACE_HULL_SCALE
# self.terrain = terrain
self.hull = None
self.face = None
self.prev_shaping = None
high = np.array([np.inf] * 24)
self.action_space = spaces.Box(np.array(
[-1, -1, -1, -1, -1, -1, -1, -1]),
np.array([1, 1, 1, 1, 1, 1, 1, 1]),
dtype=np.float32)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
self.total_reward = 0
self.a = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
self.state = STAY_ON_ONE_LEG
self.moving_leg = 0
self.supporting_leg = 1 - self.moving_leg
self.supporting_knee_angle = SUPPORT_KNEE_ANGLE
self.done = False
self.reset()
def __init__(self, observation_size, action_size,
initial_random_force=30,
out_of_bounds_penalty=100,
max_steps=1000,
max_angle=45,
bounds=10,
initial_altitude=10):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.pose = None
self.action_size = action_size
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
+np.inf,
shape=(observation_size,),
dtype=np.float32)
# Action is two floats [throttle, roll]
self.action_space = spaces.Box(-1,
+1,
(action_size,),
dtype=np.float32)
# Pre-convert max-angle degrees to radians
self.max_angle = np.radians(max_angle)
# Grab remaining settings
self.initial_random_force = initial_random_force
self.out_of_bounds_penalty = out_of_bounds_penalty
self.max_steps = max_steps
self.bounds = bounds
self.initial_altitude = initial_altitude
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(8, ),
dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self, mode=NORMAL):
""" mode is the game mode: NORMAL, TRAIN_SHOOTING, TRAIN_DEFENSE,
it can be changed later using the reset function
"""
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.mode = mode
self.world = Box2D.b2World([0, 0])
self.player1 = None
self.player2 = None
self.puck = None
self.goal_player_1 = None
self.goal_player_2 = None
self.world_objects = []
self.drawlist = []
self.done = False
self.winner = 0
self.one_starts = True # player one starts the game (alternating)
self.max_puck_speed = 20
self.timeStep = 1.0 / FPS
self.time = 0
self.max_timesteps = 500
self.closest_to_goal_dist = 1000
# 0 x pos player one
# 1 y pos player one
# 2 sin(angle player one)
# 3 cos(angle player one)
# 4 x vel player one
# 5 y vel player one
# 6 angular vel player one
# 7 x player two
# 8 y player two
# 9 sin(angle player two)
# 10 cos(angle player two)
# 11 y vel player two
# 12 y vel player two
# 13 angular vel player two
# 14 x pos puck
# 15 y pos puck
# 16 x vel puck
# 17 y vel puck
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(18, ),
dtype=np.float32)
# linear force in (x,y)-direction and torque
self.action_space = spaces.Box(-1, +1, (3 * 2, ), dtype=np.float32)
# see discrete_to_continous_action()
self.discrete_action_space = spaces.Discrete(7)
self.reset(self.one_starts)
def __init__(self, **kwargs):
default_kwargs = dict(arm='both',
block_gripper=False,
reward_type='sparse',
distance_threshold=0.05)
merged = {**default_kwargs, **kwargs}
super().__init__(task=YumiTask.PICK_AND_PLACE_BAR, **merged)
EzPickle.__init__(self)
def __init__(self, **kwargs):
default_kwargs = dict(block_gripper=False)
merged = {**default_kwargs, **kwargs}
super().__init__(task=YumiTask.LIFT_ABOVE_TABLE,
arm='both',
reward_type='dense',
**merged)
EzPickle.__init__(self)
def __init__(self, map_size, minimap_mode, reward_args, max_cycles):
EzPickle.__init__(self, map_size, minimap_mode, reward_args, max_cycles)
assert map_size >= 16, "size of map must be at least 16"
env = magent.GridWorld(load_config(map_size, minimap_mode, **reward_args))
reward_vals = np.array([KILL_REWARD] + list(reward_args.values()))
reward_range = [np.minimum(reward_vals, 0).sum(), np.maximum(reward_vals, 0).sum()]
names = ["redmelee", "redranged", "bluemele", "blueranged"]
super().__init__(env, env.get_handles(), names, map_size, max_cycles, reward_range, minimap_mode)
def __init__(self, map_size, minimap_mode, reward_args, max_cycles):
EzPickle.__init__(self, map_size, minimap_mode, reward_args, max_cycles)
env = magent.GridWorld(load_config(map_size, minimap_mode, **reward_args))
handles = env.get_handles()
reward_vals = np.array([5] + list(reward_args.values()))
reward_range = [np.minimum(reward_vals, 0).sum(), np.maximum(reward_vals, 0).sum()]
names = ["omnivore"]
super().__init__(env, handles[1:], names, map_size, max_cycles, reward_range, minimap_mode)
def __init__(self, map_size, max_frames, seed):
EzPickle.__init__(self, map_size, max_frames, seed)
env = magent.GridWorld(get_config(map_size), map_size=map_size)
handles = env.get_handles()
names = ["deer", "tiger"]
super().__init__(env, handles, names, map_size, max_frames, seed)
def __init__(self, map_size, reward_args, max_frames, seed):
EzPickle.__init__(self, map_size, reward_args, max_frames, seed)
env = magent.GridWorld(get_config(map_size, **reward_args), map_size=map_size)
handles = env.get_handles()
names = ["predator", "prey"]
super().__init__(env, handles, names, map_size, max_frames, seed)
def __init__(self, map_size, reward_args, max_frames):
EzPickle.__init__(self, map_size, reward_args, max_frames)
env = magent.GridWorld(get_config(map_size, **reward_args),
map_size=map_size)
self.leftID = 0
self.rightID = 1
names = ["red", "blue"]
super().__init__(env, env.get_handles(), names, map_size, max_frames)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.landers = None
self.particles = []
def __init__(self, settings_file_path):
EzPickle.__init__(self)
self._settings = json.load(open(settings_file_path))
# load env resources
self._data_loader = DataSupporter(self._settings)
# init world
self.seed()
self.contactListener_keepref = RefactoredContactListener(self)
self.world = Box2D.b2World((0, 0), contactListener=self.contactListener_keepref)
self._was_done: bool = False
self._init_world()
# init agent data
self.car = None
self.rewarder = Rewarder(self._settings)
# init bots data
self.num_bots = self._settings['bot_number']
self.bot_cars = []
self._preseted_agent_track = None
self._preseted_render_mode = 'human'
# init gym properties
self.picture_state = np.zeros_like(self._data_loader.get_background(), dtype=np.uint8)
self.action_space = spaces.Box(
low=np.array([-1.0, -1.0, -1.0]),
high=np.array([+1.0, +1.0, +1.0]),
dtype=np.float32
) # steer, gas, brake
test_car = DummyCar(
world=self.world,
car_image=self._data_loader.peek_car_image(is_for_agent=True),
track=DataSupporter.do_with_points(
self._data_loader.peek_track(is_for_agent=True, expand_points=200, index=self._preseted_agent_track),
self._data_loader.convertIMG2PLAY,
),
data_loader=self._data_loader,
bot=False,
)
self.observation_space = spaces.Dict(
picture=spaces.Box(
low=0,
high=255,
shape=self._data_loader.get_background().shape,
dtype=np.uint8,
),
vector=spaces.Box(
low=-5,
high=+5,
shape=(len(test_car.get_vector_state()), ),
dtype=np.float32,
),
)
self.reset()
def __init__(self, knock_reward: float = 0.5, gin_reward: float = 1.0, opponents_hand_visible=False):
EzPickle.__init__(self, knock_reward, gin_reward)
self._opponents_hand_visible = opponents_hand_visible
num_planes = 5 if self._opponents_hand_visible else 4
RLCardBase.__init__(self, "gin-rummy", 2, (num_planes, 52))
self._knock_reward = knock_reward
self._gin_reward = gin_reward
self.env.game.judge.scorer.get_payoff = self._get_payoff
def __init__(self, reward_type='sparse'):
"""Initializes a new myUR5Gripper environment.
Args:
model_path (string): path to the environments XML file
n_substeps (int): number of substeps the simulation runs on every call to step
gripper_extra_height (float): additional height above the table when positioning the gripper
block_gripper (boolean): whether or not the gripper is blocked (i.e. not movable) or not
has_object (boolean): whether or not the environment has an object
target_in_the_air (boolean): whether or not the target should be in the air above the table or on the table surface
target_offset (float or array with 3 elements): offset of the target
obj_range (float): range of a uniform distribution for sampling initial object positions
target_range (float): range of a uniform distribution for sampling a target
distance_threshold (float): the threshold after which a goal is considered achieved
initial_qpos (dict): a dictionary of joint names and values that define the initial configuration
reward_type ('sparse' or 'dense'): the reward type, i.e. sparse or dense
"""
# TODO: Requirements for .xml:
# mocap body in worldbody
# target body in worldbody
# finder body welded to mocap body in equality
# configured initial position of joints such that all joints are reachable
# TODO: Init configs
self.gripper_extra_height = 0.
self.block_gripper = True
self.has_object = False
self.target_in_the_air = False
self.target_offset = 0.
self.obj_range = 0.
self.target_range = 0.8 #default:0.2
self.distance_threshold = 0.15 #default 0.05
self.reward_type = reward_type
self.mocap_name = 'robot:mocap' # type body
self.target_name = 'target0' # type body
self.finder_name = 'tool0' #'wrist_1_link' # type body
self.ref_name = 'gripperfinger_middle_link_3'
self.object_name = "object0"
n_substeps = 20
model_path = os.path.join('myUR5Gripper', 'myUR5gripper_fall.xml')
initial_qpos = {
'robot:wrist_2_joint': -1.57,
'robot:shoulder_pan_joint': 0.0,
'robot:shoulder_lift_joint': -0.6,
'robot:elbow_joint': 1.1,
#'wrist_1_joint': -0.7,
#'wrist_2_joint': 1.57,
#'gripperfinger_1_joint_1': 0.0,
#'gripperfinger_middle_joint_1': 0.0,
#'gripperpalm_finger_1_joint': 0.0,
}
# TODO: update myUR5<>env
super(myUR5GripperFallEnv, self).__init__(model_path=model_path,
n_substeps=n_substeps,
n_actions=4,
initial_qpos=initial_qpos)
EzPickle.__init__(self)
def __init__(self):
EzPickle.__init__(self) # TODO: not sure if this is still needed...
self.seed() # TODO: not sure if this is still needed...
self.viewer = None
# Define our grid map dimensions
self.map_height = 20
self.map_width = 20
self.scale = VIEWPORT_W / self.map_width
# observation space
self.robot_pos = (0, 0)
self.task_to_do = Tasks.to_binary_list(0)
self.vision_grid = np.zeros(48)
self.states = {'cabinet_open': 0, 'has_tea': 0, 'has_soup_jar': 0, 'fire_on': 0, 'tap_open': 0,
'holding_saucepan': 0, 'saucepan_full': 0, 'heated_up': 0, 'has_boiling_water': 0,
'has_cleaning_cloth': 0, 'has_cleaning_product': 0, 'stove_cleaned': 0,
'has_pasta': 0, 'has_sauce': 0, 'pasta_drained': 0, 'item_cooked': 0,
'has_eggs': 0, 'has_milk': 0, 'has_pancake_mix': 0, 'holding_frying_pan': 0,
'whisked': 0, 'rinsed': 0}
self.action_dict = {0: self._move_up,
1: self._move_down,
2: self._move_left,
3: self._move_right,
4: self._open_door,
5: self._close_door,
6: self._get_tea,
7: self._get_soup_jar,
8: self._get_saucepan,
9: self._get_cleaning_cloth,
10: self._get_cleaning_product,
11: self._get_pasta,
12: self._get_sauce,
13: self._turn_on_heat,
14: self._turn_off_heat,
15: self._heat_up,
16: self._open_tap,
17: self._close_tap,
18: self._fill,
19: self._rinse_and_dry,
20: self._scrub,
21: self._drain,
22: self._mix,
23: self._get_eggs,
24: self._get_milk,
25: self._get_pancake_mix,
26: self._get_frying_pan,
27: self._whisk,
28: self._flip
}
self.reset()
# Min-Max values for states
low = np.zeros(29) # 2(pos) + 22 + 5 task enc
high = np.hstack((np.array([19, 19]), np.ones(27)))
self.action_space = spaces.Discrete(29)
self.observation_space = spaces.Box(low, high, dtype=np.int)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]), dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
