def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track."""
global net
out = self.model(Variable(self.input))
self.input = self.update_state(out, carstate)
inputs = self.make_input(carstate, out.data)
if self.track_check1 == True and self.check_offtrack(carstate) == True:
self.track_check2 = True
if self.counter % 100 == 0:
self.track_check1 = self.check_offtrack(carstate)
self.temp_fitness += carstate.speed_x * (np.cos(carstate.angle*(np.pi/180)) - np.absolute(np.sin(carstate.angle * (np.pi/180))))
self.counter += 1
outputs = net.activate(inputs)
command = Command()
command.accelerator = outputs[0]
command.brake = outputs[1]
command.steering = outputs[2]
v_x = 350
self.counter += 1
self.accelerate(carstate, v_x, command)
if self.data_logger:
self.data_logger.log(carstate, command)
if carstate.damage >= 9500 or carstate.last_lap_time > 0 or carstate.current_lap_time > 60:
positions_won = 10 - carstate.race_position
damage = (carstate.damage) / 1000
global fitness
fitness = self.eta + (self.temp_fitness/self.counter) + positions_won - damage
command.meta = 1
return command
def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
"""
global net
# define the output
out = self.model(Variable(self.input))
self.input = self.update_state(out, carstate)
# code to check wheter the driver is stuck, namely if it is for a long time of track
if self.track_check1 == True and self.check_offtrack(carstate) == True:
self.track_check2 = True
if self.counter % 100 == 0:
self.track_check1 = self.check_offtrack(carstate)
# this is a previous used fitness function
#self.temp_fitness += carstate.speed_x * (np.cos(carstate.angle*(np.pi/180)) - np.absolute(np.sin(carstate.angle * (np.pi/180))))
# calculate the fitness
if(carstate.rpm > 8000 or carstate.rpm < 2500):
reward = -1
else:
reward = 1
self.temp_fitness += reward
# calculate the gear with the neat network
output = self.net.activate([carstate.rpm/10000])
# convert the outcome into a command
command = Command()
if(output[0] < -0.5):
command.gear = carstate.gear - 1
elif(output[0] > 0.5):
command.gear = carstate.gear + 1
else:
command.gear = carstate.gear
if command.gear < 1:
command.gear = 1
if command.gear > 6:
command.gear = 6
# Define the command with output of the other neural net
command.accelerator = out.data[0]
command.brake = out.data[1]
command.steering = out.data[2]
# update the counter
self.counter += 1
# log the command
if self.data_logger:
self.data_logger.log(carstate, command)
# If car has too much damage or max time has exceeded do a restart
if carstate.damage >= 9500 or carstate.last_lap_time > 0 or carstate.current_lap_time > 120:
global fitness
fitness = (self.temp_fitness/self.counter)
command.meta = 1
return command
def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track.
"""
command = Command()
command.meta = 0
#self.steer(carstate, 0.0, command)
# ACC_LATERAL_MAX = 6400 * 5
# v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
x_predict = [carstate.speed_x]
x_predict.append(carstate.distance_from_center)
x_predict.append(carstate.angle)
[x_predict.append(i) for i in carstate.distances_from_edge]
l_predict = x_predict
x_predict = np.array(x_predict)
x_predict = x_predict.reshape(1, 22)
#x_predict = scaler.transform(x_predict)
input_sensor = torch.Tensor(1, 22)
for i in range(0, 22):
input_sensor[0, i] = float(x_predict[0][i])
x_temp = Variable(torch.zeros(1, 22), requires_grad=False)
for j in range(0, 22):
x_temp.data[0, j] = input_sensor[0, j]
MyDriver.network.forward(x_temp)
output = MyDriver.network.output
self.speed_x += carstate.speed_x * (3.6)
#self.distance += carstate.distance_raced
self.distance = carstate.distance_raced
self.brake += abs(output.data[0, 1])
self.count += 1
command.accelerator = max(0.0, output.data[0, 0])
command.accelerator = min(1.0, command.accelerator)
#command.accelerator=0.8*command.accelerator
command.steering = output.data[0, 2]
command.steering = max(-1, command.steering)
command.steering = min(1, command.steering)
if (carstate.damage > 0 or carstate.distance_raced > 6400.00
or carstate.current_lap_time > 160.00):
self.msg = 'f'
#print("Layer Changed "+str(MyDriver.network.layer_changed))
fitness = MyDriver.w_distance * (
self.distance) + MyDriver.w_speed * (
self.speed_x / self.count) - MyDriver.w_brake * (
self.brake) + -MyDriver.w_damage * (carstate.damage)
print(fitness)
self.net_score[MyDriver.index] = fitness
print(
str(self.speed_x / self.count) + " " + str(self.distance) +
" " + str(self.brake / self.count) + " " +
str(carstate.current_lap_time) + " " + str(carstate.damage))
MyDriver.network.fitness = fitness
if ((MyDriver.index + 1) < len(MyDriver.networks)):
print(MyDriver.index)
MyDriver.index += 1
else:
print("else")
mutate = Mutate()
if (MyDriver.index <= MyDriver.num_childs):
MyDriver.add_network(MyDriver.network)
child_netowrk = mutate.do_mutate_network_sin(
MyDriver.get_best_network())
MyDriver.index += 1
MyDriver.networks.append(child_netowrk)
else:
print(str(datetime.now()))
folder_name = "data/evolution/" + str(datetime.now())
os.makedirs(folder_name)
for i in range(0, len(MyDriver.networks)):
path = folder_name + "/" + str(i) + ".pkl"
Network.save_networks(MyDriver.networks[i], path)
MyDriver.index = 0
print("Mutation on")
MyDriver.heap_size += 5
self.sort()
#MyDriver.networks=mutate.mutate_list(networks)
MyDriver.num_childs = MyDriver.num_childs + int(
0.1 * MyDriver.num_childs)
mutate = Mutate()
child_netowrk = mutate.do_mutate_network_sin(
MyDriver.get_best_network())
MyDriver.networks = []
MyDriver.networks.append(child_netowrk)
MyDriver.network = MyDriver.networks[MyDriver.index]
self.reinitiaze()
command.meta = 1
car_speed = carstate.speed_x * (3.6)
if (car_speed >= 0.0 and car_speed < 40.0):
command.gear = 1
if (car_speed >= 40.0 and car_speed < 70.0):
command.gear = 2
if (car_speed >= 70.0 and car_speed < 120.0):
command.gear = 3
if (car_speed >= 120.0 and car_speed < 132.0):
command.gear = 4
if (car_speed >= 132.0 and car_speed < 150.0):
command.gear = 5
if (car_speed >= 150.0):
command.gear = 6
if not command.gear:
command.gear = carstate.gear or 1
command.brake = min(1, output.data[0, 1])
command.brake = max(0, command.brake)
#self.accelerate(carstate, v_x, command)
#if self.data_logger:
# self.data_logger.log(carstate, command)
logging.info(
str(command.accelerator) + "," + str(command.brake) + "," +
str(command.steering) + "," + str(l_predict))
return command
def drive(self, carstate: State) -> Command:
"""
fitness calculation
"""
command = Command()
##########################################################
distance_from_edge = list(carstate.distances_from_edge[0:19])
# opponents = list(carstate.opponents[0:36])
# data = [carstate.speed_x,carstate.speed_y, carstate.distance_from_center, carstate.angle] + distance_from_edge + opponents
# distance_from_edge_left = abs(carstate.distances_from_edge[9] - carstate.distances_from_edge[8])
# distance_from_edge_right = abs(carstate.distances_from_edge[9] - carstate.distances_from_edge[10])
# data = [carstate.speed_x, carstate.distance_from_center, carstate.angle] + distance_from_edge
# data = pd.DataFrame(data)
# data = np.array(data)
##########################################################
# =======================================================================================
# net_break = joblib.load('nnmodel_brk.pkl')
# data_break = net_break.predict(data.transpose())
# command.brake = data_break[0]
# net_acc = joblib.load('nnmodel_acc.pkl')
# data_acc = net_acc.predict(data.transpose())
# command.accelerator = data_acc[0]
# ===============================================================================
command.accelerator = 1
command.brake = 0
command.steering = 0
# =============================================================================
# data = [carstate.speed_x, carstate.speed_y,carstate.distance_from_center, carstate.angle] + distance_from_edge + [
# distance_from_edge_left, distance_from_edge_right]
# with open('neat_torcs_winner_steering1.pkl', 'rb') as input:
# net_steering = pickle.load(input)
# steering_data = net_steering.activate(data)
# command.steering = steering_data[0]
# ========================================================================
# ========================================================================
angle = carstate.angle / np.math.pi
speed_x = (max(0, min(carstate.speed_x, 200)) / 100) - 1
distance_from_center = max(min(carstate.distance_from_center / 2, 1),
-1)
distance_from_edge = [((x + 1) / 100.5) - 1
for x in carstate.distances_from_edge]
distance_from_edge_left = abs(distance_from_edge[9] -
distance_from_edge[8]) / 2
distance_from_edge_right = abs(distance_from_edge[9] -
distance_from_edge[10]) / 2
data = [speed_x, distance_from_center, angle] + distance_from_edge + [
distance_from_edge_left, distance_from_edge_right
]
with open('neat_torcs_winner_steering_new.pkl', 'rb') as input:
net_steering = pickle.load(input)
steering_data = net_steering.activate(data)
command.steering = steering_data[0]
# with open('neat_torcs_winner_brake.pkl', 'rb') as input:
# net_brake = pickle.load(input)
# brake_data = net_brake.activate(data)
# brake_data[0] = brake_data[0] * 0.1
# print(brake_data[0])
# command.brake = brake_data[0]
# command.accelerator = 1 - brake_data[0]
# if (command.brake > 0.5):
# command.accelerator = 0
# ========================================================================
with open('network.p', 'rb') as input:
net = pickle.load(input)
# nw_activate = neatlite.generate_network(net)
# data_ = nw_activate(data)
data_ = net.activate(data)
# data = data_[0]
# print(data_)
command.brake = data_[0]
if data_[0] > 0.5:
command.accelerator = 0
# if command.brake > 0:
# command.accelerator=0
# if (data > 0.0):
# command.accelerator = 1
# command.brake =0
# if (data < 0.0):
# command.accelerator = 0
# command.brake = abs(data)
#
# if command.brake > 0.3:
# command.accelerator = 0
# else:
# command.accelerator = 1
#
# if (command.steering >0.4):
# command.accelerator = 0
# #
# command.accelerator = 1
# MAXSPEED = min(distance_from_edge_left , distance_from_edge_right)
# if (carstate.distances_from_edge[9] < 200):
# if (carstate.speed_x > max(MAXSPEED, 35) ):
# command.brake= 0.7 # max(0.7,command.brake)
# command.accelerator = 0 #min(0.3,command.accelerator)
# else:
# command.steering = command.steering * 0.1
# command.brake = command.brake * 0.1
#
# if (distance_from_edge_right < 25 or distance_from_edge_left < 25):
# if (carstate.speed_x > 15):
# command.brake = max(0.6, command.brake)
# if (distance_from_edge_right < 5 or distance_from_edge_left < 5):
# if (carstate.speed_x > 10):
# command.brake = max(0.6, command.brake)
#
# if carstate.distances_from_edge[9] > 70:
# command.steering = command.steering * 0.1
##########################################################
# FITNESS
#################################
#
MAX_DISTANCE = 4400
MAX_COUNTER = 45
TRACK_LENGTH = MAX_DISTANCE - 100
# self.counter = self.counter + 1
fitness = carstate.distance_from_start
# fitness = 10000 - carstate.current_lap_time
# fitness += self.reward
if carstate.distance_from_start > TRACK_LENGTH:
fitness = 0
# self.reward += ( 180 - (abs(carstate.angle))) * 0.001
# fitness += self.reward
counter = carstate.current_lap_time
# if (carstate.distance_from_start > MAX_DISTANCE and carstate.distance_raced > 100):
# self.fitness_to_file(fitness)
# print("COUNTER DISTANCE fitness: ", fitness, " counter: ", counter, " Distance: ",carstate.distance_from_start)
# command.meta = 1
if (counter > MAX_COUNTER):
self.fitness_to_file(fitness)
print("COUNTER MAX fitness: ", fitness, " counter: ", counter,
" Distance: ", carstate.distance_from_start)
command.meta = 1
# if (abs(carstate.angle) > 5 and carstate.current_lap_time > 5):
# self.fitness_to_file(fitness)
# print("BAD TURN fitness: ", fitness, " counter: ", counter, " Distance: ",carstate.distance_from_start)
# command.meta = 1
if (counter > 5 and counter < 10 and carstate.speed_x < 4):
# fitness = 0
self.fitness_to_file(fitness)
print("DID NOT MOVE fitness: ", fitness, " counter: ", counter,
" Distance: ", carstate.distance_from_start)
command.meta = 1
if (counter > 20 and carstate.speed_x < 1):
# fitness = 0
self.fitness_to_file(fitness)
print("STOPED MOVING fitness: ", fitness, " counter: ", counter,
" Distance: ", carstate.distance_from_start)
command.meta = 1
if (carstate.distance_raced < -2):
fitness = 0
self.fitness_to_file(fitness)
print("BACKWARD fitness: ", fitness, " counter: ", counter,
" Distance: ", carstate.distance_from_start)
command.meta = 1
if (abs(carstate.distance_from_center) > 0.9):
# fitness = 0
self.fitness_to_file(fitness)
print("OUT OF TRACK fitness: ", fitness, " counter: ", counter,
" Distance: ", carstate.distance_from_start)
command.meta = 1
# if (carstate.damage > 5000):
# self.fitness_to_file(fitness)
# print("DAMAGED fitness: ", fitness, " counter: ", counter, " Distance: ",carstate.distance_from_start)
# command.meta = 1
if (carstate.distance_from_start > TRACK_LENGTH - 100
and carstate.distance_from_start < TRACK_LENGTH):
self.fitness_to_file(TRACK_LENGTH)
print("MAX FITNESS fitness: ", TRACK_LENGTH, " counter: ",
counter, " Distance: ", carstate.distance_from_start)
command.meta = 1 #########################
# prevent sliding when out of track
# if carstate.distance_from_center > 1.1 : # out of track to left
# if carstate.speed_x > 5 :
# command.brake =1
# else:
# command.brake = 0
# command.accelerator = 0.1
# command.steering = -0.5
#
# elif carstate.distance_from_center < -1.1: # to right
# if carstate.speed_x > 5 :
# command.brake =1
# else:
# command.brake = 0
# command.accelerator = 0.1
# command.steering = 0.5
if carstate.rpm > 9000:
command.gear = carstate.gear + 1
if carstate.rpm < 4500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
if self.data_logger:
self.data_logger.log(carstate, command)
#initial acceleration
if (carstate.current_lap_time < 6):
command.accelerator = 1
command.brake = 0
command.steering = 0
# prevent stoping completly
# if (carstate.speed_x < 20):
# command.accelerator = 1
# command.brake=0
# if (carstate.distances_from_edge[9] > 200):
# command.accelerator=1
# command.brake=0
# command.steering = command.steering * 0.1
return command
def drive(self, carstate: State) -> Command:
#Get current state
state = self.get_state(carstate)
# Get current action
action = self.get_action(carstate, state)
# Get current reward
reward = self.get_reward(carstate)
# Keep track of the average reward
self.average_reward += reward
if self.counter > 0:
self.replay_memory.append(
(self.previous_state, self.action, reward, state, False))
# Check if replay memory is full
while len(self.replay_memory) > self.max_RM_size:
del self.replay_memory[np.random.randint(
0, len(self.replay_memory))]
command = Command()
# Predict brake and accelerate
out = self.model_acc_brake(Variable(self.input))
self.input = self.update_state(out, carstate)
#Create command
command = Command()
command.brake = out.data[1] * 0.2
# Maximum speed for training,
v_x = 300
self.counter += 1
self.counter_per_game += 1
self.accelerate(carstate, v_x, command)
command.steering = self.action_space[action]
self.action = action
self.previous_state = state
if carstate.damage > 0 or carstate.last_lap_time > 0:
command.meta = 1
# Add terminal states to the replay memory
if carstate.damage > 0:
self.replay_memory.append(
(self.previous_state, self.action, -100, np.ones(
(26, )), True))
else:
self.replay_memory.append(
(self.previous_state, self.action, 1000, np.ones(
(26, )), True))
self.save_variables()
print("distance:, ", carstate.distance_from_start)
print(
"------------------------------------------------------------------------------"
)
if self.exploration_rate == 0:
print("TEST DRIVE AVERAGE REWARD IS: ",
self.average_reward / self.counter_per_game)
print("THE DISTANCE DRIVEN BY THE AGENT IS: ",
carstate.distance_from_start)
print("EPISODE ENDED")
print(
"------------------------------------------------------------------------------"
)
return command
def drive(self, carstate: State) -> Command:
# count from race start
global count_s
global ACC
global client
global TRAIN
# if race finished
global termination
global CAR_ID
global CAR2_ID
global CAR_FILE_A
global CAR_FILE_B
global CAR2_FILE_A
global CAR2_FILE_B
global accerlate_credit
global break_penalty
global last_steering
global stable_penalty
global speed_reward
command = Command()
self.current_accelerator_controller = 'NEAT'
self.current_break_controller = 'NEAT'
self.current_steer_controller = 'NEAT'
self.swing = False
self.closer = False
count_s += 1
# * 3.6 to KM/H
speed = carstate.speed_x * 3.6
min_edge_value = 199.0
closest_edge_idx = -1
for idx, value in enumerate(carstate.distances_from_edge):
if value < min_edge_value:
min_edge_value = value
closest_edge_idx = idx
# calculate top speed
if not hasattr(self, 'top_speed'):
self.top_speed = 0.0
if speed > self.top_speed:
self.top_speed = speed
if not hasattr(self, 'stuck'):
self.stuck = False
self.stuck_count = 0
# calculate average speed
if not hasattr(self, 'average_speed'):
self.average_speed = 0.0
if not hasattr(self, 'volatility'):
self.volatility = 0.0
if not hasattr(self, 'volatility'):
self.volatility = 0.0
if not hasattr(self, 'average_angle'):
self.average_angle = 0.0
if not hasattr(self, 'speed_reward'):
self.speed_reward = 0.0
# some candidate of fitness funtion factors
self.speed_reward += speed*math.cos(math.radians(carstate.angle))
self.average_speed = (self.average_speed * (count_s - 1) + speed) / float(count_s)
self.average_angle = (self.average_angle * (count_s - 1) + np.cos(math.radians(carstate.angle))) / float(count_s)
if not hasattr(self, 'prev_steering'):
self.prev_steering = 0.0
if not hasattr(self, 'accumulate_speed_multiple_cos_angle'):
self.accumulate_speed_multiple_cos_angle = 0.0
if not hasattr(self, 'never_use_steer'):
self.never_use_steer = True
# input features
if carstate.speed_x < 1:
speed_x = 1
else:
speed_x = carstate.speed_x
radio_speed_xy = carstate.speed_z / speed_x
x = [(carstate.speed_x * 3.6 - 100) / 200, carstate.distance_from_center, carstate.angle / 360, radio_speed_xy] + ((np.array(list(carstate.distances_from_edge)) - 100) / 200).tolist()
self.accumulate_speed_multiple_cos_angle += speed * np.cos(math.radians(carstate.angle))
if DEBUG:
print('x', x)
# create output
y = self.output_net.activate(x)
# some candidate of fitness funtion factors
self.volatility = (self.volatility * (count_s - 1) + 5 * abs(y[2] - self.prev_steering)) / float(count_s)
self.prev_steering = y[2]
if DEBUG:
print('y', y)
# some candidate of fitness funtion factors
if abs(y[2]) > 0.1 and speed > 1:
self.never_use_steer = False
# automatically switch gear
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
# assign output
command.accelerator = y[0]
command.brake = y[1]
command.steering = y[2]
# Termination condition
# 1. speed too low for long time.
# 2. hit wall
# 3. off track
# 4. run long enough
if TRAIN or DUMP_WINNER:
if (carstate.current_lap_time > 3 and abs(speed - 0.0) < 3) or \
(carstate.current_lap_time > 30 and abs(speed - 0.0) < 20) or \
carstate.damage > 0 or \
carstate.distance_from_center >= 1 or \
carstate.distance_from_center <= -1 or \
carstate.distance_raced > 13000:
termination = True
if termination:
# fitness factors
fitness_factor['raced_distance'] = carstate.distance_raced
fitness_factor['top_speed'] = self.top_speed
fitness_factor['average_speed'] = self.average_speed
fitness_factor['volatility'] = self.volatility
fitness_factor['average_angle'] = self.average_angle
fitness_factor['accumulate_speed_multiple_cos_angle'] = self.accumulate_speed_multiple_cos_angle
fitness_factor['damage'] = carstate.damage
fitness_factor['never_use_steer'] = self.never_use_steer
fitness_factor['speed_reward'] = self.speed_reward
fitness_factor['time'] = carstate.current_lap_time
fitness_factor['last_lap_time'] = carstate.last_lap_time
print('fitness_factor:', fitness_factor)
# Reset parameters
termination = False
count_s = 0
# Ask server to restart
command.meta = 1
return command