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