def main3(): global sample_count, path_to_trainingdir # Convert training dataframe into images and labels arrays # Training data generator with random shear and random brightness start_time = time.time() # Start of MODEL Definition m = Model() model = m.define_model() generator = DatasetGenerator([0, 1, 2], batch_size=10000, dim=(32, 32, 32), n_channels=1, feature="steering", shuffle=False) model.fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, validation_freq=1, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=False, initial_epoch=0) model_name = 'BeamNGmodel-racetracksteering2' model.save_weights('{}.h5'.format(model_name)) with open('{}.json'.format(model_name), 'w') as outfile: json.dump(model.to_json(), outfile) print("All done :)") print("Time to train: {}".format(time.time() - start_time))
def main2(): global sample_count, path_to_trainingdir # Convert training dataframe into images and labels arrays # Training data generator with random shear and random brightness start_time = time.time() # Start of MODEL Definition m = Model() model = m.define_model() # prep training set t = os.listdir(path_to_trainingdir) training_dirs = [ "{}/{}/".format(path_to_trainingdir, training_dir) for training_dir in t ] # for training_dir in t: # training_dirs.append("{}/{}/".format(path_to_trainingdir, training_dir)) shape = (0, 1, m.input_shape[0], m.input_shape[1], m.input_shape[2]) X_train = np.array([]).reshape(shape) y_train = np.array([]) for d in training_dirs[-1:]: print("Processing {}".format(d)) redo_csv("{}/data.csv".format(d)) x_temp, steering_y_temp, throttle_y_temp = process_training_dir(d, m) print("Concatenating X_train shape:{} x_temp shape:{}".format( X_train.shape, x_temp.shape)) X_train = np.concatenate((X_train, x_temp), axis=0) steering_y_train = np.concatenate((y_train, steering_y_temp), axis=0) throttle_y_train = np.concatenate((y_train, throttle_y_temp), axis=0) print("Final X_train shape:{} Final y_train shape:{}".format( X_train.shape, steering_y_train.shape)) # Train and save the model BATCH_SIZE = 100 NB_EPOCH = 9 NB_SAMPLES = 2 * len(X_train) # Train steering model.fit(x=X_train, y=steering_y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH) model_name = 'BeamNGmodel-racetracksteering' model.save_weights('{}.h5'.format(model_name)) with open('{}.json'.format(model_name), 'w') as outfile: json.dump(model.to_json(), outfile) # Train throttle model.fit(x=X_train, y=throttle_y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH) model_name = 'BeamNGmodel-racetrackthrottle' model.save_weights('{}.h5'.format(model_name)) with open('{}.json'.format(model_name), 'w') as outfile: json.dump(model.to_json(), outfile) print("All done :)") print("Total training samples: {}".format(sample_count)) print("Time to train: {}".format(time.time() - start_time))
def main_compare_dual_model(): global sample_count, path_to_trainingdir # Convert training dataframe into images and labels arrays # Training data generator with random shear and random brightness start_time = time.time() # Start of MODEL Definition m1 = Model() m2 = Model() m3 = Model() model1 = m1.define_model() model2 = m2.define_model() model3 = m3.define_dual_model_BeamNG() dirlist = [0, 1, 2] generator = DatasetGenerator(dirlist, batch_size=10000, dim=(32, 32, 32), n_channels=1, feature="steering", shuffle=False) # 2D output X, y_all, y_steering, y_throttle = generator.process_all_training_dirs_with_2D_output( m1) print("dataset size: {} output size: {}".format(X.shape, y_all.shape)) print("time to load dataset: {}".format(time.time() - start_time)) BATCH_SIZE = 64 NB_EPOCH = 20 # Train steering it = "comparison10K" model1_name = 'BeamNGmodel-racetracksteering{}'.format(it) model2_name = 'BeamNGmodel-racetrackthrottle{}'.format(it) model3_name = 'BeamNGmodel-racetrackdual{}'.format(it) model1.fit(x=X, y=y_steering, batch_size=BATCH_SIZE, epochs=NB_EPOCH) save_model(model1, model1_name) print("Finished steering model") # delete the previous model so that you don't max out the memory del model1 model2.fit(x=X, y=y_throttle, batch_size=BATCH_SIZE, epochs=NB_EPOCH) save_model(model2, model2_name) print("Finished throttle model") del model2 model3.fit(x=X, y=y_all, batch_size=BATCH_SIZE, epochs=NB_EPOCH) save_model(model3, model3_name) print("Finished dual model") print("All done :)") print("Time to train: {}".format(time.time() - start_time))
def data_generation(self, i): 'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels) # Initialization X = np.empty((self.batch_size, *self.dim, self.n_channels)) y = np.empty((self.batch_size), dtype=int) # Generate data # for i, ID in enumerate(list_IDs_temp): # # Store sample # X[i,] = np.load('data/' + ID + '.npy') # # # Store class # y[i] = self.labels[ID] # 'H:/BeamNG_DAVE2_racetracks/' training_dir = "{}training_images_industrial-racetrackstartinggate{}".format( self.training_dir, i) m = Model() X, y1, y2 = self.process_training_dir(training_dir, m) print(X.shape, y1.shape) return X, y1, y2
def run_scenario(self): global base_filename, default_model, default_color, default_scenario, setpoint global prev_error #vehicle_loadfile = 'vehicles/pickup/pristine.save.json' # setup DNN model + weights m = Model() model = m.define_model_BeamNG("BeamNGmodel-4.h5") random.seed(1703) setup_logging() #beamng = BeamNGpy('localhost', 64256, home='C:/Users/merie/Documents/BeamNG.research.v1.7.0.1') beamng = BeamNGpy('localhost', 64256, home='H:/BeamNG.research.v1.7.0.1clean') scenario = Scenario(default_scenario, 'research_test') vehicle = Vehicle('ego_vehicle', model=default_model, licence='LOWPRESS', color=default_color) vehicle = setup_sensors(vehicle) spawn = spawn_point(default_scenario, 'highway') scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat']) # Compile the scenario and place it in BeamNG's map folder scenario.make(beamng) # Start BeamNG and enter the main loop bng = beamng.open(launch=True) bng.hide_hud() bng.set_deterministic() # Set simulator to be deterministic bng.set_steps_per_second(100) # With 60hz temporal resolution # Load and start the scenario bng.load_scenario(scenario) bng.start_scenario() # perturb vehicle #vehicle.ai_set_mode('span') #vehicle.ai_drive_in_lane(True) #vehicle_loadfile = 'vehicles/etk800/fronttires_0psi.pc' # vehicle_loadfile = 'vehicles/etk800/backtires_0psi.pc' # vehicle_loadfile = 'vehicles/etk800/chassis_forcefeedback201.pc' # vehicle.load_pc(vehicle_loadfile, False) vehicle.deflate_tires([1,1,1,1]) #vehicle.break_all_breakgroups() #vehicle.break_hinges() # Put simulator in pause awaiting further inputs bng.pause() assert vehicle.skt bng.resume() wheelspeed = 0.0; throttle = 0.0; prev_error = setpoint; damage_prev = None; runtime = 0.0 kphs = [] damage = None final_img = None # Send random inputs to vehice and advance the simulation 20 steps for _ in range(1024): # collect images image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB') img = m.process_image(image) prediction = model.predict(img) # control params kph = ms_to_kph(wheelspeed) throttle = throttle_PID(kph, dt) brake = 0 #if throttle < 0: if setpoint < kph: brake = throttle / 1000.0 throttle = 0.0 # throttle = 0.2 # random.uniform(0.0, 1.0) # brake = random.choice([0, 0, 0.1 , 0.2]) steering = float(prediction[0][0]) #random.uniform(-1.0, 1.0) vehicle.control(throttle=throttle, steering=steering, brake=brake) steering_state = bng.poll_sensors(vehicle)['electrics']['steering'] steering_input = bng.poll_sensors(vehicle)['electrics']['steering_input'] avg_wheel_av = bng.poll_sensors(vehicle)['electrics']['avg_wheel_av'] wheelspeed = bng.poll_sensors(vehicle)['electrics']['wheelspeed'] damage = bng.poll_sensors(vehicle)['damage'] new_damage = diff_damage(damage, damage_prev) damage_prev = damage print("\n") # #print("steering state: {}".format(steering_state)) # print("AI steering_input: {}".format(steering_input)) #print("avg_wheel_av: {}".format(avg_wheel_av)) # print("DAVE2 steering prediction: {}".format(float(prediction[0][0]))) print("throttle:{}".format(throttle)) print("brake:{}".format(brake)) print("kph: {}".format(ms_to_kph(wheelspeed))) print("new_damage:{}".format(new_damage)) kphs.append(ms_to_kph(wheelspeed)) if new_damage > 0.0: final_img = image break bng.step(5) runtime += (0.05) # print("runtime:{}".format(round(runtime, 2))) # print("time to crash:{}".format(round(runtime, 2))) bng.close() avg_kph = float(sum(kphs)) / len(kphs) plt.imshow(final_img) plt.pause(0.01) return runtime, avg_kph, damage['damage'], kphs
def run_spawn_for_parts_config( vehicle_model='etk800', loadfile='C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/front17x8rear17x9.json' ): global base_filename, default_color, default_scenario, setpoint global prev_error global fcam # setup DNN model + weights m = Model() model = m.define_model_BeamNG("BeamNGmodel-5.h5") random.seed(1703) setup_logging() beamng = BeamNGpy('localhost', 64256, home='H:/BeamNG.research.v1.7.0.1clean') scenario = Scenario(default_scenario, 'research_test') vehicle = Vehicle('ego_vehicle', model=vehicle_model, licence='LOWPRESS', color=default_color) vehicle = setup_sensors(vehicle) spawn = spawn_point(default_scenario, 'highway') # scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat']) # Compile the scenario and place it in BeamNG's map folder scenario.make(beamng) # Start BeamNG and enter the main loop bng = beamng.open(launch=True) # bng.hide_hud() bng.set_deterministic() # Set simulator to be deterministic bng.set_steps_per_second(100) # With 60hz temporal resolution # Load and start the scenario bng.load_scenario(scenario) bng.start_scenario() # vehicle.load('C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/pristine.json') if loadfile: bng.spawn_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'], partConfig=loadfile) else: bng.spawn_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'], partConfig='vehicles/hopper/custom.pc') #bng.set_relative_camera() # Put simulator in pause awaiting further inputs bng.pause() assert vehicle.skt bng.resume() bng.set_steps_per_second(100) bng.set_deterministic() totalsecs = 0.0 pitch_traj = [] while totalsecs <= 30: vehicle.update_vehicle() camera_state = bng.poll_sensors(vehicle)['front_cam'] camera_state['roll'] = vehicle.state['roll'] camera_state['pitch'] = vehicle.state['pitch'] camera_state['yaw'] = vehicle.state['yaw'] pitch_traj.append(round(math.degrees(vehicle.state['pitch'][0]), 4)) print("roll:{}, pitch:{}, yaw:{}".format(vehicle.state['roll'], vehicle.state['pitch'], vehicle.state['yaw'])) bng.step(100) totalsecs += 1 # print("Camera state:{}".format(camera_state)) image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB') #get_camera_rot_and_pos([-0.3, 1, 1.0], [0, 0.75, 0], before_state['pos'], before_state['dir'], before_state['up']) img = m.process_image(image) before_prediction = model.predict(img) camera_state["prediction"] = before_prediction plt.imshow(image) plt.pause(0.01) bng.close() return camera_state, vehicle.state, pitch_traj
def run_spawn_for_deflation(vehicle_model='etk800', deflation_pattern=[0, 0, 0, 0]): global base_filename, default_color, default_scenario, setpoint global prev_error global fcam vehicle_loadfile = 'vehicles/hopper/crawler.pc' # setup DNN model + weights m = Model() model = m.define_model_BeamNG("BeamNGmodel-5.h5") random.seed(1703) setup_logging() # beamng = BeamNGpy('localhost', 64256, home='C:/Users/merie/Documents/BeamNG.research.v1.7.0.1') beamng = BeamNGpy('localhost', 64256, home='H:/BeamNG.research.v1.7.0.1clean') scenario = Scenario(default_scenario, 'research_test') vehicle = Vehicle('ego_vehicle', model=vehicle_model, licence='LOWPRESS', color=default_color) vehicle = setup_sensors(vehicle) spawn = spawn_point(default_scenario, 'highway') # scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat']) # Compile the scenario and place it in BeamNG's map folder scenario.make(beamng) # Start BeamNG and enter the main loop bng = beamng.open(launch=True) # bng.hide_hud() bng.set_deterministic() # Set simulator to be deterministic # Load and start the scenario bng.load_scenario(scenario) bng.start_scenario() # load part config #pc = vehicle.get_part_config() # loadfile = 'C:/Users/merie/Documents/BeamNG.research/vehicles/hopper/front17x8rear17x9.json' # vehicle.load(loadfile) bng.spawn_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'], partConfig='vehicles/hopper/custom.pc') #bng.set_relative_camera() # Put simulator in pause awaiting further inputs bng.pause() assert vehicle.skt # vehicle.control(throttle=0.0, steering=0.0, brake=1.0) # perturb vehicle # before_state = copy.deepcopy(vehicle.state) before_state = bng.poll_sensors(vehicle)['front_cam'] before_state['vel'] = vehicle.state['vel'] before_state['roll'] = vehicle.state['roll'] before_state['pitch'] = vehicle.state['pitch'] before_state['yaw'] = vehicle.state['yaw'] # print("vehicle position before deflation via beamstate:{}".format(vehicle.get_object_position())) # print("vehicle position before deflation via vehicle state:{}".format(vehicle.state)) print( "vehicle position before deflation via camera:{}".format(before_state)) image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB') # print("camera sensor before deflation: {}".format(bng.poll_sensors(vehicle)['front_cam'])) #get_camera_rot_and_pos([-0.3, 1, 1.0], [0, 0.75, 0], before_state['pos'], before_state['dir'], before_state['up']) img = m.process_image(image) before_prediction = model.predict(img) before_state["prediction"] = before_prediction plt.imshow(image) plt.pause(0.01) if deflation_pattern != [0, 0, 0, 0]: print("deflating according to pattern {}".format(deflation_pattern)) vehicle.deflate_tires(deflation_pattern) time.sleep(1) bng.resume() bng.set_steps_per_second(100) bng.set_deterministic() totalsecs = 0.0 deflation_traj = [] while totalsecs <= 30: vehicle.update_vehicle() # vehicle.control(throttle=0.0, steering=0.0, brake=1.0) after_state = bng.poll_sensors(vehicle)['front_cam'] after_state['vel'] = vehicle.state['vel'] after_state['roll'] = vehicle.state['roll'] after_state['pitch'] = vehicle.state['pitch'] after_state['yaw'] = vehicle.state['yaw'] print("roll:{}, pitch:{}, yaw:{}".format(vehicle.state['roll'], vehicle.state['pitch'], vehicle.state['yaw'])) deflation_traj.append(round(math.degrees(vehicle.state['pitch'][0]), 4)) bng.step(100) totalsecs += 1 # after_state = copy.deepcopy(vehicle.state) # print("vehicle position after deflation via beamstate:{}".format(vehicle.get_object_position())) # print("vehicle position after deflation via vehicle state:{}".format(vehicle.state)) image = bng.poll_sensors(vehicle)['front_cam']['colour'].convert('RGB') print("vehicle position after deflation via camera:{}".format(after_state)) #print("camera sensor output: {}".format(bng.poll_sensors(vehicle)['front_cam']['rot'])) #print("camera pos output: {}".format(bng.poll_sensors(vehicle)['front_cam']['pos'])) # print("camera rot output: {}".format(bng.poll_sensors(vehicle)['front_cam']['direction'])) # print("fcam.encode_engine_request() = {}".format(fcam.encode_engine_request())) damages = bng.poll_sensors(vehicle)['damage']['deform_group_damage'] d = ["{}={}".format(k, damages[k]['damage']) for k in damages.keys()] print("vehicle pressure after deflation: lowpressure={} damages:".format( bng.poll_sensors(vehicle)['damage']['lowpressure'], d)) img = m.process_image(image) after_state["prediction"] = model.predict(img) plt.imshow(image) plt.pause(0.01) bng.close() return before_state, after_state, deflation_traj
def main(): global sample_count, path_to_trainingdir # Convert training dataframe into images and labels arrays # Training data generator with random shear and random brightness start_time = time.time() # Start of MODEL Definition m1 = Model() m2 = Model() model1 = m1.define_model() model2 = m2.define_model() dirlist = [0, 1, 2] generator = DatasetGenerator(dirlist, batch_size=10000, dim=(32, 32, 32), n_channels=1, feature="steering", shuffle=False) # model.fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1, # callbacks=None, validation_data=None, validation_steps=None, # validation_freq=1, class_weight=None, max_queue_size=10, # workers=1, use_multiprocessing=False, shuffle=False, initial_epoch=0) # for d in dirlist: # print("Batch training on dir {}".format(d)) # X,y1, y2 = generator.data_generation(d) # model1.train_on_batch(X, y1) # model2.train_on_batch(X, y2) filename_root = "H:/BeamNG_DAVE2_racetracks/training_images_industrial-racetrackstartinggate" # X, y_steering, y_throttle = generator.process_enumerated_training_dirs(filename_root, dirlist, m1) # 1D output X, y_steering, y_throttle = generator.process_all_training_dirs(m1) print("X .shape", X.shape, "y_steering.shape", y_steering.shape, "y_throttle.shape", y_throttle.shape) characterize_steering_distribution(y_steering, generator) print("Moments of steering distribution:", generator.get_distribution_moments(y_steering)) print("Moments of throttle distribution:", generator.get_distribution_moments(y_throttle)) # 2D output # X, y = generator.process_all_training_dirs_with_2D_output(m1) print("time to load dataset: {}".format(time.time() - start_time)) BATCH_SIZE = 64 NB_EPOCH = 20 # Train steering it = "1Doutput" model1_name = 'BeamNGmodel-racetracksteering{}'.format(it) model2_name = 'BeamNGmodel-racetrackthrottle{}'.format(it) model1.fit(x=X, y=y_steering, batch_size=BATCH_SIZE, epochs=NB_EPOCH) save_model(model1, model1_name) print("Finished steering model") # delete the previous model so that you don't max out the memory del model1 del y_steering model2.fit(x=X, y=y_throttle, batch_size=BATCH_SIZE, epochs=NB_EPOCH) save_model(model2, model2_name) print("Finished throttle model") print("All done :)") print("Time to train: {}".format(time.time() - start_time))
def run_comparison(vehicle_model='etk800', deflation_pattern=[0, 0, 0, 0], parts_config=None): global base_filename, default_color, default_scenario, default_spawnpoint, setpoint, steps_per_sec global integral, prev_error integral = 0.0 prev_error = 0.0 # setup DNN model + weights m = Model() model = m.define_model_BeamNG("BeamNGmodel-racetrack.h5") random.seed(1703) setup_logging() beamng = BeamNGpy('localhost', 64256, home='H:/BeamNG.research.v1.7.0.1clean', user='******') scenario = Scenario(default_scenario, 'research_test') # unperturbed_vehicle = Vehicle('unperturbed_vehicle', model=vehicle_model, # licence='SAFE', color='Red') # unperturbed_vehicle = setup_sensors(unperturbed_vehicle) vehicle = Vehicle('ego_vehicle', model=vehicle_model, licence='EGO', color=default_color) vehicle = setup_sensors(vehicle) spawn = get_spawn_point(default_scenario, default_spawnpoint) scenario.add_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat']) temp = copy.deepcopy(spawn['pos']) temp = [temp[0] + lanewidth, temp[1] + lanewidth, temp[2]] # scenario.add_vehicle(unperturbed_vehicle, pos=temp, rot=None, rot_quat=spawn['rot_quat']) # Compile the scenario and place it in BeamNG's map folder scenario.make(beamng) bng = beamng.open(launch=True) #bng.hide_hud() bng.set_deterministic() # Set simulator to be deterministic bng.set_steps_per_second(steps_per_sec) # Load and start the scenario bng.load_scenario(scenario) bng.start_scenario() #bng.spawn_vehicle(vehicle, pos=spawn['pos'], rot=None, rot_quat=spawn['rot_quat'], partConfig=parts_config) # Put simulator in pause awaiting further inputs bng.pause() assert vehicle.skt bng.resume() # perturb vehicle vehicle.deflate_tires(deflation_pattern) bng.step(steps_per_sec * 6) vehicle.update_vehicle() return_str = '\nPERTURBED headlight_cam INFO:' print('\nPERTURBED headlight_cam INFO:') temp = bng.poll_sensors(vehicle)['headlight_cam'] for key in temp: if key == 'rotation': degs = euler_from_quaternion(temp[key][0], temp[key][1], temp[key][2], temp[key][3]) return_str = "{}\nquaternions {}".format(return_str, temp[key]) return_str = "{}\n{} {}".format(return_str, key, [round(i, 3) for i in degs]) print(key, degs) elif key != "colour" and key != "annotation" and key != "depth": return_str = "{}\n{} {}".format(return_str, key, temp[key]) print(key, temp[key]) print('\nPERTURBED rearview_cam INFO:') return_str = "{}\nPERTURBED rearview_cam INFO:".format(return_str) # temp = bng.poll_sensors(vehicle)['rearview_cam'] for key in temp: if key == 'rotation': degs = euler_from_quaternion(temp[key][0], temp[key][1], temp[key][2], temp[key][3]) return_str = "{}\nquaternions {}".format(return_str, temp[key]) return_str = "{}\n{} {}".format(return_str, key, [round(i, 3) for i in degs]) print(key, degs) elif key != "colour" and key != "annotation" and key != "depth": return_str = "{}\n{} {}".format(return_str, key, temp[key]) print(key, temp[key]) # rearview_img = bng.poll_sensors(vehicle)['rearview_cam']['colour'].convert('RGB') headlight_img = bng.poll_sensors( vehicle)['headlight_cam']['colour'].convert('RGB') bng.step(steps_per_sec * 6) # print("runtime:{}".format(round(runtime, 2))) # print("time to crash:{}".format(round(runtime, 2))) bng.close() # avg_kph = float(sum(kphs)) / len(kphs) # plt.imshow(rearview_img) # plt.pause(0.01) plt.imshow(headlight_img) plt.pause(0.01) # results = {'pitch': round(pitch,3), 'roll':round(roll,3), "z":round(z,3), 'rearview_img':rearview_img, 'headlight_img':headlight_img} return return_str