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