def __init__(self):
super(ValidCallBack, self).__init__()
# h5py file containing validation features and validation word embeddings
self.F = h5py.File("./processed_features/validation_features.h5", "r")
self.val_features = self.F["data/features"]
wordF = h5py.File("./processed_features/embeddings.h5", 'r')
self.word_embed = wordF["data/word_embeddings"][:, :]
self.word_names = map(lambda a: a[0], wordF["data/word_names"][:])
wordF.close()
self.image_fnames = map(lambda a: a[0], self.F["data/fnames"][:])
print "[LOG] ValidCallBack: "
print "val_feats: {} -- word_embed: {} -- word_names: {} -- image_fnames: {}".format(
self.val_features.shape, self.word_embed.shape,
len(self.word_names), len(self.image_fnames))
# find all classes present in validation set
validation_classes = [cl.split("/")[-2] for cl in self.image_fnames]
# Keep only those word_embed and word_names that are present in dataset
self.unique_classes = list(set(validation_classes))
self.unique_classes_embed = []
for cl in self.unique_classes:
idx = self.word_names.index(cl)
self.unique_classes_embed.append(self.word_embed[idx])
self.unique_classes_embed = np.array(self.unique_classes_embed)
self.unique_classes_embed = self.unique_classes_embed / np.linalg.norm(
self.unique_classes_embed, axis=1, keepdims=True)
self.mylogger = Logger("logs/top_{}".format(time()))
def __init__(self,
path,
args=None,
events_dir=None,
max_step=None,
save_period=10):
self.save_period = save_period
self.path = path
train_dir = os.path.join(path, 'training')
if not os.path.exists(train_dir): os.makedirs(train_dir)
self.train_logger = Logger(train_dir)
valid_dir = os.path.join(path, 'validation')
if not os.path.exists(valid_dir): os.makedirs(valid_dir)
self.valid_logger = Logger(valid_dir)
if args:
text = 'Parameters\n---------\n'
for (key, val) in args.items():
text += '- ' + key + ' = ' + str(val) + '\n'
self.train_logger.log_text('Description', text)
self.valid_logger.log_text('Description', text)
if events_dir and max_step:
events_files = [
F for F in scan_dir(events_dir, '')[1]
if os.path.basename(F).startswith('events')
]
for events_file in events_files:
parent_dir = os.path.dirname(events_file).split(os.sep)[-1]
if 'training' == parent_dir:
train_events_file = events_file
elif 'validation' == parent_dir:
valid_events_file = events_file
self.train_logger.copyFrom(train_events_file, max_step=max_step)
self.valid_logger.copyFrom(valid_events_file, max_step=max_step)
def main(_):
# Place data loading and preprocessing on the cpu
with tf.device('/cpu:0'):
generator = DataGenerator(data_dir=FLAGS.data_dir,
dataset=FLAGS.dataset,
train_file=train_file,
test_file=val_file,
batch_size=1,
num_threads=FLAGS.num_threads,
train_shuffle=True)
# Initialize model
model = FVS_CNN(num_classes, num_factor_units, skip_layers,
finetune_layers)
loss = loss_fn(model)
train_op, learning_rate = train_fn(loss, generator)
accuracy = eval_fn(model)
# Initialize an saver for store model checkpoints
saver = tf.train.Saver(max_to_keep=1)
# Start Tensorflow session
config = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement)
with tf.Session(config=config) as sess:
# Initialize the FileWriter
logger = Logger(writer_dir, sess.graph)
# Initialize all variables
sess.run(tf.global_variables_initializer())
# Load the pretrained factor_weights into the non-trainable layer
model.load_initial_weights(sess)
print("{} Start training...".format(datetime.now()))
print("{} Open Tensorboard at --logdir {}".format(
datetime.now(), writer_dir))
# Loop over number of epochs
for epoch in range(FLAGS.num_epochs):
print("\n{} Epoch number: {}".format(datetime.now(), epoch + 1))
train(sess, model, generator, train_op, learning_rate, loss,
accuracy, epoch, logger)
test(sess, model, generator, accuracy)
save_model(sess, model, saver, epoch)
def main(_):
generator = DataGenerator(data_dir=FLAGS.data_dir,
dataset=FLAGS.dataset,
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_threads)
model = VS_CNN(num_classes=2, skip_layers=skip_layers)
loss = loss_fn(model)
warm_up, train_op, learning_rate = train_fn(loss, generator)
saver = tf.train.Saver(max_to_keep=FLAGS.num_checkpoints)
config = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
logger = Logger(writer_dir, sess.graph)
result_file = open('result_{}_base.txt'.format(FLAGS.dataset), 'w')
sess.run(tf.global_variables_initializer())
model.load_initial_weights(sess)
print("{} Start training...".format(datetime.now()))
print("{} Open Tensorboard at --logdir {}".format(
datetime.now(), writer_dir))
for epoch in range(FLAGS.num_epochs):
print("\n{} Epoch: {}/{}".format(datetime.now(), epoch + 1,
FLAGS.num_epochs))
result_file.write("\n{} Epoch: {}/{}\n".format(
datetime.now(), epoch + 1, FLAGS.num_epochs))
if epoch < 20:
train(sess, model, generator, warm_up, learning_rate, loss,
epoch, logger)
else:
train(sess, model, generator, train_op, learning_rate, loss,
epoch, logger)
test(sess, model, generator, result_file)
save_model(sess, saver, epoch)
result_file.close()
def main():
global args
args = parser.parse_args()
torch.manual_seed(seed)
torch.cuda.set_device(0)
#build model
model = CausualLSTM((IMG_HEIGHT, IMG_WIDTH), IMG_CHANNELS, args.nhid, args.kernel_size, args.nlayers,
True, args.seq_length, args.input_length).cuda()
model = torch.nn.DataParallel(model, device_ids=[0, 2, 3]).cuda()
l2_loss = nn.MSELoss(size_average=False).cuda()
l1_loss = nn.L1Loss(size_average=False).cuda()
criterion = (l1_loss,l2_loss)
if args.test:
test_input_param = {'path': os.path.join(args.path,'moving-mnist-test.npz'),
'minibatch_size': args.batch_size,
'input_data_type': 'float32',
'is_output_sequence': True}
test_input_handle = InputHandle(test_input_param)
test_input_handle.begin(do_shuffle = False)
# load the model.
with open(args.save, 'rb') as f:
model = torch.load(f)
#run the model on test data.
test_mae, test_mse, test_psnr = evaluate(model,test_input_handle,criterion)
print('=' * 120)
print('| test mae {:5.2f} | test mse {:5.2f} | test psnr {:5.2f}|'.format(
test_mae, test_mse, test_psnr))
print('=' * 120)
return
optimizer = torch.optim.Adamax(model.parameters(), lr = args.lr, betas=(0.9, 0.999))
#load data
logger = Logger(os.path.join('./log','convLSTM'))
train_input_param = {'path': os.path.join(args.path,'moving-mnist-train.npz'),
'minibatch_size': args.batch_size,
'input_data_type': 'float32',
'is_output_sequence': True}
train_input_handle = InputHandle(train_input_param)
valid_input_param = {'path': os.path.join(args.path,'moving-mnist-valid.npz'),
'minibatch_size': args.batch_size,
'input_data_type': 'float32',
'is_output_sequence': True}
valid_input_handle = InputHandle(valid_input_param)
best_val_loss = None
#test for evaluate function
valid_mae,valid_mse,valid_psnr = evaluate(model,valid_input_handle,criterion)
for epoch in range(1, args.epochs+1):
train_input_handle.begin(do_shuffle = True)
epoch_start_time = time.time()
train_loss, train_mae, train_mse = train(model,train_input_handle,criterion,optimizer,epoch)
valid_mae,valid_mse,valid_psnr = evaluate(model,valid_input_handle,criterion)
print('\n| end of epoch {:3d} | time: {:5.5f}s | valid mae {:5.2f} |'
' valid mse {:5.2f} | valid psnr {:5.2f}'
.format(epoch, (time.time() - epoch_start_time),valid_mae,valid_mse,valid_psnr))
print('-' * 120)
logger.log_scalar('train_loss',train_loss, epoch)
logger.log_scalar('train_mae',train_mae, epoch)
logger.log_scalar('train_mse',train_mse, epoch)
logger.log_scalar('valid_mae',valid_mae,epoch)
logger.log_scalar('valid_mse',valid_mse, epoch)
logger.log_scalar('valid_psnr',valid_psnr, epoch)
# Save the model if the validation loss is the best we've seen so far.
if not best_val_loss or valid_mae+valid_mse < best_val_loss:
with open(args.save, 'wb') as f:
torch.save(model, f)
best_val_loss = valid_mae+valid_mse
ratio = (new_log_probs - old_log_probs).exp()
surr1 = ratio * advantage
surr2 = torch.clamp(ratio, 1.0 - clip_param, 1.0 + clip_param) * advantage
actor_loss = - torch.min(surr1, surr2).mean()
critic_loss = (return_ - value).pow(2).mean()
loss = 0.5 * critic_loss + actor_loss - 0.001 * entropy
optimizer.zero_grad()
loss.backward()
optimizer.step()
if __name__ == '__main__':
logger = Logger('./log')
env = ProstheticsEnv(False)
envs = [make_env() for i in range(NUM_ENVS)]
envs = SubprocVecEnv(envs)
model = ActorCritic(num_inputs, num_outputs, hidden_size).to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
frame_idx = 0
test_rewards = []
state = envs.reset()
while frame_idx < max_frames:
log_probs = []
values = []
# Setup env
env = create_environment(args.env,
n_env=args.n_proc,
size=args.size,
sparse=args.sparse)
eval_env = create_environment(args.env,
n_env=args.n_proc,
seed=42,
size=args.size,
sparse=args.sparse)
is_mario = True if 'Mario' in args.env else False
norm_input = True
# Logger
TB_LOGGER = Logger(sett.LOGPATH)
print('Torch Device: %s' % sett.device)
# Store HYPER in the log
for key, value in args._get_kwargs():
TB_LOGGER.log_text(tag=str(key), value=[str(value)], step=0)
obs = env.reset()
# Setup Model
n_actions = env.action_space.n if env.action_space.shape == (
) else env.action_space.shape[0]
n_state = env.observation_space.n if env.observation_space.shape == (
) else env.observation_space.shape
conv = True if isinstance(n_state, tuple) else False
class ValidCallBack(keras.callbacks.Callback):
def __init__(self):
super(ValidCallBack, self).__init__()
# h5py file containing validation features and validation word embeddings
self.F = h5py.File("./processed_features/validation_features.h5", "r")
self.val_features = self.F["data/features"]
wordF = h5py.File("./processed_features/embeddings.h5", 'r')
self.word_embed = wordF["data/word_embeddings"][:, :]
self.word_names = map(lambda a: a[0], wordF["data/word_names"][:])
wordF.close()
self.image_fnames = map(lambda a: a[0], self.F["data/fnames"][:])
print "[LOG] ValidCallBack: "
print "val_feats: {} -- word_embed: {} -- word_names: {} -- image_fnames: {}".format(
self.val_features.shape, self.word_embed.shape,
len(self.word_names), len(self.image_fnames))
# find all classes present in validation set
validation_classes = [cl.split("/")[-2] for cl in self.image_fnames]
# Keep only those word_embed and word_names that are present in dataset
self.unique_classes = list(set(validation_classes))
self.unique_classes_embed = []
for cl in self.unique_classes:
idx = self.word_names.index(cl)
self.unique_classes_embed.append(self.word_embed[idx])
self.unique_classes_embed = np.array(self.unique_classes_embed)
self.unique_classes_embed = self.unique_classes_embed / np.linalg.norm(
self.unique_classes_embed, axis=1, keepdims=True)
self.mylogger = Logger("logs/top_{}".format(time()))
def on_epoch_end(self, epoch, logs={}):
accuracy_list = []
for i in range(len(self.val_features)):
trueclass = self.image_fnames[i].split("/")[-2]
feat = self.val_features[i]
preds = self.model.predict(feat.reshape((1, 4096)))
preds = preds / np.linalg.norm(preds)
diff = self.unique_classes_embed - preds
diff = np.linalg.norm(diff, axis=1)
# min_idx = sorted(range(len(diff)), key=lambda x: diff[x])
min_idx = np.argsort(diff)
min_idx = min_idx[0:3]
# print "current image of class {} | is closest to embedding of words:".format(trueclass)
closest_words = []
for i in min_idx:
# print self.unique_classes[i]
closest_words.append(self.unique_classes[i])
# save closest words to accuracy_list
accuracy_list.append([self.image_fnames, trueclass, closest_words])
# Display accuracy
top_1_acc = 0.0
top_3_acc = 0.0
for accuracy_data in accuracy_list:
if accuracy_data[1] in accuracy_data[2][
0:3]: # --- Top 1 Accuracy ---
top_3_acc += 1
if accuracy_data[1] == accuracy_data[2][
0]: # --- Top 3 Accuracy ---
top_1_acc += 1
top_1_acc = round(top_1_acc / len(accuracy_list), 3)
top_3_acc = round(top_3_acc / len(accuracy_list), 3)
print "top 1: {} | top 3: {} ".format(top_1_acc, top_3_acc)
print epoch
self.mylogger.log_scalar("top1", float(top_1_acc), epoch)
self.mylogger.log_scalar("top3", float(top_3_acc), epoch)
def custom_for_keras(self, ALL_word_embeds):
## only the top 20 rows from word_vectors is legit!
def top_accuracy(true_word_indices, image_vectors):
l2 = lambda x, axis: K.sqrt(
K.sum(K.square(x), axis=axis, keepdims=True))
l2norm = lambda x, axis: x / l2(x, axis)
l2_words = l2norm(ALL_word_embeds, axis=1)
l2_images = l2norm(image_vectors, axis=1)
tiled_words = K.tile(K.expand_dims(l2_words, axis=1), (1, 200, 1))
tiled_images = K.tile(K.expand_dims(l2_images, axis=1), (1, 20, 1))
diff = K.squeeze(l2(l2_words - l2_images, axis=2))
# slice_top3 = lambda x: x[:, 0:3]
# slice_top1 = lambda x: x[:, 0:1]
diff_top5 = metrics.top_k_categorical_accuracy(tiled_images, diff)
return diff_top5
return top_accuracy
surr1 = ratio * advantage
surr2 = torch.clamp(ratio, 1.0 - clip_param,
1.0 + clip_param) * advantage
actor_loss = -torch.min(surr1, surr2).mean()
critic_loss = (return_ - value).pow(2).mean()
loss = 0.5 * critic_loss + actor_loss - 0.001 * entropy
optimizer.zero_grad()
loss.backward()
optimizer.step()
if __name__ == '__main__':
logger = Logger('./log')
env = ProstheticsEnv(False)
envs = [make_env() for i in range(NUM_ENVS)]
envs = SubprocVecEnv(envs)
model = ActorCritic(num_inputs, num_outputs, hidden_size).to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
frame_idx = 0
test_rewards = []
state = envs.reset()
while frame_idx < max_frames:
log_probs = []
values = []
def main():
train_x, train_y, valid_x, valid_y, test_x, test_y = get_cifar10('./cifar-10-batches-py/')
labels = unpickle('./cifar-10-batches-py/batches.meta')['label_names']
train_x = train_x.astype(np.float32) / 255.0
valid_x = valid_x.astype(np.float32) / 255.0
test_x = test_x.astype(np.float32) / 255.0
num_epochs = args.epochs
eta = args.lr
batch_size = args.batch_size
# input
x = T.tensor4("x")
y = T.ivector("y")
# test values
# x.tag.test_value = np.random.randn(6, 3, 32, 32).astype(np.float32)
# y.tag.test_value = np.array([1,2,1,4,5]).astype(np.int32)
# x.tag.test_value = x.tag.test_value / x.tag.test_value.max()
# import ipdb; ipdb.set_trace()
# network definition
conv1 = BinaryConv2D(input=x, num_filters=50, input_channels=3, size=3, strides=(1,1), padding=1, name="conv1")
act1 = Activation(input=conv1.output, activation="relu", name="act1")
pool1 = Pool2D(input=act1.output, stride=(2,2), name="pool1")
conv2 = BinaryConv2D(input=pool1.output, num_filters=100, input_channels=50, size=3, strides=(1,1), padding=1, name="conv2")
act2 = Activation(input=conv2.output, activation="relu", name="act2")
pool2 = Pool2D(input=act2.output, stride=(2,2), name="pool2")
conv3 = BinaryConv2D(input=pool2.output, num_filters=200, input_channels=100, size=3, strides=(1,1), padding=1, name="conv3")
act3 = Activation(input=conv3.output, activation="relu", name="act3")
pool3 = Pool2D(input=act3.output, stride=(2,2), name="pool3")
flat = Flatten(input=pool3.output)
fc1 = BinaryDense(input=flat.output, n_in=200*4*4, n_out=500, name="fc1")
act4 = Activation(input=fc1.output, activation="relu", name="act4")
fc2 = BinaryDense(input=act4.output, n_in=500, n_out=10, name="fc2")
softmax = Activation(input=fc2.output, activation="softmax", name="softmax")
# loss
xent = T.nnet.nnet.categorical_crossentropy(softmax.output, y)
cost = xent.mean()
# errors
y_pred = T.argmax(softmax.output, axis=1)
errors = T.mean(T.neq(y, y_pred))
# updates + clipping (+-1)
params = conv1.params + conv2.params + conv3.params + fc1.params + fc2.params
params_bin = conv1.params_bin + conv2.params_bin + conv3.params_bin + fc1.params_bin + fc2.params_bin
grads = [T.grad(cost, param) for param in params_bin] # calculate grad w.r.t binary parameters
updates = []
for p,g in zip(params, grads):
updates.append(
(p, clip_weights(p - eta*g)) #sgd + clipping update
)
# compiling train, predict and test fxns
train = theano.function(
inputs = [x,y],
outputs = cost,
updates = updates
)
predict = theano.function(
inputs = [x],
outputs = y_pred
)
test = theano.function(
inputs = [x,y],
outputs = errors
)
# train
checkpoint = ModelCheckpoint(folder="snapshots")
logger = Logger("logs/{}".format(time()))
for epoch in range(num_epochs):
print "Epoch: ", epoch
print "LR: ", eta
epoch_hist = {"loss": []}
t = tqdm(range(0, len(train_x), batch_size))
for lower in t:
upper = min(len(train_x), lower + batch_size)
loss = train(train_x[lower:upper], train_y[lower:upper].astype(np.int32))
t.set_postfix(loss="{:.2f}".format(float(loss)))
epoch_hist["loss"].append(loss.astype(np.float32))
# epoch loss
average_loss = sum(epoch_hist["loss"])/len(epoch_hist["loss"])
t.set_postfix(loss="{:.2f}".format(float(average_loss)))
logger.log_scalar(
tag="Training Loss",
value= average_loss,
step=epoch
)
# validation accuracy
val_acc = 1.0 - test(valid_x, valid_y.astype(np.int32))
print "Validation Accuracy: ", val_acc
logger.log_scalar(
tag="Validation Accuracy",
value= val_acc,
step=epoch
)
checkpoint.check(val_acc, params)
# Report Results on test set (w/ best val acc file)
best_val_acc_filename = checkpoint.best_val_acc_filename
print "Using ", best_val_acc_filename, " to calculate best test acc."
load_model(path=best_val_acc_filename, params=params)
test_acc = 1.0 - test(test_x, test_y.astype(np.int32))
print "Test accuracy: ",test_acc
def main():
tLog = Logger("./logs")
trainFeatures=h5py.File("./data/train_feat.hdf5",'r')["train_feat"]
trainLabels=h5py.File("./data/train_label.hdf5", 'r')['train_label']
valFeatures=h5py.File("./data/val_feat_v2.hdf5",'r')['val_feat']
valLabels=h5py.File("./data/val_label.hdf5", 'r')['val_label']
print("Loading is done")
print("trainFeatures.shape", trainFeatures.shape)
print("trainLabels.shape", trainLabels.shape)
print("valFeatures.shape", valFeatures.shape)
print("valLabels.shape", valLabels.shape)
batchSize=64
model=stDecoder(batchSize, 512, 51)
model=model.to(DEVICE)
criterion = stAttentionLoss(0.1, 0.01)
#criterion =nn.CrossEntropyLoss()
criterion=criterion.to(DEVICE)
optimizer=torch.optim.Adam(model.parameters())
indexList=list(range(trainFeatures.shape[0]))
batches=trainFeatures.shape[0]//batchSize
epochs=50
batchID=0
val(model, valFeatures, valLabels, batchSize)
for epoch in range(epochs):
random.shuffle(indexList)
begin=time.time()
for j in range(batches):
model.train()
optimizer.zero_grad()
batchIndexList=indexList[(j*batchSize):(j+1)*batchSize]
batchIndexList.sort()
videos=torch.from_numpy(trainFeatures[ batchIndexList ])
videos=videos.to(DEVICE)
labels=torch.from_numpy(trainLabels[ batchIndexList ]).long()
labels=labels.to(DEVICE)
logits, alphas, betas=model(videos)
#print("alphas", alphas)
#print("betas", betas[0])
#print("logits", logits)
#print("labels", labels)
#loss = criterion(logits, labels)
loss = criterion(logits, labels, alphas, betas)
loss.backward()
optimizer.step()
batchID+=1
if batchID%20 ==0 :
print("batch %d loss is %f" %(batchID, loss.cpu().detach().numpy()))
train_prediction = logits.cpu().detach().argmax(dim=1)
train_accuracy = (train_prediction.numpy()==labels.cpu().numpy()).mean()
print("train_accracy is %f" % train_accuracy)
tr_info = { 'Train Loss': loss.cpu().detach().numpy(), 'Train Accuracy': train_accuracy }
for tag, value in tr_info.items():
tLog.log_scalar(tag, value, batchID+1)
end=time.time()
print("Epoch %d training time: %.2fs" %(epoch,(end-begin)) )
valAcc=val(model, valFeatures, valLabels, batchSize)
val_info= {"Validation Accuracy": valAcc}
for tag, value in val_info.items():
tLog.log_scalar(tag, value, epoch+1)
print("[i] contain checkpoint: ", ckpt)
if continue_training and ckpt:
saver_restore = tf.train.Saver([
var for var in tf.trainable_variables()
if 'discriminator' not in var.name
])
print('loaded ' + ckpt.model_checkpoint_path)
saver_restore.restore(sess, ckpt.model_checkpoint_path)
input_real_names, output_real_names1, _ = prepare_data(
train_real_root) # no reflection ground truth for real images
print("[i] Total %d training images, first path of real image is %s." %
(len(output_real_names1), input_real_names[0]))
num_train = len(output_real_names1)
logger = Logger('logs')
for epoch in range(1, maxepoch):
sum_p = 0
sum_g = 0
sum_d = 0
sum_grad = 0
sum_l1 = 0
sum_loss = 0
sum_ssim = 0
sum_psnr = 0
picked = [None] * num_train
if os.path.isdir("%s/%04d" % (task, epoch)):
def main():
train_x, train_y, valid_x, valid_y, test_x, test_y = get_mnist()
num_epochs = args.epochs
eta = args.lr
batch_size = args.batch_size
# input
x = T.matrix("x")
y = T.ivector("y")
#x.tag.test_value = np.random.randn(3, 784).astype("float32")
#y.tag.test_value = np.array([1,2,3])
#drop_switch.tag.test_value = 0
#import ipdb; ipdb.set_trace()
hidden_1 = BinaryDense(input=x, n_in=784, n_out=2048, name="hidden_1")
act_1 = Activation(input=hidden_1.output, activation="relu", name="act_1")
hidden_2 = BinaryDense(input=act_1.output,
n_in=2048,
n_out=2048,
name="hidden_2")
act_2 = Activation(input=hidden_2.output, activation="relu", name="act_2")
hidden_3 = BinaryDense(input=act_2.output,
n_in=2048,
n_out=2048,
name="hidden_3")
act_3 = Activation(input=hidden_3.output, activation="relu", name="act_3")
output = BinaryDense(input=act_3.output,
n_in=2048,
n_out=10,
name="output")
softmax = Activation(input=output.output,
activation="softmax",
name="softmax")
# loss
xent = T.nnet.nnet.categorical_crossentropy(softmax.output, y)
cost = xent.mean()
# errors
y_pred = T.argmax(softmax.output, axis=1)
errors = T.mean(T.neq(y, y_pred))
# updates + clipping (+-1)
params_bin = hidden_1.params_bin + hidden_2.params_bin + hidden_3.params_bin
params = hidden_1.params + hidden_2.params + hidden_3.params
grads = [T.grad(cost, param)
for param in params_bin] # calculate grad w.r.t binary parameters
updates = []
for p, g in zip(
params, grads
): # gradient update on full precision weights (NOT binarized wts)
updates.append((p, clip_weights(p - eta * g)) #sgd + clipping update
)
# compiling train, predict and test fxns
train = theano.function(inputs=[x, y], outputs=cost, updates=updates)
predict = theano.function(inputs=[x], outputs=y_pred)
test = theano.function(inputs=[x, y], outputs=errors)
# train
checkpoint = ModelCheckpoint(folder="snapshots")
logger = Logger("logs/{}".format(time()))
for epoch in range(num_epochs):
print "Epoch: ", epoch
print "LR: ", eta
epoch_hist = {"loss": []}
t = tqdm(range(0, len(train_x), batch_size))
for lower in t:
upper = min(len(train_x), lower + batch_size)
loss = train(train_x[lower:upper],
train_y[lower:upper].astype(np.int32))
t.set_postfix(loss="{:.2f}".format(float(loss)))
epoch_hist["loss"].append(loss.astype(np.float32))
# epoch loss
average_loss = sum(epoch_hist["loss"]) / len(epoch_hist["loss"])
t.set_postfix(loss="{:.2f}".format(float(average_loss)))
logger.log_scalar(tag="Training Loss", value=average_loss, step=epoch)
# validation accuracy
val_acc = 1.0 - test(valid_x, valid_y.astype(np.int32))
print "Validation Accuracy: ", val_acc
logger.log_scalar(tag="Validation Accuracy", value=val_acc, step=epoch)
checkpoint.check(val_acc, params)
# Report Results on test set
best_val_acc_filename = checkpoint.best_val_acc_filename
print "Using ", best_val_acc_filename, " to calculate best test acc."
load_model(path=best_val_acc_filename, params=params)
test_acc = 1.0 - test(test_x, test_y.astype(np.int32))
print "Test accuracy: ", test_acc
class TensorboardCallback(Callback):
def __init__(self,
path,
args=None,
events_dir=None,
max_step=None,
save_period=10):
self.save_period = save_period
self.path = path
train_dir = os.path.join(path, 'training')
if not os.path.exists(train_dir): os.makedirs(train_dir)
self.train_logger = Logger(train_dir)
valid_dir = os.path.join(path, 'validation')
if not os.path.exists(valid_dir): os.makedirs(valid_dir)
self.valid_logger = Logger(valid_dir)
if args:
text = 'Parameters\n---------\n'
for (key, val) in args.items():
text += '- ' + key + ' = ' + str(val) + '\n'
self.train_logger.log_text('Description', text)
self.valid_logger.log_text('Description', text)
if events_dir and max_step:
events_files = [
F for F in scan_dir(events_dir, '')[1]
if os.path.basename(F).startswith('events')
]
for events_file in events_files:
parent_dir = os.path.dirname(events_file).split(os.sep)[-1]
if 'training' == parent_dir:
train_events_file = events_file
elif 'validation' == parent_dir:
valid_events_file = events_file
self.train_logger.copyFrom(train_events_file, max_step=max_step)
self.valid_logger.copyFrom(valid_events_file, max_step=max_step)
def on_epoch_begin(self, epoch, logs={}):
self.starttime = time()
def on_epoch_end(self, epoch, logs={}):
self.train_logger.log_scalar("Speed", time() - self.starttime, epoch)
self.train_logger.log_scalar("sparse_categorical_accuracy_%",
logs['sparse_categorical_accuracy'] * 100,
epoch)
self.train_logger.log_scalar("loss", logs['loss'], epoch)
self.valid_logger.log_scalar("Speed", time() - self.starttime, epoch)
self.valid_logger.log_scalar(
"sparse_categorical_accuracy_%",
logs['val_sparse_categorical_accuracy'] * 100, epoch)
self.valid_logger.log_scalar("loss", logs['val_loss'], epoch)
# Model save
if ((epoch + 1) % self.save_period) == 0:
self.model.save(
os.path.join(self.path, 'save_' + str(epoch) + '.h5'))
_, oldsaves = scan_dir(self.path, '.h5')
for save in oldsaves:
try:
if int(save.split('.')[-2].split('_')[-1]) < epoch:
os.remove(save)
except:
continue
# are implemented in the "step" function
actions = [(difference_bins, 0.0, 0.0), (-difference_bins, 0.0, 0.0),
(0.0, difference_bins, 0.0), (0.0, -difference_bins, 0.0),
(0.0, 0.0, difference_bins), (0.0, 0.0, -difference_bins),
(0.0, 0.0, 0.0)]
############
# The Q-learn algorithm
#qlearn = QLearn(actions=actions,
# alpha=0.2, gamma=0.90, epsilon=0.5, epsilon_decay_rate=0.99)
qlearn = QLearn(actions=actions,
alpha=0.5, gamma=0.30, epsilon=0.8, epsilon_decay_rate=0.999)
# logs_path = "/tmp/modular_scara_3dof_qlearn/"
logger = Logger("/tmp/rosrl/GazeboModularScara3DOF-v2/q-learn/")
with tf.Session() as sess:
# op to write logs to Tensorboard
# summary_writer = tf.summary.FileWriter(logs_path, graph=tf.get_default_graph())
for i_episode in range(1000): # episodes
print("I_EPISODE", i_episode)#####
observation = env.reset()
joint1_position, joint2_position, joint3_position = observation[:3]
state = build_state([to_bin(joint1_position, joint1_bins),
to_bin(joint2_position, joint2_bins),
to_bin(joint3_position, joint3_bins)])
episode_reward = 0
