def extract_result(opt, crnn, converter, extra_path):
print(extra_path)
test_dataset = dataset.hwrDataset(mode="test",
transform=dataset.resizeNormalize(
(100, 32)),
return_index=True,
extra_path=extra_path)
accuracy, predicted_list = run_net_batch(crnn, opt, test_dataset,
converter)
sorted(predicted_list, key=lambda instance: instance.index)
return predicted_list
def validate(opt, crnn, converter, criterion):
test_dataset = dataset.hwrDataset(mode="test",
transform=dataset.resizeNormalize(
(100, 32)))
val_loss_avg, accuracy, corrected_accuracy = val_batch(crnn,
opt,
test_dataset,
converter,
criterion,
full_val=True)
print(corrected_accuracy)
print(accuracy)
print(val_loss_avg)
def main(opt):
print(opt)
if opt.experiment is None:
opt.experiment = 'expr'
os.system('mkdir {0}'.format(opt.experiment))
# Why is this?
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
np.random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
cudnn.benchmark = True
if torch.cuda.is_available() and not opt.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
train_dataset = dataset.hwrDataset(mode="train")
assert train_dataset
# if not opt.random_sample:
# sampler = dataset.randomSequentialSampler(train_dataset, opt.batchSize)
# else:
# sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers),
collate_fn=dataset.alignCollate(
imgH=opt.imgH,
imgW=opt.imgW,
keep_ratio=True))
# test_dataset = dataset.lmdbDataset(
# root=opt.valroot, transform=dataset.resizeNormalize((100, 32)))
test_dataset = dataset.hwrDataset(mode="test",
transform=dataset.resizeNormalize(
(100, 32)))
nclass = len(opt.alphabet) + 1
nc = 1
criterion = CTCLoss()
# custom weights initialization called on crnn
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
crnn = crnn_model.CRNN(opt.imgH, nc, nclass, opt.nh)
crnn.apply(weights_init)
if opt.crnn != '':
print('loading pretrained model from %s' % opt.crnn)
crnn.load_state_dict(torch.load(opt.crnn))
print(crnn)
# TODO make this central
image = torch.FloatTensor(opt.batchSize, 3, opt.imgH, opt.imgH)
text = torch.IntTensor(opt.batchSize * 5)
length = torch.IntTensor(opt.batchSize)
if opt.cuda:
crnn.cuda()
crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
image = image.cuda()
criterion = criterion.cuda()
image = Variable(image)
text = Variable(text)
length = Variable(length)
# TODO what is this, read this.
# loss averager
loss_avg = utils.averager()
# Todo default is RMS Prop. I wonder why?
# setup optimizer
#Following the paper's recommendation
opt.adadelta = True
if opt.adam:
optimizer = optim.Adam(crnn.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
elif opt.adadelta:
optimizer = optim.Adadelta(crnn.parameters(), lr=opt.lr)
else:
optimizer = optim.RMSprop(crnn.parameters(), lr=opt.lr)
converter = utils.strLabelConverter(opt.alphabet)
def val(net, dataset, criterion, max_iter=100):
print('Start val')
for p in crnn.parameters():
p.requires_grad = False
net.eval()
data_loader = torch.utils.data.DataLoader(dataset,
shuffle=True,
batch_size=opt.batchSize,
num_workers=int(opt.workers))
val_iter = iter(data_loader)
n_correct = 0
loss_avg = utils.averager()
max_iter = min(max_iter, len(data_loader))
for i in range(max_iter):
print("Is 'i' jumping two values? i == " + str(i))
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
) # todo where is the output size set to 26? Empirically it is.
# preds = preds.squeeze(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data,
preds_size.data,
raw=False) # Todo read this.
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))
for epoch in range(opt.niter):
train_iter = iter(train_loader)
i = 0
while i < len(train_loader):
for p in crnn.parameters():
p.requires_grad = True
crnn.train()
cost = train_batch(crnn, criterion, optimizer, train_iter, opt,
converter)
loss_avg.add(cost)
i += 1
if i % opt.displayInterval == 0:
print('[%d/%d][%d/%d] Loss: %f' %
(epoch, opt.niter, i, len(train_loader), loss_avg.val()))
loss_avg.reset()
if i % opt.valInterval == 0:
try:
val(crnn, test_dataset, criterion)
except Exception as e:
print(e)
# do checkpointing
if i % opt.saveInterval == 0:
torch.save(
crnn.state_dict(),
'{0}/netCRNN_{1}_{2}.pth'.format(opt.experiment, epoch, i))
def main(opt, case):
print("Arguments are : " + str(opt))
if opt.experiment is None:
opt.experiment = 'expr'
os.system('mkdir {0}'.format(opt.experiment))
# Why do we use this?
opt.manualSeed = random.randint(1, 10000) # fix seed
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
np.random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
cudnn.benchmark = True
if torch.cuda.is_available() and not opt.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
opt.cuda = True
print('Set CUDA to true.')
train_dataset = dataset.hwrDataset(mode="train")
assert train_dataset
# The shuffle needs to be false when the sizing has been done.
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=opt.batchSize,
shuffle=False,
num_workers=int(opt.workers),
collate_fn=dataset.alignCollate(
imgH=opt.imgH,
imgW=opt.imgW,
keep_ratio=True))
test_dataset = dataset.hwrDataset(mode="test",
transform=dataset.resizeNormalize(
(100, 32)))
nclass = len(opt.alphabet) + 1
nc = 1
criterion = CTCLoss()
# custom weights initialization called on crnn
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
crnn = crnn_model.CRNN(opt.imgH, nc, nclass, opt.nh)
crnn.apply(weights_init)
if opt.cuda and not opt.uses_old_saving:
crnn.cuda()
crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
criterion = criterion.cuda()
if opt.crnn != '':
print('Loading pre-trained model from %s' % opt.crnn)
loaded_model = torch.load(opt.crnn)
if opt.uses_old_saving:
print("Assuming model was saved in rudementary fashion")
crnn.load_state_dict(loaded_model)
crnn.cuda()
crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
criterion = criterion.cuda()
start_epoch = 0
else:
print("Loaded model accuracy: " + str(loaded_model['accuracy']))
print("Loaded model epoch: " + str(loaded_model['epoch']))
start_epoch = loaded_model['epoch']
crnn.load_state_dict(loaded_model['state'])
# Read this.
loss_avg = utils.averager()
# If following the paper's recommendation, using AdaDelta
if opt.adam:
optimizer = optim.Adam(crnn.parameters(),
lr=opt.lr,
betas=(opt.beta1, 0.999))
elif opt.adadelta:
optimizer = optim.Adadelta(crnn.parameters(), lr=opt.lr)
elif opt.adagrad:
print("Using adagrad")
optimizer = optim.Adagrad(crnn.parameters(), lr=opt.lr)
else:
optimizer = optim.RMSprop(crnn.parameters(), lr=opt.lr)
converter = utils.strLabelConverter(opt.alphabet)
best_val_accuracy = 0
for epoch in range(start_epoch, opt.niter):
train_iter = iter(train_loader)
i = 0
while i < len(train_loader):
for p in crnn.parameters():
p.requires_grad = True
crnn.train()
cost = train_batch(crnn, criterion, optimizer, train_iter, opt,
converter)
loss_avg.add(cost)
i += 1
if i % opt.displayInterval == 0:
print(
'[%d/%d][%d/%d] Loss: %f' %
(epoch, opt.niter, i, len(train_loader), loss_avg.val()) +
" " + case)
loss_avg.reset()
if i % opt.valInterval == 0:
try:
val_loss_avg, accuracy = val_batch(crnn, opt, test_dataset,
converter, criterion)
model_state = {
'epoch': epoch + 1,
'iter': i,
'state': crnn.state_dict(),
'accuracy': accuracy,
'val_loss_avg': val_loss_avg,
}
utils.save_checkpoint(
model_state, accuracy > best_val_accuracy,
'{0}/netCRNN_{1}_{2}_{3}.pth'.format(
opt.experiment, epoch, i,
accuracy), opt.experiment)
if accuracy > best_val_accuracy:
best_val_accuracy = accuracy
except Exception as e:
print(e)