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