def source_only(encoder, classifier, discriminator, source_train_loader, target_train_loader, save_name): print("Source-only training") for epoch in range(params.epochs): print('Epoch : {}'.format(epoch)) encoder = encoder.train() classifier = classifier.train() discriminator = discriminator.train() classifier_criterion = nn.CrossEntropyLoss().cuda() start_steps = epoch * len(source_train_loader) total_steps = params.epochs * len(target_train_loader) for batch_idx, (source_data, target_data) in enumerate( zip(source_train_loader, target_train_loader)): source_image, source_label = source_data p = float(batch_idx + start_steps) / total_steps source_image = torch.cat( (source_image, source_image, source_image), 1) # MNIST convert to 3 channel source_image, source_label = source_image.cuda( ), source_label.cuda() # 32 optimizer = optim.SGD(list(encoder.parameters()) + list(classifier.parameters()), lr=0.01, momentum=0.9) optimizer = utils.optimizer_scheduler(optimizer=optimizer, p=p) optimizer.zero_grad() source_feature = encoder(source_image) # Classification loss class_pred = classifier(source_feature) class_loss = classifier_criterion(class_pred, source_label) class_loss.backward() optimizer.step() if (batch_idx + 1) % 50 == 0: print('[{}/{} ({:.0f}%)]\tClass Loss: {:.6f}'.format( batch_idx * len(source_image), len(source_train_loader.dataset), 100. * batch_idx / len(source_train_loader), class_loss.item())) if (epoch + 1) % 10 == 0: test.tester(encoder, classifier, discriminator, source_test_loader, target_test_loader, training_mode='source_only') save_model(encoder, classifier, discriminator, 'source', save_name) visualize(encoder, 'source', save_name)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--logs', type=str, default=None, help='logs by tensorboardX') parser.add_argument('--local_test', type=str2bool, default=False, help='local test verbose') parser.add_argument('--model_name', type=str, default="dcgan", help='model name for saving') parser.add_argument('--test', type=str2bool, default=False, help='call tester.py') parser.add_argument('--use_visdom', type=str2bool, default=False, help='visualization by visdom') args = parser.parse_args() parameters.print_params() if args.test == False: trainer(args) else: tester(args)
def main(): source_train_loader = mnist.mnist_train_loader target_train_loader = mnistm.mnistm_train_loader if torch.cuda.is_available(): get_free_gpu() print('Running GPU : {}'.format(torch.cuda.current_device())) encoder = model.Extractor().cuda() classifier = model.Classifier().cuda() discriminator = model.Discriminator().cuda() train.source_only(encoder, classifier, discriminator, source_train_loader, target_train_loader, save_name) test.tester(encoder, classifier, discriminator, source_train_loader, target_train_loader, 'source') else: print("There is no GPU -_-!")
#from hangingGui import runit import test #from test import yepp from test import tester global yepp yepp = 'ro' print(yepp) test.tester() print(yepp)
up_alp_interval = 10 save_ep_interval = 4 disp_interval = 2 nan_error = False try: # phase train, 8 phases for phs in range(start_phs, phs_num): cur_res, batch_size, l_rate, k_imgs, update_alp = train_phases[phs] lr.assign(l_rate) # g_batch_size = batch_size * strategy.num_replicas_in_sync # losses = loss.losses2(g_batch_size, tf.distribute.has_strategy()) g_batch_size = batch_size losses = loss.losses2() tester = test.tester(SAMP_DIR, batch_size) # data print("======= Make data: %dx%d =======" % (cur_res, cur_res)) tr_data = data.img_ds(data_dir=DATA_DIR, img_resize=cur_res, batch_size=g_batch_size) # tr_ite = iter(strategy.experimental_distribute_dataset(tr_data.ds)) tr_ite = iter(tr_data.ds) # create tf graph d_graph = tf.function(d_step) g_graph = tf.function(g_step) # training loop print("======= Create training loop =======")
def dann(encoder, classifier, discriminator, source_train_loader, target_train_loader, save_name): print("DANN training") for epoch in range(params.epochs): print('Epoch : {}'.format(epoch)) encoder = encoder.train() classifier = classifier.train() discriminator = discriminator.train() classifier_criterion = nn.CrossEntropyLoss().cuda() discriminator_criterion = nn.CrossEntropyLoss().cuda() start_steps = epoch * len(source_train_loader) total_steps = params.epochs * len(target_train_loader) optimizer = optim.SGD(list(encoder.parameters()) + list(classifier.parameters()) + list(discriminator.parameters()), lr=0.01, momentum=0.9) for batch_idx, (source_data, target_data) in enumerate( zip(source_train_loader, target_train_loader)): source_image, source_label = source_data target_image, target_label = target_data p = float(batch_idx + start_steps) / total_steps alpha = 2. / (1. + np.exp(-10 * p)) - 1 # source_image = torch.cat((source_image, source_image, source_image), 1) source_image, source_label = source_image.cuda( ), source_label.cuda() target_image, target_label = target_image.cuda( ), target_label.cuda() combined_image = torch.cat((source_image, target_image), 0) # Auge label combined_label = torch.cat((source_label, target_label), 0) optimizer = utils.optimizer_scheduler(optimizer=optimizer, p=p) optimizer.zero_grad() combined_feature = encoder(combined_image) source_feature = encoder(source_image) # 1.Classification loss # class_pred = classifier(source_feature) # class_loss = classifier_criterion(class_pred, source_label) # Auge class_pred = classifier(combined_feature) # print('PRED: ', class_pred.size()) # print('LABEL: ', combined_label.size()) class_loss = classifier_criterion(class_pred, combined_label) # 2. Domain loss domain_pred = discriminator(combined_feature, alpha) domain_source_labels = torch.zeros(source_label.shape[0]).type( torch.LongTensor) domain_target_labels = torch.ones(target_label.shape[0]).type( torch.LongTensor) domain_combined_label = torch.cat( (domain_source_labels, domain_target_labels), 0).cuda() domain_loss = discriminator_criterion(domain_pred, domain_combined_label) total_loss = class_loss + domain_loss total_loss.backward() optimizer.step() if (batch_idx + 1) % 50 == 0: print( '[{}/{} ({:.0f}%)]\tLoss: {:.6f}\tClass Loss: {:.6f}\tDomain Loss: {:.6f}' .format(batch_idx * len(target_image), len(target_train_loader.dataset), 100. * batch_idx / len(target_train_loader), total_loss.item(), class_loss.item(), domain_loss.item())) if (epoch + 1) % 10 == 0: test.tester(encoder, classifier, discriminator, source_test_loader, target_test_loader, training_mode='dann') tensorboard(encoder, classifier, target_test_loader, target_train_loader, epoch) save_model(encoder, classifier, discriminator, 'source', save_name) visualize(encoder, 'source', save_name)
z = Enc(x) z_stu = Stu(z, a) x_fake = Gen(z_stu, a - a) d, att = Dis(x) lr = tf.Variable(initial_value=0., trainable=False) g_opt = tf.optimizers.Adam(lr, beta_1=0., beta_2=0.99) d_opt = tf.optimizers.Adam(lr, beta_1=0., beta_2=0.99) params = tf.Variable(initial_value=[5, 0], trainable=False, dtype=tf.int64) sample_dir = './output/%s/%s' % (experiment_name, experiment_name + "_test") if os.path.exists(sample_dir): shutil.rmtree(sample_dir) os.makedirs(sample_dir, exist_ok=True) tester = test.tester(sample_dir, batch_size) checkpoint_dir = './output/%s/trained_model' % experiment_name checkpoint = tf.train.Checkpoint(params=params, d_opt=d_opt, g_opt=g_opt, Gen=Gen, Dis=Dis, Enc=Enc, Stu=Stu) manager = tf.train.CheckpointManager(checkpoint, checkpoint_dir, max_to_keep=3) checkpoint.restore(manager.latest_checkpoint) if manager.latest_checkpoint:
def trainer(exp_name, train_data_loader, train_tile_borders, cfg, val_data_loader=None, val_tile_borders=None, DEBUG=False, use_tensorboard=True): net, optimizer, criterion, start_epoch = exp.load_exp(exp_name) if torch.cuda.is_available(): net.cuda() criterion = criterion.cuda() net.train() # Change model to 'train' mode # set up TensorBoard experiment, use_tensorboard = exp.setup_crayon(use_tensorboard, CrayonClient, exp_name) # Training setting log_iter_interval = cfg['log_iter_interval'] snapshot_epoch_interval = cfg['snapshot_epoch_interval'] num_epochs = cfg['num_epochs'] accumulated_batch_size = cfg['train']['accumulated_batch_size'] # Train the Model for epoch in range(start_epoch, num_epochs + 1): epoch_start = time.time() # initialize epoch stats epoch_train_loss = 0 epoch_train_accuracy = 0 accumulated_batch_loss = 0 print('Epoch [%d/%d] starts' % (epoch, num_epochs)) for i, (img_name, images, targets) in enumerate(train_data_loader): iter_start = time.time() # convert to FloatTensor images = images.float() targets = targets.float() images = Variable(images) targets = Variable(targets) if torch.cuda.is_available(): images = images.cuda() targets = targets.cuda() outputs = net(images) # remove tile borders images = tile.remove_tile_borders(images, train_tile_borders) outputs = tile.remove_tile_borders(outputs, train_tile_borders) targets = tile.remove_tile_borders(targets, train_tile_borders) loss = criterion(outputs, targets) # generate prediction masks = (outputs > 0.5).float() accuracy = evaluation.dice_loss(masks, targets) epoch_train_accuracy += accuracy # Backward pass loss.backward() accumulated_batch_loss += (loss.data[0] / accumulated_batch_size) # Update epoch stats epoch_train_loss += loss.data[0] # Log Training Progress if (i + 1) % log_iter_interval == 0: print( 'Epoch [%d/%d] Iter [%d/%d] Loss: %.3f Accumd Loss:%.4f Accuracy: %.5f' % (epoch, num_epochs, i + 1, len(train_data_loader), loss.data[0], accumulated_batch_loss, accuracy)) if DEBUG and accuracy < 0.98: print('Epoch {}, Iter {}, {}: Loss {:.5f}, Accuracy: {:.6f}'. format(epoch, i, img_name, loss.data[0], accuracy)) # convert to numpy array image = images.data[0].cpu().numpy() mask = masks.data[0].cpu().numpy() target = targets.data[0].cpu().numpy() viz.visualize(image, mask, target) if (i + 1) % accumulated_batch_size == 0: optimizer.step() # reset optimizer.zero_grad() accumulated_batch_loss = 0 iter_end = time.time() # Log Training Progress if (i + 1) % log_iter_interval == 0: print('Time Spent: {:.2f} sec'.format(iter_end - iter_start)) # inner for loop ends epoch_train_loss /= len(train_data_loader) epoch_train_accuracy /= len(train_data_loader) # Validate if val_data_loader is not None: epoch_val_loss, epoch_val_accuracy = test.tester(exp_name, val_data_loader, val_tile_borders, net, criterion, is_val=True) if use_tensorboard: experiment.add_scalar_value('train loss', epoch_train_loss, step=epoch) experiment.add_scalar_value('train accuracy', epoch_train_accuracy, step=epoch) if val_data_loader is not None: experiment.add_scalar_value('val loss', epoch_val_loss, step=epoch) experiment.add_scalar_value('val accuracy', epoch_val_accuracy, step=epoch) # experiment.add_scalar_value('learning_rate', lr, step=epoch) # Save the trained model if epoch % snapshot_epoch_interval == 0: exp.save_checkpoint(exp_name, epoch, net.state_dict(), optimizer.state_dict()) epoch_end = time.time() print('Epoch [%d/%d] Loss: %.4f Accuracy: %.5f Time Spent: %.2f sec' % (epoch, num_epochs, epoch_train_loss, epoch_train_accuracy, epoch_end - epoch_start)) # outer for loop ends return
while True: # Read and display initial frame from webcam ret, frame = cam.read() cv2.imshow("Current_Stream", frame) # Wait for keystroke k = cv2.waitKey(1) if not ret: break # Actions for when SPACE is pressed if k%256 == 32: # Concatenate image path/filename img_name = "webcam_image/opencv_frame.jpg" # Save captured frame cv2.imwrite(img_name, frame) print("The file {} was created!".format(img_name)) # Increment counter to keep track of captured frames img_counter += 1 #calling the tester function from the test.py script tester() # Actions for when ESC is pressed elif k%256 == 27: print("ESC key entered, now closing application!") break cam.release() cv2.destroyAllWindows()
opts = options.parse() #data loader data_loader = data.dataloader(opts) train_loader = util.create_dataset(data_loader.train_data, data_loader.letteridx, data_loader.labelidx, opts) test_loader = util.create_dataset(data_loader.test_data, data_loader.letteridx, data_loader.labelidx, opts) from network import RNN from train import trainer from test import tester '''RNN model''' RNN = RNN(opts, data_loader.letteridx).to(device) if opts.print_model: print(RNN) '''Optimizers''' import torch.optim as optim RNN_optim = optim.Adam(RNN.parameters(), lr=opts.lr, betas=(opts.beta1, opts.beta2)) '''Criterion''' criterion = nn.NLLLoss() '''run training''' trainer(opts, RNN, RNN_optim, criterion, train_loader) '''test''' tester(opts, RNN, test_loader)
def main(args): train_dir = args.train_dir train_csv = args.train_csv test_dir = args.test_dir test_csv = args.test_csv ratio = args.train_valid_ratio batch_size = args.batch_size epochs = args.epochs train_flag = args.train pretrain_weight = args.pretrain_weight verbose = args.verbose if (train_flag == 0): if (verbose == 2): print("Reading Training Data...") train_csv = pd.read_csv(train_csv) train_csv, valid_csv = train_valid_split(train_csv, ratio) train = RetinopathyDataset(train_csv, train_dir) valid = RetinopathyDataset(valid_csv, train_dir) if (verbose == 2): print("Creating DataLoader...") train_dataloader = DataLoader(train, batch_size=batch_size, shuffle=True, num_workers=4) valid_dataloader = DataLoader(valid, batch_size=batch_size * 4, shuffle=False, num_workers=4) if (verbose == 2): print("Creating EfficientNet Model...") model = EfficientNetFinetune( level="efficientnet-b5", finetune=False, pretrain_weight="./weights/pretrained/aptos2018.pth") trainer = Trainer(model, train_dataloader, valid_dataloader, epochs, early_stop="QK", verbose=verbose) if (verbose == 2): print("Strat Training...") trainer.train() if (train_flag == 1): if (verbose == 2): print("Strat Predicting...") test_csv = pd.read_csv(test_csv) test = RetinopathyDataset(test_csv, test_dir, test=True) test_dataloader = DataLoader(test, batch_size=batch_size * 4, shuffle=False, num_workers=4) model = EfficientNetFinetune(level="efficientnet-b5", finetune=False, test=True, pretrain_weight=pretrain_weight) tester(model, test_dataloader, verbose)
from methods import extract_hog, get_svm_detector, train_svm, hog_detect from dataset_class import Dataset def logger_init(): # 获取logger实例,如果参数为空则返回root logger logger = logging.getLogger("PedestranDetect") formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s') console_handler = logging.StreamHandler(sys.stdout) console_handler.formatter = formatter logger.addHandler(console_handler) logger.setLevel(logging.INFO) return logger if __name__ == '__main__': file_path = 'data/test.mp4' logger = logger_init() dataset = Dataset() pos, neg, test = dataset.load_data_set(logger=logger) samples, labels = dataset.load_train_samples(pos, neg) train = extract_hog(samples, logger=logger) logger.info('Size of feature vectors of samples: {}'.format(train.shape)) logger.info('Size of labels of samples: {}'.format(labels.shape)) svm_detector = train_svm(train, labels, logger=logger) hog_detect(test, svm_detector, logger) tester(file_path)
def schedule_tester(self, cycle=TESTER_CYCLE): self.tester = tester() while True: print(" 测试器开始运行 ") self.tester.run() time.sleep(cycle)