def inference(self, image): print "Loading Network.." pred_result = [] image_placeholder = tf.placeholder(tf.float32, shape=[28, 28, 3], name='input_image') model = CapsNet() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) weights_dir = self.OBJ_RECOG_ROOT + '/weights' supervisor = tf.train.Supervisor(graph=model.graph, logdir=weights_dir, save_model_secs=0) with supervisor.managed_session(config=tf.ConfigProto( allow_soft_placement=True)) as sess: supervisor.saver.restore( sess, tf.train.latest_checkpoint(weights_dir)) pred = model.inference() logits_value = sess.run( [pred], feed_dict={model.image_placeholder: image}) pred_result = logits_value[0][0] result = np.argmax(pred_result, axis=0, out=None) obj_num = result[0][0] print 'object is ', self.obj_list[obj_num] return obj_num
def main(): trX, trY, num_tr_batch, valX, valY, num_val_batch = load_data('mnist', batch_size, is_training=True) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5) model = CapsNet() sv = tf.train.Supervisor(graph=model.graph, logdir=logdir, save_model_secs=0) with sv.managed_session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: for epoch in range(num_epochs): print('Ep %d/%d' % (epoch, num_epochs)) if sv.should_stop(): print('Should stop.') break for step in range(num_tr_batch): global_step = epoch * num_tr_batch + step # model.X, model.Y, _, _ = data.train.next_batch(batch_size) if global_step % 10 == 0: _, loss, acc, summary, margin_loss = sess.run( [model.train_op, model.total_loss, model.accuracy, model.train_summary, model.margin_loss]) print('Step %d: loss %f \t acc %f \t margin loss %f' % (global_step, loss, acc, margin_loss)) # l, ml, mr, v_length, digit_cap, primary_caps, pre_vec, conv1= sess.run([model.Y, model.max_l, # model.max_r, model.v_length, # model.digit_caps, model.primary_caps, # model.pre_vector, model.conv1]) # print(l[0]) # # print(v_length[0]) # # print(ml[0]) # # print(mr[0]) # # print(digit_cap[0]) # # print(primary_caps[0]) # print('conv1') # print(conv1[0][0]) sv.summary_writer.add_summary(summary, global_step) else: sess.run(model.train_op)
def main(_): if cfg.is_training: prepare_output_dir() graph = tf.Graph() with graph.as_default(): tf.set_random_seed(1) model = CapsNet() saver = tf.train.Saver() if cfg.is_training: session = tf.train.MonitoredTrainingSession(hooks=[ tf.train.NanTensorHook(model.total_loss), tf.train.CheckpointSaverHook( checkpoint_dir=cfg.checkpoint_dir, save_steps=cfg.save_checkpoint_steps, saver=saver), tf.train.SummarySaverHook(save_steps=cfg.train_sum_freq, output_dir=LOG_DIR, summary_op=model.train_summary) ], ) train(model, session) else: session = tf.train.MonitoredSession() evaluation(model, session, saver)
def main(_): capsNet = CapsNet(is_training=cfg.is_training) tf.logging.info('Graph loaded') sv = tf.train.Supervisor(graph=capsNet.graph, logdir=cfg.logdir, save_model_secs=0) path = cfg.results + '/accuracy.csv' if not os.path.exists(cfg.results): os.mkdir(cfg.results) elif os.path.exists(path): os.remove(path) fd_results = open(path, 'w') fd_results.write('step,test_acc\n') with sv.managed_session() as sess: num_batch = int(60000 / cfg.batch_size) num_test_batch = 10000 // cfg.batch_size teX, teY = load_mnist(cfg.dataset, False) for epoch in range(cfg.epoch): if sv.should_stop(): break for step in tqdm(range(num_batch), total=num_batch, ncols=70, leave=False, unit='b'): global_step = sess.run(capsNet.global_step) sess.run(capsNet.train_op) if step % cfg.train_sum_freq == 0: _, summary_str = sess.run( [capsNet.train_op, capsNet.train_summary]) sv.summary_writer.add_summary(summary_str, global_step) if (global_step + 1) % cfg.test_sum_freq == 0: test_acc = 0 for i in range(num_test_batch): start = i * cfg.batch_size end = start + cfg.batch_size test_acc += sess.run( capsNet.batch_accuracy, { capsNet.X: teX[start:end], capsNet.labels: teY[start:end] }) test_acc = test_acc / (cfg.batch_size * num_test_batch) fd_results.write( str(global_step + 1) + ',' + str(test_acc) + '\n') fd_results.flush() summary_str = sess.run(capsNet.test_summary, {capsNet.test_acc: test_acc}) sv.summary_writer.add_summary(summary_str, global_step) if epoch % cfg.save_freq == 0: sv.saver.save( sess, cfg.logdir + '/model_epoch_%04d_step_%02d' % (epoch, global_step)) fd_results.close() tf.logging.info('Training done')
def __init__(self, batch_size, use_recons_loss, recon_with_y, model_path="log"): self.batch_size = batch_size self.type_name = "with_y" if recon_with_y else "no_y" self.model_path = os.path.join(model_path, self.type_name) # data self.num_train = 60000 // self.batch_size self.num_test = 10000 // self.batch_size self.test_x, self.test_y = load_mnist(is_training=False) # net self.capsNet = CapsNet(batch_size=self.batch_size, use_recons_loss=use_recons_loss, recon_with_y=recon_with_y) # A training helper that checkpoints models and computes summaries. self.sv = tf.train.Supervisor(graph=self.capsNet.graph, logdir=self.model_path, save_model_secs=0) # config self.config = tf.ConfigProto() self.config.gpu_options.allow_growth = True pass
def predict_picture(pic_path,model_path,dataset,device): if dataset == 'char74k': size = 20 num_classes = 26 else: size = 28 num_classes = 10 transform = transforms.Compose([ transforms.Scale(size), transforms.CenterCrop((size,size)), transforms.ToTensor(), transforms.Normalize((0.1307,),(0.3081,)) ]) img = Image.open(pic_path) img_tensor = transform(img) img_tensor = img_tensor.unsqueeze(0) img_tensor = img_tensor.to(device) model = CapsNet(num_classes=num_classes,conv_in=3) model = model.to(device) model.eval() state_dict = torch.load(model_path) model.load_state_dict(state_dict) score = model(img_tensor) probs = nn.functional.softmax(score,dim=-1) max_value,index = torch.max(probs,dim=-1) print('The picture {} is:{}'.format(pic_path.split('/')[-1],char74k_id2labels[int(index)]))
def main(_): data = d.load_data(cfg) model = CapsNet(data.image_axis_size) n_epochs = cfg.epochs n_iterations_per_epoch = data.train.num_examples // cfg.batch_size n_iterations_validation = data.validation.num_examples // cfg.batch_size if (cfg.is_training): train(True, n_epochs, n_iterations_per_epoch, n_iterations_validation, data, model) else: validate(data, model)
def main(_): num_label = 10 model = CapsNet() sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if cfg.is_training: train(model, sv, num_label) else: evaluation(model, sv, num_label)
def main(_): tf.logging.info(' Loading Graph...') num_label = 10 model = CapsNet() tf.logging.info(' Graph loaded') sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if cfg.is_training: tf.logging.info(' Start trainging...') train(model, sv, num_label) tf.logging.info('Training done') else: evaluation(model, sv, num_label)
def main(_): tf.logging.info(' Loading Graph...') num_label = 10 model = CapsNet() tf.logging.info(' Graph loaded') sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) # The above is a deprecated version. Replacing it with MonitoredTraining Session - Sudeep #with model.graph.as_default(): # with tf.train.MonitoredTrainingSession(summary_dir=cfg.logdir, save_summaries_secs=0) as sv: if cfg.is_training: tf.logging.info(' Start training...') train(model, sv, num_label) tf.logging.info('Training done') else: evaluation(model, sv, num_label)
def main(_): tf.logging.info(' 获取CapsNet计算图...') num_label = 10 model = CapsNet() tf.logging.info(' 计算图已经加载 ') sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if cfg.is_training: tf.logging.info(' Start training...') train(model, sv, num_label) tf.logging.info('Training done') else: evaluation(model, sv, num_label) return 0
def main(_): tf.logging.info(' Loading Graph...') num_label = 10 model = CapsNet(height=cfg.sample_height, width=cfg.sample_width, channels=cfg.sample_channel, num_label=cfg.amount_label) tf.logging.info(' Graph loaded') sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if cfg.is_training: tf.logging.info(' Start training...') train(model, sv, num_label) tf.logging.info('Training done') else: evaluation(model, sv, num_label)
def main(_): tf.logging.info('Loading Graph...') # model = CapsNet() tf.logging.info('Graph loaded') # if cfg.is_training: # tf.logging.info('Start training...') # train(model, sv, model.tr_batch_num) # tf.logging.info('Training done') # else: # if not cfg.predict: # evaluation(model, sv) # else: # return prediction(model, sv) for i in range(8): model = CapsNet(i + 1) sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) train(model, sv, model.tr_batch_num) evaluation(model, sv, i + 1)
def eval(model_path, result_path, dataProcessor, num_classes, epoch, device, eval_type, logger): capsNet = CapsNet(num_classes=num_classes, conv_in=3) state_dict = torch.load(model_path + '/model_state_dict.pkl') capsNet.load_state_dict(state_dict) capsNet.to(device) valid_scores, valid_predicts, valid_labels = predict( capsNet, dataProcessor, num_classes, epoch, device, 'valid', logger) test_scores, test_predicts, test_labels = predict(capsNet, dataProcessor, num_classes, epoch, device, 'test', logger) store_results(test_predicts, test_labels, result_path) with open(result_path + '/result.csv', 'w') as file: file.write('valid scores,test scores\n') file.write(str(valid_scores) + ',' + str(test_scores)) return valid_scores, test_scores
def main(_): #remove cpu occupation os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" # os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # os.environ['CUDA_VISIBLE_DEVICES'] = "0" # os.environ['CUDA_VISIBLE_DEVICES'] = "" tf.reset_default_graph() tf.logging.info(' Loading Graph...') num_label = 52 # reset graph # tf.reset_default_graph() model = CapsNet() tf.logging.info(' Graph loaded') # sv= tf.train.MonitoredTrainingSession(model.graph, checkpoint_dir=cfg.logdir,save_checkpoint_secs=3) sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if cfg.is_training: tf.logging.info(' Start training...') train(model, sv, num_label) tf.logging.info('Training done') else: evaluation(model, sv, num_label)
def main(_): # ### Create the multimnist set. # create_multimnist(is_training=cfg.is_training) # trX, trY, num_tr_batch, valX, valY, num_val_batch = load_multimnist(is_training=cfg.is_training) # while True: # index = np.random.randint(550000) # print(trY[index]) # plt.imshow(np.squeeze(trX[index])) # plt.show() # sys.exit() # The number of labels for the data. num_label = 10 # Generate the model. tf.logging.info('Loading Graph...') if cfg.use_cnn == True: model = cnn() else: model = CapsNet() tf.logging.info('Graph loaded') # Generate the supervisor. sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) # Run training or evaluation. if cfg.is_training: tf.logging.info('Start training') train(model, sv, num_label) tf.logging.info('Training done') else: tf.logging.info('Start evaluation') evaluation(model, sv, num_label) tf.logging.info('Evaluation done')
Set up variables ''' config = tf.ConfigProto() config.gpu_options.allow_growth = True train_sum_freq = 10 val_sum_freq = 50 ''' Set up model ''' #To make it Distributed device, target = device_and_target() # getting node environment with tf.device(device): global_step1 = tf.train.get_or_create_global_step() model = CapsNet(batch=FLAGS.batch_size, mnist=FLAGS.use_mnist, data_path=FLAGS.path_to_data,global_step=global_step1) step1 = tf.assign_add(global_step1,1) ''' Load the data ''' trX, trY, num_tr_batch, valX, valY, num_val_batch = load_mnist(FLAGS.batch_size, is_training=True, path=FLAGS.path_to_data, mnist=FLAGS.use_mnist) #Format Y Y = valY[:num_val_batch * FLAGS.batch_size].reshape((-1, 1)) ''' Run the Model Pass in target to determine the worker '''
import tensorflow as tf from config import cfg from capsNet import CapsNet if __name__ == "__main__": capsNet = CapsNet(is_training=cfg.is_training) tf.logging.info('Graph loaded') sv = tf.train.Supervisor(graph=capsNet.graph, logdir=cfg.logdir, save_model_secs=0) with sv.managed_session() as sess: num_batch = int(60000 / cfg.batch_size) for epoch in range(cfg.epoch): if sv.should_stop(): break for step in range(num_batch): sess.run(capsNet.train_op) global_step = sess.run(capsNet.global_step) sv.saver.save( sess, cfg.logdir + '/model_epoch_%04d_step_%02d' % (epoch, global_step)) tf.logging.info('Training done')
import tensorflow as tf import numpy as np import utils from capsNet import CapsNet if __name__ == "__main__": vec, label, map_label = utils.get_vector('train', 12, None) vec = np.array(vec).astype(np.float) vec_test, label_test, _ = utils.get_vector('test', 12, map_label) vec_test = np.array(vec_test).astype(np.float) vec = np.array(vec.reshape(-1, 12, 25, 1)).astype(np.float32) vec_test = vec_test.reshape(-1, 12, 25, 1) caps_model = CapsNet() earlyStopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=8) reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=1e-5) #tensorBoard = tf.keras.callbacks.TensorBoard(log_dir='logs') caps_model.compile(optimizer=tf.keras.optimizers.Adam(1e-3), loss=caps_model.margin_loss, metrics=['accuracy']) caps_model.fit(vec, label, batch_size=32, epochs=50, validation_data=(vec_test, label_test), callbacks=[earlyStopping, reduce_lr])
epochs = cfg.epochs dataset = cfg.dataset if dataset == 'MNIST': num_classes = 10 else: num_classes = 26 dataProcessor = DataProcessor(batch_size=batch_size, dataset=dataset, data_path='data/char74k_preprocessed') if torch.cuda.is_available(): device = torch.device('cuda') else: device = torch.device('cpu') capsNet = CapsNet(conv_in=3, num_classes=num_classes).to(device) cseloss = torch.nn.CrossEntropyLoss() adamOptimizer = torch.optim.Adam(params=capsNet.parameters()) best_val_acc = -1 best_val_epoch = 0 for epoch in tqdm(range(epochs)): epoch_loss = 0 for batch_id, (data, target) in enumerate(dataProcessor.train_loader): capsNet.train() target = torch.eye(num_classes).index_select(dim=0, index=target) data = data.to(device) target = target.to(device) adamOptimizer.zero_grad() # output,reconstructions,masked = capsNet(data)
def main(_): # print("PrePreA") capsNet = CapsNet(is_training=cfg.is_training) # print("PreA") tf.logging.info('Graph loaded') sv = tf.train.Supervisor(graph=capsNet.graph, logdir=cfg.logdir, save_model_secs=0, summary_op=None) path = cfg.results + '/accuracy.csv' if not os.path.exists(cfg.results): os.mkdir(cfg.results) elif os.path.exists(path): os.remove(path) fd_results = open(path, 'w') fd_results.write('step,test_acc\n') config = tf.ConfigProto() config.gpu_options.allow_growth = True ex_imgs, ex_imgs_label, imgs_scale, imgs_rotated, imgs_label = load_mnist_affNIST( True) teX, teY, teCtrl = load_mnist_affNIST(False) num_batches = ex_imgs.shape[0] + imgs_rotated.shape[0] + imgs_scale.shape[0] # print("A") with sv.managed_session(config=config) as sess: num_test_batch = teX.shape[0] // cfg.batch_size for epoch in range(cfg.epoch): # Recreate/reshuffle batches for each epoch var_seq = np.random.choice( range(6), size=num_batches, replace=True) # select 6 to attain 1:1:4 ratio imgs_rotated_select = np.random.choice(range( imgs_rotated.shape[0]), size=sum(var_seq == 0), replace=True) imgs_scale_select = np.random.choice(range(imgs_scale.shape[0]), size=sum(var_seq == 1), replace=True) # imgs_hscale_select = np.random.choice(range(imgs_hscale.shape[0]),size = sum(var_seq == 2), replace = True) ex_imgs_select = np.random.choice( range(ex_imgs.shape[0]), size=sum(var_seq >= cfg.num_ex_var), replace=True) var_seq = np.array(sorted(var_seq)) epoch_batches_imgs = np.concatenate([ imgs_rotated[imgs_rotated_select], imgs_scale[imgs_scale_select], ex_imgs[ex_imgs_select] ], axis=0) epoch_batches_imgs = epoch_batches_imgs.reshape( [num_batches, cfg.batch_size, cfg.img_dim, cfg.img_dim, 1]) epoch_batches_labels = np.concatenate([ imgs_label[imgs_rotated_select], imgs_label[imgs_scale_select], ex_imgs_label[ex_imgs_select] ], axis=0) shuffle_ind = np.random.choice(range(num_batches), size=num_batches, replace=False) var_seq = var_seq[shuffle_ind] epoch_batches_imgs = epoch_batches_imgs[shuffle_ind] epoch_batches_labels = epoch_batches_labels[shuffle_ind] if sv.should_stop(): break for step in tqdm(range(num_batches), total=num_batches, ncols=70, leave=False, unit='b'): _, global_step = sess.run( [capsNet.train_op, capsNet.global_step], feed_dict={ capsNet.X: epoch_batches_imgs[step], capsNet.labels: epoch_batches_labels[step], capsNet.train_var: var_seq[step] }) if step % cfg.train_sum_freq == 0: _, summary_str = sess.run( [capsNet.train_op, capsNet.train_summary], feed_dict={ capsNet.X: epoch_batches_imgs[step], capsNet.labels: epoch_batches_labels[step], capsNet.train_var: var_seq[step] }) sv.summary_writer.add_summary(summary_str, global_step) if (global_step + 1) % cfg.test_sum_freq == 0: test_acc = 0 for i in range(num_test_batch): start = i * cfg.batch_size end = start + cfg.batch_size test_acc += sess.run( capsNet.batch_accuracy, { capsNet.X: teX[start:end], capsNet.labels: teY[start:end] }) test_acc = test_acc / (cfg.batch_size * num_test_batch) fd_results.write( str(global_step + 1) + ',' + str(test_acc) + '\n') fd_results.flush() if global_step % cfg.save_freq == 0: sv.saver.save( sess, cfg.logdir + '/model_epoch_%04d_step_%02d' % (epoch, global_step)) sv.saver.save( sess, cfg.logdir + '/Final_model_epoch_%02d_step_%04d' % (epoch, global_step)) fd_results.close() tf.logging.info('Training done')
def train(do_k_fold, out_dir, log_f): if do_k_fold: utils.print_out("# do k_fold k=%d" % k_fold, log_f) k_fold_val = 0 k_fold_tra = 0 [k_TP, k_TN, k_FP, k_FN, k_SE, k_SP, k_MCC, k_ACC] = [0, 0, 0, 0, 0, 0, 0, 0] for i in range(k_fold): trX_=[] trY_=[] for j in range(k_fold): if j == i: continue trX_.append(k_fold_X[j]) trY_.append(k_fold_Y[j]) trX_ = np.concatenate(trX_) trY_ = np.concatenate(trY_) utils.print_out("#k_fold %d" % i, log_f) utils.print_out("#do DBN ...", log_f) dbn = DBN() dbn.train(trX_) utils.print_out("#end DBN", log_f) utils.print_out("#do caps ...", log_f) capsNet = CapsNet(is_training=True, dbn=dbn) i_k_fold_val, i_k_fold_tra = capsNet.train(trX_, trY_, k_fold_X[i], k_fold_Y[i], None, log_f) TP, TN, FP, FN, SE, SP, MCC, ACC = eva(capsNet, k_fold_X[i], k_fold_Y[i]) print(i,", TP:", TP) print(i,", TN:", TN) print(i,", FP:", FP) print(i,", FN:", FN) print(i,", SE:", SE) print(i,", SP:", SP) print(i,", MCC:", MCC) print(i,", ACC: ", ACC) k_TP += TP k_TN += TN k_FP += FP k_FN += FN k_SE += SE k_SP += SP k_MCC += MCC k_ACC += ACC print("TP :", k_TP / 5) print("TN :", k_TN / 5) print("FP :", k_FP / 5) print("FN :", k_FN / 5) print("SE :", k_SE / 5) print("SP :", k_SP / 5) print("MCC: ", k_MCC / 5) print("ACC: ", k_ACC / 5) else: utils.print_out("#do DBN ...", log_f) dbn = DBN() dbn.train(trX) utils.print_out("#end DBN", log_f) utils.print_out("#do caps ...", log_f) utils.print_out("#test instead val set for test ...", log_f) capsNet = CapsNet(is_training=isTraining, dbn=dbn) if isTraining: i_k_fold_val, i_k_fold_tra = capsNet.train(trX, trY, teX, teY, "./board", log_f) utils.print_out("#end caps", log_f) tr_TP, tr_TN, tr_FP, tr_FN, tr_SE, tr_SP, tr_MCC, tr_ACC = eva(capsNet, trX, trY) val_TP, val_TN, val_FP, val_FN, val_SE, val_SP, val_MCC, val_ACC = eva(capsNet, vaX, vaY) te_P, te_TN, te_FP, te_FN, te_SE, te_SP, te_MCC,te_ACC = eva(capsNet, teX, teY) utils.print_out('train : TP:%.3f; TN:%.3f; FP:%.3f; FN:%.3f; SE:%.3f SP:%.3f MCC:%.3f P:%.3f' \ %(tr_TP, tr_TN, tr_FP, tr_FN, tr_SE, tr_SP, tr_MCC, tr_ACC), log_f) utils.print_out('val : TP:%.3f; TN:%.3f; FP:%.3f; FN:%.3f; SE:%.3f SP:%.3f MCC:%.3f P:%.3f' \ % (val_TP, val_TN, val_FP, val_FN, val_SE, val_SP, val_MCC, val_ACC), log_f) utils.print_out('test : TP:%.3f; TN:%.3f; FP:%.3f; FN:%.3f; SE:%.3f SP:%.3f MCC:%.3f P:%.3f' \ % (te_P, te_TN, te_FP, te_FN, te_SE, te_SP, te_MCC, te_ACC), log_f) else: import csv csvFile = open("./"+train_datadir+"/"+setFileNames[1], "r") reader = csv.reader(csvFile) # 返回的是迭代类型 data = [] for item in reader: data.append(item[0]) csvFile.close() data = data[1:] utils.print_out("#end caps", log_f) pre_Y= pre(capsNet, vaX).tolist()[0] import pandas as pd dataFrame = pd.DataFrame({ "0_name": data,"1_class": pre_Y}) dataFrame.to_csv('./data_set/test_dir/180831-result.csv', index=False, sep=",")