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)
