def test_smoke_bad_parameters_settings(self):
params = {'class': 'some.class', 'parameters': 1}
with self.assertRaises(Exception) as context:
createAgent(action_space, None, params)
self.assertEquals(
"Parameters must have key 'parameters' containing a dict but got {'class': 'some.class', 'parameters': 1}",
str(context.exception))
def test_smoke_no_some_class(self):
params = {'class': 'some.class', 'id': 'robot1', 'parameters': {}}
with self.assertRaises(Exception) as context:
createAgent(action_space, None, params)
self.assertEquals(
"Can't load some.class from {'class': 'some.class', 'id': 'robot1', 'parameters': {}}",
str(context.exception))
def test_smoke_agents_no_dict(self):
params = {'class': randomclass, 'parameters': {}, 'subAgentList': 3}
with self.assertRaises(Exception) as context:
createAgent(action_space, None, params)
self.assertEquals(
"the subAgentList parameter must contain a list, but got {'class': 'aiagents.single.RandomAgent.RandomAgent', 'parameters': {}, 'subAgentList': 3}",
str(context.exception))
def test_check_subparty_rootclass_nochildren(self):
params = {
'class':
randomclass,
'parameters': {},
'subAgentList': [{
'class': randomclass,
'id': 'robot1',
'parameters': {}
}]
}
with self.assertRaises(Exception) as context:
createAgent(action_space, None, params)
self.assertEquals(
"aiagents.single.RandomAgent.RandomAgent failed on __init__:",
str(context.exception))
def __init__(self, agentId, action_space, observation_space, parameters: dict):
"""
TBA
"""
# try:
# self._model = parameters["model"] # model is a dictionary states to actions
# except KeyError:
try:
with open(parameters["modelFile"], 'r') as stream:
try:
self._model = yaml.load(stream)
except yaml.YAMLError as exc:
logging.error(exc)
except FileNotFoundError:
print("No agent files available yet")
self._model={}
backupClassDictionary = {}
backupClassDictionary["id"]=agentId
backupClassDictionary["class"]=parameters["backupClass"]
backupClassDictionary["parameters"]=parameters["backupClassParameters"]
self._subAgent = createAgent(action_space, observation_space, backupClassDictionary)
super().__init__(agentId, action_space, observation_space, parameters)
self.predicts=0
self.noPredicts=0
def main():
"""
Demo how to run an agent
"""
dirname = os.path.dirname(__file__)
if (len(sys.argv) > 1):
env_configName = str(sys.argv[1])
agent_configName = str(sys.argv[2])
else:
print("Default config ")
env_configName = "./configs/factory_floor_experiment.yaml"
env_filename = os.path.join(dirname, env_configName)
agent_configName = "./configs/agent_combined_config.yaml"
agent_filename = os.path.join(dirname, agent_configName)
env_parameters = getParameters(env_filename)
agent_parameters = getParameters(agent_filename)
# whao, you need to know exact contents of all files here..
recursive_update(
agent_parameters['subAgentList'][0]['parameters']['simulator'],
env_parameters['environment'])
print(env_parameters)
print(agent_parameters)
random.seed(env_parameters['seed'])
maxSteps = env_parameters['max_steps']
baseEnv = FactoryFloor(env_parameters['environment'])
packedActionSpace = PackedSpace(baseEnv.action_space,
{"robots": ["robot1", "robot2", "robot3"]})
env = ModifiedGymEnv(baseEnv, packedActionSpace)
logging.info("Starting example MCTS agent")
logoutput = io.StringIO("episode output log")
try:
logoutputpickle = open('./' + os.environ["SLURM_JOB_ID"] + '.pickle',
'wb')
except KeyError:
print("No SLURM_JOB_ID found")
logoutputpickle = io.BytesIO()
obs = env.reset()
complexAgent = createAgent(env.action_space, env.observation_space,
agent_parameters)
experiment = Experiment(complexAgent, env, maxSteps, render=True)
experiment.addListener(JsonLogger(logoutput))
experiment.addListener(PickleLogger(logoutputpickle))
stats, confidence_ints = experiment.run()
logoutputpickle.close()
print("json output:", logoutput.getvalue())
print("\n\nREWARD STATS: " + str(stats) + " \nCONFIDENCE INTERVALS " +
str(confidence_ints))
def test_smoke(self):
actions = Mock(spec=Discrete)
actions.n = 10
env = Mock()
actspace = Mock(spec=Dict)
spacesmock = { 'entity1':actions}
actspace.spaces = spacesmock
env.action_space = actspace
agent = createAgent(actspace, None, {'id': 'entity1',
'class':'aiagents.single.RandomAgent.RandomAgent',
'parameters':{}})
def test_check_subparty(self):
params = {
'class':
compoundclass,
'parameters': {},
'subAgentList': [{
'class': randomclass,
'id': 'robot1',
'parameters': {}
}]
}
agt = createAgent(action_space, None, params)
subs = agt._agentSubcomponents
self.assertEquals(1, len(subs))
self.assertEquals('RandomAgent', type(subs[0]).__name__)
def test_is_good_agent(self):
actions = Mock(spec=Discrete)
actions.n = 10
env = Mock()
actspace = Mock(spec=Dict)
spacesmock = { 'entity1':actions}
actspace.spaces = spacesmock
env.action_space = actspace
state = Mock()
agent = createAgent(actspace , None, {'id': 'entity1',
'class':'aiagents.single.RandomAgent.RandomAgent',
'parameters':{}})
action = agent.step(state)
print('agent did action:' + str(action))
self.assertTrue(['entity1'], action.keys())
def __init__(self, agentId, action_space, observation_space, parameters: dict):
"""
TBA
"""
try:
self._model = load_model(parameters["modelFile"])
self._subAgent = None
except OSError:
# for first generation we will start with a "backup class"
backupClassDictionary = {}
backupClassDictionary["id"]=agentId
backupClassDictionary["class"]=parameters["backupClass"]
backupClassDictionary["parameters"]=parameters["backupClassParameters"]
self._subAgent = createAgent(action_space, observation_space, backupClassDictionary)
logging.info("Agent " + str(agentId) + " using backup agent")
super().__init__(agentId, action_space, observation_space, parameters)
def main():
"""
Demo how to construct complex agents
"""
configName = "configs/factory_floor_complex.yaml"
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, configName)
parameters = getParameters(filename)
env = FactoryFloor(parameters['environment'])
obs = env.reset()
complexAgent = createAgent(env.action_space, env.observation_space,
parameters['agents'])
print(complexAgent)
sub = complexAgent._agentSubcomponents[0]
subsub = sub._agentSubcomponents
print(subsub)
def test_smoke(self):
params = {'class': randomclass, 'id': 'robot1', 'parameters': {}}
createAgent(action_space, None, params)
def test_smoke_no_agents(self):
params = {}
with self.assertRaises(Exception) as context:
createAgent(action_space, None, params)
self.assertEquals("Parameters must have key 'class' but got {}",
str(context.exception))
def main():
"""
MCTS Factory Floor experiment
"""
dirname = os.path.dirname(__file__)
parser = configargparse.ArgParser()
parser.add('-e',
'--env-config',
dest="env_filename",
default=os.path.join(
dirname, "./debug_configs/factory_floor_experiment.yaml"))
parser.add('-a',
'--agent-config',
dest="agent_filename",
default=os.path.join(dirname,
"./debug_configs/agent_config.yaml"))
parser.add('-d', '--data-dirname', dest="data_dirname", default="data")
args = parser.parse_args()
try:
data_outputdir = os.path.join(
dirname,
"./" + args.data_dirname + "/" + os.environ["SLURM_JOB_ID"])
os.makedirs(data_outputdir)
logoutputpickle = open('./' + data_outputdir + '/output.pickle', 'wb')
rewardsFile = open('./' + data_outputdir + '/rewards.yaml', 'w+')
except KeyError:
print("No SLURM_JOB_ID found")
logoutputpickle = io.BytesIO()
rewardsFile = io.StringIO()
env_parameters = getParameters(args.env_filename)
agent_parameters = getParameters(args.agent_filename)
print(env_parameters)
print(agent_parameters)
for subAgent in agent_parameters["subAgentList"]:
subAgent["parameters"]["simulator"] = env_parameters["environment"]
subAgent["parameters"]["simulator"][
"fullname"] = "aienvs.FactoryFloor.FactoryFloor.FactoryFloor"
random.seed(env_parameters['seed'])
maxSteps = env_parameters['max_steps']
env = FactoryFloor(env_parameters['environment'])
logging.info("Starting example MCTS agent")
logoutput = io.StringIO("episode output log")
obs = env.reset()
complexAgent = createAgent(env.action_space, env.observation_space,
agent_parameters)
experiment = Experiment(complexAgent, env, maxSteps, render=False)
experiment.addListener(JsonLogger(logoutput))
experiment.addListener(PickleLogger(logoutputpickle))
rewards = experiment.run()
# statistics, confidence_ints = stats.describe(rewards), stats.bayes_mvs(rewards)
logoutputpickle.close()
yaml.dump(rewards, rewardsFile)
rewardsFile.close()
print("json output:", logoutput.getvalue())
print("\n\nREWARD STATS: " + str(statistics) + " \nCONFIDENCE INTERVALS " +
str(confidence_ints))
def __init__(self, agentId, actionspace: Dict, observationspace,
parameters: dict):
"""
@param parameters dict that must contain keys 'otherAgents', 'treeAgent' and 'rolloutAgent'
'otherAgents' must map to a (possibly empty) list of dict objects for a call to createAgents
'treeAgent' and 'rolloutAgent' must map to a dict object for a call to createAgent.
The dict must also contain a 'simulator' key containing a copy of the env parameters,
so that the agent can create a duplicate environment. The simulator dict must contain
a key 'fullname' containing the full name of the environment
for the class loader (se EnvironmentsFactory).
"""
super().__init__(agentId, actionspace, observationspace, parameters)
if not ('treeAgent' in parameters and 'rolloutAgent' in parameters):
raise "parameters does not contain 'treeAgent', 'rolloutAgent':" + str(
parameters)
self._parameters = copy.deepcopy(self.DEFAULT_PARAMETERS)
self._parameters = recursive_update(self._parameters, parameters)
if 'timeLimit' in self._parameters:
if 'iterationLimit' in self._parameters:
raise ValueError(
"Cannot have both a time limit and an iteration limit")
self._limitType = 'time'
else:
if 'iterationLimit' not in self._parameters:
DEFAULT_LIMIT = 1000
logging.error(
"Must have either a time limit or an iteration limit. Using default iteration limit: "
+ str(DEFAULT_LIMIT))
self._parameters['iterationLimit'] = DEFAULT_LIMIT
# number of iterations of the search
if self._parameters['iterationLimit'] < 1:
raise ValueError("Iteration limit must be greater than one")
self._limitType = 'iterations'
# start the simulator environment
envparams = self._parameters['simulator']
e = EnvironmentFactory.createEnvironment(envparams['fullname'],
envparams)
self._simulator = ModifiedGymEnv(
e, DecoratedSpace.create(copy.deepcopy(e.action_space)))
# diyBonus logic: to refactor -- include in a simulator factory / only for FactoryFloor env
diyBonus = self._parameters.get("diyBonus")
if diyBonus is not None:
self._simulator = DiyFactoryFloorAdapter(self._simulator, diyBonus,
self.agentId)
self._treeAgent = createAgent(self._simulator.action_space,
self._simulator.observation_space,
parameters['treeAgent'])
if 'otherAgents' in parameters:
rolloutAgentDict = copy.deepcopy(parameters['otherAgents'])
rolloutAgentList = rolloutAgentDict['subAgentList']
rolloutAgentList.append(parameters['rolloutAgent'])
rolloutAgentDict['subAgentList'] = rolloutAgentList
self._rolloutAgent = createAgent(self._simulator.action_space,
self._simulator.observation_space,
rolloutAgentDict)
self._otherAgents = createAgent(self._simulator.action_space,
self._simulator.observation_space,
parameters['otherAgents'])
else:
self._otherAgents = None
self._rolloutAgent = createAgent(self._simulator.action_space,
self._simulator.observation_space,
parameters['rolloutAgent'])
