# 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.CRNN(config.imgH, config.nc, config.nclass, config.nh)
if config.pretrained_model != '' and os.path.exists(config.pretrained_model):
print('loading pretrained model from %s' % config.pretrained_model)
crnn.load_state_dict(torch.load(config.pretrained_model))
else:
crnn.apply(weights_init)
print(crnn)
# image = torch.FloatTensor(config.batchSize, 3, config.imgH, config.imgH)
# text = torch.IntTensor(config.batchSize * 5)
# length = torch.IntTensor(config.batchSize)
device = torch.device('cpu')
if config.cuda:
crnn.cuda()
# crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
# image = image.cuda()
device = torch.device('cuda:0')
criterion = criterion.cuda()
test_set = OCR_set('/content/Plate', augmentations(False))
test_loader = DataLoader(test_set, 1, shuffle=True)
assert test_set
alphabet = '1234567890abekmhopctyx'
nclass = len(alphabet) + 1
nc = 3
nh = 256
imgH = 64
preds_size = torch.tensor([33])
converter = utils.strLabelConverter(alphabet)
crnn = crnn.CRNN(imgH, nc, nclass, nh).to(device)
crnn.load_state_dict(torch.load('/content/drive/My Drive/WeightNet/OCR(3.0)'))
tp_1, fp_1, fn_1 = 0, 0, 0 # True Positive, False positive, False negative for first head
tp_2, fp_2, fn_2 = 0, 0, 0 # for double head
result = ['', '']
with torch.no_grad():
for x, y in test_loader:
cpu_images, cpu_texts = x.to(device), y
preds = crnn(cpu_images)
preds = preds.view(-1, preds_size.item(), 1, 23)
for idx, head in enumerate(preds):
_, preds1 = head.max(2)
full_path_image = '/content/drive/My Drive/DataCars'
#list_cars = os.listdir(full_path_image)
list_cars = []
alphabet = '1234567890abekmhopctyx'
nclass = len(alphabet) + 1
nc = 3
nh = 256
imgH = 64
preds_size = torch.tensor([33])
converter = utils.strLabelConverter(alphabet)
crnn = crnn.CRNN(imgH, nc, nclass, nh).to(device)
print('loading crnn model...\n')
crnn.load_state_dict(torch.load('OCR(3.0)', map_location='cpu'))
crnn.eval()
def detect(path_name_img):
image, image_orig, img_shape = prepare_image(path_name_img)
test_output = model(image.to(device))
w, h, _ = img_shape
mask_gray = cv2.resize(
(test_output[0].cpu().detach().numpy().squeeze() > 0.6).astype(
np.uint8),
dsize=(h, w))
mask_rgb = cv2.cvtColor(mask_gray, cv2.COLOR_GRAY2RGB)
contours, hierarchy = cv2.findContours(mask_gray.copy(), cv2.RETR_EXTERNAL,
# 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.CRNN(opt.imgH, nc, nclass, nh, ngpu)
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)
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()
image = image.cuda()
criterion = criterion.cuda()
image = Variable(image)
text = Variable(text)
length = Variable(length)
trainloader, validloader = prepare_dataloader()
crnn = crnn.CRNN(num_classes).to(device)
criterion = torch.nn.CTCLoss().to(device)
if args.adam:
optimizer = optim.Adam(crnn.parameters(), lr=args.lr)
elif args.rmsprop:
optimizer = optim.RMSprop(crnn.parameters(), lr=args.lr)
else:
optimizer = optim.Adadelta(crnn.parameters())
if args.pretrained != '':
print('loading pretrained model from {}'.format(args.pretrained))
crnn.load_state_dict(torch.load(args.pretrained))
crnn.train()
for epoch in range(args.num_epoch):
train(trainloader, crnn, converter, criterion, optimizer)
if epoch % args.eval_epoch == 0:
print('-------------------- eval --------------------')
crnn.eval()
validate(validloader, crnn, converter)
crnn.train()
if epoch % args.save_epoch == 0:
torch.save(crnn.state_dict(),
'{}/crnn_{}.pth'.format(args.save_path, epoch + 1))
shuffle=True,
num_workers=params.workers)
converter = utils.strLabelConverter(dataset.alphabet)
nclass = len(params.alphabet) + 1
print('nclass:', nclass)
nc = 1
criterion = torch.nn.CTCLoss(reduction='sum')
# criterion = CTCLoss()
# cnn and rnn
crnn = crnn.CRNN(32, nc, nclass, params.nh)
crnn.apply(weights_init)
if params.crnn != '':
print('loading pretrained model from %s' % params.crnn)
crnn.load_state_dict(torch.load(params.crnn))
# setup optimizer
if params.adam:
optimizer = optim.Adam(crnn.parameters(),
lr=params.lr,
betas=(params.beta1, 0.999))
elif params.adadelta:
optimizer = optim.Adadelta(crnn.parameters(), lr=params.lr)
else:
optimizer = optim.RMSprop(crnn.parameters(), lr=params.lr)
crnn.register_backward_hook(backward_hook)
main(crnn, train_loader, val_loader, criterion, optimizer)
# 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.CRNN(config.imgH, config.nc, config.nclass, config.nh)
if config.pretrained_model!='':# and os.path.exists(config.pretrained_model):
print('loading pretrained model from %s' % config.pretrained_model)
crnn.load_state_dict(torch.load(config.saved_model_dir+'/'+config.pretrained_model))
else:
crnn.apply(weights_init)
print(crnn)
# image = torch.FloatTensor(config.batchSize, 3, config.imgH, config.imgH)
# text = torch.IntTensor(config.batchSize * 5)
# length = torch.IntTensor(config.batchSize)
device = torch.device('cpu')
if config.cuda:
crnn.cuda()
# crnn = torch.nn.DataParallel(crnn, device_ids=range(opt.ngpu))
# image = image.cuda()
device = torch.device('cuda:0')
criterion = criterion.cuda()