def eval_genomes(genomes, config, episode): """" SOMETHING SMETHING""" x = 0 # state_empty=np.zeros([feature_number,1]) for genome_id, genome in genomes: x += 1 SUMO.step = 0 SUMO.Colliion = False SUMO.RouteEnd = False v_episode = [] a_episode = [] distance_episode = [] created = multiprocessing.Process() sim = current._identity[1] simulation = traci.getConnection('sim' + str(sim - 1)) SUMO.init_vars_episode() """Anmerkung: Hier werden einige Variationen des Verkehrsszenarios für meine Trainingsepisoden definiert, wenn 'training = True' gesetzt ist. Im Fall 'training = False' oder 'evaluation = True' (Evaluierungsepisoden unter gleichen Randbedingungen) wird immer eine Episode mit gleichen Randbedingungen (z.B. Geschwindigkeitsprofil vorausfahrendes Fahrzeug) gesetzt""" if trafic.evaluation: simulation.vehicle.add(trafic.vehicle_ego.ID, trafic.vehicle_ego.RouteID, departSpeed='0', typeID='ego_vehicle') # Ego vehicle simulation.trafficlight.setPhase( 'junction1', 0 ) # set traffic light phase to 0 for evaluation (same conditions) else: traci.vehicle.add(trafic.vehicle_ego.ID, trafic.vehicle_ego.RouteID, departSpeed=np.array2string( trafic.vehicle_ego.depart_speed[episode - 1]), typeID='ego_vehicle') # Ego vehicle if trafic.vehicle2_exist: simulation.vehicle.add( trafic.vehicle_2.ID, trafic.vehicle_2.RouteID, typeID='traffic_vehicle') # preceding vehicle 1 if trafic.vehicle3: simulation.vehicle.add( trafic.vehicle_3.ID, trafic.vehicle_3.RouteID, typeID='traffic_vehicle') # preceding vehicle 2 if trafic.training and not trafic.evaluation: simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', trafic.episoden_variante) else: simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', 0.) simulation.simulationStep() # to spawn vehicles # if controller != 'SUMO': simulation.vehicle.setSpeedMode( trafic.vehicle_ego.ID, 16 ) # only emergency stopping at red traffic lights --> episode ends if trafic.vehicle2_exist: simulation.vehicle.setSpeedMode(trafic.vehicle_2.ID, 17) if trafic.vehicle3: simulation.vehicle.setSpeedMode(trafic.vehicle_3.ID, 17) SUMO.currentvehiclelist = simulation.vehicle.getIDList() # SUMO subscriptions simulation.vehicle.subscribeLeader(trafic.vehicle_ego.ID, 10000) simulation.vehicle.subscribe(trafic.vehicle_ego.ID, [ traci.constants.VAR_SPEED, traci.constants.VAR_BEST_LANES, traci.constants.VAR_FUELCONSUMPTION, traci.constants.VAR_NEXT_TLS, traci.constants.VAR_ALLOWED_SPEED, traci.constants.VAR_LANE_ID ]) dynamics_ego = Longitudinal_dynamics(tau=0.5) net = neat.nn.FeedForwardNetwork.create(genome, config) """"Run episode =======================================================================""" while simulation.simulation.getMinExpectedNumber( ) > 0: # timestep loop """Get state for first iteration ===================================================================""" if SUMO.step == 0: calculate_features_firststep() # if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN': # nn_controller.state = get_state() """Controller ====================================================================================== Hier wird die Stellgröße des Reglers (z.B. Sollbeschleunigung) in Abhängigkeit der Reglereingänge (zusammengefasst in 'features' für den ACC Controller bzw. 'nn_controller.state' für die Neuronalen Regler""" # if controller == 'ACC': # SUMO.a_set[SUMO.step] = acc_controller.calculate_a(features) # Calculate set acceleration with ACC controller # # Save ACC mode to SUMO class # SUMO.mode_ego[SUMO.step] = acc_controller.mode # ACC control modes (speed control, headway control, etc) # elif controller == 'DQN': # # Calculate Q-Values for all actions # nn_controller.action_value = nn_controller.model.predict(nn_controller.state) # NN inputs: distance, delta_v # # Choose Action according to epsilon-greedy policy # nn_controller.index[SUMO.step] = nn_controller.choose_action(nn_controller.action_value, episode) # # Calculate the set acceleration for the timestep # nn_controller.a_set = nn_controller.actions[nn_controller.index[SUMO.step]] # SUMO.a_set[SUMO.step] = nn_controller.a_set # elif controller == 'DDPG': # if training and not evaluation: # if exploration_policy == 'ACC': # SUMO.a_set[SUMO.step] = explo_policy.calculate_a(features) # SUMO.a_set[SUMO.step] = nn_controller.add_noise(SUMO.a_set[SUMO.step]) # else: # SUMO.a_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=True) # else: # SUMO.a_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False) # elif controller == 'hybrid_a': # acc_controller.a_set = acc_controller.calculate_a( # features) # Calculate set acceleration with ACC controller # # Save ACC mode to SUMO class # SUMO.mode_ego[SUMO.step] = acc_controller.mode # ACC control modes (speed control, headway control, etc) # if SUMO.step == 0: # nn_controller.state[0, 3] = acc_controller.a_set # if training and not evaluation: # nn_controller.a_set = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=True) # else: # nn_controller.a_set = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False) # SUMO.a_set[SUMO.step] = acc_controller.a_set + nn_controller.k_hybrid_a * nn_controller.a_set # SUMO.a_hybrid_a[SUMO.step] = nn_controller.a_set # elif controller == 'DDPG_v': # if training and not evaluation: # SUMO.v_set[SUMO.step], SUMO.v_set_nonoise[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', features=features, noise=True) # else: # SUMO.v_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False) # SUMO.a_set[SUMO.step] = acc_controller.calc_a_P(features, SUMO.v_set[SUMO.step]) state = get_state(trafic.state_empty) # print(state) # net = neat.nn.FeedForwardNetwork.create(genome, config) SUMO.a_set[SUMO.step] = net.activate( state) #[0,0], state[0,1], state[0,2], state[0,3]) SUMO.a_set[SUMO.step] = 20 * SUMO.a_set[ SUMO.step] - 10 #[0,0], state[0,1], state[0,2], state[0,3]) # print(SUMO.a_set[SUMO.step], SUMO.step) """Longitudinal Dynamics =========================================================================== Hier werden Längsdynamische Größen des Egofahrzeugs berechnet. beispielsweise die Realbeschleunigung aus den Stellgrößen des Reglers oder der Kraftstoffverbrauch für ein definiertes Fahrzeug (aktuell konventionelles Verbrennerfahrzeug mit Mehrganggetriebe). Am Ende wird als Schnittstelle zu SUMO eine neue Geschwindigkeit für das Egofahrzeug für den nächsten Zeitschritt gesetzt""" dynamics_ego = Longitudinal_dynamics(tau=0.5) # if controller == 'SUMO': # dynamics_ego.a_real = traci.vehicle.getAcceleration(vehicle_ego.ID) # dynamics_ego.wheel_demand(SUMO.v_ego[SUMO.step], vehicle_ego, # SUMO.step) # Calculate the torque and speed wheel demand of this timestep # dynamics_ego.operating_strategy(SUMO.sim['timestep'], vehicle_ego, s0=2, kp=10, step=SUMO.step) # SUMO.a_real[SUMO.step] = dynamics_ego.a_real # else: dynamics_ego.low_lev_controller( SUMO.a_set[SUMO.step], SUMO.sim['timestep'] ) # Calculate a_real with a_set and a PT1 Transfer function dynamics_ego.wheel_demand( SUMO.v_ego[SUMO.step], trafic.vehicle_ego, SUMO.step ) # Calculate the torque and speed wheel demand of this timestep dynamics_ego.operating_strategy(SUMO.sim['timestep'], trafic.vehicle_ego, s0=2, kp=10, step=SUMO.step) dynamics_ego.v_real_next = SUMO.v_ego[ SUMO.step] + dynamics_ego.a_real * SUMO.sim['timestep'] dynamics_ego.v_real_next = np.clip(dynamics_ego.v_real_next, 0., None) SUMO.a_real[SUMO.step] = dynamics_ego.a_real simulation.vehicle.setSpeed( trafic.vehicle_ego.ID, dynamics_ego.v_real_next ) # Set velocity of ego car for next time step """Control traffic ================================================================""" if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist: if trafic.vehicle_2.end == False: if simulation.vehicle.getLaneID( trafic.vehicle_2.ID ) == 'junction_out_0' and traci.vehicle.getLanePosition( trafic.vehicle_2.ID) > 90: simulation.vehicle.remove(trafic.vehicle_2.ID) trafic.vehicle_2.end = True else: #traci.vehicle.setSpeed(vehicle_2.ID, SUMO.v_profile[SUMO.step]) # set velocity of preceding car 1 pass if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist: traci.vehicle.setSpeed(trafic.vehicle_3.ID, SUMO.v_profile[ SUMO.step]) # set velocity of preceding car 2 """SUMO simulation step ============================================================================""" simulation.simulationStep() SUMO.currentvehiclelist = traci.vehicle.getIDList() """Check if any of the endstate conditions is true (e.g. collision) ===================================""" if trafic.vehicle_ego.ID not in SUMO.currentvehiclelist: SUMO.RouteEnd = True SUMO.endstate = True print([x, SUMO.step], ' Route finished!') elif simulation.simulation.getCollidingVehiclesNumber() > 0: SUMO.endstate = True SUMO.Collision = True print([x, SUMO.step], ' Collision!') elif trafic.vehicle_ego.ID in simulation.simulation.getEmergencyStoppingVehiclesIDList( ): # Check for ego vehicle passing red traffic light SUMO.Collision = True SUMO.endstate = True print([x, SUMO.step], ' Red lights passed!') # Set a maximum time step limit for 1 episode elif SUMO.step > 5000: SUMO.RouteEnd = True SUMO.endstate = True print([x, SUMO.step], ' Maximum time reached!') """get new state ===================================================================================""" calculate_features() v_episode.append(features.v_ego) a_episode.append(dynamics_ego.a_real) distance_episode.append(features.distance) # if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN': # nn_controller.new_state = get_state() """Prepare next timestep ===========================================================================""" if SUMO.Collision or SUMO.RouteEnd: # end episode when endstate conditions are true break dynamics_ego.a_previous = copy( dynamics_ego.a_real ) # copy --> to create an independent copy of the variable, not a reference to it # if controller == 'DQN' or controller == 'hybrid_a' or controller == 'DDPG' or controller == 'DDPG_v': # nn_controller.state = copy(nn_controller.new_state) if sample_generation: sample_generator.state = copy(sample_generator.new_state) trafic.vehicle_ego.ID_prec_previous = copy( trafic.vehicle_ego.ID_prec) # print(SUMO.step) SUMO.step += 1 # print(v_episode) """Calculate Reward ================================================================================""" fitness = len(v_episode) * np.sqrt(np.sum( np.square(v_episode))) - np.sum( 0.5 * np.sign(features.v_allowed - np.asarray(v_episode)) + 1) - np.mean(np.square(a_episode)) - 1 / sum( np.square( np.asarray(v_episode) * 3.6 - np.asarray(distance_episode))) - 100000 * int( SUMO.Collision) genome.fitness = fitness[0].item() print(fitness) # cum_reward[episode] += reward """End of episode - prepare next episode ====================================================================== Reset position of vehicles by removing and (later) adding them again, call running plots and export data """ if trafic.vehicle_ego.ID in SUMO.currentvehiclelist: simulation.vehicle.remove(trafic.vehicle_ego.ID) if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist: simulation.vehicle.remove(trafic.vehicle_2.ID) if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist: simulation.vehicle.remove(trafic.vehicle_3.ID) simulation.simulationStep() dynamics_ego.reset_variables()
number_episodes) * 20 / 3.6 + 10 / 3.6 else: SUMO.prec_train_amplitude = 25 / 3.6 # a=25/3.6 SUMO.prec_train_mean = 30 / 3.6 # c=30/3.6 SUMO.create_v_profile_prec(a=SUMO.prec_train_amplitude, c=SUMO.prec_train_mean) elif vehicle3_vprofile == 'emergstop': SUMO.create_v_profile_emerg_stop() else: raise NameError('No valid velocity profile selected') trafic.vehicle_ego = Vehicle(ego=True, ID='ego', RouteID='RouteID_ego', Route=trafic.Route_Ego, powertrain_concept='ICEV') trafic.dynamics_ego = Longitudinal_dynamics(tau=0.5) if trafic.vehicle2_exist: trafic.vehicle_2 = Vehicle(ego=False, ID='traffic.0', RouteID='traci_route_traffic.0', Route=trafic.Route_Traffic1) if trafic.vehicle3_exist: trafic.vehicle_3 = Vehicle(ego=False, ID='traffic.1', RouteID='traci_route_traffic.1', Route=trafic.Route_Traffic2) acc_controller = {} # if controller == 'ACC' or controller == 'hybrid_a' or controller == 'DDPG_v': # acc_controller = ACC_Controller(v_set=19.44, h_set=1, a_set_min=-10.) # instantiate ACC controller # acc_controller.create_mode_map() # if controller == 'DQN':
def SimInitializer(trafic, episode): error = False try: timestep = 1 trafic.number_episodes = 100000 feature_number = 4 trafic.training = True sample_generation = False trafic.TLS_virt_vehicle = True # Red and Yellow traffic lights are considered as preceding vehicles with v=0 trafic.TLS_ID = ['0', '1', '2', '3', '4'] trafic.evaluation = False trafic.vehicle2_exist = False # currently no meaningful trajectory / route - keep on False trafic.vehicle3_exist = True trafic.vehicle3_vprofile = 'sinus' # 'sinus', 'emergstop' liveplot = False # memory leak problem on windows when turned on trafic.Route_Ego = ['startedge', 'gneE01', 'gneE02', 'stopedge'] trafic.ego_depart_speed = np.ones( (trafic.number_episodes, )) * 0. # specific depart speed for ego vehicle when not training trafic.Route_Traffic1 = ['gneE01', 'junction_out'] # for vehicle2 trafic.Route_Traffic2 = ['gneE01', 'gneE02', 'stopedge'] # for vehicle3 trafic.state_empty = np.zeros([feature_number, 1]) timestep = 2 np.random.seed(42 + episode) SUMO2 = SUMO(trafic.Route_Ego, trafic.Route_Traffic1, trafic.Route_Traffic2, timestep=0.2) ## create velocity profile of preceding vehicle ## """Hier werden bei 'training = True' unterschiedliche Geschwindigkeitsprofile für das vorausfahrende Fahrzeug definiert. Für 'training = False' wird ein festes sinusförmiges Profil mit Mittelwert 30 km/h und Amplitude +- 25 km/h definiert.""" if trafic.vehicle3_exist: if trafic.vehicle3_vprofile == 'sinus': if trafic.training: # create random sinusodial velocity profiles for training SUMO2.prec_train_amplitude = np.random.rand( trafic.number_episodes) * 20 / 3.6 SUMO2.prec_train_mean = np.random.rand( trafic.number_episodes) * 20 / 3.6 + 10 / 3.6 else: SUMO2.prec_train_amplitude = 25 / 3.6 # a=25/3.6 SUMO2.prec_train_mean = 30 / 3.6 # c=30/3.6 SUMO2.create_v_profile_prec(a=SUMO.prec_train_amplitude, c=SUMO.prec_train_mean) elif vehicle3_vprofile == 'emergstop': SUMO2.create_v_profile_emerg_stop() else: raise NameError('No valid velocity profile selected') trafic.vehicle_ego = Vehicle(ego=True, ID='ego', RouteID='RouteID_ego', Route=trafic.Route_Ego, powertrain_concept='ICEV') trafic.dynamics_ego = Longitudinal_dynamics(tau=0.5) if trafic.vehicle2_exist: trafic.vehicle_2 = Vehicle(ego=False, ID='traffic.0', RouteID='traci_route_traffic.0', Route=trafic.Route_Traffic1) if trafic.vehicle3_exist: trafic.vehicle_3 = Vehicle(ego=False, ID='traffic.1', RouteID='traci_route_traffic.1', Route=trafic.Route_Traffic2) acc_controller = {} timestep = 3 # if trafic.training and liveplot: # fig_running, ax_running_1, ax_running_2, ax_running_3, ax_running_4 = plot_running_init(training) process_param = multiprocessing.Process() # print(process_param.name) traci.start(['sumo', '-c', 'SUMO_config.sumocfg', '--no-warnings'], label=str(process_param.name)) #, label=sim) simulation = traci.getConnection(process_param.name) simulation.route.add(trafic.vehicle_ego.RouteID, trafic.vehicle_ego.Route) if trafic.vehicle2_exist: simulation.route.add(trafic.vehicle_2.RouteID, trafic.vehicle_2.Route) if trafic.vehicle3_exist: simulation.route.add(trafic.vehicle_3.RouteID, trafic.vehicle_3.Route) simulation.vehicletype.setSpeedFactor(typeID='traffic_vehicle', factor=5.0) length_episode = np.zeros((trafic.number_episodes, 1)) restart_step = 0 # counter for calculating the reset timing when the simulation time gets close to 24 days evaluation = False if trafic.training: trafic.vehicle_ego.depart_speed = np.random.randint( 0, 30, size=trafic.number_episodes) else: trafic.vehicle_ego.depart_speed = ego_depart_speed simulation.trafficlight.setProgram(tlsID='junction1', programID=np.random.choice( trafic.TLS_ID)) timestep = 4 + episode if not trafic.training: simulation.trafficlight.setPhase('junction1', 0) if trafic.training and not trafic.evaluation and trafic.vehicle3_exist: trafic.vehicle3 = np.random.choice([True, False], p=[0.95, 0.05]) simulation.lane.setMaxSpeed( 'gneE01_0', np.random.choice([8.33, 13.89, 19.44, 25.])) simulation.lane.setMaxSpeed( 'gneE02_0', np.random.choice([8.33, 13.89, 19.44, 25.])) simulation.lane.setMaxSpeed( 'startedge_0', np.random.choice([8.33, 13.89, 19.44, 25.])) SUMO2.create_v_profile_prec(a=SUMO2.prec_train_amplitude[episode - 1], c=SUMO2.prec_train_mean[episode - 1]) else: trafic.vehicle3 = vehicle3_exist simulation.lane.setMaxSpeed('startedge_0', 13.89) # 13.89 simulation.lane.setMaxSpeed('gneE01_0', 19.44) # 19.44 simulation.lane.setMaxSpeed('gneE02_0', 13.89) # 13.89 simulation.lane.setMaxSpeed('stopedge_0', 8.33) # 8.33 trafic.episoden_variante = np.random.rand() * 240. return process_param.name, SUMO2, error except Exception as ex: template = "An exception of type {0} occurred. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) error = True traci.close()
def eval_genomes(genome_id, genome, config, episode, trafic): """" SOMETHING SMETHING""" error = False error_return = 10000 timestep = 0 try: [simname, SUMO, error] = SimInitializer(trafic, episode) except Exception as ex: template = "An exception of type {0} occurred. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) if error == True: return error_return # fitness=timestep # raise Exception('Error SimInitializer', message) if error == True: return error_return try: x = 0 # state_empty=np.zeros([feature_number,1]) # for genome_id, genome in genomes: x += 1 SUMO.step = 0 SUMO.Colliion = False SUMO.RouteEnd = False v_episode = [] a_episode = [] distance_episode = [] timestep = 1 process_param = multiprocessing.Process() sim = simname #process_param.name timestep = [sim, simname] simulation = traci.getConnection(simname) timestep = 1.5 SUMO.init_vars_episode() """Anmerkung: Hier werden einige Variationen des Verkehrsszenarios für meine Trainingsepisoden definiert, wenn 'training = True' gesetzt ist. Im Fall 'training = False' oder 'evaluation = True' (Evaluierungsepisoden unter gleichen Randbedingungen) wird immer eine Episode mit gleichen Randbedingungen (z.B. Geschwindigkeitsprofil vorausfahrendes Fahrzeug) gesetzt""" if trafic.evaluation: simulation.vehicle.add(trafic.vehicle_ego.ID, trafic.vehicle_ego.RouteID, departSpeed='0', typeID='ego_vehicle') # Ego vehicle simulation.trafficlight.setPhase( 'junction1', 0 ) # set traffic light phase to 0 for evaluation (same conditions) else: simulation.vehicle.add( trafic.vehicle_ego.ID, trafic.vehicle_ego.RouteID, departSpeed=np.array2string( trafic.vehicle_ego.depart_speed[episode - 1]), typeID='ego_vehicle') # Ego vehicle if trafic.vehicle2_exist: simulation.vehicle.add( trafic.vehicle_2.ID, trafic.vehicle_2.RouteID, typeID='traffic_vehicle') # preceding vehicle 1 timestep = 1.7 if trafic.vehicle3: simulation.vehicle.add( trafic.vehicle_3.ID, trafic.vehicle_3.RouteID, typeID='traffic_vehicle') # preceding vehicle 2 if trafic.training and not trafic.evaluation: simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', trafic.episoden_variante) else: simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', 0.) timestep = 2 simulation.simulationStep() # to spawn vehicles # if controller != 'SUMO': simulation.vehicle.setSpeedMode( trafic.vehicle_ego.ID, 16 ) # only emergency stopping at red traffic lights --> episode ends if trafic.vehicle2_exist: simulation.vehicle.setSpeedMode(trafic.vehicle_2.ID, 17) if trafic.vehicle3: simulation.vehicle.setSpeedMode(trafic.vehicle_3.ID, 17) SUMO.currentvehiclelist = simulation.vehicle.getIDList() # SUMO subscriptions simulation.vehicle.subscribeLeader(trafic.vehicle_ego.ID, 10000) simulation.vehicle.subscribe(trafic.vehicle_ego.ID, [ traci.constants.VAR_SPEED, traci.constants.VAR_BEST_LANES, traci.constants.VAR_FUELCONSUMPTION, traci.constants.VAR_NEXT_TLS, traci.constants.VAR_ALLOWED_SPEED, traci.constants.VAR_LANE_ID ]) timestep = 3 dynamics_ego = Longitudinal_dynamics(tau=0.5) timestep = 3.1 net = neat.nn.FeedForwardNetwork.create(genome[1], config) """"Run episode =======================================================================""" while simulation.simulation.getMinExpectedNumber( ) > 0: # timestep loop """Get state for first iteration ===================================================================""" if SUMO.step == 0: calculate_features_firststep(sim, SUMO) # if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN': # nn_controller.state = get_state() timestep = 3.3 """Controller ====================================================================================== Hier wird die Stellgröße des Reglers (z.B. Sollbeschleunigung) in Abhängigkeit der Reglereingänge (zusammengefasst in 'features' für den ACC Controller bzw. 'nn_controller.state' für die Neuronalen Regler""" state = get_state(trafic.state_empty) timestep = 4 # print(state) # net = neat.nn.FeedForwardNetwork.create(genome, config) SUMO.a_set[SUMO.step] = net.activate( state) #[0,0], state[0,1], state[0,2], state[0,3]) SUMO.a_set[SUMO.step] = 10 * SUMO.a_set[ SUMO.step] #-10 #[0,0], state[0,1], state[0,2], state[0,3]) # print(SUMO.a_set[SUMO.step], SUMO.step) timestep = 5 """Longitudinal Dynamics =========================================================================== Hier werden Längsdynamische Größen des Egofahrzeugs berechnet. beispielsweise die Realbeschleunigung aus den Stellgrößen des Reglers oder der Kraftstoffverbrauch für ein definiertes Fahrzeug (aktuell konventionelles Verbrennerfahrzeug mit Mehrganggetriebe). Am Ende wird als Schnittstelle zu SUMO eine neue Geschwindigkeit für das Egofahrzeug für den nächsten Zeitschritt gesetzt""" dynamics_ego = Longitudinal_dynamics(tau=0.5) dynamics_ego.low_lev_controller( SUMO.a_set[SUMO.step], SUMO.sim['timestep'] ) # Calculate a_real with a_set and a PT1 Transfer function dynamics_ego.wheel_demand( SUMO.v_ego[SUMO.step], trafic.vehicle_ego, SUMO.step ) # Calculate the torque and speed wheel demand of this timestep dynamics_ego.operating_strategy(SUMO.sim['timestep'], trafic.vehicle_ego, s0=2, kp=10, step=SUMO.step) dynamics_ego.v_real_next = SUMO.v_ego[ SUMO.step] + dynamics_ego.a_real * SUMO.sim['timestep'] dynamics_ego.v_real_next = np.clip(dynamics_ego.v_real_next, 0., None) SUMO.a_real[SUMO.step] = dynamics_ego.a_real simulation.vehicle.setSpeed( trafic.vehicle_ego.ID, dynamics_ego.v_real_next ) # Set velocity of ego car for next time step timestep = 6 """Control traffic ================================================================""" if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist: if trafic.vehicle_2.end == False: if simulation.vehicle.getLaneID( trafic.vehicle_2.ID ) == 'junction_out_0' and simulation.vehicle.getLanePosition( trafic.vehicle_2.ID) > 90: simulation.vehicle.remove(trafic.vehicle_2.ID) trafic.vehicle_2.end = True else: #traci.vehicle.setSpeed(vehicle_2.ID, SUMO.v_profile[SUMO.step]) # set velocity of preceding car 1 pass if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist: simulation.vehicle.setSpeed( trafic.vehicle_3.ID, SUMO.v_profile[ SUMO.step]) # set velocity of preceding car 2 """SUMO simulation step ============================================================================""" simulation.simulationStep() SUMO.currentvehiclelist = traci.vehicle.getIDList() timestep = 7 """Check if any of the endstate conditions is true (e.g. collision) ===================================""" if trafic.vehicle_ego.ID not in SUMO.currentvehiclelist: SUMO.RouteEnd = True SUMO.endstate = True # print([x, SUMO.step],' Route finished!') elif simulation.simulation.getCollidingVehiclesNumber() > 0: SUMO.endstate = True SUMO.Collision = True # print([x, SUMO.step],' Collision!') elif trafic.vehicle_ego.ID in simulation.simulation.getEmergencyStoppingVehiclesIDList( ): # Check for ego vehicle passing red traffic light SUMO.Collision = True SUMO.endstate = True # print([x, SUMO.step],' Red lights passed!') # Set a maximum time step limit for 1 episode elif SUMO.step > 5000: SUMO.RouteEnd = True SUMO.endstate = True # print([x, SUMO.step],' Maximum time reached!') timestep = 7.5 """get new state ===================================================================================""" calculate_features(sim, SUMO) v_episode.append(features.v_ego) a_episode.append(dynamics_ego.a_real) distance_episode.append(features.distance) # """Prepare next timestep ===========================================================================""" if SUMO.Collision or SUMO.RouteEnd: # end episode when endstate conditions are true timestep = 9 break dynamics_ego.a_previous = copy( dynamics_ego.a_real ) # copy --> to create an independent copy of the variable, not a reference to it trafic.vehicle_ego.ID_prec_previous = copy( trafic.vehicle_ego.ID_prec) SUMO.step += 1 timestep = 8 """Calculate Reward ================================================================================""" # fitness = np.sqrt(len(v_episode))*np.sqrt(np.sum(np.square(np.asarray(v_episode)/250)))+np.sum(0.5*np.sign(features.v_allowed/250-np.asarray(v_episode)/250)+1) -0.0001*np.sum(np.square(a_episode))-1/sum(np.square(np.asarray(v_episode)/250*3.6-np.asarray(distance_episode)/250))-100000*int(SUMO.Collision) +100000*int(SUMO.RouteEnd) verbrauch = (10 * (np.mean(trafic.vehicle_ego.fuel_cons) / 0.05) - 1 ) #*50#*100 travelled_distance = sum([c * 0.2 for c in v_episode]) travelled_distance_divisor = 1 / 1800 if travelled_distance == 0 else travelled_distance abstand = np.sum([ 1 for ii in range(len(v_episode)) if distance_episode[ii] < 2 * v_episode[ii] * 3.6 and distance_episode[ii] > v_episode[ii] * 3.6 ]) crash = int(SUMO.Collision) #route_ende=int(SUMO.RouteEnd and not SUMO.maxtime) speed = np.mean(v_episode) / features.v_allowed if np.mean( v_episode) / features.v_allowed < 1 else 0 over_speed_limit = sum([ 1 for jj in range(len(v_episode)) if v_episode[jj] > features.v_allowed ]) evil_acc = sum([ 1 for kk in range(len(a_episode)) if abs(a_episode[kk].item()) > 4 ]) travelled_distance_divisor = evil_acc + 1 if travelled_distance == 0 else travelled_distance fitness = travelled_distance / 1800 + abstand / SUMO.step - crash + speed - 10 * over_speed_limit / SUMO.step - evil_acc / travelled_distance_divisor - 0.5 * verbrauch genome[1].fitness = fitness[0].item() # print(fitness) output = fitness[0].item() # cum_reward[episode] += reward """End of episode - prepare next episode ====================================================================== Reset position of vehicles by removing and (later) adding them again, call running plots and export data """ traci.close() except Exception as ex: template = "An exception of type {0} occurred. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) output = 10000 traci.close() # raise Exception('My error eval genome!', timestep, message) return output
def calculate_features(): state = np.zeros([1, feature_number]) dynamics_ego = Longitudinal_dynamics(tau=0.5) sub_ego = traci.vehicle.getSubscriptionResults(trafic.vehicle_ego.ID) if SUMO.Collision: # collision happened! features.distance = 0 # set the distance of the cars after a collision to 0 features.v_prec = SUMO.v_prec[ SUMO. step] # set the velocity of the preceding car after a collision to the value of the previous timestep features.v_ego = SUMO.v_ego[ SUMO. step] # set the velocity of the ego car after a collision to the value of the previous timestep elif SUMO.RouteEnd: features.distance = SUMO.distance[ SUMO. step] # set the distance of the cars after preceding vehicle ends route to previous timestep features.v_prec = SUMO.v_prec[ SUMO. step] # set the velocity of the preceding car after preceding vehicle ends route to the value of the previous timestep features.v_ego = SUMO.v_ego[ SUMO. step] # set the velocity of the ego car after preceding vehicle ends route to the value of the previous timestep else: ## TLS Distance if traci.constants.VAR_NEXT_TLS in sub_ego and len( sub_ego[traci.constants.VAR_NEXT_TLS]) > 0: features.distance_TLS = sub_ego[traci.constants.VAR_NEXT_TLS][0][2] features.TLS_state = sub_ego[traci.constants.VAR_NEXT_TLS][0][3] else: features.distance_TLS = 1000 # TODO: Handling when no TLS ahead features.TLS_state = None ## v_ego features.v_ego = sub_ego[traci.constants.VAR_SPEED] # print(dynamics_ego.fuel_cons_per_100km) ## fuel_consumption trafic.vehicle_ego.fuel_cons[SUMO.step + 1] = sub_ego[ traci.constants.VAR_FUELCONSUMPTION] # in ml/s # trafic.vehicle_ego.fuel_cons_ECMS[SUMO.step + 1] = dynamics_ego.fuel_cons_per_100km # trafic.vehicle_ego.fuel_cons_ECMS_per_s[SUMO.step + 1] = dynamics_ego.fuel_cons_per_s ## distance, v_prec try: if traci.constants.VAR_LEADER in sub_ego: trafic.vehicle_ego.ID_prec, features.distance = sub_ego[ traci.constants.VAR_LEADER] SUMO.distance[SUMO.step + 1] = features.distance features.distance = np.clip(features.distance, None, 250.) features.v_prec = traci.vehicle.getSpeed( trafic.vehicle_ego.ID_prec) SUMO.v_prec[SUMO.step + 1] = features.v_prec else: raise TypeError except TypeError: features.distance = 250 SUMO.distance[SUMO.step + 1] = features.distance SUMO.v_prec[SUMO.step + 1] = features.v_ego trafic.vehicle_ego.ID_prec = 'none' if features.distance == 250: features.v_prec = copy( features.v_ego ) # when no preceding car detected OR distance > 250 (clipped), set a 'virtual velocity' = v_ego ## correct distance, v_prec with virtual TLS vehicle if trafic.TLS_virt_vehicle: if features.TLS_state == 'y' or features.TLS_state == 'r': if features.distance_TLS < features.distance: features.distance = copy(features.distance_TLS) features.v_prec = 0 ## headway if features.v_ego < 0.1: features.headway = 10000. else: features.headway = features.distance / features.v_ego ## v_allowed if traci.constants.VAR_LANE_ID in sub_ego: features.v_allowed = traci.lane.getMaxSpeed( sub_ego[traci.constants.VAR_LANE_ID]) else: features.v_allowed = 33.33 # tempo limit set to 120 km/h when no signal received, unlikely to happen ## plotting variables SUMO.headway[SUMO.step + 1] = features.headway SUMO.v_ego[SUMO.step + 1] = features.v_ego