def test(world, restore=False, show=True, agent_name=None): """ Run BECCA with world. If restore=True, this method loads a saved agent if it can find one. Otherwise it creates a new one. It connects the agent and the world together and runs them for as long as the world dictates. To profile BECCA's performance with world, manually set profile_flag in the top level script environment to True. """ if agent_name is None: agent_name = '_'.join((world.name, 'agent')) agent = Agent(world.num_sensors, world.num_actions, agent_name=agent_name, show=show) if restore: agent = agent.restore() # If configured to do so, the world sets some BECCA parameters to # modify its behavior. This is a development hack, and # should eventually be removed as BECCA matures and settles on # a good, general purpose set of parameters. world.set_agent_parameters(agent) actions = np.zeros((world.num_actions,1)) # Repeat the loop through the duration of the existence of the world while(world.is_alive()): sensors, reward = world.step(actions) actions = agent.step(sensors, reward) world.visualize(agent) return agent.report_performance()
def gen_traj_loop(): n = 100 agent = Agent(env_factory, policy_list[0], running_state=running_state_list[0], render=args.render, num_threads=args.num_threads, mode_list=args.mode_list, state_type=args.state_type, num_steps_per_mode=args.num_steps_per_mode) env_data_dict = {'num_goals': 1} expert_data_dict = {} i_iter = 0 print('Writing to h5 file ...') while i_iter < n: #vid_folder = str(i_iter) vid_folder = None path_key = str(i_iter) + '_0' returned_dict, save_flag = agent.generate_mixed_expert_trajs( policy_list, running_state_list, vid_folder=vid_folder) if save_flag: expert_data_dict[path_key] = returned_dict i_iter += 1 print(i_iter) save_expert_traj_dict_to_h5(expert_data_dict, args.traj_save_dir)
def step(self): # If we are doing animation: if Braess_World.state == 'a': if not Agent.key_step_done: Agent.run_an_animation_step() else: self.setup_2() return # We are not doing animation. We are in either state_1 or state_2. Process them normally. # If there was a change during the previous step, see if additional changes are needed. if Agent.some_agent_changed: # When a link changes length, Agent.some_agent_changed is set to True. Agent.some_agent_changed = False for lnk in self.adjustable_links: lnk.adjust_nodes() else: # Since no agent changed on the previous step, we're done with this state. # "Click" the STOP button. gui.WINDOW[GOSTOP].click() # Enable/disable the Cut-cord button depending on whether we are leaving state 1. SimEngine.gui_set(Braess_World.CUT_CORD, enabled=(Braess_World.state == 1))
def disable_agent(): set_global('agent_status', 'disabled') for job in get_db('jobs'): if job['status'] != 'completed': agent = Agent(job['id']) assign_agent = job['assign_agent'] agent.deorchestrate(assign_agent['url'], assign_agent['port']) return {}
def __init__(self, args): self.args = args ######### Initialize the Multiagent Team of agents ######## if self.args.ps == 'full' or self.args.ps == 'trunk': self.agents = [Agent(self.args, id)] #todo: is it one agent or more>? is it just agent? sharing all parameters elif self.args.ps == 'none': self.agents = [Agent(self.args, id) for id in range(self.args.config.num_agents)] # neural network for each agent else: sys.exit('Incorrect PS choice') self.test_agent = TestAgent(self.args, 991) ###### Buffer and Model Bucket as references to the corresponding agent's attributes #### if args.ps == "trunk": self.buffer_bucket = [buffer.tuples for buffer in self.agents[0].buffer] else: self.buffer_bucket = [ag.buffer.tuples for ag in self.agents] # Specifying 3 different networks for evo, PG and test rollouts self.popn_bucket = [ag.popn for ag in self.agents] self.rollout_bucket = [ag.rollout_actor for ag in self.agents] self.test_bucket = self.test_agent.rollout_actor ######### EVOLUTIONARY WORKERS ############ if self.args.popn_size > 0: self.evo_task_pipes = [Pipe() for _ in range(args.popn_size * args.num_evals)] # evals for computing the fitness self.evo_result_pipes = [Pipe() for _ in range(args.popn_size * args.num_evals)] self.evo_workers = [Process(target=rollout_worker, args=( self.args, i, 'evo', self.evo_task_pipes[i][1], self.evo_result_pipes[i][0], self.buffer_bucket, self.popn_bucket, True, RANDOM_BASELINE)) for i in range(args.popn_size * args.num_evals)] # rollout for pop_size*num_evals, # popn_bucket is the neural network for evo for worker in self.evo_workers: worker.start() ######### POLICY GRADIENT WORKERS ############ if self.args.rollout_size > 0: self.pg_task_pipes = Pipe() self.pg_result_pipes = Pipe() self.pg_workers = [ Process(target=rollout_worker, args=(self.args, 0, 'pg', self.pg_task_pipes[1], self.pg_result_pipes[0], self.buffer_bucket, self.rollout_bucket, self.args.rollout_size > 0, RANDOM_BASELINE))] # rollout_bucket is the neural network for evo for worker in self.pg_workers: worker.start() ######### TEST WORKERS ############ self.test_task_pipes = Pipe() self.test_result_pipes = Pipe() self.test_workers = [Process(target=rollout_worker, args=(self.args, 0, 'test', self.test_task_pipes[1], self.test_result_pipes[0], None, self.test_bucket, False, RANDOM_BASELINE))] # test_bucket is the neural network for evo for worker in self.test_workers: worker.start() #### STATS AND TRACKING WHICH ROLLOUT IS DONE ###### self.best_score = -999; self.total_frames = 0; self.gen_frames = 0; self.test_trace = []
def _hosts_list(self): """ List all OpenStack hypervisors with runtime details """ agent = CMAgent() hypervisors = agent.list_hypervisors() response.body = encode_dict_json(hypervisors) logging.debug('Hypervisor list response', response.body) response.status = 200 response.content_type = 'application/json' return response
def _hosts_list(self): """ List all OpenStack hypervisors with runtime details """ agent = CMAgent() hypervisors = agent.list_hypervisors() response.body = encode_dict_json(hypervisors) logging.debug("Hypervisor list response", response.body) response.status = 200 response.content_type = "application/json" return response
def __init__(self, args): self.args = args ######### Initialize the Multiagent Team of agents ######## self.agents = Agent(self.args, id) self.prey_agent = PreyAgent(self.args, -1) self.test_agent = TestAgent(self.args, 991) ###### Buffer and Model Bucket as references to the corresponding agent's attributes #### self.predator_buffer_bucket = [buffer.tuples for buffer in self.agents.buffer] self.prey_buffer_bucket = [self.prey_agent.buffer[0].tuples] self.popn_bucket = self.agents.popn self.predator_rollout_bucket = self.agents.rollout_actor self.prey_rollout_bucket = self.prey_agent.rollout_actor self.predator_test = self.test_agent.predator self.prey_test = self.test_agent.prey ######### EVOLUTIONARY WORKERS ############ if self.args.popn_size > 0: self.evo_task_pipes = [Pipe() for _ in range(args.popn_size * args.num_evals)] self.evo_result_pipes = [Pipe() for _ in range(args.popn_size * args.num_evals)] self.evo_workers = [Process(target=rollout_worker, args=( self.args, i, 'evo', self.evo_task_pipes[i][1], self.evo_result_pipes[i][0], self.predator_buffer_bucket, self.prey_buffer_bucket, self.popn_bucket, self.prey_rollout_bucket, True, args.config.config)) for i in range(args.popn_size * args.num_evals)] for worker in self.evo_workers: worker.start() ######### POLICY GRADIENT WORKERS ############ if self.args.rollout_size > 0: self.pg_task_pipes = Pipe() self.pg_result_pipes = Pipe() self.pg_workers = [ Process(target=rollout_worker, args=(self.args, 0, 'pg', self.pg_task_pipes[1], self.pg_result_pipes[0], self.predator_buffer_bucket, self.prey_buffer_bucket, self.predator_rollout_bucket, self.prey_rollout_bucket, self.args.rollout_size > 0, args.config.config))] for worker in self.pg_workers: worker.start() ######### TEST WORKERS ############ self.test_task_pipes = Pipe() self.test_result_pipes = Pipe() self.test_workers = [Process(target=rollout_worker, args=(self.args, 0, 'test', self.test_task_pipes[1], self.test_result_pipes[0], None, None, self.predator_test, self.prey_test, False, args.config.config))] for worker in self.test_workers: worker.start() #### STATS AND TRACKING WHICH ROLLOUT IS DONE ###### self.best_score = -999; self.total_frames = 0; self.gen_frames = 0; self.test_trace = []
def submit(job): agent = Agent(job_id=job.job_id, role='submit') try: agent.report_job(job.job_id, 'submitting') # todo - add tracker object orchestrator_agent = request_orchestrator(agent, 1, job_id=job.job_id) job.set('assigned_agent', orchestrator_agent) # agent.report(f'sending job: {job.job_id}, to orchestrator: {orchestrator_agent}', job_id=job.job_id) agent.report_job(job.job_id, f'sending to orchestrator: {orchestrator_agent}') submission_time = str(datetime.datetime.now()) # todo - make sure api call is not waiting for response, then have job.set_may after call job_params = { 'job_status': 'submitted', 'submission_time': str(datetime.datetime.now()), } job.set_many(job_params) # todo - this is an agent skill # todo - handle async try: requests.get(f'http://{orchestrator_agent["url"]}:{orchestrator_agent["port"]}/orchestrate', params={ 'git_repo': job.get("git_repo"), 'file_name': job.get("file_name"), 'job_id': job.job_id, 'submission_time': submission_time, 'submitter_name': get_global('agent_name'), 'submitter_url': get_global('agent_url'), 'submitter_port': get_global('agent_port') }, timeout=0.0000000001) except requests.exceptions.ReadTimeout: pass agent.set('agent_status', 'connected') except Exception as e: agent.log(e) return f'error submitting job {job.job_id}: {e}' return { 'status': 'submitted', 'timestamp': submission_time, 'orchestrator': orchestrator_agent, 'job_id': job.job_id }
def one_image(label_interest=5): images, labels = load_mnist.load_images(images_number=100) world = World() poppy = Agent() image_interest = images[labels == label_interest][0] world.add_image(image_interest) poppy.cortex.reset_activations() poppy.cortex.display = True while True: poppy.sense_data(world) poppy.cortex.associate(label=label_interest)
def learn_pairs(label_interest=5, n_jumps_test=50): """ :param label_interest: MNIST label of interest :param n_jumps_test: how many test saccades to be made for one image; as we increase `n_jumps_test`, we expect overlap with L23 train history to decrease in time, since during the training we observe only the most significant features in an image. Ideally, we'd like the overlap not to decrease much in time. """ images, labels = load_mnist.load_images(images_number=100) world = World() poppy = Agent() images_interest = images[labels == label_interest] for image in images_interest: world.add_image(image) poppy.cortex.reset_activations() l23_train = poppy.learn_pairs(world, label_interest) world.reset() if n_jumps_test == 0: l23_test = poppy.learn_pairs(world, label=label_interest) else: l23_test = [] poppy.sense_data(world) for saccade in range(n_jumps_test): poppy.sense_data(world) l23_test.append(poppy.cortex.V1.layers['L23'].cells.copy()) l23_test = np.vstack(l23_test) overlap = np.dot(l23_train, l23_test.T) overlap = (overlap * 255 / poppy.cortex.V1.layers['L23'].n_active).astype(np.uint8) cv2.imshow('overlap', overlap) cv2_step()
def __init__(self): logging.info("Initializing Open Assistant") Agent.__init__(self, home=os.path.dirname(__file__)) # Establish OA core. oa.core = self oa.core_directory = self.home # Setup parts and threads. self.parts = Core() self.minds = Core() self.mind = None self.finished = threading.Event() self.thread_pool = []
def __init__(self, host, port): self._host = host self._port = port self._app = Bottle() self._route() self._debug = True self.agent = CMAgent()
def setUp(self): time_step = 0.05 self.agents = [Agent(0, 0, time_step)] self.arena = Arena(10, 20) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.algorithm = AStar(self.arena, self.agents, self.biased_grid) self.cli = CommandLine(self.arena, self.agents)
def abort(): job_id = request.args.get('job_id') # todo - need to fix this, it isn't being processed properly (parallelism?) # set_job(job_id, {'job_status': 'requested_abort'}) Agent(job_id=job_id, role='execute').report_job(job_id, 'requested aborting') return {}
class Application: def __init__(self, host, port): self._host = host self._port = port self._app = Bottle() self._route() self._debug = True self.agent = CMAgent() def _route(self): # Welcome Screen self._app.route('/', method="GET", callback=self._welcome) # Hypervisor methods self._app.route('/hosts', method="GET", callback=self._hosts_list) self._app.route('/server/<hypervisor_name>/<server_name>', method="GET", callback=self.get_server_info) # QoS methods self._app.route('/qoses', method=["POST", "OPTIONS"], callback=self._qoses_set) # QoS methods self._app.route('/qoses/<hypervisor_hostname>/<qos_id>', method=["DELETE", "OPTIONS"], callback=self._delete_qos) # QoS methods self._app.route('/queue/<hypervisor_name>/<queue_id>/<queue_number>/<qos_id>', method=["DELETE", "OPTIONS"], callback=self._delete_queue) self._app.route('/queue', method=["POST","OPTIONS"], callback=self.add_queue_to_qos) # Flow methods self._app.route('/flow', method=["POST", "OPTIONS"], callback=self._assign_flow_to_queue) self._app.route('/flow/<hypervisor_name>/<flow_protocol>/<flow_ip>', method=["DELETE","OPTIONS"], callback=self._delete_flow) def start(self): self._app.run(host=self._host, port=self._port) def _welcome(self): response.body = "Welcome to the Connectivity Manager Agent" response.status = 200 return response def _assign_flow_to_queue(self): """ Assign a flow to a specific queue on the """ flow_json = request.body.getvalue() logging.debug('QoS JSON is: %s', flow_json) if not flow_json: return bad_request('This POST methods requires a valid JSON') try: set_flow = self.agent.set_flow(flow_json) except Exception, exc: logging.error(exc.message) return internal_error(exc.message) response.status = 200 response.body = encode_dict_json(set_flow) logging.debug('Setting Flows processed: %s', response.body) return response
class Application: def __init__(self, host, port): self._host = host self._port = port self._app = Bottle() self._route() self._debug = True self.agent = CMAgent() def _route(self): # Welcome Screen self._app.route('/', method="GET", callback=self._welcome) # Hypervisor methods self._app.route('/hosts', method="GET", callback=self._hosts_list) # QoS methods self._app.route('/qoses', method=["POST", "OPTIONS"], callback=self._qoses_set) def start(self): self._app.run(host=self._host, port=self._port) def _welcome(self): response.body = "Welcome to the Connectivity Manager Agent" response.status = 200 return response def _hosts_list(self): """ List all OpenStack hypervisors with runtime details """ agent = CMAgent() hypervisors = agent.list_hypervisors() response.body = encode_dict_json(hypervisors) logging.debug('Hypervisor list response', response.body) response.status = 200 response.content_type = 'application/json' return response def _qoses_set(self): """ Set QoS for VMs """ qos_json = request.body.getvalue() logging.debug('QoS JSON is: %s', qos_json) if not qos_json: return bad_request('This POST methods requires a valid JSON') try: set_qos = self.agent.set_qos(qos_json) except Exception, exc: logging.error(exc.message) return internal_error(exc.message) response.status = 200 response.body = encode_dict_json(set_qos) logging.debug('QoS processed: %s', response.body) return response
def wrapper(): if Agent.get('agent_status') == 'disabled': return jsonify({'status': 'disabled'}) Agent.set('agent_status', 'busy') log.info(f'processing request: \n' f'{[{k:v} for k,v in request.args.items()]}\n' f'role: {api.__name__}') try: job = Job(request) job.set('role', api.__name__) log.info(f'job object created with id: {job.job_id}') return api(job) except Exception as e: log.info(f'error in job processing: {e}', report=True)
def main(args): logger = create_logger(build_expname, args) initialize_logger(logger) """create agent""" agent = Agent(env, policy_net, device, running_state=running_state, render=args.render, num_threads=args.num_threads) exp = Experiment(agent, env, logger, args) exp.main_loop()
def _read_json(self, filepath): print('Importing file', filepath) with open(filepath) as f: data = json.load(f) for varname in data['variables']: name = varname domain = data['variables'][varname]['domain'] id = data['variables'][varname]['id'] constr = data['variables'][varname]['cons'] type = data['variables'][varname]['type'] agent = data['variables'][varname]['agent'] self.variables[name] = Variable(name=name, domain=domain, type='decision') for con in data['constraints']: name = con scope = data['constraints'][con]['scope'] costs = data['constraints'][con]['vals'] domains = [self.variables[vname].domain for vname in scope] all_tuples = list(product(*domains)) assert (len(all_tuples) == len(costs)) con_values = { all_tuples[i]: costs[i] for i in range(len(all_tuples)) } self.constraints[name] = Constraint( name, scope=[self.variables[vid] for vid in scope], values=con_values) # add constriant to variables for vid in scope: self.variables[vid].addConstraint(self.constraints[name]) for agt in data['agents']: name = agt var_names = data['agents'][agt]['vars'] agt_constraints = [ ] #list(set([c for c in self.variables[vid].constraints for vid in var_names])) for vid in var_names: for c in self.variables[vid].constraints: if c not in agt_constraints: agt_constraints.append(c) self.agents[name] = Agent( name, variables=[self.variables[vid] for vid in var_names], constraints=agt_constraints) for vid in var_names: self.variables[vid].setOwner(self.agents[name]) # Connect neighbors: for con in self.constraints: clique = [var.controlled_by for var in self.constraints[con].scope] for ai, aj in permutations(clique, 2): ai.addNeighbor(aj, self.constraints[con])
class Application: def __init__(self, host, port): self._host = host self._port = port self._app = Bottle() self._route() self._debug = True self.agent = CMAgent() def _route(self): # Welcome Screen self._app.route("/", method="GET", callback=self._welcome) # Hypervisor methods self._app.route("/hosts", method="GET", callback=self._hosts_list) # QoS methods self._app.route("/qoses", method=["POST", "OPTIONS"], callback=self._qoses_set) def start(self): self._app.run(host=self._host, port=self._port) def _welcome(self): response.body = "Welcome to the Connectivity Manager Agent" response.status = 200 return response def _hosts_list(self): """ List all OpenStack hypervisors with runtime details """ agent = CMAgent() hypervisors = agent.list_hypervisors() response.body = encode_dict_json(hypervisors) logging.debug("Hypervisor list response", response.body) response.status = 200 response.content_type = "application/json" return response def _qoses_set(self): """ Set QoS for VMs """ qos_json = request.body.getvalue() logging.debug("QoS JSON is: %s", qos_json) if not qos_json: return bad_request("This POST methods requires a valid JSON") try: set_qos = self.agent.set_qos(qos_json) except Exception, exc: logging.error(exc.message) return internal_error(exc.message) response.status = 200 response.body = encode_dict_json(set_qos) logging.debug("QoS processed: %s", response.body) return response
def init_agent(): services, workers, session, _ = parse_old_config() endpoint = Service('cmd_responder', EventSetOutputConnector('cmd_responder').send, StateManager.save_dialog_dict, 1, ['responder']) input_srv = Service('input', None, StateManager.add_human_utterance_simple_dict, 1, ['input']) pipeline = Pipeline(services) pipeline.add_responder_service(endpoint) pipeline.add_input_service(input_srv) agent = Agent(pipeline, StateManager()) return agent, session
def orchestrate(job): job_id = job.job_id agent = Agent(job_id=job_id, role='orchestrate') job.set('start_time', time.time()) git_repo = job.get('git_repo') file_name = job.get('file_name') agent.log(f'orchestrating', report=True, job_id=job_id) exec_agents = json.loads( requests.get(f'http://{get_global("tracker_host")}:3000/assign_agents', params={ 'source': job.get('submitter_name'), 'orchestrator': get_global('agent_name'), 'required': 2 }).content.decode("ascii")) job.set('executors', exec_agents) agent.report_job(job_id, f'executors: {exec_agents}') for exec_agent in exec_agents: agent.log(f'sending to executor: {exec_agent["name"]}', report=True, job_id=job_id) time.sleep(5) try: requests.get( f'http://{exec_agent["url"]}:{exec_agent["port"]}/execute', params={ 'git_repo': git_repo, 'file_name': file_name, 'job_id': job_id, 'submission_time': job.get('submission_time'), 'submitter_name': job.get('submitter_name'), 'submitter_url': job.get('submitter_url'), 'submitter_port': job.get('submitter_port'), 'orchestrator_name': get_global('agent_name'), 'orchestrator_url': get_global('agent_url'), 'orchestrator_port': get_global('agent_port') }, timeout=0.0000000001) except requests.exceptions.ReadTimeout: pass time.sleep(3) Thread(target=sync, kwargs={'job_id': job_id}).start() set_global('agent_status', 'connected') return f'sent job {job.job_id} to executors: {exec_agents}'
def run(): from core.agent import Agent from core.state_manager import StateManager from core.skill_manager import SkillManager from core.rest_caller import RestCaller from core.service import Service from core.postprocessor import DefaultPostprocessor from core.response_selector import ConfidenceResponseSelector from core.skill_selector import ChitchatQASelector from core.config import MAX_WORKERS, ANNOTATORS, SKILL_SELECTORS, SKILLS import logging logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARNING) state_manager = StateManager() anno_names, anno_urls = zip(*[(annotator['name'], annotator['url']) for annotator in ANNOTATORS]) preprocessor = Service( rest_caller=RestCaller(max_workers=MAX_WORKERS, names=anno_names, urls=anno_urls)) postprocessor = DefaultPostprocessor() skill_caller = RestCaller(max_workers=MAX_WORKERS) response_selector = ConfidenceResponseSelector() ss_names, ss_urls = zip(*[(annotator['name'], annotator['url']) for annotator in SKILL_SELECTORS]) skill_selector = ChitchatQASelector(rest_caller=RestCaller(max_workers=MAX_WORKERS, names=ss_names, urls=ss_urls)) skill_manager = SkillManager(skill_selector=skill_selector, response_selector=response_selector, skill_caller=skill_caller, profile_handlers=[skill['name'] for skill in SKILLS if skill.get('profile_handler')]) agent = Agent(state_manager, preprocessor, postprocessor, skill_manager) def infer(messages: Collection[Message], dialog_ids): utterances: List[Optional[str]] = [message.text for message in messages] tg_users: List[User] = [message.from_user for message in messages] u_tg_ids = [str(user.id) for user in tg_users] u_tg_data = [{ 'id': user.id, 'username': user.username, 'first_name': user.first_name, 'last_name': user.last_name } for user in tg_users] u_d_types = [None] * len(messages) date_times = [datetime.utcnow()] * len(messages) locations: List[Optional[Location]] = [message.location for message in messages] ch_types = ['telegram'] * len(messages) answers = agent(utterances=utterances, user_telegram_ids=u_tg_ids, user_device_types=u_d_types, date_times=date_times, locations=locations, channel_types=ch_types) return answers return infer
def _create_agents(self, n): """ Creates an agent :param n: :return: """ name, vid = 'a_' + str(n), 'v_' + str(n) self.agents[name] = Agent(name, variables=[self.variables[vid]], constraints=self.variables[vid].constraints) self.variables[vid].setOwner(self.agents[name])
def setup(self): nbr_agents = SimEngine.get_gui_value('nbr_agents') for _ in range(nbr_agents): # When created, a agent adds itself to self.agents and to its patch's list of Agents. # self.agent_class(scale=1) Agent(scale=1) initial_velocities = cycle([Velocity((-1, -1)), Velocity((-1, 1)), Velocity((0, 0)), Velocity((1, -1)), Velocity((1, 1))]) for (agent, vel) in zip(World.agents, initial_velocities): agent.set_velocity(vel)
def test(world, restore=False, show=True): """ Run BECCA with a world If restore is True, this method loads a saved agent if it can find one. Otherwise it creates a new one. It connects the agent and the world together and runs them for as long as the world dictates. """ agent_name = '_'.join((world.name, 'agent')) agent = Agent(world.num_sensors, world.num_actions, agent_name=agent_name, show=show) if restore: agent = agent.restore() actions = np.zeros((world.num_actions,1)) # Repeat the loop through the duration of the existence of the world while(world.is_alive()): sensors, reward = world.step(actions) world.visualize(agent) actions = agent.step(sensors, reward) return agent.report_performance()
def complete(): try: job_id = request.args.get('job_id') completing_agent = request.args.get('agent_name') job_params = { 'job_status': 'completed', 'completion_time': request.args.get('completion_time'), 'executor_name': request.args.get('executor_name'), 'executor_url': request.args.get('executor_url'), 'executor_port': request.args.get('executor_port') } set_job(job_id, job_params) if get_job(job_id)['role'] == 'orchestrate': agent = Agent(job_id) for executor in list(get_job(job_id)['executors']): if executor['name'] != completing_agent: agent.request_abort(job_id, executor['url'], executor['port']) return str(job_params) except Exception as e: log.exception('unable to complete') return {}
def prepare_agent(services, endpoint: Service, input_serv: Service, use_response_logger: bool): pipeline = Pipeline(services) pipeline.add_responder_service(endpoint) pipeline.add_input_service(input_serv) if use_response_logger: response_logger_callable = response_logger else: response_logger_callable = None agent = Agent(pipeline, StateManager(), response_logger_callable=response_logger_callable) return agent.register_msg, agent.process
def test(world, restore=False, show=True): """ Run BECCA with a world If restore is True, this method loads a saved agent if it can find one. Otherwise it creates a new one. It connects the agent and the world together and runs them for as long as the world dictates. """ agent_name = '_'.join((world.name, 'agent')) agent = Agent(world.num_sensors, world.num_actions, agent_name=agent_name, show=show) if restore: agent = agent.restore() actions = np.zeros((world.num_actions, 1)) # Repeat the loop through the duration of the existence of the world while (world.is_alive()): sensors, reward = world.step(actions) world.visualize(agent) actions = agent.step(sensors, reward) return agent.report_performance()
def create_agents(self): """ create agent list :return: list containing all generated agents """ # create agenets for count in range(self.number_of_agents): self.agent_list.append(Agent(count, True)) logging.debug("agent list created with " + str(len(self.agent_list)) + " agents") return self.agent_list
def main(cfg): env_name, use_zf, gamma, tau, policy_state, filter_state =\ cfg.require("env name", "use zfilter", "advantage gamma", "advantage tau", "policy state dict", "filter state dict") logger = Logger() logger.init(cfg) filter_op = ZFilter(gamma, tau, enable=use_zf) env = FakeGym(env_name) policy = Policy(cfg, env.info()) agent = Agent(cfg, env, policy, filter_op) # ---- start training ---- # if policy_state is not None: agent.policy().reset(policy_state) if filter_state is not None: agent.filter().reset(filter_state) train_loop(cfg, agent, logger) print("Done")
def main(cfg): env_name, action_mode, policy_state, filter_state =\ cfg.require("env name", "action mode", "policy state dict", "filter state dict") logger = Logger() logger.init(cfg) filter_op = Filter() # env = FakeGym(env_name) env = FakeRLBench(env_name, action_mode=action_mode) policy = Policy(cfg, env.info()) agent = Agent(cfg, env, policy, filter_op) # ---- start training ---- # if policy_state is not None: agent.policy().reset(policy_state) if filter_state is not None: agent.filter().reset(filter_state) train_loop(cfg, agent, logger) print("Done")
def main(cfg): env_name, gamma, tau, policy_state, filter_state = \ cfg.require("env name", "advantage gamma", "advantage tau", "policy state dict", "filter state dict") filter_op = ZFilter(gamma, tau) # env = FakeGym(env_name) env = FakeRLBench(env_name) policy = Policy(cfg, env.info()) agent = Agent(cfg, env, policy, filter_op) # ---- start training ---- # if policy_state is not None: agent.policy().reset(policy_state) if filter_state is not None: agent.filter().reset(filter_state) print("Info: Start replaying saved model") replay_loop(cfg, agent) print("Done")
print("Device: " + str(args.device)) print("Seed: " + str(args.seed)) print("Number of CPU threads: " + str(args.num_threads)) print("Number of Expert Trajectories: " + str(args.num_trajs)) print("---------------------------------------") print("Training DRIL Imitator for {} Epochs".format(args.max_iter_num)) # create imitator imitator = DRIL(args, state_dim, action_dim, is_disc_action) imitator.set_expert(expert_traj, args.num_trajs) print("Starting Ensemble!") imitator.train_ensemble() print("Finished Ensemble!") # create agent agent = Agent(env, imitator.policy.actor, args.device, running_state=running_state, render=args.render, num_threads=args.num_threads) log_list = {"bc_loss": [], "uncertainty_cost":[], "avg_reward": [], "std_reward": []} total_timesteps = 0 for i_iter in range(args.max_iter_num): batch, log = agent.collect_samples(args.min_batch_size) # train DRIL t0 = time.time() loss = imitator.train(batch) t1 = time.time()