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,
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},
# 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',
)
# 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',
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 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='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
)
