Exemple #1
0
        m.bias.data.fill_(0)


crnn = crnn.CRNN(opt.imgH, nc, nclass, opt.nh)
crnn.apply(weights_init)
if opt.pretrained != '':
    print('loading pretrained model from %s' % opt.pretrained)
    crnn.load_state_dict(torch.load(opt.pretrained))
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()
    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)

# loss averager
loss_avg = utils.averager()

# setup optimizer
if opt.adam:
    optimizer = optim.Adam(crnn.parameters(),
                           lr=opt.lr,
Exemple #2
0
#     new_state_dict[name] = v

# for name, module in crnn.named_children():
#     if name == 'cnn':
#         module_dict = module.state_dict()
#         new_state_dict = {k: v for k, v in new_state_dict.items() if k in module_dict}

#        module_dict.update(new_state_dict)
#         module.load_state_dict(module_dict)

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 = crnn.cuda(id_gpu)
    image = image.cuda(id_gpu)
    criterion = criterion.cuda(id_gpu)

image = Variable(image)
text = Variable(text)
length = Variable(length)

# loss averager
loss_avg = util.averager()

# setup optimizer
if opt.adam:
    optimizer = optim.Adam(crnn.parameters(),
                           lr=opt.lr,
                           betas=(opt.beta1, 0.999))
Exemple #3
0
    try:
        with io.open(args.alphabet, 'r', encoding='utf-8') as myfile:
            alphabet = myfile.read().split()
            alphabet.append(u' ')
            alphabet = ''.join(alphabet)

        converter = utils.strLabelConverter(alphabet, attention=False)

        nclass = converter.num_classes

        crnn = models.crnn.CRNN(imgH, nc, nclass, num_hidden)
        crnn.apply(weights_init)

        if args.cuda:
            crnn = crnn.cuda()
            crnn = torch.nn.DataParallel(crnn)

        logger.info("Loading pretrained model from {}".format(args.ckpt))
        file_weights = torch.load(args.ckpt)

        crnn.load_state_dict(file_weights)

        print("The oracle network:",
              crnn)  # Logging can't print torch models :thinking:

        image = Image.open(args.input[0]).convert('L')
        attack = CarliniAttack(crnn, alphabet, image.size, args.target,
                               file_weights)

        attack.execute(args.input, args.out)
Exemple #4
0
        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)

# loss averager
loss_avg = utils.averager()

# setup optimizer
if opt.adam:
    optimizer = optim.Adam(crnn.parameters(), lr=opt.lr,
                           betas=(opt.beta1, 0.999))
elif opt.adadelta: