def train(cfg, tub_names, new_model_path, base_model_path=None): """ use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name """ X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] new_model_path = os.path.expanduser(new_model_path) kl = KerasLinear() if base_model_path is not None: base_model_path = os.path.expanduser(base_model_path) kl.load(base_model_path) print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=new_model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, new_model_path, base_model_path=None): """ use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name """ X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] new_model_path = os.path.expanduser(new_model_path) kl = KerasLinear() if base_model_path is not None: base_model_path = os.path.expanduser(base_model_path) kl.load(base_model_path) print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) print(train_gen[0]) print(type(train_gen)) print(len(train_gen))
def train(cfg, tub_names, model_name): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def rt(record): record['user/angle'] = dk.utils.linear_bin(record['user/angle']) return record kl = KerasCategorical() print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def my_train(cfg, tub_names, model_name): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def rt(record): record['user/angle'] = dk.utils.linear_bin(record['user/angle']) return record print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, new_model_path, base_model_path=None): """ 引数 tub_names 似て指定されたパスに格納されている tub データを学習データとして トレーニングを行い、引数 new_model_path にて指定されたパスへ学習済みモデルファイルを格納する。 引数: cfg 個別車両設定オブジェクト、`config.py`がロードされたオブジェクト。 tub_names 学習データとして使用するtubディレクトリのパスを指定する。 new_model_path トレーニング後モデルファイルとして保管するパスを指定する。 base_model_path ファインチューニングを行う場合、ベースとなるモデルファイルを指定する。 戻り値 なし """ # モデルの入力データとなる項目 X_keys = ['cam/image_array'] # モデルの出力データとなる項目 y_keys = ['user/angle', 'user/throttle'] # トレーニング後モデルファイルとして保管するパスをフルパス化 new_model_path = os.path.expanduser(new_model_path) # トレーニング後モデルファイルとして保管するパスをフルパス化 kl = KerasLinear() # ファインチューニングを行う場合は base_model_path にベースモデルファイルパスが指定されている if base_model_path is not None: # ベースモデルファイルパスをフルパス化 base_model_path = os.path.expanduser(base_model_path) # ベースモデルファイルを読み込む kl.load(base_model_path) print('tub_names', tub_names) # 引数tub_names 指定がない場合 if not tub_names: # config.py 上に指定されたデータファイルパスを使用 tub_names = os.path.join(cfg.DATA_PATH, '*') # Tub データ群をあらわすオブジェクトを生成 tubgroup = TubGroup(tub_names) # トレーニングデータGenerator、評価データGeneratorを生成 train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) # 全学習データ件数を取得 total_records = len(tubgroup.df) # トレーニングデータ件数の取得 total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) # 評価データ件数の取得 total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) # 1epochごとのステップ数の取得 steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) # トレーニングの開始 kl.train(train_gen, val_gen, saved_model_path=new_model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, new_model_path, base_model_path=None, model_class=''): """ use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name """ X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] new_model_path = os.path.expanduser(new_model_path) import tensorflow as tf config = tf.ConfigProto() config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU # config.log_device_placement=True sess = tf.Session(config=config) tf.keras.backend.set_session(sess) model_module, model_class_name = model_class.rsplit('.', 1) print("loading {} from {}...".format(model_class_name, model_module)) module = importlib.import_module(model_module) model_cls = getattr(module, model_class_name) kl = model_cls() if base_model_path is not None: base_model_path = os.path.expanduser(base_model_path) kl.load(base_model_path) print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) top_view_transform = TopViewTransform(cfg.CAMERA_RESOLUTION) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT, train_record_transform=top_view_transform, val_record_transform=top_view_transform) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=new_model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def plot_predictions(self, cfg, tub_paths, model_path): """ Plot model predictions for angle and throttle against data from tubs. """ from donkeycar.parts.datastore import TubGroup from donkeycar.parts.keras import KerasLinear import pandas as pd from matplotlib import pyplot as plt tg = TubGroup(tub_paths) model_path = os.path.expanduser(model_path) model = KerasLinear() model.load(model_path) gen = tg.get_batch_gen(None,batch_size=len(tg.df),record_transform=None,shuffle=True, df=tg.df) arr = next(gen) user_angles = [] user_throttles = [] pilot_angles = [] pilot_throttles = [] for tub in tg.tubs: num_records = tub.get_num_records() for iRec in tub.get_index(shuffled=False): record = tub.get_record(iRec) img = record["cam/image_array"] user_angle = float(record["user/angle"]) user_throttle = float(record["user/throttle"]) pilot_angle, pilot_throttle = model.run(img) user_angles.append(user_angle) user_throttles.append(user_throttle) pilot_angles.append(pilot_angle) pilot_throttles.append(pilot_throttle) angles_df = pd.DataFrame({'user_angle': user_angles, 'pilot_angle': pilot_angles}) throttles_df = pd.DataFrame({'user_throttle': user_throttles, 'pilot_throttle': pilot_throttles}) fig = plt.figure() title = "Model Predictions\nTubs: {}\nModel: {}".format(tub_paths, model_path) fig.suptitle(title) ax1 = fig.add_subplot(211) ax2 = fig.add_subplot(212) angles_df.plot(ax=ax1) throttles_df.plot(ax=ax2) ax1.legend(loc=4) ax2.legend(loc=4) plt.show()
def train(cfg, tub_names, new_model_path, base_model_path=None): """ use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name """ X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def train_record_transform(record): """ convert categorical steering to linear and apply image augmentations """ record['user/angle'] = dk.util.data.linear_bin(record['user/angle']) # TODO add augmentation that doesn't use opencv return record def val_record_transform(record): """ convert categorical steering to linear """ record['user/angle'] = dk.util.data.linear_bin(record['user/angle']) return record new_model_path = os.path.expanduser(new_model_path) kl = KerasCategorical() if base_model_path is not None: base_model_path = os.path.expanduser(base_model_path) kl.load(base_model_path) print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, train_record_transform=train_record_transform, val_record_transform=val_record_transform, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=new_model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT) kl.model.save(new_model_path + '.h5', save_format='h5')
def show_histogram(self, tub_paths, record_name, out): ''' Produce a histogram of record type frequency in the given tub ''' from matplotlib import pyplot as plt from donkeycar.parts.datastore import TubGroup output = out or os.path.basename(tub_paths) tg = TubGroup(tub_paths=tub_paths) if record_name is not None: tg.df[record_name].hist(bins=50) else: tg.df.hist(bins=50) try: if out is not None: filename = output else: if record_name is not None: filename = output + '_hist_%s.png' % record_name.replace( '/', '_') else: filename = output + '_hist.png' plt.savefig(filename) print('saving image to:', filename) except Exception as e: print(e) plt.show()
def train(cfg, tub_names, model_name): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] #use these offsets from the current frame as points to learn the future #steering values. frames = [0, 20, 40, 120] new_y_keys = [] for iFrame in frames: for key in y_keys: new_y_keys.append(key + "_" + str(iFrame)) y_keys = new_y_keys kl = KerasLinear(num_outputs=len(y_keys)) tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, model_name, resnet50, tensorboardlog_path): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def rt(record): record['user/angle'] = dk.utils.linear_bin(record['user/angle']) return record if resnet50: print('Using resnet50') kl = KerasCategorical(cfg=cfg, modelType=ModelType.RESNET50) else: print('Using categorical') kl = KerasCategorical(cfg=cfg) if tensorboardlog_path: kl.activate_tensorboard_log(tensorboardlog_path) print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def plot_predictions(cfg, tub_paths, model_path): ''' Plot model predictions for angle and throttle against data from tubs. ''' from donkeycar.parts.datastore import TubGroup from donkeycar.parts.keras import KerasCategorical tg = TubGroup(tub_paths) model_path = os.path.expanduser(model_path) model = KerasCategorical() model.load(model_path) gen = tg.get_batch_gen(batch_size=len(tg.df), shuffle=False) arr = next(gen) """
def test_angle_distribution_large_speed(self): filter_method = drive_record_filter_include_all tubgroup = TubGroup("../data/log_w_6,../data/log_w_7") dataset = DriveDataSet.from_tubgroup(tubgroup.df, filter_method=filter_method, fake_image=True) plt = Plot.angle_distribution(dataset.angles()) plt.savefig("angle/angle_distribution_original_faster_max_speed.jpg")
def train(cfg, tub_names, model_name): X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def rt(record): record['user/angle'] = donkeycar.utils.utils.linear_bin( record['user/angle']) return record def combined_gen(gens): import itertools combined_gen = itertools.chain() for gen in gens: combined_gen = itertools.chain(combined_gen, gen) return combined_gen kl = KerasCategorical() logger.info('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train logger.info('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE logger.ino('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, model_name): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] #use these offsets from the current frame as points to learn the future #steering values. frames = [0, 20, 40, 120] new_y_keys = [] for iFrame in frames: for key in y_keys: new_y_keys.append(key + "_" + str(iFrame)) y_keys = new_y_keys kl = KerasLinear(num_outputs=len(y_keys)) tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) kl.train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def train(cfg, tub_names, model_name): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] def rt(record): record['user/angle'] = dk.utils.linear_bin(record['user/angle']) return record tubgroup = TubGroup(tub_names) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) if (hasattr(cfg, 'ENGINE') and cfg.ENGINE == "mxnet"): import donkeycar.parts.mxnetpart as mxp df = tubgroup.df train_df = train=df.sample(frac=cfg.TRAIN_TEST_SPLIT,random_state=200) val_df = df.drop(train_df.index) m1 = mxp.MxnetLinear() train_iter, val_iter = m1.get_train_val_iter(train_df, val_df, cfg.BATCH_SIZE) m1.train(train_iter, val_iter, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT) else: kl = KerasCategorical() train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) kl.train(train_gen, val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT)
def show_histogram(self, tub_paths, record_name): """ Produce a histogram of record type frequency in the given tub """ from matplotlib import pyplot as plt from donkeycar.parts.datastore import TubGroup tg = TubGroup(tub_paths) if record_name is not None: tg.df[record_name].hist(bins=50) else: tg.df.hist(bins=50) plt.show()
def show_histogram(self, tub_paths, record_name): ''' Produce a histogram of record type frequency in the given tub ''' from matplotlib import pyplot as plt from donkeycar.parts.datastore import TubGroup tg = TubGroup(tub_paths=tub_paths) if record_name is not None: tg.df[record_name].hist(bins=50) else: tg.df.hist(bins=50) plt.savefig( os.path.basename(model_path) + '_hist_%s.png' % record_name) plt.show()
def estimate_frames(): args = docopt(__doc__) tubs = args["--tub"] tg = TubGroup(tubs) #print(tg.df) model_path = "C:\\Users\\moritz\\Documents\\donkeycar\\d2\\mymodel_tmp2" model = keras.models.load_model(model_path) for index, frame in tg.df.iterrows(): img = PIL.Image.open(frame["cam/image_array"]) arr = np.array(img) n = np.uint8(arr) img_arr = n.reshape((1, ) + n.shape) angle_binned, throttle = model.predict(np.uint8(img_arr)) angle_unbinned = dk.utils.linear_unbin(angle_binned) print("angle_unbinned", angle_unbinned, "throttle", throttle) print("user/angle", frame["user/angle"], "user/throttle", frame["user/throttle"])
def create_real_dataset(filter_method): tubgroup = TubGroup( "data/log_20,data/log_21,data/log_23,data/log_1,data/log_2,data/log_3,data/log_4,data/log_w_6,data/log_w_7" ) print("splitting train / validation 0.9/0.1") train_df = tubgroup.df.sample(frac=0.9, random_state=200) val_df = tubgroup.df.drop(train_df.index) train_data_set = DriveDataSet.from_tubgroup(train_df, filter_method=filter_method, fake_image=False) val_data_set = DriveDataSet.from_tubgroup(val_df, filter_method=filter_method, fake_image=False) print("dataset created") return train_data_set, val_data_set
def augment(tub_names, new_data_dir, args): new_data_dir = os.path.expanduser(new_data_dir) tubgroup = TubGroup(tub_names) # If tub directory does not exist, create directory if not os.path.exists(new_data_dir): os.makedirs(new_data_dir) # If directory does not contain meta.json, copy one from the first source tub if not os.path.exists(os.path.join(new_data_dir, 'meta.json')): copyfile(src=tubgroup.tubs[0].meta_path, dst=os.path.join(new_data_dir, 'meta.json')) new_tub = Tub(new_data_dir) for tub in tubgroup.tubs: for ix in tub.get_index(shuffled=False): record = tub.get_record(ix) for augmented_record in augment_single_record(record, args): new_tub.put_record(augmented_record)
def clean_slow_frames(): args = docopt(__doc__) tubs = args["--tub"] tg = TubGroup(tubs) print(tg.df) tg.df[tg.df["user/throttle"] < 0.1] json_files_to_clean = tg.df[ tg.df["user/throttle"] < 0.1]["cam/image_array"].map( lambda x: "\\".join(x.split("\\")[:-1]) + "\\" + "record_" + x. replace("_cam-image_array_.jpg", "").rsplit("\\")[-1] + ".json") images_to_clean = tg.df[tg.df["user/throttle"] < 0.1]["cam/image_array"] for file in json_files_to_clean: f = "C:\\Users\\moritz\\Documents\\donkeycar\\d2\\data\\tmp\\" + file.split( "\\")[-2] + file.split("\\")[-2] if not os.path.exists(f): os.mkdir(f) shutil.move(file, f) for file in images_to_clean: f = "C:\\Users\\moritz\\Documents\\donkeycar\\d2\\data\\tmp\\" + file.split( "\\")[-2] + file.split("\\")[-2] if not os.path.exists(f): os.mkdir(f) shutil.move(file, f)
def test_tubgroup_types(tubs): """ Get TubGroup types """ list_of_tubs = tubs[1] str_of_tubs = ','.join(list_of_tubs) t = TubGroup(str_of_tubs) assert sorted(t.types) == sorted(['image_array', 'float', 'float'])
def create_real_dataset(filter_method): tubgroup = TubGroup("../data/aws") return DriveDataSet.from_tubgroup(tubgroup.df, filter_method=filter_method, fake_image=False)
import keras from donkeycar.parts.datastore import TubGroup from model import create_model verbose = 2 train_split = .8 X_keys = ['cam/image_array'] y_keys = ['user/angle'] tubgroup = TubGroup( "..\..\..\picar_sync\wide-36.6-day,..\..\..\picar_sync\wide-36.6-evening-ccw-recovery" ) train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, batch_size=10, train_frac=train_split) save_best = keras.callbacks.ModelCheckpoint('model_{val_loss:.4f}.hdf5', monitor='val_loss', verbose=verbose, save_best_only=True, mode='min') early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=.0005, patience=5, verbose=verbose, mode='auto') steps_per_epoch = 100
def playback(cfg, tub_names, model_name=None): if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) if not model_name is None: from donkeycar.parts.keras import KerasCategorical kl = KerasCategorical() kl.load(model_name) pilot_angles = [] pilot_throttles = [] print('tub_names', tub_names) tub_paths = utils.expand_path_arg(tub_names) print('TubGroup:tubpaths:', tub_paths) user_angles = [] user_throttles = [] tubs = [Tub(path) for path in tub_paths] for tub in tubs: num_records = tub.get_num_records() print(num_records) for iRec in tub.get_index(shuffled=False): record = tub.get_record(iRec) #record = tubs.get_record(random.randint(1,num_records+1)) img = record["cam/image_array"] user_angle = float(record["user/angle"]) user_throttle = float(record["user/throttle"]) user_angles.append(user_angle) user_throttles.append(user_throttle) if not model_name is None: pilot_angle, pilot_throttle = kl.run(img) pilot_angles.append(pilot_angle) pilot_throttles.append(pilot_throttle) record = tubs[0].get_record(random.randint(1,num_records+1)) user_angle = float(record["user/angle"]) user_throttle = float(record["user/throttle"]) print(img.shape) print('-----') print(user_angle) print(user_throttle) plt.figure() plt.imshow(img) plt.plot([80,80+10*user_throttle*np.cos(user_angle)],[120,120+100*user_throttle*np.sin(user_angle)]) plt.figure() plt.plot(user_angles) plt.plot(user_throttles) fig = plt.figure() ax1 = plt.subplot2grid((2,2),(0,0)) record = tubs[0].get_record(1) img = record["cam/image_array"] imPlot = ax1.imshow(img,animated=True) floorImg = lookAtFloorImg(img) print(floorImg) ax3 = plt.subplot2grid((2,2),(0,1)) imPlot2 = ax3.imshow(floorImg,animated=True) ax2 = plt.subplot2grid((2,2),(1,0), colspan=2) line1, = ax2.plot(user_angles) line2, = ax2.plot(user_throttles) if not model_name is None: line4, = ax2.plot(pilot_angles) line5, = ax2.plot(pilot_throttles) line3, = ax2.plot([0,0],[-1,1]) def animate(i): record = tubs[0].get_record(i) img = record["cam/image_array"] imPlot.set_array(img) imPlot2.set_array(lookAtFloorImg(img)) line3.set_data([i,i],[-1,1]) #print(i) #sys.stdout.flush() return imPlot, # Init only required for blitting to give a clean slate. def init(): record = tubs[0].get_record(1) img = record["cam/image_array"] imPlot.set_array(img) line3.set_data([0,0],[-1,1]) return imPlot, ani = animation.FuncAnimation(fig, animate, np.arange(1, tubs[0].get_num_records()), interval=100, blit=False) plt.show()
self.model.predict(image_ready[None, :, :, :], batch_size=1)) fig = plt.figure(figsize=(6, 4)) show(fig, (1, 1, 1), "Predicted steering angle : {}".format(steering_angle), image) savefig(parameter['saved_images_folder'] + name) def load_N_make_prediction(self, path, name): image = load_image(path[0]) self.make_prediction(image, name) if __name__ == "__main__": X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] tubgroup = TubGroup("./data/tub_29_18-09-09") train_gen, val_gen = tubgroup.get_train_val_gen(X_keys, y_keys, batch_size=32, train_frac=0.8) print("Fetching data ...") steering_angles = [] for _, user_data in train_gen: steering_angles.append(user_data[0]) print("%f frames.".format(len(steering_angles))) if 0: i = get_random_image_id(image_paths) save_3_views(image_paths[i], steering_angles[i], '3views.png')
def train(cfg, tub_names, model_name, model_type): ''' use the specified data in tub_names to train an artifical neural network saves the output trained model as model_name ''' X_keys = ['cam/image_array'] y_keys = ['user/angle', 'user/throttle'] binning = dk.utils.linear_bin if model_type == "hres_cat": binning = dk.utils.linear_bin_hres def rt(record): record['user/angle'] = binning(record['user/angle']) return record kl = KerasCategorical() if model_type == 'linear': kl = KerasLinear() if model_type == 'categorical': kl = KerasCategorical() if model_type == 'hres_cat': kl = KerasHresCategorical() print('tub_names', tub_names) if not tub_names: tub_names = os.path.join(cfg.DATA_PATH, '*') tubgroup = TubGroup(tub_names) train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, record_transform=rt, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) if model_type == 'linear': train_gen, val_gen = tubgroup.get_train_val_gen( X_keys, y_keys, batch_size=cfg.BATCH_SIZE, train_frac=cfg.TRAIN_TEST_SPLIT) model_path = os.path.expanduser(model_name) total_records = len(tubgroup.df) total_train = int(total_records * cfg.TRAIN_TEST_SPLIT) total_val = total_records - total_train print('train: %d, validation: %d' % (total_train, total_val)) steps_per_epoch = total_train // cfg.BATCH_SIZE print('steps_per_epoch', steps_per_epoch) print(val_gen) history, save_best = kl.train(train_gen=train_gen, val_gen=val_gen, saved_model_path=model_path, steps=steps_per_epoch, train_split=cfg.TRAIN_TEST_SPLIT) plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss : %f' % save_best.best) plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.savefig(model_path + '_' + model_type + '_loss_%f.png' % save_best.best)
def test_tubgroup_inputs(tubs): """ Get TubGroup inputs """ list_of_tubs = tubs[1] str_of_tubs = ','.join(list_of_tubs) t = TubGroup(str_of_tubs) assert sorted(t.inputs) == sorted(['cam/image_array', 'angle', 'throttle'])
def test_tubgroup_get_num_records(tubs): """ Get number of records in TubGroup """ list_of_tubs = tubs[1] str_of_tubs = ','.join(list_of_tubs) t = TubGroup(str_of_tubs) assert t.get_num_records() == 25
def test_tubgroup_load(tubs): """ Load TubGroup from existing tubs dir """ list_of_tubs = tubs[1] str_of_tubs = ','.join(list_of_tubs) t = TubGroup(str_of_tubs) assert t is not None