2b.Define the Network Architecture-GPU_train.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.3"
    },
    "colab": {
      "name": "FaceKeypoint-GPU.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3Ou99Jo-Pm_"
      },
      "source": [
        "## Define the Convolutional Neural Network - GPU Mode\n",
        " \n",
        "After you've looked at the data you're working with and, in this case, know the shapes of the images and of the keypoints, you are ready to define a convolutional neural network that can *learn* from this data.\n",
        "\n",
        "In this notebook and in `models.py`, you will:\n",
        "1. Define a CNN with images as input and keypoints as output\n",
        "2. Construct the transformed FaceKeypointsDataset, just as before\n",
        "3. Train the CNN on the training data, tracking loss\n",
        "4. See how the trained model performs on test data\n",
        "5. If necessary, modify the CNN structure and model hyperparameters, so that it performs *well* **\\***\n",
        "\n",
        "**\\*** What does *well* mean?\n",
        "\n",
        "\"Well\" means that the model's loss decreases during training **and**, when applied to test image data, the model produces keypoints that closely match the true keypoints of each face. And you'll see examples of this later in the notebook.\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SVjrngJoMuNX"
      },
      "source": [
        "Mount Google Drive to work inside Colab"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c78AZbxv-TsE"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "%cd /content/drive/My\\ Drive/Colab\\ Notebooks/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kp7n1p3mNABL"
      },
      "source": [
        "# Load Data\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tTV_auJI-PnE"
      },
      "source": [
        "# load the data if you need to; if you have already loaded the data, you may comment this cell out\n",
        "# -- DO NOT CHANGE THIS CELL -- #\n",
        "!mkdir /data\n",
        "!wget -P /data/ https://s3.amazonaws.com/video.udacity-data.com/topher/2018/May/5aea1b91_train-test-data/train-test-data.zip\n",
        "!unzip -n /data/train-test-data.zip -d /data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "McI7dxULNH6T"
      },
      "source": [
        "Import Standard dependencies and Torch\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MDv_N9Za-PnM"
      },
      "source": [
        "# import the usual resources\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import datetime\n",
        "# import utilities to keep workspaces alive during model training\n",
        "#from workspace_utils import active_session\n",
        "\n",
        "# watch for any changes in model.py, if it changes, re-load it automatically\n",
        "#%load_ext autoreload\n",
        "#%autoreload 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uhP1jatR-PnP"
      },
      "source": [
        "## TODO: Define the Net in models.py\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.nn.init as I\n",
        "from torch.utils.tensorboard import SummaryWriter\n",
        "\n",
        "## TODO: Once you've define the network, you can instantiate it\n",
        "# one example conv layer has been provided for you\n",
        "from Face_Keypoints_Detection.models_deep import Net\n",
        "\n",
        "USE_CUDA = True # Activate Net in GPU mode\n",
        "if USE_CUDA and torch.cuda.is_available():\n",
        "  net = Net().cuda()\n",
        "else:\n",
        "  net = Net()\n",
        "\n",
        "print(net)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "7M8zHA7D-PnT"
      },
      "source": [
        "## Transform the dataset \n",
        "\n",
        "To prepare for training, create a transformed dataset of images and keypoints.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ik2DBjsN-PnU"
      },
      "source": [
        "from torch.utils.data import Dataset, DataLoader\n",
        "from torchvision import transforms, utils\n",
        "\n",
        "# the dataset we created in Notebook 1 is copied in the helper file `data_load.py`\n",
        "from Face_Keypoints_Detection.data_load import FacialKeypointsDataset\n",
        "# the transforms we defined in Notebook 1 are in the helper file `data_load.py`\n",
        "from Face_Keypoints_Detection.data_load import Rescale, RandomCrop, Normalize, ToTensor\n",
        "\n",
        "\n",
        "## TODO: define the data_transform using transforms.Compose([all tx's, . , .])\n",
        "# order matters! i.e. rescaling should come before a smaller crop\n",
        "data_transform = transforms.Compose([Rescale(250),\n",
        "                                     RandomCrop(224),\n",
        "                                     Normalize(),\n",
        "                                     ToTensor()])\n",
        "\n",
        "# testing that you've defined a transform\n",
        "assert(data_transform is not None), 'Define a data_transform'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x4MciVls-PnY"
      },
      "source": [
        "# create the transformed dataset\n",
        "transformed_dataset = FacialKeypointsDataset(csv_file='/data/training_frames_keypoints.csv',\n",
        "                                             root_dir='/data/training/',\n",
        "                                             transform=data_transform)\n",
        "\n",
        "\n",
        "print('Number of images: ', len(transformed_dataset))\n",
        "\n",
        "# perform sanity check over dimensions\n",
        "# iterate through the transformed dataset and print some stats about the first few samples\n",
        "for i in range(4):\n",
        "    sample = transformed_dataset[i]\n",
        "    print(i, sample['image'].size(), sample['keypoints'].size())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Xgmm1JE-Pnc"
      },
      "source": [
        "## Batching and loading data\n",
        "\n",
        "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).\n",
        "\n",
        "#### Batch size\n",
        "Decide on a good batch size for training your model. Try both small and large batch sizes and note how the loss decreases as the model trains. Too large a batch size may cause your model to crash and/or run out of memory while training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HRqcfR8t-Pnc"
      },
      "source": [
        "# load training data in batches\n",
        "batch_size = 40 # initial value 10\n",
        "\n",
        "train_loader = DataLoader(transformed_dataset, \n",
        "                          batch_size=batch_size,\n",
        "                          shuffle=True, \n",
        "                          num_workers=0) # 0 windows user\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Lbz7C8o-Pnh"
      },
      "source": [
        "# Before training\n",
        "\n",
        "Take a look at how this model performs before it trains. You should see that the keypoints it predicts start off in one spot and don't match the keypoints on a face at all! It's interesting to visualize this behavior so that you can compare it to the model after training and see how the model has improved.\n",
        "\n",
        "## Load in the test dataset\n",
        "\n",
        "The test dataset is one that this model has *not* seen before, meaning it has not trained with these images. We'll load in this test data and before and after training, see how your model performs on this set!\n",
        "\n",
        "To visualize this test data, we have to go through some un-transformation steps to turn our images into python images from tensors and to turn our keypoints back into a recognizable range. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_wSwYiys-Pnh"
      },
      "source": [
        "# load in the test data, using the dataset class\n",
        "# AND apply the data_transform you defined above\n",
        "\n",
        "# create the test dataset\n",
        "test_dataset = FacialKeypointsDataset(csv_file='/data/test_frames_keypoints.csv',\n",
        "                                             root_dir='/data/test/',\n",
        "                                             transform=data_transform)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tz2vWf9R-Pnk"
      },
      "source": [
        "# load test data in batches\n",
        "batch_size = 40\n",
        "\n",
        "test_loader = DataLoader(test_dataset, \n",
        "                          batch_size=batch_size,\n",
        "                          shuffle=True, \n",
        "                          num_workers=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QrAqVuSz-Pno"
      },
      "source": [
        "## Apply the model on a test sample\n",
        "\n",
        "To test the model on a test sample of data, you have to follow these steps:\n",
        "1. Extract the image and ground truth keypoints from a sample\n",
        "2. Wrap the image in a Variable, so that the net can process it as input and track how it changes as the image moves through the network.\n",
        "3. Make sure the image is a FloatTensor, which the model expects.\n",
        "4. Forward pass the image through the net to get the predicted, output keypoints.\n",
        "\n",
        "This function test how the network performs on the first batch of test data. It returns the images, the transformed images, the predicted keypoints (produced by the model), and the ground truth keypoints."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L3EZceUr-Pno"
      },
      "source": [
        "Network weights inizializer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EbUn5cHH-Pnp"
      },
      "source": [
        "# customize weights initialization - to improve training performances\n",
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        torch.nn.init.xavier_uniform_(m.weight)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        m.weight.data.normal_(1.0, 0.02)\n",
        "        m.bias.data.fill_(0)\n",
        "    elif classname.find('Linear') != -1:\n",
        "        torch.nn.init.xavier_uniform_(m.weight)\n",
        "        m.bias.data.fill_(0.01)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q2ZtqWkr-Pns"
      },
      "source": [
        "# test the model on a batch of test images\n",
        "\n",
        "def net_sample_output(weight_init=False):\n",
        "    \"\"\"\n",
        "    :param weight_init: <bool> performs weight initialization if True (default:False)\n",
        "    \"\"\"\n",
        "    \n",
        "    # iterate through the test dataset\n",
        "    for i, sample in enumerate(test_loader):\n",
        "        \n",
        "        # get sample data: images and ground truth keypoints\n",
        "        images = sample['image']\n",
        "        key_pts = sample['keypoints']\n",
        "\n",
        "        # convert images to FloatTensors\n",
        "        images = images.type(torch.FloatTensor)\n",
        "\n",
        "        if USE_CUDA and torch.cuda.is_available():\n",
        "              images = images.cuda()\n",
        "\n",
        "        # forward pass to get net output\n",
        "        if weight_init:\n",
        "            net.apply(weights_init)\n",
        "            output_pts = net(images)\n",
        "        else:\n",
        "            output_pts = net(images)\n",
        "            \n",
        "        # reshape to batch_size x 68 x 2 pts\n",
        "        output_pts = output_pts.view(output_pts.size()[0], 68, -1)\n",
        "        \n",
        "        # break after first image is tested\n",
        "        if i == 0:\n",
        "            return images, output_pts, key_pts\n",
        "            "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dEZexVTL-Pn1"
      },
      "source": [
        "# call the above function\n",
        "# returns: test images, test predicted keypoints, test ground truth keypoints\n",
        "test_images, test_outputs, gt_pts = net_sample_output(weight_init=False) # weight initializatio deactivated\n",
        "\n",
        "# print out the dimensions of the data to see if they make sense\n",
        "print(test_images.data.size())\n",
        "print(test_outputs.data.size())\n",
        "print(gt_pts.size())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xLJn57nv-Pn4"
      },
      "source": [
        "## Visualize the predicted keypoints\n",
        "\n",
        "Once we've had the model produce some predicted output keypoints, we can visualize these points in a way that's similar to how we've displayed this data before, only this time, we have to \"un-transform\" the image/keypoint data to display it.\n",
        "\n",
        "Note that I've defined a *new* function, `show_all_keypoints` that displays a grayscale image, its predicted keypoints and its ground truth keypoints (if provided)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KLUIdpA2-Pn5"
      },
      "source": [
        "def show_all_keypoints(image, predicted_key_pts, gt_pts=None):\n",
        "    \"\"\"Show image with predicted keypoints\"\"\"\n",
        "    # image is grayscale\n",
        "    plt.imshow(image, cmap='gray')\n",
        "    plt.scatter(predicted_key_pts[:, 0], predicted_key_pts[:, 1], s=20, marker='.', c='m')\n",
        "    # plot ground truth points as green pts\n",
        "    if gt_pts is not None:\n",
        "        plt.scatter(gt_pts[:, 0], gt_pts[:, 1], s=20, marker='.', c='g')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z6WZsUEy-Pn9"
      },
      "source": [
        "# visualize the output\n",
        "# by default this shows a batch of 10 images\n",
        "def visualize_output(test_images, test_outputs, gt_pts=None, batch_size=10):\n",
        "\n",
        "    for i in range(batch_size):\n",
        "        plt.figure(figsize=(20,10))\n",
        "        ax = plt.subplot(1, batch_size, i+1)\n",
        "\n",
        "        # un-transform the image data\n",
        "        image = test_images[i].data   # get the image from it's Variable wrapper\n",
        "        image = image.cpu() # Ready to work in gpu\n",
        "        image = image.numpy()   # convert to numpy array from a Tensor\n",
        "        image = np.transpose(image, (1, 2, 0))   # transpose to go from torch to numpy image\n",
        "\n",
        "        # un-transform the predicted key_pts data\n",
        "        predicted_key_pts = test_outputs[i].data\n",
        "        predicted_key_pts = predicted_key_pts.cpu() # Ready to work in gpu\n",
        "        predicted_key_pts = predicted_key_pts.numpy()\n",
        "        # undo normalization of keypoints  \n",
        "        predicted_key_pts = predicted_key_pts*50.0+100\n",
        "        \n",
        "        # plot ground truth points for comparison, if they exist\n",
        "        ground_truth_pts = None\n",
        "        if gt_pts is not None:\n",
        "            ground_truth_pts = gt_pts[i]         \n",
        "            ground_truth_pts = ground_truth_pts*50.0+100\n",
        "        \n",
        "        # call show_all_keypoints\n",
        "        show_all_keypoints(np.squeeze(image), predicted_key_pts, ground_truth_pts)\n",
        "            \n",
        "        plt.axis('off')\n",
        "\n",
        "    plt.show()\n",
        "    \n",
        "# call it\n",
        "visualize_output(test_images, test_outputs, gt_pts)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0km8AgzN-PoA"
      },
      "source": [
        "Note: According to the set of weight_init inside net_sample_output, this pictures show random initialized weights or nn.init.xavier_uniform_ weights - This last initialization spread all the weights."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVIFijqb-PoB"
      },
      "source": [
        "# Training\n",
        "\n",
        "## Loss function\n",
        "Training a network to predict keypoints is different than training a network to predict a class; instead of outputting a distribution of classes and using cross entropy loss, you may want to choose a loss function that is suited for regression, which directly compares a predicted value and target value. Read about the various kinds of loss functions (like MSE or L1/SmoothL1 loss) in [this documentation](http://pytorch.org/docs/master/_modules/torch/nn/modules/loss.html).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oreQhF6Z-PoB"
      },
      "source": [
        "## Define the loss and optimization\n",
        "import torch.optim as optim\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001) # 1e-3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4OvK3bFA-PoF"
      },
      "source": [
        "## Training and Initial Observation\n",
        "\n",
        "Now, you'll train on your batched training data from `train_loader` for a number of epochs. \n",
        "\n",
        "To quickly observe how your model is training and decide on whether or not you should modify it's structure or hyperparameters, you're encouraged to start off with just one or two epochs at first. As you train, note how your the model's loss behaves over time: does it decrease quickly at first and then slow down? Does it take a while to decrease in the first place? What happens if you change the batch size of your training data or modify your loss function? etc. \n",
        "\n",
        "Use these initial observations to make changes to your model and decide on the best architecture before you train for many epochs and create a final model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOqUy6Ii-PoG"
      },
      "source": [
        "def train_net(n_epochs):\n",
        "    \n",
        "    loss_over_time = [] # track loss function over batches\n",
        "    \n",
        "    # prepare the net for training\n",
        "    # initialize weights and train\n",
        "    net.apply(weights_init).train()\n",
        "\n",
        "    # initialize random gaussian weights and train\n",
        "    #net.train()\n",
        "    total_batch = 0\n",
        "\n",
        "    for epoch in range(n_epochs):  # loop over the dataset multiple times\n",
        "        \n",
        "        running_loss = 0.0\n",
        "\n",
        "        # train on batches of data, assumes you already have train_loader\n",
        "        for batch_i, data in enumerate(train_loader):\n",
        "            # get the input images and their corresponding labels\n",
        "            images = data['image']\n",
        "            key_pts = data['keypoints']\n",
        "\n",
        "            # flatten pts\n",
        "            key_pts = key_pts.view(key_pts.size(0), -1)\n",
        "\n",
        "            # convert variables to floats for regression loss\n",
        "            key_pts = key_pts.type(torch.FloatTensor)\n",
        "            images = images.type(torch.FloatTensor)\n",
        "\n",
        "            if USE_CUDA and torch.cuda.is_available():\n",
        "              images = images.cuda()\n",
        "              key_pts = key_pts.cuda()\n",
        "\n",
        "            # forward pass to get outputs\n",
        "            output_pts = net(images)\n",
        "\n",
        "            # calculate the loss between predicted and target keypoints\n",
        "            loss = criterion(output_pts, key_pts)\n",
        "\n",
        "            # zero the parameter (weight) gradients\n",
        "            optimizer.zero_grad()\n",
        "            \n",
        "            # backward pass to calculate the weight gradients\n",
        "            loss.backward()\n",
        "\n",
        "            # update the weights\n",
        "            optimizer.step()\n",
        "            \n",
        "            # print loss statistics\n",
        "            running_loss += loss.item()\n",
        "            if batch_i % 10 == 9:    # print every 10 batches\n",
        "                avg_loss = running_loss/10\n",
        "                loss_over_time.append(avg_loss)\n",
        "                total_batch+=10\n",
        "                writer.add_scalar('Loss/train', avg_loss, total_batch)\n",
        "                print('Epoch: {}, Batch: {}, Avg. Loss: {}'.format(epoch + 1, batch_i+1, avg_loss))\n",
        "                running_loss = 0.0\n",
        "\n",
        "    print('Finished Training')\n",
        "    return loss_over_time"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nyDilzFb-PoJ"
      },
      "source": [
        "# train your network\n",
        "writer = SummaryWriter(\"/content/drive/MyDrive/Colab Notebooks/Face_Keypoints_Detection/runs/{}\".format(datetime.datetime.now()))\n",
        "n_epochs = 25 # start small, and increase when you've decided on your model structure and hyperparams\n",
        "\n",
        "train_loss_batches = train_net(n_epochs)\n",
        "writer.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-DgQlOoK-PoM"
      },
      "source": [
        "## Visualizing the loss\n",
        "\n",
        "Explore loss function to optimize batch size and lr"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Qu0ez4r4e2N"
      },
      "source": [
        "%load_ext tensorboard\n",
        "%tensorboard --logdir '/content/drive/MyDrive/Colab Notebooks/Face_Keypoints_Detection/runs'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N2guKSYQ-PoP"
      },
      "source": [
        "# Test data\n",
        "\n",
        "See how your model performs on previously unseen, test data. We've already loaded and transformed this data, similar to the training data. Next, run your trained model on these images to see what kind of keypoints are produced. You should be able to see if your model is fitting each new face it sees, if the points are distributed randomly, or if the points have actually overfitted the training data and do not generalize."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R9ozfFDY-PoQ"
      },
      "source": [
        "# get a sample of test data again\n",
        "test_images, test_outputs, gt_pts = net_sample_output()\n",
        "\n",
        "print(test_images.data.size())\n",
        "print(test_outputs.data.size())\n",
        "print(gt_pts.size())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4N2KAd23-PoT"
      },
      "source": [
        "# visualize your test output\n",
        "# you can use the same function as before, by un-commenting the line below:\n",
        "\n",
        "# visualize_output(test_images, test_outputs, gt_pts)\n",
        "visualize_output(test_images, test_outputs, gt_pts)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LzvWSii0-PoV"
      },
      "source": [
        "Once you've found a good model (or two), save your model so you can load it and use it later!\n",
        "\n",
        "Save your models but please **delete any checkpoints and saved models before you submit your project** otherwise your workspace may be too large to submit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jeky0ogl-PoW"
      },
      "source": [
        "# change the name to something uniqe for each new model\n",
        "# create an unique model id\n",
        "import time\n",
        "ident= str(int(time.time()))\n",
        "\n",
        "# model_dir = 'saved_models/'\n",
        "model_name = '{}_cnn_keypoints_model.pt'.format(ident)\n",
        "\n",
        "checkpoint = {\n",
        "    'state_dict': net.state_dict(),\n",
        "    'optimizer': optimizer.state_dict()}\n",
        "\n",
        "# after training, save your model parameters in the dir 'saved_models'\n",
        "torch.save(checkpoint, \"/content/drive/MyDrive/Colab Notebooks/Face_Keypoints_Detection/saved_models/\"+model_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "enQlaCjX-PoZ"
      },
      "source": [
        "After you've trained a well-performing model, answer the following questions so that we have some insight into your training and architecture selection process. Answering all questions is required to pass this project."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rxnQ6jAD6hDH"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}