def __init__(self): # Handlers self._vc = None self._sim = None try: self._vc = VirtualCoach(environment='local') except: self._vc = None # Flags self._done = False # Data self._weights = None self._data = np.empty(0)
def start_experiment(experiment_id): # Instantiate Virtual Coach and launch Experiment vc = VirtualCoach(environment='local', storage_username='******') sim = vc.launch_experiment(experiment_id) # roslaunch fh_desc controllers.launch fh_desc_launch_file = "/home/akl-ma/.opt/nrpStorage/{}/controllers.launch".format( experiment_id) uuid = roslaunch.rlutil.get_or_generate_uuid(None, False) roslaunch.configure_logging(uuid) launch = roslaunch.parent.ROSLaunchParent(uuid, [fh_desc_launch_file]) launch.start() time.sleep(10) sim.start() return sim
def main(): # set parameters episodes = 100 steps = 32 gamma = .98 epsilon = np.linspace(.6, .1, episodes) alpha = .1 n_env = 16 n_actions = 3 # start virtual coach vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') # run training model = Model(episodes=episodes, steps=steps, gamma=gamma, epsilon=epsilon, alpha=alpha, n_env=n_env, n_actions=n_actions) model.run_training(vc)
def main(): # initialize agents dqn = Agent(param.alpha, param.n_observations, param.n_actions, param.n_neurons) # if you want to run the experiment from an external program, use VC # this will allow you to use frontend interface from python vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') for episode in range(param.episodes): count = 0 while True: try: sim = vc.launch_experiment('template_husky_0') break except: count += 1 print('Try:', count) time.sleep(2) # subscribe to topics published by ros nhl.perform_subscribers() # start the experiment nhl.sync_params(episode + 1) sim.start() time.sleep(2) # inner-loop for running an episode run_episode(episode, dqn) # stop experiment sim.stop() time.sleep(2) # save metrics and network for postprocessing if (episode + 1) % 100 == 0: dhl.save_objects(dqn, episode + 1) print('Target score:', sum(param.target_scores) / float(param.episodes)) print('Reward visits:', np.sum(param.reward_visits))
import logging import evolution_utils import numpy as np from gazebo_msgs.msg import ModelState from IPython.display import clear_output from tf.transformations import quaternion_from_euler from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach # disable global logging from the virtual coach logging.disable(logging.INFO) logging.getLogger('rospy').propagate = False logging.getLogger('rosout').propagate = False vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') display_episode_tf = """@nrp.Robot2Neuron() def display_episode_number(t): clientLogger.advertise('%s') """ class FloreanoExperiment(object): def __init__(self, experiment_name, population, generations): self.experiment_name = experiment_name self.experiment_dir = os.environ['HOME'] + '/.opt/nrpStorage/' + self.experiment_name self.last_status = [None] self.sim = None self.initial_pose = np.array([])
import time import os import argparse import timeit parser = argparse.ArgumentParser( description='Run a number of trial and store data.') parser.add_argument('--n', type=int, default=10, help='number of trials') parser.add_argument('--duration', type=float, default=1., help='duration of a trial (in second)') args = parser.parse_args() vc = VirtualCoach(environment='local', storage_username='******') fname_base = "/home/nrpuser/.ros/cdp4/experiment" def setup(sim): pass start = timeit.default_timer() for i in range(args.n): print "### Running experiment %d" % i print "Launching" sim = vc.launch_experiment('CDP4_experiment_0') setup(sim) print "Starting" sim.start()
reward = (1 + cylinder_reward)**2 - distance_reward print('FINISHED TEST WITH REWARD {}'.format(reward)) return reward return get_reward if __name__ == '__main__': # Start simulation and launch experiment csv_name = "cylinder_position.csv" try: from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach vc = VirtualCoach(environment='local', storage_username='******') except ImportError as e: print(e) print("You have to start this notebook with the command:\ cle-virtual-coach jupyter notebook") raise e sim = vc.launch_experiment('hbpprak_2018_throwing') sim.register_status_callback(on_status) #solution # Network params and init topology = [6, 50, 20, 6] weights = []
class MotionChallenge: # Constants # Experiment name EXC_NAME = 'ExDHBPPrak_Motion' # Csv file name to save distance CSV_NAME = 'distance.csv' # Placeholder for the smallest (unreal) distance value MIN_VAL = -1000.0 # New transfer function to save distance in csv file RECORD_DISTANCE_TF = '''# Imported Python Transfer Function @nrp.MapRobotSubscriber("ball_distance", Topic("/ball_distance", Float32)) @nrp.MapCSVRecorder("distance_recorder", filename="''' + CSV_NAME + '''", headers=["time", "distance"]) @nrp.Robot2Neuron() def record_distance(t, ball_distance, distance_recorder): distance_recorder.record_entry(t, ball_distance.value.data if ball_distance.value else ''' + str( MIN_VAL) + ''')''' # Brain code from challenge with ability to set weigths BRAIN_TEMPLATE = '''# -*- coding: utf-8 -*- # pragma: no cover __author__ = 'Template' from hbp_nrp_cle.brainsim import simulator as sim import numpy as np import logging logger = logging.getLogger(__name__) sim.setup(timestep=0.1, min_delay=0.1, max_delay=20.0, threads=1, rng_seeds=[1234]) # Following parameters were taken from the husky braitenberg brain experiment (braitenberg.py) sensors = sim.Population(3, cellclass=sim.IF_curr_exp()) actors = sim.Population(3, cellclass=sim.IF_curr_exp()) sim.Projection(sensors, actors, sim.AllToAllConnector(), sim.StaticSynapse(weight={syn_weights})) circuit = sensors + actors''' def __init__(self): # Handlers self._vc = None self._sim = None try: self._vc = VirtualCoach(environment='local') except: self._vc = None # Flags self._done = False # Data self._weights = None self._data = np.empty(0) def getData(self): return np.reshape(self._data, (-1, 10)) def getDataCount(self): return self._data.shape[0] / 10 def clearData(self): self._data = np.empty(0) def popData(self): data = self.getData() self.clearData() return data def initialized(self): return self._vc != None def stopSim(self): try: self._done = True self._sim.stop() time.sleep(2.0) except: pass def receiveDistance(self): try: csv_data = self._sim.get_csv_data(self.CSV_NAME) if not csv_data: return self.MIN_VAL return float(csv_data[-1][-1]) except: print('Unable to get csv data') return self.MIN_VAL def makeOnStatus(self): def onStatus(msg): if not self._done: print("Current simulation time: {}".format( msg['simulationTime'])) distance = self.receiveDistance() if distance > self.MIN_VAL: self._sim.pause() self._done = True self._data = np.append(self._data, np.append(self._weights, distance)) print('Weights:\n' + str(self._weights) + '\nDistance: ' + str(distance)) #print('Distance: ' + str(distance)) return onStatus def run(self, weights): if not self.initialized(): print('Virtual coach hasn\'t been initialized') return self._done = False # Launch experiment try: self._sim = self._vc.launch_experiment(self.EXC_NAME) except: print('Unable to launch experiment') if self._sim: self.stopSim() return # Set experiment try: self._sim.register_status_callback(self.makeOnStatus()) self._sim.add_transfer_function(self.RECORD_DISTANCE_TF) self._weights = weights self._sim.edit_brain( self.BRAIN_TEMPLATE.format( **{'syn_weights': numpyArrayToInitStr(self._weights)})) except: print( 'Unable to set callback function, transfer function or brain') self._sim.stopSim() time.sleep(2.0) return # Start experiment try: self._sim.start() except: print('Unable to start simulation') self.stopSim() time.sleep(2.0) return # Wait until end of experiment and stop it while not self._done: time.sleep(0.2) self.stopSim() time.sleep(3.0)
import numpy as np import rospy from PIL import Image from geometry_msgs.msg import Pose from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach from cdp4_data_collection import CDP4DataCollection as data_collection objects = list(['cube_a', 'coffee_machine', 'aeroplane_toy']) vc = VirtualCoach(environment='local', storage_username='******') sim = vc.launch_experiment('scene_understanding_icub_holodeck_0_1') sim.start() dc = data_collection() path = 'training_data' orig_pose = Pose() orig_pose.position.z = 10 for i in range(3): dc.add_object(objects[i], orig_pose) for i in range(100): pose = dc.generate_random_pose() idx = np.random.randint(3) dc.set_object_pose(objects[idx], pose, True) dc.move_eyes(pose.position) rospy.sleep(0.2) image = dc.capture_image().astype(np.uint8) image = Image.fromarray(image) file_name = '%s/images/snapshot_%.3d.jpg' % (path, i) image.save(file_name)
#!/usr/bin/python from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') import sys from StringIO import StringIO old_stdout = sys.stdout result = StringIO() sys.stdout = result vc.print_cloned_experiments() sys.stdout = old_stdout result_string = result.getvalue() if not ("ser_rl_ss20_0" in result_string): vc.import_experiment('/home/bbpnrsoa/nrp/src/Worker/ser_rl_ss20.zip') else: print("Experiment already imported") sim = vc.launch_experiment('ser_rl_ss20_0') sim.start() exit()
def main(): # initialize agents if param.episode: str_ = 'double' if param.double else 'single' str_ += '_replay' if param.replay else '_noreplay' agent = pickle.load(open('results/agent_%s_%d.pkl' % (str_, param.episode), 'rb')) memory = pickle.load(open('results/memory_%s_%d.pkl' % (str_, param.episode), 'rb')) else: agent = Agent(param.n_observations, param.n_actions, param.n_neurons, param.gamma, param.batch_size, param.tau, param.double) memory = Memory(50000) # if you want to run the experiment from an external program, use VC # this will allow you to use frontend interface from python vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') # start training start = time.time() while param.episode < param.episodes: # choose initial position # start_pos = np.random.rand(2) * 10 + 3 # start_dir = np.random.rand() * 2 + np.pi # print('Starting position: %.2f %.2f' % (start_pos[0], start_pos[1])) # print('Starting direction: %.2f' % start_dir) start_pos = np.array([8.0, 8.0]) # with open(folder + 'experiment_configuration.exc', 'r') as file: # data = file.readlines() # data[13] = ' <robotPose robotId="husky" x="%.2f" y="%.2f" ' \ # 'z="0.5" roll="0.0" pitch="-0.0" yaw="%.2f" />\n' \ # % (start_pos[0], start_pos[1], start_dir) # with open(folder + 'experiment_configuration.exc', 'w') as file: # file.writelines(data) # launch experiment count = 0 while True: try: sim = vc.launch_experiment('template_husky_0') break except: count += 1 print('Try:', count) time.sleep(2) # subscribe to topics published by ros nhl.perform_subscribers() # start the experiment sim.start() time.sleep(2) # inner-loop for running an episode done = run_episode(start_pos, param.episode, agent, memory) if done: param.episode += 1 # stop experiment sim.stop() time.sleep(2) # save metrics and network for postprocessing if (param.episode + 1) % 100 == 0: dhl.save_objects(agent, memory, param.episode + 1) # print final score print('Time elapsed:', time.time() - start) print('Target score:', param.target_scores[-1]) print('Reward visits:', np.sum(param.reward_visits))
def main(): logger = init_logger() args = init_parser() num_generations = args['num_generations'] population_size = args['population_size'] mutation = args['mutation'] load = args['load'] subscribe_cylinder_distance() # create evolution evol = EvolutionaryAlgo(num_generations, population_size, mutation=mutation) if load: logger.warning('load generation {}'.format(load)) try: evol.load(load) except: raise ValueError('Could not load generation: {}'.format(load)) # log into the virtual coach vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') # start simulation logger.warning('start expe !!!') sim = vc.launch_experiment('template_manipulation_0') for gen in range(evol.generation_size): logger.warning('Generation: {}/{}'.format(gen + 1, evol.generation_size)) for individual in range(evol.population_size): logger.warning('Individual: {}/{}'.format(individual + 1, evol.population_size)) # set id evol.set_id(gen, individual) logger.warning('ID: {}'.format(evol.get_id(gen, individual))) # get weights weights = evol.get_weights(gen, individual) # run simulation distance = test_weights(sim, weights) # save distance evol.set_distance(distance, gen, individual) logger.warning('Distance: {}'.format(distance)) # save weights filen = evol.save(gen) logger.warning('Saved Generation {} to {}'.format(gen, filen)) # mutate generation if gen < evol.generation_size - 1: evol.mutate() # reset simulation sim.reset('full') # stop simulation sim.stop() # print best weights per generation for g in evol.generations: logger.warning("Elite:") logger.warning(g.get_elite(1))
new_individual = ind1.cross(ind2) new_individual.mutate() new_population.append(new_individual) population = new_population except (KeyboardInterrupt, rospy.exceptions.ROSInterruptException): pass finally: best = max(population, key=lambda x: x._fitness) logger.critical(best._fitness) logger.critical(repr(best.weights)) # log into the virtual coach, update with your credentials try: from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach vc = VirtualCoach(environment='local') except ImportError as e: print(e) print("You have to start this file with the command:\ cle-virtual-coach learn_weights.py") raise e sim = vc.launch_experiment('ExDHBPPrak_Motion') last_restart = time.time() try: # If you can't keep your logging diarrhea in check, I will not respect your private variables sim._Simulation__logger.setLevel(logging.WARNING) # Additionally, you may want to change line 281 of nrp_virtual_coach/simulation.py to # if 'state' in status and status['state'] in ['stopped', 'halted']: # to avoid additional (unproblematic) error messages genetic_search()
from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach import rospy import time import os vc = VirtualCoach(environment='local') fname_base = "/home/nrpuser/.ros/cdp4/experiment" for i in range(0, 10): print "### Running experiment %d" % i print "Launching" sim = vc.launch_experiment('cdp4') print "Starting" sim.start() while rospy.get_time() <= 8.7: time.sleep(2) print "Pausing" sim.pause() print "Stopping" sim.stop() while os.path.isfile(fname_base + ".bag.active"): time.sleep(2) print "Renaming" os.rename(fname_base + ".bag", fname_base + "_" + str(i) + ".bag")
import numpy as np import rospy from PIL import Image from geometry_msgs.msg import Pose from hbp_nrp_virtual_coach.virtual_coach import VirtualCoach from cdp4_data_collection import CDP4DataCollection as data_collection objects = list(['cube_a', 'coffee_machine','aeroplane_toy']) # create directory to save training data if doesn't exist if not os.path.exists('training_data'): os.mkdir('training_data') os.mkdir('training_data/images/') vc = VirtualCoach(environment='local', storage_username='******', storage_password='******') sim = vc.launch_experiment('cdp4_toy_experiment_0') sim.start() dc = data_collection() path = 'training_data' orig_pose = Pose() orig_pose.position.z = 10 for i in range(3): dc.add_object(objects[i], orig_pose) for i in range(100):