def __init__(self, args):
super().__init__()
self.args = args
obs_dim, act_dim = self.args.obs_dim, self.args.act_dim
n_hiddens, n_units, hidden_activation = self.args.num_hidden_layers, self.args.num_hidden_units, self.args.hidden_activation
value_model_cls, policy_model_cls = NAME2MODELCLS[self.args.value_model_cls], \
NAME2MODELCLS[self.args.policy_model_cls]
self.policy = policy_model_cls(
obs_dim,
n_hiddens,
n_units,
hidden_activation,
act_dim * 2,
name='policy',
output_activation=self.args.policy_out_activation)
policy_lr_schedule = PolynomialDecay(*self.args.policy_lr_schedule)
self.policy_optimizer = self.tf.keras.optimizers.Adam(
policy_lr_schedule, name='adam_opt')
self.vs = value_model_cls(obs_dim,
n_hiddens,
n_units,
hidden_activation,
2,
name='vs')
value_lr_schedule = PolynomialDecay(*self.args.value_lr_schedule)
self.value_optimizer = self.tf.keras.optimizers.Adam(value_lr_schedule,
name='adam_opt')
self.models = (
self.vs,
self.policy,
)
self.optimizers = (self.value_optimizer, self.policy_optimizer)
def get_lr_scheduler(learning_rate, decay_type, decay_steps):
if decay_type:
decay_type = decay_type.lower()
if decay_type == None:
lr_scheduler = learning_rate
elif decay_type == 'cosine':
lr_scheduler = CosineDecay(
initial_learning_rate=learning_rate,
decay_steps=decay_steps,
alpha=0.2) # use 0.2*learning_rate as final minimum learning rate
elif decay_type == 'exponential':
lr_scheduler = ExponentialDecay(initial_learning_rate=learning_rate,
decay_steps=decay_steps,
decay_rate=0.9)
elif decay_type == 'polynomial':
lr_scheduler = PolynomialDecay(initial_learning_rate=learning_rate,
decay_steps=decay_steps,
end_learning_rate=learning_rate / 100)
elif decay_type == 'piecewise_constant':
#apply a piecewise constant lr scheduler, including warmup stage
boundaries = [500, int(decay_steps * 0.9), decay_steps]
values = [
0.001, learning_rate, learning_rate / 10., learning_rate / 100.
]
lr_scheduler = PiecewiseConstantDecay(boundaries=boundaries,
values=values)
else:
raise ValueError('Unsupported lr decay type')
return lr_scheduler
def make_scheduler(name, init_lr, steps_per_epoch):
if name == 'constant':
lr_fn = init_lr
elif name == 'piecewise_decay':
lr_fn = PiecewiseConstantDecay(
boundaries=[20*steps_per_epoch,
50*steps_per_epoch,
100*steps_per_epoch,
150*steps_per_epoch,
200*steps_per_epoch,
250*steps_per_epoch],
values=[init_lr,
init_lr * 0.8, #50
init_lr * 0.6, #50
init_lr * 0.4, #100
init_lr * 0.3, #150
init_lr * 0.2, #200
init_lr * 0.1]) #250
elif name == 'linear_decay':
decay_steps = steps_per_epoch * 300 # defaultly during 300 epoch, learning rate goes down.
lr_fn = PolynomialDecay(initial_learning_rate=init_lr, decay_steps=decay_steps, end_learning_rate=init_lr*0.1, power=1.0)
elif name == 'cosine_decay_restart':
first_decay_steps = 1000
lr_fn = CosineDecayRestarts(initial_learning_rate=init_lr, first_decay_steps=first_decay_steps, t_mul=2.0)
print(name, lr_fn)
return lr_fn
def getScheduler(sched, lr=1e-3):
if sched == 'poly':
return PolynomialDecay(lr, 3000, 0.99)
elif sched == 'exp':
return ExponentialDecay(lr, 1000)
else:
return lr
def build_model(transformer,
max_len: int = 512,
multi_class: bool = True,
lr_decay: bool = False): # noqa: D205
"""
Build an end-to-end Transformer model. Requires a transformer of type TFAutoBert.
https://www.kaggle.com/xhlulu/jigsaw-tpu-distilbert-with-huggingface-and-keras
:param transformer: Transformer model
:param max_len: maximum length of encoded sequence
:param multi_class: if True, final layer is multiclass so softmax is used. If False, final layer
is sigmoid and binary crossentropy is evaluated.
:param lr_decay: if True, use a learning rate decay schedule. If False, use a constant learning rate.
:return: Constructed Transformer model
"""
input_word_ids = Input(shape=(max_len, ),
dtype=tf.int32,
name="input_word_ids")
sequence_output = transformer(input_word_ids)[0]
cls_token = sequence_output[:, 0, :]
if multi_class:
out = Dense(3, activation='softmax', name='softmax')(cls_token)
else:
out = Dense(1, activation='sigmoid', name='sigmoid')(cls_token)
model = Model(inputs=input_word_ids, outputs=out)
if lr_decay:
# There are various options, starting with a linear decay for now
# TODO: Tune for the best decay schedule
lr = PolynomialDecay(initial_learning_rate=2e-5,
decay_steps=10000,
end_learning_rate=1e-6,
power=1)
else:
lr = 1e-6
if multi_class:
model.compile(Adam(learning_rate=lr),
loss='categorical_crossentropy',
metrics=[
tf.keras.metrics.Recall(),
tf.keras.metrics.Precision(),
tf.keras.metrics.CategoricalAccuracy()
])
else:
model.compile(Adam(learning_rate=lr),
loss='binary_crossentropy',
metrics=[
tf.keras.metrics.Recall(),
tf.keras.metrics.Precision(), 'accuracy'
])
return model
def get_lr_scheduler(learning_rate, decay_type, decay_steps):
if decay_type:
decay_type = decay_type.lower()
if decay_type == None:
lr_scheduler = learning_rate
elif decay_type == 'cosine':
lr_scheduler = CosineDecay(initial_learning_rate=learning_rate, decay_steps=decay_steps)
elif decay_type == 'exponential':
lr_scheduler = ExponentialDecay(initial_learning_rate=learning_rate, decay_steps=decay_steps, decay_rate=0.9)
elif decay_type == 'polynomial':
lr_scheduler = PolynomialDecay(initial_learning_rate=learning_rate, decay_steps=decay_steps, end_learning_rate=learning_rate/100)
else:
raise ValueError('Unsupported lr decay type')
return lr_scheduler
def main():
gpus = tf.config.experimental.list_physical_devices("GPU")
if gpus:
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
# 读取数据
reader = DataLoader(cfg.annotation_path, cfg.input_shape, cfg.batch_size)
train, valid = reader.read_data_and_split_data()
train_datasets = reader.make_datasets(train, "train")
valid_datasets = reader.make_datasets(valid, "valid")
train_steps = len(train) // cfg.batch_size
valid_steps = len(valid) // cfg.batch_size
if os.path.exists(cfg.log_dir):
# 清除summary目录下原有的东西
for f in os.listdir(cfg.log_dir):
file = os.path.join(cfg.log_dir, f)
shutil.rmtree(file)
# 建立模型保存目录
if not os.path.exists(os.path.split(cfg.model_path)[0]):
os.mkdir(os.path.split(cfg.model_path)[0])
print('Train on {} samples, val on {} samples, with batch size {}.'.format(len(train), len(valid), cfg.batch_size))
if cfg.train_mode == "eager":
# 定义优化器和学习率衰减速率
# PolynomialDecay参数：cfg.learn_rating 经过 cfg.epochs 衰减到 cfg.learn_rating/10
# 1、lr_fn是类似是一个函数，每次需要它来计算当前学习率都会调用它
# 2、它具有一个内部计数器，每次调用apply_gradients，就会+1
yolo_loss = [YoloLoss(cfg.anchors[mask]) for mask in cfg.anchor_masks]
lr_fn = PolynomialDecay(cfg.learn_rating, cfg.epochs, cfg.learn_rating / 10, 2)
optimizer = Adam(learning_rate=lr_fn)
low_level_train(optimizer, yolo_loss, train_datasets, valid_datasets, train_steps, valid_steps)
else:
# 创建summary
writer = tf.summary.create_file_writer(logdir=cfg.log_dir + '/loss')
optimizer = Adam(learning_rate=cfg.learn_rating)
yolo_loss = [YoloLoss(cfg.anchors[mask],
summary_writer=writer,
optimizer=optimizer) for mask in cfg.anchor_masks]
high_level_train(optimizer, yolo_loss, train_datasets, valid_datasets, train_steps, valid_steps)
def run_training():
trainee = AiAgent(prediction_model,
gameplay_model,
epsilon=0.2,
epsilon_decay=PolynomialDecay(initial_learning_rate=0.9,
decay_steps=25,
end_learning_rate=0.1))
trainer = MetaFixAgent()
dojo = RPSDojo(trainee=trainee,
trainer=trainer,
episodes=NUM_GAMES,
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.MeanSquaredError(),
discount=0.95,
batch_size=512,
rounds_in_episode=NUM_ROUNDS,
trainee_logging_path=DATA_LOCATION + 'action_history.csv')
dojo.run_training()
gameplay_model.save(MODEL_LOCATION, include_optimizer=False)
dojo.write_history(DATA_LOCATION + 'training_history.csv')
def train_by_eager(train_datasets, valid_datasets, train_steps, valid_steps):
# 创建模型结构
if cfg.backbone == 'csp-darknet':
model = yolo4_body(cfg.input_shape)
elif cfg.backbone == 'tiny-csp-darknet':
model = tiny_yolo4_body(cfg.input_shape)
# 定义模型评估指标
train_loss = metrics.Mean(name='train_loss')
valid_loss = metrics.Mean(name='valid_loss')
# 将数据集实例化成迭代器
train_datasets = iter(train_datasets)
valid_datasets = iter(valid_datasets)
# 设置保存最好模型的指标
best_test_loss = float('inf')
patience = 10
min_delta = 1e-3
patience_cnt = 0
history_loss = []
# 创建优化器
# 定义优化器和学习率衰减速率
# PolynomialDecay参数：cfg.learn_rating 经过 cfg.epochs 衰减到 cfg.learn_rating/10
# 1、lr_fn是类似是一个函数，每次需要它来计算当前学习率都会调用它
# 2、它具有一个内部计数器，每次调用apply_gradients，就会+1
lr_fn = PolynomialDecay(cfg.learning_rate, cfg.epochs,
cfg.learning_rate / 10, 2)
optimizer = optimizers.Adam(learning_rate=lr_fn)
# 创建summary
summary_writer = tf.summary.create_file_writer(logdir=cfg.log_dir)
# 定义loss
yolo_loss = [
YoloLoss(cfg.anchors[mask],
label_smooth=cfg.label_smooth,
summary_writer=summary_writer,
optimizer=optimizer) for mask in cfg.anchor_masks
]
# low level的方式计算loss
for epoch in range(1, cfg.epochs + 1):
train_loss.reset_states()
valid_loss.reset_states()
# 处理训练集数据
process_bar = tqdm(range(train_steps),
ncols=100,
desc="Epoch {}".format(epoch),
unit="step")
for _ in process_bar:
images, labels = next(train_datasets)
with tf.GradientTape() as tape:
# 得到预测
outputs = model(images, training=True)
# 计算损失(注意这里收集model.losses的前提是Conv2D的kernel_regularizer参数)
regularization_loss = tf.reduce_sum(model.losses)
pred_loss = []
# yolo_loss、label、output都是3个特征层的数据，通过for 拆包之后，一个loss_fn就是yolo_loss中一个特征层
# 然后逐一计算,
for output, label, loss_fn in zip(outputs, labels, yolo_loss):
pred_loss.append(loss_fn(label, output))
# 总损失 = yolo损失 + 正则化损失
total_train_loss = tf.reduce_sum(
pred_loss) + regularization_loss
# 反向传播梯度下降
# model.trainable_variables代表把loss反向传播到每个可以训练的变量中
grads = tape.gradient(total_train_loss, model.trainable_variables)
# 将每个节点的误差梯度gradients，用于更新该节点的可训练变量值
# zip是把梯度和可训练变量值打包成元组
optimizer.apply_gradients(zip(grads, model.trainable_variables))
# 更新train_loss
train_loss.update_state(total_train_loss)
loss = train_loss.result().numpy()
process_bar.set_postfix({
'loss':
'{:.4f}'.format(loss),
'lbox_loss':
'{:.4f}'.format(pred_loss[0]),
'mbox_loss':
'{:.4f}'.format(pred_loss[1]),
'sbox_loss':
'{:.4f}'.format(pred_loss[2])
if cfg.backbone == 'csp-backone' else None,
'reg_loss':
'{:.4f}'.format(regularization_loss),
})
# 计算验证集
process_bar = tqdm(range(valid_steps),
ncols=100,
desc="Epoch {}".format(epoch),
unit="step")
for _ in process_bar:
images, labels = next(valid_datasets)
# 得到预测，不training
outputs = model(images)
regularization_loss = tf.reduce_sum(model.losses)
pred_loss = []
for output, label, loss_fn in zip(outputs, labels, yolo_loss):
pred_loss.append(loss_fn(label, output))
total_valid_loss = tf.reduce_sum(pred_loss) + regularization_loss
# 更新valid_loss
valid_loss.update_state(total_valid_loss)
process_bar.set_postfix({
'loss':
'{:.4f}'.format(valid_loss.result().numpy()),
'lbox_loss':
'{:.4f}'.format(pred_loss[0]),
'mbox_loss':
'{:.4f}'.format(pred_loss[1]),
'sbox_loss':
'{:.4f}'.format(pred_loss[2])
if cfg.backbone == 'csp-backone' else None,
'reg_loss':
'{:.4f}'.format(regularization_loss),
})
# 保存loss，可以选择train的loss
history_loss.append(valid_loss.result().numpy())
# 保存到tensorboard里
with summary_writer.as_default():
tf.summary.scalar('train_loss',
train_loss.result(),
step=optimizer.iterations)
tf.summary.scalar('valid_loss',
valid_loss.result(),
step=optimizer.iterations)
tf.summary.scalar('regularization_loss',
regularization_loss,
step=optimizer.iterations)
# 只保存最好模型
if valid_loss.result() < best_test_loss:
best_test_loss = valid_loss.result()
model.save_weights(cfg.model_path)
# EarlyStopping
if epoch > 1 and history_loss[epoch - 2] - history_loss[epoch -
1] > min_delta:
patience_cnt = 0
else:
patience_cnt += 1
if patience_cnt >= patience:
tf.print(
"No improvement for {} times, early stopping optimization.".
format(patience))
break
def train(type_name, n_hidden):
# Initialize save path
save_path = "/home/kevin/projects/exercise_pose_evaluation_machine/models/lstm_model/keras/" + type_name + "/" + type_name + "_lstm_model.h5"
# Get original dataset
x, y = get_dataset(type_name)
# Fill original class type with the label 1
y = [1 for label in y]
# Get negative dataset
neg_x, neg_y = get_dataset("not-" + type_name)
# Fill original class type with the label 1
neg_y = [0 for label in neg_y]
x.extend(neg_x)
y.extend(neg_y)
# Flatten X coodinates and filter
x = np.array(x)
_x = []
_y = []
for idx, data in enumerate(x):
data = [np.reshape(np.array(frames), (28)).tolist() for frames in data]
_x.append(data)
_y.append(y[idx])
x = _x
y = _y
# Split to training and test dataset
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.3)
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
# Define training parameters
n_classes = 1
# Make LSTM Layer
# Pair of lstm cell initialization through loop
# use_bias -> Adding bias vector on each layer, by default is True so this line could be deleted
# unit_forget_bias ->
lstm_cells = [
LSTMCell(n_hidden,
activation='relu',
use_bias=True,
unit_forget_bias=1.0) for _ in range(2)
]
stacked_lstm = StackedRNNCells(lstm_cells)
lstm_layer = RNN(stacked_lstm)
learning_rate = 1e-2
lr_schedule = PolynomialDecay(initial_learning_rate=learning_rate,
decay_steps=10,
end_learning_rate=0.00001)
optimizer = Adam(learning_rate=lr_schedule)
# Initiate model
# kernel_regularizers -> regularizing weights to avoid overfit training data on layer kernel
# activity_regularizer -> regularizing weights to avoid overfit training data on layer output
model = Sequential()
model.add(lstm_layer)
model.add(Dropout(0.3))
model.add(
Dense(n_classes,
activation='sigmoid',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.01)))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# simple early stopping
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=50)
# Train model
# shufffle = True -> shuffle training data
# validation_split -> portion of training data used for validation split
# validation_data -> external data used for validation
model.fit(x_train,
y_train,
epochs=450,
batch_size=150,
shuffle=True,
validation_data=(x_test, y_test),
validation_split=0.4,
callbacks=[es])
# Print model stats
print(model.summary())
print(model.get_config())
# Find accuracy
_, accuracy = model.evaluate(x_test, y_test)
print('Accuracy: %.2f' % (accuracy * 100))
# Save model
model.save(save_path)
print("Saved model!")
# Generate predictions
print("See prediction result")
random_int = random.randint(0, len(x_test))
data = x_test[random_int]
prediction = "1" if model.predict(np.array([data])) > 0.5 else "0"
print("predictions result:", prediction)
print("expected result: ", y_test[random_int])
# # num_found = re.search(r'\d+', checkpoint_filename)
# # if num_found:
# # start_epoch = int(num_found.group(0))
# # _LOGGER.info(f"Resuming from epoch {start_epoch}")
# else:
model.save_weights(checkpoint_prefix, overwrite=True, save_format="tf")
# _LOGGER.debug("Model summary: %s", model.summary())
# -
# configure training and compile model
# create learning_rate function
if learning_policy == "poly":
learning_rate_fn = PolynomialDecay(
initial_learning_rate=learning_rate,
decay_steps=steps_per_epoch * n_epochs,
end_learning_rate=0,
power=learning_power,
)
elif learning_policy == "step":
learning_rate_fn = ExponentialDecay(
initial_learning_rate=learning_rate,
decay_steps=steps_per_epoch,
decay_rate=learning_rate_decay,
staircase=True,
)
# create custom metric
metric = MeanIoUCustom(
num_classes=num_classes,
ignore_label=ignore_label,
crop_size_h=cs_h,
def train(type_name, filename, n_hidden, lstm_layer, dropout, epoch, batch_size, x, y):
# Make filename
date_string = datetime.now().isoformat().replace(':', '.')
filename = f'{filename} k-fold results {date_string}'
# Create file and write CSV header
write_header(filename)
body = {}
body['n_hidden'] = n_hidden
body['lstm_layer'] = lstm_layer
body['dropout'] = dropout
body['epoch'] = epoch
body['batch_size'] = batch_size
# Initialize total accuracy variable and number of K-Fold splits
total = 0
n_splits = 5
# Initialize K Fold
skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=1)
k_fold_index = 1
x = np.array(x)
y = np.array(y)
t_start = time.time()
for train_index, test_index in skf.split(x, y):
# Initialize training sets
x_train = x[train_index]
y_train = y[train_index]
x_test = x[test_index]
y_test = y[test_index]
# Define training parameters
n_output = 1
# Make LSTM Layer
# Pair of lstm cell initialization through loop
lstm_cells = [LSTMCell(
n_hidden,
activation='relu',
use_bias=True,
unit_forget_bias = 1.0
) for _ in range(lstm_layer)]
stacked_lstm = StackedRNNCells(lstm_cells)
# Decaying learning rate
learning_rate = 1e-2
lr_schedule = PolynomialDecay(
initial_learning_rate=learning_rate,
decay_steps=10,
end_learning_rate= 0.00001
)
optimizer = Adam(learning_rate = lr_schedule)
# Initiate model
model = Sequential()
model.add(RNN(stacked_lstm))
model.add(Dropout(dropout))
model.add(Dense(n_output,
activation='sigmoid',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.01)))
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Train model
fit_start = time.time()
model.fit(x_train, y_train, epochs=epoch, batch_size=batch_size, shuffle = True, validation_data = (x_test, y_test), validation_split = 0.4, callbacks=[ForceGarbageCollection()])
# Print model stats
print(model.summary())
# Find accuracy
_, accuracy = model.evaluate(x_test, y_test)
accuracy *= 100
total += accuracy
body[f'k-fold {k_fold_index}'] = "{:.2f}".format(accuracy)
body[f'k-fold {k_fold_index} time'] = float(time.time() - fit_start)
print('Accuracy: %.2f' % (accuracy))
k_fold_index += 1
# UNTUK SELANJUTNYA, DIBUAT TRY EXCEPT UNTUK SETIAP BLOCK BERBEDA
# SEPERTI SAAT PREDICT ATAU SAAT OLAH DATA ATAUPUN SAAT CEK AKURASI
# AGAR GAMPANG PINPOINT MASALAH.
# Write iterations
body['seconds_to_finish'] = float(time.time() - t_start)
body['exercise name'] = type_name
body['avg'] = "{:.2f}".format(total/n_splits)
write_body(filename, body)
# Print the summary
print(model.summary())
# Callbacks
tensorboard_callback = TensorBoard(log_dir=log_dir) # , histogram_freq=1, profile_batch='1')
save_weights_only = False
# PolynomialDecay definition
if 'reds' in task:
data_size = train_sharp_generator.samples // batch_size
else:
data_size = len(train_sharp_generator)
max_steps = int((epochs-load_epoch) * data_size)
pd = PolynomialDecay(initial_learning_rate=initial_lr, decay_steps=max_steps, end_learning_rate=end_lr, power=power)
rlrop = ReduceLROnPlateau(monitor=monitor_rlrop, factor=factor_rlrop, patience=patience_rlrop, min_lr=min_lr_rlrop)
lrs = LearningRateScheduler(pd)
es = EarlyStopping(monitor=monitor_es, patience=patience_es)
mc = ModelCheckpoint(filepath=checkpoint_filepath, monitor='val_loss', save_best_only=False,
save_weights_only=save_weights_only, period=mc_period)
callbacks = [tensorboard_callback, mc]
if 'cifar' in task:
callbacks.append(LearningRateScheduler(MyPolynomialDecay(max_epochs=epochs, init_lr=initial_lr, power=5)))
# Check if tf is using GPU
# print('Using GPU: {}'.format(tf.test.is_gpu_available()))
print(tf.config.list_physical_devices('GPU'))
def train(exercise_name, dataset):
# Initialize save path
save_path = '/home/kevin/projects/exercise_pose_evaluation_machine/models/pose_model'
# save_path = '/home/kevin/projects/exercise_pose_evaluation_machine/models/pose_model_v2'
if not os.path.exists(save_path):
os.makedirs(save_path)
save_path += '/' + str(exercise_name)
if not os.path.exists(save_path):
os.makedirs(save_path)
save_path += '/' + str(exercise_name) + '_pose_model.h5'
# Get keypoint
x = []
y = []
for data in dataset:
keypoints = np.array(data["keypoints"]).flatten()
x.append(keypoints)
is_starting_pose = data["is_starting_pose"]
label = 1 if is_starting_pose else 0
y.append(label)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.3)
# Convert to np arrays so that we can use with TensorFlow
x_train = np.array(x_train).astype(np.float32)
x_test = np.array(x_test).astype(np.float32)
y_train = np.array(y_train).astype(np.float32)
y_test = np.array(y_test).astype(np.float32)
# Define number of features, labels, and hidden
num_features = 28 # 14 pairs of (x, y) keypoints
num_hidden = 8
num_output = 1
# Decaying learning rate
learning_rate = 0.01
lr_schedule = PolynomialDecay(
initial_learning_rate=learning_rate,
decay_steps=10,
end_learning_rate= 0.00001
)
optimizer = SGD(learning_rate = lr_schedule)
model = Sequential()
model.add(Dense(60, input_shape=(num_features,)))
model.add(Dense(30, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_output, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])
# Train model
model.fit(x_train, y_train, epochs=250, batch_size=25, shuffle = True, validation_data = (x_test, y_test), validation_split = 0.3)
# Find accuracy
_, accuracy = model.evaluate(x_test, y_test)
print('Accuracy: %.2f' % (accuracy*100))
print("Class: " + exercise_name)
# Save model to the designated path
model.save(save_path)
model.summary()
print("Saved model")
target_q_net = CategoricalQNetwork(
input_tensor_spec=eval_env.observation_spec(),
action_spec=eval_env.action_spec(),
num_atoms=num_atoms,
conv_layer_params=conv_layer_units,
fc_layer_params=fc_layer_units,
activation_fn=GELU())
# Defining train_step, which will be used to store the current step.
train_step = tf.Variable(initial_value=0)
total_steps = 150000
# Defining decay epsilon-greedy strategy.
decay_epsilon_greedy = PolynomialDecay(
initial_learning_rate=0.9,
decay_steps=total_steps,
end_learning_rate=0.001,
)
# 3. Constructing the DQN Agent.
optimizer = Yogi(learning_rate=0.00025)
loss = Huber()
n_steps = 3
tau = 0.001
gamma = 0.99
min_q = -200
max_q = 200
agent = CategoricalDqnAgent(
time_step_spec=eval_env.time_step_spec(),
action_spec=eval_env.action_spec(),
def print_model(filename, n_hidden, lstm_layer, dropout, type_name):
# Get original dataset
x, y = get_dataset(type_name)
# Fill original class type with the label 1
y = [1 for label in y]
# Get negative dataset
neg_x, neg_y = get_dataset("not-" + type_name)
# Fill original class type with the label 1
neg_y = [0 for label in neg_y]
x.extend(neg_x)
y.extend(neg_y)
# Flatten X coodinates and filter
x = np.array(x)
_x = []
_y = []
for idx, data in enumerate(x):
data = [np.reshape(np.array(frames), (28)).tolist() for frames in data]
_x.append(data)
_y.append(y[idx])
x = _x
y = _y
# Split to training and test dataset
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.3)
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
# Define training parameters
n_output = 1
# Make LSTM Layer
# Pair of lstm cell initialization through loop
lstm_cells = [
LSTMCell(n_hidden,
activation='relu',
use_bias=True,
unit_forget_bias=1.0) for _ in range(lstm_layer)
]
stacked_lstm = StackedRNNCells(lstm_cells)
# Decaying learning rate
learning_rate = 1e-2
lr_schedule = PolynomialDecay(initial_learning_rate=learning_rate,
decay_steps=10,
end_learning_rate=0.00001)
optimizer = Adam(learning_rate=lr_schedule)
# Initiate model
model = Sequential()
model.add(InputLayer(input_shape=x_train[0].shape))
model.add(RNN(stacked_lstm))
# model.add(LSTM(
# n_hidden,
# activation='relu',
# use_bias=True,
# unit_forget_bias = 1.0,
# input_shape=x_train[0].shape,
# return_sequences=True))
# for _ in range(lstm_layer-2):
# model.add(LSTM(
# n_hidden,
# activation='relu',
# use_bias=True,
# unit_forget_bias = 1.0,
# return_sequences=True))
# model.add(LSTM(
# n_hidden,
# activation='relu',
# use_bias=True,
# unit_forget_bias = 1.0))
model.add(Dropout(dropout))
model.add(
Dense(n_output,
activation='sigmoid',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.01)))
model.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# Train model
model.fit(x_train,
y_train,
epochs=1,
batch_size=1000,
shuffle=True,
validation_data=(x_test, y_test),
validation_split=0.4)
# Print model
with open(f'{filename}.txt', 'w') as f:
model.summary(print_fn=lambda x: f.write(x + '\n'))
plot_model(model,
to_file=f'{filename}.png',
show_shapes=True,
show_layer_names=True)
]
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=y_true_labels, logits=y_pred_logits)
weights = tf.gather(c_weights, y_true_labels)
losses = tf.multiply(losses, weights)
return tf.math.reduce_mean(losses)
EPOCHS = 350
STEPS_PER_EPOCH = TRAIN_LENGTH // BATCH_SIZE
VALIDATION_STEPS = VALID_LENGTH // BATCH_SIZE
DECAY_STEPS = (STEPS_PER_EPOCH * EPOCHS) # // ACCUM_STEPS
print("Decay steps: {}".format(DECAY_STEPS))
learning_rate_fn = PolynomialDecay(initial_learning_rate=1e-2,
decay_steps=DECAY_STEPS,
end_learning_rate=1e-5,
power=0.9)
model.compile(optimizer=SGD(learning_rate=learning_rate_fn,
momentum=0.9,
decay=0.0005),
loss=weighted_cross_entropy_loss,
metrics=['accuracy', iou_coef])
callbacks = [
# ReduceLROnPlateau(monitor='val_iou_coef', mode='max', patience=10, factor=0.2, min_lr=1e-5, verbose=2),
ModelCheckpoint(MODEL_PATH,
monitor='val_iou_coef',
mode='max',
verbose=2,
save_best_only=True,
def train(exercise_name, epochs, batch_size, double, dataset):
# Get keypoint
x = []
y = []
for data in dataset:
keypoints = np.array(data["keypoints"]).flatten()
x.append(keypoints)
is_starting_pose = data["is_starting_pose"]
label = 1 if is_starting_pose else 0
y.append(label)
# Initialize paths
base_path = "/home/kevin/projects/initial-pose-data/train_data"
date_string = datetime.now().isoformat()
filename = f'{exercise_name}_{epochs}_epochs_{batch_size}_batch_size_2x30 binary pose k-fold results {date_string}' if double else f'{exercise_name}_{epochs}_epochs_{batch_size}_batch_size binary pose k-fold results {date_string}'
# Get dataset folders
dirs = os.listdir(base_path)
# One hot encoder
y = np.array(y)
# y = y.reshape(-1, 1)
# one_hot = OneHotEncoder(sparse=False)
# y = one_hot.fit_transform(y)
# Create file and write CSV header
write_header(filename)
body = {}
# Initialize total accuracy variable and number of K-Fold splits
total = 0
n_splits = 10
# Initialize K Fold
skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=1)
k_fold_index = 1
x = np.array(x)
y = np.array(y)
for train_index, test_index in skf.split(x, y):
x_train = x[train_index]
y_train = y[train_index]
x_test = x[test_index]
y_test = y[test_index]
# Define number of features, labels, and hidden
num_features = 28 # 14 pairs of (x, y) keypoints
num_hidden = 8
num_output = 1
# Decaying learning rate
learning_rate = 0.01
lr_schedule = PolynomialDecay(
initial_learning_rate=learning_rate,
decay_steps=10,
end_learning_rate= 0.00001
)
optimizer = SGD(learning_rate = lr_schedule)
model = Sequential()
model.add(Dense(60, input_shape=(num_features,)))
model.add(Dense(30, activation='relu'))
if double:
model.add(Dense(30, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_output, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])
# Train model
model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, shuffle = True, validation_data = (x_test, y_test), validation_split = 0.3)
# Find accuracy
_, accuracy = model.evaluate(x_test, y_test)
accuracy *= 100
total += accuracy
body['k-fold ' + str(k_fold_index)] = "{:.2f}".format(accuracy)
print('Accuracy: %.2f' % (accuracy))
k_fold_index += 1
# Write iterations
body['exercise name'] = exercise_name
body['avg'] = "{:.2f}".format(total/n_splits)
write_body(filename, body)
def __init__(self, obs_dim, act_dim, value_model_cls,
value_num_hidden_layers, value_num_hidden_units,
value_hidden_activation, value_lr_schedule, policy_model_cls,
policy_num_hidden_layers, policy_num_hidden_units,
policy_hidden_activation, policy_out_activation,
policy_lr_schedule, alpha, alpha_lr_schedule, policy_only,
double_Q, target, tau, delay_update, deterministic_policy,
action_range, **kwargs):
super().__init__()
self.policy_only = policy_only
self.double_Q = double_Q
self.target = target
self.tau = tau
self.delay_update = delay_update
self.deterministic_policy = deterministic_policy
self.action_range = action_range
self.alpha = alpha
value_model_cls, policy_model_cls = NAME2MODELCLS[value_model_cls], \
NAME2MODELCLS[policy_model_cls]
self.policy = policy_model_cls(obs_dim,
policy_num_hidden_layers,
policy_num_hidden_units,
policy_hidden_activation,
act_dim * 2,
name='policy',
output_activation=policy_out_activation)
self.policy_target = policy_model_cls(
obs_dim,
policy_num_hidden_layers,
policy_num_hidden_units,
policy_hidden_activation,
act_dim * 2,
name='policy_target',
output_activation=policy_out_activation)
policy_lr = PolynomialDecay(*policy_lr_schedule)
self.policy_optimizer = self.tf.keras.optimizers.Adam(
policy_lr, name='policy_adam_opt')
self.Q1 = value_model_cls(obs_dim + act_dim,
value_num_hidden_layers,
value_num_hidden_units,
value_hidden_activation,
1,
name='Q1')
self.Q1_target = value_model_cls(obs_dim + act_dim,
value_num_hidden_layers,
value_num_hidden_units,
value_hidden_activation,
1,
name='Q1_target')
self.Q1_target.set_weights(self.Q1.get_weights())
value_lr = PolynomialDecay(*value_lr_schedule)
self.Q1_optimizer = self.tf.keras.optimizers.Adam(value_lr,
name='Q1_adam_opt')
self.Q2 = value_model_cls(obs_dim + act_dim,
value_num_hidden_layers,
value_num_hidden_units,
value_hidden_activation,
1,
name='Q2')
self.Q2_target = value_model_cls(obs_dim + act_dim,
value_num_hidden_layers,
value_num_hidden_units,
value_hidden_activation,
1,
name='Q2_target')
self.Q2_target.set_weights(self.Q2.get_weights())
self.Q2_optimizer = self.tf.keras.optimizers.Adam(value_lr,
name='Q2_adam_opt')
if self.policy_only:
self.target_models = ()
self.models = (self.policy, )
self.optimizers = (self.policy_optimizer, )
else:
if self.double_Q:
assert self.target
self.target_models = (
self.Q1_target,
self.Q2_target,
self.policy_target,
)
self.models = (
self.Q1,
self.Q2,
self.policy,
)
self.optimizers = (
self.Q1_optimizer,
self.Q2_optimizer,
self.policy_optimizer,
)
elif self.target:
self.target_models = (
self.Q1_target,
self.policy_target,
)
self.models = (
self.Q1,
self.policy,
)
self.optimizers = (
self.Q1_optimizer,
self.policy_optimizer,
)
else:
self.target_models = ()
self.models = (
self.Q1,
self.policy,
)
self.optimizers = (
self.Q1_optimizer,
self.policy_optimizer,
)
if self.alpha == 'auto':
self.alpha_model = AlphaModel(name='alpha')
alpha_lr = self.tf.keras.optimizers.schedules.PolynomialDecay(
*alpha_lr_schedule)
self.alpha_optimizer = self.tf.keras.optimizers.Adam(
alpha_lr, name='alpha_adam_opt')
self.models += (self.alpha_model, )
self.optimizers += (self.alpha_optimizer, )