def play(): np.random.seed(1351) # 1348, 1351 register( id='Osokoban-v0', entry_point='mygym.osokoban:OsokobanEnv', timestep_limit=1000) env = gym.make('Osokoban-v0') # env.shape = (4, 4) # env.walls_lim = (0, 1) # env.diamonds_lim = (0, 1) env.reset() history = get_history(env, 500) cves = history_to_cves(env, history) abstract_cves = get_abstract_cves(cves) print 'cves:', len(cves) print 'abstract cves:', len(abstract_cves) print 'ideas:', len(OsokobanEnv.MapChars) oracle = Oracle(cves, SpatialVectorsCount) print # play_with_user_oracle(env, history, oracle) metaoracle = MetaOracle(oracle)
def _build_env(self): frozen_lake = 'FrozenLakeNonSlippery4x4-v0' try: spec(frozen_lake) except: register(id=frozen_lake, entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={'map_name': '4x4', 'is_slippery': False}) return gym.make(frozen_lake)
def pass_params_to_gym(env_name): global env_version_num register( id=env_name, entry_point='ray.rllib.examples:' + "MultiAgentMountainCarEnv", max_episode_steps=200, kwargs={} )
def get_random_opponent_env(): """Registers and makes a 9x9 hex env, exactly like the standard but a bit easier to see what's going on.""" register( id='PrettyHex9x9-random-v0', entry_point='prettyhex:PrettyHexEnv', kwargs={ 'player_color': 'black', 'observation_type': 'numpy3c', 'opponent': 'random', # apart from here 'illegal_move_mode': 'raise', # and here for debugging 'board_size': 9 } ) return gym.make('PrettyHex9x9-random-v0')
def get_human_opponent_env(): """Registers and makes a 9x9 hex environment with the above function that prompts for input as opponent""" # this part is pretty much the same as gym.envs.__init__.py register( id='PrettyHex9x9-human-v0', entry_point='prettyhex:PrettyHexEnv', kwargs={ 'player_color': 'black', 'observation_type': 'numpy3c', 'opponent': human_text_policy, # apart from here 'illegal_move_mode': 'raise', # and here for debugging 'board_size': 9 } ) return gym.make('PrettyHex9x9-human-v0')
def register_custom_environments(): from gym.envs.registration import register MAX_STEPS = 1000 register( id='SilverstoneRacetrack-v0', entry_point='custom_files.silverstone_racetrack_env:SilverstoneRacetrackEnv', max_episode_steps=MAX_STEPS, reward_threshold=200 ) register( id='SilverstoneRacetrack-Discrete-v0', entry_point='custom_files.silverstone_racetrack_env:SilverstoneRacetrackDiscreteEnv', max_episode_steps=MAX_STEPS, reward_threshold=200 ) register( id='SilverstoneRacetrack-MultiDiscrete-v0', entry_point='custom_files.silverstone_racetrack_env:SilverstoneRacetrackMultiDiscreteEnv', max_episode_steps=MAX_STEPS, reward_threshold=200 )
phase = sys.argv[2] learning_rate = float(sys.argv[3]) layer_width = int(sys.argv[4]) num_sensors = int(sys.argv[5]) recordname = '_'.join([modeldir, phase]) print('experiment id:{}'.format(recordname)) solarrecord = simple_solar_env.emulate_solar_ts(365) solarfname = 'training_12' solarrecord = solar_sensor_env.get_generated_power(solarfname) monthrecord = get_month(solarrecord, 8) register(id='SolarGraphSensor-v0', entry_point='solar_sensor_env:GoodGraphSensorEnv', kwargs={ 'max_batt': 1, 'num_sensors': num_sensors, 'deltat': 3, 'solarpowerrecord': monthrecord, 'recordname': recordname, 'coordinate_generator': random_graph.generate_sorted_grid_coords }) env = gym.make('SolarGraphSensor-v0') agent = ddqlearner.DDQNAgent(env, n_episodes=5000, max_env_steps=300 * 8, modeldir=loadmodel, decay_rate=0.99999975, learning_rate=learning_rate, layer_width=layer_width) #agent = ddqlearner.DDQNAgent(env,n_episodes = 400, max_env_steps=300*8, modeldir=loadmodel,decay_rate = 0.01, learning_rate = learning_rate, layer_width=layer_width) #agent = ddqlearner.DDQNAgent(env,n_episodes = 5000, max_env_steps=300*8, modeldir=loadmodel,decay_rate = 0.99999975, learning_rate = learning_rate, layer_width=layer_width)
from gym.envs.registration import registry, register, make, spec # Algorithmic # ---------------------------------------- register( id='Copy-v0', entry_point='gym.envs.algorithmic:CopyEnv', max_episode_steps=200, reward_threshold=25.0, ) register( id='RepeatCopy-v0', entry_point='gym.envs.algorithmic:RepeatCopyEnv', max_episode_steps=200, reward_threshold=75.0, ) register( id='ReversedAddition-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows' : 2}, max_episode_steps=200, reward_threshold=25.0, ) register( id='ReversedAddition3-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows' : 3},
from gym.envs.registration import register register( id='LunarOrbiter-v0', entry_point='gym_lunar_orbiter.envs:LunarOrbiter', max_episode_steps=1000, reward_threshold=200, )
from gym.envs.registration import registry, register, make, spec # ------------bullet------------- register( id='MinitaurBulletEnv-v0', entry_point='pybullet_envs.bullet:MinitaurBulletEnv', timestep_limit=1000, reward_threshold=5.0, ) register( id='MinitaurBulletDuckEnv-v0', entry_point='pybullet_envs.bullet:MinitaurBulletDuckEnv', timestep_limit=1000, reward_threshold=5.0, ) register( id='RacecarBulletEnv-v0', entry_point='pybullet_envs.bullet:RacecarGymEnv', timestep_limit=1000, reward_threshold=5.0, ) register( id='RacecarZedBulletEnv-v0', entry_point='pybullet_envs.bullet:RacecarZEDGymEnv', timestep_limit=1000, reward_threshold=5.0,
# Deprecated environments. We want to keep around the old environment # specifications, though they may no longer be possible to # instantiate. from gym.envs.registration import register # MuJoCo register(id='Reacher-v0', timestep_limit=50) register(id='InvertedPendulum-v0', ) register(id='InvertedDoublePendulum-v0', ) register(id='HalfCheetah-v0', ) register(id='Hopper-v0', ) register(id='Swimmer-v0', ) register(id='Walker2d-v0', ) register(id='Ant-v0', ) register(id='Humanoid-v0', )
# Deprecated environments. We want to keep around the old environment # specifications, though they may no longer be possible to # instantiate. from gym.envs.registration import register # MuJoCo register( id='Reacher-v0', timestep_limit=50 ) register( id='InvertedPendulum-v0', ) register( id='InvertedDoublePendulum-v0', ) register( id='HalfCheetah-v0', ) register( id='Hopper-v0', ) register( id='Swimmer-v0',
"""Highway scenario with continuous behavior model. Behavior model takes the steering-rate and acceleration. """ def __init__(self): params = ParameterServer(filename=os.path.join( os.path.dirname(__file__), "../environments/blueprints/visualization_params.json")) cont_highway_bp = ContinuousSingleLaneBlueprint(params) SingleAgentRuntime.__init__(self, blueprint=cont_highway_bp, render=True) # register gym envs register(id='highway-v0', entry_point='bark_ml.environments.gym:ContinuousHighwayGym') register(id='highway-v1', entry_point='bark_ml.environments.gym:DiscreteHighwayGym') register(id='merging-v0', entry_point='bark_ml.environments.gym:ContinuousMergingGym') register(id='merging-medium-v0', entry_point='bark_ml.environments.gym:MediumContinuousMergingGym') register(id='merging-v1', entry_point='bark_ml.environments.gym:DiscreteMergingGym') register(id='intersection-v0', entry_point='bark_ml.environments.gym:ContinuousIntersectionGym') register(id='intersection-v1', entry_point='bark_ml.environments.gym:DiscreteIntersectionGym') register(id='singlelane-v0', entry_point='bark_ml.environments.gym:ContinuousSingleLaneGym')
from gym.envs.registration import register register( id='underwater-v0', entry_point='gym_underwater.envs:UnderwaterEnv', )
from gazebo_msgs.srv import GetModelState from gazebo_msgs.srv import SetModelState from gazebo_msgs.srv import GetLinkState from geometry_msgs.msg import Point, Quaternion, Vector3 from gazebo_msgs.msg import ModelState from geometry_msgs.msg import Pose from geometry_msgs.msg import Point from openai_ros.msg import RLExperimentInfo from simulation.msg import VacuumGripperState from simulation.srv import VacuumGripperControl # REGISTER THE TRAININGS ENVIRONMENT IN THE GYM AS AN AVAILABLE ONE reg = register( id='Pickbot-v3', entry_point='environments.pickbot_withgripper_env_continuous:PickbotEnv', timestep_limit=120, ) # DEFINE ENVIRONMENT CLASS class PickbotEnv(gym.Env): def __init__(self, joint_increment_value=0.02, running_step=0.001): """ initializing all the relevant variables and connections """ # Assign Parameters self._joint_increment_value = joint_increment_value self.running_step = running_step
import logging from gym.envs.registration import register logger = logging.getLogger(__name__) register( id='TicTacToe-v0', entry_point='gym_tictactoe.envs:TicTacToeEnv', timestep_limit=10, reward_threshold=1.0, nondeterministic=True, )
from gym.envs.registration import register register( id='boring_conversation-v0', entry_point='gym_boring_conversation.envs:Boring_conversationEnv', )
''' Copyright (C) 2019 Simon D. Levy MIT License ''' from gym.envs.registration import register register(id='Lander-v0', entry_point='gym_copter.envs:Lander2D', max_episode_steps=2000) register(id='Lander3D-v0', entry_point='gym_copter.envs:Lander3D', max_episode_steps=2000) register(id='Lander3DHardCore-v0', entry_point='gym_copter.envs:Lander3DHardCore', max_episode_steps=2000)
vehicles_type = utils.class_from_path( self.config["other_vehicles_type"]) for i in range(3): self.road.vehicles.append( vehicles_type( road, position=road.network.get_lane(("a", "b", 1)).position( 70 + 40 * i + 10 * self.np_random.randn(), 0), heading=road.network.get_lane( ("a", "b", 1)).heading_at(70 + 40 * i), velocity=24 + 2 * self.np_random.randn(), enable_lane_change=False)) for i in range(2): v = vehicles_type( road, position=road.network.get_lane( ("b", "a", 0)).position(200 + 100 * i + 10 * self.np_random.randn(), 0), heading=road.network.get_lane( ("b", "a", 0)).heading_at(200 + 100 * i), velocity=20 + 5 * self.np_random.randn(), enable_lane_change=False) v.target_lane_index = ("b", "a", 0) self.road.vehicles.append(v) register(id='two-way-v0', entry_point='highway_env.envs:TwoWayEnv', max_episode_steps=15)
from gym.envs.registration import registry, register, make, spec # Algorithmic # ---------------------------------------- register( id='Copy-v0', entry_point='gym.envs.algorithmic:CopyEnv', timestep_limit=200, reward_threshold=25.0, ) register( id='RepeatCopy-v0', entry_point='gym.envs.algorithmic:RepeatCopyEnv', timestep_limit=200, reward_threshold=75.0, ) register( id='ReversedAddition-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows' : 2}, timestep_limit=200, reward_threshold=25.0, ) register( id='ReversedAddition3-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows' : 3},
from gym.envs.registration import register register( id='CliffWalking-v0', entry_point='CliffWalking.envs:CliffWalkingEnv', )
from gym.envs.registration import register register( id='monopoly-v0', entry_point='gym_monopoly.envs:MonopolyEnv', kwargs={ 'player_decision_agents': {}, 'game_schema': "/media/shilpa/data/projects/gym-monopoly/examples/monopoly_game_schema_v1-2.json" }, )
#! /usr/bin/env python ############################################################################### # __init__.py # # initialization for the variable_pendulum OpenAI environment # # NOTE: Any plotting is set up for output, not viewing on screen. # So, it will likely be ugly on screen. The saved PDFs should look # better. # # Created: 07/07/17 # - Joshua Vaughan # - [email protected] # - http://www.ucs.louisiana.edu/~jev9637 # # Modified: # * # # TODO: # * ############################################################################### from gym.envs.registration import register register( id='variable_pendulum_continuous-v0', entry_point='variable_pendulum_continuous.variable_pendulum_continuous:VariablePendulumContEnv', )
self.config["other_vehicles_type"]) road.vehicles.append( other_vehicles_type(road, road.network.get_lane( ("a", "b", 0)).position(90, 0), speed=29)) road.vehicles.append( other_vehicles_type(road, road.network.get_lane( ("a", "b", 1)).position(70, 0), speed=31)) road.vehicles.append( other_vehicles_type(road, road.network.get_lane( ("a", "b", 0)).position(5, 0), speed=31.5)) merging_v = other_vehicles_type(road, road.network.get_lane( ("j", "k", 0)).position(110, 0), speed=20) merging_v.target_speed = 30 road.vehicles.append(merging_v) self.vehicle = ego_vehicle register( id='merge-v0', entry_point='highway_env.envs:MergeEnv', )
import matplotlib.pyplot as plt from gym.envs.registration import register import random as pr import readchar def rargmax(vector): m = np.amax(vector) indices = np.nonzero(vector == m)[0] return pr.choice(indices) # This is the original version, but not work on windows. # ........ register( id='FrozenLake-v3', entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={'map_name' : '4x4', 'is_slippery': False} ) env = gym.make('FrozenLake-v3') Q = np.zeros([env.observation_space.n, env.action_space.n]) dis = .99 num_episodes = 1000 rList = [] for i in range(num_episodes): state = env.reset() rAll = 0 done = False
#!/usr/bin/env python from gym.envs.registration import register register( id='pogrid-fo-84-v0', entry_point='gym_pogrid.envs:PoGridFO84', ) register( id='pogrid-fo-42-v0', entry_point='gym_pogrid.envs:PoGridFO42', )
#! /usr/bin/env python ############################################################################### # __init__.py # # initialization for the variable_pendulum OpenAI environment # # NOTE: Any plotting is set up for output, not viewing on screen. # So, it will likely be ugly on screen. The saved PDFs should look # better. # # Created: 07/07/17 # - Joshua Vaughan # - [email protected] # - http://www.ucs.louisiana.edu/~jev9637 # # Modified: # * # # TODO: # * ############################################################################### from gym.envs.registration import register register( id='planar_crane_feedback-v0', entry_point='planar_crane_feedback.planar_crane_feedback:PlanarCraneEnv', )
ACTION_DOWN: 'down', ACTION_RIGHT: 'right', ACTION_UP: 'up' } logger = logging.getLogger('log') logger.setLevel(logging.WARNING) np.random.seed(12321) MY_ENV_NAME='FrozenLakeNonSlippery4x4-v0' try: spec(MY_ENV_NAME) except: register( id=MY_ENV_NAME, entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={'map_name': '4x4', 'is_slippery': False}, ) env = gym.make(MY_ENV_NAME) NB_OBSERVATIONS = env.observation_space.n NB_ACTIONS = env.action_space.n def init_Q_table(nb_status, nb_actions): return DataFrame(np.zeros((nb_status, nb_actions))) def get_valid_actions(status): valid_actions = [ACTION_LEFT, ACTION_DOWN, ACTION_RIGHT, ACTION_UP] if status < 4: valid_actions.remove(ACTION_UP)
# register custom toribash environment from gym.envs.registration import register # Single Agent with access to full action space register(id='Toribash-SingleAgentToribash-v0', entry_point='gym_Toribash.envs:SingleAgentToribash', kwargs={ 'reward_func': 0, }) register(id='Toribash-SingleAgentToribash-v1', entry_point='gym_Toribash.envs:SingleAgentToribash', kwargs={ 'reward_func': 1, }) register(id='Toribash-SingleAgentToribash-v2', entry_point='gym_Toribash.envs:SingleAgentToribash', kwargs={ 'reward_func': 2, }) register(id='Toribash-SingleAgentToribash-v3', entry_point='gym_Toribash.envs:SingleAgentToribash', kwargs={ 'reward_func': 3, }) # Individual limbs register(id='Toribash-LeftLeg-v0', entry_point='gym_Toribash.envs:Left_Leg',
from BlockGameInterface import BlockGameEnv from CartPole3DInterface import CartPole3DEnv from Quadruped3DInterface import Quadruped3DEnv from Tennis3DInterface import Tennis3DEnv from gym.envs.registration import registry, register, make, spec # Games # ---------------------------------------- register( id='BlockGame-v0', entry_point='pypge.BlockGameInterface:BlockGameEnv', timestep_limit=1000 ) register( id='CartPole3D-v0', entry_point='pypge.CartPole3DInterface:CartPole3DEnv', timestep_limit=600 ) register( id='Quadruped3D-v0', entry_point='pypge.Quadruped3DInterface:Quadruped3DEnv', timestep_limit=600 ) register( id='Tennis3D-v0', entry_point='pypge.Tennis3DInterface:Tennis3DEnv', timestep_limit=600
from pandas.core.frame import DataFrame from envs import Portfolio2 as Portfolio from pathlib import Path DIR_PATH = Path(__file__).resolve().parent DATA_PATH = DIR_PATH / 'data' if __name__ == '__main__': # Constants INITIAL_CASH: int = 1_000 TRADING_PERIODS: int = 5 # Episode length TRANSACTION_COST: float = 1e-3 # Gym environment registration register(id='TradingEnv-v0', entry_point='envs:TradingEnv', max_episode_steps=TRADING_PERIODS) # Importing data data = pd.read_csv(DATA_PATH / 'sp500_closefull.csv', parse_dates=['Date'], index_col=['Date']) ptf_data: DataFrame = data[['AAPL', 'MSFT']] # Create portfolios ptf = Portfolio(INITIAL_CASH, ptf_data, TRADING_PERIODS, TRANSACTION_COST) # Environment instantiation env = gym.make('TradingEnv-v0', trader_portfolio=ptf, verbose=True) print(env.action_space.sample()) print(env.observation_space.sample()) env.reset() s1 = env.step([0.3, 0.7])
import logging from gym.envs.registration import register logger = logging.getLogger(__name__) register( id='cartpoleSwing-v0', entry_point='cartpole.envs:CartPoleContinous', reward_threshold=10000.0, nondeterministic = True, ) register( id='cartpoleSwingD-v0', entry_point='cartpole.envs:CartPoleDiscrete', reward_threshold=10000.0, nondeterministic = True, )
from gym.envs.registration import register MAX_STEPS = 1000 register( id='SageMaker-TurtleBot3-Discrete-v0', entry_point='robomaker.environments.object_tracker_env:TurtleBot3ObjectTrackerAndFollowerDiscreteEnv', max_episode_steps = MAX_STEPS, reward_threshold = 200 )
"""Initialize the env.stocks module""" from gym.envs.registration import registry, register, make, spec # Public classes from stock_gym.envs.stocks.basic import MarketEnv from stock_gym.envs.stocks.imarket import IMarketEnv register( id='MarketEnv-v0', entry_point='stock_gym.envs.stocks:MarketEnv', )
import gym import numpy as np from builtins import range from gym import spaces from gym.envs.registration import register from gym.utils import seeding from scipy.integrate import odeint import ifqi.utils.spaces as fqispaces register( id='CarOnHill-v0', entry_point='ifqi.envs.carOnHill:CarOnHill' ) class CarOnHill(gym.Env): """ The Car On Hill environment as presented in: "Tree-Based Batch Mode Reinforcement Learning, D. Ernst et. al." """ metadata = { 'render.modes': ['human', 'rgb_array'], 'video.frames_per_second': 15 } def __init__(self): self.horizon = 100
from gym.envs.registration import register register( id='LinkToThePastEnv-v0', entry_point='gym_alttp_gridworld.envs:LinkToThePastEnv', )
name = ''.join([g.capitalize() for g in game.split('_')]) if obs_type == 'ram': name = '{}-ram'.format(name) nondeterministic = False if game == 'elevator_action' and obs_type == 'ram': # ElevatorAction-ram-v0 seems to yield slightly # non-deterministic observations about 10% of the time. We # should track this down eventually, but for now we just # mark it as nondeterministic. nondeterministic = True register( id='Wrapped_{}-v0'.format(name), entry_point='Envs.AtariWrapper:AtariEnv', kwargs={'game_name': name, 'colours': False}, tags={'wrapper_config.TimeLimit.max_episode_steps': 100000}, nondeterministic=nondeterministic, ) # Grid world non slippery register( id="FrozenLake4x4_NoSlip-v0", entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={'map_name': '4x4', 'is_slippery': False}, tags={'wrapper_config.TimeLimit.max_episode_steps': 100}, reward_threshold=0.78, # optimum = .8196 ) for s in range(15): register(
from gym.envs.registration import registry, register, make, spec # Algorithmic # ---------------------------------------- register( id='Copy-v0', entry_point='gym.envs.algorithmic:CopyEnv', max_episode_steps=200, reward_threshold=25.0, ) register( id='RepeatCopy-v0', entry_point='gym.envs.algorithmic:RepeatCopyEnv', max_episode_steps=200, reward_threshold=75.0, ) register( id='ReversedAddition-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows': 2}, max_episode_steps=200, reward_threshold=25.0, ) register( id='ReversedAddition3-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows': 3},
from gym.envs.registration import registry, register, make, spec from blackjack import BlackjackEnv register( id='Blackjack-v0', entry_point='gym_nastics:BlackjackEnv', timestep_limit=200, reward_threshold=21.0, )
from gym.envs.registration import register from gym_pcgrl.envs.probs import PROBLEMS from gym_pcgrl.envs.reps import REPRESENTATIONS # Register all the problems with every different representation for the OpenAI GYM for prob in PROBLEMS.keys(): for rep in REPRESENTATIONS.keys(): register(id='{}-{}-v0'.format(prob, rep), entry_point='gym_pcgrl.envs:PcgrlEnv', kwargs={ "prob": prob, "rep": rep })
from gym.envs.registration import register register( id='MultiplayerLunarLander-v0', entry_point='sample_apps.gym_mp_lunarlander.envs:MultiplayerLunarLander', )
from gym.envs.registration import register import gym register(id='DyPushEnv-v0', entry_point='dygym.envs.robotics.push:DyPushEnv', max_episode_steps=200, kwargs={ 'direction': (0, 1, 0), 'velocity': 0.005 }) env = gym.make("DyPushEnv-v0") for i in range(10): env.reset() env.render() for i in range(50): action = env.action_space.sample() obs, reward, done, info = env.step(action) print(obs) env.render()
from gym.envs.registration import registry, register, make, spec # ------------bullet------------- register( id='CartPoleBulletEnv-v0', entry_point='envs.bullet:CartPoleBulletEnv', timestep_limit=1000, reward_threshold=950.0, ) register( id='MinitaurBulletEnv-v0', entry_point='envs.bullet:MinitaurBulletEnv', timestep_limit=1000, reward_threshold=5.0, )
from gym.envs.registration import register register( id='Babak-v0', entry_point='gym_game.envs:CustomEnv', max_episode_steps=2000, )
from gym.envs.registration import register import gym.spaces import networkx as nx import numpy as np import scipy.io as sio from absl import logging import gin import cv2 import label_map_util import visualization_utils as vis_util from envs import task_env register( id='active-vision-env-v0', entry_point= 'cognitive_planning.envs.active_vision_dataset_env:ActiveVisionDatasetEnv', # pylint: disable=line-too-long ) _MAX_DEPTH_VALUE = 12102 SUPPORTED_ACTIONS = [ 'right', 'rotate_cw', 'rotate_ccw', 'forward', 'left', 'backward', 'stop' ] SUPPORTED_MODALITIES = [ task_env.ModalityTypes.SEMANTIC_SEGMENTATION, task_env.ModalityTypes.DEPTH, task_env.ModalityTypes.OBJECT_DETECTION, task_env.ModalityTypes.IMAGE, task_env.ModalityTypes.GOAL, task_env.ModalityTypes.PREV_ACTION,
import numpy as np import gym import gym_microrts from gym.envs.registration import register from gym_microrts import Config gym_id = "GlobalAgentBinaryEnv" if gym_id not in gym.envs.registry.env_specs: register( gym_id + '-v0', entry_point=f'gym_microrts.envs:{gym_id}', kwargs={ 'config': Config( frame_skip=9, ai1_type="no-penalty", ai2_type="passive", map_path="maps/4x4/baseTwoWorkers4x4.xml", # below are dev properties microrts_path= "~/Documents/work/go/src/github.com/vwxyzjn/microrts", ) }) env = gym.make(gym_id + '-v0') print(gym_id) env.action_space.seed(0) try: obs = env.reset(True) env.render() except Exception as e: e.printStackTrace()
from gym.envs.registration import registry, register, make, spec # Make sure that deprecated environments are still registered. import gym.envs.deprecated # Algorithmic # ---------------------------------------- register( id='Copy-v0', entry_point='gym.envs.algorithmic:CopyEnv', timestep_limit=200, reward_threshold=25.0, ) register( id='RepeatCopy-v0', entry_point='gym.envs.algorithmic:RepeatCopyEnv', timestep_limit=200, reward_threshold=75.0, ) register( id='ReversedAddition-v0', entry_point='gym.envs.algorithmic:ReversedAdditionEnv', kwargs={'rows' : 2}, timestep_limit=200, reward_threshold=25.0, ) register(
# -*- coding: utf-8 -*- import gym from gym.envs.registration import register import sys import msvcrt LEFT = 0 DOWN = 1 RIGHT = 2 UP = 3 arrow_keys = {b'8': UP, b'2': DOWN, b'6': RIGHT, b'4': LEFT} register(id='FrozenLake-v3', entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={ 'map_name': '4x4', 'is_slippery': False }) env = gym.make('FrozenLake-v3') env.render() while True: key = msvcrt.getch() if key not in arrow_keys.keys(): print("Game aborted") break action = arrow_keys[key] state, reward, done, info = env.step(action) env.render() print("State: ", state, "Action: ", action, "Reward: ", reward, "Info: ", info)
import time import numpy as np import math import gym # Create a non-skid version of Frozen Lake from gym.envs.registration import register, spec MY_ENV_NAME='FrozenLakeNonskid8x8-v0' try: spec(MY_ENV_NAME) except: register( id=MY_ENV_NAME, entry_point='gym.envs.toy_text:FrozenLakeEnv', kwargs={'map_name': '8x8', 'is_slippery': False}, timestep_limit=100, reward_threshold=0.78, # optimum = .8196 ) env = gym.make(MY_ENV_NAME) # This helper is for later. def to_onehot(size,value): my_onehot = np.zeros((size)) my_onehot[value] = 1.0 return my_onehot OBSERVATION_SPACE = env.observation_space.n ACTION_SPACE = env.action_space.n
# Created by Giuseppe Paolo # Date: 11/09/2020 from gym.envs.registration import register register( id='RedundantArm-v0', entry_point='gym_redarm.envs:ArmEnv', # timestep_limit=1000, )
#! /usr/bin/env python ############################################################################### # __init__.py # # initialization for the variable_pendulum OpenAI environment # # NOTE: Any plotting is set up for output, not viewing on screen. # So, it will likely be ugly on screen. The saved PDFs should look # better. # # Created: 07/07/17 # - Joshua Vaughan # - [email protected] # - http://www.ucs.louisiana.edu/~jev9637 # # Modified: # * # # TODO: # * ############################################################################### from gym.envs.registration import register register( id='planar_crane-v0', entry_point='planar_crane.planar_crane:PlanarCraneEnv', )
self.agent.remember(state, action, reward, next_state, done, memory_current, memory_next) print(".", end="", flush=True) state = next_state index += 1 print() scores.append(index + 1) print(f"-> Score: {index+1}") print( f"-> Min Score: {np.min(scores):.0f}, Max Score: {np.max(scores):.0f}, Median Score: {np.median(scores):.0f}, Mean Score: {np.mean(scores):.2f}," ) self.agent.replay(self.sample_batch_size) if index_episode % 5 == 0: self.agent.refresh_target() print("-> Target refreshed!") print("===========================") finally: self.agent.save_model() if __name__ == "__main__": register( id='CartPole-v999', entry_point='env:CartPoleExtEnv', max_episode_steps=500, reward_threshold=475.0, ) cartpole = CartPole() cartpole.run()
from gym.envs.registration import register # ---------------------------------------- # drl_hw1 environments # ---------------------------------------- register( id='drl_hw1_point_mass-v0', entry_point='drl_hw1.envs:PointMassEnv', max_episode_steps=25, ) register( id='drl_hw1_swimmer-v0', entry_point='drl_hw1.envs:SwimmerEnv', max_episode_steps=500, ) register( id='drl_hw1_half_cheetah-v0', entry_point='drl_hw1.envs:HalfCheetahEnv', max_episode_steps=500, ) register( id='drl_hw1_ant-v0', entry_point='drl_hw1.envs:AntEnv', max_episode_steps=500, ) from drl_hw1.envs.mujoco_env import MujocoEnv
from gym.envs.registration import register from NeutronGame.neutron_util import Player, BoardTypes from NeutronRL.envs.neutron_env import Opponent register( id='Neutron-5x5-White-Random-v0', entry_point='NeutronRL.envs:NeutronEnv', kwargs={'board_type': BoardTypes.Board_5X5, 'player': Player.White, 'opponent': Opponent.Random}, max_episode_steps=2000 ) register( id='Neutron-5x5-White-Easy-v0', entry_point='NeutronRL.envs:NeutronEnv', kwargs={'board_type': BoardTypes.Board_5X5, 'player': Player.White, 'opponent': Opponent.Easy}, max_episode_steps=2000 )
from gym.envs.registration import register register( id='Didi-v0', entry_point='gym_Didi.envs:DidiEnv', )
from gym.envs.registration import register MAX_STEPS = 1000 register( id='SageMaker-DeepRacer-Discrete-v0', entry_point='robomaker.environments.deepracer_env:DeepRacerDiscreteEnv', max_episode_steps=MAX_STEPS, reward_threshold=200 )
import logging from gym.envs.registration import register logger = logging.getLogger(__name__) register(id='CaptureTheHack-v0', entry_point='gym_capturethehack.envs:CaptureTheHackEnv' #max_episode_steps = 500 )