def init_weights(m):
for name, param in m.named_parameters():
if 'weight' in name:
nn.init.normal_(param.data, mean=0, std=0.01)
else:
nn.init.constant_(param.data, 0)
if __name__ == "__main__":
config = Config()
device = config.device
attn = Attention(config.s2s_enc_hid, config.s2s_dec_hid)
enc = Encoder(config.s2s_emb_dim, config.s2s_enc_hid, config.s2s_dec_hid,
config.s2s_enc_dropout)
dec = Decoder(len(config.class_char), config.s2s_emb_dim,
config.s2s_enc_hid, config.s2s_dec_hid,
config.s2s_enc_dropout, attn)
model = Seq2Seq(enc, dec, device).to(device)
model.apply(init_weights)
model.load_state_dict(torch.load('weight/s2s.pt'))
model.eval()
data = gen(["data/test/96.json"], 1, config.max_box_num, device)
with torch.no_grad():
src, trg = next(data)
batch_size=batch_size,
shuffle=True,
num_workers=16,
pin_memory=True)
val_loader = DataLoader(val_set,
batch_size=batch_size,
shuffle=True,
num_workers=16,
pin_memory=True)
test_loader = DataLoader(test_set,
batch_size=batch_size,
shuffle=True,
num_workers=16,
pin_memory=True)
# Create Model
encoder = Encoder(lstm_hidden_size=enc_hid_dim, arch="resnet18").to(device)
decoder = Decoder(output_dim=vocab_size,
emb_dim=emb_dim,
enc_hid_dim=enc_hid_dim,
dec_hid_dim=dec_hid_dim,
dropout=dropout).to(device)
model = Seq2Seq(encoder=encoder, decoder=decoder, device=device).to(device)
# Resume model
if checkpoint is not None:
start_epoch, best_wer = resume_model(model, checkpoint)
# Run the model parallelly
if torch.cuda.device_count() > 1:
print("Using {} GPUs".format(torch.cuda.device_count()))
model = nn.DataParallel(model)
# Create loss criterion & optimizer
criterion = nn.CrossEntropyLoss()
collate_fn=collate_fn,
pin_memory=True)
test_loader = DataLoader(PhoenixDataset(root,
mode='test',
interval=sample_interval,
transform=transform),
batch_size=batch_size,
shuffle=False,
num_workers=16,
collate_fn=collate_fn,
pin_memory=True)
# Create Model
encoder = Encoder(enc_hid_dim=enc_hid_dim,
dec_hid_dim=dec_hid_dim,
arch="resnet18").to(device)
attn = Attn(enc_hid_dim=enc_hid_dim,
dec_hid_dim=dec_hid_dim,
attn_dim=attn_dim).to(device)
decoder = Decoder(output_dim=vocab_size,
emb_dim=emb_dim,
enc_hid_dim=enc_hid_dim,
dec_hid_dim=dec_hid_dim,
dropout=dropout,
attention=attn,
pretrained_emb=TRG.vocab.vectors).to(device)
model = Seq2Seq(encoder=encoder, decoder=decoder, device=device).to(device)
# Resume model
if checkpoint is not None:
start_epoch, best_wer = resume_model(model, checkpoint)