def validate_detection(self, epoch, iteration):
print('Start val')
self.setModelState('test')
val_loader = self.val_loader
val_iter = iter(val_loader)
input_json_path = self.res2json()
gt_json_path = self.opt.ADDRESS.GT_JSON_DIR
# loss
losses = AverageMeter()
for i in range(len(val_loader)):
data = val_iter.next()
pretreatmentData = self.pretreatment(data)
img = self.get_img_data(pretreatmentData)
modelResult = self.model(img)
loss = self.posttreatment(modelResult, pretreatmentData, data, True)
print("No.%d, loss:%f" % (i, loss))
file_summary(self.opt.ADDRESS.LOGGER_DIR, self.opt.BASE.MODEL + "_result.txt",
"No.%d, loss:%f \n" % (i, loss))
losses.update(loss.item(), img.size(0))
tqdm.write('Validate Loss - Avg Loss {0}'.format(losses.avg))
# Precision / Recall / F_score
precision, recall, f_score = \
eval_func(input_json_path, gt_json_path, self.opt)
# Generate log
total_index = epoch * (
len(self.train_loader) // self.opt.FREQ.VAL_FREQ + 1) + iteration // self.opt.FREQ.VAL_FREQ
self.Logger.scalar_summary('Precision', precision, total_index)
self.Logger.scalar_summary('Recall', recall, total_index)
self.Logger.scalar_summary('F_score', f_score, total_index)
self.Logger.scalar_summary('Avg Loss', losses.avg, total_index)
self.setModelState('train')
return precision
def validate_recognition(self, epoch, iteration):
'''
在特定训练次数后执行验证模型能力操作
'''
print('Start val')
self.setModelState('test')
val_loader = self.val_loader
val_iter = iter(val_loader)
n_correct = 0
n_total = 0
distance = 0.0
loss_avg = averager()
self.val_times += 1
cnt = 0
for i in range(len(val_loader)):
try:
data = val_iter.next()
except:
print("数据读取错误")
continue
pretreatmentData = self.pretreatment(data, True)
modelResult = self.model(*pretreatmentData)['result']
try:
alphas = self.model(*pretreatmentData)['alphas']
except:
alphas = None
# print("输出",type(modelResult))
cost, preds, targets = self.posttreatment(modelResult,
pretreatmentData,
originData=data,
test=True)
loss_avg.add(cost)
index = 0
for image, pred, target in zip(data[0], preds, targets):
if pred.lower() == target.lower():
n_correct += 1
# else:
# wrong_gt_predict(target,pred,cnt,self.opt)
'''可视化操作'''
# if self.opt.FUNCTION.VAL_ONLY:
# saveByOrder(data[0], self.opt)
# wrong_gt_predict(target, pred, cnt, self.opt)
if self.opt.FUNCTION.VAL_ONLY:
if alphas != None:
visualize(image,
target,
pred,
cnt,
self.opt,
alpha=alphas[index])
else:
visualize(image, target, pred, cnt, self.opt)
# wrong_gt_predict(target, pred, cnt, self.opt)
'''利用logger工具将结果记录于文件夹中'''
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_result" + ".txt", "预测 %s 目标 %s\n" % (pred, target))
'''添加功能：对正确文本和错误文本进行分类'''
if pred.lower() == target.lower():
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_right" + ".txt",
"预测 %s 目标 %s\n" % (pred, target))
else:
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_wrong" + ".txt",
"预测 %s 目标 %s\n" % (pred, target))
distance += Levenshtein.distance(pred.lower(),
target.lower()) / max(
len(pred), len(target))
n_total += 1
index += 1
cnt += 1
accuracy = n_correct / float(n_total)
'''利用logger工具将结果进行可视化'''
total_index = epoch * (len(self.train_loader) // self.opt.FREQ.VAL_FREQ
+ 1) + iteration // self.opt.FREQ.VAL_FREQ
self.Logger.scalar_summary('Levenshtein Distance', distance / n_total,
total_index)
self.Logger.scalar_summary('Accuracy', accuracy, total_index)
self.Logger.scalar_summary('Avg Loss', loss_avg.val(), total_index)
print("correct / total: %d / %d, " % (n_correct, n_total))
print('levenshtein distance: %f' % (distance / n_total))
print('Test loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
self.setModelState('train')
'''结束可视化工作'''
visualize(opt=self.opt, finish=True)
return accuracy
def train(self):
'''
训练函数
Already Done:
1.初始化一个可训练模型
2.定义损失函数与优化器
TODO:
1.定义一个epoch循环，循环总数在配置文件中定义。每个epoch会把所有
2.定义一个train_loader迭代器，在每一个iter里，使用next()获取下一个批次
对于每一个iter,计算模数，在对应的迭代周期里执行保存/验证/记录 操作
'''
'''如果只需验证，只需要一次验证过程即可无需训练'''
if self.opt.FUNCTION.VAL_ONLY == True:
self.validate(1, self.opt.FREQ.VAL_FREQ)
return
loss_avg = averager()
t0 = time.time()
self.highestAcc = 0
for epoch in range(self.opt.MODEL.EPOCH):
iteration = 0
train_iter = iter(self.train_loader)
while iteration < len(self.train_loader):
'''检查该迭代周期是否需要保存或验证'''
self.checkSaveOrVal(epoch, iteration)
data = train_iter.next()
# print(data)
pretreatmentData = self.pretreatment(data, False)
modelResult = self.model(*pretreatmentData)['result']
# print("402行类型为",type(modelResult))
cost = self.posttreatment(modelResult, pretreatmentData, data)
self.optimizer.zero_grad()
# self.optimizer.zero_grad()
cost.backward()
self.optimizer.step()
loss_avg.add(cost)
'''
展示阶段
在训练的时候仅仅展示在相应阶段的loss
'''
if iteration % self.opt.FREQ.SHOW_FREQ == 0:
t1 = time.time()
print('Epoch: %d/%d; iter: %d/%d; Loss: %f; time: %.2f s;' %
(epoch, self.opt.MODEL.EPOCH, iteration, len(self.train_loader), loss_avg.val(), t1 - t0))
file_summary(self.opt.ADDRESS.LOGGER_DIR, "log.txt",
'Epoch: %d/%d; iter: %d/%d; Loss: %f; time: %.2f s;' %
(epoch, self.opt.MODEL.EPOCH, iteration, len(self.train_loader), loss_avg.val(), t1 - t0))
loss_avg.reset()
t0 = time.time()
iteration += 1
'''动态调整学习率'''
if self.scheduler != None:
scheduler.step()
self.Logger.close_summary()
def validate_recognition(self, epoch, iteration):
'''
在特定训练次数后执行验证模型能力操作
'''
print('Start val')
self.setModelState('test')
val_loader = self.val_loader
val_iter = iter(val_loader)
n_correct = 0
n_total = 0
distance = 0.0
loss_avg = averager()
self.val_times += 1
cnt = 0
for i in range(len(val_loader)):
data = val_iter.next()
pretreatmentData = self.pretreatment(data, True)
modelResult = self.model(*pretreatmentData)
cost, preds, targets = self.posttreatment(modelResult,
pretreatmentData,
originData=data,
test=True)
loss_avg.add(cost)
for pred, target in zip(preds, targets):
# print(pred,target)
if pred.lower() == target.lower():
n_correct += 1
else:
wrong_gt_predict(target, pred, cnt, self.opt)
'''利用logger工具将结果记录于文件夹中'''
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_result" + ".txt", "预测 %s 目标 %s\n" % (pred, target))
'''添加功能：对正确文本和错误文本进行分类'''
if pred.lower() == target.lower():
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_right" + ".txt",
"预测 %s 目标 %s\n" % (pred, target))
else:
file_summary(
self.opt.ADDRESS.LOGGER_DIR,
str(self.val_times) + '_' + self.opt.BASE.MODEL +
"_wrong" + ".txt",
"预测 %s 目标 %s\n" % (pred, target))
distance += Levenshtein.distance(pred.lower(),
target.lower()) / max(
len(pred), len(target))
n_total += 1
cnt += 1
accuracy = n_correct / float(n_total)
'''利用logger工具将结果进行可视化'''
total_index = epoch * (len(self.train_loader) // self.opt.FREQ.VAL_FREQ
+ 1) + iteration // self.opt.FREQ.VAL_FREQ
self.Logger.scalar_summary('Levenshtein Distance', distance / n_total,
total_index)
self.Logger.scalar_summary('Accuracy', accuracy, total_index)
self.Logger.scalar_summary('Avg Loss', loss_avg.val(), total_index)
print("correct / total: %d / %d, " % (n_correct, n_total))
print('levenshtein distance: %f' % (distance / n_total))
print('Test loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
self.setModelState('train')
return accuracy