def debug_me(): # Define network net = Net() print(net) data_transform = transforms.Compose( [Rescale(250), RandomCrop(224), Normalize()]) aww_dataset = FacialKeypointsDataset( csv_file='data/aww_frames_keypoints.csv', root_dir='data/aww/', transform=data_transform) sample = aww_dataset[0] print(sample['image'].shape, sample['keypoints'].shape) print(np.max(sample['keypoints'])) aww_loader = DataLoader(aww_dataset, batch_size=10, shuffle=True, num_workers=4) aww_images, aww_outputs, gt_pts = net_sample_output(net, aww_loader) visualize_output(aww_images, aww_outputs, gt_pts, 1) '''
def transform_data(self, csv_file, root_dir): # create the transformed dataset transformed_dataset = FacialKeypointsDataset( csv_file=csv_file, root_dir=root_dir, transform=self.data_transform) return transformed_dataset
def main(): hyp_batch_size = 20 net = Net2() model_dir = '../saved_models/' model_name = 'keypoints_model_2.pt' data_transform = transforms.Compose([ Rescale(256), RandomCrop(224), Normalize(), ToTensor() ]) # retreive the saved model net_state_dict = torch.load(model_dir+model_name) net.load_state_dict(net_state_dict) # load the test data test_dataset = FacialKeypointsDataset(csv_file='../files/test_frames_keypoints.csv', root_dir='../files/test/', transform=data_transform) # load test data in batches batch_size = hyp_batch_size test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=0) test_images, test_outputs, gt_pts = net_sample_output(test_loader, net) print(test_images.data.size()) print(test_outputs.data.size()) print(gt_pts.size()) # Get the weights in the first conv layer, "conv1" # if necessary, change this to reflect the name of your first conv layer weights1 = net.conv1.weight.data w = weights1.numpy() filter_index = 0 print(w[filter_index][0]) print(w[filter_index][0].shape) # display the filter weights plt.imshow(w[filter_index][0], cmap='gray') #plt.show() ##TODO: load in and display any image from the transformed test dataset i = 1 show_image(test_images, w, i)
def initialize_test_loader(transform): test_dataset = FacialKeypointsDataset( csv_file='./data/test_frames_keypoints.csv', root_dir='./data/test/', transform=transform) print('Number of test images: ', len(test_dataset)) assert test_dataset[0]['image'].size( ) == desired_image_shape, "Wrong test image dimension" assert test_dataset[0]['keypoints'].size( ) == desired_keypoints_shape, "Wrong test keypoints dimension" test_loader = DataLoader(test_dataset, batch_size=evaluate_batch_size, shuffle=True, num_workers=0) return test_loader
def __init__(self, root_dir=None): self.data_root_dir = root_dir or './data/' self.training_csv = os.path.join(self.data_root_dir, 'training_frames_keypoints.csv') self.training_data_dir = os.path.join(self.data_root_dir, 'training/') self.test_csv = os.path.join(self.data_root_dir, 'test_frames_keypoints.csv') self.test_data_dir = os.path.join(self.data_root_dir, 'test/') self.key_pts_frame = pd.read_csv(self.training_csv) self.face_dataset = FacialKeypointsDataset( csv_file=self.training_csv, root_dir=self.training_data_dir) self.face_dataset_len = len(self.face_dataset) # define the data tranform # order matters! i.e. rescaling should come before a smaller crop self.data_transform = transforms.Compose( [Rescale(250), RandomCrop(224), Normalize(), ToTensor()]) self.transformed_training_data = self.transform_data( self.training_csv, self.training_data_dir) self.transformed_test_data = self.transform_data( self.test_csv, self.test_data_dir)
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, num_workers=0) def net_sample_output(): # iterate through the test dataset for i, sample in enumerate(train_loader):
assert (data_transform is not None), 'Define a data_transform' # In[ ]: # In[136]: # In[137]: ###########load the csv # order matters! i.e. rescaling should come before a smaller crop data_transform = transforms.Compose([ Rescale(224), # RandomCrop(222), Normalize(), ToTensor() ]) # create the transformed dataset transformed_dataset = FacialKeypointsDataset( csv_file=('/home/jonathan/Project_Eye/data/try_harder_cleaned.csv'), root_dir='/home/jonathan/Project_Eye/data/training/', transform=data_transform) print('Number of images: ', len(transformed_dataset)) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].size(), sample['keypoints'].size()) # ## Batching and loading data # # In[138]: # load training data in batches batch_size = 1 train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True,
package_dir = os.path.dirname(os.path.abspath(__file__)) net = Net() # net.load_state_dict(torch.load(package_dir + '/saved_models/model3.pt')) print(net) data_transform = transforms.Compose([Rescale(250), RandomCrop(224), Normalize(), ToTensor()]) ##########LOAD TRAIN DATASET transformed_dataset = FacialKeypointsDataset(csv_file= package_dir + '/data/training_frames_keypoints.csv', root_dir= package_dir + '/data/training/', transform=data_transform) batch_size = 30 train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True, num_workers=4) ##########LOAD TEST DATASET test_dataset = FacialKeypointsDataset(csv_file=package_dir+'/data/test_frames_keypoints.csv', root_dir=package_dir+'/data/test/', transform=data_transform) test_loader = DataLoader(test_dataset, batch_size=batch_size,
## TODO: define the data_transform using transforms.Compose([all tx's, . , .]) # order matters! i.e. rescaling should come before a smaller crop data_transform = transforms.Compose( [Rescale(227), RandomCrop(224), Normalize(), ToTensor()]) # testing that you've defined a transform assert (data_transform is not None), 'Define a data_transform' # In[5]: # create the transformed dataset transformed_dataset = FacialKeypointsDataset( csv_file= 'D:/Computer_vision_udacity/P1_Facial_Keypoints-master/data/training_frames_keypoints.csv', root_dir= 'D:/Computer_vision_udacity/P1_Facial_Keypoints-master/data/training/', transform=data_transform) print('Number of images: ', len(transformed_dataset)) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].size(), sample['keypoints'].size(), sample['keypoints']) # ## Batching and loading data # # Next, having defined the transformed dataset, we can use PyTorch's DataLoader class to load the training data in batches of whatever size as well as to shuffle the data for training the model. You can read more about the parameters of the DataLoader, in [this documentation](http://pytorch.org/docs/master/data.html). #
from data_load import Rescale, RandomCrop, Normalize, ToTensor ## TODO: define the data_transform using transforms.Compose([all tx's, . , .]) # order matters! i.e. rescaling should come before a smaller crop # testing that you've defined a transform data_transform = transforms.Compose( [Rescale(250), RandomCrop(224), Normalize(), ToTensor()]) assert (data_transform is not None), 'Define a data_transform' # create the transformed dataset transformed_dataset = FacialKeypointsDataset( csv_file= "D:\\Users\\Tsvetan\\FootDataset\\person_keypoints_train2017_foot_v1\\NEWOUT.csv", root_dir= "D:\\Users\\Tsvetan\\FootDataset\\person_keypoints_train2017_foot_v1\\out\\", transform=data_transform) print('Number of images: ', len(transformed_dataset)) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].size(), sample['keypoints'].size()) # load training data in batches batch_size = 32 train_loader = DataLoader(transformed_dataset, batch_size=batch_size,
def train(cfg): # make run_dir with date d = datetime.datetime.now() run_dir = pjoin(cfg.out_dir, 'exp_{:%Y-%m-%d_%H-%M}'.format(d)) if(not os.path.exists(run_dir)): os.makedirs(run_dir) with open(pjoin(run_dir, 'cfg.yml'), 'w') as outfile: yaml.dump(cfg.__dict__, stream=outfile, default_flow_style=False) # generate tensorboard object writer = SummaryWriter(run_dir) net = UNet(cfg.out_channels, in_channels=cfg.in_channels, depth=cfg.depth, merge_mode=cfg.merge_mode) #criterion = nn.CrossEntropyLoss() criterion = nn.MSELoss() optimizer = optim.SGD(net.parameters(), lr=cfg.lr, momentum=cfg.momentum) optimizer = optim.Adam(params=net.parameters(), lr=0.0025, weight_decay=0.00001) #softm = nn.Softmax(dim=1) softm = nn.Sigmoid() ################################ # make augmenter transf = iaa.Sequential([ iaa.SomeOf(3, [ iaa.Affine(rotate=iap.Uniform(-cfg.aug_rotate, cfg.aug_rotate)), iaa.Affine(shear=iap.Uniform(-cfg.aug_shear, cfg.aug_shear)), iaa.Fliplr(1.), iaa.Flipud(1.), iaa.GaussianBlur(sigma=iap.Uniform(0.0, cfg.aug_gaussblur)) ]), iaa.Resize(cfg.in_shape), rescale_augmenter ]) base_loader = FacialKeypointsDataset(csv_file=cfg.csv_file, root_dir=cfg.root_dir, sig_kp=cfg.sig_kp, transform=transf) # build train, val and test sets randomly with given split ratios idxs = np.arange(len(base_loader)) np.random.shuffle(idxs) train_idxs = idxs[:int(len(base_loader) * cfg.train_split)] others_idxs = idxs[int(len(base_loader) * cfg.train_split):] val_idxs = others_idxs[:int(others_idxs.size * cfg.val_split)] test_idxs = others_idxs[int(others_idxs.size * cfg.val_split):] train_loader = torch.utils.data.Subset(base_loader, train_idxs) val_loader = torch.utils.data.Subset(base_loader, val_idxs) test_loader = torch.utils.data.Subset(base_loader, test_idxs) loaders = {'train': DataLoader(train_loader, batch_size=cfg.batch_size, num_workers=cfg.n_workers), 'val': DataLoader(train_loader, batch_size=cfg.batch_size, num_workers=cfg.n_workers), 'test': DataLoader(train_loader, batch_size=cfg.batch_size, num_workers=cfg.n_workers)} # convert batch to device device = torch.device('cuda' if cfg.cuda else 'cpu') net.to(device) batch_to_device = lambda batch: { k: v.to(device) if (isinstance(v, torch.Tensor)) else v for k, v in batch.items() } for epoch in range(cfg.n_epochs): # loop over the dataset multiple times for phase in loaders.keys(): if phase == 'train': net.train() else: net.eval() # Set model to evaluate mode running_loss = 0.0 # train on batches of data, assumes you already have train_loader pbar = tqdm.tqdm(total=len(loaders[phase])) for i, data in enumerate(loaders[phase]): data = batch_to_device(data) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.set_grad_enabled(phase == 'train'): #import pdb; pdb.set_trace() out = softm(net(data['image'].float())) #data_truth = softm(torch.squeeze(data['truth'])) ## here I am not sure, bc the entropy fct already has softmax #data_truth = data_truth.long().reshape(4, 224*224) #out = out.reshape(4, 1, 224*224) # data_truth should have shape 4, 244,244 # input matrix is in the shape: (Minibatch, Classes, H, W) # the target is in size (Minibatch, H, W) loss = criterion(out, data['truth'].float()) ############################# # backward + optimize only if in training phase if phase == 'train': loss.backward() optimizer.step() running_loss += loss.cpu().detach().numpy() loss_ = running_loss / ((i + 1) * cfg.batch_size) pbar.set_description('[{}] loss: {:.4f}'.format(phase, loss_)) pbar.update(1) pbar.close() writer.add_scalar('{}/loss'.format(phase), loss_, epoch) # make preview images if phase == 'test': data = next(iter(loaders[phase])) data = batch_to_device(data) pred_ = softm(net(data['image'].float())).cpu() im_ = data['image'].float().cpu().detach() im_ = [torch.cat(3*[im_[i, ...]]) for i in range(im_.shape[0])] truth_ = data['truth'].float().cpu() truth_ = [ torch.cat([truth_[i, ...]]) for i in range(truth_.shape[0]) ] # normalize prediction maps in-place for b in range(pred_.shape[0]): for n in range(pred_.shape[1]): pred_[b, n, ...] = (pred_[b, n, ...] - pred_[b, n, ...].min()) pred_[b, n, ...] = pred_[b, n, ...] / pred_[b, n, ...].max() # find max location on each channel of each batch element pos = [] for b in range(pred_.shape[0]): pos.append([]) for n in range(pred_.shape[1]): idx_max = pred_[b, n, ...].argmax() i, j = np.unravel_index(idx_max, pred_[b, n, ...].shape) pos[-1].append((i, j)) # draw circle on image through numpy :( rr, cc = draw.circle(i, j, 5, shape=im_[b][n, ...].shape) im__ = np.rollaxis(im_[b].detach().numpy(), 0, 3) im__[rr, cc, ...] = (1., 0., 0.) im_[b] = torch.from_numpy(np.rollaxis(im__, -1, 0)) pred_ = [torch.cat([pred_[i, ...]]) for i in range(pred_.shape[0])] #import pdb; pdb.set_trace() all_ = [ tutls.make_grid([im_[i], truth_[i], pred_[i]], nrow=len(pred_), padding=10, pad_value=1.) for i in range(len(truth_)) ] all_ = torch.cat(all_, dim=1) writer.add_image('test/img', all_, epoch) # save checkpoint if phase == 'val': is_best = False if (loss_ < best_loss): is_best = True best_loss = loss_ path = pjoin(run_dir, 'checkpoints') save_checkpoint( { 'epoch': epoch + 1, 'model': net, 'best_loss': best_loss, 'optimizer': optimizer.state_dict() }, is_best, path=path)
def main(): # Define network net = Net() print(net) data_transform = transforms.Compose( [Rescale(250), Normalize(), RandomCrop(224)]) train_dataset = FacialKeypointsDataset( csv_file='data/training_frames_keypoints.csv', root_dir='data/training/', transform=data_transform) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = train_dataset[i] print(i, sample['image'].size, sample['keypoints'].size) train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True, num_workers=4) test_dataset = FacialKeypointsDataset( csv_file='data/test_frames_keypoints.csv', root_dir='data/test/', transform=data_transform) test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True, num_workers=4) test_images, test_outputs, gt_pts = net_sample_output(net, test_loader) # print out the dimensions of the data to see if they make sense print(test_images.data.size()) print(test_outputs.data.size()) print(gt_pts.size()) # call it visualize_output(test_images, test_outputs, gt_pts, 1) criterion = nn.MSELoss() optimizer = optim.Adam(net.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-8) n_epochs = 2 train_net(net, criterion, optimizer, train_loader, n_epochs) # get a sample of test data again test_images, test_outputs, gt_pts = net_sample_output(net, test_loader) print(test_images.data.size()) print(test_outputs.data.size()) print(gt_pts.size()) model_dir = 'saved_models/' model_name = 'keypoints_model_1.pt' # after training, save your model parameters in the dir 'saved_models' torch.save(net.state_dict(), model_dir + model_name) weights1 = net.conv1.weight.data w = weights1.numpy() filter_index = 0 print(w[filter_index][0]) print(w[filter_index][0].shape) # display the filter weights plt.imshow(w[filter_index][0], cmap='gray')
import matplotlib.pyplot as plt import numpy as np device = torch.device('cuda') net = Net() data_transform = transforms.Compose( [Rescale(256), RandomCrop(224), Normalize(), ToTensor()] ) train_dataset = FacialKeypointsDataset( "./data/training_frames_keypoints.csv", "./data/training", data_transform ) test_dataset = FacialKeypointsDataset( "./data/test_frames_keypoints.csv", "./data/test", data_transform ) batch_size = 256 train_loader = DataLoader( train_dataset, batch_size=batch_size, shuffle=True )
import torch import torch.optim as optim import torch.nn as nn from models import Net from torch.utils.data import DataLoader from torchvision import transforms from data_load import FacialKeypointsDataset from data_load import Rescale, RandomCrop, Normalize, ToTensor # 载入数据 data_transform = transforms.Compose( [Rescale(250), RandomCrop(224), Normalize(), ToTensor()]) transformed_dataset = FacialKeypointsDataset( csv_file= 'C:/Users/76785/Downloads/Facial-Key-Point-Detection-CNN-master/data/training_frames_keypoints.csv', root_dir= 'C:/Users/76785/Downloads/Facial-Key-Point-Detection-CNN-master/data/training', transform=data_transform) batch_size = 10 train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True, num_workers=0) test_dataset = FacialKeypointsDataset( csv_file= 'C:/Users/76785/Downloads/Facial-Key-Point-Detection-CNN-master/data/test_frames_keypoints.csv', root_dir= 'C:/Users/76785/Downloads/Facial-Key-Point-Detection-CNN-master/data/test/', transform=data_transform) test_loader = DataLoader(test_dataset, batch_size=batch_size,
def main(): #------------------------------------------------------------------------------------------------------------------ # Hyperparameters hyp_epochs = 5 hyp_batch_size = 20 #hyp_optim = "SGD" hyp_optim = "Adam" #hyp_net = Net1() hyp_net = Net2() print("Hyperparameters") print("--------------") print("Epochs = ", hyp_epochs) print("Batch Size = ", hyp_batch_size) print("Optimizer = ", hyp_optim) print("--------------") ## TODO: Define the Net in models.py net = hyp_net print(net) ## TODO: define the data_transform using transforms.Compose([all tx's, . , .]) # order matters! i.e. rescaling should come before a smaller crop data_transform = transforms.Compose( [Rescale(256), RandomCrop(224), Normalize(), ToTensor()]) # testing that you've defined a transform assert (data_transform is not None), 'Define a data_transform' # create the transformed dataset transformed_dataset = FacialKeypointsDataset( csv_file='../files/training_frames_keypoints.csv', root_dir='../files/training/', transform=data_transform) print('Number of images: ', len(transformed_dataset)) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].size(), sample['keypoints'].size()) # load training data in batches batch_size = hyp_batch_size train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True, num_workers=0) # load in the test data, using the dataset class # AND apply the data_transform you defined above # create the test dataset test_dataset = FacialKeypointsDataset( csv_file='../files/test_frames_keypoints.csv', root_dir='../files/test/', transform=data_transform) # load test data in batches batch_size = hyp_batch_size test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=0) # test the model on a batch of test images # call the above function # returns: test images, test predicted keypoints, test ground truth keypoints test_images, test_outputs, gt_pts = net_sample_output(test_loader, net) # print out the dimensions of the data to see if they make sense print(test_images.data.size()) print(test_outputs.data.size()) print(gt_pts.size()) # visualize the output # by default this shows a batch of 10 images # call it _visualise = False if _visualise == True: visualize_output(test_images, test_outputs, gt_pts) ## TODO: Define the loss and optimization import torch.optim as optim criterion = nn.MSELoss() hyp_optimizer = None if hyp_optim == "Adam": hyp_optimizer = optim.Adam(net.parameters(), lr=0.001) if hyp_optim == "SGD": hyp_optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) optimizer = hyp_optimizer # train your network n_epochs = hyp_epochs # start small, and increase when you've decided on your model structure and hyperparams # this is a Workspaces-specific context manager to keep the connection # alive while training your model, not part of pytorch train_net(n_epochs, train_loader, net, criterion, optimizer) # get a sample of test data again test_images, test_outputs, gt_pts = net_sample_output(test_loader, net) print(test_images.data.size()) print(test_outputs.data.size()) print(gt_pts.size()) ## TODO: change the name to something uniqe for each new model model_dir = '../saved_models/' model_name = 'keypoints_model_2.pt' # after training, save your model parameters in the dir 'saved_models' torch.save(net.state_dict(), model_dir + model_name) # -------------------------------------------------------------------- # To run the following code after retreiving an existing model, # you can do so in the resume.py file # -------------------------------------------------------------------- # Get the weights in the first conv layer, "conv1" # if necessary, change this to reflect the name of your first conv layer weights1 = net.conv1.weight.data w = weights1.numpy() filter_index = 0 print(w[filter_index][0]) print(w[filter_index][0].shape) # display the filter weights plt.imshow(w[filter_index][0], cmap='gray') ##TODO: load in and display any image from the transformed test dataset i = 1 show_image(test_images, w, i)
# testing that you've defined a transform assert(train_transform is not None and test_transform is not None), 'Define a data_transform' # create the transformed dataset if args["dataset"] == "Kaggle": X, y = load_KagggleDataset(split=args['split'],train_30=args['train30'],train_8=args['train8']) X_test, y_test = X[:300], y[:300] X_train, y_train = X[300:], y[300:] transformed_dataset = KagggleDataset(X_train, y_train, train_transform) test_dataset = KagggleDataset(X_test, y_test, test_transform) sub, div = 48., 48. else: transformed_dataset = FacialKeypointsDataset(csv_file='./data/training_frames_keypoints.csv', root_dir='./data/training/', transform=train_transform) test_dataset = FacialKeypointsDataset(csv_file='./data/test_frames_keypoints.csv', root_dir='./data/test/', transform = test_transform) sub, div = 100.,50. print('Number of images: ', len(transformed_dataset)) # iterate through the transformed dataset and print some stats about the first few samples for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].shape, sample['keypoints'].size()) # load training data in batches batch_size = args["batch_size"] train_loader = DataLoader(transformed_dataset, batch_size=batch_size,
def train(cfg): # make run_dir with date import pdb; pdb.set_trace() ## DEBUG ## d = datetime.datetime.now() run_dir = pjoin(cfg.out_dir, 'exp_{:%Y-%m-%d_%H-%M}'.format(d)) if(not os.path.exists(run_dir)): os.makedirs(run_dir) with open(pjoin(run_dir, 'cfg.yml'), 'w') as outfile: yaml.dump(cfg.__dict__, stream=outfile, default_flow_style=False) # generate tensorboard object writer = SummaryWriter(run_dir) net = UNet(cfg.out_channels, in_channels=cfg.in_channels, depth=cfg.depth, merge_mode=cfg.merge_mode) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=cfg.lr, momentum=cfg.momentum) # make augmenter transf = iaa.Sequential([ iaa.SomeOf(3, [ iaa.Affine(rotate=iap.Uniform(-cfg.aug_rotate, cfg.aug_rotate)), iaa.Affine(shear=iap.Uniform(-cfg.aug_shear, cfg.aug_shear)), iaa.Fliplr(1.), iaa.Flipud(1.), iaa.GaussianBlur(sigma=iap.Uniform(0.0, cfg.aug_gaussblur)) ]), iaa.Resize(cfg.in_shape), rescale_augmenter ]) base_loader = FacialKeypointsDataset(csv_file=cfg.csv_file, root_dir=cfg.root_dir, sig_kp=cfg.sig_kp, transform=transf) # build train, val and test sets randomly with given split ratios idxs = np.arange(len(base_loader)) np.random.shuffle(idxs) train_idxs = idxs[:int(len(base_loader) * cfg.train_split)] others_idxs = idxs[int(len(base_loader) * cfg.train_split):] val_idxs = others_idxs[:int(others_idxs.size * cfg.val_split)] test_idxs = others_idxs[int(others_idxs.size * cfg.val_split):] train_loader = torch.utils.data.Subset(base_loader, train_idxs) val_loader = torch.utils.data.Subset(base_loader, val_idxs) test_loader = torch.utils.data.Subset(base_loader, test_idxs) loaders = {'train': DataLoader(train_loader, batch_size=cfg.batch_size, num_workers=cfg.n_workers), 'val': DataLoader(train_loader, batch_size=cfg.batch_size, num_workers=cfg.n_workers), 'test': DataLoader(train_loader, num_workers=cfg.n_workers)} # convert batch to device device = torch.device('cuda' if cfg.cuda else 'cpu') net.to(device) batch_to_device = lambda batch: { k: v.to(device) if (isinstance(v, torch.Tensor)) else v for k, v in batch.items() } for epoch in range(cfg.n_epochs): # loop over the dataset multiple times for phase in loaders.keys(): if phase == 'train': net.train() else: net.eval() # Set model to evaluate mode running_loss = 0.0 # train on batches of data, assumes you already have train_loader pbar = tqdm.tqdm(total=len(loaders[phase])) for i, data in enumerate(loaders[phase]): data = batch_to_device(data) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.set_grad_enabled(phase == 'train'): out = net(data['image']) loss = criterion(out, data['truth']) # backward + optimize only if in training phase if phase == 'train': loss.backward() optimizer.step() running_loss += loss.cpu().detach().numpy() loss_ = running_loss / ((i + 1) * cfg.batch_size) pbar.set_description('[{}] loss: {:.4f}'.format(phase, loss_)) pbar.update(1) pbar.close() writer.add_scalar('{}/loss'.format(phase), loss_, epoch) # make preview images if phase == 'prev': data = next(iter(loaders[phase])) data = batch_to_device(data) pred_ = net(data['image']).cpu() pred_ = [ pred_[i, ...].repeat(3, 1, 1) for i in range(pred_.shape[0]) ] im_ = data['image'].cpu() im_ = [im_[i, ...] for i in range(im_.shape[0])] truth_ = data['truth'].cpu() truth_ = [ truth_[i, ...].repeat(3, 1, 1) for i in range(truth_.shape[0]) ] all_ = [ tutls.make_grid([im_[i], truth_[i], pred_[i]], nrow=len(pred_), padding=10, pad_value=1.) for i in range(len(truth_)) ] all_ = torch.cat(all_, dim=1) writer.add_image('test/img', all_, epoch) # save checkpoint if phase == 'val': is_best = False if (loss_ < best_loss): is_best = True best_loss = loss_ path = pjoin(run_dir, 'checkpoints') save_checkpoint( { 'epoch': epoch + 1, 'model': net, 'best_loss': best_loss, 'optimizer': optimizer.state_dict() }, is_best, path=path)
torch.cuda.empty_cache() offline = True device = torch.device("cuda" if torch.cuda.is_available() else "cpu") n_epochs = 20 print("AI Running on", device) net = FCN().apply(initialize_weights_advance_).to(device) print(net) data_transform = transforms.Compose( [Rescale(250), RandomCrop(224), Normalize(), ToTensor()]) transformed_dataset = FacialKeypointsDataset( csv_file='data/training_frames_keypoints.csv', root_dir='data/training/', transform=data_transform) # load training data in batches batch_size = 128 train_loader = DataLoader(transformed_dataset, batch_size=batch_size, shuffle=True, num_workers=4) criterion = nn.MSELoss() optimizer = optim.Adam(params=net.parameters(), lr=0.001) losses = train_net(n_epochs, net, train_loader, device, optimizer,
data_transform = transforms.Compose([Rescale(250), RandomCrop(crop), Normalize(crop), ToTensor()]) # testing that you've defined a transform assert(data_transform is not None), 'Define a data_transform' # In[134]: # create the transformed dataset transformed_dataset = FacialKeypointsDataset(csv_file='training_frames_keypoints.csv', root_dir='/home/tianbai/P1_Facial_Keypoints/data/training/', transform=data_transform) print('Number of images: ', len(transformed_dataset)) for i in range(4): sample = transformed_dataset[i] print(i, sample['image'].size(), sample['keypoints'].size()) print (sample['keypoints'][0:5]) # In[135]: