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 setup(self):
logger.debug('Environment setup')
self.connection.connect()
self.__set_conditions()
# self.__update_path()
self.__spawn()
self.reset()
def check(self, environment):
finished = False
successful = False
reason = 'UNKNOWN'
coll = environment.data.get(DataKey.SENSOR_COLLISION)
pos = environment.data.get(DataKey.SENSOR_POSITION)
if pos is not None:
pos = [pos[0], pos[1]]
d = environment.path.distance(pos)
else:
pos = None
d = -1.0
if coll is not None:
finished = True
reason = 'Collision'
if d > MAX_OFF_DISTANCE:
finished = True
reason = f'Too far from path: {MAX_OFF_DISTANCE} meters'
logger.debug(pos)
logger.debug(environment.path.find_segment(pos).start)
if pos is not None and distance(
environment.path.find_segment(pos).end,
environment.path.end) < 0.1:
finished = True
successful = True
reason = 'At finish'
self.finished = finished
self.successful = successful
self.reason = reason
self.dist = distance(pos, environment.path.start)
self.traveled = environment.path.distance_along_path(pos)
def main():
logger.debug('main starting')
if ENVIRONMENT_TYPE is EnvironmentTypes.CARLA:
env = CarlaEnvironment()
elif ENVIRONMENT_TYPE is EnvironmentTypes.Replay:
env = ReplayEnvironment()
else:
logger.critical('Unknown environment type in main, raising error')
raise RuntimeError('Unknown environment type in main')
dashboard = DashboardThread()
log_settings(env)
try:
env.setup()
env.start()
dashboard.start()
# normal_main_loop(env, dashboard)
train_multiple_main_loop(env, dashboard)
finally:
if env is not None:
for actor in env.actors:
actor.destroy()
del env # Make sure to forget env after we cleaned up it's actors
logger.debug('Cleaned up')
def run(self):
self.beginning()
while not self.stop:
while not self.data.get(DataKey.THREAD_HALT) and not self.stop:
self.loop()
logger.debug(f'{self.__class__.__name__} sleeping')
time.sleep(1.0)
self.finish()
def run(self):
self.beginning()
while not self.stop:
while not self.stop:
self.loop()
logger.debug(f'{self.__class__.__name__} sleeping')
time.sleep(1.0)
self.finish()
def reset(self):
logger.debug('Resetting actors')
self.clear()
logger.warning('Halting threads')
self.data.put(DataKey.THREAD_HALT, True)
self.vehicle.apply_control(icarla.vehicle_control(throttle=0, steer=0))
icarla.set_velocity(self.vehicle, icarla.vector3d())
logger.debug('Environment reset successful')
def load(self):
if os.path.isfile(
f'{file_name}.data-00000-of-00001'): # search for actual file
self.network.load_weights(file_name)
logger.debug(
f'Successfully loaded {file_name} model in KerasModel.load()')
else:
logger.error(f'{file_name} file not found in KerasModel.load()')
def __set_weather(self):
weather = self.connection.world.get_weather()
weather.precipitation = 0.0
weather.precipitation_deposits = 0.0
weather.wetness = 0.0
self.connection.world.set_weather(weather)
logger.debug('Applied nice weather')
def __spawn(self):
logger.debug('Spawning actors, sensors')
if self.path is None:
spawn_vehicle(self, [0.0, 0.0], [0.0, 0.0, 0.0])
else:
spawn_vehicle(self, self.path.start, self.path.direction())
spawn_camera(self)
spawn_radar(self)
spawn_collision(self)
spawn_obstacle(self)
def balance(trainables):
leftchoices = []
rightchoices = []
for trainable in trainables:
if np.argmax(trainable[1]) == 0:
leftchoices.append(trainable)
elif np.argmax(trainable[1]) == 1:
rightchoices.append(trainable)
leftchoices = leftchoices[:min(len(leftchoices), len(rightchoices))]
rightchoices = rightchoices[:min(len(leftchoices), len(rightchoices))]
logger.debug(
f'Trainables: {len(trainables)} -> {len(leftchoices)+len(rightchoices)}'
)
return leftchoices + rightchoices
def train_on_memory(self, memory):
x = 0
r = [[], []]
for (prev_state, prev_action, state) in memory:
x += 1
reward = self.optimize(state, prev_state, prev_action)
r[prev_action].append(reward)
logger.debug(f'Successfully trained {x} times')
for i, action_rewards in enumerate(r):
logger.debug(
f'Action rewards (ID, AVG, AMOUNT) '
f'-:- {i}; {np.average(action_rewards)}; {len(action_rewards)}'
)
self.model.reset()
self.save()
def do_run(agent, env, dashboard, statefilters, outputfilters, memory):
env.clear()
status = Status()
prev_state = None
prev_action = None
# This is the loop of a run
while status.finished is False:
frame_start = time.time_ns()
# Get data from environment and format it
data, path, starting_dir = env.pull()
state = convert(repack(data, path, starting_dir))
# Apply filters to state
for sf in statefilters:
state = sf.filter(state)
if TRAIN and TRAIN_PER_DECISION and prev_state is not None:
agent.optimize(state)
# Agent predicts
action, out = agent.predict(state)
# Apply filters to output
for of in outputfilters:
action, out = of.filter(action, out)
# Update dashboard
dashboard.handle(state, out)
# Tell env about the choice
if out is not None:
env.put(DataKey.CONTROL_OUT, out)
# Update memory
if prev_state is not None and prev_action is not None and state is not None:
memory.append([prev_state, prev_action, state])
prev_state = state
prev_action = action
apply_frame_time(frame_start)
status = env.check()
logger.debug(f'{status}')
return status.traveled
def create(self):
# TODO (5) check validity of model architecture
network = keras.Sequential([
# Input ex.: INPUT_SHAPE = 80, 60, 1
keras.Input(shape=INPUT_SHAPE),
# Layer (1)
layers.Conv2D(16, 7, strides=4, activation='relu', padding='same'),
# layers.MaxPooling2D(3, strides=2), # TODO (4) valueerror
layers.Lambda(tf.nn.local_response_normalization),
# Layer (2)
layers.Conv2D(32, 5, strides=4, activation='relu', padding='same'),
# layers.MaxPooling2D(3, strides=2),
layers.Lambda(tf.nn.local_response_normalization
), # TODO (3) change to BatchNormalization()
# Layer (3)
layers.Conv2D(32, 3, activation='relu', padding='same'),
# # Layer (4)
# layers.Conv2D(64, 3, activation='relu', padding='same'),
# # Layer (5)
# layers.Conv2D(256, 3, activation='relu', padding='same'),
layers.MaxPooling2D(2, strides=2),
layers.Lambda(tf.nn.local_response_normalization),
layers.Flatten(), # I added this
# Layer (6) # I changed 4096->2048->256
# layers.Dense(128, activation='tanh'),
# layers.Dropout(0.5),
# Layer (7) # I changed 4096->512->32
layers.Dense(8, activation='tanh'),
# layers.Dropout(0.5),
# Layer (8)
layers.Dense(choices_count, activation='softmax'),
])
loss = tf.keras.losses.BinaryCrossentropy()
network.compile(loss=loss,
optimizer=SGD(lr=LEARNING_RATE),
metrics=['accuracy'])
logger.debug('Skipping kerasmodel summary')
# network.summary()
self.network = network
def nameof(var, outside_locals):
if var is None:
logger.debug(f'Not searching for name of None var in nameof()')
return 'None'
if issubclass(type(var), Iterable) and all(v is None for v in var):
logger.debug(f'Not searching for name of Nones var in nameof()')
return 'Nones'
for string, val in outside_locals.items():
if type(var) == type(val) and var == val:
return string
elif isinstance(val, object):
try:
string = nameof(var, val.__dict__)
if string is not None:
return string
except AttributeError:
pass
logger.warning(f'Did not find name of var {var} in nameof()')
return None
def set_velocity(actor, velocity, safe=True):
"""
Sets the velocity of the actor to a given speed
| If safe mode is enabled, set_velocity becomes a blocking function which retries if it failed"""
if not safe:
actor.set_target_velocity(velocity)
if safe:
first = True
while (actor.get_velocity().x**2+actor.get_velocity().y**2+actor.get_velocity().z**2)**0.5 > 0.1:
if not first:
logger.debug('Previous attempt at setting vehicle velocity unsuccessful')
logger.debug('Setting vehicle velocity to 0...')
actor.set_target_velocity(velocity)
time.sleep(0.5)
first = False
logger.debug('Velocity is approx. 0')
# based on kerasmodel.py from Tamás Visy's temalab_gta repo
import gc
from settings import choices_count, AGENT_IM_WIDTH, AGENT_IM_HEIGHT
from support.logger import logger
# TODO (2) move and update warnings - best into readme or somewhere where they are actually read
logger.debug('Use a NumPy version with allow_pickle enabled')
logger.warning('Tensorflow warnings and info suppressed')
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
logger.debug('Tensorflow 2 requires 64 bit Python')
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.optimizers import SGD
from tensorflow.lite.python.lite import TFLiteConverterV2
import numpy as np
import os
logger.debug('Keras imports finished')
INPUT_SHAPE = [AGENT_IM_WIDTH, AGENT_IM_HEIGHT, 1] # [WIDTH, HEIGHT, 1]
LEARNING_RATE = 0.1
PATH_PREFIX = ''
METRIC = 'val_loss'
def optimize(self, new_state):
logger.debug('OmniscientAgent does not optimize')
import math
import numpy as np
from support.logger import logger
PATH_FILE_NAME = 'files/path.npy'
path_file_points = np.load(PATH_FILE_NAME)
logger.debug(f'Loaded file {PATH_FILE_NAME} for path.py')
class Path:
# a 2D path consisting of segments
def __init__(self, points):
self.points = None
self.start = None
self.end = None
self.__set_points(points)
def __set_points(self, points):
self.points = points
self.start = self.points[0]
self.end = self.points[-1]
def slice(self, start=None, to=None):
if start is None:
start = 0
if to is None:
to = len(self.points)
self.__set_points(self.points[start:to])
def clear(self):
# Clears all data -> removes thread_halt -> threads can resume
logger.debug('Clearing data')
self.data.clear()
def clear(self):
if self.window is not None:
self.window.clear()
else:
logger.debug('Window is None, can not handle clear')
def beginning(self):
logger.debug(f'{self.__class__.__name__} started')
def set_stop(self):
if self.window is not None:
self.window.add_event(QUIT)
else:
logger.debug('Window is None, can not stop')
def handle(self, state, out=None):
if self.window is not None:
self.window.handle(state, out)
else:
logger.debug('Window is None, can not handle incoming')
def save(self):
logger.debug('OmniscientAgent does not save')
def train(self, train, test, epochs=None):
# awaiting as {ndarray: (X,)}
# inside: x {ndarray: (2,)}
# inside: {ndarray: (width, height)}* and float? *or other way (height, width)
logger.debug(
f'Num GPUs Available: {len(tf.config.experimental.list_physical_devices("GPU"))}'
)
model_checkpoint_callback = keras.callbacks.ModelCheckpoint(
filepath=checkpoint_file_names,
save_weights_only=True,
monitor=METRIC,
mode='min',
save_best_only=False) # revert to True if needed
initial_epoch = 0
found = False
path = ''
for i in list(range(1000))[::-1]:
path = checkpoint_file_names.format(epoch=i)
if not found and os.path.isfile(path):
logger.debug(f'File exists, loading checkpoint {path}')
self.network.load_weights(path)
if epochs is None:
initial_epoch = i
found = True
if not found:
logger.warning(f'No checkpoint found at {path}')
logger.debug('Reshaping data...')
train_x = []
train_y = []
for i in train:
train_x.append(i[0])
train_y.append(i[1])
train_x = np.array(train_x).reshape(
[-1, INPUT_SHAPE[0], INPUT_SHAPE[1], INPUT_SHAPE[2]])
train_y = np.array(train_y)
logger.debug('Training data finished')
test_x = np.array([i[0] for i in test]).reshape(
[-1, INPUT_SHAPE[0], INPUT_SHAPE[1], INPUT_SHAPE[2]])
test_y = np.array([i[1] for i in test])
logger.debug(
'Starting training on {} data with {} data as test set'.format(
len(train_x), len(test_x)))
if epochs is None:
e = 10
else:
e = epochs
# (4.) Training the CNN
logger.debug('Not printing epoch training data in KerasModel')
self.network.fit(train_x,
train_y,
validation_data=(test_x, test_y),
epochs=e,
initial_epoch=initial_epoch,
callbacks=[model_checkpoint_callback],
verbose=0)
# Saving the weights
self.network.save_weights(file_name)
logger.debug('Finished training, cleaning up...')
# Long training session can crash
tf.keras.backend.clear_session() # TODO (4) check whether it helps
gc.collect() # TODO (2) remove if doesn't help
logger.debug('Done')
def load(self):
logger.debug('OmniscientAgent does not load')
def run(self):
logger.debug(f'{self.__class__.__name__} started')
self.window = Window()
logger.debug(f'{self.__class__.__name__} ready')
self.window.work()
logger.debug(f'{self.__class__.__name__} finished')
