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 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, 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']
#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 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 #KerasCategorical
import pandas as pd
import matplotlib.pyplot as plt
tg = TubGroup(tub_paths)
model_path = os.path.expanduser(model_path)
# model = KerasCategorical()
model = KerasLinear()
model.load(model_path)
# gen = tg.get_batch_gen(None, batch_size=len(tg.df),shuffle=False, df=tg.df)
# gen = tg.get_batch_gen(None, None, batch_size=len(tg.df),shuffle=False, 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):
"""
引数 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 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, 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):
"""
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 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 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 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 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 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 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_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
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 create_real_dataset(filter_method):
tubgroup = TubGroup("../data/aws")
return DriveDataSet.from_tubgroup(tubgroup.df,
filter_method=filter_method,
fake_image=False)
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_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 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
