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()