def drive(self, carstate: State) -> Command: command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) input_data = np.reshape(input_data, (1, 22, 1)) # output = self.model.predict(input_data) # output = self.dense_model.predict(input_data) # output = self.lstm_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0.5: brake = 0 else: acceleration = 0 if acceleration > 0: 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 command.accelerator = acceleration command.brake = brake command.steering = steering return command
def drive(self, carstate: State) -> Command: command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) distance = carstate.distance_from_start distance_raced = carstate.distance_raced curlaptime = carstate.current_lap_time lastlaptime = carstate.last_lap_time time = curlaptime track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) opponents = carstate.opponents for i in range(9, len(opponents), 9): input_data.append(opponents[i]) input_data = np.reshape(input_data, (1,len(input_data))) output = self.alt_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0: 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 if track_edges[9] < 130.0 and track_edges[9] > 80.0: if speed > 40: acceleration = 0 brake = 0.05 elif track_edges[9] < 80 and track_edges[9] > 40: if speed > 25: acceleration = 0 brake = 0.05 elif track_edges[9] < 40: if speed > 15: acceleration = 0 brake = 0.05 if speed > 30: acceleration = 0 brake = 0.05 command.accelerator = acceleration command.brake = brake command.steering = steering # To train: #if time > 6 and distance_raced > 80 and distance > 20: # if lastlaptime < 2: # fitness = (distance*distance)/(time*1000.) # else: # fitness = 200 # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("down") # pyautogui.press("enter") # pyautogui.press("down") # pyautogui.press("enter") # pyautogui.press("right") # pyautogui.press("enter") # pyautogui.press("enter") # pyautogui.press("enter") # pyautogui.press("up") # pyautogui.press("enter") # exit(0) #else: # fitness = 0 #print(distance) #print(fitness) #if abs(angle) >= 80: # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #elif time > 5 and speed < 2: # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #elif time > 400: # print("Stop2") # print(fitness) # fitness = 250 # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #print(track_edges[9]) #print(command) return command
def drive(self, carstate: State) -> Command: command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) distance = carstate.distance_from_start distance_raced = carstate.distance_raced curlaptime = carstate.current_lap_time lastlaptime = carstate.last_lap_time time = curlaptime track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) opponents = carstate.opponents for i in range(9, len(opponents), 9): input_data.append(opponents[i]) input_data = np.reshape(input_data, (1, len(input_data))) output = self.alt_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0: 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 if track_edges[9] < 130.0 and track_edges[9] > 80.0: if speed > 40: acceleration = 0 brake = 0.05 elif track_edges[9] < 80 and track_edges[9] > 40: if speed > 25: acceleration = 0 brake = 0.05 elif track_edges[9] < 40: if speed > 15: acceleration = 0 brake = 0.05 if speed > 30: acceleration = 0 brake = 0.05 command.accelerator = acceleration command.brake = brake command.steering = steering # To train: #if time > 6 and distance_raced > 80 and distance > 20: # if lastlaptime < 2: # fitness = (distance*distance)/(time*1000.) # else: # fitness = 200 # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("down") # pyautogui.press("enter") # pyautogui.press("down") # pyautogui.press("enter") # pyautogui.press("right") # pyautogui.press("enter") # pyautogui.press("enter") # pyautogui.press("enter") # pyautogui.press("up") # pyautogui.press("enter") # exit(0) #else: # fitness = 0 #print(distance) #print(fitness) #if abs(angle) >= 80: # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #elif time > 5 and speed < 2: # print("Stop") # print(fitness) # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #elif time > 400: # print("Stop2") # print(fitness) # fitness = 250 # fi = open("fitness.p","wb") # pickle.dump(fitness, fi) # fi.close() # pyautogui.press("esc") # pyautogui.press("enter") # exit(0) #print(track_edges[9]) #print(command) return command
def drive(self, carstate: State) -> Command: command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) distance = carstate.distance_from_start distance_raced = carstate.distance_raced #print("Raced") #print(distance_raced) #print(distance) curlaptime = carstate.current_lap_time lastlaptime = carstate.last_lap_time time = curlaptime + lastlaptime #print(lastlaptime) #print(time) track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) input_data = np.reshape(input_data, (1,22)) output = self.alt_model.predict(input_data) #output = self.alt_model.activate(input_data) #print(output) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0: 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 if track_edges[9] < 130.0 and track_edges[9] > 80.0: if speed > 40: acceleration = 0 brake = 0.05 elif track_edges[9] < 60 and track_edges[9] > 40: if speed > 25: acceleration = 0 brake = 0.05 elif track_edges[9] < 40: if speed > 15: acceleration = 0 brake = 0.05 command.accelerator = acceleration command.brake = brake command.steering = steering if time > 5 and distance_raced > 15 and distance > 15: fitness = (distance*distance)/(time*1000.) else: fitness = 0 #print(distance) #print(fitness) if abs(angle) >= 90: print("Stop") print(fitness) pickle.dump(fitness, open("fitness.p","wb")) pyautogui.press("esc") pyautogui.press("enter") exit(0) elif time > 5 and speed < 2: print("Stop") print(fitness) pickle.dump(fitness, open("fitness.p","wb")) pyautogui.press("esc") pyautogui.press("enter") exit(0) elif time > 500: print("Stop") print(fitness) pickle.dump(fitness, open("fitness.p","wb")) pyautogui.press("esc") pyautogui.press("enter") exit(0) #print(track_edges[9]) #print(command) return command
def drive(self, carstate: State) -> Command: if self.speedup is None: self.speedup = any(opponent !=200 for opponent in carstate.opponents) print(self.speedup) command = Command() print(self.offtrack, carstate.distance_from_center) if(self.recovering): print('recovering') if abs(carstate.distance_from_center) > 1 or (carstate.angle > 45 and carstate.angle < 315) or self.recovering: self.offtrack += 1 if self.offtrack > 10: self.recovering = True self.accelerate(carstate, 20, command) self.steer(carstate, 0, command) if abs(carstate.distance_from_center) < 1 and (carstate.angle < 45 or carstate.angle > 315): self.recovering = False self.offtrack = 0 if command.steering < 0: command.steering = max(command.steering, -0.07) elif command.steering > 0: command.steering = min(command.steering, 0.07) return command sample = self.state2sample(carstate) result = self.net.activate(sample) command.accelerator = self.my_accelerate(carstate.speed_x) command.gear = self.shiftGears(carstate.gear, carstate.rpm) command.steering = result[0] - 0.5 command.brake = 0 interval = 10 position = math.floor(int(carstate.distance_from_start) / interval) with open('roadmap', 'rb') as file: self.roadmap = pickle.load(file) if self.speedup and position + 1 < len(self.roadmap): if max(self.roadmap[position:position + int(200 / interval)]) < 0.1 and carstate.speed_x < 180: command.accelerator = 1 else: if carstate.speed_x > 80: command.brake = 1 command.accelerator = 0 if len(self.roadmap) == position and int(carstate.distance_from_start) % interval == 0: self.roadmap.append(abs(command.steering)) print('Pos: {}, len(RM): {}'.format(position, len(self.roadmap))) with open('roadmap', 'wb') as file: pickle.dump(self.roadmap, file) print('brake: {}, acc: {}, steering: {}'.format(command.brake, command.accelerator, command.steering)) return command
def drive(self, carstate: State): # at the begin of the race: determine on which position the car starts if self.previous_position == 0: self.previous_position = carstate.race_position print('Starting in %s position'%carstate.race_position) self.ID = carstate.race_position self.team_mate_pos = self.ID + 1 # in the very beginning, both team mates should behave as if they were first if self.use_team: self.position_file = './team_communication/positions/'+str(self.ID)+'.txt' with open(self.position_file, 'w') as file: file.write(str(carstate.race_position)+"\n") if self.use_team: """ determine position relative to team mate """ # if not team_check: # check if there are 2 files for root, dirs, files in os.walk("./team_communication/positions"): if len(files) < 2: # no team mate self.team_mate_pos = 100 for filename in files: if filename != str(self.ID)+'.txt': team_mate_pos = np.loadtxt("./team_communication/positions/"+filename, ndmin=1) self.team_mate_pos = int(team_mate_pos[-1]) if carstate.race_position < self.team_mate_pos: self.is_first = True else: self.is_first = False self.team_check = False if carstate.race_position != self.previous_position: # log the changed race position with open(self.position_file, 'a') as file: file.write(str(carstate.race_position)+"\n") t = carstate.current_lap_time if t < self.last_cur_lap_time: # made a lap, adjust timing events accordingly print('Lap completed, in position %s'%carstate.race_position) self.off_time -= carstate.last_lap_time self.recovered_time -= carstate.last_lap_time self.stopped_time -= carstate.last_lap_time self.last_cur_lap_time = t # initialize the driving command command = Command() """ Collect Input Data. Speed, Track Position, Angle on the track and the 19 values of the Track Edges """ sensor_SPEED = carstate.speed_x * 3.6 # Convert from MPS to KPH sensor_TRACK_POSITION = carstate.distance_from_center sensor_ANGLE_TO_TRACK_AXIS = carstate.angle * math.pi / 180 sensor_TRACK_EDGES = carstate.distances_from_edge if sensor_SPEED < 2: if not self.is_stopped: self.is_stopped = True self.stopped_time = t else: self.is_stopped = False """ Process Inputs. Feed the sensor data into the network to produce a Accelrator, Brake and Steering command """ sensor_data = [min(sensor_SPEED, 300)/300, sensor_TRACK_POSITION, sensor_ANGLE_TO_TRACK_AXIS] x = np.array(sensor_TRACK_EDGES) / 200 sensor_data += list(x) if self.is_stopped & (t > self.stopped_time + 2) & (not self.recovering): self.recovering = True self.is_stopped = False #print(self.RECOVER_MSG) print('Stopped for 2 seconds...') if self.recovering: """ Recovery Bot """ self.simpleDriver(sensor_data, carstate, command) if np.abs(sensor_TRACK_POSITION) < 1: # recovered! # self.stuck = 0 if not self.warm_up: #print('Back on track...') self.recovered_time = t self.warm_up = True self.off_track = False # considered recovered if moving fast and straightish if (t > self.recovered_time + 2) & (sensor_SPEED > 50) & (np.abs(sensor_ANGLE_TO_TRACK_AXIS) < 0.5): self.recovering = False self.warm_up = False self.init_time = t + 1 print('~~ Recovered! ~~') #print('+-'*18) else: self.off_track = True self.warm_up = False else: """ Drive using the EchoStateNet """ # check if car is off road and if so, for how long if np.abs(sensor_TRACK_POSITION) > 1: if self.off_track == False: #print("### OFF ROAD ###") if self.use_team: # write to pheromone.txt warning team mate: self.drop_pheromone(carstate.distance_from_start) self.off_time = t self.off_track = True if t > self.off_time + 3: # haven't recovered in 3 seconds # get back on road and start new evaluation self.recovering = True print('Off road for 3 seconds...') else: self.off_track = False """ apply team strategy: if the car is behind his team mate, try to block opponents comming from behind """ # print(self.is_first) if self.use_team and not self.is_first and abs(carstate.distance_from_center) < 0.6: closest_opponent = np.argmin(carstate.opponents) if closest_opponent > 26: delta = abs(closest_opponent-35) # get values between 0 (if opponent is directly behind) and 8 (if opponent is at to the car's right ) delta /= 10.0 # scale to values between 0 and 1 # delta = 0.2 adjusted_track_position = min(1, sensor_TRACK_POSITION + delta) sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer towards the opponent if closest_opponent < 9: delta = closest_opponent/10.0 # scale to values between 0 (if opponent is directly behind) and 1 (if opponent is at to the car's left ) adjusted_track_position = max(-1, sensor_TRACK_POSITION - delta) sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer towards the opponent print('Blocking Opponent') """ overtaking strategy """ if self.use_overtaking_assistant: closest_opponent = np.argmin(carstate.opponents) distance_to_opponent = carstate.opponents[closest_opponent] #print(closest_opponent) close_opponents_left = carstate.opponents[3:9] left = min(close_opponents_left) < 20 close_opponents_front_left = carstate.opponents[9:18] # front left quarter front_left = min(close_opponents_front_left) < 100 close_opponents_front_right = carstate.opponents[18:28] # front right quarter front_right = min(close_opponents_front_right) < 100 close_opponents_right = carstate.opponents[28:32] right = min(close_opponents_right) < 20 """ overtaking """ #if (closest_opponent > 5 and closest_opponent < 12) or (closest_opponent > 24 and closest_opponent < 30): if not (front_left or front_right): # if no opponents are in front if abs(carstate.angle) < 20 and distance_to_opponent > 5: # assure that overtaking makes sense self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_OVERTAKE # increase speed limit to enable fast overtaking #print('speed up!') """ get around an opponent on the car's left/front """ #if closest_opponent >= 12 and closest_opponent < 18 and carstate.distance_from_center > -0.75: if front_left and not (front_right or right) and carstate.distance_from_center > -0.75: if np.argmin(close_opponents_front_left) < 50: delta = 0.5 else: delta = 0.3 #scale = 1/(max(1,distance_to_opponent)) #delta = (np.argmin(close_opponents_front_left))/len(close_opponents_front_left) # dependent on angle: if opponent is in the front, steer stronger #print('move to the right!') #print('delta = '+str(delta)) adjusted_track_position = min(1, sensor_TRACK_POSITION + delta) sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer away from the opponent """ get around an opponent on the car's right/front """ #if closest_opponent >= 18 and closest_opponent <= 24 and carstate.distance_from_center < 0.75: if front_right and not (front_left or left) and carstate.distance_from_center < 0.75: if np.argmin(close_opponents_front_right) < 50: delta = 0.5 else: delta = 0.3 #scale = 1/(max(1,distance_to_opponent)) delta = abs(np.argmin(close_opponents_front_right) - len(close_opponents_front_right) + 1)/len(close_opponents_front_right) #print('move to the left!') #print('delta = '+str(delta)) adjusted_track_position = max(-1, sensor_TRACK_POSITION - delta) sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer away from the opponent """ load ESN if it is not yet available, predict the driving command """ try: output = self.esn.predict(sensor_data,continuation=True) # print('esn already loaded') except: # load ESN from specified path self.esn = neuralNet.restore_ESN(self.PATH_TO_ESN) # start a new 'history of states' output = self.esn.predict(sensor_data,continuation=False) print('Loaded ESN from %s'%self.PATH_TO_ESN) """ Controller extension: Multi-Layer Perceptron that adjust the driving commands if opponents are close """ # modifiy ESN output based on the opponents data # only if car is not racing at the first position self.active_mlp = False #if self.use_mlp_opponents and carstate.race_position > 1: if self.use_mlp_opponents: opponents_data = carstate.opponents # if closest opponent is less than 50m away, use mlp to adjust outputs distance_limit = 50.0 if min(opponents_data) < distance_limit: self.active_mlp = True self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_OVERTAKE #print('-------------use mlp---------------') mlp_input = [output[0],output[1]] #print(opponents_data) for sensor in opponents_data: # normalize opponents_data to [0,1] mlp_input.append(sensor/distance_limit) """ load MLP if it is not yet available, predict the driving commands """ try: change_output = self.mlp.predict(np.asarray(mlp_input)) except: self.mlp = neuralNet.restore_MLP(self.PATH_TO_MLP) change_output = self.mlp.predict(np.asarray(mlp_input)) print('Loaded MLP for overtaking') # adjust the ESN output based on the MLP output output += change_output self.esn.set_last_outputs(output) """ determine if car should accelerate or brake """ if self.use_team: # check if near any difficult positions that have been communicated by pheromones: pheromones = np.loadtxt(open('./team_communication/pheromones.txt', 'rb'), ndmin=1) if pheromones.size > 0: for p in pheromones: dist = float(p) - carstate.distance_from_start if np.abs(dist) < 100: self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_CAREFUL # print('### CAREFUL MODE ###') break else: if not self.active_mlp: self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL else: # if on second position in team, slow down when opponent is directly behind if not self.is_first: closest_opponent = np.argmin(carstate.opponents) if closest_opponent == 0 or closest_opponent == 35: self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_BLOCKING else: if not self.active_mlp: # print('### NORMAL MODE ###') self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL else: if not self.active_mlp: self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL else: if not self.active_mlp: # print('### NORMAL MODE ###') self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL if output[0] > 0: if sensor_SPEED < self.CURRENT_SPEED_LIMIT: accel = min(max(output[0],0),1) else: accel = 0 brake = 0.0 else: accel = 0.0 brake = min(max(-output[0],0),1) steer = min(max(output[1],-1),1) # uncomment to print current input and output data """ print('Speed: %.2f, Track Position: %.2f, Angle to Track: %.2f\n'%(sensor_data[0], sensor_data[1], sensor_data[2])) print('Accelrator: %.2f, Brake: %.2f, Steering: %.2f'%(accel, brake, steer)) print('Field View:') print(''.join('{:3f}, '.format(x) for x in sensor_data[3:])) """ """ Apply Accelrator, Brake and Steering Commands. """ # for the first second do not listen to the network # this allows it to initate it's state if t > self.init_time: command.accelerator = accel command.brake = brake command.steering = steer else: self.simpleDriver(sensor_data, carstate, command) """ Automatic Transmission. Automatically change gears depending on the engine revs """ if not self.recovering: if carstate.rpm > 8000 and command.accelerator > 0: command.gear = carstate.gear + 1 elif carstate.rpm < 2500: command.gear = max(1, carstate.gear - 1) if not command.gear: command.gear = carstate.gear or 1 # save position information for the next simulation step self.previous_position = carstate.race_position return command
def drive(self, carstate: State) -> Command: # threading.Thread(target=c.communicate, args=(carstate, "communication.csv")).start() command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) opponents = carstate.opponents for i in range(0, len(opponents), 9): if not i == 27: input_data.append(opponents[i]) input_data = np.reshape(input_data, (1,len(input_data))) # output = self.model.predict(input_data) # output = self.alt_model.predict(input_data) output = self.opponents_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0: 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 if track_edges[9] < 130.0 and track_edges[9] > 80.0: if speed > 40: acceleration = 0 brake = 0.05 elif track_edges[9] < 60 and track_edges[9] > 40: if speed > 25: acceleration = 0 brake = 0.05 elif track_edges[9] < 40: if speed > 15: acceleration = 0 brake = 0.05 command.accelerator = acceleration command.brake = brake command.steering = steering 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
def cheesy_drive(self, carstate): ''' Opponent obstruction behaviour ''' command = Command() angle_change = 2 self.check_jesus_position(carstate) # enter obstruction mode if self.cheesus_state == 0: # come to a stop if carstate.speed_x > 1: command.brake = 1 # once stopped, measure track and enter turning procedure else: self.track_width = carstate.distances_from_edge[ 0] + carstate.distances_from_edge[18] self.cheesus_state = 1 # turning procedure elif self.cheesus_state == 1: if carstate.angle < self.last_angle - angle_change: self.last_angle = carstate.angle self.cheesus_state = 2 else: command.gear = 1 if carstate.speed_x < 5: command.accelerator = 1 if carstate.speed_x > 0: command.steering = 1 else: command.brake = 1 # turning procedure elif self.cheesus_state == 2: if np.abs(carstate.angle) > 88: self.cheesus_state = 3 else: if carstate.angle < self.last_angle - angle_change: self.last_angle = carstate.angle self.cheesus_state = 1 else: command.gear = -1 if carstate.speed_x < 0: command.steering = -1 else: command.brake = 1 if carstate.speed_x > -5: command.accelerator = 1 # exit turning procedure elif self.cheesus_state == 3: command.brake = 1 command.steering = 0 command.accelerator = 0 if carstate.speed_x > -1: self.cheesus_state = 4 # oscillation forward elif self.cheesus_state in [4, 5]: command.gear = 1 if self.cheesus_state == 4 else -1 command.steering = 0 if np.abs(carstate.speed_x) < 3: command.accelerator = 1 if (self.cheesus_state == 4 and carstate.distance_from_center > .03 * self.track_width)\ or (self.cheesus_state == 5 and carstate.distance_from_center < -.03 * self.track_width): command.brake = 1 if not self.close_to_jesus: self.cheesus_state = 5 if self.cheesus_state == 4 else 4 if np.abs(carstate.angle) < 89: command.steering = -0.2 if np.abs(carstate.angle) > 91: command.steering = 0.2 return command
def drive(self, carstate: State, offroad_count, turn_around_count, negative_speed_count) -> Command: command = Command() max_dist = 200.0 react_dist = 200.0 max_angle = 180.0 max_speed = 200.0 / 3.6 max_rpm = 10000 # left_side = list(carstate.distances_from_edge[:9])[::-1] # right_side = list(carstate.distances_from_edge[10:]) middle_sens = carstate.distances_from_edge[9] opps = list(carstate.opponents) for i, dist in enumerate(opps): if dist == 200.: opps[i] = 0. # back_opp = opponents[0] # left_opp = opponents[1:18][::-1] # forward_opp = opponents[18] # right_opp = opponents[19:] # even_sens = [x + y for x,y in zip(left_side, right_side)] # uneven_sens = [x - y for x,y in zip(left_side, right_side)] # edges = even_sens + uneven_sens + [middle_sens] edges = [np.exp(-x / react_dist) for x in carstate.distances_from_edge] # even_opp = even_sens = [x + y for x,y in zip(left_opp, right_opp)] # uneven_opp = even_sens = [x - y for x,y in zip(left_opp, right_opp)] # opps = even_opp + uneven_opp + [forward_opp] + [back_opp] offroad = False if middle_sens == -1.: offroad_count += 1 offroad = True edges = 19 * [0] else: for i, dist in enumerate(edges): if dist > 0: edges[i] = np.exp(-dist / react_dist) else: edges[i] = -np.exp(dist / react_dist) turn_around = False if carstate.angle > 100 or carstate.angle < -100: turn_around_count += 1 turn_around = True negative_speed = False if carstate.speed_x < 0: negative_speed_count += 1 negative_speed = True for i, dist in enumerate(opps): if dist != 0.: opps[i] = np.exp(-dist / react_dist) input_vector = edges + [carstate.speed_x/max_speed] + [carstate.speed_y/max_speed] + [carstate.speed_z/max_speed] + [carstate.angle/max_angle] + \ [carstate.distance_from_center] + [carstate.rpm/max_rpm] #+ opps # print("LEN", len(input_vector)) output_vector = self.network.NN(input_vector) # speed_value = 200. * (output_vector[0] + 1.)/2. speed_value = output_vector[0] # Combination of acceleration and brake acceleration_value = 0. brake_value = 0. if speed_value > 0: acceleration_value = speed_value elif speed_value < 0: brake_value = -speed_value steer_value = output_vector[1] if not math.isnan(output_vector[2]): gear_value = int(((output_vector[2] + 1) / 2) * 5 + 1) else: gear_value = 1 command.gear = gear_value command.accelerator = acceleration_value command.brake = brake_value command.steering = steer_value # self.accelerate(carstate, speed_value, command) # self.steer(carstate, steer_value, command) fitness = fitness_function(carstate.distance_from_start, carstate.distance_raced, carstate.damage, offroad_count, carstate.race_position, carstate.last_lap_time, turn_around_count, negative_speed_count) # print('------') # # print() # # print("input_vector ", input_vector) # # print() # # print("weights_matrix ", np.array(self.network.weights_matrix)) # # print() # # print("output vector ", output_vector) # print() # print("acceleration_value ", acceleration_value) # print("brake_value ", brake_value) # print("steer_value ", steer_value) # print("gear_value ", gear_value) # print() # # print("input vector ", input_vector) # print("turn_around_count " , turn_around_count) # print("negative speed count " , negative_speed_count) # print("carstate.speed_x " , carstate.speed_x ) # print("carstate.speed_y " , carstate.speed_y ) # print("carstate.speed_z " , carstate.speed_z ) # print() # print("distance_from_start ", carstate.distance_from_start) # print("distance_raced ", carstate.distance_raced) # print("damage ", carstate.damage) # print("offroad ", offroad) # print("offroad count ", offroad_count) # print("race_position ", carstate.race_position) # print() # # print(list(carstate.opponents)) # # print() # print("fitness ", fitness) # # print() return command, fitness, offroad_count, turn_around_count, negative_speed_count
def drive(self, carstate: State) -> Command: if carstate.distance_raced < 3: try: self.dict["position"] = carstate.race_position with open("mjv_partner{}.txt".format(self.port), "wb") as handle: pickle.dump(self.dict, handle, protocol=pickle.HIGHEST_PROTOCOL) except: pass path = os.path.abspath(os.path.dirname(__file__)) for i in os.listdir(path): if os.path.isfile(os.path.join( path, i)) and 'mjv_partner' in i and not str(self.port) in i: self.partner = i.strip('mjv_partner').strip('.txt') else: self.race_started = True try: with open("mjv_partner{}.txt".format(self.partner), 'rb') as handle: self.dict_teammate = pickle.load(handle) self.dict["position"] = carstate.race_position with open("mjv_partner{}.txt".format(self.port), "wb") as handle: pickle.dump(self.dict, handle, protocol=pickle.HIGHEST_PROTOCOL) # print(self.port, self.dict_teammate["position"]) # print("RESULT", carstate.race_position > int(self.dict_teammate["position"])) if carstate.race_position > int( self.dict_teammate["position"]): self.is_leader = False else: self.is_leader = True except: print("Not able to read port", self.port) pass # print(self.dict_teammate) # print(self.port, self.leader) # print("Distance: {}".format(carstate.distance_from_start)) # Select the sensors we need for our model self.speeds.append(carstate.speed_x) command = Command() distances = list(carstate.distances_from_edge) sensors = [ carstate.speed_x, carstate.distance_from_center, carstate.angle, *(carstate.distances_from_edge) ] # CRASHED off_road = all(distance == -1.0 for distance in distances) standing_still = self.recovers == 0 and all( abs(s) < 1.0 for s in self.speeds[-5:]) if self.race_started and (off_road or self.recovers > 0): command = self.recover(carstate, command) if not self.crash_recorded: self.crash_recorded = True self.dict["crashes"].append(carstate.distance_raced) # NOT CRASHED else: self.crash_recorded = False if carstate.gear == -1: carstate.gear = 2 if self.norm: # Sensor normalization -> ? sensors = self.normalize_sensors(sensors) # Forward pass our model y = self.model(Variable(torch.Tensor(sensors)))[0] # Create command from model output command.accelerator = np.clip(y.data[0], 0, 1) command.brake = np.clip(y.data[1], 0, 1) command.steering = np.clip(y.data[2], -1, 1) command = self.smooth_commands(command) # print(self.race_started and not self.is_leader) # print("LEADER", self.is_leader) if self.race_started and not self.is_leader and carstate.distance_from_start > 50: command = self.check_swarm(command, carstate) # Naive switching of gear self.switch_gear(carstate, command) # print("Accelerate: {}".format(command.accelerator)) # print("Brake: {}".format(command.brake)) # print("Steer: {}".format(command.steering)) if self.record is True: sensor_string = ",".join([str(x) for x in sensors]) + "\n" self.file_handler.write( str(y.data[0]) + "," + str(y.data[1]) + "," + str(y.data[2]) + "," + sensor_string) return command