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)