def drive(self, carstate: State) -> Command: print('Drive') self.print_log(carstate) self.update(carstate) command = Command() command.accelerator = 1 command.gear = 1 command.brake = 0 command.steering = 0 #-1 * carstate.angle * np.pi / (180.0 * 0.785398) if carstate.speed_x > 1 and command.gear >= 0 and command.brake < 0.1 and carstate.rpm > 8000: command.gear = min(6, command.gear + 1) if carstate.rpm < 2500 and command.gear > 1: command.gear = command.gear - 1 if not command.gear: command.gear = carstate.gear or 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() stateList = self.stateToArray(carstate) # output = self.network.activate(stateList) output = self.network.forward(stateList).data print(output) #self.steer(carstate, output[0, 2], command) command.steering = output[0, 0] command.accelerator = output[0, 1] command.brake = output[0, 2] if command.accelerator > 0: if carstate.rpm > 8000: command.gear = carstate.gear + 1 if command.accelerator < 0: if carstate.rpm < 2500: command.gear = carstate.gear - 1 if not command.gear: command.gear = carstate.gear or 1 #acceleration = output[0,1]*129 #acceleration = math.pow(acceleration, 3) #if acceleration > 0: # if abs(carstate.distance_from_center) >= 1: # off track, reduced grip: # acceleration = min(0.4, acceleration) # command.accelerator = min(acceleration, 1) # if carstate.rpm > 8000: # command.gear = carstate.gear + 1 #else: # command.brake = min(-acceleration, 1) #if carstate.rpm < 2500: # command.gear = carstate.gear - 1 #if not command.gear: # command.gear = carstate.gear or 1 #if output[0,0]>0.5: # ACC_LATERAL_MAX = 6400 * 5 # v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering))) #else: # v_x = 0 #self.accelerate(carstate, 85, command) if self.data_logger: self.data_logger.log(carstate, command) return command
def shift(self, carstate: State, command: Command): if carstate.rpm > 9000: command.gear = carstate.gear + 1 if carstate.rpm < 2500 and carstate.gear > 1: command.gear = carstate.gear - 1 if not command.gear: command.gear = carstate.gear or 1
def step(self, carstate: State, command: Command): command.accelerator = 1 command.brake = 0 command.gear = carstate.gear if command.gear >= 0 and carstate.rpm > 8000: command.gear = min(6, command.gear + 1) if carstate.rpm < 2500 and command.gear > 1: command.gear = command.gear - 1 if not command.gear: command.gear = carstate.gear or 1
def recovery_drive(self, carstate): ''' Recovery driving behaviour ''' ANGLE_THRESHOLD = 10 BRAKING_CENTER_TRACK_THRESHOLD = 0.1 command = Command() self.epochs_unmoved = 0 print("Recovery") if np.abs(carstate.angle) > ANGLE_THRESHOLD: recovery_steering = 0.9 command.steering = recovery_steering if carstate.distance_from_center > 0 else -recovery_steering command.gear = 1 if carstate.angle * carstate.distance_from_center > 0 else -1 if carstate.distance_from_center < 0: if (carstate.speed_x < -1 and carstate.angle < 0) or (carstate.speed_x > 1 and carstate.angle > 0): if carstate.distance_from_center < -BRAKING_CENTER_TRACK_THRESHOLD: command.brake = 1 command.accelerator = 0 else: command.steering = -command.steering else: command.accelerator = 0.5 command.brake = 0 else: if (carstate.speed_x < -1 and carstate.angle > 0) or (carstate.speed_x > 1 and carstate.angle < 0): if carstate.distance_from_center > BRAKING_CENTER_TRACK_THRESHOLD: command.brake = 1 command.accelerator = 0 else: command.steering = -command.steering else: command.accelerator = 0.5 command.brake = 0 else: command.steering = -1 if carstate.distance_from_center > 0 else 1 command.accelerator = .5 command.gear = -1 # check if recovery complete if -ANGLE_THRESHOLD < carstate.angle < ANGLE_THRESHOLD: self.recovery = False print("The lord hath risen!") return command
def drive(self, car_state: State) -> Command: """ Produces driving command in response to newly received car state. """ self.last_state = car_state feature_vector = self.feature_transformer.transform(car_state) steering, brake, acceleration = self.network.activate(feature_vector) # print("steering", steering) # print("brake", brake) # print("acceleration", acceleration) command = Command() command.accelerator = acceleration command.brake = brake # push steering into a [-1, 1] range command.steering = (steering * 2) - 1 if acceleration > 0: if car_state.rpm > 8000: command.gear = car_state.gear + 1 if car_state.rpm < 2500 and car_state.gear > 2: command.gear = car_state.gear - 1 if not command.gear: command.gear = car_state.gear or 1 if self.data_logger: self.data_logger.log(car_state, command) if self.call_number % 100 == 0: print(command) print(car_state.distance_raced) print(self.stop_flag.value) print() # early stopping if self.call_number > 100 and car_state.distance_raced < 10: self.stop_flag.set(True) self.call_number += 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. """ # f = open("Test_data3.txt","a+") # f.write("\n*** "+str(carstate)+"\n") command = Command() # constructing the input x_predict = [abs(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] x_predict = np.array(x_predict) x_predict = x_predict.reshape(1, 22) x_predict = scaler.transform(x_predict) input_sensor = tf.convert_to_tensor(data_np, np.float32) # predicting the output y_predict = output, s_prev = predict_action(x_predict, s_prev, u_z, w_z, u_r, w_r, u_h, w_h, w_out) command.accelerator = y_predict[0][0] if command.accelerator < 0: command.brake = y_predict[0][1] command.steering = y_predict[0][2] if carstate.rpm < 2500 and carstate.gear > 0: command.gear = carstate.gear - 1 elif carstate.rpm > 8000: command.gear = carstate.gear + 1 if not command.gear: command.gear = carstate.gear or 1 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) 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): command = Command() command.steering = carstate.angle / 180 if carstate.angle > 30 or carstate.angle < -30: command.brake = 0.5 command.accelerator = 0 else: command.brake = 0 command.accelerator = 1 command.gear = 1 return command
def step(self, carstate: State, command: Command): command.accelerator = min( 1, (carstate.distance_from_center - 0.2)**4) #2 - min(carstate.distances_from_edge) command.gear = -1 command.brake = 0.0 command.clutch = 0.0 command.steering = -1 * carstate.angle * np.pi / (180.0 * 0.785398) * 1.5 return True
def step(self, carstate: State, command: Command): if self.front_stuck > 15: d = min(carstate.distances_from_edge) command.accelerator = max(0, min(1, 1.3 - 0.7 * d)) command.gear = -1 command.brake = 0.0 command.clutch = 0.0 command.steering = -1 * carstate.angle * np.pi / (180.0 * 0.785398) else: if carstate.speed_x < 3: command.gear = 1 if carstate.rpm > 8000: command.gear = min(6, command.gear + 1) if carstate.rpm < 2500: command.gear = command.gear - 1 if command.gear <= 0: command.gear = 1 command.accelerator = 1 command.gear = 1 if carstate.gear <= 0 else carstate.gear command.brake = 0.0 command.clutch = 0.0 command.steering = carstate.angle * np.pi / (180.0 * 0.785398) command.steering -= 0.35 * np.sign( carstate.distance_from_center) * min( 1.5, math.fabs(carstate.distance_from_center)) return True
def drive(self, carstate: State) -> Command: command = Command() current_state = state_to_vector(carstate) command_vector = self.model.take_wheel(current_state) command = vector_to_command(command_vector) command.accelerator = 1.0 command.brake = 0.0 current_gear = carstate.gear current_rpm = carstate.rpm if current_gear != self.last_gear: self.last_gear = current_gear print("Added downshift", carstate.gear) self.downshift.append(carstate.rpm) if current_gear == 0: command.gear = 1 elif current_gear == 6: command.gear = current_gear elif self.upshifts[current_gear-1] <= current_rpm: command.gear = current_gear + 1 self.last_gear = current_gear else: command.gear = current_gear if self.epoch > 2500: f = open(self.save_path + "/result.txt", 'w') if carstate.distance_raced < 20000: f.write(str(carstate.distance_raced)) print(self.downshift) else: f.write(str(0)) f.close() sys.exit() self.epoch += 1 return command
def drive(self, carstate: State) -> Command: # translate carstate to tensor for NN x_in = Variable(carstate_to_tensor(carstate)) # get speed/steering target acc_break_steer_prediction = self.model(x_in).data print(acc_break_steer_prediction) # based on target, implement speed/steering manually command = Command() command.accelerator = acc_break_steer_prediction[0] command.brake = acc_break_steer_prediction[1] command.steering = acc_break_steer_prediction[2] command.gear = acc_break_steer_prediction[3] self.last_command = command return command
def drive(self, carstate: State) -> Command: # # NN_MODEL # x_test = self.convert_carstate_to_array(carstate) # predicted = self.nn_model(Variable(torch.from_numpy(x_test))).data.numpy() # # command = Command() # # command.accelerator = predicted[0][0] # command.brake = predicted[0][1] # command.steering = predicted[0][2] # # # if carstate.rpm < 2500: # # command.gear = carstate.gear - 1 command = Command() command = self.reservoir_computing(carstate, command) if not command.gear: command.gear = carstate.gear or 1 if carstate.rpm > 1500: command.gear = carstate.gear + 1 return command
def overtake_drive(self, carstate): ''' Behaviour for overtaking opponents ''' print("Overtaking") command = Command() state = state_to_dict(carstate, apply_mask=False) # collect distance to opponents in front dist_opponents_f = state['opponents'][17] dist_opponents_l = state['opponents'][8] dist_opponents_r = state['opponents'][26] # sanity checks if min(state['opponents']) > min(carstate.speed_x, 40): self.avoidance_state = 0 print("sanity giving back control (opponents)") return command if np.abs(carstate.distance_from_center) > .9: self.avoidance_state = 0 print("sanity giving back control (center)") return command # init avoidance steering avoidance_steering = .1 * np.sign(self.avoidance_state) # check if already overtaking if np.abs(self.avoidance_state) == 1 and np.abs(carstate.angle) > min( 10, 250 / carstate.speed_x): self.avoidance_state = 2 * np.sign(self.avoidance_state) # check if we should steer back if np.abs(self.avoidance_state) == 2: avoidance_steering *= -1 # check if car should stop steering if np.abs(carstate.angle) < 5: avoidance_steering = 0 self.avoidance_state = 3 * np.sign(self.avoidance_state) # check if pass was completed if self.avoidance_state == 3 and dist_opponents_l > 10: avoidance_steering = 0 self.avoidance_state = 0 if self.avoidance_state == -3 and dist_opponents_r > 10: avoidance_steering = 0 self.avoidance_state = 0 # create command command.steering = avoidance_steering print("avoidance steering: ", avoidance_steering) command.accelerator = 1 command.gear = self.my_gear return command
def drive(self, carstate): self.it += 1 x = [carstate.angle, carstate.speed_x, carstate.speed_y, carstate.speed_z] + \ list(carstate.distances_from_edge) + \ [carstate.distance_from_center] pred_y = list(self.model.predict(x).data)[0] command = Command() command.accelerator = pred_y[0] command.brake = pred_y[1] command.steering = pred_y[2] gear_flt = pred_y[3] if self.it > 750 else self.it / 250.0 command.gear = min(5, max(1, int(gear_flt + 0.5))) print(self.it, "acc: %.2f, brk: %.2f, ste: %.2f, gea: %.2f" % (command.accelerator, command.brake, command.steering, gear_flt), end='\r') return command
def drive(self, carstate: State): # https://github.com/lanquarden/pyScrcClient/blob/master/src/driver.py steer = (carstate.angle - carstate.distance_from_center * 0.5) / self.steer_lock rpm = carstate.rpm gear = carstate.gear if self.prev_rpm is None: up = True else: if (self.prev_rpm - rpm) < 0: up = True else: up = False if up and rpm > 7000: gear += 1 if not up and rpm < 3000: gear -= 1 speed = carstate.speed_x accel = 1 if self.prev_accel is None else self.prev_accel if speed < self.max_speed: accel += 0.1 if accel > 1: accel = 1.0 else: accel -= 0.1 if accel < 0: accel = 0.0 command = Command() command.accelerator = accel command.steering = steer command.gear = gear self.prev_accel = command.accelerator return command
def make_next_command(self, carstate): command = Command() # we switch gears manually gear = self.gear_decider(carstate) # we get the steering prediction steer_pred = self.steer_decider(carstate, steering_values=self.steering_values) # steer_pred = self.steer_decider_nn(carstate) # pedal =[-1;1], combining breaking and accelerating to one variable pedal = self.speed_decider(carstate, max_speed=self.global_max_speed) # make sure we don't drive at people opponents_deltas = list(map(sub, carstate.opponents, self.last_opponents)) steer_pred, pedal = self.deal_with_opponents(steer_pred, pedal, carstate.speed_x, carstate.distance_from_center, carstate.opponents, opponents_deltas) # disambiguate pedal with smoothing brake, accel = self.disambiguate_pedal(pedal, accel_cap=1.0, break_cap=0.75, break_max_length=5) command.brake = brake command.accelerator = accel command.steering = steer_pred command.gear = gear return command
def drive(self, carstate: State) -> Command: command = Command() out = self.model(Variable(self.input)) self.input = self.update_state(out, carstate) # If crashed -> reversing if self.crashed: self.check_back_on_track(carstate) command.accelerator = 0.5 command.gear = -1 # Only steer if incorrect angle and off track if abs(carstate.angle) > 20 and abs( carstate.distance_from_center) < 1: # If car orientated towards the right if carstate.angle > 0: # Steer to right while reversing command.steering = -1 # self.forward_steer_direction = 1 self.forward_steer_direction = 0.5 else: # Steer to left while reversing command.steering = 1 # else: # Steer to right while reversing # command.steering = -1 # self.forward_steer_direction = 1 self.forward_steer_direction = -0.5 # command.steering = 1 # self.forwardCounter -= 1 self.resetGear = True elif self.forwardCounter > 0: # print("Turning to correct direction") if self.forwardCounter > 200: command.brake = 1 # if abs(carstate.angle) > : if carstate.angle > 0: command.steering = 0.5 else: command.steering = -0.5 # command.steering = self.forward_steer_direction command.accelerator = 0.5 command.gear = 1 self.forwardCounter -= 1 # Normal behaviour else: out = self.model(Variable(self.input)) self.input = self.update_state(out, carstate) self.update_history(carstate) self.detect_crash() command.accelerator = out.data[0] command.brake = out.data[1] command.steering = out.data[2] begin_corner = self.check_for_corner(command.steering, carstate.distance_from_start) begin_acceleration, end_acceleration = self.check_for_acceleration( command.steering, carstate.distance_from_start) if begin_corner > 0: self.pheromones.append(("Corner", begin_corner)) if begin_acceleration > 0: self.pheromones.append( ("Accel", begin_acceleration, end_acceleration)) if self.counter % 50 == 0: pickle.dump(self.pheromones, open("../sent_3001.txt", "wb")) if os.path.isfile("../sent_3001.txt"): self.received = pickle.load(open("../sent_3001.txt", "rb")) v_x = 500 max_speed, accel, brake, steer = self.check_for_info( self.received, carstate.distance_from_start, carstate.speed_x) if max_speed is not None: v_x = max_speed command.accelerator = accel command.brake = brake if steer == 0: command.steering = steer #command.gear = self.get_gear(carstate) USE NEAT TO SHIFT GEARS self.accelerate(carstate, v_x, command) if self.resetGear: #command.gear = self.get_gear(carstate) self.resetGear = False if carstate.speed_x * 3.6 < 20: command.brake = 0 self.counter += 1 self.input[2] = command.accelerator 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: """ 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: 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, car_state: State) -> Command: command = Command() target_speed = 100 # # Damage Control # target_speed -= car_state.damage * .05 # # if target_speed < 25: # target_speed = 25 # # Steer To Corner # steer = car_state.angle * (10 / 3.14) # # Steer To Center # steer -= car_state.distance_from_center * .10 # # if steer < -1: # steer = -1 # if steer > 1: # steer = 1 self.steer(car_state, 0.0, command) steer = command.steering if car_state.speed_x > target_speed: accelerate = 0.2 else: accelerate = 0.8 # Throttle Control if car_state.speed_x < target_speed - (steer * 50): accelerate += .01 else: accelerate -= .01 if car_state.speed_x < 10: accelerate += 1 / (car_state.speed_x + .1) wheelVel = car_state.wheel_velocities # Traction Control System if ((wheelVel[2] + wheelVel[3]) - (wheelVel[0] + wheelVel[1]) > 5): accelerate -= .2 if accelerate < 0: accelerate = 0 if accelerate > 1: accelerate = 1 if accelerate > 0: if car_state.rpm > 8000: command.gear = car_state.gear + 1 if car_state.rpm < 2500 and car_state.gear > 2: command.gear = car_state.gear - 1 if not command.gear: command.gear = car_state.gear or 1 command.accelerator = accelerate command.steering = steer print(accelerate) self.prev_command = command return command
def drive(self, carstate: State): X=np.zeros((1,41)) # # print("mehmeh",carstate) # # X[0]=carstate.speed with open('model.json', 'r') as json_file: loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") X[0][0]=carstate.angle print('meh') X[0][1]=carstate.speed_x/280 # X[3]=carstate.distance_from_start X[0][21]=carstate.distances_from_edge[0]/200 X[0][22]=carstate.distances_from_edge[1]/200 X[0][23]=carstate.distances_from_edge[2]/200 X[0][24]=carstate.distances_from_edge[3]/200 X[0][25]=carstate.distances_from_edge[4]/200 X[0][26]=carstate.distances_from_edge[5]/200 X[0][27]=carstate.distances_from_edge[6]/200 X[0][28]=carstate.distances_from_edge[7]/200 X[0][29]=carstate.distances_from_edge[8]/200 X[0][30]=carstate.distances_from_edge[9]/200 X[0][31]=carstate.distances_from_edge[10]/200 X[0][32]=carstate.distances_from_edge[11]/200 X[0][33]=carstate.distances_from_edge[12]/200 X[0][34]=carstate.distances_from_edge[13]/200 X[0][35]=carstate.distances_from_edge[14]/200 X[0][36]=carstate.distances_from_edge[15]/200 X[0][37]=carstate.distances_from_edge[16]/200 X[0][38]=carstate.distances_from_edge[17]/200 X[0][39]=carstate.distances_from_edge[18]/200 # print(carstate.distances_from_edge[19]) X[0][40]=carstate.distance_from_center X[0][2]= carstate.opponents[0]/200 X[0][3]= carstate.opponents[1]/200 X[0][4]=carstate.opponents[2]/200 X[0][5]= carstate.opponents[3]/200 X[0][6]=carstate.opponents[4]/200 X[0][7]= carstate.opponents[5]/200 X[0][8]= carstate.opponents[6]/200 X[0][9]= carstate.opponents[7]/200 X[0][10]= carstate.opponents[8]/200 X[0][11]= carstate.opponents[9]/200 X[0][12]= carstate.opponents[10]/200 X[0][13]=carstate.opponents[11]/200 X[0][14]= carstate.opponents[12]/200 X[0][15]= carstate.opponents[13]/200 X[0][16]= carstate.opponents[14]/200 X[0][17]= carstate.opponents[15]/200 X[0][18]= carstate.opponents[16]/200 X[0][19]= carstate.opponents[17]/200 X[0][20]= carstate.opponents[19]/200 # fitnesses = [] sumofSensors=0 for i in range(19): sumofSensors+=np.sqrt(carstate.distances_from_edge[i]) # print((summ*0.3)+50) #action = self.net.advance(X, 1, 10) print('mehblahmeh') #------------------------------------------------------------------------------- action=loaded_model.predict(X,batch_size=1,verbose=1) print('mehblahmeh',action) # exit() #------------------------------------------------------------------------------- # front=((carstate.distances_from_edge[8]+carstate.distances_from_edge[9])/2) # brakeoff=0 # if front<100 : # manualSpeed=70 # if not self.flag: # brakeOff=0.50 # self.flag=True # else: # brakeOff=0 # else: # self.flag=False # brakeOff=0 # manualSpeed=front+50 # # print(front) # # print(action) # # print("heeeey") # summ=np.zeros(6) # for i in range(len(X[4:])): # # print(len(X[4:])) # if i <4 : # summ[0]+=X[i] # elif i<7: # summ[1]+=X[i] # elif i<9: # summ[2]+=X[i] # elif i<11: # summ[3]+=X[i] # elif i<14: # summ[4]+=X[i] # elif i<18: # summ[5]+=X[i] command = Command() # if carstate.gear ==3: # gear=3 # v_x= (action[0]*170)+40#(sumofSensors*1.3)#((action[2]*250)**2)+70 # self.accelerate(carstate, v_x, command) # print(command.accelerator) # averages=np.zeros(10) # averages[0]=summ[0]/4 # averages[1]=summ[1]/3*5 # averages[2]=summ[2]/2*15 # averages[3]=summ[3]/2*15 # averages[4]=summ[4]/3*5 # averages[5]=summ[5]/4 # averages[6]=X[0] # averages[7]=X[1] # averages[8]=X[2] # averages[9]=command.accelerator gear=carstate.gear # X[0]=carstate. # X[0]=carstate.speed # gear=carstate.gear # inp=np.zeros(3) # inp[0]=command.accelerator # inp[1]=X[1] # inp[2]=X[2] # # X[0]=carstate. # X[0]=carstate.speed Kp=0.003 dfromC=carstate.distance_from_center # if carstate.distance_from_center==-1: # dfromC=-10 # elif carstate.distance_from_center==1: # dfromC=10 error=(carstate.angle-dfromC*12) pidoff=Kp*carstate.angle*100 pid=Kp*error # print(action) # print(pid) # X=list(carstate) # print(X) #self.net.Input(X) #self.net.Activate() #action = self.net.Output() # # print(action,"mehblah") # # # if y[0][0] > 0: # ((action[0]*2)-1)*0.7 # x=np.array(()) # self.steer(carstate,0, command) # # else: # # command.brake = min(-acceleration, 1) # steer=action[0] # if (action[0]*2)-1<-0.2: # steer=-0.2 # elif (action[0])*2-1>0.2: # steer=0.2 # brake=0.01 # if action[1]>0.8: # accel=0.8 # elif action[1]<0.4: # accel=0.4 # steeraction=action.index(max(action)) # if steeraction==0: # command.steering=-0.7 # elif steeraction==1: # command.steering=-0.4 # elif steeraction==2: # command.steering=-0.2 # elif steeraction==3: # command.steering=-0.1 # elif steeraction==4: # command.steering=-0.05 # elif steeraction==5: # command.steering=0 # elif steeraction==6: # command.steering=0.05 # elif steeraction==7: # command.steering=0.1 # elif steeraction==8: # command.steering=0.2 # elif steeraction==9: # command.steering=0.4 # elif steeraction==10: # command.steering=0.7 # brake=action[2] # if action[2]>0.2: # brake=0.2 # elif action[1]<0.4: # accel=0.4 # v_x = (((((action[2]-1)*-1)**2)-1)*-1*100)+95 # if carstate.rpm < 2500: # command.gear = carstate.gear - 1 # if not command.gear: # command.gear = 1 # print("mehblah",carstate.distance_from_center) # self.data_logger.log(carstate,command) # print(y) # if carstate.distance_from_center>1.5 or carstate.distance_from_center<-1.5: # self.data_logger.close() # self.data_logger = None # else: # if carstate.distances_from_edge[8]<65 and carstate.distances_from_edge[8]>0: # command.brake=(((carstate.distances_from_edge[8]/65)-1)*-1)**3 # # if carstate.distances_from_edge[8]==-1.0: # command.brake=0 # command.accelerator=0.8 # command.steering=pidoff # print(action) # print((action[0]*2)-1) if carstate.rpm>7000: gear+=1 elif carstate.gear==0: gear+=1 elif carstate.rpm<2000 and X[0][1]>10: print(X[0][1]) gear-=1 # if command.accelerator==0: # command.brake=0.02 # else: # command.brake=0 print('blahandreas',action[0][0]) command.accelerator=1#float(action[0][0])+2#0.4#accel#y[0][0] command.brake=action[0][1]#abs(pid)*2#y[0][1]*y[0][1] command.steering=action[0][2] # command.steering=((action[0]*2)-1)*0.7#steer command.gear=gear command.focus=0 # command.gear=1 # print(command) # print(command) return command
def make_next_command(self, carstate): """ Description Args: carstate: The full carstate object as passed to Driver() Returns: command: The command object to pass back to the server """ # checking in on the swarm position = carstate.distance_from_start position = int(position - (position % self.swarm.pos_int)) new_frame = position > (self.previous_frame_position + self.swarm.pos_int) new_lap = self.previous_frame_position > (position + self.swarm.pos_int) if ENABLE_SWARM and (new_frame or new_lap): self.max_speed = self.swarm.check_in(position, carstate.speed_x, self.crashed_in_last_frame, self.contact_in_last_frame) self.crashed_in_last_frame = False self.contact_in_last_frame = False self.previous_frame_position = position err(self.iter, "SWARM: pos=%i, max_speed=%i" % (position, self.max_speed)) # basic predictions if ENABLE_NETWORK: steer_pred = self.steering_model.predict( [carstate.angle, carstate.speed_x] + list(carstate.distances_from_edge) + [carstate.distance_from_center]) steer_pred = steer_pred[0] else: steer_pred = self.basic_control.steer_decider(carstate) gear = self.basic_control.gear_decider(carstate) pedal = self.basic_control.speed_decider(carstate, max_speed=self.max_speed) # making sure we don't drive at people opponents_deltas = list( map(sub, carstate.opponents, self.last_opponents)) steer_pred, pedal = self.basic_control.deal_with_opponents( steer_pred, pedal, carstate.speed_x, carstate.distance_from_center, carstate.opponents, opponents_deltas) # if too fast descelerate to max speed if carstate.speed_x > self.max_speed: pedal = 0.0 err(self.iter, "MAIN: capping speed") # disambiguating pedal with smoothing brake, accel = self.basic_control.disambiguate_pedal(pedal, accel_cap=1.0) # debug output if PRINT_COMMAND and self.iter % PRINT_CYCLE_INTERVAL: print("Executing comand: gear=%.2f, acc=%.2f," % (gear, accel), "break=%.2f, steering=%.2f" % (brake, steer_pred)) # command construction command = Command() command.brake = brake command.accelerator = accel command.steering = steer_pred command.gear = gear if command.steering > 0.10: debug(self.iter, "BASIC: turning left") elif command.steering < -0.10: debug(self.iter, "BASIC: turning right") return command
def drive(self, carstate: State) -> Command: command = Command() # If crashed, reverse if self.crashed: self.check_back_on_track(carstate) command.accelerator = 0.5 command.gear = -1 # Only steer if incorrect angle and off track if abs(carstate.angle) > 20 and abs( carstate.distance_from_center) < 1: # If car orientated towards the right if carstate.angle > 0: # Steer to right while reversing command.steering = -1 self.forward_steer_direction = 0.5 # Car orientated towards left else: # Steer to left while reversing command.steering = 1 self.forward_steer_direction = -0.5 self.resetGear = True # If forwardCounter is activated, drive forward, steering in the correct direction elif self.forwardCounter > 0: # Start by braking if self.forwardCounter > 200: command.brake = 1 # Then drive forward steering in the correct direction if carstate.angle > 0: command.steering = 0.5 else: command.steering = -0.5 command.accelerator = 0.5 command.gear = 1 self.forwardCounter -= 1 # Normal behaviour else: # Run input through model to predict next commands out = self.model(Variable(self.input)) self.input = self.update_state(out, carstate) self.update_history(carstate) self.detect_crash() # Create command with predictions command.accelerator = out.data[0][0] command.brake = out.data[0][1] command.steering = out.data[0][2] # Check for corners, if found, place pheromones begin_corner = self.check_for_corner(command.steering, carstate.distance_from_start) if begin_corner > 0: self.pheromones.append(("Corner", begin_corner)) # Save pheromones to file if self.counter % 50 == 0: pickle.dump(self.pheromones, open("sent_3001.txt", "wb")) if os.path.isfile("sent_3001.txt"): self.received = pickle.load(open("sent_3001.txt", "rb")) # Maximum target speed v_x = 500 # Use information from pheromones max_speed, accel, brake, steer = self.check_for_info( self.received, carstate.distance_from_start, carstate.speed_x) if max_speed is not None: v_x = max_speed command.accelerator = accel command.brake = brake if steer == 0: command.steering = steer self.accelerate(carstate, v_x, command) if self.resetGear: self.resetGear = False # Prevent the car from braking when driving slowly, causing it to get stuck when off track if carstate.speed_x * 3.6 < 20: command.brake = 0 self.counter += 1 self.input[2] = command.accelerator 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: # 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: """ 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() stateList = self.stateToArray(carstate) # output = self.network.activate(stateList) # Set the link to find the file of the one to work with if not self.set: files = glob.glob("cooperation*.txt") for fileN in files: if fileN != "cooperation" + str(self.id) + ".txt": self.co_car = fileN break self.set = True fh = open("cooperation" + str(self.id) + ".txt", "w") fh.write(str(self.id) + ": " + str(carstate.distance_raced)) fh.close() fh = open(self.co_car, "r") lines = fh.read() distance_other = float(lines.split(": ")[-1]) fh.close() if distance_other > carstate.distance_raced: opponents = carstate.opponents # Now get information from these opponents to ride against them, # Feed that information in the network and drive # by changing the stateList output = self.network.forward(stateList).data #print(output) #print(carstate.speed_x) #print(carstate.distance_from_start) #print(carstate.opponents) #self.steer(carstate, output[0, 2], command) command.steering = output[0, 0] #self.accelerate(carstate, 80, command) if carstate.speed_x < 0.1: command.accelerator = abs(output[0, 1]) else: command.accelerator = output[0, 1] if output[0, 1] < 0.0: command.brake = output[0, 2] else: command.brake = 0 if command.accelerator > 0: if carstate.rpm > 8000: command.gear = carstate.gear + 1 if command.accelerator < 0: if carstate.rpm < 2500: command.gear = carstate.gear - 1 if not command.gear: command.gear = carstate.gear or 1 #acceleration = output[0,1]*129 #acceleration = math.pow(acceleration, 3) #if acceleration > 0: # if abs(carstate.distance_from_center) >= 1: # off track, reduced grip: # acceleration = min(0.4, acceleration) # command.accelerator = min(acceleration, 1) # if carstate.rpm > 8000: # command.gear = carstate.gear + 1 #else: # command.brake = min(-acceleration, 1) #if carstate.rpm < 2500: # command.gear = carstate.gear - 1 #if not command.gear: # command.gear = carstate.gear or 1 #if output[0,0]>0.5: # ACC_LATERAL_MAX = 6400 * 5 # v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering))) #else: # v_x = 0 #self.accelerate(carstate, 85, command) if self.data_logger: self.data_logger.log(carstate, command) 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): # if len(os.listdir('./evolver/kill_torcs/')) > 0: # self.kill(self.torcs_process.pid) # evaluation period in seconds EVAL_TIME = 90 t = carstate.current_lap_time if t < self.last_cur_lap_time: # made a lap, adjust timing events accordingly! self.period_end_time -= carstate.last_lap_time 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 use_pca = False command = Command() ''' Handeling Evaluation Change: ''' if t > self.period_end_time and not self.recovering: # END CURRENT EVALUATION PERIOD: if self.first_evaluation: # check the right files and folders are available: # if not os.path.isdir('./evolver/pool/'): # print('NO POOL FOLDER FOUND') # return command # # if not os.path.exists('./log.csv'): # print('Creating log.csv...') # open('./log.csv', 'w').close() pass elif self.esn != None: # FITNESS CALCULATION # currently average speed (in MPS) # penalties for off track and recovery, and using brake too much # bonus points for staying in middle of track and keeping small # angle # self.fitness += (carstate.distance_raced - self.period_start_dist) self.fitness += self.period_distance_raced # log the performance: # save the network with the fitness in the title: # new_path = './evolver/queue/%s.pkl'%self.fitness # os.system('mv %s %s'%(self.PATH_TO_NEURAL_NET, new_path)) self.esn.save('./evolver/queue/%.2f.pkl' % self.fitness) # with open(new_path, 'wb') as file: # pkl.dump(self,file) # nn_id = int(self.PATH_TO_NEURAL_NET[12:-4]) # log = open('./log.csv', 'a') # log.write('%s, %.2f\n'%(nn_id, self.fitness)) # log.close() if self.fitness > 0: print('Fitness Score \033[7m%.2f\033[0m logged\n' % (self.fitness)) else: print('Fitness Score %.2f logged\n' % (self.fitness)) # START NEXT EVALUATION PERIOD: # load random net: pool = os.listdir('./evolver/driver_esn/') if len(pool) > 0: self.PATH_TO_NEURAL_NET = './evolver/driver_esn/' + str( np.random.choice(pool, 1)[0]) self.esn = neuralNet.restore_ESN(self.PATH_TO_NEURAL_NET) # remove ESN so no other driver can use it: os.system('rm %s' % self.PATH_TO_NEURAL_NET) print('Evaluating %s:' % self.PATH_TO_NEURAL_NET) else: # no choice of ESNs, use robot driver # print('No ESNS :(') self.esn = None self.recovering = True # reset values: self.fitness = 0 self.period_end_time = t + EVAL_TIME self.period_start_dist = carstate.distance_raced self.period_distance_raced = 0 self.first_evaluation = False self.init_time = t + 2 """ 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 # reward fitness for being within 15 degress: if np.abs(sensor_ANGLE_TO_TRACK_AXIS) < 0.2618: self.fitness += 1 # reward if in center of road: if np.abs(sensor_TRACK_POSITION) < 0.1: self.fitness += 1 """ 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 ] if self.is_stopped & (t > self.stopped_time + 3) & (not self.recovering): self.recovering = True self.is_stopped = False # print(self.RECOVER_MSG) # print('Stopped for 3 seconds...') self.fitness -= 5000 self.finished_evaluation = True if self.recovering: 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 + 5) & (sensor_SPEED > 40) & ( np.abs(sensor_ANGLE_TO_TRACK_AXIS) < 0.5): self.recovering = False self.warm_up = False self.period_end_time = t # will end evaluation period # print('Recovered and starting new evaulation') # print('+-'*18) else: self.off_track = True self.warm_up = False else: ''' Drive using Neural Net ''' if np.abs(sensor_TRACK_POSITION) > 1: if self.off_track == False: # print("### OFF ROAD ###") self.off_time = t self.off_track = True self.fitness -= 1 if t > self.off_time + 5: # haven't recovered in 3 seconds # get back on road and start new evaluation self.fitness -= 5000 # penalty self.recovering = True self.finished_evaluation = True # print(self.RECOVER_MSG) else: self.off_track = False self.period_distance_raced = carstate.distance_raced - self.period_start_dist x = np.array(sensor_TRACK_EDGES) / 200 if use_pca: y = PCA.convert(x.T) sensor_data += list(y) else: sensor_data += list(x) # use EchoStateNet try: output = self.esn.predict(sensor_data, continuation=True) except: # pass self.esn = neuralNet.restore_ESN(self.PATH_TO_NEURAL_NET) output = self.esn.predict(sensor_data, continuation=True) # print('Loaded ' + self.PATH_TO_NEURAL_NET) if output[0] > 0: if sensor_SPEED < 120: accel = min(max(output[0], 0), 1) else: accel = 0 brake = 0.0 else: accel = 0.0 brake = min(max(-output[0], 0), 1) if sensor_SPEED < 10: self.fitness -= 1 else: if np.abs(sensor_ANGLE_TO_TRACK_AXIS) > 0.2618: self.fitness += 1 steer = min(max(output[1], -1), 1) # if np.abs(steer) < 0.1 and x[9] > 0.9: # self.fitness += 1 # # if np.abs(steer) > 0.8 and x[9] < 0.2: # self.fitness += 1 """ Apply Accelrator, Brake and Steering Commands from the neural net """ if self.train_overtaking: # reduce range to within 10m opponents = np.array(carstate.opponents) opponents = np.minimum(10, opponents) if min(opponents) < 10: # opponent nearby, engage overtaking network input2 = [output[0], steer] input2 += list(opponents / 10) ############################################ # CODE TO ALTER OUTPUTS ############################################ # 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 return command
def drive(self, carstate: State) -> Command: global car_str global friend_car_str global s global count_s global SWARM global TOTAL_STUCK_LIMIT if not hasattr(self, 'stuck'): self.stuck = False self.stuck_count = 0 self.recover_stuck = False if not hasattr(self, 'reverse'): self.reverse = False if not hasattr(self, 'total_stuck'): self.total_stuck = 0 if SWARM: if count_s == 0: s.send(b'start') count_s += 1 speed = carstate.speed_x * 3.6 if carstate.speed_x < 1: speed_x = 1 else: speed_x = carstate.speed_x # input features 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() for x_idx in range(23): if str(-(x_idx + 1)) in node_dict.node_dict: node_dict.node_dict[str(-(x_idx + 1))].value = x[x_idx] # output y = forward() command = Command() command.accelerator = y[0] command.brake = y[1] command.steering = y[2] # reset feed forward network node_dict.reset() # auto 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 # avoid hitting to opponents if abs(command.steering) <= 0.8: if (np.where(((np.array( list(carstate.opponents[0:13]) + list(carstate.opponents[23:36])))) <= 100)[0]).size > 0: pass #command.accelerator += 1.0 #command.brake -= 0.2 #print('oppoent behind you, accelarate! ') elif (np.where(((np.array( list(carstate.opponents[14:18]) + list(carstate.opponents[20:23])))) <= 100)[0]).size > 0: pass #command.accelerator += 1.0 #command.brake -= 0.2 #print('oppoent in front of you, accelarate! ') elif (np.where( ((np.array(list(carstate.opponents[18:19])))) < 20)[0] ).size > 0: if carstate.distance_from_center < 0.2 and carstate.distance_from_center >= 0: command.steering = command.steering - 0.1 elif carstate.distance_from_center > -0.2 and carstate.distance_from_center < 0: command.steering = command.steering + 0.1 else: command.steering = command.steering + carstate.distance_from_center * -0.2 # swarm intelligence if SWARM and self.total_stuck < TOTAL_STUCK_LIMIT: # prevent reuse self.acce car_str = str(CAR_ID) + ',' + str(round(speed, 2)) + "," + str( carstate.race_position) + "," + str( round(carstate.distance_raced, 2)) if car_str != None: s.send(car_str.encode()) friend_car_str = s.recv(128).decode() if friend_car_str == 'exit': SWARM = False elif friend_car_str != '' and friend_car_str != 'not ready': friend_car_str_split = friend_car_str.split(',') friend_car_id = int(friend_car_str_split[0]) friend_car_speed = float(friend_car_str_split[1]) friend_race_position = int(friend_car_str_split[2]) friend_distance_raced = float(friend_car_str_split[3]) if carstate.race_position > friend_race_position: # too far. closer. diff = friend_distance_raced - carstate.distance_raced if diff > 10 and diff < 100: command.brake -= 0.05 # too close elif diff <= 10: leave_diff = -(diff - 10) command.brake += 0.1 * leave_diff / 16 # detect wrong way if (carstate.angle > 170.0 or carstate.angle < -170 ) and speed > 20 and abs( carstate.distance_from_center) <= 0.7 and carstate.gear >= 1: self.reverse = True if carstate.angle < 30 and carstate.angle > -30 and abs( carstate.distance_from_center) <= 1: self.reverse = False if self.reverse: command.steering = np.sign(math.cos(carstate.angle)) * -1.0 if self.stuck == False and carstate.distance_raced > 50 and speed < 2: self.stuck = True self.total_stuck += 1 # if offtrack, try to back to road. if self.total_stuck < TOTAL_STUCK_LIMIT: if abs(carstate.distance_from_center) >= 1 and not self.stuck: self.steer(carstate, 0.0, command) # auto recover from stucked if self.stuck: if abs(carstate.distance_from_center ) <= 0.5 or self.stuck_count > 500 or ( carstate.angle < 30 and carstate.angle > -30): if carstate.gear <= -1: command.gear = -1 command.brake = 1.0 command.accelerator = 0.0 if speed >= -0.1: command.gear = 1 elif carstate.gear >= 1: command.gear = carstate.gear or 1 command.brake = 0.0 if abs(carstate.distance_from_center) >= 0.2: self.steer(carstate, 0.0, command) else: self.stuck = False self.stuck_count = 0 if self.stuck_count > 1000: self.stuck_count = 0 elif carstate.distance_from_center <= -0.5: command.gear = -1 command.accelerator = 0.5 command.steering = -1.0 command.brake = 0.0 self.stuck_steer = command.steering elif carstate.distance_from_center >= 0.5: command.gear = -1 command.accelerator = 0.5 command.steering = 1.0 command.brake = 0.0 self.stuck_steer = command.steering self.stuck_count += 1 # if stucked too many times, switch default driver. Just in case. if not self.stuck and self.total_stuck >= TOTAL_STUCK_LIMIT: self.steer(carstate, 0.0, command) self.accelerate(carstate, 40, command) return command
def drive(self, carstate: State): t = carstate.current_lap_time if t < self.last_cur_lap_time: # made a lap, adjust timing events accordingly! self.period_end_time -= carstate.last_lap_time 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 + 3) & (not self.recovering): self.recovering = True self.is_stopped = False #print(self.RECOVER_MSG) #print('Stopped for 3 seconds...') with open('./simulation_log.txt', 'a') as file: file.write('stopped for 3 seconds\n') 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 + 5) & (sensor_SPEED > 40) & ( np.abs(sensor_ANGLE_TO_TRACK_AXIS) < 0.5): self.recovering = False self.warm_up = False self.init_time = t + 1 self.period_end_time = t # will end evaluation period #print('Recovered and starting new evaulation') #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 ###") with open('./simulation_log.txt', 'a') as file: file.write('driver %.0f off road\n' % carstate.race_position) file.close() 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.fitness -= 100 # penalty self.recovering = True #print(self.RECOVER_MSG) else: self.off_track = False with open('./simulation_log.txt', 'a') as file: file.write('driver %.0f on road\n' % carstate.race_position) """ 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) """ 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)) # adjust the ESN output based on the MLP output # output += change_output output[0] += max(-0.5, min(0.5, change_output[0])) output[1] += max(-0.5, min(0.5, change_output[1])) self.esn.set_last_outputs(output) # determine the deviation between ESN and MLP output self.accel_deviation = abs(output[0] - mlp_input[0]) self.steering_deviation = abs(output[1] - mlp_input[1]) """ determine if car should accelerate or brake """ 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 """ write data for evaluation to the file 'simulation_log.txt' """ with open('./simulation_log.txt', 'a') as file: file.write('##################################\n') file.write('race position: %.0f\n' % carstate.race_position) file.write('current_lap_time: ' + str(carstate.current_lap_time) + '\n') if carstate.distance_from_start <= carstate.distance_raced: file.write('distance_from_start: ' + str(carstate.distance_from_start) + '\n') else: file.write('distance_from_start: 0 \n') # if overtaking was successful if self.active_mlp and carstate.race_position < self.previous_position: file.write('overtaking successful \n') # overtaking of opponent if self.active_mlp and carstate.race_position > self.previous_position: file.write('position lost \n') #file.write('damage: '+str(carstate.damage)+'\n') file.write('distance from center: ' + str(carstate.distance_from_center) + '\n') file.write('distance to opponent: ' + str(min(carstate.opponents)) + '\n') file.write('angle to track: ' + str(carstate.angle) + '\n') if self.active_mlp and self.current_damage < carstate.damage: file.write('MLP damage \n') if self.active_mlp: file.write('MLP d from center: ' + str(carstate.distance_from_center) + '\n') file.write('MLP accelerator deviation: ' + str(self.accel_deviation) + '\n') file.write('MLP steering deviation: ' + str(self.steering_deviation) + '\n') file.write('MLP speed: ' + str(carstate.speed_x) + '\n') file.write('MLP angle: ' + str(carstate.angle) + '\n') # save damage and position information for the next simulation step self.current_damage = carstate.damage self.previous_position = carstate.race_position return command