def recog(img, model, converter, device, mode):
model = model.to(device)
img = dataset.img_nomalize(img, mode)
img = torch.unsqueeze(img, 0)
img = img.to(device)
preds = model(img)
preds = preds.to('cpu')
probs, preds = preds.max(2)
text_preds = preds.transpose(1, 0).contiguous().view(-1)
text_preds_size = torch.IntTensor([text_preds.size(0)])
text = converter.decode(text_preds.data, text_preds_size.data, raw=False)
return text, probs.detach().numpy()
if not compute_metric:
return pred
pred = np.array(pred, dtype=np.float64)
ce = log_loss(gt, pred)
prauc = compute_prauc(pred, gt)
rce = compute_rce(pred, gt)
return ce, prauc, rce
if __name__ == '__main__':
if not os.path.exists('results'):
os.mkdir('results')
checkpoint = torch.load(
os.path.join(checkpoints_dir, model_name + '_best.pt'))
model.load_state_dict(checkpoint['model_state_dict'])
model.to(device)
if make_prediction:
data = pd.read_csv(test_file,
sep='\x01',
header=None,
names=all_features,
encoding='utf-8')
pred = test(model, compute_metric=False)
print('prediction finished')
pred = pd.concat([
data[['tweet_id', 'engaging_user_id']],
pd.DataFrame({'prediction': pred})
], 1)
pred.to_csv(os.path.join('results', arg.label + '_prediction.csv'),
header=False,
index=False)
def train(model,
criterion,
converter,
device,
train_datasets,
valid_datasets=None,
pretrain=False):
print('Device:', device)
'''
data_parallel = False
if torch.cuda.device_count() > 1:
print("Use", torch.cuda.device_count(), 'gpus')
data_parallel = True
model = nn.DataParallel(model)
'''
model = model.to(device)
if pretrain:
#print("Using pretrained model")
'''
state_dict = torch.load("/home/chen-ubuntu/Desktop/checks_dataset/pths/crnn_pertrain.pth", map_location=device)
cnn_modules = {}
rnn_modules = {}
for module in state_dict:
if module.split('.')[1] == 'FeatureExtraction':
key = module.replace("module.FeatureExtraction.", "")
cnn_modules[key] = state_dict[module]
elif module.split('.')[1] == 'SequenceModeling':
key = module.replace("module.SequenceModeling.", "")
rnn_modules[key] = state_dict[module]
model.cnn.load_state_dict(cnn_modules)
model.rnn.load_state_dict(rnn_modules)
'''
#model.load_state_dict(torch.load('/root/checks_recognize_v2/pths/hand_num_epoch278_acc0.995020.pth'))
dataset_name = 'symbol'
batch_dict = {
'print_word': 32,
'hand_num': 48,
'print_num': 48,
'symbol': 64,
'hand_word': 64,
'seal': 64,
'catword': 32
}
dataset = train_datasets.get(dataset_name)
dataloader = DataLoader(dataset,
batch_size=batch_dict.get(dataset_name),
shuffle=True,
num_workers=4,
drop_last=False)
lr = 1e-3
params = model.parameters()
optimizer = optim.Adam(params, lr)
optimizer.zero_grad()
batch_cnt = 0
for epoch in range(config.epochs):
epoch_loss = 0
model.train()
train_acc = 0
train_acc_cnt = 0
for i, (img, label, _) in enumerate(dataloader):
n_correct = 0
batch_cnt += 1
train_acc_cnt += 1
img = img.to(device)
text, length = converter.encode(label)
preds = model(img)
preds_size = torch.IntTensor([preds.size(0)] * img.size(0))
preds = preds.to('cpu')
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)
list1 = [x for x in label]
for pred, target in zip(sim_preds, list1):
if pred == target:
n_correct += 1
# loss.backward()
# optimizer.step()
# model.zero_grad()
loss.backward()
if (i + 1) % 4:
optimizer.step()
optimizer.zero_grad()
epoch_loss += loss.item()
train_acc += n_correct / len(list1)
if (i + 1) % 4 == 0:
print("epoch: {:<3d}, dataset:{:<8}, batch: {:<3d}, batch loss: {:4f}, epoch loss: {:4f}, acc: {}". \
format(epoch, dataset_name, i, loss.item(), epoch_loss, n_correct / len(list1)))
# writer.add_scalar('data/train_loss', loss.item(), batch_cnt)
# writer.add_scalar('data/train_acc', n_correct/len(list1), batch_cnt)
print('==========train_average_acc is: {:.3f}'.format(train_acc /
train_acc_cnt))
# writer.add_scalar('data/valid_{}acc'.format(dataset_name), train_acc/train_acc_cnt, batch_cnt)
if epoch % 3 == 0:
dataset_names = [dataset_name]
accs, valid_losses = valid(model, criterion, converter, device,
valid_datasets, dataset_names)
acc, valid_loss = accs.get(dataset_name), valid_losses.get(
dataset_name)
print('========== valid acc: ', acc, ' ============valid loss: ',
valid_loss)
# writer.add_scalar('data/valid_{}acc'.format(dataset_name), acc, batch_cnt)
# writer.add_scalar('data/valid_{}loss'.format(dataset_name), valid_loss, batch_cnt)
if epoch % 3 == 0:
state_dict = model.state_dict()
torch.save(
state_dict,
'/root/last_dataset/crnn_char_pths/catword_lr3_epoch_{}_acc{:4f}.pth'
.format(epoch + 1, train_acc / train_acc_cnt))
if train_acc / train_acc_cnt > 0.95:
state_dict = model.state_dict()
torch.save(
state_dict,
'/root/last_dataset/crnn_char_pths/catword_lr3_epoch{}_acc{:4f}.pth'
.format(epoch + 1, train_acc / train_acc_cnt))
def train(model, criterion, converter, device, pretrain=False):
imgdir_list = []
label_list = []
rootdir = '/home/chen-ubuntu/Desktop/checks_dataset/new_train_stamp_crop/'
for mode in ['new_crop', 'new_crop2', 'new_crop3']:
imgfile_dir = os.path.join(rootdir, mode)
imgs_files = sorted(os.listdir(imgfile_dir))
for img_file in imgs_files:
imgs_dir = os.path.join(imgfile_dir, img_file)
imgs = sorted(os.listdir(imgs_dir))
for img in imgs:
img_dir = os.path.join(imgs_dir, img)
imgdir_list.append(img_dir)
label_list.append(img[:-6])
if len(imgdir_list) != len(label_list):
print('dataset is wrong!')
np.random.seed(10)
state = np.random.get_state()
np.random.shuffle(imgdir_list)
np.random.set_state(state)
np.random.shuffle(label_list)
segment = len(imgdir_list) // 10
train_imgdirs = imgdir_list[:segment * 9]
train_labels = label_list[:segment * 9]
val_imgdirs = imgdir_list[segment * 9:]
val_labels = label_list[segment * 9:]
print('trainset: ', len(train_imgdirs))
print('validset: ', len(val_labels))
trainset = dataset_seal.BaseDataset(train_imgdirs,
train_labels,
transform=dataset_seal.img_enhancer,
_type='seal')
validset = dataset_seal.BaseDataset(val_imgdirs,
val_labels,
transform=dataset_seal.img_padder,
_type='seal')
print('Device:', device)
model = model.to(device)
if pretrain:
print("Using pretrained model")
'''
state_dict = torch.load("/home/chen-ubuntu/Desktop/checks_dataset/pths/crnn_pertrain.pth", map_location=device)
cnn_modules = {}
rnn_modules = {}
for module in state_dict:
if module.split('.')[1] == 'FeatureExtraction':
key = module.replace("module.FeatureExtraction.", "")
cnn_modules[key] = state_dict[module]
elif module.split('.')[1] == 'SequenceModeling':
key = module.replace("module.SequenceModeling.", "")
rnn_modules[key] = state_dict[module]
model.cnn.load_state_dict(cnn_modules)
model.rnn.load_state_dict(rnn_modules)
'''
model.load_state_dict(
torch.load(
'/home/chen-ubuntu/Desktop/checks_dataset/pths/seal_lr3_bat256_aug_epoch15_acc0.704862.pth'
))
dataloader = DataLoader(trainset,
batch_size=64,
shuffle=True,
num_workers=4,
drop_last=False)
'''
lr = 1e-3
params = model.parameters()
optimizer = optim.Adam(params, lr)
optimizer.zero_grad()
batch_cnt = 0
for epoch in range(config.epochs):
epoch_loss = 0
model.train()
train_acc = 0
train_acc_cnt = 0
for i, (img, label, _) in enumerate(dataloader):
n_correct = 0
batch_cnt += 1
train_acc_cnt += 1
img = img.to(device)
text, length = converter.encode(label)
preds = model(img)
preds_size = torch.IntTensor([preds.size(0)] * img.size(0))
preds = preds.to('cpu')
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)
list1 = [x for x in label]
for pred, target in zip(sim_preds, list1):
if pred == target:
n_correct += 1
# loss.backward()
# optimizer.step()
# model.zero_grad()
loss.backward()
if (i + 1) % 4:
optimizer.step()
optimizer.zero_grad()
epoch_loss += loss.item()
train_acc += n_correct / len(list1)
if (i + 1) % 4 == 0:
print("epoch: {:<3d}, batch: {:<3d}, batch loss: {:4f}, epoch loss: {:4f}, acc: {}". \
format(epoch, i, loss.item(), epoch_loss, n_correct / len(list1)))
writer.add_scalar('data/train_loss', loss.item(), batch_cnt)
writer.add_scalar('data/train_acc', n_correct / len(list1), batch_cnt)
'''
#print('train_average_acc is: {:.3f}'.format(train_acc / train_acc_cnt))
acc, valid_loss = valid(model, criterion, converter, device, validset)
'''
help='The gamma for lr')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
G, Adj, Node = dataset.Read_graph(args.input)
model = model.MNN(Node, args.nhid0, args.nhid1, args.dropout, args.alpha)
opt = optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=args.step_size, gamma=args.gamma)
Data = dataset.Dataload(Adj, Node)
Data = DataLoader(Data, batch_size=args.bs, shuffle=True, )
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)
model.train()
for epoch in range(1, args.epochs + 1):
loss_sum, loss_L1, loss_L2, loss_reg = 0, 0, 0, 0
for index in Data:
adj_batch = Adj[index]
adj_mat = adj_batch[:, index]
b_mat = torch.ones_like(adj_batch)
b_mat[adj_batch != 0] = args.beta
opt.zero_grad()
L_1st, L_2nd, L_all = model(adj_batch, adj_mat, b_mat)
L_reg = 0
for param in model.parameters():
L_reg += args.nu1 * torch.sum(torch.abs(param)) + args.nu2 * torch.sum(param * param)
Loss = L_all + L_reg
def train():
tb = SummaryWriter(comment=f"LR_{args.lr}_BS_{args.batch_size}")
images, labels = next(iter(train_loader))
grid = torchvision.utils.make_grid(images)
tb.add_image("image", grid)
tb.add_graph(model.to(device=device), images.to(device=device))
print("Batch Size: {} Learning Rate: {}".format(args.lr, args.batch_size))
for epoch in range(1, args.epochs + 1):
t1 = time.time()
batch_metrics = defaultdict(list)
batch_metrics = {
"iters": [],
"lrs": [],
"train_losses": [],
"val_losses": [],
"val_accuracies": [],
}
model.train()
for batch_idx, batch in enumerate(train_loader):
# prepare data
images = Variable(batch[0]).to(device=device)
targets = Variable(batch[1]).to(device=device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if args.vis and batch_idx % args.log_interval == 0 and images.shape[
0] == 1:
cv2.imshow("output: ", outputs.cpu().data.numpy()[0][0])
cv2.imshow("target: ", targets.cpu().data.numpy()[0][0])
cv2.waitKey(10)
if batch_idx % args.log_interval == 0:
val_loss, val_acc = evaluate("val", n_batches=args.val_size)
train_loss = loss.item()
batch_metrics["iters"].append(
len(train_loader.dataset) * (epoch - 1) + batch_idx)
batch_metrics["lrs"].append(lr)
batch_metrics["train_losses"].append(train_loss)
batch_metrics["val_losses"].append(val_loss)
batch_metrics["val_accuracies"].append(val_acc)
examples_this_epoch = batch_idx * len(images)
epoch_progress = 100.0 * batch_idx / len(train_loader)
print("Train Epoch: {} [{}/{} ({:.0f}%)]\t"
"Train Loss: {:.4f}\tVal Loss: {:.4}\tVal Acc: {:.4}".
format(
epoch,
examples_this_epoch,
len(train_loader.dataset),
epoch_progress,
train_loss,
val_loss,
val_acc,
))
print(
"epoch: {} total train_loss: {:.4f} total val_loss: {:.4f} total val_acc: {:.4f}"
.format(
epoch,
sum(batch_metrics["train_losses"]),
sum(batch_metrics["val_losses"]),
sum(batch_metrics["val_accuracies"]) /
len(batch_metrics["val_accuracies"]),
))
if epoch % args.save_interval == 0 and args.save_model:
save_path = os.path.join(backup_dir,
"IGVCModel" + "_" + str(epoch) + ".pt")
print("Saving model: %s" % save_path)
torch.save(model.state_dict(), save_path)
tb.add_scalar("train loss", sum(batch_metrics["train_losses"]), epoch)
tb.add_scalar("val loss", sum(batch_metrics["val_losses"]), epoch)
tb.add_scalar(
"val_acc",
sum(batch_metrics["val_accuracies"]) /
len(batch_metrics["val_accuracies"]),
epoch,
)
for name, weight in model.named_parameters():
tb.add_histogram(name, weight, epoch)
tb.add_histogram("{}.grad".format(name), weight.grad, epoch)
metrics_path = os.path.join(backup_dir, "metrics.npy")
np.save(metrics_path, batch_metrics)
t2 = time.time()
print("training time: %.2fs" % (t2 - t1))
tb.close()
test_size=0.2,
random_state=0)
print(len(train_dataset))
print(len(valid_dataset))
train_loader = DataLoader(
train_dataset, batch_size=BATCH_SIZE, shuffle=True,
num_workers=0) #Batch Size定义：一次训练所选取的样本数。 Batch Size的大小影响模型的优化程度和速度。
valid_loader = DataLoader(
valid_dataset, batch_size=BATCH_SIZE, shuffle=True,
num_workers=0) #Batch Size定义：一次训练所选取的样本数。 Batch Size的大小影响模型的优化程度和速度。
model = model.MobileNetV3_large()
model.load_state_dict(torch.load('weigths/best.pkl'))
model.conv4 = Conv2d(1280, 5, kernel_size=(1, 1),
stride=(1, 1)) #修改最后一层输出的分类个数
model.to(DEVICE)
optimizer = torch.optim.SGD(model.parameters(), lr=0.0001, momentum=0.9)
loss_func = torch.nn.CrossEntropyLoss()
avg_loss = []
avg_acc = []
def train(model, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = loss_func(output, target)
loss.backward()
optimizer.step()
