def main(args): train_loader, val_loader = create_dataloaders(args.batch_size) model = Net().to(device) optim = torch.optim.Adam(model.parameters()) lr_schedule = torch.optim.lr_scheduler.ReduceLROnPlateau(optim, patience=1, verbose=True) criterion = torch.nn.CrossEntropyLoss() best_accuracy = 0 for epoch in range(1, args.epochs + 1): model.train() train_loss, train_accuracy = do_epoch(model, train_loader, criterion, optim=optim) model.eval() with torch.no_grad(): val_loss, val_accuracy = do_epoch(model, val_loader, criterion, optim=None) tqdm.write( f'EPOCH {epoch:03d}: train_loss={train_loss:.4f}, train_accuracy={train_accuracy:.4f} ' f'val_loss={val_loss:.4f}, val_accuracy={val_accuracy:.4f}') if val_accuracy > best_accuracy: print('Saving model...') best_accuracy = val_accuracy torch.save(model.state_dict(), 'trained_models/source.pt') lr_schedule.step(val_loss)
def main(args): if args.adapt_setting == 'svhn2mnist': target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) elif args.adapt_setting == 'mnist2usps': target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) else: raise NotImplementedError dataloader = DataLoader(target_dataset, batch_size=args.batch_size, shuffle=False, drop_last=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(dataloader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += (y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(dataloader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
def get_prediction(image_bytes): model = Net() model.load_state_dict(torch.load('model.pt', map_location='cpu'), strict=False) model.eval() tensor = transform_image(image_bytes=image_bytes) outputs = F.softmax(model(tensor), dim=1) top_p, top_class = outputs.topk(1, dim=1) return top_p, top_class
def main(): model = Net() model.load_state_dict(torch.load(checkpoint_path)) model.eval() tar = prep_data() output = model(Variable(tar)) res = output.cpu().data.numpy() res_ = np.squeeze(res) num = np.argwhere(res_ == np.max(res_)) print(int(num))
def main(): # load in a haar cascade classifier for detecting frontal faces face_cascade = cv2.CascadeClassifier( 'detector_architectures/haarcascade_frontalface_default.xml') model = Net() model.load_state_dict(torch.load('./saved_models/keypoints_model_1.pt')) model.eval() show_webcam(model, face_cascade)
def main(args): X_target, y_target = preprocess_test() target_dataset = torch.utils.data.TensorDataset(X_target, y_target) target_loader = DataLoader(target_dataset, batch_size=args.batch_size, shuffle=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(target_loader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += (y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(target_loader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
def main(): args = get_args() print(args) # set device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # device = 'cpu' transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) net = Net(device=device, mode=args.target, target_mode=args.target_mode) net = net.eval() net = net.to(device) load_model( net, device, fullpath='trained_models/Net_continuous_trained/checkpoint_274.pth.tar' ) imgs_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Real-Images/png' imgs_filelist = [ os.path.join(imgs_dir, img) for img in os.listdir(imgs_dir) if img.endswith('.png') ] for i, img in enumerate(imgs_filelist): # x,x_paths, y, y_paths = data x = plt.imread(img) x = np.expand_dims(x, 0) x = np.transpose(x, (0, 3, 1, 2)) x = x[:, :, 2:-2, 8:-8] x = torch.Tensor(x).to(device) with torch.no_grad(): out = net(x) out = out.detach().cpu().numpy() x = x.detach().cpu().numpy() plt.figure(1) if args.target_mode == 'discrete': out = np.argmax(out, axis=1) out = out[0] # out = np.squeeze(out,0) out = (out - np.min(out)) / (np.max(out) - np.min(out)) ax1 = plt.subplot(1, 3, 1) # x = (x + 1) / 2 ax1.imshow(np.transpose(x[0], (1, 2, 0))) ax3 = plt.subplot(1, 3, 3, sharex=ax1, sharey=ax1) ax3.imshow(out, cmap='jet') # plt.suptitle(label, fontsize="large") plt.show()
def pred_homography(batch, patch_size, model_file='homography_model.pytorch', scale=32): device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') batch = normalize_batch(batch).to(device) net = Net() net.load_state_dict(torch.load(model_file)) net.eval().to(device) with torch.no_grad(): output = net(batch).detach().cpu().numpy() * scale mean_shift = np.mean(output, axis=0) pts1 = np.float32( [0, 0, patch_size, 0, patch_size, patch_size, 0, patch_size]).reshape(-1, 1, 2) pts2 = mean_shift.reshape(-1, 1, 2) + pts1 h = np.linalg.inv(cv2.findHomography(pts1, pts2)[0]) return h
def main(args): dataset = MNISTM(train=False) dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, drop_last=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(dataloader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += ( y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(dataloader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
def train(options): exp_name = options['exp_name'] batch_size = options['batch_size'] use_pca = options['use_pca'] model_type = options['model_type'] loss_fn = options['loss_fn'] optim = options['optim'] use_scheduler = options['use_scheduler'] lr = options['lr'] epochs = options['epochs'] pca_var_hold = options['pca_var_hold'] debug_mode = options['debug_mode'] if os.path.exists(exp_name): shutil.rmtree(exp_name) time.sleep(1) writer = SummaryWriter(exp_name,flush_secs=1) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") X = os.listdir('hilbert_data') X_train = X[:int(0.8*len(X))] X_test = X[int(0.8*len(X)):] # X = np.load('bined_x.npy') # y = np.load('bined_y.npy') # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # if use_pca and 'Raw' in exp_name: # scaler = PCA(pca_var_hold) # scaler.fit(X_train) # X_train = scaler.transform(X_train) # X_test = scaler.transform(X_test) # needed_dim = X_train.shape[1] dataset_train = HIL_MOOD(X_train, model_type=model_type,data_type='train',debug_mode=debug_mode) train_loader = DataLoader(dataset=dataset_train, batch_size=batch_size, shuffle=True) dataset_val = HIL_MOOD(X_test, model_type=model_type,data_type='val') valid_loader = DataLoader(dataset=dataset_val, batch_size=batch_size, shuffle=False) model = Net() model.to(device) if optim == None: print('you need to specify an optimizer') exit() elif optim == 'adam': optimizer = torch.optim.Adam( model.parameters(), lr=lr) elif optim == 'sgd': optimizer = torch.optim.SGD( model.parameters(), lr=lr,momentum=0.9) if use_scheduler: scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min',verbose=True,threshold=0.0001,patience = 10) if loss_fn == None: print('you need to specify an optimizer') exit() else: if loss_fn == 'mse': loss_fn = torch.nn.MSELoss() elif loss_fn == 'cross_entropy': loss_fn = torch.nn.CrossEntropyLoss() mean_train_losses = [] mean_valid_losses = [] valid_acc_list = [] best = 0 #small number for acc big number for loss to save a model for epoch in range(epochs): model.train() train_losses = [] valid_losses = [] for i, (images, labels) in enumerate(train_loader): if images.shape[0] != batch_size: continue images = images.to(device) labels = labels.to(device) optimizer.zero_grad() # print(images.shape) outputs = model(images) # print(images.shape) # print(outputs.shape) # print(labels.shape) # print(i) loss =loss_fn(outputs,labels) # print('loss: ',loss.item()) writer.add_scalar('Loss/train', loss.item(), len(train_loader)*epoch+i) loss.backward() optimizer.step() train_losses.append(loss.item()) del outputs # if (i * batch_size) % (batch_size * 100) == 0: # print(f'{i * batch_size} / 50000') model.eval() correct_5_2 = 0 correct_5_1 = 0 total_loss = 0 total = 0 accsat =[0.5,0.05,0.005] accs = np.zeros(len(accsat)) # corrs = np.zeros(len(accsat)) correct_array = np.zeros(len(accsat)) with torch.no_grad(): for i, (images, labels) in enumerate(valid_loader): images = images.to(device) labels = labels.to(device) outputs = model(images) loss = loss_fn(outputs, labels) for i in range(len(accsat)): correct_array[i] += accat(outputs,labels,thresh=accsat[i]) # total_loss += loss.item() total += labels.size(0) valid_losses.append(loss.item()) mean_train_losses.append(np.mean(train_losses)) mean_valid_losses.append(np.mean(valid_losses)) # scheduler.step(np.mean(valid_losses)) for i in range(len(accsat)): accs[i] = 100*correct_array[i]/total writer.add_scalar('Acc/val_@'+str(accsat[i]), accs[i], epoch) if np.mean(valid_losses) < best: best = np.mean(valid_losses) torch.save(model.state_dict(),os.path.join(os.getcwd(),'models','meh.pth')) writer.add_scalar('Loss/val', np.mean(valid_losses), epoch) # valid_acc_list.append(accuracy) if epoch ==epochs-1: print('epoch : {}, train loss : {:.4f}, valid loss : {:.4f}, [email protected] : {:.4f}'\ .format(epoch+1, np.mean(train_losses), np.mean(valid_losses), accsat[1]))
def main(args): source_model = Net().to(device) source_model.load_state_dict(torch.load(args.MODEL_FILE)) source_model.eval() set_requires_grad(source_model, requires_grad=False) clf = source_model source_model = source_model.feature_extractor target_model = Net().to(device) target_model.load_state_dict(torch.load(args.MODEL_FILE)) target_model = target_model.feature_extractor target_clf = clf.classifier discriminator = nn.Sequential(nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 1)).to(device) half_batch = args.batch_size // 2 source_dataset = MNIST(config.DATA_DIR / 'mnist', train=True, download=True, transform=Compose([GrayscaleToRgb(), ToTensor()])) source_loader = DataLoader(source_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) target_dataset = MNISTM(train=False) target_loader = DataLoader(target_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) discriminator_optim = torch.optim.Adam(discriminator.parameters()) target_optim = torch.optim.Adam(target_model.parameters()) criterion = nn.BCEWithLogitsLoss() for epoch in range(1, args.epochs + 1): batch_iterator = zip(loop_iterable(source_loader), loop_iterable(target_loader)) total_loss = 0 total_accuracy = 0 target_label_accuracy = 0 for _ in trange(args.iterations, leave=False): # Train discriminator set_requires_grad(target_model, requires_grad=False) set_requires_grad(discriminator, requires_grad=True) for _ in range(args.k_disc): (source_x, _), (target_x, _) = next(batch_iterator) source_x, target_x = source_x.to(device), target_x.to(device) source_features = source_model(source_x).view( source_x.shape[0], -1) target_features = target_model(target_x).view( target_x.shape[0], -1) discriminator_x = torch.cat([source_features, target_features]) discriminator_y = torch.cat([ torch.ones(source_x.shape[0], device=device), torch.zeros(target_x.shape[0], device=device) ]) preds = discriminator(discriminator_x).squeeze() loss = criterion(preds, discriminator_y) discriminator_optim.zero_grad() loss.backward() discriminator_optim.step() total_loss += loss.item() total_accuracy += (( preds > 0).long() == discriminator_y.long()).float().mean().item() # Train classifier set_requires_grad(target_model, requires_grad=True) set_requires_grad(discriminator, requires_grad=False) for _ in range(args.k_clf): _, (target_x, target_labels) = next(batch_iterator) target_x = target_x.to(device) target_features = target_model(target_x).view( target_x.shape[0], -1) # flipped labels discriminator_y = torch.ones(target_x.shape[0], device=device) preds = discriminator(target_features).squeeze() loss = criterion(preds, discriminator_y) target_optim.zero_grad() loss.backward() target_optim.step() target_label_preds = target_clf(target_features) target_label_accuracy += (target_label_preds.cpu().max(1)[1] == target_labels).float().mean().item() mean_loss = total_loss / (args.iterations * args.k_disc) mean_accuracy = total_accuracy / (args.iterations * args.k_disc) target_mean_accuracy = target_label_accuracy / (args.iterations * args.k_clf) tqdm.write( f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, ' f'discriminator_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}' ) # Create the full target model and save it clf.feature_extractor = target_model torch.save(clf.state_dict(), 'trained_models/adda.pt')
def main(args): source_model = Net().to(device) source_model.load_state_dict(torch.load(args.MODEL_FILE)) source_model.eval() set_requires_grad(source_model, requires_grad=False) clf = source_model source_model = source_model.feature_extractor target_model = Net().to(device) target_model.load_state_dict(torch.load(args.MODEL_FILE)) target_model = target_model.feature_extractor classifier = clf.classifier discriminator = nn.Sequential(nn.Linear(EXTRACTED_FEATURE_DIM, 64), nn.ReLU(), nn.BatchNorm1d(64), nn.Linear(64, 1), nn.Sigmoid()).to(device) #half_batch = args.batch_size // 2 batch_size = args.batch_size # X_source, y_source = preprocess_train() X_source, y_source = preprocess_train_single(1) source_dataset = torch.utils.data.TensorDataset(X_source, y_source) source_loader = DataLoader(source_dataset, batch_size=batch_size, shuffle=False, num_workers=1, pin_memory=True) X_target, y_target = preprocess_test(args.person) target_dataset = torch.utils.data.TensorDataset(X_target, y_target) target_loader = DataLoader(target_dataset, batch_size=batch_size, shuffle=False, num_workers=1, pin_memory=True) discriminator_optim = torch.optim.Adam(discriminator.parameters()) target_optim = torch.optim.Adam(target_model.parameters(), lr=3e-6) criterion = nn.BCEWithLogitsLoss() criterion_class = nn.CrossEntropyLoss() best_tar_acc = test(args, clf) final_accs = [] for epoch in range(1, args.epochs + 1): source_loader = DataLoader(source_loader.dataset, batch_size=batch_size, shuffle=True) target_loader = DataLoader(target_loader.dataset, batch_size=batch_size, shuffle=True) batch_iterator = zip(loop_iterable(source_loader), loop_iterable(target_loader)) total_loss = 0 adv_loss = 0 total_accuracy = 0 second_acc = 0 total_class_loss = 0 for _ in trange(args.iterations, leave=False): # Train discriminator set_requires_grad(target_model, requires_grad=False) set_requires_grad(discriminator, requires_grad=True) discriminator.train() for _ in range(args.k_disc): (source_x, source_y), (target_x, _) = next(batch_iterator) source_y = source_y.to(device).view(-1) source_x, target_x = source_x.to(device), target_x.to(device) source_features = source_model(source_x).view( source_x.shape[0], -1) target_features = target_model(target_x).view( target_x.shape[0], -1) discriminator_x = torch.cat([source_features, target_features]) discriminator_y = torch.cat([ torch.ones(source_x.shape[0], device=device), torch.zeros(target_x.shape[0], device=device) ]) preds = discriminator(discriminator_x).squeeze() loss = criterion(preds, discriminator_y) discriminator_optim.zero_grad() loss.backward() discriminator_optim.step() total_loss += loss.item() total_accuracy += ((preds >= 0.5).long() == discriminator_y. long()).float().mean().item() # Train feature extractor set_requires_grad(target_model, requires_grad=True) set_requires_grad(discriminator, requires_grad=False) target_model.train() for _ in range(args.k_clf): _, (target_x, _) = next(batch_iterator) target_x = target_x.to(device) target_features = target_model(target_x).view( target_x.shape[0], -1) source_features = target_model(source_x).view( source_x.shape[0], -1) source_pred = classifier(source_features) # (batch_size, 4) # flipped labels discriminator_y = torch.ones(target_x.shape[0], device=device) preds = discriminator(target_features).squeeze() second_acc += ((preds >= 0.5).long() == discriminator_y.long() ).float().mean().item() loss_adv = criterion(preds, discriminator_y) adv_loss += loss_adv.item() loss_class = criterion_class(source_pred, source_y) total_class_loss += loss_class.item() loss = loss_adv #+ 0.001*loss_class target_optim.zero_grad() loss.backward() target_optim.step() mean_loss = total_loss / (args.iterations * args.k_disc) mean_adv_loss = adv_loss / (args.iterations * args.k_clf) total_class_loss = total_class_loss / (args.iterations * args.k_clf) dis_accuracy = total_accuracy / (args.iterations * args.k_disc) sec_acc = second_acc / (args.iterations * args.k_clf) clf.feature_extractor = target_model tar_accuarcy = test(args, clf) final_accs.append(tar_accuarcy) if tar_accuarcy > best_tar_acc: best_tar_acc = tar_accuarcy torch.save(clf.state_dict(), 'trained_models/adda.pt') tqdm.write( f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, adv_loss = {mean_adv_loss:.4f}, ' f'discriminator_accuracy={dis_accuracy:.4f}, tar_accuary = {tar_accuarcy:.4f}, best_accuracy = {best_tar_acc:.4f}, ' f'sec_acc = {sec_acc:.4f}, total_class_loss: {total_class_loss:.4f}' ) # Create the full target model and save it clf.feature_extractor = target_model #torch.save(clf.state_dict(), 'trained_models/adda.pt') jd = {"test_acc": final_accs} with open(str(args.seed) + '/acc' + str(args.person) + '.json', 'w') as f: json.dump(jd, f)
class Trainer(object): def __init__(self, train_loader, test_loader, config): self.config = config self.device = config.device self.train_loader = train_loader self.test_loader = test_loader self.n_epoch = config.n_epoch self.lr = config.lr self.gamma = config.gamma self.device = config.device # self.start_epoch = 1 self.start_itr = 1 n_classes = len(self.train_loader.dataset.classes) self.model = Net(n_classes=n_classes).to(self.device) print(self.model) print('Initialized model...\n') self.optim = torch.optim.Adadelta(self.model.parameters(), self.lr) self.scheduler = StepLR(self.optim, step_size=1, gamma=self.gamma) # if not self.config.model_state_path == '': # self._load_models(self.config.model_state_path) self.writer = SummaryWriter(log_dir=self.config.log_dir) def train(self): self.model.train() n_itr = self.start_itr print('Start training...!') for epoch in range(1, self.n_epoch + 1): with tqdm(total=len(self.train_loader)) as pbar: for idx, (img, label) in enumerate(self.train_loader): pbar.set_description( f'Epoch[{epoch}/{self.n_epoch}], iteration[{idx}/{len(self.train_loader)}]' ) img, label = img.to(self.device), label.to(self.device) self.optim.zero_grad() output = self.model(img) loss = F.nll_loss(output, label) loss.backward() self.optim.step() if n_itr % self.config.log_interval == 0: pbar.set_postfix(OrderedDict(loss=loss.item())) tqdm.write( f'Epoch[{epoch}], iteration[{idx}/{len(self.train_loader)}], loss: {loss.item()}' ) self.writer.add_scalar('loss/loss', loss.item(), n_itr) if n_itr % self.config.checkpoint_interval == 0: self._save_models(epoch, n_itr) n_itr += 1 pbar.update() self.scheduler.step() self.test(n_itr) self.writer.close() def test(self, n_itr): self.model.eval() test_loss = 0 correct = 0 print('Start testing...!') with torch.no_grad(): for _, (img, label) in enumerate(self.test_loader): img, label = img.to(self.device), label.to(self.device) output = self.model(img) test_loss += F.nll_loss(output, label, reduction='sum').item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(label.view_as(pred)).sum().item() test_loss /= len(self.test_loader.dataset) accuracy = correct / len(self.test_loader.dataset) self.writer.add_scalar('accuracy/test_accuracy', accuracy, n_itr) tqdm.write( f'Test: Average loss: {test_loss}, Accuracy: {accuracy * 100.0}%') self.model.train() def _save_models(self, epoch, n_itr): checkpoint_name = f'{self.config.dataset_name}_model_ckpt_{n_itr}.pt' checkpoint_path = os.path.join(self.config.checkpoint_dir, checkpoint_name) torch.save( { # 'epoch': epoch, 'n_itr': n_itr, 'model': self.model.state_dict(), 'optim': self.optim.state_dict(), }, checkpoint_path) tqdm.write(f'Saved models state_dict: n_itr_{n_itr}') def _load_models(self, model_state_path): checkpoint = torch.load(model_state_path) # self.start_epoch = checkpoint['epoch'] self.start_itr = checkpoint['n_itr'] + 1 self.model.load_state_dict(checkpoint['model']) self.optim.load_state_dict(checkpoint['optim']) print(f'start_itr: {self.start_itr}') print('Loaded pretrained models...\n')
# 利用已有的训练好的检测器检测人脸 face_cascade = cv2.CascadeClassifier( 'detector_architectures/haarcascade_frontalface_default.xml') faces = face_cascade.detectMultiScale(image, 1.2, 2) # image_with_detections = image.copy() # for (x, y, w, h) in faces: # cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (255, 0, 0), 3) # fig = plt.figure(figsize=(9, 9)) # plt.imshow(image_with_detections) # 利用自己训练的网络进行 # 1 加载训练好的网络 net = Net() net.load_state_dict( torch.load('./saved_models/krunal_keypoints_model_lr0001_epoch20.pt')) print(net.eval()) def show_points(image_test, key_points): """ 显示检测结果 :param image_test: :param key_points: :return: """ plt.figure() key_points = key_points.data.numpy() key_points = key_points * 60.0 + 68 key_points = np.reshape(key_points, (68, -1)) plt.imshow(image_test, cmap='gray') plt.scatter(key_points[:, 0], key_points[:, 1], s=50, marker='.', c='r')
def main(): args = get_args() print(args) # set device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") test_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Sintel/Filtered/rgb' label_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Sintel/Filtered/GT' test_filelist = [ os.path.join(test_dir, img) for img in os.listdir(test_dir) if 'alley_1' in img ] test_labels_filelist = [ img.replace(test_dir, label_dir).replace('_1100_maskImg.png', '_GT.dpt') for img in test_filelist ] transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) test_dataset = Dataset(image_filelist=test_filelist, label_filelist=test_labels_filelist, transforms=transform, pickle_name='test.pickle', train=False) test_data_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=True, num_workers=8) net = Net(device=device, mode=args.target, target_mode=args.target_mode) net = net.eval() net = net.to(device) load_model( net, device, fullpath= '/home/yotamg/PycharmProjects/dfd/trained_models/Net_default/checkpoint_76.pth.tar' ) for i, data in enumerate(test_data_loader): # x,x_paths, y, y_paths = data x, x_path, y, y_path = data x = x.to(device) with torch.no_grad(): out = net(x) out = out.detach().cpu().numpy() x = x.detach().cpu().numpy() plt.figure(1) out = np.argmax(out, axis=1) out = np.squeeze(out, 0) out = (out - np.min(out)) / (np.max(out) - np.min(out)) ax1 = plt.subplot(1, 3, 2) ax1.imshow(y[0]) ax2 = plt.subplot(1, 3, 1, sharex=ax1, sharey=ax1) x = (x + 1) / 2 ax2.imshow(np.transpose(x[0], (1, 2, 0))) ax3 = plt.subplot(1, 3, 3, sharex=ax1, sharey=ax1) ax3.imshow(out) # plt.suptitle(label, fontsize="large") plt.show()
loss.backward() optimizer.step() #记录误差 一个数 loss_tr += loss.item() #累计当前批次的损失 loss_tr_epoch = loss_tr / len(loader_tr) print(f'train done. {process_time()- start} sec, loss={loss_tr_epoch:.4f}') losses_tr.append(loss_tr_epoch) # 保存loss的数据与epoch数值 writer.add_scalar('Train', loss_tr_epoch, epoch) loss_ts = 0 #改成eval模式 model.eval() for data in loader_ts: #x y 送入 gpu data = data.to(device) out = model(data) #print(out[0,:]) #print(data.y[0,:]) loss = criterion(out, data.y) #记录误差 一个数 loss_ts += loss.item() #累计当前批次的损失 loss_ts_epoch = loss_ts / len(loader_ts) print(f'test sec, loss={loss_ts_epoch:.4f}')
def train(data_folder, output_folder, es_patience, epochs, TTA): device = torch.device('cuda' if torch.cuda.is_available() else "cpu") print("使用デバイス:", device) train = pd.read_csv(data_folder + '/train.csv') test = pd.read_csv(data_folder + '/test.csv') arch = EfficientNet.from_pretrained('efficientnet-b1') #モデル meta_features = list(train.columns) meta_features.remove('image_name') meta_features.remove('target') meta_features.remove('fold') #パラメータ各種 oof = np.zeros((len(train), 1)) preds = torch.zeros((len(test), 1), dtype=torch.float32, device=device) skf = KFold(n_splits=5, shuffle=True, random_state=47) #=========================== # ループスタート #=========================== for fold, (idxT, idxV) in enumerate(skf.split(np.arange(15)), 1): print('=' * 20, 'Fold', fold, '=' * 20) #kfold train_idx = train.loc[train['fold'].isin(idxT)].index val_idx = train.loc[train['fold'].isin(idxV)].index #学習パラメータ model_path = f'/model_{fold}.pth' best_val = 0 patience = es_patience model = Net(arch=arch, n_meta_features=len(meta_features)) model = model.to(device) #optimizer optim = torch.optim.Adam(model.parameters(), lr=0.001) #scheduler scheduler = ReduceLROnPlateau(optimizer=optim, mode='max', patience=1, verbose=True, factor=0.2) criterion = nn.BCEWithLogitsLoss() trainDataset = MelanomaDataset( df=train.iloc[train_idx].reset_index(drop=True), imfolder=data_folder + '/train', train=True, transforms=train_transform, meta_features=meta_features) valDataset = MelanomaDataset( df=train.iloc[val_idx].reset_index(drop=True), imfolder=data_folder + '/train', train=True, transforms=test_transform, meta_features=meta_features) testDataset = MelanomaDataset(df=test, imfolder=data_folder + '/test', train=False, transforms=test_transform, meta_features=meta_features) train_loader = DataLoader(dataset=trainDataset, batch_size=64, shuffle=True, num_workers=2) val_loader = DataLoader(dataset=valDataset, batch_size=16, shuffle=False, num_workers=2) test_loader = DataLoader(dataset=testDataset, batch_size=16, shuffle=False, num_workers=2) #===================== # epochs #===================== for epoch in range(epochs): start_time = time.time() correct = 0 epoch_loss = 0 #train_loop model.train() for x, y in train_loader: x[0] = torch.tensor(x[0], device=device, dtype=torch.float32) x[1] = torch.tensor(x[1], device=device, dtype=torch.float32) y = torch.tensor(y, device=device, dtype=torch.float32) optim.zero_grad() z = model(x) loss = criterion(z, y.unsqueeze(1)) loss.backward() optim.step() pred = torch.round(torch.sigmoid(z)) correct += (pred.cpu() == y.cpu().unsqueeze(1)).sum().item() epoch_loss += loss.item() train_acc = correct / len(train_idx) model.eval() val_preds = torch.zeros((len(val_idx), 1), dtype=torch.float32, device=device) with torch.no_grad(): #validation_loop for j, (x_val, y_val) in enumerate(val_loader): x_val[0] = torch.tensor(x_val[0], device=device, dtype=torch.float32) x_val[1] = torch.tensor(x_val[1], device=device, dtype=torch.float32) y_val = torch.tensor(y_val, device=device, dtype=torch.float32) z_val = model(x_val) val_pred = torch.sigmoid(z_val) val_preds[j * val_loader.batch_size:j * val_loader.batch_size + x_val[0].shape[0]] = val_pred val_acc = accuracy_score(train.iloc[val_idx]['target'].values, torch.round(val_preds.cpu())) val_roc = roc_auc_score(train.iloc[val_idx]['target'].values, val_preds.cpu()) print( 'Epoch{:03}: | Loss:{:.3f} | Train acc:{:.3f} | Val acc:{:.3f} | Val roc_auc:{:.3f} | Training time:{}' .format( epoch + 1, epoch_loss, train_acc, val_acc, val_roc, str( datetime.timedelta(seconds=time.time() - start_time))[:7])) scheduler.step(val_roc) if val_roc >= best_val: best_val = val_roc patience = es_patience torch.save(model, output_folder + model_path) else: patience -= 1 if patience == 0: print('Early stopping. Best Val roc_auc:{:.3f}'.format( best_val)) break model = torch.load(output_folder + model_path) model.eval() val_preds = torch.zeros((len(val_idx), 1), dtype=torch.float32, device=device) #evaluation loop with torch.no_grad(): for j, (x_val, y_val) in enumerate(val_loader): x_val[0] = torch.tensor(x_val[0], device=device, dtype=torch.float32) x_val[1] = torch.tensor(x_val[1], device=device, dtype=torch.float32) y_val = torch.tensor(y_val, device=device, dtype=torch.float32) z_val = model(x_val) val_pred = torch.sigmoid(z_val) val_preds[j * val_loader.batch_size:j * val_loader.batch_size + x_val[0].shape[0]] = val_pred oof[val_idx] = val_preds.cpu().numpy() for _ in range(TTA): for i, x_test in enumerate(test_loader): x_test[0] = torch.tensor(x_test[0], device=device, dtype=torch.float32) x_test[1] = torch.tensor(x_test[1], device=device, dtype=torch.float32) z_test = model(x_test) z_test = torch.sigmoid(z_test) preds[i * test_loader.batch_size:i * test_loader.batch_size + x_test[0].shape[0]] += z_test preds /= TTA preds /= skf.n_splits return preds, oof
def test(pathModel, nnClassCount, testTensor, trBatchSize): print("\n\n\n") print("Inside test funtion") CLASS_NAMES = ['Broken', 'Normal'] # cudnn.benchmark = True model = Net() # model = model.cuda() # -------------------- SETTINGS: NETWORK ARCHITECTURE, MODEL LOAD print("Is model==None:", model is None) print("Is pathModel==None:", pathModel is None) # cudnn.benchmark = True # if pathModel!=None: # model = Trainer.loadModel(nnArchitecture, nnClassCount, nnIsTrained) # #model = torch.nn.DataParallel(model) # model.to(device) if os.path.isfile(pathModel): print("=> loading checkpoint: ", pathModel) modelCheckpoint = torch.load(pathModel, map_location='cpu') model.load_state_dict(modelCheckpoint['state_dict'], strict=False) print("=> loaded checkpoint: ", pathModel) else: print("=> no checkpoint found: ") print( "\n============================ Loading data into RAM ======================================== " ) testImage = testTensor testSize = testImage.size()[0] print( "============================= Evaluation of model starts ====================================" ) model.eval() broken = 0 normal = 0 batchID = 1 with torch.no_grad(): for i in range(0, testSize, trBatchSize): if (batchID % 1) == 0: print("batchID:" + str(batchID) + '/' + str(testImage.size()[0] / trBatchSize)) if i + trBatchSize >= testSize: input = testImage[i:] else: input = testImage[i:i + trBatchSize] input = trans_test(input) input = input.type(torch.FloatTensor) varInput = torch.autograd.Variable(input) out = model(varInput) _, predicted = torch.max(out.data, 1) print(predicted) if i + trBatchSize <= testSize: for k in range(trBatchSize): if (predicted[k] == 1): normal += 1 elif (predicted[k] == 0): broken += 1 else: for k in range(testSize % trBatchSize): if (predicted[k] == 1): normal += 1 elif (predicted[k] == 0): broken += 1 batchID += 1 print(' Number of broken grains in sample : ', broken) print(' Number of normal grains in sample :', normal)
def main(): # file_structure = check_directories() # if file_structure == -1: # print('\nERROR: Directories can\'t be created, error thrown') # return -1 # else: # print('\nDirectories created successfully...\nLaunching camera module...') net = Net() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # # dev = torch.cuda.is_available() # # Assume that we are on a CUDA machine, then this should print a CUDA device: # # print(dev) net.to(device) net.load_state_dict(torch.load('saved_models/keypoints_model_2.pt')) ## print out your net and prepare it for testing (uncomment the line below) net.eval() # net.load_state_dict(torch.load('saved_models/keypoints_model_2.pt')) # Fire camera & launch streams # pyrs.start() serv = pyrs.Service() # cam = pyrs.Device(device_id = 0, streams = [pyrs.stream.ColorStream(fps=60), # pyrs.stream.DepthStream(fps=60), # pyrs.stream.CADStream(fps=60), # pyrs.stream.DACStream(fps=60)]) cam = serv.Device( device_id=0, streams=[ pyrs.stream.ColorStream(fps=60), # pyrs.stream.DepthStream(fps=60), # pyrs.stream.CADStream(fps=60), # pyrs.stream.DACStream(fps=60) ]) # scale = cam.depth_scale # Some important variables flag_save_frames = False # file_num = 0 # cap = cv2.VideoCapture(0) # Define the codec and create VideoWriter object # fourcc = cv2.cv.CV_FOURCC(*'DIVX') # out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480)) # out = cv2.VideoWriter('./output.avi', -1, 20.0, (640, 480)) # Define the codec and create VideoWriter object.The output is stored in 'outpy.avi' file. out = cv2.VideoWriter('output_4.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 20, (640, 480)) # Start fetching Buffer print('Starting Buffer...') i = 1000 while (i): cam.wait_for_frames() image_1 = cam.color[:, :, ::-1] gray_1 = cv2.cvtColor(image_1, cv2.COLOR_RGB2GRAY) face_cascade = cv2.CascadeClassifier( 'detector_architectures/haarcascade_frontalface_default.xml') faces_1 = face_cascade.detectMultiScale(gray_1, 1.1, 5) # make a copy of the original image to plot detections on image_with_detections_1 = image_1.copy() # loop over the detected faces, mark the image where each face is found for (x, y, w, h) in faces_1: # face = gray_1 roi = gray_1[y:y + int(h), x:x + int(w)] org_shape = roi.shape roi = roi / 255.0 roi = cv2.resize(roi, (224, 224)) # image_plot = np.copy(roi) roi = roi.reshape(roi.shape[0], roi.shape[1], 1) roi = np.transpose(roi, (2, 0, 1)) roi = torch.from_numpy(roi) roi = Variable(roi) roi = roi.type(torch.cuda.FloatTensor) roi = roi.unsqueeze(0) predicted_key_pts = net(roi) predicted_key_pts = predicted_key_pts.view(68, -1) predicted_key_pts = predicted_key_pts.data predicted_key_pts = predicted_key_pts.cpu().numpy() predicted_key_pts = predicted_key_pts * 50.0 + 100 predicted_key_pts[:, 0] = predicted_key_pts[:, 0] * org_shape[ 0] / 224 + x predicted_key_pts[:, 1] = predicted_key_pts[:, 1] * org_shape[ 1] / 224 + y # cv2.rectangle(image_with_detections_1, (x, y), (x + w, y + h), (0, 0, 255), 3) for (x_point, y_point) in zip(predicted_key_pts[:, 0], predicted_key_pts[:, 1]): cv2.circle(image_with_detections_1, (x_point, y_point), 3, (0, 255, 0), -1) # current_color = cam.color[:, :, ::-1] # current_depth = cam.depth * scale # current_cad = cam.cad[:, :, ::-1] # current_dac = cam.dac * scale out.write(image_with_detections_1) cv2.imshow('Color', image_with_detections_1) # cv2.imshow('Depth', current_depth) # cv2.imshow('CAD', current_cad) # cv2.imshow('DAC', current_dac) # if flag_save_frames: # num = format(file_num, '08') # cv2.imwrite('./data/depth/' + str(num) + '.png', cam.depth) # cv2.imwrite('./data/color/' + str(num) + '.png', current_color) # cv2.imwrite('./data/dac/' + str(num) + '.png', cam.dac) # cv2.imwrite('./data/cad/' + str(num) + '.png', current_cad) # file_num += 1 i = i - 1 k = cv2.waitKey(1) if k == ord('q'): print('Q Pressed...\nEnding execution') break if k == ord('f'): if flag_save_frames: print('F Pressed...\nStopped fetching frames...') flag_save_frames = False else: print('F Pressed...\nStarted fetching frames...') flag_save_frames = True cam.stop() # pyrs.stop() out.release() serv.stop() return 0
import cv2 import torch from torch.utils.data import DataLoader from torchvision import transforms from data_load import FacialKeypointsDataset, Rescale, RandomCrop, Normalize, ToTensor from models import Net net = Net() net.load_state_dict( torch.load( r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontaltrainedmodel_10epoch.pth' )) ## print out your net and prepare it for testing (uncomment the line below) net.eval() data_transform = transforms.Compose( [Rescale(225), RandomCrop(224), Normalize(), ToTensor()]) transformed_dataset = FacialKeypointsDataset( csv_file= r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontalpoints.csv', root_dir= r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\ceasar_mat', transform=data_transform) # load training data in batches batch_size = 10 train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True,
class NNet(): """ Wrapper to manage neural net. """ def __init__(self, args): self.args = args self.num_channels = NUM_CHANNELS if args.netType == 1: self.net = Net(self.num_channels, args) elif args.netType == 2: self.net = Net2(self.num_channels, args) if args.cuda: self.net = self.net.cuda() self.load_dataset_from_folder() self.writer = SummaryWriter() self.unique_tok = str(time.time()) self.init_weights() def init_weights(self): """ Initialize by Xavier weights """ self.net.apply(init_weights) def load_dataset_from_folder(self): """ Load complete dataset """ all_data_path = self.args.all_data_path validation_split_size = self.args.validation_split_size batch_size = self.args.batch_size num_workers = self.args.num_workers shuffle = self.args.shuffle all_data = ImageFolder(root=all_data_path, transform=TRANSFORM) classes = all_data.classes self.classes = classes validation_size = int(validation_split_size * len(all_data)) test_size = int(validation_split_size * len(all_data)) train_size = len(all_data) - 2 * validation_size train_dataset, val_dataset, test_dataset = random_split( all_data, [train_size, validation_size, test_size]) training_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) validation_dataset_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) test_dataset_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) self.train_loader = training_data_loader self.val_loader = validation_dataset_loader self.test_loader = test_dataset_loader def train(self): """ Train Neural Net """ if self.args.optim == 'RMSprop': optimizer = optim.RMSprop(self.net.parameters(), lr=self.args.lr, momentum=self.args.momentum, weight_decay=self.args.l2_regularization) elif self.args.optim == 'SGD': optimizer = optim.SGD(self.net.parameters(), lr=self.args.lr, momentum=self.args.momentum) elif self.args.optim == 'Adam': optimizer = optim.Adam(self.net.parameters(), lr=self.args.lr) criterion = nn.CrossEntropyLoss() # scheduler = optim.lr_scheduler.StepLR( # optimizer, step_size=self.args.scheduler_step_size, gamma=self.args.scheduler_gamma) self.net.train() for epoch in range(self.args.epoch): start_time = time.time() running_loss_t = 0.0 num_batches = 0 y_true = [] y_pred = [] # print('Epoch: {} , LR: {}'.format(epoch+1, scheduler.get_lr())) for data in tqdm(self.train_loader): inputs, labels = data labels_cp = labels.clone() # imshow(torchvision.utils.make_grid(inputs[:,:3,:,:])) if len(inputs) < 2: continue if self.args.cuda: inputs = inputs.cuda() labels = labels.cuda() outputs = self.net(inputs) loss = criterion(outputs, labels) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) optimizer.zero_grad() loss.backward() optimizer.step() running_loss_t += loss.item() num_batches += 1 end_time = time.time() train_f1 = f1_score(y_true, y_pred, average='weighted') # scheduler.step() self.save(epoch + 1) self.writer.add_scalar('Loss/train', running_loss_t / num_batches, epoch + 1) self.writer.add_scalar('F1/train', train_f1, epoch + 1) loss_v, val_f1 = self.get_validation_loss(criterion) self.writer.add_scalar('Loss/val', loss_v, epoch + 1) self.writer.add_scalar('F1/val', val_f1, epoch + 1) print( "Epoch {} Time {:.2f}s Train-Loss {:.3f} Val-Loss {:.3f} Train-F1 {:.3f} Val-F1 {:.3f}" .format(epoch + 1, end_time - start_time, running_loss_t / num_batches, loss_v, train_f1, val_f1)) def get_validation_loss(self, criterion): """ Check validation loss """ running_loss = 0.0 num_batches = 0 self.net.eval() y_true = [] y_pred = [] with torch.no_grad(): for data in tqdm(self.val_loader): images, labels = data labels_cp = labels.clone() if self.args.cuda: images = images.cuda() labels = labels.cuda() outputs = self.net(images) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) loss = criterion(outputs, labels) running_loss += loss.item() num_batches += 1 self.net.train() val_f1 = f1_score(y_true, y_pred, average='weighted') return running_loss / num_batches, val_f1 def get_test_accuracy(self): """ Check overall accuracy of model """ y_true = [] y_pred = [] class_correct = list(0. for i in range(4)) class_total = list(0. for i in range(4)) with torch.no_grad(): for data in tqdm(self.test_loader): images, labels = data labels_cp = labels.clone() if self.args.cuda: images = images.cuda() labels = labels.cuda() outputs = self.net(images) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) c = (predicted == labels_cp).squeeze() for i in range(min(self.args.batch_size, len(labels_cp))): label = labels_cp[i] class_correct[label] += c[i].item() class_total[label] += 1 print("Test F1: ", f1_score(y_true, y_pred, average='weighted')) def save(self, epochs, folder_path="../models/"): """ Save Model """ dict_save = {'params': self.net.state_dict(), 'classes': self.classes} name = folder_path + self.unique_tok + '_' + str(epochs) + '.model' torch.save(dict_save, name) print('Model saved at {}'.format(name)) return name def load(self, path): """ Load a saved model """ device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dict_load = torch.load(path, map_location=torch.device(device)) self.net.load_state_dict(dict_load['params']) return dict_load['classes'] def predict(self, inp): """ Predict using net """ if self.args.cuda: inp = inp.cuda() self.net.eval() with torch.no_grad(): vals = self.net(inp) print(vals) _, predicted = torch.max(vals, 1) predicted = predicted.cpu() result_class = self.classes[predicted] return result_class