def rotate(actor, rot, safe=True): """ Rotates the actor to a given rotation in degrees | If safe mode is enabled, rotate becomes a blocking function which retries if it failed | Rotate seems to work even if safe mode is disabled""" loc = actor.get_transform().location while rot.pitch <= -180.0: rot.pitch += 360.0 while rot.yaw <= -180.0: rot.yaw += 360.0 while rot.roll <= -180.0: rot.roll += 360.0 t = transform(loc.x, loc.y, loc.z, rot.pitch, rot.yaw, rot.roll) actor.set_transform(t) if safe: # for some reason we must wait for the simulator to process this time.sleep(0.5) # Then we test if it worked r1 = actor.get_transform().rotation r2 = rot diff = ((r1.pitch - r2.pitch) ** 2 + (r1.yaw - r2.yaw) ** 2 + (r1.roll - r2.roll) ** 2) ** 0.5 if diff > 1.0: logger.warning(f'Failed rotating {actor.type_id} to {rot}') logger.info(f'Rotation is {r1}')
def normal_main_loop(env, dashboard): if AGENT_TYPE is AgentTypes.Network: agent = NetworkAgent(NETWORK_AGENT_MODEL_TYPE) elif AGENT_TYPE is AgentTypes.Keras: agent = KerasAgent() elif AGENT_TYPE is AgentTypes.Omniscient: agent = OmniscientAgent() else: logger.critical('Unknown agent type in main, raising error') raise RuntimeError('Unknown agent type in main') agent.load() statefilters = [ImageNoiseFilter(st_dev=0.001)] # st_dev = 0.02 is alright outputfilters = [MotorNoiseFilter(st_dev=0.001) ] # st_dev = 0.05 is alright memory = [] i = 0 while True: env.load_path(i) traveled = do_run(agent, env, dashboard, statefilters, outputfilters, memory) logger.info(f'Agent finished, traveled {traveled} meters') dashboard.clear() env.reset() train(agent, memory) logger.info('Continuing...') i += 1
def __set_conditions(self): current_map_name = self.connection.world.get_map().name # Loading correct map if current_map_name != MAP_NAME: logger.info(f'Loading map: {MAP_NAME} <- {current_map_name}') try: self.connection.world = self.connection.client.load_world( MAP_NAME) except RuntimeError as r: logger.critical(f'{r}') raise r else: # Destroying old actors actors = self.connection.world.get_actors() for actor in actors.filter('vehicle.*.*'): actor.destroy() for actor in actors.filter('sensor.*.*'): actor.destroy() if len(actors.filter('vehicle.*.*')) > 0 and len( actors.filter('sensor.*.*')) > 0: logger.debug('Cleaned up old actors') else: logger.warning('Issues while cleaning up old actors') # Setting nice weather self.__set_weather()
def _get_environment_variable(self) -> str: try: return os.environ['ENVIRONMENT'] except KeyError: logger.info( 'No variable passed, using default ENVIRONMENT: staging.') return 'staging'
def __connect(self): try: logger.info(f'Connecting to {HOST}:{PORT}...') self.client = icarla.client(HOST, PORT) # Even on a local machine, CARLA server takes about 2-3 seconds to respond - especially loading maps is long self.client.set_timeout(10.0) self.world = self.client.get_world() logger.info(f'Connected successfully') except RuntimeError as r: logger.error(f'Could not connect to server: {r}')
def train(agent, memory): # memory is a list, containing (prev_state, prev_action, state) triplets if TRAIN and not TRAIN_PER_DECISION: if TRAIN_MEMORY_SIZE is None or len(memory) >= TRAIN_MEMORY_SIZE: logger.info( f'{type(agent).__name__} is starting training with memory of {len(memory)}' ) agent.train_on_memory(memory) memory.clear() else: logger.info(f'Memory not full, {len(memory)}/{TRAIN_MEMORY_SIZE}')
def load(self, path=NETWORKAGENT_MODEL_PATH): logger.info(f'Loading model from {path}') try: self.model.load_model(path, dim_features=get_feature_dimension, image_height=AGENT_IM_HEIGHT, image_width=AGENT_IM_WIDTH, n_actions=choices_count, model=self.model_class) except FileNotFoundError as f: logger.error(f'Failed to find file at {path} - {f}') except RuntimeError as r: logger.critical(f'Failed to load agent from {path} - {r}')
def move(actor, loc, safe=True): """ Moves the actor to a given location | If safe mode is enabled, move becomes a blocking function which retries if it failed""" actor.set_location(loc) if safe: time.sleep(0.5) # for some reason we must wait for the simulator to process this d = actor.get_location().distance(loc) if d > 1.0: logger.warning(f'Failed moving {actor.type_id} to {loc}, retry...') logger.info(f'Actors transform is {actor.get_transform()}') actor.set_transform(carla.Transform(add_locations(loc, location(0, 0, 1)), rotation([0, 0, 0]))) time.sleep(0.5) d = actor.get_location().distance(loc) if d > 3.0: logger.error(f'Failed moving {actor.type_id} to {loc}') logger.info(f'Actors transform is {actor.get_transform()}') return
def log_list(li_name, li): if li is not None and len(li) > 0: logger.info(f'{li_name}:') for i, x in enumerate(li): logger.info(f'\t{i}. {type(x).__name__}') else: logger.info(f'No {li_name}')
def __update_path(self, i): self.path = get_path() # TODO (3) make prettier # if r < 1/6: # logger.info('Environment: normal short') # self.path.slice(None, 20) # elif r < 2/6: # logger.info('Environment: backwards short') # self.path.slice(70, None) # self.path.invert() # elif if i % 4 is 0: logger.info('Environment: normal full') pass elif i % 4 is 1: logger.info('Environment: backwards full') self.path.invert() elif i % 4 is 2: logger.info('Environment: normal turn (left)') self.path.slice(30, 60) elif i % 4 is 3: logger.info('Environment: backwards turn (right)') self.path.slice(40, 70) self.path.invert()
def log_settings(env): logger.info(f'Train is {TRAIN}') logger.info(f'Train per decision is {TRAIN_PER_DECISION}') logger.info(f'Environment is {type(env).__name__}')
def finish(self): logger.info(f'{self.__class__.__name__} finishing') pass
import glob import os import sys import time import numpy as np from support.logger import logger try: sys.path.append(glob.glob('files/carla-*%d.%d-%s.egg' % ( sys.version_info.major, sys.version_info.minor, 'win-amd64' if os.name == 'nt' else 'linux-x86_64'))[0]) except IndexError: logger.critical('IndexError while trying to find carla egg') logger.info('Place carla egg into files directory') sys.exit() try: import carla # Carla package uses the egg from Carla - Python installed package doesn't work except ModuleNotFoundError: logger.critical('ModuleNotFoundError while importing carla from egg') sys.exit() # TODO (8) hide ICarla with a proper interface or smth def client(host, port): return carla.Client(host, port) def transform(x=0.0, y=0.0, z=0.0, pitch=0.0, yaw=0.0, roll=0.0):
def train_multiple_main_loop(env, dashboard): # TODO (6) filters name, log, show properly trainer_agent = OmniscientAgent() trainees = [NetworkAgent(NetworkAgentModelTypes.SCNN), KerasAgent()] trainer_statefilters = [ImageNoiseFilter(st_dev=0.0001) ] # st_dev = 0.02 is alright trainee_statefilters = [] # st_dev = 0.02 is alright trainer_outputfilters = [MotorNoiseFilter(st_dev=0.05) ] # st_dev = 0.05 is alright trainee_outputfilters = [MotorNoiseFilter(st_dev=0.001) ] # st_dev = 0.05 is alright memory = [] trainer_agent.load() for t in trainees: t.load() logger.info(f'TrainerAgent is {type(trainer_agent).__name__}') log_list('Trainees', trainees) log_list('Trainer StateFilters', trainer_statefilters) log_list('Trainee StateFilters', trainee_statefilters) log_list('Trainer OutputFilters', trainer_outputfilters) log_list('Trainee OutputFilters', trainee_outputfilters) for j in range(10): logger.info(f'Starting epoch {j}') for i in range(4): env.load_path(i) traveled = do_run(trainer_agent, env, dashboard, trainer_statefilters, trainer_outputfilters, memory) logger.info( f'TrainerAgent finished Course {i}, traveled {traveled} meters' ) dashboard.clear() env.reset() logger.info('Continuing...') for trainee in trainees: train(trainee, memory[:]) for i in range(4): env.load_path(i) traveled = do_run(trainee, env, dashboard, trainee_statefilters, trainee_outputfilters, []) logger.info( f'Trainee {type(trainee).__name__} finished Course {i}, traveled {traveled} meters' ) # TODO (6) give names to agents - using the hash of their model dashboard.clear() env.reset() logger.info('Continuing...') memory.clear()
def save(self, path=NETWORKAGENT_MODEL_PATH): logger.info(f'Saving model to {path}') self.model.save_model(path)