def test(**kwargs):
opt.parse(kwargs)
import ipdb
ipdb.set_trace()
# configure model
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# data
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, path) in enumerate(test_dataloader):
input = t.autograd.Variable(data, volatile=True)
if opt.use_gpu: input = input.cuda()
score = model(input)
probability = t.nn.functional.softmax(score)[:, 0].data.tolist()
# label = score.max(dim = 1)[1].data.tolist()
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
results += batch_results
write_csv(results, opt.result_file)
return results
def main():
args = prepare_parse()
model = resnet50(num_classes=2)
optimizer = SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=args.nesterov)
criterion = CrossEntropyLoss()
train_data = DogCat(args.train_data_path, training=True)
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_data)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.n_threads,
pin_memory=True,
sampler=train_sampler)
for ii, (image, label) in enumerate(train_loader):
image = image.cuda()
label = label.cuda()
pred = model(image)
loss = criterion(pred, label)
print(loss)
def test(**kwargs):
"""
测试
"""
opt.parse(kwargs)
# ipdb.set_trace() # 设置断点，进行调试
# 配置模型
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
# 准备测试集
test_data = DogCat(opt.test_data_root, test=True)
test_data_loader = DataLoader(test_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, test_id) in enumerate(test_data_loader):
input = Variable(data)
if opt.use_gpu:
input = input.cuda()
pred = model(input)
probability = F.softmax(pred)[:, 0].data.tolist()
batch_results = [
(test_id_.item(), probability_)
for test_id_, probability_ in zip(test_id, probability)
]
results += batch_results
write_csv(results, opt.result_file)
return results
def test(**kwargs):
opt._parse(kwargs)
# configure model
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
model.to(opt.device)
# data
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, path) in tqdm(enumerate(test_dataloader)):
input = data.to(opt.device)
score = model(input)
probability = t.nn.functional.softmax(score,
dim=1)[:, 0].detach().tolist()
# label = score.max(dim = 1)[1].detach().tolist()
batch_results = [(path_.item(), probability_)
for path_, probability_ in zip(path, probability)]
results += batch_results
write_csv(results, opt.result_file)
return results
def test(**kwargs):
"""
testing for inference
:param kwargs:
:return:
"""
opt.parse(kwargs)
ipdb.set_trace()
# model
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
# data
test_data = DogCat(root=opt.test_data_root, test=True)
test_data_loader = DataLoader(test_data, batch_size=opt.batch_size, shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, path) in enumerate(test_data_loader):
input_ = Variable(data, volatile=True)
if opt.use_gpu:
input_ = input_.cuda()
score = model(input_)
probability = F.softmax(score)[:, 1].data.tolist()
batch_results = [(path_, probability_) for path_, probability_ in zip(path, probability)]
results += batch_results
write_csv(results, opt.result_file)
return results
def test(**kwargs):
'''
测试
'''
#加载配置
opt.parse(kwargs)
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model = model.cuda()
#加载数据
test_dataset = DogCat(opt.test_data_root, test=True)
test_loader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for i, data in enumerate(test_loader):
inputs, labels = data
if opt.use_gpu:
inputs = inputs.cuda()
outputs = model(inputs)
#softmax将计算结果归一化为概率，batch_results记录每一组数据的（编号，概率）字典
probability = t.nn.functional.softmax(outputs)[:, 0].tolist()
batch_results = [(id_num, proba)
for id_num, proba in zip(labels, probability)]
results += batch_results
write_csv(results, opt.result_file)
def test(**kwargs):
opt.parse(kwargs)
#model
model = getattr(models, opt.model).().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
#data
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,,batch_size=opt.batch_size,shuffle=False,num_workers=opt.num_workers)
results = []
for step, (data,path) in enumerate(test_dataloader):
input = t.autograd.Variable(data, volatile=True)
if opt.use_gpu:
input = input.cuda()
socre=model(input)
probability = t.nn.functional.softmax(score)[:,1].data.tolist()
batch_results = [(path_,probability_) \
for path_,probability_ in zip(path,probability) ]
results += batch_results
write_csv(results,opt.result_file)
return results
if __name__ == '__main__':
import fire
fire.Fire()
def test(**kwargs):
"""
计算每个样本属于狗的概率，并保存为CSV文件
:return:
"""
opt.parse(kwargs)
#模型
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
#数据
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(dataset=train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
result = []
for II, (data, path) in enumerate(test_dataloader):
input = Variable(data, volatile=True)
if opt.use_gpu:
input = input.cuda()
score = model(input)
probability = F.softmax(score)[:, 1].data.tolist()
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
result += batch_results
write_csv(result, opt.result_file)
return result
def test(**kwargs):
'''
猫狗大战 测试集 预测完成后写入cvs中每张图片为狗的概率
'''
opt.parse(kwargs)
# 通过config中模型名称来加载模型
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# data
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
# 测试集命名只有数字 data/test1/8973.jpg path为8973
for ii, (data, path) in tqdm(enumerate(test_dataloader)):
input = t.autograd.Variable(data, volatile=True)
if opt.use_gpu:
input = input.cuda()
score = model(input)
#概率 通过softmax可得概率 [:, 0]行全要，列只要第一列
probability = t.nn.functional.softmax(score)[:, 0].data.tolist()
#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同（两个对象 path,probability）
#两个对象 path,probability 逐元素拿出来打包成一个元组，返回由这些元组组成的列表
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
results = results + batch_results
#result_file 写入的文件地址
write_csv(results, opt.result_file)
def test(opt):
# 模型进入验证模式
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# 数据
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
# index (data, id)
for ii, (data, path) in enumerate(test_dataloader):
# 包装 data 并记录用在它身上的 operations
input = t.autograd.Variable(data, volatile=True)
if opt.use_gpu:
input = input.cuda()
score = model(input)
probability = t.nn.functional.softmax(score)[:, 1].data.tolist()
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
results += batch_results
write_csv(results, opt.result_file)
return results
def test(**kwargs):
# opt.parse(kwargs)
# import ipdb;
# ipdb.set_trace()
# configure model
#model = getattr(models, opt.model)().eval()
model=models.resnet18(pretrained=True)
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# data
test_data = DogCat(opt.test_data_root,test=True)
test_dataloader = DataLoader(test_data,batch_size=opt.batch_size,shuffle=True,num_workers=opt.num_workers)
#print(test_dataloader)
print("come")
results = []
for ii,(data,path) in tqdm(enumerate(test_dataloader)):
input = t.autograd.Variable(data,volatile = True)
#print("data is {}".format(data))
print("path is {}".format(path))
if opt.use_gpu: input = input.cuda()
score = model(input)
print("score is :{}".format(score))
probability = t.nn.functional.softmax(score)[:,0].data.tolist()
print("probability is :".format(probability))
label = score.max(dim = 1)[1].data.tolist()
print("Label is {}".format(label))
batch_results = [(path_,probability_) for path_,probability_ in zip(path,probability) ]
results += batch_results
write_csv(results,opt.result_file)
print(results)
val_data = DogCat(opt.test_data_root,train=False)
val_dataloader = DataLoader(val_data,opt.batch_size,
shuffle=False,num_workers=opt.num_workers)
val_cm, val_accuracy = val(model, val_dataloader)
print("end val function")
print(val_cm.value(),val_accuracy)
print("test function end")
return results
def train(**kwargs): opt._parse(kwargs) # step1: configure model model = getattr(models, opt.model)() if opt.load_model_path: model.load(opt.load_model_path) if opt.use_gpu: model.cuda() # step2: data train_data = DogCat(opt.train_data_root, train = True) val_data = DogCat(opt.train_data_root, train = False) train_dataloader = DataLoader(train_data, opt.batch_size,shuffle = True, num_workers = opt.num_workers) val_dataloader = DataLoader(val_data, opt.batch_size,shuffle=False,num_workers=opt.num_workers) # step3: loss & optimizer critetion = t.nn.CrossEntropyLoss() lr = opt.lr optimizer = t.optim.Adam(model.parameters(), lr = lr, weight_decay = opt.weight_decay)
def train():
# 1 数据
train_data = DogCat(opt.train_data_root)
trainloader = DataLoader(train_data, batch_size=opt.batch_size)
val_data = DogCat(opt.val_data_root, train=False)
# 2 模型
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
# 3
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr, weight_decay=opt.weight_decay)
for epoch in range(opt.max_epoch):
for ii, (data, label) in enumerate(trainloader):
input = Variable(data)
target = Variable(label)
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
if ii % 20 == 0:
print('epochs[{}] loss {}'.format(str(epoch),str(loss.data[0])))
model.save()
def test(**kwargs):
opt.parse(kwargs)
#data
test_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(test_data,
batch_size=1,
shuffle=False,
num_workers=opt.num_workers)
results = []
#model
model = models.densenet161(pretrained=True)
#model.fc = nn.Linear(2048,2)
#model.fc = nn.Dropout(0.2)
model.fc = nn.Linear(1000, 2)
model.load_state_dict(t.load('./model.pth'))
if opt.use_gpu:
model.cuda()
model.eval()
for ii, (data, path) in enumerate(test_dataloader):
#input = Variable(data,volatile=True)
with torch.no_grad():
input = Variable(data)
if opt.use_gpu:
input = input.cuda()
score = model(input)
#print(score)
path = path.numpy().tolist()
#print path
#print score.data,"+++++"
_, predicted = t.max(score.data, 1)
print(predicted)
#print "***************"
#print predicted
predicted = predicted.data.cpu().numpy().tolist()
res = ""
for (i, j) in zip(path, predicted):
if j == 1:
res = "CN"
else:
res = "AD"
results.append([i, "".join(res)])
#print results
write_csv(results, opt.result_file)
print('完成预测！')
return results
def inference():
"""
inference
:return:
"""
logging.debug('Begin to inference')
# step1: configure model
model = torchvision.models.densenet121(pretrained=False, num_classes=2)
if config.use_gpu:
model = torch.nn.DataParallel(model).cuda()
logging.info(
'Loading checkpoint from {path}'.format(path=config.load_model_path))
state = model_util.load(config.load_model_path)
model.load_state_dict(state['state_dic'])
model.eval()
logging.info(
'Loaded checkpoint from {path}'.format(path=config.load_model_path))
# dataset
test_data = DogCat(config.test_data_root, test=True)
test_dataloader = DataLoader(test_data,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.num_workers)
results = []
for ii, (data, path) in enumerate(test_dataloader):
input_var = torch.autograd.Variable(data, volatile=True)
if config.use_gpu:
input_var = input_var.cuda()
score = model(input_var)
probability = torch.nn.functional.softmax(score)[:, 0].data.tolist()
# label = score.max(dim = 1)[1].data.tolist()
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
results += batch_results
write_csv(results, config.result_file)
logging.debug('End to inference')
return results
def test(**kwargs):
opt.parse(kwargs)
#data
test_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(test_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
#model
model = models.resnet34(pretrained=True)
model.fc = nn.Linear(512, 2)
model.load_state_dict(t.load('./model.pth'))
if opt.use_gpu:
model.cuda()
model.eval()
for ii, (data, path) in enumerate(test_dataloader):
input = Variable(data, volatile=True)
if opt.use_gpu:
input = input.cuda()
score = model(input)
path = path.numpy().tolist()
#print path
#print score.data,"+++++"
_, predicted = t.max(score.data, 1)
#print "***************"
#print predicted
predicted = predicted.data.cpu().numpy().tolist()
res = ""
for (i, j) in zip(path, predicted):
if j == 1:
res = "Dog"
else:
res = "Cat"
results.append([i, "".join(res)])
#print results
write_csv(results, opt.result_file)
return results
def Visualizer(**kwargs):
#opt.parse(kwargs)
# import ipdb;
# ipdb.set_trace()
# configure model
model = getattr(models, opt.model)().eval()
#model=models.resnet18(pretrained=True)
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# data
test_data = DogCat(opt.visualize_data_root, test=True)
test_dataloader = DataLoader(test_data, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers)
# print(test_dataloader)
print("come")
results = []
for ii, (data, path) in tqdm(enumerate(test_dataloader)):
input = t.autograd.Variable(data, volatile=True)
# print("data is {}".format(data))
# print("path is {}".format(path))
imgs = input
if opt.use_gpu: input = input.cuda()
import time
print("time is ")
print(time.time())
score = model(input)
print(time.time())
# print("score is :{}".format(score))
label = score.max(dim=1)[1].data.tolist()
print("Label is {}".format(label))
img = torchvision.utils.make_grid(imgs)
img = img.numpy().transpose(1, 2, 0)
std = [0.5, 0.5, 0.5]
mean = [0.5, 0.5, 0.5]
img = img * std + mean
# print(img)
plt.imshow(img)
plt.show()
def test(**kwargs):
'''
猫狗大战 测试集 预测完成后写入cvs中每张图片为狗的概率
'''
# configure model
# 直接使用指定的module
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# data
# 加载测试集数据
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, path) in enumerate(test_dataloader):
input = t.autograd.Variable(data, volatile=True)
if opt.use_gpu: input = input.cuda()
# score代表分类后的每一项的得分
score = model(input)
# [:,0]全行，第一列，第一列为狗，计算是狗的得分，通过softmax计算概率
probability = t.nn.functional.softmax(score)[:, 0].data.tolist()
# label = score.max(dim = 1)[1].data.tolist()
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同（两个对象 path,probability）
# 两个对象 path,probability 逐元素拿出来打包成一个元组，返回由这些元组组成的列表
# 分模块迭代results
batch_results = [(path_, probability_)
for path_, probability_ in zip(path, probability)]
# 总的results
results += batch_results
# result_file 写入的文件地址
write_csv(results, opt.result_file)
return results
def test(**kwargs):
# opt.parse(kwargs)
# import ipdb
# ipdb.set_trace()
# configure model
model = getattr(models, opt.model)().eval()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
total_label = 0
total_probability = 0.
# data
train_data = DogCat(opt.test_data_root, test=True)
test_dataloader = DataLoader(train_data,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
results = []
for ii, (data, path) in enumerate(test_dataloader):
input = data
if opt.use_gpu: input = input.cuda()
score = model(input)
probability = t.nn.functional.softmax(score)[:, 0].data.tolist()
label = score.max(dim=1)[1].data.tolist()
total_label += sum(label)
total_probability += sum(probability)
batch_results = [
(label_, path_, probability_)
for label_, path_, probability_ in zip(label, path, probability)
]
results += batch_results
write_csv(results, opt.result_file)
if total_label / 4 >= 50:
print(1, total_label / 4, total_probability / 400,
total_label / 4 - total_probability / 400)
else:
print(0, 100 - total_label / 4, 100 - total_probability / 400,
(100 - total_label / 4) - (total_probability / 400))
def train(**kwargs):
opt._parse(kwargs)
vis = Visualizer(opt.env, port=opt.vis_port)
# step1: configure model
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
model.to(opt.device)
# step2: data
train_data = DogCat(opt.train_data_root, train=True)
val_data = DogCat(opt.train_data_root, train=False)
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = model.get_optimizer(lr, opt.weight_decay)
# optimizer = torch.optim.Adam(model.parameters(), lr=lr, betas=(0.9, 0.99))
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e10
# train
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
print("trian epoch: ", epoch)
for ii, (data, label) in tqdm(enumerate(train_dataloader)):
# train model
input = data.to(opt.device)
target = label.to(opt.device)
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.item())
# detach 一下更安全保险
confusion_matrix.add(score.detach(), target.detach())
if (ii + 1) % opt.print_freq == 0:
vis.plot('loss', loss_meter.value()[0])
# # 进入debug模式
# if os.path.exists(opt.debug_file):
# import ipdb;
# ipdb.set_trace()
model.save()
# validate and visualize
print("start eval:")
val_cm, val_accuracy = val(model, val_dataloader)
vis.plot('val_accuracy', val_accuracy)
vis.log(
"epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}"
.format(epoch=epoch,
loss=loss_meter.value()[0],
val_cm=str(val_cm.value()),
train_cm=str(confusion_matrix.value()),
lr=lr))
# update learning rate
if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
# 第二种降低学习率的方法:不会有moment等信息的丢失
for param_group in optimizer.param_groups:
param_group['lr'] = lr
vis.plot('lr', lr)
previous_loss = loss_meter.value()[0]
def train(**kwargs):
"""根据命令行参数更新配置"""
opt.parse(kwargs)
#vis = Visualizer(opt.env)
"""(1)step1：加载网络，若有预训练模型也加载"""
#model = getattr(models,opt.model)()
model = models.alexnet(pretrained=True)
#model.aux_logits = False
#num_ftrs = model.fc.in_features
print(model)
# 自己构建的分类模型有8个类
#model.classifier = nn.Linear(2208, 2)
model.classifier = nn.Sequential(
nn.Dropout(p=0.5, inplace=False),
nn.Linear(in_features=9216, out_features=4096, bias=True),
nn.ReLU(inplace=True), nn.Dropout(p=0.5, inplace=False),
nn.Linear(in_features=4096, out_features=4096, bias=True),
nn.ReLU(inplace=True),
nn.Linear(in_features=4096, out_features=2, bias=True))
#model.fc = nn.Dropout(0.2)
#model.fc = nn.Softmax(2)
#if opt.load_model_path:
# model.load(opt.load_model_path)
if opt.use_gpu: #GPU
model.cuda()
"""(2)step2：处理数据"""
train_data = DogCat(opt.train_data_root, train=True) #训练集
val_data = DogCat(opt.train_data_root, train=False) #验证集
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
"""(3)step3：定义损失函数和优化器"""
criterion = t.nn.CrossEntropyLoss() #交叉熵损失
lr = opt.lr #学习率
optimizer = t.optim.SGD(model.parameters(),
lr=opt.lr,
weight_decay=opt.weight_decay)
"""(4)step4：统计指标，平滑处理之后的损失，还有混淆矩阵"""
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e10
"""(5)开始训练"""
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in enumerate(train_dataloader):
#训练模型参数
input = Variable(data)
target = Variable(label)
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
#梯度清零
optimizer.zero_grad()
score = model(input)
#result = np.round(score.cpu().detach().numpy(),3)
#print(score.data)
#print(result)
#print(target.cpu().detach().numpy())
loss = criterion(score, target)
loss.backward() #反向传播
#更新参数
optimizer.step()
#更新统计指标及可视化
loss_meter.add(loss.item())
#print score.shape,target.shape
print(np.round(score.cpu().detach().numpy()).shape)
print(np.round(target.cpu().detach().numpy()))
confusion_matrix.add(score.detach(), target.detach())
print("ii:", ii, 'loss', loss_meter.value()[0])
if ii % opt.print_freq == opt.print_freq - 1:
#vis.plot('loss',loss_meter.value()[0])
#print('loss',loss_meter.value()[0])
if os.path.exists(opt.debug_file):
import ipdb
ipdb.set_trace()
"""计算验证集上的指标及可视化"""
val_cm, val_accuracy = val(model, val_dataloader)
#vis.plot('val_accuracy',val_accuracy)
#vis.log("epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}".
#format(epoch=epoch,loss=loss_meter.value()[0],val_cm=str(val_cm.value()),train_cm=str(confusion_matrix.value()),lr=lr))
print("epoch:", epoch, "loss:",
loss_meter.value()[0], "accuracy:", val_accuracy)
if val_accuracy == 100.0:
break
"""如果损失不再下降，则降低学习率"""
if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
for param_group in optimizer.param_groups:
param_group["lr"] = lr
previous_loss = loss_meter.value()[0]
# model.save()
name = time.strftime('model' + '%m%d_%H_%M_%S.pth')
t.save(model.state_dict(), 'checkpoints/' + name)
# model.save()
name = time.strftime('model' + '%m%d_%H_%M_%S.pth')
t.save(model.state_dict(), 'checkpoints/' + name)
default=1,
metavar='seed',
help='random seed(default=1)')
args = parser.parse_args()
print(args)
torch.manual_seed(args.seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
check_file = 'checkpoints/best_model.pkl'
########data
test_data_root = 'data/test1/'
train_data_root = 'data/train/'
train_data = DogCat(train_data_root, train=True)
test_data = DogCat(test_data_root, train=False, test=True)
val_data = DogCat(train_data_root, train=False)
train_dataloader = DataLoader(dataset=train_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=num_workers)
val_dataloader = DataLoader(dataset=val_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=num_workers)
test_dataloader = DataLoader(dataset=test_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=num_workers)
def train(**kwargs):
opt._parse(kwargs)
vis = Visualizer(opt.env,port = opt.vis_port)
# step1: configure model
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
model.to(opt.device)
# step2: data
train_data = DogCat(opt.train_data_root,train=True)
val_data = DogCat(opt.train_data_root,train=False)
train_dataloader = DataLoader(train_data,opt.batch_size,
shuffle=True,num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,opt.batch_size,
shuffle=False,num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = model.get_optimizer(lr, opt.weight_decay)
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e10
# train
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
train_loss = 0.
train_acc = 0.
i = 0
for ii,(data,label) in tqdm(enumerate(train_dataloader)):
# train model
input = data.to(opt.device)
target = label.to(opt.device)
optimizer.zero_grad()
score = model(input)
loss = criterion(score,target)
train_loss += loss.item()
pred = t.max(score, 1)[1]
train_correct = (pred==target).sum()
train_acc += train_correct.item()
print('epoch ', epoch, ' batch ', i)
i+=1
print('Train Loss: %f, Acc: %f' % (loss.item(), train_correct.item() / float(len(data))))
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.item())
# detach 一下更安全保险
confusion_matrix.add(score.detach(), target.detach())
if (ii + 1)%opt.print_freq == 0:
vis.plot('loss', loss_meter.value()[0])
# 进入debug模式
if os.path.exists(opt.debug_file):
import ipdb;
ipdb.set_trace()
print('Train Loss: {:.6f}, Acc: {:.6f}'.format(train_loss / (len(
train_data)), train_acc / (len(train_data))))
# model.save()
prefix = 'checkpoints/' + opt.model + '_a'+str(epoch)+'.pth'
t.save(model.state_dict(), prefix)
# validate and visualize
val_cm,val_accuracy = val(model,val_dataloader, criterion, val_data)
vis.plot('val_accuracy',val_accuracy)
vis.log("epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}".format(
epoch = epoch,loss = loss_meter.value()[0],val_cm = str(val_cm.value()),train_cm=str(confusion_matrix.value()),lr=lr))
# update learning rate
if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
# 第二种降低学习率的方法:不会有moment等信息的丢失
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
def train(**kwargs):
opt.parse(kwargs)
# vis = Visualizer(opt.env)
# step1: configure model
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# step2: data
train_data = DogCat(opt.train_data_root, train=True)
val_data = DogCat(opt.train_data_root, train=False)
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = t.optim.Adam(model.parameters(),
lr=lr,
weight_decay=opt.weight_decay)
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e100
# train
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in tqdm(enumerate(train_dataloader),
total=len(train_data)):
# train model
input = Variable(data)
target = Variable(label)
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
# meters update and visualize
# loss_meter.add(loss.data[0])
loss_meter.add(loss.item())
confusion_matrix.add(score.data, target.data)
# if ii % opt.print_freq == opt.print_freq - 1:
# vis.plot('loss', loss_meter.value()[0])
# 进入debug模式
# if os.path.exists(opt.debug_file):
# import ipdb;
# ipdb.set_trace()
model.save()
# validate and visualize
val_cm, val_accuracy = val(model, val_dataloader)
# vis.plot('val_accuracy', val_accuracy)
# vis.log("epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}".format(
# epoch=epoch, loss=loss_meter.value()[0], val_cm=str(val_cm.value()), train_cm=str(confusion_matrix.value()),
# lr=lr))
# update learning rate
if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
# 第二种降低学习率的方法:不会有moment等信息的丢失
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
def train(**kwargs):
opt.parse(**kwargs)
# step1: configure model
model = getattr(models,opt.model)(opt.num_class)
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu:
model.cuda()
# step2: data
train_data = DogCat(opt.train_data_path, transform=opt.train_transform, train = True)
val_data = DogCat(opt.train_data_path, transform=opt.test_val_transform, train = False, test= False)
train_dataloader = DataLoader(train_data, batch_size= opt.batch_size, shuffle=opt.shuffle, num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data, batch_size= opt.batch_size, shuffle=opt.shuffle, num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = t.optim.Adam(params=model.parameters(), lr=lr, weight_decay=opt.weight_decay)
# step4: meters
loss_meter = meter.AverageValueMeter() # 用于统计一个epoch内的平均误差
confusion_matrix = meter.ConfusionMeter(opt.num_class)
previous_loss=1e6
# step5: train
vis = Visualizer(opt.env)
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
for ii,(data, label) in tqdm(enumerate(train_dataloader)):
# train model
input = Variable(data)
target = Variable(label)
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score,target)
loss.backward()
optimizer.step()
loss_meter.add(loss.data)
confusion_matrix.add(score.data, target.data)
# ipdb.set_trace()
if ii%opt.print_freq == opt.print_freq-1:
vis.plot(win='loss', y=loss_meter.value()[0])
model.save()
# step6: validate and visualize
val_confusion_matrix, val_accuracy = val(model, val_dataloader)
vis.plot(win='val_accuracy',y=val_accuracy)
vis.log(win='log_text', info=
'epoch:{epoch}, lr:{lr}, loss:{loss}, train_cm:{train_cm}, val_cm:{val_cm}'.format(
epoch=epoch,lr=lr,loss=loss_meter.value()[0],train_cm=str(confusion_matrix.value()),val_cm=str(val_confusion_matrix)
)
)
# step7: update learning_rate
if loss_meter.value()[0] > previous_loss:
lr=lr*opt.lr_decay
for param_group in optimizer.param_groups:
param_group['lr']=lr
previous_loss=loss_meter.value()[0]
def train(**kwargs):
# 根据命令行参数更新配置
opt.parse(kwargs)
vis = Visualizer(opt.env)
# step1: 模型
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# step2: 数据
train_data = DogCat(opt.train_data_root, train=True)
val_data = DogCat(opt.train_data_root, train=False)
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# step3: 目标函数和优化器
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = t.optim.Adam(model.parameters(),
lr=lr,
weight_decay=opt.weight_decay)
# step4: 统计指标：平滑处理之后的损失，还有混淆矩阵
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e100
# 训练
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in tqdm(enumerate(train_dataloader)):
# 训练模型
input = Variable(data)
target = Variable(label)
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
print('epoch:numerate={}:{}'.format(epoch, ii))
# 更新统计指标以及可视化
loss_meter.add(loss.data[0])
confusion_matrix.add(score.data, target.data)
# print('confusion_matrix',confusion_matrix)
# print('score.data',score.data)
# print('target.data',target.data)
if ii % opt.print_freq == opt.print_freq - 1:
vis.plot('loss', loss_meter.value()[0])
# 如果需要的话，进入debug模式
if os.path.exists(opt.debug_file):
import ipdb
ipdb.set_trace()
model.save()
print('model saved ')
# 计算验证集上的指标及可视化
val_cm, val_accuracy = val(model, val_dataloader)
vis.plot('val_accuracy', val_accuracy)
vis.log(
"epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}"
.format(epoch=epoch,
loss=loss_meter.value()[0],
val_cm=str(val_cm.value()),
train_cm=str(confusion_matrix.value()),
lr=lr))
# 如果损失不再下降，则降低学习率
print('loss_meter.value()[0]', loss_meter.value()[0])
if float(loss_meter.value()[0]) > previous_loss:
# if loss_meter.value().numpy().tolist[0] > previous_loss:
lr = lr * opt.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
def train(**kwargs):
# opt.parse(kwargs)
vis = Visualizer(opt.env)
savingData = [] #
# step1: configure model
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path)
if opt.use_gpu: model.cuda()
# step2: data
train_data = DogCat(opt.train_data_root, train=True)
val_data = DogCat(opt.train_data_root, train=False)
test_data = DogCat(opt.test_data_root, test=True)
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
test_dataloader = DataLoader(test_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = t.optim.Adam(model.parameters(),
lr=lr,
weight_decay=opt.weight_decay)
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e100
# train
for epoch in range(opt.max_epoch + 1):
# validate and visualize
val_cm, val_accuracy = val(model, val_dataloader)
test_cm, test_accuracy = val(model, test_dataloader)
vis.plot('test_accuracy', test_accuracy)
vis.plot('lr', lr)
vis.plot('val_accuracy', val_accuracy)
vis.log(
"epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm},test_cm:{test_cm}"
.format(epoch=epoch,
loss=loss_meter.value()[0],
val_cm=str(val_cm.value()),
train_cm=str(confusion_matrix.value()),
test_cm=str(test_cm.value()),
lr=lr))
print("epoch = ", epoch, " loss = ",
loss_meter.value()[0], " lr = ", lr)
batch_results = [(epoch, loss_meter.value()[0], lr,
str(val_cm.value()), str(confusion_matrix.value()),
str(test_cm.value()), val_accuracy, test_accuracy)
] #
savingData += batch_results #
save_training_data(savingData, opt.traingData_file) #
# update learning rate
# if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
# # 第二种降低学习率的方法:不会有moment等信息的丢失
# for param_group in optimizer.param_groups:
# param_group['lr'] = lr
if epoch == opt.max_epoch:
return
previous_loss = loss_meter.value()[0]
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in tqdm(enumerate(train_dataloader),
total=len(train_data) / opt.batch_size):
# train model
input = data
target = label
if opt.use_gpu:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.item())
confusion_matrix.add(score.data, target.data)
if ii % opt.print_freq == opt.print_freq - 1:
vis.plot('loss', loss_meter.value()[0])
# 进入debug模式
if os.path.exists(opt.debug_file):
import ipdb
ipdb.set_trace()
prefix = 'checkpoints/'
name = time.strftime(prefix + '%m%d_%H:%M:%S_' + str(epoch + 1) +
'.pth')
if epoch == 0:
model.save(name)
if np.mod(epoch + 1, 10) == 0:
model.save(name)
def train():
"""
train function
:return:
"""
vis = visualizer.Visualizer(config.visdom_env)
# step1: configure model
model = torchvision.models.densenet121(pretrained=False, num_classes=2)
if config.use_gpu:
model = torch.nn.DataParallel(model).cuda()
# step2: data
train_data = DogCat(config.train_data_root, train=True)
val_data = DogCat(config.train_data_root, train=False)
train_dataloader = DataLoader(train_data,
config.batch_size,
shuffle=True,
num_workers=config.num_workers)
val_dataloader = DataLoader(val_data,
config.batch_size,
shuffle=False,
num_workers=config.num_workers)
# step3: criterion and optimizer
criterion = torch.nn.CrossEntropyLoss()
lr = config.lr
optimizer = torch.optim.Adam(model.parameters(),
lr=lr,
weight_decay=config.weight_decay)
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(2)
previous_loss = 1e100
# train
model.train()
best_acc = -1.0
start_epoch = -1
# optionally resume from a checkpoint
state = dict()
if config.load_model_path:
logging.info('Loading checkpoint from {path}'.format(
path=config.load_model_path))
state = model_util.load(config.load_model_path)
start_epoch = state['epoch']
best_acc = state['accuracy']
model.load_state_dict(state['state_dic'])
optimizer.load_state_dict(state['optimizer'])
logging.info('Loaded checkpoint from {path}'.format(
path=config.load_model_path))
for epoch in range(start_epoch + 1, config.max_epoch):
logging.info('epoch = %d' % epoch)
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in tqdm(enumerate(train_dataloader),
total=len(train_data)):
# train model
input_var = Variable(data)
target_var = Variable(label)
if config.use_gpu:
input_var = input_var.cuda()
target_var = target_var.cuda()
optimizer.zero_grad()
score = model(input_var)
loss = criterion(score, target_var)
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.data[0])
confusion_matrix.add(score.data, target_var.data)
if ii % config.print_freq == config.print_freq - 1:
vis.plot('loss', loss_meter.value()[0])
# 进入debug模式
# if os.path.exists(config.debug_file):
# import ipdb;
# ipdb.set_trace()
# validate and visualize
val_cm, val_accuracy = val(model, val_dataloader)
vis.plot('val_accuracy', val_accuracy)
vis.log(
"epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}"
.format(epoch=epoch,
loss=loss_meter.value()[0],
val_cm=str(val_cm.value()),
train_cm=str(confusion_matrix.value()),
lr=lr))
is_best = val_accuracy > best_acc
best_acc = max(val_accuracy, best_acc)
logging.info(
"epoch:{epoch},lr:{lr},loss:{loss},acc:{acc} train_cm:{train_cm},val_cm:{val_cm}"
.format(epoch=epoch,
loss=loss_meter.value()[0],
acc=val_accuracy,
val_cm=str(val_cm.value()),
train_cm=str(confusion_matrix.value()),
lr=lr))
state['epoch'] = epoch
state['model'] = config.model
state['state_dic'] = model.state_dict()
state['accuracy'] = val_accuracy
state['optimizer'] = optimizer.state_dict()
model_util.save(state, config.checkpoint_dir, is_best)
# update learning rate
if loss_meter.value()[0] > previous_loss:
lr = lr * config.lr_decay
# 第二种降低学习率的方法:不会有moment等信息的丢失
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
# load best model weights
model.load_state_dict(best_model_wts)
return model, train_acc, valid_acc
TRAIN_DATA_ROOT = './dogs-vs-cats/train/' # 训练集存放路径
TEST_DATA_ROOT = './dogs-vs-cats/test1' # 测试集存放路径
BATCH_SIZE = 64
EPOCH = 10
LR = 0.001
MOMENTUM = 0.9
NUM_WORKER = 4
train_data = DogCat(TRAIN_DATA_ROOT, train=True)
val_data = DogCat(TRAIN_DATA_ROOT, train=False)
train_dataloader = Data.DataLoader(train_data,
BATCH_SIZE,
shuffle=True,
num_workers=NUM_WORKER)
val_dataloader = Data.DataLoader(val_data,
BATCH_SIZE,
shuffle=False,
num_workers=NUM_WORKER)
dataloaders = {'train': train_dataloader, 'val': val_dataloader}
#train_inputs, train_labels = train_dataloader
#val_inputs, val_labels = val_dataloader
datasizes = {'train': train_data.__len__(), 'val': val_data.__len__()}
print('data loaded!')
print(datasizes)
def train(**kwargs):
opt._parse(kwargs)
print(opt)
# vis = Visualizer(opt.env,port = opt.vis_port)
# step1: configure model
model = getattr(models, opt.model)()
if opt.load_model_path:
model.load(opt.load_model_path, opt.use_gpu)
model.to(opt.device)
# step2: data
train_data = DogCat(opt.train_data_root, train=True)
val_data = DogCat(opt.train_data_root, train=False)
train_dataloader = DataLoader(train_data,
opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataloader = DataLoader(val_data,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
# step3: criterion and optimizer
criterion = t.nn.CrossEntropyLoss()
lr = opt.lr
optimizer = model.get_optimizer(lr, opt.weight_decay)
lr_scheduler = LRS.ExponentialLR(optimizer, gamma=opt.lr_decay)
# step4: meters
loss_meter = meter.AverageValueMeter()
confusion_matrix = meter.ConfusionMeter(4)
previous_loss = 1e10
# train
for epoch in range(opt.max_epoch):
loss_meter.reset()
confusion_matrix.reset()
for ii, (data, label) in tqdm(enumerate(train_dataloader)):
# train model
input = data.to(opt.device)
target = label.to(opt.device)
optimizer.zero_grad()
score = model(input)
loss = criterion(score, target)
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.item())
# detach 一下更安全保险
confusion_matrix.add(score.detach(), target.detach())
if (ii + 1) % opt.print_freq == 0:
print('Train Epoch: {} Loss: {:.6f}, lr={:.5f}'.format(
epoch,
loss_meter.value()[0], optimizer.param_groups[0]['lr']))
# vis.plot('loss', loss_meter.value()[0])
# 进入debug模式
if os.path.exists(opt.debug_file):
import ipdb
ipdb.set_trace()
if epoch % 100 == 99:
model.save(epoch=epoch, label=opt.label_name)
# validate and visualize
val_cm, val_accuracy = val(model, val_dataloader)
# update learning rate by lr_scheduler
lr_scheduler.step(epoch=epoch)
print('Val set: Average loss: {:.4f}, Accuracy: ({:.2f}%)\n'.format(
loss_meter.value()[0], val_accuracy))
with open(opt.loss_file, 'a') as f:
f.write(str(loss_meter.value()[0]) + '\n')
with open(opt.acc_file, 'a') as f:
f.write(str(val_accuracy) + '\n')
# vis.plot('val_accuracy',val_accuracy)
# vis.log("epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}".format(
# epoch = epoch,loss = loss_meter.value()[0],val_cm = str(val_cm.value()),train_cm=str(confusion_matrix.value()),lr=lr))
# update learning rate by validation
if loss_meter.value()[0] > previous_loss:
lr = lr * opt.lr_decay
# 第二种降低学习率的方法:不会有moment等信息的丢失
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
