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 run():
print("CUDA is available: {}".format(torch.cuda.is_available()))
data_transform = transforms.Compose(
[Rescale(250), CenterCrop(224),
Normalize(), ToTensor()])
# loader will split datatests into batches witht size defined by batch_size
train_loader = initialize_train_loader(data_transform)
test_loader = initialize_test_loader(data_transform)
model_id = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime())
# instantiate the neural network
net = Net()
net.to(device=device)
summary(net, (1, 224, 224))
# define the loss function using SmoothL1Loss
criterion = nn.SmoothL1Loss()
# define the params updating function using Adam
optimizer = optim.Adam(net.parameters(), lr=0.001)
loss_logger = []
for i in range(1, epochs + 1):
model_name = 'model-{}-epoch-{}.pt'.format(model_id, i)
# train all data for one epoch
train(net, criterion, optimizer, i, train_loader, model_id,
loss_logger)
# evaludate the accuracy after each epoch
evaluate(net, criterion, i, test_loader)
# save model after every 5 epochs
# https://discuss.pytorch.org/t/loading-a-saved-model-for-continue-training/17244/3
# https://github.com/pytorch/pytorch/issues/2830
# https://pytorch.org/tutorials/beginner/saving_loading_models.html
if i % 5 == 1:
torch.save(
{
'epoch': i,
'model': net.state_dict(),
'optimizer': optimizer.state_dict(),
'loss_logger': loss_logger,
}, model_dir + model_name)
print("Finished training!")
model_name = 'model-{}-final.pt'.format(model_id)
torch.save(
{
'epoch': epochs,
'model': net.state_dict(),
'optimizer': optimizer.state_dict(),
'loss_logger': loss_logger,
}, model_dir + model_name)
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 __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)
def data_transform(npy_train, npy_test, batch_size=64, shuffle=True):
# Setting up our image transforms
DATA_TRANSFORM = transforms.Compose(
[Rescale(256), RandomCrop(224),
Normalize(), ToTensor()])
# importing in the Custome dataset
TRANSFORMED_DATASET_TRAIN = KeypointDataSet(npy_file=npy_train,
root_dir='data/',
transform=DATA_TRANSFORM)
TRANSFORMED_DATASET_TEST = KeypointDataSet(npy_file=npy_test,
root_dir='data/',
transform=DATA_TRANSFORM)
# passing in the trainformed data into the dataLoader
TRAIN_LOADER = DataLoader(TRANSFORMED_DATASET_TRAIN,
batch_size=64,
shuffle=True,
pin_memory=True)
TEST_LOADER = DataLoader(TRANSFORMED_DATASET_TEST,
batch_size=64,
shuffle=True,
pin_memory=True)
return TRAIN_LOADER, TEST_LOADER
from train import train_net
if __name__ == "__main__":
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()
n = 30
if args['model'] == "NaimishNet":
net = NaimishNet(n)
elif args['model'] == "VggFace":
net = VggFace(n)
elif args['model'] == "Custom":
net = Net2(n)
else:
net = LeNet5(n)
model_name = args['model']
print(net)
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# order matters! i.e. rescaling should come before a smaller crop
train_transform = transforms.Compose([Rescale(110),RandomCrop(96),Albu(),Normalize(args["dataset"]),ToTensor()])
test_transform = transforms.Compose([Normalize(args["dataset"]),ToTensor()])
# 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:
assert args.optimizer in optimizers, f"Error: Optimizer {args.optimizer} not found."
opti = getattr(optim, args.optimizer)
optimizer = opti(model.parameters(), lr=args.lr)
assert args.loss_func in loss_funcs, f"Error: Network architecture {args.loss_func} not found."
criterion = loss_funcs[args.loss_func]
# hard-coded
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
# Define a transform
data_transform = transforms.Compose([
Rescale((224,224)),
#RandomCrop(),
Normalize(),
ToTensor(),
])
# create the transformed dataset
train_val_dataset = FacialKeypointsDataset(csv_file='data/training_frames_keypoints.csv',
root_dir='data/training/',
transform=data_transform)
# for faster experimentation select only a subset of images
if args.subset_size > 0:
train_val_dataset = Subset(train_val_dataset, range(args.subset_size))
print('Number of images: ', len(train_val_dataset))
# split train/val - hard coded
if is_debug:
print('fc1.out_shape:', x.shape)
# a modified x, having gone through all the layers of your model, should be returned
return x
if __name__ == '__main__':
import os
os.chdir('/Users/rawk/Projects/Project Zero/MLND-projects/cv-project0-facial-keypoints/')
from data_load import FacialKeypointsDataset
from data_load import Rescale, RandomCrop, Normalize, ToTensor
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
data_transform = transforms.Compose([Rescale((250, 250)), RandomCrop((224, 224)), Normalize(), ToTensor()])
transformed_dataset = FacialKeypointsDataset(csv_file='./data/training_frames_keypoints.csv',
root_dir='./data/training/',
transform=data_transform)
batch_size = 2
data_loader = DataLoader(transformed_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=4)
for i, sample in enumerate(data_loader):
images = sample['image']
images = images.type(torch.FloatTensor)
net = Net()
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)
import torch
from torch.autograd import Variable
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
from data_load import FacialKeypointsDataset
from data_load import Rescale, RandomCrop, Normalize, ToTensor
kwargs = {'num_workers': 4} if torch.cuda.is_available() else {}
# define the data_transform
data_transform = transforms.Compose(
[Rescale((96, 96)), Normalize(),
ToTensor()])
# create the transformed dataset
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,
**kwargs)
# create the test dataset
test_dataset = FacialKeypointsDataset(
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')
def run_epochs(config, checkpoint_path):
print("CUDA is available: {}".format(torch.cuda.is_available()))
# Define data loader: data preprocessing and augmentation
# I use same procedures for all models that consumes imagenet-2012 dataset for simplicity
imagenet_train_transform = transforms.Compose([
Rescale(256),
RandomHorizontalFlip(0.5),
RandomCrop(224),
ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0),
ToTensor(),
# https://github.com/pytorch/examples/blob/master/imagenet/main.py#L195
# this is pre-calculated mean and std of imagenet dataset
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
imagenet_val_transform = transforms.Compose([
Rescale(256),
CenterCrop(224),
ToTensor(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
train_loader = initialize_train_loader(imagenet_train_transform, config)
val_loader = initialize_val_loader(imagenet_val_transform, config)
# Define the neural network.
Model = config.get('model')
model_params = config.get('model_params')
if model_params is not None:
net = Model(**model_params)
else:
net = Model()
# transfer variables to GPU if present
net.to(device=device)
# Print the network structure given 3x32x32 input
# need to put this before DataParallel to avoid "Expected more than 1 value per channel when training" error
# https://github.com/pytorch/pytorch/issues/4534
summary(net, (3, 224, 224))
# Wrap it with DataParallel to train with multiple GPUs
if torch.cuda.device_count() > 1:
print("Using", torch.cuda.device_count(), "GPUs!")
net = nn.DataParallel(net)
# Define the loss function. CrossEntrophyLoss is the most common one for classification task.
criterion = nn.CrossEntropyLoss()
# Define the optimizer
Optim = config.get('optimizer')
optimizer = Optim(
net.parameters(),
**config.get('optimizer_params'),
)
# Define the scheduler
Sched = config.get('scheduler')
scheduler = Sched(
optimizer,
**config.get('scheduler_params'),
)
loggers = initialize_loggers()
model_id = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime())
model_name = config.get('name')
start_epoch = 1
if checkpoint_path is not None:
net, optimizer, scheduler, loggers, start_epoch = load_checkpoint(
checkpoint_path,
net,
optimizer,
scheduler,
loggers,
)
validate(val_loader, net, criterion, 0, loggers)
for epoch in range(start_epoch, config.get('total_epochs') + 1):
train(
train_loader,
net,
criterion,
optimizer,
epoch,
loggers,
)
val_loss, top1_acc, top5_acc = validate(
val_loader,
net,
criterion,
epoch,
loggers,
)
# for ReduceLROnPlateau scheduler, we need to use top1_acc as metric
if isinstance(scheduler, optim.lr_scheduler.ReduceLROnPlateau):
scheduler.step(top1_acc)
else:
scheduler.step()
checkpoint_file = '{}-{}-epoch-{}.pt'.format(
model_name,
model_id,
epoch,
)
torch.save(
{
'epoch': epoch,
'model': net.state_dict(),
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
'loggers': loggers,
}, model_dir + checkpoint_file)
def plot_face_pts(img, pts):
plt.imshow(img[:, :, 0], cmap='gray')
for i in range(1, 31, 2):
plt.plot(pts[i - 1], pts[i], 'b.')
#load models
net_8 = Net2(8)
net_8.load_state_dict(
torch.load('./saved_models/Kaggle_Custom_1.68410162627697.pt'))
net_30 = Net2(30)
net_30.load_state_dict(
torch.load('./saved_models/Kaggle_Custom_1.6080801971256733.pt'))
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
data_transform = transforms.Compose([Normalize("Kaggle"), ToTensor()])
# testing that you've defined a transform
assert (data_transform is not None), 'Define a data_transform'
X, y = load_KagggleDataset(test=True)
y = np.zeros((X.shape[0], 30))
test_dataset = KagggleDataset(X, y, data_transform)
batch_size = 32
test_loader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=0)
from models.vgg19 import VGG19
from models.inception_v1 import InceptionV1
from models.resnet34 import ResNet34
evaluate_batch_size = 128
epochs = 250
desired_image_shape = torch.empty(3, 224, 224).size()
model_dir = './saved_models/'
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
val_transform = transforms.Compose([
Rescale(256),
CenterCrop(224),
ToTensor(),
# https://github.com/pytorch/examples/blob/master/imagenet/main.py#L195
# this is pre-calculated mean and std of imagenet dataset
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def initialize_train_loader(transform, batch_size):
train_dataset = ImageNet2012Dataset(
root_dir='../dataset/train_flatten/',
labels_file='../dataset/synsets.txt',
transform=transform,
)
print('Number of train images: ', len(train_dataset))
assert train_dataset[0]['image'].size(
) == desired_image_shape, "Wrong train image dimension"
train_loader = DataLoader(
# In[133]:
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
# the dataset we created in Notebook 1 is copied in the helper file `data_load.py`
from data_load import FacialKeypointsDataset
# the transforms we defined in Notebook 1 are in the helper file `data_load.py`
from data_load import Rescale, RandomCrop, Normalize, ToTensor
crop = 224
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)
