def test(test_loader, max_iter=10):
test_size = 0
total_cer_loss = 0
total_ctc_loss = 0
test_iter = iter(test_loader)
max_iter = min(max_iter, len(test_loader))
crnn.eval()
with torch.no_grad():
for i in range(max_iter):
data = test_iter.next()
cpu_images, cpu_texts = data
utils.loadData(image, cpu_images)
batch_size = cpu_images.size(0)
test_size += batch_size
preds = crnn(image)
preds_size = Variable(torch.IntTensor([preds.size(0)] *
batch_size))
total_ctc_loss += criterion(preds, text, preds_size, length)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data,
preds_size.data,
raw=False)
# sim_preds = converter.beam_decode(preds.data)
total_cer_loss += utils.cer_loss(sim_preds,
cpu_texts,
ignore_case=False)
return total_ctc_loss * 1.0 / test_size, total_cer_loss * 1.0 / test_size
def val(crnn, data_loader, criterion, converter, device, max_iter=100):
print('Start val')
crnn.eval()
val_iter = iter(data_loader)
n_correct = 0
loss_avg = utils.averager()
max_iter = min(max_iter, len(data_loader))
for _ in range(max_iter):
data = val_iter.next()
cpu_images, text, length, cpu_texts = data
image = cpu_images.to(device)
batch_size = cpu_images.size(0)
with torch.no_grad():
preds = crnn(image)
preds_size = torch.IntTensor([preds.size(0)] * batch_size)
cost = criterion(preds, text, preds_size, length)
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
for pred, target in zip(sim_preds, cpu_texts):
if pred == target.lower():
n_correct += 1
raw_preds = converter.decode(preds.data, preds_size.data, raw=True)[:opt.n_test_disp]
for raw_pred, pred, gt in zip(raw_preds, sim_preds, cpu_texts):
print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
accuracy = n_correct / float(max_iter * opt.batchsize)
print('Test loss: %f, accuray: %.2f%%' % (loss_avg.val(), accuracy * 100))
def val(crnn, criterion):
with torch.no_grad():
crnn.eval()
test_iter = iter(test_loader)
n_correct = 0
cost = 0
for i in range(len(test_loader)):
data = test_iter.next()
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
utils.loadData(length, l)
# c1= converter.decode(t, l, raw=False)
# print("=============")
# print(cpu_texts)
# print("=============")
# print(c1)
# print("text:",text.size())
preds = crnn(image)
preds = F.log_softmax(preds, dim=2)
# print("preds:",preds.size())
preds_size = Variable(torch.IntTensor([preds.size(0)] *
batch_size))
# print(preds.size())
# print(text.size())
# torch.backends.cudnn.flags = False
cost += criterion(preds,
text.long().cuda(), preds_size,
length) / batch_size
_, acc = preds.max(2)
if int(torch.__version__.split('.')[1]) < 2:
acc = acc.squeeze(2)
acc = acc.transpose(1, 0).contiguous().view(-1)
# for i in acc.data:
# print(i)
sim_preds = converter.decode(acc, preds_size, raw=False)
# print(sim_preds)
# print(cpu_texts)
for pred, target in zip(sim_preds, cpu_texts):
# print(pred)
# print(target)
if pred.lower() == target.lower():
# print(pred.lower())
n_correct += 1
accuracy = n_correct / float(len(test_loader) * batchSize)
cost = cost / len(test_loader)
loss_list.append(cost)
accuracy_list.append(accuracy)
# accuracy = n_correct / float(max_iter * opt.batchSize)
print('Test loss: %f, accuray: %f' % (cost, accuracy))
print("loss: ", loss_list)
print("accuracy: ", accuracy_list)
def val(net, criterion):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
val_iter = iter(val_loader)
i = 0
n_correct = 0
loss_avg = utils.averager() # The blobal loss_avg is used by train
max_iter = len(val_loader)
for i in range(max_iter):
data = val_iter.next()
i += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
utils.loadData(length, l)
preds = crnn(image)
## change
# preds_size_0 = preds.size(0)
# preds_size_1 = preds.size(1)
# preds_size_2 = preds.size(2)
# preds = preds.view(preds_size_0 // params.ngpu, preds_size_1 * params.ngpu, preds_size_2)
##
preds_size = Variable(torch.LongTensor([preds.size(0)] * batch_size))
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
cpu_texts_decode = []
for i in cpu_texts:
cpu_texts_decode.append(i.decode('utf-8', 'strict'))
for pred, target in zip(sim_preds, cpu_texts_decode):
if pred == target:
n_correct += 1
raw_preds = converter.decode(preds.data, preds_size.data,
raw=True)[:params.n_val_disp]
for raw_pred, pred, gt in zip(raw_preds, sim_preds, cpu_texts_decode):
print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
accuracy = n_correct / float(max_iter * params.batchSize)
print('Val loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
def val(crnn, val_loader, criterion, iteration, max_i=1000):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
crnn.eval()
i = 0
n_correct = 0
loss_avg = utils.averager()
for i_batch, (image, index) in enumerate(val_loader):
image = image.to(device)
label = utils.get_batch_label(val_dataset, index)
preds = crnn(image)
batch_size = image.size(0)
index = np.array(index.data.numpy())
text, length = converter.encode(label)
preds_size = Variable(torch.IntTensor([preds.size(0)] * batch_size))
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
for pred, target in zip(sim_preds, label):
if pred == target:
n_correct += 1
if (i_batch + 1) % params.displayInterval == 0:
print('[%d/%d][%d/%d]' %
(iteration, params.niter, i_batch, len(val_loader)))
if i_batch == max_i:
break
raw_preds = converter.decode(preds.data, preds_size.data,
raw=True)[:params.n_test_disp]
for raw_pred, pred, gt in zip(raw_preds, sim_preds, label):
print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
print(n_correct)
print(max_i * params.val_batchSize)
accuracy = n_correct / float(max_i * params.val_batchSize)
print('Test loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
return accuracy
def val(net, criterion, max_iter=100):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
val_iter = iter(val_loader)
i = 0
n_correct = 0
loss_avg = utils.averager()
max_iter = len(val_loader)
for i in range(max_iter):
data = val_iter.next()
i += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
# t, l = converter.encode(cpu_texts)
# utils.loadData(text, t)
# utils.loadData(length, l)
preds = crnn(image)
preds_size = Variable(torch.IntTensor([preds.size(0)] * batch_size))
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.squeeze(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
for pred, target in zip(sim_preds, cpu_texts):
if pred == target.lower():
n_correct += 1
raw_preds = converter.decode(preds.data, preds_size.data, raw=True)[:opt.n_test_disp]
for raw_pred, pred, gt in zip(raw_preds, sim_preds, cpu_texts):
print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
accuracy = n_correct / float(max_iter * opt.batchSize)
print('Test loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
def val(crnn, valid_loader, criterion, max_iter=1000):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
crnn.eval()
val_iter = iter(valid_loader)
i = 0
n_correct = 0
loss_avg = utils.averager()
max_iter = min(max_iter, len(valid_loader))
for i in range(max_iter):
names, images, texts = val_iter.next()
batch_size = images.size(0)
t, l = converter.encode(texts)
images = images.cuda()
preds = crnn(images)
preds_size = Variable(torch.IntTensor([preds.size(0)] * batch_size))
cost = criterion(preds, t, preds_size, l) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
for pred, target in zip(sim_preds, texts):
if pred == target:
n_correct += 1
raw_preds = converter.decode(preds.data, preds_size.data,
raw=True)[:opt.n_test_disp]
for name, raw_pred, pred, gt in zip(names, raw_preds, sim_preds, texts):
print('%-20s:%-20s => %-20s, gt: %-20s' % (name, raw_pred, pred, gt))
accuracy = n_correct / float(max_iter * opt.batchSize)
print('Test loss: %f, accuray: %f' % (loss_avg.val(), accuracy))
return accuracy
img_path = opt.image
alphabet = '0123456789abcdefghijklmnopqrstuvwxyz'
with open('./data/vocabulary.txt', 'r') as voca_file:
alphabet = voca_file.readline()
if torch.cuda.is_available():
torch.cuda.set_device(opt.gpu)
print('device:', torch.cuda.current_device())
crnn = crnn.CRNN(32, 1, len(alphabet) + 1, 256)
if torch.cuda.is_available():
crnn = crnn.cuda()
print('loading pretrained model from %s' % model_path)
crnn.load_state_dict(torch.load(model_path))
crnn.eval()
converter = utils.strLabelConverter(alphabet)
def test_image(image_path, label, keep_ratio=False):
image = Image.open(image_path).convert('L')
if keep_ratio:
h, w = image.shape
resize_w = 32.0 * w / h
transformer = dataset.resizeNormalize((resize_w, 32))
else:
transformer = dataset.resizeNormalize((576, 32))
image = transformer(image)
if torch.cuda.is_available():
def val(crnn, val_data_list_param, criterion, max_iter_num=100):
# print('开始校验准确性')
for p in crnn.parameters():
p.requires_grad = False
crnn.eval()
i = 0
all_Count = 0
correct_Count = 0
while i < len(val_data_list_param):
val_data = val_data_list_param[i]
# datasetOne = datasetList[i]
# data_loader = torch.utils.data.DataLoader(
# datasetOne, shuffle=True, batch_size=opt.batchSize, num_workers=int(opt.workers))
data_set = val_data['dataset']
data_loader = torch.utils.data.DataLoader(
data_set, shuffle=True, batch_size=opt.batchSize, num_workers=1)
i += 1
# print("验证进度:{}/{},当前Flag:{}".format(i, len(val_data_list_param), val_data['dir']))
val_iter = iter(data_loader)
one_index = 0
one_correct = 0
loss_avg = utils.averager()
# 检测所用的图片数量
max_iter = min(max_iter_num, len(data_loader))
# 检测的总数量增加
all_Count += max_iter * opt.batchSize
for one_index in range(max_iter):
data = val_iter.next()
one_index += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
utils.loadData(length, l)
preds = crnn(image)
preds_size = Variable(torch.IntTensor([preds.size(0)] * batch_size))
# cost = criterion(preds, text, preds_size, length)
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2, keepdim=True)
preds = preds.squeeze(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
for pred, target in zip(sim_preds, cpu_texts):
if pred == target.lower():
# 两个成功数量都加1
one_correct += 1
correct_Count += 1
del val_iter
raw_preds = converter.decode(preds.data, preds_size.data, raw=True)[:opt.n_test_disp]
accuracy = one_correct / float(max_iter * opt.batchSize)
if accuracy < 0.95:
for raw_pred, pred, gt in zip(raw_preds, sim_preds, cpu_texts):
print_msg('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
print_msg('验证 %-3d/%d,Loss: %f,Flag: [%-15s] 的成功率: %f' % (
i, len(val_data_list_param), loss_avg.val(), val_data['dir'], accuracy))
accuracy = correct_Count / float(all_Count)
print_msg('总的成功率: %f ,总验证文件数: %d ' % (accuracy, all_Count))
return accuracy
"""
only when
torch.__version__ < '1.1.0'
we use this way to change the inf to zero
"""
crnn.register_backward_hook(crnn.backward_hook)
# -----------------------------------------------
def val(net, criterion):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
val_iter = iter(val_loader)
i = 0
n_correct = 0
loss_avg = utils.averager() # The blobal loss_avg is used by train
max_iter = len(val_loader)
for i in range(max_iter):
data = val_iter.next()
i += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
def val(net, criterion, show_error=False, img_check_dir='DATA/img_check'):
global best_acc, epoch
if show_error and not os.path.exists(img_check_dir):
os.makedirs(img_check_dir, exist_ok=True)
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
val_iter = iter(val_loader)
i = 0
n_correct = 0
loss_avg = utils.averager() # The blobal loss_avg is used by train
max_iter = len(val_loader)
errors = []
for i in range(max_iter):
data = val_iter.next()
i += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
utils.loadData(length, l)
preds = crnn(image)
preds_size = Variable(torch.LongTensor([preds.size(0)] * batch_size))
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
# from IPython import embed; embed()
preds_exp = preds.exp() # log_softmax -> softmax : SxBxC
max_probs, preds = preds_exp.max(2)
probs = max_probs.cumprod(0)[-1].cpu().numpy()
preds = preds.transpose(1, 0).contiguous().view(-1) # 1D # BXSXC
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
cpu_texts_decode = []
for i in cpu_texts:
cpu_texts_decode.append(i.decode('utf-8', 'strict'))
for idx, (pred, target) in enumerate(zip(sim_preds, cpu_texts_decode)):
if pred == target:
n_correct += 1
else:
if show_error:
errors.append([pred, target])
cv2.imwrite('DATA/img_check/' + str(idx) + "_" + str(target) + ".jpg", image[idx].cpu().mul_(0.5).add_(0.5).permute(1, 2, 0).numpy()* 255.0)
raw_preds = converter.decode(preds.data, preds_size.data, raw=True)[:params.n_val_disp]
for raw_pred, pred, gt, prob in zip(raw_preds, sim_preds, cpu_texts_decode, probs):
info = '%-20s ==> %-10s || Label: %-10s || prob: %-6.4f' % (raw_pred, pred, gt, prob)
logger.info(info)
accuracy = n_correct / float(len(val_dataset))
if accuracy > best_acc:
best_acc = accuracy
torch.save(crnn.state_dict(), os.path.join(params.expr_dir, 'best.pth'))
info = '[Epoch %d/%d]: Val loss: %f, accuray: %f, best_acc: %-10f \n %s' % (epoch, params.nepoch, loss_avg.val(), accuracy, best_acc, '='*100)
logger.info(info)
if show_error:
for error in errors:
print('pred: %-20s - gt: %-20s' % (error[0], error[1]))
def val(net, criterion):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
val_iter = iter(val_loader)
i = 0
n_correct = 0
similarity = 0
distances = 0
count = 0.0
loss_avg = utils.averager() # The blobal loss_avg is used by train
max_iter = len(val_loader)
all_predicts = []
for i in range(max_iter):
data = val_iter.next()
i += 1
cpu_images, cpu_texts = data
batch_size = cpu_images.size(0)
utils.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
utils.loadData(text, t)
utils.loadData(length, l)
preds = crnn(image)
preds_size = Variable(torch.LongTensor([preds.size(0)] * batch_size))
cost = criterion(preds, text, preds_size, length) / batch_size
loss_avg.add(cost)
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
cpu_texts_decode = []
for i in cpu_texts:
cpu_texts_decode.append(i.decode('utf-8', 'strict'))
for pred, target in zip(sim_preds, cpu_texts_decode):
if pred == target:
n_correct += 1
simr = jaccard_similarity([x for x in pred], [x for x in target])
distance = cer(pred, target)
all_predicts.append({
'pred': pred,
'actual': target,
'similarity': simr,
'distant': distance
})
similarity += simr
distances += distance
count += 1
raw_preds = converter.decode(preds.data, preds_size.data,
raw=True)[:params.n_val_disp]
for raw_pred, pred, gt in zip(raw_preds, sim_preds, cpu_texts_decode):
print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt))
accuracy = n_correct / count
similarity = similarity / count
distance = distances / count
print('Val loss: %f, accuracy: %f, similarity: %f, distance: %f' %
(loss_avg.val(), accuracy, similarity, distance))
return accuracy, all_predicts
