def main(batch_size, test_batch_size, epochs, lr, cuda, seed, log_interval): """ Runs data processing scripts to turn raw data from (../raw) into cleaned data ready to be analyzed (saved in ../processed). """ logger = logging.getLogger(__name__) logger.info('making final data set from raw data') TRAIN_DATA = os.path.join(Path(__file__).resolve().parents[2], 'data', 'processed', 'training.pt') TEST_DATA = os.path.join(Path(__file__).resolve().parents[2], 'data', 'processed', 'test.pt') torch.manual_seed(seed) device = torch.device("cuda" if (cuda and torch.cuda.is_available()) else "cpu") x_train, y_train = torch.load(TRAIN_DATA) x_test, y_test = torch.load(TEST_DATA) train = data_utils.TensorDataset(x_train, y_train) train_loader = data_utils.DataLoader(train, batch_size=batch_size, shuffle=True) test = data_utils.TensorDataset(x_test, y_test) test_loader = data_utils.DataLoader(test, batch_size=test_batch_size, shuffle=True) model = LeNet().to(device) optimizer = optim.Adam(model.parameters(), lr=lr) for epoch in range(1, epochs + 1): train(args, model, device, train_loader, optimizer, epoch) test(args, model, device, test_loader)
def main(epochs, training=True): results = defaultdict(list) model = LeNet() print(model) if USE_CUDA: # GPU optimization model.cuda() model = torch.nn.DataParallel(model, device_ids=range( torch.cuda.device_count())) cudnn.benchmark = True dataloader = load_data() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters()) for epoch in range(epochs): steps, losses, acc = train( model, # the model dataloader, # the data provider criterion, # the loss function optimizer, # the optimization algorithm epoch + 1, # current epoch ) # add observations to the dictionary results['step'] += steps results['loss_scores'] += losses results['acc_scores'] += acc results['epoch'] += [epoch + 1] * len(steps) if save: save_checkpoint({ 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), }) return results
net = torch.nn.DataParallel(net) cudnn.benchmark = True if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isdir( 'checkpoint'), 'Error: no checkpoint directory found!' if os.path.isfile('./checkpoint/lifted_ckpt.t7'): checkpoint = torch.load('./checkpoint/lifted_ckpt.t7') best_acc = checkpoint['acc'] else: checkpoint = torch.load('./checkpoint/classification_ckpt.t7') best_acc = 0 net.load_state_dict(checkpoint['net']) start_epoch = checkpoint['epoch'] current_best_epoch = start_epoch print('the current best acc is %.3f on epoch %d' % (best_acc, start_epoch)) criterion = LiftedStructureLoss() optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4) for epoch in range(start_epoch, start_epoch + args.epochs): train(epoch) test(epoch)
# net = resnet18() net = LeNet(num_classes=cfg.num_classes) # net = VGG('VGG11', num_classes=10, dataset='cifar-10') # 重写网络最后一层 # fc_in_features = net.fc.in_features # 网络最后一层的输入通道 # net.fc = nn.Linear(in_features=fc_in_features, out_features=cfg.num_classes) # 将网络结构、损失函数放置在GPU上;配置优化器 net = net.to(cfg.device) # net = nn.DataParallel(net, device_ids=[0, 1]) # criterion = nn.BCEWithLogitsLoss().cuda(device=cfg.device) criterion = nn.CrossEntropyLoss().cuda(device=cfg.device) # 常规优化器:随机梯度下降和Adam #optimizer = optim.SGD(params=net.parameters(), lr=cfg.learning_rate, # weight_decay=cfg.weight_decay, momentum=cfg.momentum) optimizer = optim.Adam(params=net.parameters(), lr=cfg.learning_rate, weight_decay=cfg.weight_decay) # 线性学习率优化器 #optimizer = optim.SGD(params=net.parameters(), lr=cfg.learning, # weight_decay=cfg.weight_decay, momentum=cfg.momentum) # --------------进行训练----------------- # print('进行训练....') # train_and_valid_(net, criterion=criterion, # optimizer=optimizer, # train_loader=train_loader, # valid_loader=test_loader, cfg=cfg, # is_lr_warmup=False, is_lr_adjust=False) # -------------进行测试-----------------
transforms.ToTensor()])) data_test = MNIST('./data/mnist', train=False, download=True, transform=transforms.Compose( [transforms.Resize((32, 32)), transforms.ToTensor()])) data_train_loader = DataLoader(data_train, batch_size=256, shuffle=True, num_workers=8) data_test_loader = DataLoader(data_test, batch_size=1024, num_workers=8) net = LeNet() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(net.parameters(), lr=2e-3) cur_batch_win = None cur_batch_win_opts = { 'title': 'Epoch Loss Trace', 'xlabel': 'Batch Number', 'ylabel': 'Loss', 'width': 1200, 'height': 600, } def train(epoch): global cur_batch_win net.train() loss_list, batch_list = [], []
def run_training(): # A simple transform which we will apply to the MNIST images simple_transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, ), (1.0, ))]) train_set = datasets.MNIST(root=config.DATA_DIR, train=True, transform=simple_transform, download=True) test_set = datasets.MNIST(root=config.DATA_DIR, train=False, transform=simple_transform, download=True) # train_dataset = dataset.ClassificationDataset(image_paths=train_imgs, targets=train_targets, # resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH)) train_loader = torch.utils.data.DataLoader(dataset=train_set, batch_size=config.BATCH_SIZE, num_workers=config.NUM_WORKERS, shuffle=True) # test_dataset = dataset.ClassificationDataset(image_paths=test_imgs, targets=test_targets, # resize=(config.IMAGE_HEIGHT, config.IMAGE_WIDTH)) test_loader = torch.utils.data.DataLoader(dataset=test_set, batch_size=config.BATCH_SIZE, num_workers=config.NUM_WORKERS, shuffle=False) model = LeNet() if torch.cuda.is_available(): print('GPU available... using GPU') torch.cuda.manual_seed_all(42) # device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu') model.to(config.DEVICE) optimizer = torch.optim.Adam(model.parameters(), lr=3e-4) # scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( # optimizer, factor=0.8, patience=5, verbose=True # ) criterion = nn.CrossEntropyLoss() train_loss_data = [] test_loss_data = [] for epoch in range(config.EPOCHS): # training train_loss = engine.train_fn(model, train_loader, optimizer, criterion, save_model=True) # validation eval_preds, eval_loss = engine.eval_fn(model, test_loader, criterion) print( f"Epoch {epoch} => Training Loss: {train_loss}, Val Loss: {eval_loss}" ) train_loss_data.append(train_loss) test_loss_data.append(eval_loss) # print(train_dataset[0]) plot_loss(train_loss_data, test_loss_data, plot_path=config.PLOT_PATH) print("done")
def main(args): check_path(args) # CIFAR-10的全部类别,一共10类 classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # 数据集 data_builder = DataBuilder(args) dataSet = DataSet(data_builder.train_builder(), data_builder.test_builder(), classes) # 选择模型 if args.lenet: net = LeNet() model_name = args.name_le elif args.vgg: net = Vgg16_Net() model_name = args.name_vgg elif args.resnet18: net = ResNet18() model_name = args.name_res18 elif args.resnet34: net = ResNet34() model_name = args.name_res34 elif args.resnet50: net = ResNet50() model_name = args.name_res50 elif args.resnet101: net = ResNet101() model_name = args.name_res101 elif args.resnet152: net = ResNet152() model_name = args.name_res152 # 交叉熵损失函数 criterion = nn.CrossEntropyLoss() # SGD优化器 optimizer = optim.SGD(net.parameters(), lr=args.learning_rate, momentum=args.sgd_momentum, weight_decay=args.weight_decay) # 余弦退火调整学习率 scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=150) # 模型的参数保存路径 model_path = os.path.join(args.model_path, model_name) # 启动训练 if args.do_train: print("Training...") trainer = Trainer(net, criterion, optimizer, scheduler, dataSet.train_loader, dataSet.test_loader, model_path, args) trainer.train(epochs=args.epoch) # t.save(net.state_dict(), model_path) # 启动测试,如果--do_train也出现,则用刚刚训练的模型进行测试 # 否则就使用已保存的模型进行测试 if args.do_eval: if not args.do_train and not os.path.exists(model_path): print( "Sorry, there's no saved model yet, you need to train first.") return # --do_eval if not args.do_train: checkpoint = t.load(model_path) net.load_state_dict(checkpoint['net']) accuracy = checkpoint['acc'] epoch = checkpoint['epoch'] print("Using saved model, accuracy : %f epoch: %d" % (accuracy, epoch)) tester = Tester(dataSet.test_loader, net, args) tester.test() if args.show_model: if not os.path.exists(model_path): print( "Sorry, there's no saved model yet, you need to train first.") return show_model(args) if args.do_predict: device = t.device("cuda" if t.cuda.is_available() else "cpu") checkpoint = t.load(model_path, map_location=device) net.load_state_dict(checkpoint['net']) predictor = Predictor(net, classes) img_path = 'test' img_name = [os.path.join(img_path, x) for x in os.listdir(img_path)] for img in img_name: predictor.predict(img)