2. Define the Network Architecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the Convolutional Neural Network\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": {},
   "source": [
    "## CNN Architecture\n",
    "\n",
    "Recall that CNN's are defined by a few types of layers:\n",
    "* Convolutional layers\n",
    "* Maxpooling layers\n",
    "* Fully-connected layers\n",
    "\n",
    "You are required to use the above layers and encouraged to add multiple convolutional layers and things like dropout layers that may prevent overfitting. You are also encouraged to look at literature on keypoint detection, such as [this paper](https://arxiv.org/pdf/1710.00977.pdf), to help you determine the structure of your network.\n",
    "\n",
    "\n",
    "### TODO: Define your model in the provided file `models.py` file\n",
    "\n",
    "This file is mostly empty but contains the expected name and some TODO's for creating your model.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch Neural Nets\n",
    "\n",
    "To define a neural network in PyTorch, you define the layers of a model in the function `__init__` and define the feedforward behavior of a network that employs those initialized layers in the function `forward`, which takes in an input image tensor, `x`. The structure of this Net class is shown below and left for you to fill in.\n",
    "\n",
    "Note: During training, PyTorch will be able to perform backpropagation by keeping track of the network's feedforward behavior and using autograd to calculate the update to the weights in the network.\n",
    "\n",
    "#### Define the Layers in ` __init__`\n",
    "As a reminder, a conv/pool layer may be defined like this (in `__init__`):\n",
    "```\n",
    "# 1 input image channel (for grayscale images), 32 output channels/feature maps, 3x3 square convolution kernel\n",
    "self.conv1 = nn.Conv2d(1, 32, 3)\n",
    "\n",
    "# maxpool that uses a square window of kernel_size=2, stride=2\n",
    "self.pool = nn.MaxPool2d(2, 2)      \n",
    "```\n",
    "\n",
    "#### Refer to Layers in `forward`\n",
    "Then referred to in the `forward` function like this, in which the conv1 layer has a ReLu activation applied to it before maxpooling is applied:\n",
    "```\n",
    "x = self.pool(F.relu(self.conv1(x)))\n",
    "```\n",
    "\n",
    "Best practice is to place any layers whose weights will change during the training process in `__init__` and refer to them in the `forward` function; any layers or functions that always behave in the same way, such as a pre-defined activation function, should appear *only* in the `forward` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Why models.py\n",
    "\n",
    "You are tasked with defining the network in the `models.py` file so that any models you define can be saved and loaded by name in different notebooks in this project directory. For example, by defining a CNN class called `Net` in `models.py`, you can then create that same architecture in this and other notebooks by simply importing the class and instantiating a model:\n",
    "```\n",
    "    from models import Net\n",
    "    net = Net()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the usual resources\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# watch for any changes in model.py, if it changes, re-load it automatically\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 32, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv3): Conv2d(64, 128, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv5): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (fc1): Linear(in_features=8192, out_features=1000, bias=True)\n",
      "  (fc2): Linear(in_features=1000, out_features=1000, bias=True)\n",
      "  (fc3): Linear(in_features=1000, out_features=136, bias=True)\n",
      "  (dropout1): Dropout(p=0.1)\n",
      "  (dropout2): Dropout(p=0.2)\n",
      "  (dropout3): Dropout(p=0.3)\n",
      "  (dropout4): Dropout(p=0.4)\n",
      "  (dropout5): Dropout(p=0.4)\n",
      "  (dropout6): Dropout(p=0.4)\n",
      ")\n"
     ]
    }
   ],
   "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",
    "\n",
    "## TODO: Once you've define the network, you can instantiate it\n",
    "# one example conv layer has been provided for you\n",
    "from models import Net\n",
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "net = Net()\n",
    "net.cuda()\n",
    "#net.to(device)\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Transform the dataset \n",
    "\n",
    "To prepare for training, create a transformed dataset of images and keypoints.\n",
    "\n",
    "### TODO: Define a data transform\n",
    "\n",
    "In PyTorch, a convolutional neural network expects a torch image of a consistent size as input. For efficient training, and so your model's loss does not blow up during training, it is also suggested that you normalize the input images and keypoints. The necessary transforms have been defined in `data_load.py` and you **do not** need to modify these; take a look at this file (you'll see the same transforms that were defined and applied in Notebook 1).\n",
    "\n",
    "To define the data transform below, use a [composition](http://pytorch.org/tutorials/beginner/data_loading_tutorial.html#compose-transforms) of:\n",
    "1. Rescaling and/or cropping the data, such that you are left with a square image (the suggested size is 224x224px)\n",
    "2. Normalizing the images and keypoints; turning each RGB image into a grayscale image with a color range of [0, 1] and transforming the given keypoints into a range of [-1, 1]\n",
    "3. Turning these images and keypoints into Tensors\n",
    "\n",
    "These transformations have been defined in `data_load.py`, but it's up to you to call them and create a `data_transform` below. **This transform will be applied to the training data and, later, the test data**. It will change how you go about displaying these images and keypoints, but these steps are essential for efficient training.\n",
    "\n",
    "As a note, should you want to perform data augmentation (which is optional in this project), and randomly rotate or shift these images, a square image size will be useful; rotating a 224x224 image by 90 degrees will result in the same shape of output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "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 data_load import FacialKeypointsDataset\n",
    "# the transforms we defined in Notebook 1 are in the helper file `data_load.py`\n",
    "from 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",
    "# testing that you've defined a transform\n",
    "assert(data_transform is not None), 'Define a data_transform'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of images:  3462\n",
      "0 torch.Size([1, 224, 224]) torch.Size([68, 2])\n",
      "1 torch.Size([1, 224, 224]) torch.Size([68, 2])\n",
      "2 torch.Size([1, 224, 224]) torch.Size([68, 2])\n",
      "3 torch.Size([1, 224, 224]) torch.Size([68, 2])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    }
   ],
   "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",
    "# 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())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.\n",
    "\n",
    "**Note for Windows users**: Please change the `num_workers` to 0 or you may face some issues with your DataLoader failing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# load training data in batches\n",
    "batch_size = 10\n",
    "\n",
    "train_loader = DataLoader(transformed_dataset, \n",
    "                          batch_size=batch_size,\n",
    "                          shuffle=True, \n",
    "                          num_workers=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# load test data in batches\n",
    "batch_size = 10\n",
    "\n",
    "test_loader = DataLoader(test_dataset, \n",
    "                          batch_size=batch_size,\n",
    "                          shuffle=True, \n",
    "                          num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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. Make sure the image is a FloatTensor, which the model expects.\n",
    "3. 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": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# test the model on a batch of test images\n",
    "\n",
    "def net_sample_output():\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",
    "        # convert images to FloatTensors\n",
    "        images = images.type(torch.cuda.FloatTensor)\n",
    "\n",
    "        # forward pass to get net output\n",
    "        output_pts = net(images)\n",
    "        output_pts = output_pts\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",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Debugging tips\n",
    "\n",
    "If you get a size or dimension error here, make sure that your network outputs the expected number of keypoints! Or if you get a Tensor type error, look into changing the above code that casts the data into float types: `images = images.type(torch.FloatTensor)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1, 224, 224])\n",
      "torch.Size([10, 68, 2])\n",
      "torch.Size([10, 68, 2])\n"
     ]
    }
   ],
   "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()\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())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Un-transformation\n",
    "\n",
    "Next, you'll see a helper function. `visualize_output` that takes in a batch of images, predicted keypoints, and ground truth keypoints and displays a set of those images and their true/predicted keypoints.\n",
    "\n",
    "This function's main role is to take batches of image and keypoint data (the input and output of your CNN), and transform them into numpy images and un-normalized keypoints (x, y) for normal display. The un-transformation process turns keypoints and images into numpy arrays from Tensors *and* it undoes the keypoint normalization done in the Normalize() transform; it's assumed that you applied these transformations when you loaded your test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIYAAACBCAYAAAAFfMIpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztnWtsJdlV739Vp+q8n3a73e532+2e7p5XR6OQSzJAAkIKCbm6RBcJ5QsiEgm6BCT4QEIihhCIwgeUKJAr+IAgIlISEUQIQeEOjDQzMJmZTN95ZKZf7u5xu2237fbjvE+dR52quh9O1vY+1WV3Ty4Id3SWZPnYPqdctfd/r8d/rb22EQQBIxlJWMz/6hsYyd6UETBGEikjYIwkUkbAGEmkjIAxkkgZAWMkkTICxkgiZQSMkUTKCBgjiRTrv/oGAF588cVd6dcwOxsEAYZhEAQBrusCEIvFuHXrFouLi9y8eZN+v8+zzz7LxsYGsViMfD6PZVl0Oh1isRie52FZFplMBtu2SSQSFItFbNvG8zz6/T7JZJJWq4VhGMTjcXzfB8AwDGzbJhaLAWCaJvF4nGKxSCqVAsCyLBKJBOPj4zz44IOYpkksFsO2bXzfxzTNO54l/Iye5w39LhaLqff5vk+v18P3fTzPU7/vdrssLi6yurrK1tYWrVYL3/cJgkB9ly/f9/n7v/97I2rM9wQwdpOdKHsZUBms+fl5XnnlFebn52k2m8RiMTqdDr1ejyAISCQS6lr9fh/Lskin0ySTSRKJBIlEgng8DkA8HiedTmMYBul0GtM0hyav3+8DqIFOp9Pkcjksy8L3feLxOLFYTH3vdrvYtj10Df25dnpGAZ7+PgGn53k0Gg0cx8E0TXzfxzAMOp0OjuMosHiepz4jn5f7NoxITAD3ATCiRMAgD1qpVHjxxRdZXl7GMAzq9Tpra2s4jkMsFsN1XTqdDq7rqsFOJpMYhoFlWdi2TRAENJtNHMchm83S6/WUFqnX6/T7ffL5PPF4XH3JwLbbbTY2NrBtm2w2i2maeJ5HJpOh2+3SarVIp9MEQYBlWUpjGYYxNKk7SRiQ8nOj0WBjY0NNtGmaBEFAtVql0WjQ7/cVMASU9y0wolSqLoZhDD1Qu93m6tWrLCwskM1mWVpaYmlpiWazSSKRUKpdV80CBM/zaLfbeJ5HKpXCtm3S6TTxeFxplHg8TiqVwvM8er0e3W4X0zRJpVKkUinS6TQAvV6ParWK4zg4joNlWTiOQy6Xo1Ao0Ov1yOVyJJNJZa4EHP1+X5mn8OoOq37Xdel2uziOw5tvvkm5XKbb7aq/y/UEEPIlIj8LyHaSPQeMKNEfzDRNer0elmVhmiatVovl5WXa7Tarq6ssLCxgGAapVEqpd0D5IjJ4MtGu6yrAjI+P0+12aTQaJBIJLMuiVCphmib9fp9ms0mn0wFQfglsg9WyLFzXVX6JAOnAgQN4nkc8Ho+cMFm9suL7/T6+79PtdtVz6z5Eu92mWq3S6XTodrt0u13la+jA0MEl15Av/ZpRcl8AQ9StPKhpmmqil5eXWVtbU1okmUzS6XSU/yCmQzSDTKKsWBHbtmk0GqTTafbv34/ruvR6PTY3N9WEdjodfN8nlUrR6/XUKvc8T02YTJQ4l77vU6/X1f+yLItisahUe7/fp9frkUwmh0Dqui71el2ZCBmDWCxGr9ejVqvRaDSUHyXPBihgAUOaRH4W0NzXwJBJlNewDZSNjQ1efvllFhcXicfjJJNJLMsa8gUsyyKVSmFZFv1+X60mYMguB0FAu92m1+vRbrcBmJiYIJfLqQjEdV01oa1Wi1arpSIY8R8Mw8D3fTKZjLrn+fl5CoUCuVyOtbU1Dh48yJEjR0ilUnS7XeUwyv3EYjEajQa3b98ecjjFSXYcR5ktiUxk8sVMhLVDVOSzm+x5YIRF99Rv3rzJ1tYWqVQK13VJJpMUi0Vc18W2bWDbdIhJkUET1W1ZFvF4XJkGCVNlkjudjlL/siolTI7FYtTrdQClOeS1aDbRCltbW9RqNYrFIul0mqNHj6rwWXwdsfvxeJxarcba2prSIplMRkVOcm3RFrovIs8sIsCScdPBseedz92QHPW3Xq+Hbdt8//vfp9VqKeeu1+sxMTHBrVu3sCyL+fl55WskEgmSySSFQoFEIoHnecocidmRCUilUkq7tFotxT8UCgUFwuXlZSqVCrFYTIW04vcI6ABlBjqdjrrmysoKp06dIpfLKT5iaWmJer2uQuZWq0W5XFbRhTjS2WxW+S+tVusOrRAWCel1s6kDZyfZE8B4qyIOaLVaVare932SySTVahXf9ymVSsTjcfVeGMT+ElEI3yDhqm3biuCSkDIIAnq9HrFYTA1wu91WGimfzw9pEVHj8nMsFlO/syxLmYpiscjm5qb6vPgmtVpNAUmAK5MoIO31ekoTwZ18SBQ4fpjyzfsOGDLgCwsLOI6jHEEZwHq9rlZuoVBQ6llWnZgHy7LI5XJkMhmCIFDg0IEi17FtW3Ehopmy2SzZbJZqtaqAJ6CQ+xTzJeYiHo+zf/9+Op0OzWZT+QlbW1tUq1Xq9br63/qq1skq8X/k/+i+w06m4a3+Hu4DYMiDy0P4vk+z2WRpaWnI1sLAxIijefv2bQqFAvV6XRFN/X6fWq2GZVkcO3aMYrFIoVBQK1kmMhaLqdXe6XTUSpXwUecTLMvCsiw1eToJJepb5w42NjaUgzk/P4/v+ywvL+M4jopQROQa4uD2+/0hsyBaTUAk2kYX3dHWv4f5oLDsCWDs5hDpuQTbtpUqjcfjZDIZ5TeI8ybEkjiceq5DnD0hsjKZDKVSaYheF3Mjk6/fl25WYBAlSFQh96qHhvp9J5NJBT7XdZUJXF9fp1qtAij6XucfdHCFx0XPkcjPEpnoEh7TsB8UJXsCGPqDhPMDumqW7+l0mkQiMbQSJQqBAZchK1dMgmgTyVlI2JpOp9XKk5Up96SDBLbDZFltQqO3220F1lgsNqR9RDtkMhlyuRz5fB5AmUExG3q4uhMFrr8Ok2NR9yv/PwyCu9HhsEeAoUuUxtD/ZhiGUuECCAGJ2PhkMsn6+jrFYlGtvng8TjabJZFI4Lou8XhcRSemaaqkGWxnLpPJJM1mU4XCMqlCQesOpn6fYedQwOG6LuVymePHjytzdeDAAS5evKgmUDSKTK5cX9ccYSZTHycd3HpkpINFQH1fEVx3y5XIyrZtm3a7TavVUiGkPHClUsHzPPU3AYFkUmOxmEqRF4tFYDABQiDpAym0uUyWZFDlPhzHUY6pRBKu66qJ1v2D27dvE4vFyGazKus6MTHByZMnuXjxIoZh0G63dw0nwz6FaDB5Hc6LiIbUx/K+1Bj3ymnYtq28+3w+r2hoMUWFQkHVRAg3kE6nFRMq/oVOT+s5FplYQOVVhAYXES0gNLhwCxJduK5Lv99XmV35LgC6desWW1tbFAoFBbzwxOpaTL7LatdrOnYatygAiNO+GwD3HDB2ulnxC2AACiGH2u026+vrigaXKMW2bWVaBCD5fJ5ms8nRo0cpFotMTExw4MAB5UCGWVBdJGzVU9gyGbpWEUpdootOp0O1WiUIBjUh5XKZWCzG3Nyc4jYWFxeH8hcycWKSwsymSDjzKvepi05sCRjuG+fzXkR3usQnkAFrt9uMj4+TTCaHMpdBEAzVTsjqFAZRHNbwZAjBpa9IGUzRPvJ7nV6XyCadTqtiGQFRr9djbGyMfr+P67qsr6+ryEgnwnSnUiT8u7AW0E3JbqI/Y1Roq8t9AQzd85YHsm1bpd3FqbQsS5kUybLqk9lqtUgmkyrrapomzWZTcQUyuXqyTp8EPRqRv8s9CW0uk5ROp5VvIZpE6jskLO10Oop0059VJFzaF/67Ljo4dpvwe5U9B4y72UqZ9HK5rCZ2fHxchZ0SlgpQZBXlcjkOHjxIOp1WA55KpVSoKb6IAEYvG9TVteu6CqjyHv3+5H/qAJPoBVDVYWNjY4pJFTZTf/5wpBN1LzqnIveg0/N66l9EtOmPhMbQncMgCOh2u2QyGTKZDPV6XUUesmokrCwUCiq8FbPR7/eVhtFZQcmmSq2HnuPQayfCwI1y7nSCTNdEAsBUKqWSfeKL6GZJXktEk0gkFKBFw8FwcXD4nsKsaPh9ei1olNwXwNBtq04T5/N5bty4QRAEaiV3Oh3lJ0hJnvAAruuSSCTIZrMqgyomQAeAnmLXi24gukA3/FoPX+V+xY+IxWLUajXS6TTFYpG1tbWhiEOuo9dVyP8Nk1u75UDCJilsYnSuJUruC2DooqtniUIk8wgorkGYR5kMmWyZKOE9xOTsFgHopiGsfnUHVRfdARaRiW42mypa0okpvQprN00gi2C38dFBoxNd+r3tJvclMAQUUrAr6l/PVZimObTa+/3+UAgokYbusEUNtq7i70YK6X5QmHzSk2yNRkOl/nVtod9j+JryWudW7kVkTO4FDLrsCWBEqeNwOlkGRAAgpkDqH4XdFA0hA5fJZBQxJREJoDYcyf8UswIMaRD531EaQ7fhsO0wCgUvkZQeusZiMZWn2djYUJVg4XBcNIpMqOM4d3ArovV0MIULcvQFEwbcns+uikQBJPxaBkoILJ0Wb7VaKowtFAoKJLqdDqtY/WdxFEUMw1AhqK7iw9fQTY9MvmgM/fNSJCR1m7rjGZU91aMeIeDEURZyTyfwZHzCkU0YvHLfu8meAsZOonv2AohGo0E+n+ehhx7i4YcfptPpsLCwQKfTUSxjr9dTJXWSyZTklV6GJ6L7GCICrrBEfU4fbJ0hlf8pYEkkEmxtbQ35POGC57uZLRmXcJINts1mFMV+r3JfAENWShAESiNUq1UKhQLT09MUi0UmJyd57LHHOH/+PLVaTeUvZHMRMESSyWoUcwLbAwrbvoWwkfI+XXtIkkyns0Uric8gdLtOyuXzea5fv66uIYSX/LyT6IDV2Vb9M+EIZye5GxF2XwAjHHoFQUCxWGRqaopqtcry8jIrKyucPHmSQ4cOqVyFUNEiOiklg6IPbDKZHDIVehZV/q+YBl2L6ISTfr8ycQIYCYmTyeTQhmS5D5GdtFRY5Hq6idSd6XCy7F5oc3Xte3rXf7LsFk+HRQZTsqCrq6sEQcDa2pqiwS3Lot1uK1ssmkDS9XouRI8edLUvgyq1F6I5xFnUQ0DdqdS5CNM0yWazHD58mGqtynpznbgbJ5lKUg8GGdg4cVWVpmumsC8DqJBcaP6dxi3sJ+kgC1eM7yR7AhhvVWQSS6USk5OTdLtdTp8+TbVaZW1tDdu2VTFPr9cjn8+rVLu0PdBjehlgWYGGadDoNyjFS5gxk63OFoV4gZ7bG7z2C0N7SMRfkT2lMHAWU+kUHbPD+uY6n775aRa9RY4Zx+h7fZZ+YgmAfDXPme+dGarW2knF3wvrGjVW4Wvo3MlOsueBsVOWUex3JpNR+0pM0+TQoUNqD2p4n6l86SrfdV38wKfWrzGeGKfv9fnU1U9xuXmZU+lTGBjMOXM8mH8QwzS4ULvAw4WH+YOH/4CSXaLVaqlJld1jvu+zubXJ1xJfY5FF4sTpMigkXggWCIwAfjBf9UId13Yx29umTf+uy70A4a2O6U6y54ERpndFxYozB9u1kVIII3s2avUaDg4H4gfUtXS16nkefa/PE/NPMOfMcSp1il/b92tcal7Cx+eKcwUDAx+fC/ULAPj4vFZ9jQ/++wc5kz3DZ2Y+g9sbcAXr6+vcunWLbrfLamOVxeOLBEZAN+gOgBDAYfMwXt9jJbYCQKFewHZt0FyKHwYA92qO9chrz/MYuz1U2FnSJ7ZYLKoKqc3NTRYWFmg0Gpw4cYJur8szx57hduI2rwav8su9Xx5y0qQqq9wtM+fM4eNztX2VylaFE9YJbvRvMGPP0Ol1WGaZw8ZhfHyWWR58Ho9LzUv87T/9LacOneLQoUO89NJLnD9/fpA88z1S/z2FM+6AC9iQb+f52L6Pcf7Cear9Kk2/ScbJ0LW2d7XrUdLdxkqiovAYhU2RONCAKgO4L4BxN0856iGCICCZTJLNZnFdl1QqxfT0NIlEguPHj/Py3MusV9YJjIBb3KLarTLpTaqNP8o5NLLMxGd4s/cmx2PHGUuM8RE+Qj1Wx9l0+LL/ZYJcwIq3ghfzKDQLGIFBLVuj0CiwNLfEVH6Kfr8/2EDUdjAyBgW7wNh3x5h71xzdfYOJr6fr/KX3l0w3p3nl7CtUMhWKjSKPvvYovIXNYqJFZYIlYgqzoDJO4Wztj4zzGQaFHkFIga/00zKMQQng9P5pTrZPcq1zjQPuAdKkaTQa7Nu3TyXPEokEtm3zxNEnWNhYYHlumTduvkG31yVRSoABlXwFTOgbfTCglqlR/OsixwrHmMxO8gv/8xc4evQo7XabcqVM9X9UaY+3sUyLX07/Mp9pfUb5EwDXe9eZTE5SyVQIzIBqropru8TdQTFRmEXVRXwrnbySqEtE16j6gpNrRrGsUbLngbHTIEniTEJHx3EoFArUajUymQz79+/nieAJXrv2Gu16m47ZoZ/p4zjOULU4DAbwYP4g44+Mky/k+dzq57jSvMLJxEn21/azHl8Hj8FoGeD/gs973fdy5PARjh07Nsi/GDD54CQv7XuJwAhYZJGvel8dAgXAdGKaTCdDoVGglqtRbBSxXfsOJzsqMglPqJ6aD5sYfex+GNnzwIgSYRaFCJLGJrFYjImJCVUul0wkeeDQAyz5S6pYVwAkm4CknH9sbIwgCNjqbHH52mV8fK51r3GicILN7ia2aavIojHW4NGZR5mZnBkUE/e6fPjfPsyFIxeIE8fF5WjsKPPd+e17xuBE/AS/mf5NvtH4Bg+//DBdq4vds/FNf4iE2i2Vr3+X94c1w07sp5iTHwmNEY5K9DoHSWBJl70gGOxSk/ZL8USculdXe0ck59Lr9Wg0GpimqbY5wmAjUb6f56H8Q1ysX2QmNcP19nV8fAUKgDO5M5w7eU7R7TW3xqXGJQICevT4o0N/RMkt8af1P+Vq5yqnUqf4xPQnyJDh5ZdfHnTA8T16dg/P9bBillrlQq7pEuVMRrGrOlMr7wvnS8Qc3U32PDCiRK9zEH9B6htk64Adt/ncyue43rvO8dhxfmf/72AwvJMtmUySyWTUBiFhSj//6Oe53byN3bX5vfnf41rnGgk/QYcOD2w9wJ+N/dlQSn48Oc4jpUd4rfwapxKnOJE5ged5PFF6ghYtxuJjQ9lgz/eY+29zNMeaZCtZznzvDDFj58YmYaCEF4tOh+u9t2C7OEiufV9R4j+MSKgm1VpSw1mv1weFwfkYb958Ex+fBW+BVtBiIj2hnFOpx9S9dAFc3I4zkZrAtVz+8NgfYvwvg2K1SC1dY6w1hoFBN94l8d2Bn+L53gB0DFhTO26TtgYV4QeSB1QTVin+7cQ6NMeaYEKz1MRLesR620XI8nx3e37Y1ia7RRrhNPy9yH0BjKhBChM12WyWdrutGqiVkiVOZ09zuXmZE9YJ8rH8ULodoNls3rHPQv4mBcb2oo1VsTAwGG+Nb99AD9yrLqm3pSh3yny/8n3FhTS8BqcPnlaEmjRGkW57cTdOtpKlWWqSq+RI9BMEDG8a0kP0cBGPvA6LnvPRf6czxmKCf+RK+0Rk4PRueHpfT8Mw+OLbvsj3LnyPfrWvzIRuw4MgUHtPxJToWdBYLEbmcIYevch78PwBSTaWGOOR0iO8Xn6daXsas20qil5aNekaKmbGOPX8KWL5GOkgjWd6BMZwi+hwhlUiEJl8Pb0vLLBe5Saf0QGgL7Bw0VJY7ltgiOgJIfE3ZADTqTRFu8hybHkoNNVrP4UkkqwqbDt0lmURm4zRG+/BlvY/CTAwYHq7WObP3/HnXF+9TnW5qrrwCa8iDp/nDdo899weRsYgF+SwLRvTMId6Y8hzhYtv5EuAC9u8hXA5En3pzyqvIbpIOErue2CICDCku02lUiEg4IvVL3Ldvc7syiyfPPjJoWIa2B4wqRwXVavvKkv9U4r2j7cJNHqy+09d/I6vnF4rZjGWGGMzuYnZM2k0GgCqWUu73SYIAtqdNvM/OU+r1KLYLPKua+8iZg4a5O/2bHohkGy7bDab9Pt9Fa6LRBXuvFX5kQEGbJsXCSNfv/4613vX8Q2fa51rVN0qk/FJYHhLgP75qLJ/M2bC/4H6k3Xq2Tr2aZuSVRpu3tp3+d0rv8uF2gVm4jN8KvspUqkUhmEo38fzPFq0aJYGjmc1V8VLeqRIDVWq676Gfn/yWgqfm83m0D3rGm+31P29JOn2xHklOp9/L19RonvpUsRz/fXrHOUoJibT9jRpPz3UlEQmQ/wKUd+ybdBxHOU0NnoN5g7MUdtfw4pv74qXYuOm3+RC/QIeHtd713n58susr6/jOA71el21mzbbJvlqHsM3KNQLeHWParU61Hxe2ifoFV5h/0PXdP1+X/Uw14uFwg41bPcXC4MuLHtCY7xV6nanKAW2nbR0Oo3X9/iQ+yF6do9ipjiUW9C7+IppkRUrtlxODpBeWRsbG5w9e1bxH6INLMvCci1Op09zqXWJwxymtlrjdva22sTseYO20r7n8+hrj+IlPOL9OL2gp7YBiCmMejY9kpCyQCGqxKeIql3RRcCgJ912kj0BjLcqUUCSiZVVJj000uk0X/e+zkJ1genWNB+f/Lhy0vRKLtheibr2EH9ldXWVI0eO0Gq1uHbtmuoxeuTIESYmJogn4ttd/fDpdDuqPxcMwt9Go4EZM/ESHkbbwDf9O+5f9r5IRNPtdu/gKAS4+j3rEYqM0U7+RThaiZL7Ehh3Ex0c/XifhdYCPj7z7jyVboVEfDuBJitVzJTUdUrEIqDIZrO87W1vU132mq0ma601Vi6tkDfz+Gmf6+nrYMAyyzw7/SxTzpQ6oiIej+P5HpffcZlmsUm2muWh//sQpmEOabtEIqF6eFQqFba2tobaQouEG7HJ36MyqrrIe34kjqUIy91Mj/S3ymazpIM009Y08/15jseOkyGjVLfexRe2TZREOKY5aLNgWRbT09ODOs5UigcfepCvX/86F1sXATjQOzDU+hFg3V7HyBqq/sP3fTacDRr7GmBCo9igGxsk0fTQVPqY27atog9xXPXoRB8H0RawexIOhvmQ3cZxTwDjbiljfUXv9Hl927/0zzh48CDtdpvfHv9tVuuryvmUY7D0LxlQ2echjmAQBOTzeTXwtm1T7Ve53Lqs/v/t+G2ID9/TEfMI+xP7lcmq1Wr0Kj2ysQHjma1kMdoGHttmwvM8Njc36XQ67Nu3b8gx1ouFw9lVfdzErMjvdDMk4BIHfM/7GPqE7waSMN0bfh9sm5F0Ok25XMYwDHK5HCW7pE4KSCaTahWHNxmJAyp5jVKppLrsCYuZ9tOcyZxRGmM2MYthGMx15gA4ylE+an1UkU3ZbBaARr3B7NwsPbuH1bXwuLMvp2w1lKawwoHINobwc4drN2SMwpMu46I/454Hhj4wYYYuave3rkp1H0G3t5ZlUa/X1dlnEnl0e12q/Spp0kN+hVxPLyyOxWJMTk4ORTOe5+H5Hr915LcGhFW7Td7MY5gGjungtByMljG0BwQGB+nUajV8zydBYogo0PeoiG+jm7uw86kvmChw6GZF3qfzNvcNMPRWQ3pH3d1WhLyG4VZGhmGo3t+iNlUTegP+2v9rljaXmG3M8vEDHx8CoAyaFBjrpYJyHJYZM/n0wqe52r7KbHKW3z762+STeRrNwYmGTsuhslZhwVvgkdwj5HI54vE4rVZrsJ3BADcx2C4QM2NDzyWblvQzVXZiNEXC4NAnXAd8lOx5YCwuLgKDG5WjIWzbVsxhFOcfjtmlgWur1eLf/u3f+LEf+zFVhBMEgx3iZs5kqbakqrO22lvsS+1T19b3m8iu9CtXrnDp0mA7Qc2qcezAMa7GruLjM9ee46NzH+VA/wA9t0c5VR7c0CCPxzf5Jn+a+VMajQaNRoOAgGvvuoYz7pDeSnPi2RPY1jZJJs6wgFGPHMLZVgGM7mNElQTqTK6+HfK+2O2+tramTIZ4/plMRrGBQnHLl+6MyoBIyZocyPuBD3xANZMXKcQKHDOPcdO/yQnrxCCzqQ2WhICSK6nX61y9OgDB1458jZ7Rw/IsCo0ClUxlUM9pwJq1pupBgUHFtzFItq3EVgg2A7a2tujEOoPtBCY44w6dWIegFwxlRqP21EJ0ZRfcWR8adiqjFtK9EIp7Ahibm5tqkhuNhuram0gk1JbCqNBMfpYaC8dxeOGFFwCUf7CxsaHOQjUMg9/I/QY1t0bBKgzF87o58jxPNZadmpoiO52lt/CDM0msPh978GNUV6r8mftnP7iJ0AMZ8s1gsj3Jq2uvslxdJmgFpDZTtPe1SW4kMdsmvulHPlsUEHTWUu4Z7gSHbn7CfpT++z1vSprNJjAYDMdxqNVq6iA6OVNE6iVEi8Cw02YYBt/5znd47rnneN/73gfAu9/9bp588kkVMkqOIO/nB+ra61PzahSt4lC+RBzFZDLJuXPnBkdgLGVoeS1MTD67+FlmUjNwl9LJT9ifYH1jnX8s/SOVd1eU+SANXt3Dsi21my4qPS79SaVkTz9lEe6c3HBEslOIf99oDFHhshpkx7o0FwEUeyjN4nXxfZ/nnnuO559/HkAdXGPbNg899BDPPfecoplVs5HA50uNL7HgLXAidoKP5T6G0TUU52AYhmrT5HkeXz33VV5ceZE/Xv3jga/Qvjb458FAM6iU/A/m6TCHcasui5uLVI9UlfkgDaZj0vf7eGyHj7rTLSI8hh5VyPOGRf9bFM8R9d49rzHgTtsoh9G0Wi3W1tYUIGZmZtSkS+vnpaUlnnzySer1uvIPxHk8e/YsjUaDa9eubTuhpkm1W2XBG1DlN7wblLtlMkFGJc3Ez5H60H6/z0nrJLPx2UEqP/DVflS1STkYfB0yDvGLjV9kaXmJixcvks1maZQaZLYydMtdup2uyoRKH8+JiQl1bLgU3ejkm3AvuVxOOZJ6fy1AHRqsdy0ULaMXIukh/k6yZ4ABDDmWkrOQiEN6Z1YqFfbt24fruqTTaSqVCs888wyVSkW1PZCTi6X6++TJk1y9elV9pt/vkyHn7IULAAAQ90lEQVSjHNFjxjEyQQbDNPDjg3rRZDJJKpUaSqYZhsGvxn+Vlc4KX2l/ha30FuPtcQzTYDO5ySH/EL+S/RWS/SRVs8rt9dvcWL/B6RdOU3frJLwEbb+tzJYUM0vCTKIHyf4KQys1JqJBgKGJlrGTkgHRGnpZgT6+InteY4Q9Zr0cTkyLNHwVAATBwNNfWlrilVdeodPpqNB0dXVVXcv3fcbHxzly5Ajr6+sKaMlkkl83f52qWyUTZMCAv2j/BTeDm5zqneJT+U+psE4G1/M88rk8xUKRzwafpRPrcDB/kGwuy1J5icnMJK7rcuPGDUpjJV599FWcxx3mynMce+aYypvIQTq6+pe6im63i2EYqt+57nPojeai6iksy2L//v2qgEiq5gHlr9xrG8g9A4ww7a3bVVn9njdomXz+/Hna7TbLy8sq1Z3JZFTxjGgHx3FotVrk83ne+c538sYbb7C4uKgKgz3PI9VJ0ff7OIbDzeDmoNK7cxXHcNhn71MgTKVS7N+/X9VXyOpuNBo06g2yDE5UbLVaWJbF5Mwk9U4dDGiNt2jRIuEnhsoGZaLltWg7AaScYQ/bTGw4QgvnSgRUuVwOgIMHD6qzVGSR1Wo1YPeyvz0BjDCK5cHl9GO9Sml9fV2d0y6V2LB9XJVhGGxubnLlyhUOHz6srmcYBmfPnsXzPKVR9BqOWDfGIeMQt4xbTNvTxHtxemZPZTr1jjmipvVaCTE1bt8lMZbg6NhRpvpTrJgrJDYS0AIv5g3Zdn0RyLPI9kqp7RSNpS+S8NjpHIhQ6hKGp1IpYrEYhUJhuxRBOxFhJ9lzwJCVKA/b7XaVtmg0Gup4SrjzIDh90K9cucLP/dzPDeUGkskkDzzwAOVyWR1RIa0Vu50uH4p9iIbXoJQoUalUGB8fHxyr1Xep9qsUreJQtZQcYCNhcM/t8YXyF1gqL3Gufo4Pxz7Mn/zvP2Ffet9gewDbTWflOcMOoOR09Kb3+jPsVpmlcyAyhroGkr8nk0nVImon2RPAgOECEn1FttttVQ0t3jUMh3Lys3w3TZPXX38dx3HUcVcSEpdKJd7+9reztLTE4uIiQRCoSq+1tTUyZCCAjY2NQYeevsvntz7PnDPH6cxpfv/47+N7gwF22g61fg27a9NsNrlVvcVicnHQdaf8Gj8T+xmyRhbf8/ECb6izb7joWPdlomoyBRhREi4e1heaSh52t/feSrSls8Jh2TPA0GltWZWu61Kr1YZWqc5QhpNpujSbTZrNJqVSSalm8dInJyfVKc4rKytDR1pILYZ0ALxw4wJXrCv4+FxuXWb+9jyZIIMZM/lC5QvMu/NM9ib5qRs/xdkzZzmbPsvl1mUeLjxM0Skq0yCqXbSaTLQODL32VNcQMuHyHPLsd+MrYFsb607sbtGIyJ4Ahu6VdzodVQshTtNuDxIeEFGhzWaT69evc/DgQbXvQm/imkqleOSRR+j3+ywsLAw1Ye12u0rd9tZ6TOQmWE+scyx2jPZmmw4dHMNhPpjHx2fNXmNyepJz587xE/mfYNPZZDI7yRtvvEE2m8VxnDtaQOp+g/xup+RWuJZTRD+9QCRcwyK/0wuAxezseedzc3NT+RECCnGqwgkzPY4PJ4uEE5BNOH/3d3/H9PQ0J06cGMpcysRks1nOnTvH1NQUN27cIJ1O0+l0uHTpEuVyWTVX+fG5H6fcLdMtd/lW51uDFk+5LKVHS1SyFc7mzvL+R95PJpPB933GEoNeG5lMRvUJ04/lkueQjdh6FjUq0tit1iJq0ejaIezHCN9xN1p8TwBDfAjxK/SiEl30SYU7tYX4KGLLb968yaVLlzh48KACms7+CTgymQypVIoXX3yRcrnMkSNHaDabLCwsEI/HKRaKjMfGKSfKrKysDPatZHN8NPFRzr39HAdyB4YSWjCYgHQ6zeHDh1WkpN+zfh/658LPvFt6POr571XuC+ZTGsMDQ7G6bpf11b7Thlxx5qRGslwu8+///u88/vjjQ1sC9GuKY3rkyBG1Y2xjY0Pdx61bt1QSTt8dPz09zcmZk+xL7bujBTVsb3w6cOAApVKJ559/fsiE6Pesfy78Wt5zt/qJ/2jZE8AI95HSPXBdtUqySffYw6lnMSXSSun111/nlVde4V3vetcQoER7uK6rqPTZ2VkOHz7M008/zRtvvEG73WZ1dVXt8vJ9n6NHjzIzM8Ps7CwTExMqjBaHVQgmGBwAPDs7S6PR4MqVK2xubkaaAAGLPItEUPJcuhOqy1vREFGy5zUGDKvU8NnkMokCjHAltHxORPwJCXH/+Z//mccffxzf91X6Xc8jSJQAgxj/Pe95Dw888ACXL19mcnKSW7du0e/3GR8f5/jx40xNTTE5OakiDsnJ6O2jxcE9fPgw1WpVJcYApaX06GSnAh39GcNle1Fa5G51FlHXjZI9AYywgxSlVqNqGnXRVbRhGHQ6HdLpNN1ul2effRbHcVQrR4lQ9GuJ+ZFM5szMzGD/6/XrHDt2jPHxcRzH4dy5czz22GNqb6tQ4BLViIYT1rZUKrG+vs7Ro0e5devW0E51/Rn1Z4payZLj0Z/3XuoqfljZM8DQv4tErZSdRLSKXr/heYNTCmq1GouLi+zfv19pEp0PCRNEwmG8/vrrPPXUUyrTWqlUuHjxIltbW3zgAx9gamqK1dVV4vG4Agpsn3six4aPjY1x7tw5zp8/r0ydfspA2HHdyTEMj8G9vOeHlT0BDF3CuQRd9LB1p8/pmkNyA/l8njfeeIOHH35Y+QHhz8r3XC5Hq9WiUqnw5ptvcvz4cbU77ODBg5TLZb785S9jWRbvec97VLJKcirdbleZQmkAl0wmOXLkCIVC4Y7Dd3eiuXcbBwHwf6bG2BNtEML+gs5f6L8Xicox6O/V/RHhNP7lX/6FixcvDtl2+ZxEJ7LZuVKp8I1vfIMLFy6Qz+dVIk8meHJykr/6q7/iiSeeoNfrqap2CXsl0yuRydGjRzlz5gz79+/f3vUeikbkmcImVUxTVIVXlOjXEdCFv+T3u6Xg9wQwoiZZNy/663v1xMMramVlhZs3bw5RzHp0o9v5S5cucenSJTqdjtp9JhMiG4Fc1+W5557jW9/6Fo1GY2jnvGQu+/0+tm0zOTnJ2NgYJ0+eHKo9FdEp791Ef9+9fkmkpn/B3SOaPQGM3WS3+P6tfNY0Tf71X/9Vpdx1SlhPzPX7fZ588knW19eB7cYkktZ3XZdWq6Wu/ZWvfIVvfvObVCoVDMNQzqVEPNKKKR6Pc+LECfVaj0LkvVHFN3d7vvDXW5HdTNGeB4ZoCZ2cuheJGqTz58/z9NNPDxXAmKY51O/zqaee4uLFi5jmoI9WpVJR2w2FIpcdY1JZ9uabb/K9731vyPHNZrMqrQ8DIB4/fnwo1S33KM6wnorfKUoLj034626i8yW7yZ5zPneSnRJM9yoyoZcvX1arGBjSGuVymW9/+9v4vq9qMKVzsORypK5DTor+2Z/9Wd797neTSCSo1+tD4BEaPp1Oq+jEcRyy2aw6fUnuQRxWnYQLa5Ww/P9GJXue4NIdR10lRsX2quIqVAirS9TgSGX5zZs3KZfLTE1NqWJjsb1/8zd/w0svvaR2w1mWheM4TE1NkUwmh/pjxeNxHn74YX76p3+a2dnZoeouOeMVBgfcjY+PqxaPomlgUPPRbrfJ5/OKaJOoSfcn5Jn1aGSnxidhfyXsl+l1L7vJngBGlERFIronHaaNowpbwmKaJhsbG6ytrVEqlVQ+xDRNBZwPf/jDlEolvv/97zM3N8fm5iYbGxvUajVmZmYUZ2EYBu985zs5evSomtiVlRVVoqebDPk/xWKRYrFItVplfX0d0zRpt9sUi0WazabyPaRFg17tFQ5RwzmXqLHbyamXqGw307wngbFbhlHXLm8lVyDX6HQ6XL9+nVOnTg0daeE4DmfOnGFiYoLZ2Vkee+wxFhYWeOqpp7h06RK3b99meXmZ/fv3q5pT8T0k5E2n00prSA2GMK2mOTiId9++fXQ6Hd7xjncozTEzM8NTTz2lSDHRGnpqIIp70bVmWMKkmYheOnlfAWMnMicsYaLrbrZV3u/7Pi+99BKPP/44+/btU6X2hmHwwAMPqBDz1KlTnDx5kpMnT/Kd73yHV155Ra22UmlQE3rz5k02NjbI5/PYtk0ymVTRi859iEZqtVqsrq7SbrdVOb/4M7rKv1etcDcnMlyHEQbLbuZkTwAjyqcIJ5WiajB2qsuI4gWEAk+n05w/f57V1VXlZxiGoQiq9fV1arUauVyObrfLoUOHOHv2LPV6nRs3bjA2NkY8HmdjY4NXX32VK1euMDY2pq6RTCZJp9NDLRplV52YJsdxeOaZZ5QzK5rFMAyq1arakCRRTT6fV2SdmBV9G4OulQT8Yb8Chh1tnWSLkj0LjKifo/yGnejxsMhgy57Yl19+mVOnTg36gf6gyFgSa7IhSAa02WzSaDRU4mtsbExt7PnSl77E8vIyH/zgBzly5IjaM2LbtnJuxeRMTU3xvve9T+2Gk8hGKHfZWyJgMk2ThYUFLl++TL1eV9eVDK6epheJcjajKrjuC+fzbjH7WyV+dsqn6DzDt7/9bU6dOsXs7Kxa5bLiJQlmmoOufYuLi8rhlLJ+Sf8/8MADPP300yQSCT7ykY+olH88HledeDY2NojH40xMTPDJT34S2N4HI6ZLHE4xEbIl8/bt27zwwgv8wz/8wxDF7TiOeh7dTIbHNGyi9GvsJnuC4PphmLt7pZFFxOmSrn31ep2VlRWSyaRqCC8TLs5oIpFgeXmZxcVFpQFkh1sQBKpjcCKR4Pnnn1cV5/L/hDST0FXyJPJ5+X+wXUMiEUOz2cRxHMbHx3nve9/LL/3SL1EoFHAch0ajoUixqJV/L4TX3QjDPQOMcP5A/5su90Jy7cYU+r6vjq4QdR2PxxVvIftfNzY26PV63Lhxg6tXr5LL5TAMQ4WuruuSTCbZ2tqi3W7T6/X47ne/qyKNVqtFvV6nVqvhOM6Q75DNZhVoZMc6bJ8y4HkemUyGXC5HPp8nHo9z+vRpfv7nf145snq12k7PG9YK8j4J+8O9SXXZE6ZED7v013oSKPx+ecjwHhN5HQUgGSjhGp577jk+9KEP0W632draIpfLqb5fKysr9Pt9XnjhBWq1GteuXaNYLNJut9VhOQcOHCCZTLK+vk6pVOL8+fPYts373/9+KpUKi4uLdLtd1aCtVquxsbGhDu+TqGN1dZVyuaxILgHG1NSU0hKzs7McP36c8fFxnn76ab773e+qEsJOp0M2m1XA15nTncyLHg5HyZ4ARpTsFqns9v7dRAZGBkR8B/HwBWTJZJKxsTHW1taYn59XtaF6vUc8HlclgrIXptPp0Gg0WF5eZn19Hdu2GRsbGyK7BFT6hElEJKpdfu71erz55pv4vk82m2VycpLHHnuMbDaLbds8+eST5HI5VS0mWlen+6P8rXvJq+wZUxKVJfyPLn4VES3U6XTY2tpSfoHQ1cJUVqtVlTXVaxnEtovmkrbOtVqNcrnM3Nwc9frgWM/x8XHV0kAmSa4hO+/y+TwzMzNMTU0xNjZGqVRSWyvlHDXZMglw+PBhfvInf1JdQ0yx3go6aqO4HrbeDRzGf2YV0EjuX9kTGmMke09GwBhJpIyAMZJIGQFjJJEyAsZIImUEjJFEyggYI4mUETBGEikjYIwkUkbAGEmkjIAxkkgZAWMkkTICxkgiZQSMkUTKCBgjiZQRMEYSKSNgjCRSRsAYSaSMgDGSSBkBYySRMgLGSCJlBIyRRMoIGCOJlP8HuT1q6FSnk+AAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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 wrapper\n",
    "        image = image.cpu().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().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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "\n",
    "### TODO: Define the loss and optimization\n",
    "\n",
    "Next, you'll define how the model will train by deciding on the loss function and optimizer.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## TODO: Define the loss and optimization\n",
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "optimizer = optim.Adam(net.parameters(), lr= 0.00035, betas=(0.8, 0.999))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def train_net(n_epochs):\n",
    "\n",
    "    # prepare the net for training\n",
    "    net.train()\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.cuda.FloatTensor)\n",
    "            images = images.type(torch.cuda.FloatTensor)\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",
    "            # to convert loss into a scalar and add it to the running_loss, use .item()\n",
    "            running_loss += loss.item()\n",
    "            if batch_i % 10 == 9:    # print every 10 batches\n",
    "                print('Epoch: {}, Batch: {}, Avg. Loss: {}'.format(epoch + 1, batch_i+1, running_loss/10))\n",
    "                running_loss = 0.0\n",
    "\n",
    "    print('Finished Training')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Batch: 10, Avg. Loss: 0.4555117696523666\n",
      "Epoch: 1, Batch: 20, Avg. Loss: 0.20455301702022552\n",
      "Epoch: 1, Batch: 30, Avg. Loss: 0.1911424770951271\n",
      "Epoch: 1, Batch: 40, Avg. Loss: 0.2129295326769352\n",
      "Epoch: 1, Batch: 50, Avg. Loss: 0.20100372433662414\n",
      "Epoch: 1, Batch: 60, Avg. Loss: 0.2218430832028389\n",
      "Epoch: 1, Batch: 70, Avg. Loss: 0.18227296322584152\n",
      "Epoch: 1, Batch: 80, Avg. Loss: 0.20888183861970902\n",
      "Epoch: 1, Batch: 90, Avg. Loss: 0.2691180996596813\n",
      "Epoch: 1, Batch: 100, Avg. Loss: 0.16875640377402307\n",
      "Epoch: 1, Batch: 110, Avg. Loss: 0.2030905783176422\n",
      "Epoch: 1, Batch: 120, Avg. Loss: 0.2410380408167839\n",
      "Epoch: 1, Batch: 130, Avg. Loss: 0.23380296528339387\n",
      "Epoch: 1, Batch: 140, Avg. Loss: 0.19825902581214905\n",
      "Epoch: 1, Batch: 150, Avg. Loss: 0.17682207226753235\n",
      "Epoch: 1, Batch: 160, Avg. Loss: 0.1939077138900757\n",
      "Epoch: 1, Batch: 170, Avg. Loss: 0.19905970245599747\n",
      "Epoch: 1, Batch: 180, Avg. Loss: 0.17231457084417343\n",
      "Epoch: 1, Batch: 190, Avg. Loss: 0.1451522670686245\n",
      "Epoch: 1, Batch: 200, Avg. Loss: 0.18598930165171623\n",
      "Epoch: 1, Batch: 210, Avg. Loss: 0.21603272333741189\n",
      "Epoch: 1, Batch: 220, Avg. Loss: 0.17075979560613633\n",
      "Epoch: 1, Batch: 230, Avg. Loss: 0.19481286257505417\n",
      "Epoch: 1, Batch: 240, Avg. Loss: 0.23112834468483925\n",
      "Epoch: 1, Batch: 250, Avg. Loss: 0.2101174920797348\n",
      "Epoch: 1, Batch: 260, Avg. Loss: 0.1866706371307373\n",
      "Epoch: 1, Batch: 270, Avg. Loss: 0.19219007790088655\n",
      "Epoch: 1, Batch: 280, Avg. Loss: 0.15509402081370355\n",
      "Epoch: 1, Batch: 290, Avg. Loss: 0.23355950862169267\n",
      "Epoch: 1, Batch: 300, Avg. Loss: 0.1944763667881489\n",
      "Epoch: 1, Batch: 310, Avg. Loss: 0.2461320772767067\n",
      "Epoch: 1, Batch: 320, Avg. Loss: 0.18328811824321747\n",
      "Epoch: 1, Batch: 330, Avg. Loss: 0.1791627861559391\n",
      "Epoch: 1, Batch: 340, Avg. Loss: 0.2714908294379711\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2, Batch: 10, Avg. Loss: 0.1769939474761486\n",
      "Epoch: 2, Batch: 20, Avg. Loss: 0.16809409335255623\n",
      "Epoch: 2, Batch: 30, Avg. Loss: 0.22580327689647675\n",
      "Epoch: 2, Batch: 40, Avg. Loss: 0.20100677236914635\n",
      "Epoch: 2, Batch: 50, Avg. Loss: 0.20477884784340858\n",
      "Epoch: 2, Batch: 60, Avg. Loss: 0.17607859671115875\n",
      "Epoch: 2, Batch: 70, Avg. Loss: 0.15979394987225531\n",
      "Epoch: 2, Batch: 80, Avg. Loss: 0.1698524348437786\n",
      "Epoch: 2, Batch: 90, Avg. Loss: 0.22518518567085266\n",
      "Epoch: 2, Batch: 100, Avg. Loss: 0.172757438570261\n",
      "Epoch: 2, Batch: 110, Avg. Loss: 0.18648184090852737\n",
      "Epoch: 2, Batch: 120, Avg. Loss: 0.18922101259231566\n",
      "Epoch: 2, Batch: 130, Avg. Loss: 0.22187304943799974\n",
      "Epoch: 2, Batch: 140, Avg. Loss: 0.1626149296760559\n",
      "Epoch: 2, Batch: 150, Avg. Loss: 0.16553905755281448\n",
      "Epoch: 2, Batch: 160, Avg. Loss: 0.18602826744318007\n",
      "Epoch: 2, Batch: 170, Avg. Loss: 0.15524011477828026\n",
      "Epoch: 2, Batch: 180, Avg. Loss: 0.15716970413923265\n",
      "Epoch: 2, Batch: 190, Avg. Loss: 0.1683506779372692\n",
      "Epoch: 2, Batch: 200, Avg. Loss: 0.20394798666238784\n",
      "Epoch: 2, Batch: 210, Avg. Loss: 0.16100894659757614\n",
      "Epoch: 2, Batch: 220, Avg. Loss: 0.2112973541021347\n",
      "Epoch: 2, Batch: 230, Avg. Loss: 0.24918802306056023\n",
      "Epoch: 2, Batch: 240, Avg. Loss: 0.1902128279209137\n",
      "Epoch: 2, Batch: 250, Avg. Loss: 0.20390653759241104\n",
      "Epoch: 2, Batch: 260, Avg. Loss: 0.18128419369459153\n",
      "Epoch: 2, Batch: 270, Avg. Loss: 0.15066924169659615\n",
      "Epoch: 2, Batch: 280, Avg. Loss: 0.15279775634407997\n",
      "Epoch: 2, Batch: 290, Avg. Loss: 0.17930278927087784\n",
      "Epoch: 2, Batch: 300, Avg. Loss: 0.13521394804120063\n",
      "Epoch: 2, Batch: 310, Avg. Loss: 0.1471690244972706\n",
      "Epoch: 2, Batch: 320, Avg. Loss: 0.15147358998656274\n",
      "Epoch: 2, Batch: 330, Avg. Loss: 0.1494288995862007\n",
      "Epoch: 2, Batch: 340, Avg. Loss: 0.13454565554857253\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 3, Batch: 10, Avg. Loss: 0.14637827649712562\n",
      "Epoch: 3, Batch: 20, Avg. Loss: 0.13551078289747237\n",
      "Epoch: 3, Batch: 30, Avg. Loss: 0.1497434303164482\n",
      "Epoch: 3, Batch: 40, Avg. Loss: 0.14409109801054001\n",
      "Epoch: 3, Batch: 50, Avg. Loss: 0.11805829182267188\n",
      "Epoch: 3, Batch: 60, Avg. Loss: 0.15611406415700912\n",
      "Epoch: 3, Batch: 70, Avg. Loss: 0.1910648874938488\n",
      "Epoch: 3, Batch: 80, Avg. Loss: 0.17635596990585328\n",
      "Epoch: 3, Batch: 90, Avg. Loss: 0.13833243697881697\n",
      "Epoch: 3, Batch: 100, Avg. Loss: 0.1487142875790596\n",
      "Epoch: 3, Batch: 110, Avg. Loss: 0.1601279377937317\n",
      "Epoch: 3, Batch: 120, Avg. Loss: 0.2182322047650814\n",
      "Epoch: 3, Batch: 130, Avg. Loss: 0.14154278188943864\n",
      "Epoch: 3, Batch: 140, Avg. Loss: 0.1536344915628433\n",
      "Epoch: 3, Batch: 150, Avg. Loss: 0.13384388759732246\n",
      "Epoch: 3, Batch: 160, Avg. Loss: 0.18547203317284583\n",
      "Epoch: 3, Batch: 170, Avg. Loss: 0.12747715041041374\n",
      "Epoch: 3, Batch: 180, Avg. Loss: 0.13437573313713075\n",
      "Epoch: 3, Batch: 190, Avg. Loss: 0.140921488404274\n",
      "Epoch: 3, Batch: 200, Avg. Loss: 0.14252994135022162\n",
      "Epoch: 3, Batch: 210, Avg. Loss: 0.1585705980658531\n",
      "Epoch: 3, Batch: 220, Avg. Loss: 0.16641609445214273\n",
      "Epoch: 3, Batch: 230, Avg. Loss: 0.13277414068579674\n",
      "Epoch: 3, Batch: 240, Avg. Loss: 0.16954300105571746\n",
      "Epoch: 3, Batch: 250, Avg. Loss: 0.14727857634425162\n",
      "Epoch: 3, Batch: 260, Avg. Loss: 0.1453629083931446\n",
      "Epoch: 3, Batch: 270, Avg. Loss: 0.11704732105135918\n",
      "Epoch: 3, Batch: 280, Avg. Loss: 0.2147488549351692\n",
      "Epoch: 3, Batch: 290, Avg. Loss: 0.14405846558511257\n",
      "Epoch: 3, Batch: 300, Avg. Loss: 0.11927788592875004\n",
      "Epoch: 3, Batch: 310, Avg. Loss: 0.16357876509428024\n",
      "Epoch: 3, Batch: 320, Avg. Loss: 0.1505019560456276\n",
      "Epoch: 3, Batch: 330, Avg. Loss: 0.1363352932035923\n",
      "Epoch: 3, Batch: 340, Avg. Loss: 0.14573454558849336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 4, Batch: 10, Avg. Loss: 0.11738446280360222\n",
      "Epoch: 4, Batch: 20, Avg. Loss: 0.1382874958217144\n",
      "Epoch: 4, Batch: 30, Avg. Loss: 0.17036004438996316\n",
      "Epoch: 4, Batch: 40, Avg. Loss: 0.18771846815943719\n",
      "Epoch: 4, Batch: 50, Avg. Loss: 0.11703699752688408\n",
      "Epoch: 4, Batch: 60, Avg. Loss: 0.1440696891397238\n",
      "Epoch: 4, Batch: 70, Avg. Loss: 0.17032492458820342\n",
      "Epoch: 4, Batch: 80, Avg. Loss: 0.12292063161730767\n",
      "Epoch: 4, Batch: 90, Avg. Loss: 0.1324722096323967\n",
      "Epoch: 4, Batch: 100, Avg. Loss: 0.1259531244635582\n",
      "Epoch: 4, Batch: 110, Avg. Loss: 0.17336716651916503\n",
      "Epoch: 4, Batch: 120, Avg. Loss: 0.18503759801387787\n",
      "Epoch: 4, Batch: 130, Avg. Loss: 0.16782684475183487\n",
      "Epoch: 4, Batch: 140, Avg. Loss: 0.17017940506339074\n",
      "Epoch: 4, Batch: 150, Avg. Loss: 0.09812943488359452\n",
      "Epoch: 4, Batch: 160, Avg. Loss: 0.1540429599583149\n",
      "Epoch: 4, Batch: 170, Avg. Loss: 0.17686067298054695\n",
      "Epoch: 4, Batch: 180, Avg. Loss: 0.1028832383453846\n",
      "Epoch: 4, Batch: 190, Avg. Loss: 0.11383571773767472\n",
      "Epoch: 4, Batch: 200, Avg. Loss: 0.08825511522591115\n",
      "Epoch: 4, Batch: 210, Avg. Loss: 0.1846885558217764\n",
      "Epoch: 4, Batch: 220, Avg. Loss: 0.14906062223017216\n",
      "Epoch: 4, Batch: 230, Avg. Loss: 0.10839082784950733\n",
      "Epoch: 4, Batch: 240, Avg. Loss: 0.1774044033139944\n",
      "Epoch: 4, Batch: 250, Avg. Loss: 0.21605841517448426\n",
      "Epoch: 4, Batch: 260, Avg. Loss: 0.10825341567397118\n",
      "Epoch: 4, Batch: 270, Avg. Loss: 0.13364344723522664\n",
      "Epoch: 4, Batch: 280, Avg. Loss: 0.13567465618252755\n",
      "Epoch: 4, Batch: 290, Avg. Loss: 0.09910062849521636\n",
      "Epoch: 4, Batch: 300, Avg. Loss: 0.09240486584603787\n",
      "Epoch: 4, Batch: 310, Avg. Loss: 0.08548345267772675\n",
      "Epoch: 4, Batch: 320, Avg. Loss: 0.17250701710581778\n",
      "Epoch: 4, Batch: 330, Avg. Loss: 0.11082163415849208\n",
      "Epoch: 4, Batch: 340, Avg. Loss: 0.09249268434941768\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 5, Batch: 10, Avg. Loss: 0.19690849706530572\n",
      "Epoch: 5, Batch: 20, Avg. Loss: 0.12208406701683998\n",
      "Epoch: 5, Batch: 30, Avg. Loss: 0.09977388270199299\n",
      "Epoch: 5, Batch: 40, Avg. Loss: 0.12511304430663586\n",
      "Epoch: 5, Batch: 50, Avg. Loss: 0.07110743671655655\n",
      "Epoch: 5, Batch: 60, Avg. Loss: 0.0828679546713829\n",
      "Epoch: 5, Batch: 70, Avg. Loss: 0.08444738201797009\n",
      "Epoch: 5, Batch: 80, Avg. Loss: 0.09713465422391891\n",
      "Epoch: 5, Batch: 90, Avg. Loss: 0.07698102593421936\n",
      "Epoch: 5, Batch: 100, Avg. Loss: 0.164835886657238\n",
      "Epoch: 5, Batch: 110, Avg. Loss: 0.09442434683442116\n",
      "Epoch: 5, Batch: 120, Avg. Loss: 0.09485811442136764\n",
      "Epoch: 5, Batch: 130, Avg. Loss: 0.16514039859175683\n",
      "Epoch: 5, Batch: 140, Avg. Loss: 0.10441940762102604\n",
      "Epoch: 5, Batch: 150, Avg. Loss: 0.0782107062637806\n",
      "Epoch: 5, Batch: 160, Avg. Loss: 0.07757850997149944\n",
      "Epoch: 5, Batch: 170, Avg. Loss: 0.07772119753062726\n",
      "Epoch: 5, Batch: 180, Avg. Loss: 0.08999979570508003\n",
      "Epoch: 5, Batch: 190, Avg. Loss: 0.07052637711167335\n",
      "Epoch: 5, Batch: 200, Avg. Loss: 0.05872946195304394\n",
      "Epoch: 5, Batch: 210, Avg. Loss: 0.059639619290828706\n",
      "Epoch: 5, Batch: 220, Avg. Loss: 0.05199561398476362\n",
      "Epoch: 5, Batch: 230, Avg. Loss: 0.055936196260154246\n",
      "Epoch: 5, Batch: 240, Avg. Loss: 0.056166546791791915\n",
      "Epoch: 5, Batch: 250, Avg. Loss: 0.09717108011245727\n",
      "Epoch: 5, Batch: 260, Avg. Loss: 0.08411215208470821\n",
      "Epoch: 5, Batch: 270, Avg. Loss: 0.07068626005202532\n",
      "Epoch: 5, Batch: 280, Avg. Loss: 0.13982411250472068\n",
      "Epoch: 5, Batch: 290, Avg. Loss: 0.08428483307361603\n",
      "Epoch: 5, Batch: 300, Avg. Loss: 0.10246977508068085\n",
      "Epoch: 5, Batch: 310, Avg. Loss: 0.06337755620479583\n",
      "Epoch: 5, Batch: 320, Avg. Loss: 0.06185197364538908\n",
      "Epoch: 5, Batch: 330, Avg. Loss: 0.05890490673482418\n",
      "Epoch: 5, Batch: 340, Avg. Loss: 0.06899720802903175\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 6, Batch: 10, Avg. Loss: 0.057813861221075055\n",
      "Epoch: 6, Batch: 20, Avg. Loss: 0.07023188695311547\n",
      "Epoch: 6, Batch: 30, Avg. Loss: 0.15491926930844785\n",
      "Epoch: 6, Batch: 40, Avg. Loss: 0.0669394925236702\n",
      "Epoch: 6, Batch: 50, Avg. Loss: 0.05077890194952488\n",
      "Epoch: 6, Batch: 60, Avg. Loss: 0.05625233240425587\n",
      "Epoch: 6, Batch: 70, Avg. Loss: 0.07762265428900719\n",
      "Epoch: 6, Batch: 80, Avg. Loss: 0.06035775206983089\n",
      "Epoch: 6, Batch: 90, Avg. Loss: 0.06304808426648378\n",
      "Epoch: 6, Batch: 100, Avg. Loss: 0.07829928938299417\n",
      "Epoch: 6, Batch: 110, Avg. Loss: 0.07328031919896602\n",
      "Epoch: 6, Batch: 120, Avg. Loss: 0.1839149847626686\n",
      "Epoch: 6, Batch: 130, Avg. Loss: 0.10552454367280006\n",
      "Epoch: 6, Batch: 140, Avg. Loss: 0.056995895504951474\n",
      "Epoch: 6, Batch: 150, Avg. Loss: 0.07988704107701779\n",
      "Epoch: 6, Batch: 160, Avg. Loss: 0.05190284438431263\n",
      "Epoch: 6, Batch: 170, Avg. Loss: 0.050511830113828184\n",
      "Epoch: 6, Batch: 180, Avg. Loss: 0.08334807567298412\n",
      "Epoch: 6, Batch: 190, Avg. Loss: 0.14296189956367017\n",
      "Epoch: 6, Batch: 200, Avg. Loss: 0.05485675036907196\n",
      "Epoch: 6, Batch: 210, Avg. Loss: 0.06613927017897367\n",
      "Epoch: 6, Batch: 220, Avg. Loss: 0.2923912700265646\n",
      "Epoch: 6, Batch: 230, Avg. Loss: 0.05145129635930061\n",
      "Epoch: 6, Batch: 240, Avg. Loss: 0.0653057549148798\n",
      "Epoch: 6, Batch: 250, Avg. Loss: 0.0863934364169836\n",
      "Epoch: 6, Batch: 260, Avg. Loss: 0.057978369295597076\n",
      "Epoch: 6, Batch: 270, Avg. Loss: 0.07665142063051462\n",
      "Epoch: 6, Batch: 280, Avg. Loss: 0.06364208608865737\n",
      "Epoch: 6, Batch: 290, Avg. Loss: 0.058092858642339706\n",
      "Epoch: 6, Batch: 300, Avg. Loss: 0.08303472027182579\n",
      "Epoch: 6, Batch: 310, Avg. Loss: 0.0467023866251111\n",
      "Epoch: 6, Batch: 320, Avg. Loss: 0.07014451436698436\n",
      "Epoch: 6, Batch: 330, Avg. Loss: 0.07299377284944057\n",
      "Epoch: 6, Batch: 340, Avg. Loss: 0.04487677253782749\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 7, Batch: 10, Avg. Loss: 0.04425049237906933\n",
      "Epoch: 7, Batch: 20, Avg. Loss: 0.04566462095826864\n",
      "Epoch: 7, Batch: 30, Avg. Loss: 0.04460214469581843\n",
      "Epoch: 7, Batch: 40, Avg. Loss: 0.05447829961776733\n",
      "Epoch: 7, Batch: 50, Avg. Loss: 0.05584604907780886\n",
      "Epoch: 7, Batch: 60, Avg. Loss: 0.06595315448939801\n",
      "Epoch: 7, Batch: 70, Avg. Loss: 0.06745215095579624\n",
      "Epoch: 7, Batch: 80, Avg. Loss: 0.07379758190363646\n",
      "Epoch: 7, Batch: 90, Avg. Loss: 0.05810890682041645\n",
      "Epoch: 7, Batch: 100, Avg. Loss: 0.052440996281802654\n",
      "Epoch: 7, Batch: 110, Avg. Loss: 0.03878220152109861\n",
      "Epoch: 7, Batch: 120, Avg. Loss: 0.04634626396000385\n",
      "Epoch: 7, Batch: 130, Avg. Loss: 0.04862495884299278\n",
      "Epoch: 7, Batch: 140, Avg. Loss: 0.07163333371281624\n",
      "Epoch: 7, Batch: 150, Avg. Loss: 0.08203976973891258\n",
      "Epoch: 7, Batch: 160, Avg. Loss: 0.10787005051970482\n",
      "Epoch: 7, Batch: 170, Avg. Loss: 0.05109188258647919\n",
      "Epoch: 7, Batch: 180, Avg. Loss: 0.04193931575864553\n",
      "Epoch: 7, Batch: 190, Avg. Loss: 0.15790436491370202\n",
      "Epoch: 7, Batch: 200, Avg. Loss: 0.040370840765535834\n",
      "Epoch: 7, Batch: 210, Avg. Loss: 0.044447601027786734\n",
      "Epoch: 7, Batch: 220, Avg. Loss: 0.041619691997766495\n",
      "Epoch: 7, Batch: 230, Avg. Loss: 0.05105831939727068\n",
      "Epoch: 7, Batch: 240, Avg. Loss: 0.051825974695384504\n",
      "Epoch: 7, Batch: 250, Avg. Loss: 0.053790144994854926\n",
      "Epoch: 7, Batch: 260, Avg. Loss: 0.06295363940298557\n",
      "Epoch: 7, Batch: 270, Avg. Loss: 0.044097619131207466\n",
      "Epoch: 7, Batch: 280, Avg. Loss: 0.04972092267125845\n",
      "Epoch: 7, Batch: 290, Avg. Loss: 0.05390308815985918\n",
      "Epoch: 7, Batch: 300, Avg. Loss: 0.1224511694163084\n",
      "Epoch: 7, Batch: 310, Avg. Loss: 0.0557684063911438\n",
      "Epoch: 7, Batch: 320, Avg. Loss: 0.060634252801537517\n",
      "Epoch: 7, Batch: 330, Avg. Loss: 0.0514569466933608\n",
      "Epoch: 7, Batch: 340, Avg. Loss: 0.04903580285608768\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 8, Batch: 10, Avg. Loss: 0.048155336454510686\n",
      "Epoch: 8, Batch: 20, Avg. Loss: 0.041059473901987074\n",
      "Epoch: 8, Batch: 30, Avg. Loss: 0.04780473634600639\n",
      "Epoch: 8, Batch: 40, Avg. Loss: 0.04803130533546209\n",
      "Epoch: 8, Batch: 50, Avg. Loss: 0.040542418137192726\n",
      "Epoch: 8, Batch: 60, Avg. Loss: 0.04150754753500223\n",
      "Epoch: 8, Batch: 70, Avg. Loss: 0.03204975239932537\n",
      "Epoch: 8, Batch: 80, Avg. Loss: 0.03571781404316425\n",
      "Epoch: 8, Batch: 90, Avg. Loss: 0.05784222278743982\n",
      "Epoch: 8, Batch: 100, Avg. Loss: 0.03781053405255079\n",
      "Epoch: 8, Batch: 110, Avg. Loss: 0.10130362287163734\n",
      "Epoch: 8, Batch: 120, Avg. Loss: 0.0559680262580514\n",
      "Epoch: 8, Batch: 130, Avg. Loss: 0.14448053743690253\n",
      "Epoch: 8, Batch: 140, Avg. Loss: 0.05288276840001345\n",
      "Epoch: 8, Batch: 150, Avg. Loss: 0.095233797095716\n",
      "Epoch: 8, Batch: 160, Avg. Loss: 0.08873137980699539\n",
      "Epoch: 8, Batch: 170, Avg. Loss: 0.0415448859333992\n",
      "Epoch: 8, Batch: 180, Avg. Loss: 0.03953275363892317\n",
      "Epoch: 8, Batch: 190, Avg. Loss: 0.04052493087947369\n",
      "Epoch: 8, Batch: 200, Avg. Loss: 0.03660714402794838\n",
      "Epoch: 8, Batch: 210, Avg. Loss: 0.044096156023442745\n",
      "Epoch: 8, Batch: 220, Avg. Loss: 0.04286434408277273\n",
      "Epoch: 8, Batch: 230, Avg. Loss: 0.08674309346824885\n",
      "Epoch: 8, Batch: 240, Avg. Loss: 0.05725250206887722\n",
      "Epoch: 8, Batch: 250, Avg. Loss: 0.06928579043596983\n",
      "Epoch: 8, Batch: 260, Avg. Loss: 0.07802828419953585\n",
      "Epoch: 8, Batch: 270, Avg. Loss: 0.04973452966660261\n",
      "Epoch: 8, Batch: 280, Avg. Loss: 0.06301085315644742\n",
      "Epoch: 8, Batch: 290, Avg. Loss: 0.17245728112757205\n",
      "Epoch: 8, Batch: 300, Avg. Loss: 0.08831818029284477\n",
      "Epoch: 8, Batch: 310, Avg. Loss: 0.06148120723664761\n",
      "Epoch: 8, Batch: 320, Avg. Loss: 0.061106641218066214\n",
      "Epoch: 8, Batch: 330, Avg. Loss: 0.04115732684731484\n",
      "Epoch: 8, Batch: 340, Avg. Loss: 0.047823182120919225\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 9, Batch: 10, Avg. Loss: 0.04329895172268152\n",
      "Epoch: 9, Batch: 20, Avg. Loss: 0.04651804398745298\n",
      "Epoch: 9, Batch: 30, Avg. Loss: 0.09336044806987047\n",
      "Epoch: 9, Batch: 40, Avg. Loss: 0.03621298773214221\n",
      "Epoch: 9, Batch: 50, Avg. Loss: 0.03839194718748331\n",
      "Epoch: 9, Batch: 60, Avg. Loss: 0.03573391996324062\n",
      "Epoch: 9, Batch: 70, Avg. Loss: 0.03138942345976829\n",
      "Epoch: 9, Batch: 80, Avg. Loss: 0.03488742709159851\n",
      "Epoch: 9, Batch: 90, Avg. Loss: 0.03342162352055311\n",
      "Epoch: 9, Batch: 100, Avg. Loss: 0.05526166055351496\n",
      "Epoch: 9, Batch: 110, Avg. Loss: 0.0371814452111721\n",
      "Epoch: 9, Batch: 120, Avg. Loss: 0.03856463469564915\n",
      "Epoch: 9, Batch: 130, Avg. Loss: 0.028027365542948247\n",
      "Epoch: 9, Batch: 140, Avg. Loss: 0.04715623613446951\n",
      "Epoch: 9, Batch: 150, Avg. Loss: 0.11144163161516189\n",
      "Epoch: 9, Batch: 160, Avg. Loss: 0.08193104956299066\n",
      "Epoch: 9, Batch: 170, Avg. Loss: 0.07231163680553436\n",
      "Epoch: 9, Batch: 180, Avg. Loss: 0.21940368562936782\n",
      "Epoch: 9, Batch: 190, Avg. Loss: 0.03273898214101791\n",
      "Epoch: 9, Batch: 200, Avg. Loss: 0.05470722336322069\n",
      "Epoch: 9, Batch: 210, Avg. Loss: 0.058568552136421204\n",
      "Epoch: 9, Batch: 220, Avg. Loss: 0.04829741958528757\n",
      "Epoch: 9, Batch: 230, Avg. Loss: 0.10872880443930626\n",
      "Epoch: 9, Batch: 240, Avg. Loss: 0.044343300722539426\n",
      "Epoch: 9, Batch: 250, Avg. Loss: 0.045402093790471554\n",
      "Epoch: 9, Batch: 260, Avg. Loss: 0.06948869433254004\n",
      "Epoch: 9, Batch: 270, Avg. Loss: 0.038453690521419046\n",
      "Epoch: 9, Batch: 280, Avg. Loss: 0.03527045547962189\n",
      "Epoch: 9, Batch: 290, Avg. Loss: 0.07356180641800165\n",
      "Epoch: 9, Batch: 300, Avg. Loss: 0.02889872658997774\n",
      "Epoch: 9, Batch: 310, Avg. Loss: 0.03922989331185818\n",
      "Epoch: 9, Batch: 320, Avg. Loss: 0.032654169201850894\n",
      "Epoch: 9, Batch: 330, Avg. Loss: 0.05258537251502275\n",
      "Epoch: 9, Batch: 340, Avg. Loss: 0.03756960537284613\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 10, Batch: 10, Avg. Loss: 0.033979423344135284\n",
      "Epoch: 10, Batch: 20, Avg. Loss: 0.06221360992640257\n",
      "Epoch: 10, Batch: 30, Avg. Loss: 0.03701868485659361\n",
      "Epoch: 10, Batch: 40, Avg. Loss: 0.04929389040917158\n",
      "Epoch: 10, Batch: 50, Avg. Loss: 0.037955771572887896\n",
      "Epoch: 10, Batch: 60, Avg. Loss: 0.03831181805580854\n",
      "Epoch: 10, Batch: 70, Avg. Loss: 0.08082747720181942\n",
      "Epoch: 10, Batch: 80, Avg. Loss: 0.05543626826256513\n",
      "Epoch: 10, Batch: 90, Avg. Loss: 0.03807003162801266\n",
      "Epoch: 10, Batch: 100, Avg. Loss: 0.04358804877847433\n",
      "Epoch: 10, Batch: 110, Avg. Loss: 0.037088217213749886\n",
      "Epoch: 10, Batch: 120, Avg. Loss: 0.04268985912203789\n",
      "Epoch: 10, Batch: 130, Avg. Loss: 0.05436706356704235\n",
      "Epoch: 10, Batch: 140, Avg. Loss: 0.038823785819113256\n",
      "Epoch: 10, Batch: 150, Avg. Loss: 0.04656973965466023\n",
      "Epoch: 10, Batch: 160, Avg. Loss: 0.12406761534512042\n",
      "Epoch: 10, Batch: 170, Avg. Loss: 0.05264162700623274\n",
      "Epoch: 10, Batch: 180, Avg. Loss: 0.03150341305881739\n",
      "Epoch: 10, Batch: 190, Avg. Loss: 0.035178270749747755\n",
      "Epoch: 10, Batch: 200, Avg. Loss: 0.030958647653460503\n",
      "Epoch: 10, Batch: 210, Avg. Loss: 0.032894583977758886\n",
      "Epoch: 10, Batch: 220, Avg. Loss: 0.029778729379177093\n",
      "Epoch: 10, Batch: 230, Avg. Loss: 0.03681323230266571\n",
      "Epoch: 10, Batch: 240, Avg. Loss: 0.05422742888331413\n",
      "Epoch: 10, Batch: 250, Avg. Loss: 0.057455032505095004\n",
      "Epoch: 10, Batch: 260, Avg. Loss: 0.0332759914919734\n",
      "Epoch: 10, Batch: 270, Avg. Loss: 0.02925803530961275\n",
      "Epoch: 10, Batch: 280, Avg. Loss: 0.03160097934305668\n",
      "Epoch: 10, Batch: 290, Avg. Loss: 0.029770848341286182\n",
      "Epoch: 10, Batch: 300, Avg. Loss: 0.03292221762239933\n",
      "Epoch: 10, Batch: 310, Avg. Loss: 0.040862437710165976\n",
      "Epoch: 10, Batch: 320, Avg. Loss: 0.05412538796663284\n",
      "Epoch: 10, Batch: 330, Avg. Loss: 0.1034705264493823\n",
      "Epoch: 10, Batch: 340, Avg. Loss: 0.06857774443924428\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 11, Batch: 10, Avg. Loss: 0.03946620225906372\n",
      "Epoch: 11, Batch: 20, Avg. Loss: 0.029717928916215896\n",
      "Epoch: 11, Batch: 30, Avg. Loss: 0.039250917918980124\n",
      "Epoch: 11, Batch: 40, Avg. Loss: 0.0316960072144866\n",
      "Epoch: 11, Batch: 50, Avg. Loss: 0.03553255219012499\n",
      "Epoch: 11, Batch: 60, Avg. Loss: 0.21485082302242517\n",
      "Epoch: 11, Batch: 70, Avg. Loss: 0.03200502656400204\n",
      "Epoch: 11, Batch: 80, Avg. Loss: 0.03348298976197839\n",
      "Epoch: 11, Batch: 90, Avg. Loss: 0.033632782846689226\n",
      "Epoch: 11, Batch: 100, Avg. Loss: 0.043471348099410535\n",
      "Epoch: 11, Batch: 110, Avg. Loss: 0.0300468809902668\n",
      "Epoch: 11, Batch: 120, Avg. Loss: 0.03728286176919937\n",
      "Epoch: 11, Batch: 130, Avg. Loss: 0.05281682834029198\n",
      "Epoch: 11, Batch: 140, Avg. Loss: 0.06424611397087573\n",
      "Epoch: 11, Batch: 150, Avg. Loss: 0.08303151316940785\n",
      "Epoch: 11, Batch: 160, Avg. Loss: 0.038778112083673474\n",
      "Epoch: 11, Batch: 170, Avg. Loss: 0.03753060568124056\n",
      "Epoch: 11, Batch: 180, Avg. Loss: 0.03215571492910385\n",
      "Epoch: 11, Batch: 190, Avg. Loss: 0.07542597111314535\n",
      "Epoch: 11, Batch: 200, Avg. Loss: 0.0482922563329339\n",
      "Epoch: 11, Batch: 210, Avg. Loss: 0.057823868840932845\n",
      "Epoch: 11, Batch: 220, Avg. Loss: 0.03361896015703678\n",
      "Epoch: 11, Batch: 230, Avg. Loss: 0.03766448777168989\n",
      "Epoch: 11, Batch: 240, Avg. Loss: 0.04055221248418093\n",
      "Epoch: 11, Batch: 250, Avg. Loss: 0.04396814368665218\n",
      "Epoch: 11, Batch: 260, Avg. Loss: 0.02896712310612202\n",
      "Epoch: 11, Batch: 270, Avg. Loss: 0.04605933595448732\n",
      "Epoch: 11, Batch: 280, Avg. Loss: 0.029764051921665667\n",
      "Epoch: 11, Batch: 290, Avg. Loss: 0.030618295818567277\n",
      "Epoch: 11, Batch: 300, Avg. Loss: 0.03750613983720541\n",
      "Epoch: 11, Batch: 310, Avg. Loss: 0.026071975007653236\n",
      "Epoch: 11, Batch: 320, Avg. Loss: 0.02594914026558399\n",
      "Epoch: 11, Batch: 330, Avg. Loss: 0.030269390530884267\n",
      "Epoch: 11, Batch: 340, Avg. Loss: 0.050435982458293435\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 12, Batch: 10, Avg. Loss: 0.030084196664392947\n",
      "Epoch: 12, Batch: 20, Avg. Loss: 0.026575901545584202\n",
      "Epoch: 12, Batch: 30, Avg. Loss: 0.02812018059194088\n",
      "Epoch: 12, Batch: 40, Avg. Loss: 0.03245800547301769\n",
      "Epoch: 12, Batch: 50, Avg. Loss: 0.030593260191380978\n",
      "Epoch: 12, Batch: 60, Avg. Loss: 0.03397182952612639\n",
      "Epoch: 12, Batch: 70, Avg. Loss: 0.038052068836987016\n",
      "Epoch: 12, Batch: 80, Avg. Loss: 0.03202605322003364\n",
      "Epoch: 12, Batch: 90, Avg. Loss: 0.05666082724928856\n",
      "Epoch: 12, Batch: 100, Avg. Loss: 0.030232788436114787\n",
      "Epoch: 12, Batch: 110, Avg. Loss: 0.097259964607656\n",
      "Epoch: 12, Batch: 120, Avg. Loss: 0.035892119910567996\n",
      "Epoch: 12, Batch: 130, Avg. Loss: 0.03146960884332657\n",
      "Epoch: 12, Batch: 140, Avg. Loss: 0.02722593620419502\n",
      "Epoch: 12, Batch: 150, Avg. Loss: 0.036795221455395224\n",
      "Epoch: 12, Batch: 160, Avg. Loss: 0.03278567530214786\n",
      "Epoch: 12, Batch: 170, Avg. Loss: 0.03229404017329216\n",
      "Epoch: 12, Batch: 180, Avg. Loss: 0.03294095490127802\n",
      "Epoch: 12, Batch: 190, Avg. Loss: 0.03387903617694974\n",
      "Epoch: 12, Batch: 200, Avg. Loss: 0.06214749775826931\n",
      "Epoch: 12, Batch: 210, Avg. Loss: 0.036797129549086094\n",
      "Epoch: 12, Batch: 220, Avg. Loss: 0.03429669979959726\n",
      "Epoch: 12, Batch: 230, Avg. Loss: 0.11326122246682643\n",
      "Epoch: 12, Batch: 240, Avg. Loss: 0.0844390919432044\n",
      "Epoch: 12, Batch: 250, Avg. Loss: 0.033278890512883665\n",
      "Epoch: 12, Batch: 260, Avg. Loss: 0.04800315583124757\n",
      "Epoch: 12, Batch: 270, Avg. Loss: 0.027973862551152705\n",
      "Epoch: 12, Batch: 280, Avg. Loss: 0.04844419434666634\n",
      "Epoch: 12, Batch: 290, Avg. Loss: 0.02801519837230444\n",
      "Epoch: 12, Batch: 300, Avg. Loss: 0.06395571455359458\n",
      "Epoch: 12, Batch: 310, Avg. Loss: 0.02837513219565153\n",
      "Epoch: 12, Batch: 320, Avg. Loss: 0.07467953991144896\n",
      "Epoch: 12, Batch: 330, Avg. Loss: 0.04289952181279659\n",
      "Epoch: 12, Batch: 340, Avg. Loss: 0.05158629268407822\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 13, Batch: 10, Avg. Loss: 0.03296777382493019\n",
      "Epoch: 13, Batch: 20, Avg. Loss: 0.1752743236720562\n",
      "Epoch: 13, Batch: 30, Avg. Loss: 0.04065330578014255\n",
      "Epoch: 13, Batch: 40, Avg. Loss: 0.08093274496495724\n",
      "Epoch: 13, Batch: 50, Avg. Loss: 0.027811709232628344\n",
      "Epoch: 13, Batch: 60, Avg. Loss: 0.05630412083119154\n",
      "Epoch: 13, Batch: 70, Avg. Loss: 0.050511193834245204\n",
      "Epoch: 13, Batch: 80, Avg. Loss: 0.028123950958251952\n",
      "Epoch: 13, Batch: 90, Avg. Loss: 0.02847073171287775\n",
      "Epoch: 13, Batch: 100, Avg. Loss: 0.028423196356743573\n",
      "Epoch: 13, Batch: 110, Avg. Loss: 0.027072505094110966\n",
      "Epoch: 13, Batch: 120, Avg. Loss: 0.052402643486857414\n",
      "Epoch: 13, Batch: 130, Avg. Loss: 0.03349220100790262\n",
      "Epoch: 13, Batch: 140, Avg. Loss: 0.0305155286565423\n",
      "Epoch: 13, Batch: 150, Avg. Loss: 0.21312250029295682\n",
      "Epoch: 13, Batch: 160, Avg. Loss: 0.0585960416123271\n",
      "Epoch: 13, Batch: 170, Avg. Loss: 0.05682316105812788\n",
      "Epoch: 13, Batch: 180, Avg. Loss: 0.028903067205101253\n",
      "Epoch: 13, Batch: 190, Avg. Loss: 0.027072809264063837\n",
      "Epoch: 13, Batch: 200, Avg. Loss: 0.028995630890130998\n",
      "Epoch: 13, Batch: 210, Avg. Loss: 0.052278957515954974\n",
      "Epoch: 13, Batch: 220, Avg. Loss: 0.03338639326393604\n",
      "Epoch: 13, Batch: 230, Avg. Loss: 0.032237923704087734\n",
      "Epoch: 13, Batch: 240, Avg. Loss: 0.03093630336225033\n",
      "Epoch: 13, Batch: 250, Avg. Loss: 0.02428589928895235\n",
      "Epoch: 13, Batch: 260, Avg. Loss: 0.03225713185966015\n",
      "Epoch: 13, Batch: 270, Avg. Loss: 0.026310261711478232\n",
      "Epoch: 13, Batch: 280, Avg. Loss: 0.026293429546058178\n",
      "Epoch: 13, Batch: 290, Avg. Loss: 0.06491747610270977\n",
      "Epoch: 13, Batch: 300, Avg. Loss: 0.02852958030998707\n",
      "Epoch: 13, Batch: 310, Avg. Loss: 0.021387681365013123\n",
      "Epoch: 13, Batch: 320, Avg. Loss: 0.03352063670754433\n",
      "Epoch: 13, Batch: 330, Avg. Loss: 0.029428770020604133\n",
      "Epoch: 13, Batch: 340, Avg. Loss: 0.05190306678414345\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 14, Batch: 10, Avg. Loss: 0.027513963542878626\n",
      "Epoch: 14, Batch: 20, Avg. Loss: 0.02517247386276722\n",
      "Epoch: 14, Batch: 30, Avg. Loss: 0.030173185281455517\n",
      "Epoch: 14, Batch: 40, Avg. Loss: 0.050260547734797004\n",
      "Epoch: 14, Batch: 50, Avg. Loss: 0.030963260866701602\n",
      "Epoch: 14, Batch: 60, Avg. Loss: 0.038772781006991865\n",
      "Epoch: 14, Batch: 70, Avg. Loss: 0.09422437101602554\n",
      "Epoch: 14, Batch: 80, Avg. Loss: 0.03589815441519022\n",
      "Epoch: 14, Batch: 90, Avg. Loss: 0.03896886315196753\n",
      "Epoch: 14, Batch: 100, Avg. Loss: 0.04449778012931347\n",
      "Epoch: 14, Batch: 110, Avg. Loss: 0.030073955841362476\n",
      "Epoch: 14, Batch: 120, Avg. Loss: 0.031976344808936116\n",
      "Epoch: 14, Batch: 130, Avg. Loss: 0.029908221587538718\n",
      "Epoch: 14, Batch: 140, Avg. Loss: 0.028955018892884255\n",
      "Epoch: 14, Batch: 150, Avg. Loss: 0.039372720383107664\n",
      "Epoch: 14, Batch: 160, Avg. Loss: 0.028994864970445632\n",
      "Epoch: 14, Batch: 170, Avg. Loss: 0.026627270691096782\n",
      "Epoch: 14, Batch: 180, Avg. Loss: 0.02666219472885132\n",
      "Epoch: 14, Batch: 190, Avg. Loss: 0.04430642472580075\n",
      "Epoch: 14, Batch: 200, Avg. Loss: 0.028789555467665196\n",
      "Epoch: 14, Batch: 210, Avg. Loss: 0.027768940664827824\n",
      "Epoch: 14, Batch: 220, Avg. Loss: 0.08397682029753924\n",
      "Epoch: 14, Batch: 230, Avg. Loss: 0.025881708599627018\n",
      "Epoch: 14, Batch: 240, Avg. Loss: 0.026328233163803817\n",
      "Epoch: 14, Batch: 250, Avg. Loss: 0.03467815453186631\n",
      "Epoch: 14, Batch: 260, Avg. Loss: 0.023764354549348353\n",
      "Epoch: 14, Batch: 270, Avg. Loss: 0.07116227243095637\n",
      "Epoch: 14, Batch: 280, Avg. Loss: 0.06801064014434814\n",
      "Epoch: 14, Batch: 290, Avg. Loss: 0.060209520440548656\n",
      "Epoch: 14, Batch: 300, Avg. Loss: 0.04430867927148938\n",
      "Epoch: 14, Batch: 310, Avg. Loss: 0.032955757528543475\n",
      "Epoch: 14, Batch: 320, Avg. Loss: 0.027955720946192742\n",
      "Epoch: 14, Batch: 330, Avg. Loss: 0.050625223107635973\n",
      "Epoch: 14, Batch: 340, Avg. Loss: 0.029120043106377124\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 15, Batch: 10, Avg. Loss: 0.021220541931688784\n",
      "Epoch: 15, Batch: 20, Avg. Loss: 0.035316833574324843\n",
      "Epoch: 15, Batch: 30, Avg. Loss: 0.025871103815734386\n",
      "Epoch: 15, Batch: 40, Avg. Loss: 0.03070754501968622\n",
      "Epoch: 15, Batch: 50, Avg. Loss: 0.03695565015077591\n",
      "Epoch: 15, Batch: 60, Avg. Loss: 0.025485272333025933\n",
      "Epoch: 15, Batch: 70, Avg. Loss: 0.023250012565404175\n",
      "Epoch: 15, Batch: 80, Avg. Loss: 0.1292382709681988\n",
      "Epoch: 15, Batch: 90, Avg. Loss: 0.05624239444732666\n",
      "Epoch: 15, Batch: 100, Avg. Loss: 0.038366646692156794\n",
      "Epoch: 15, Batch: 110, Avg. Loss: 0.024935755506157876\n",
      "Epoch: 15, Batch: 120, Avg. Loss: 0.027684517949819566\n",
      "Epoch: 15, Batch: 130, Avg. Loss: 0.027361890487372875\n",
      "Epoch: 15, Batch: 140, Avg. Loss: 0.02300482615828514\n",
      "Epoch: 15, Batch: 150, Avg. Loss: 0.033442719373852015\n",
      "Epoch: 15, Batch: 160, Avg. Loss: 0.0937194736674428\n",
      "Epoch: 15, Batch: 170, Avg. Loss: 0.0729919869452715\n",
      "Epoch: 15, Batch: 180, Avg. Loss: 0.03660330660641194\n",
      "Epoch: 15, Batch: 190, Avg. Loss: 0.028914421796798706\n",
      "Epoch: 15, Batch: 200, Avg. Loss: 0.027632780373096466\n",
      "Epoch: 15, Batch: 210, Avg. Loss: 0.05522931851446629\n",
      "Epoch: 15, Batch: 220, Avg. Loss: 0.02943077785894275\n",
      "Epoch: 15, Batch: 230, Avg. Loss: 0.03665921445935964\n",
      "Epoch: 15, Batch: 240, Avg. Loss: 0.026271990220993757\n",
      "Epoch: 15, Batch: 250, Avg. Loss: 0.027424960024654867\n",
      "Epoch: 15, Batch: 260, Avg. Loss: 0.04634683830663562\n",
      "Epoch: 15, Batch: 270, Avg. Loss: 0.07338684815913439\n",
      "Epoch: 15, Batch: 280, Avg. Loss: 0.030356775783002377\n",
      "Epoch: 15, Batch: 290, Avg. Loss: 0.023164119012653826\n",
      "Epoch: 15, Batch: 300, Avg. Loss: 0.0259931705892086\n",
      "Epoch: 15, Batch: 310, Avg. Loss: 0.025568021927028894\n",
      "Epoch: 15, Batch: 320, Avg. Loss: 0.025110857281833886\n",
      "Epoch: 15, Batch: 330, Avg. Loss: 0.024029853008687495\n",
      "Epoch: 15, Batch: 340, Avg. Loss: 0.029420841857790946\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 16, Batch: 10, Avg. Loss: 0.034199785068631174\n",
      "Epoch: 16, Batch: 20, Avg. Loss: 0.030130036920309067\n",
      "Epoch: 16, Batch: 30, Avg. Loss: 0.06963866213336586\n",
      "Epoch: 16, Batch: 40, Avg. Loss: 0.043826318345963955\n",
      "Epoch: 16, Batch: 50, Avg. Loss: 0.030960554257035255\n",
      "Epoch: 16, Batch: 60, Avg. Loss: 0.02983651766553521\n",
      "Epoch: 16, Batch: 70, Avg. Loss: 0.0325023002922535\n",
      "Epoch: 16, Batch: 80, Avg. Loss: 0.027722661942243577\n",
      "Epoch: 16, Batch: 90, Avg. Loss: 0.03681859504431486\n",
      "Epoch: 16, Batch: 100, Avg. Loss: 0.2197621618397534\n",
      "Epoch: 16, Batch: 110, Avg. Loss: 0.02805856605991721\n",
      "Epoch: 16, Batch: 120, Avg. Loss: 0.02643819246441126\n",
      "Epoch: 16, Batch: 130, Avg. Loss: 0.024542361311614514\n",
      "Epoch: 16, Batch: 140, Avg. Loss: 0.022681013122200964\n",
      "Epoch: 16, Batch: 150, Avg. Loss: 0.024262012913823128\n",
      "Epoch: 16, Batch: 160, Avg. Loss: 0.027457631006836892\n",
      "Epoch: 16, Batch: 170, Avg. Loss: 0.022462243773043157\n",
      "Epoch: 16, Batch: 180, Avg. Loss: 0.02830333951860666\n",
      "Epoch: 16, Batch: 190, Avg. Loss: 0.024582201335579156\n",
      "Epoch: 16, Batch: 200, Avg. Loss: 0.02091034995391965\n",
      "Epoch: 16, Batch: 210, Avg. Loss: 0.042362843081355094\n",
      "Epoch: 16, Batch: 220, Avg. Loss: 0.026950729079544544\n",
      "Epoch: 16, Batch: 230, Avg. Loss: 0.030137645453214644\n",
      "Epoch: 16, Batch: 240, Avg. Loss: 0.02396835871040821\n",
      "Epoch: 16, Batch: 250, Avg. Loss: 0.04389923838898539\n",
      "Epoch: 16, Batch: 260, Avg. Loss: 0.033809608221054076\n",
      "Epoch: 16, Batch: 270, Avg. Loss: 0.027945522218942642\n",
      "Epoch: 16, Batch: 280, Avg. Loss: 0.020094584114849566\n",
      "Epoch: 16, Batch: 290, Avg. Loss: 0.06405625380575657\n",
      "Epoch: 16, Batch: 300, Avg. Loss: 0.03569730538874864\n",
      "Epoch: 16, Batch: 310, Avg. Loss: 0.058961181342601775\n",
      "Epoch: 16, Batch: 320, Avg. Loss: 0.025166987814009188\n",
      "Epoch: 16, Batch: 330, Avg. Loss: 0.03716573715209961\n",
      "Epoch: 16, Batch: 340, Avg. Loss: 0.027647222764790057\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 17, Batch: 10, Avg. Loss: 0.022355921659618617\n",
      "Epoch: 17, Batch: 20, Avg. Loss: 0.04281878042966127\n",
      "Epoch: 17, Batch: 30, Avg. Loss: 0.02359912320971489\n",
      "Epoch: 17, Batch: 40, Avg. Loss: 0.022294162772595882\n",
      "Epoch: 17, Batch: 50, Avg. Loss: 0.030164689291268587\n",
      "Epoch: 17, Batch: 60, Avg. Loss: 0.027152404468506575\n",
      "Epoch: 17, Batch: 70, Avg. Loss: 0.024200862646102904\n",
      "Epoch: 17, Batch: 80, Avg. Loss: 0.02365843765437603\n",
      "Epoch: 17, Batch: 90, Avg. Loss: 0.02196191232651472\n",
      "Epoch: 17, Batch: 100, Avg. Loss: 0.022270149365067483\n",
      "Epoch: 17, Batch: 110, Avg. Loss: 0.023213931266218422\n",
      "Epoch: 17, Batch: 120, Avg. Loss: 0.029854802042245866\n",
      "Epoch: 17, Batch: 130, Avg. Loss: 0.03026933167129755\n",
      "Epoch: 17, Batch: 140, Avg. Loss: 0.02860185271129012\n",
      "Epoch: 17, Batch: 150, Avg. Loss: 0.019857198745012284\n",
      "Epoch: 17, Batch: 160, Avg. Loss: 0.023315643332898615\n",
      "Epoch: 17, Batch: 170, Avg. Loss: 0.08201631447300314\n",
      "Epoch: 17, Batch: 180, Avg. Loss: 0.023890006355941296\n",
      "Epoch: 17, Batch: 190, Avg. Loss: 0.024631564691662788\n",
      "Epoch: 17, Batch: 200, Avg. Loss: 0.06575191281735897\n",
      "Epoch: 17, Batch: 210, Avg. Loss: 0.02403275724500418\n",
      "Epoch: 17, Batch: 220, Avg. Loss: 0.03939910009503365\n",
      "Epoch: 17, Batch: 230, Avg. Loss: 0.02583162235096097\n",
      "Epoch: 17, Batch: 240, Avg. Loss: 0.02507239058613777\n",
      "Epoch: 17, Batch: 250, Avg. Loss: 0.187896073423326\n",
      "Epoch: 17, Batch: 260, Avg. Loss: 0.03411735575646162\n",
      "Epoch: 17, Batch: 270, Avg. Loss: 0.11684923768043518\n",
      "Epoch: 17, Batch: 280, Avg. Loss: 0.029320654273033143\n",
      "Epoch: 17, Batch: 290, Avg. Loss: 0.05311461966484785\n",
      "Epoch: 17, Batch: 300, Avg. Loss: 0.046178440749645236\n",
      "Epoch: 17, Batch: 310, Avg. Loss: 0.033073210157454014\n",
      "Epoch: 17, Batch: 320, Avg. Loss: 0.032261825539171694\n",
      "Epoch: 17, Batch: 330, Avg. Loss: 0.030545206740498543\n",
      "Epoch: 17, Batch: 340, Avg. Loss: 0.03624380212277174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 18, Batch: 10, Avg. Loss: 0.04261935781687498\n",
      "Epoch: 18, Batch: 20, Avg. Loss: 0.03061071652919054\n",
      "Epoch: 18, Batch: 30, Avg. Loss: 0.040229491889476776\n",
      "Epoch: 18, Batch: 40, Avg. Loss: 0.024414676055312157\n",
      "Epoch: 18, Batch: 50, Avg. Loss: 0.025556541047990322\n",
      "Epoch: 18, Batch: 60, Avg. Loss: 0.025935032404959202\n",
      "Epoch: 18, Batch: 70, Avg. Loss: 0.02477931808680296\n",
      "Epoch: 18, Batch: 80, Avg. Loss: 0.023819907754659652\n",
      "Epoch: 18, Batch: 90, Avg. Loss: 0.057474101148545745\n",
      "Epoch: 18, Batch: 100, Avg. Loss: 0.036427016742527484\n",
      "Epoch: 18, Batch: 110, Avg. Loss: 0.03005512896925211\n",
      "Epoch: 18, Batch: 120, Avg. Loss: 0.028039880841970444\n",
      "Epoch: 18, Batch: 130, Avg. Loss: 0.07061345744878053\n",
      "Epoch: 18, Batch: 140, Avg. Loss: 0.08310013897716999\n",
      "Epoch: 18, Batch: 150, Avg. Loss: 0.10287586711347103\n",
      "Epoch: 18, Batch: 160, Avg. Loss: 0.10650841444730759\n",
      "Epoch: 18, Batch: 170, Avg. Loss: 0.03586444985121488\n",
      "Epoch: 18, Batch: 180, Avg. Loss: 0.032114277593791485\n",
      "Epoch: 18, Batch: 190, Avg. Loss: 0.027482415735721587\n",
      "Epoch: 18, Batch: 200, Avg. Loss: 0.025973415933549404\n",
      "Epoch: 18, Batch: 210, Avg. Loss: 0.07414115630090237\n",
      "Epoch: 18, Batch: 220, Avg. Loss: 0.03221452385187149\n",
      "Epoch: 18, Batch: 230, Avg. Loss: 0.03540562689304352\n",
      "Epoch: 18, Batch: 240, Avg. Loss: 0.023297990299761297\n",
      "Epoch: 18, Batch: 250, Avg. Loss: 0.02198114860802889\n",
      "Epoch: 18, Batch: 260, Avg. Loss: 0.026003580912947653\n",
      "Epoch: 18, Batch: 270, Avg. Loss: 0.028950317576527596\n",
      "Epoch: 18, Batch: 280, Avg. Loss: 0.028196477331221104\n",
      "Epoch: 18, Batch: 290, Avg. Loss: 0.23798003997653722\n",
      "Epoch: 18, Batch: 300, Avg. Loss: 0.028703645430505277\n",
      "Epoch: 18, Batch: 310, Avg. Loss: 0.02508826330304146\n",
      "Epoch: 18, Batch: 320, Avg. Loss: 0.027394340746104716\n",
      "Epoch: 18, Batch: 330, Avg. Loss: 0.030887028947472573\n",
      "Epoch: 18, Batch: 340, Avg. Loss: 0.022875943407416343\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 19, Batch: 10, Avg. Loss: 0.05146875325590372\n",
      "Epoch: 19, Batch: 20, Avg. Loss: 0.035919707454741004\n",
      "Epoch: 19, Batch: 30, Avg. Loss: 0.027667607739567758\n",
      "Epoch: 19, Batch: 40, Avg. Loss: 0.03314516991376877\n",
      "Epoch: 19, Batch: 50, Avg. Loss: 0.0317897105589509\n",
      "Epoch: 19, Batch: 60, Avg. Loss: 0.02353319227695465\n",
      "Epoch: 19, Batch: 70, Avg. Loss: 0.029056341759860514\n",
      "Epoch: 19, Batch: 80, Avg. Loss: 0.021678001433610917\n",
      "Epoch: 19, Batch: 90, Avg. Loss: 0.02944003539159894\n",
      "Epoch: 19, Batch: 100, Avg. Loss: 0.027689039800316097\n",
      "Epoch: 19, Batch: 110, Avg. Loss: 0.02333185523748398\n",
      "Epoch: 19, Batch: 120, Avg. Loss: 0.028483594208955763\n",
      "Epoch: 19, Batch: 130, Avg. Loss: 0.022899734042584895\n",
      "Epoch: 19, Batch: 140, Avg. Loss: 0.027737632766366004\n",
      "Epoch: 19, Batch: 150, Avg. Loss: 0.0262572237290442\n",
      "Epoch: 19, Batch: 160, Avg. Loss: 0.0232490886002779\n",
      "Epoch: 19, Batch: 170, Avg. Loss: 0.02552740667015314\n",
      "Epoch: 19, Batch: 180, Avg. Loss: 0.025523627549409865\n",
      "Epoch: 19, Batch: 190, Avg. Loss: 0.021286706253886224\n",
      "Epoch: 19, Batch: 200, Avg. Loss: 0.022871621977537872\n",
      "Epoch: 19, Batch: 210, Avg. Loss: 0.019223794620484114\n",
      "Epoch: 19, Batch: 220, Avg. Loss: 0.04455453492701054\n",
      "Epoch: 19, Batch: 230, Avg. Loss: 0.021511284448206425\n",
      "Epoch: 19, Batch: 240, Avg. Loss: 0.021972560789436102\n",
      "Epoch: 19, Batch: 250, Avg. Loss: 0.0650946481153369\n",
      "Epoch: 19, Batch: 260, Avg. Loss: 0.027427320275455712\n",
      "Epoch: 19, Batch: 270, Avg. Loss: 0.021978656016290187\n",
      "Epoch: 19, Batch: 280, Avg. Loss: 0.02386885052546859\n",
      "Epoch: 19, Batch: 290, Avg. Loss: 0.07472852990031242\n",
      "Epoch: 19, Batch: 300, Avg. Loss: 0.029564661253243685\n",
      "Epoch: 19, Batch: 310, Avg. Loss: 0.0247745243832469\n",
      "Epoch: 19, Batch: 320, Avg. Loss: 0.025844763033092022\n",
      "Epoch: 19, Batch: 330, Avg. Loss: 0.02267533503472805\n",
      "Epoch: 19, Batch: 340, Avg. Loss: 0.025691936444491147\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 20, Batch: 10, Avg. Loss: 0.02871228866279125\n",
      "Epoch: 20, Batch: 20, Avg. Loss: 0.028976506926119326\n",
      "Epoch: 20, Batch: 30, Avg. Loss: 0.024951277114450932\n",
      "Epoch: 20, Batch: 40, Avg. Loss: 0.02096865903586149\n",
      "Epoch: 20, Batch: 50, Avg. Loss: 0.020125385466963054\n",
      "Epoch: 20, Batch: 60, Avg. Loss: 0.023603090085089207\n",
      "Epoch: 20, Batch: 70, Avg. Loss: 0.02601064182817936\n",
      "Epoch: 20, Batch: 80, Avg. Loss: 0.025350293889641762\n",
      "Epoch: 20, Batch: 90, Avg. Loss: 0.030922050587832928\n",
      "Epoch: 20, Batch: 100, Avg. Loss: 0.020359713397920132\n",
      "Epoch: 20, Batch: 110, Avg. Loss: 0.024430787935853005\n",
      "Epoch: 20, Batch: 120, Avg. Loss: 0.03323175394907594\n",
      "Epoch: 20, Batch: 130, Avg. Loss: 0.022665347438305616\n",
      "Epoch: 20, Batch: 140, Avg. Loss: 0.021613131556659938\n",
      "Epoch: 20, Batch: 150, Avg. Loss: 0.024967319797724485\n",
      "Epoch: 20, Batch: 160, Avg. Loss: 0.0395344696007669\n",
      "Epoch: 20, Batch: 170, Avg. Loss: 0.025796251930296422\n",
      "Epoch: 20, Batch: 180, Avg. Loss: 0.030411610193550587\n",
      "Epoch: 20, Batch: 190, Avg. Loss: 0.023519122693687677\n",
      "Epoch: 20, Batch: 200, Avg. Loss: 0.031201748829334974\n",
      "Epoch: 20, Batch: 210, Avg. Loss: 0.036793920584023\n",
      "Epoch: 20, Batch: 220, Avg. Loss: 0.01978746773675084\n",
      "Epoch: 20, Batch: 230, Avg. Loss: 0.026175223477184772\n",
      "Epoch: 20, Batch: 240, Avg. Loss: 0.02666471414268017\n",
      "Epoch: 20, Batch: 250, Avg. Loss: 0.025157031789422035\n",
      "Epoch: 20, Batch: 260, Avg. Loss: 0.06822021082043647\n",
      "Epoch: 20, Batch: 270, Avg. Loss: 0.02470272546634078\n",
      "Epoch: 20, Batch: 280, Avg. Loss: 0.10391019601374865\n",
      "Epoch: 20, Batch: 290, Avg. Loss: 0.041372145898640154\n",
      "Epoch: 20, Batch: 300, Avg. Loss: 0.03337891073897481\n",
      "Epoch: 20, Batch: 310, Avg. Loss: 0.03243197472766042\n",
      "Epoch: 20, Batch: 320, Avg. Loss: 0.019801922515034674\n",
      "Epoch: 20, Batch: 330, Avg. Loss: 0.040879728458821776\n",
      "Epoch: 20, Batch: 340, Avg. Loss: 0.07125926343724132\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 21, Batch: 10, Avg. Loss: 0.05172126032412052\n",
      "Epoch: 21, Batch: 20, Avg. Loss: 0.03228018628433347\n",
      "Epoch: 21, Batch: 30, Avg. Loss: 0.02509433515369892\n",
      "Epoch: 21, Batch: 40, Avg. Loss: 0.02764848116785288\n",
      "Epoch: 21, Batch: 50, Avg. Loss: 0.053676589764654635\n",
      "Epoch: 21, Batch: 60, Avg. Loss: 0.11260282630100846\n",
      "Epoch: 21, Batch: 70, Avg. Loss: 0.06889545302838088\n",
      "Epoch: 21, Batch: 80, Avg. Loss: 0.027012977935373782\n",
      "Epoch: 21, Batch: 90, Avg. Loss: 0.027525752782821655\n",
      "Epoch: 21, Batch: 100, Avg. Loss: 0.04940567146986723\n",
      "Epoch: 21, Batch: 110, Avg. Loss: 0.04745309595018625\n",
      "Epoch: 21, Batch: 120, Avg. Loss: 0.03626829404383898\n",
      "Epoch: 21, Batch: 130, Avg. Loss: 0.03628094512969256\n",
      "Epoch: 21, Batch: 140, Avg. Loss: 0.03168765362352133\n",
      "Epoch: 21, Batch: 150, Avg. Loss: 0.022423248365521432\n",
      "Epoch: 21, Batch: 160, Avg. Loss: 0.10110286511480808\n",
      "Epoch: 21, Batch: 170, Avg. Loss: 0.04117974052205682\n",
      "Epoch: 21, Batch: 180, Avg. Loss: 0.03817957965657115\n",
      "Epoch: 21, Batch: 190, Avg. Loss: 0.025795619655400514\n",
      "Epoch: 21, Batch: 200, Avg. Loss: 0.08329313118010759\n",
      "Epoch: 21, Batch: 210, Avg. Loss: 0.03630531150847673\n",
      "Epoch: 21, Batch: 220, Avg. Loss: 0.038672944717109206\n",
      "Epoch: 21, Batch: 230, Avg. Loss: 0.026371620409190655\n",
      "Epoch: 21, Batch: 240, Avg. Loss: 0.031094312481582165\n",
      "Epoch: 21, Batch: 250, Avg. Loss: 0.03613394256681204\n",
      "Epoch: 21, Batch: 260, Avg. Loss: 0.030134694837033748\n",
      "Epoch: 21, Batch: 270, Avg. Loss: 0.029161652363836766\n",
      "Epoch: 21, Batch: 280, Avg. Loss: 0.031119324173778294\n",
      "Epoch: 21, Batch: 290, Avg. Loss: 0.024368527252227067\n",
      "Epoch: 21, Batch: 300, Avg. Loss: 0.08112737992778421\n",
      "Epoch: 21, Batch: 310, Avg. Loss: 0.030802417919039725\n",
      "Epoch: 21, Batch: 320, Avg. Loss: 0.021773234568536283\n",
      "Epoch: 21, Batch: 330, Avg. Loss: 0.027087080292403698\n",
      "Epoch: 21, Batch: 340, Avg. Loss: 0.028841587156057356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 22, Batch: 10, Avg. Loss: 0.02416424248367548\n",
      "Epoch: 22, Batch: 20, Avg. Loss: 0.023548935912549494\n",
      "Epoch: 22, Batch: 30, Avg. Loss: 0.02218330670148134\n",
      "Epoch: 22, Batch: 40, Avg. Loss: 0.021670596022158862\n",
      "Epoch: 22, Batch: 50, Avg. Loss: 0.025086033903062344\n",
      "Epoch: 22, Batch: 60, Avg. Loss: 0.027756883390247823\n",
      "Epoch: 22, Batch: 70, Avg. Loss: 0.018766959197819233\n",
      "Epoch: 22, Batch: 80, Avg. Loss: 0.11397991525009274\n",
      "Epoch: 22, Batch: 90, Avg. Loss: 0.08151510283350945\n",
      "Epoch: 22, Batch: 100, Avg. Loss: 0.028990183770656586\n",
      "Epoch: 22, Batch: 110, Avg. Loss: 0.05923610329627991\n",
      "Epoch: 22, Batch: 120, Avg. Loss: 0.0273190813139081\n",
      "Epoch: 22, Batch: 130, Avg. Loss: 0.03057241775095463\n",
      "Epoch: 22, Batch: 140, Avg. Loss: 0.026120510697364808\n",
      "Epoch: 22, Batch: 150, Avg. Loss: 0.04832101874053478\n",
      "Epoch: 22, Batch: 160, Avg. Loss: 0.03487218609079719\n",
      "Epoch: 22, Batch: 170, Avg. Loss: 0.03292070534080267\n",
      "Epoch: 22, Batch: 180, Avg. Loss: 0.0808939604088664\n",
      "Epoch: 22, Batch: 190, Avg. Loss: 0.03366558887064457\n",
      "Epoch: 22, Batch: 200, Avg. Loss: 0.032444716431200504\n",
      "Epoch: 22, Batch: 210, Avg. Loss: 0.23436359595507383\n",
      "Epoch: 22, Batch: 220, Avg. Loss: 0.029764556139707566\n",
      "Epoch: 22, Batch: 230, Avg. Loss: 0.022990402393043043\n",
      "Epoch: 22, Batch: 240, Avg. Loss: 0.03102780133485794\n",
      "Epoch: 22, Batch: 250, Avg. Loss: 0.02604270139709115\n",
      "Epoch: 22, Batch: 260, Avg. Loss: 0.02790008010342717\n",
      "Epoch: 22, Batch: 270, Avg. Loss: 0.07031473889946938\n",
      "Epoch: 22, Batch: 280, Avg. Loss: 0.037929832749068734\n",
      "Epoch: 22, Batch: 290, Avg. Loss: 0.03702915487810969\n",
      "Epoch: 22, Batch: 300, Avg. Loss: 0.02399198468774557\n",
      "Epoch: 22, Batch: 310, Avg. Loss: 0.03457585051655769\n",
      "Epoch: 22, Batch: 320, Avg. Loss: 0.02936221770942211\n",
      "Epoch: 22, Batch: 330, Avg. Loss: 0.024981047306209803\n",
      "Epoch: 22, Batch: 340, Avg. Loss: 0.04155785199254751\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 23, Batch: 10, Avg. Loss: 0.03837276417762041\n",
      "Epoch: 23, Batch: 20, Avg. Loss: 0.04550146535038948\n",
      "Epoch: 23, Batch: 30, Avg. Loss: 0.022826685942709445\n",
      "Epoch: 23, Batch: 40, Avg. Loss: 0.0342928497120738\n",
      "Epoch: 23, Batch: 50, Avg. Loss: 0.02251384798437357\n",
      "Epoch: 23, Batch: 60, Avg. Loss: 0.021340032014995812\n",
      "Epoch: 23, Batch: 70, Avg. Loss: 0.026016406156122683\n",
      "Epoch: 23, Batch: 80, Avg. Loss: 0.02650738526135683\n",
      "Epoch: 23, Batch: 90, Avg. Loss: 0.025051751732826234\n",
      "Epoch: 23, Batch: 100, Avg. Loss: 0.03651115885004401\n",
      "Epoch: 23, Batch: 110, Avg. Loss: 0.021312166843563317\n",
      "Epoch: 23, Batch: 120, Avg. Loss: 0.0198831582441926\n",
      "Epoch: 23, Batch: 130, Avg. Loss: 0.037996616959571836\n",
      "Epoch: 23, Batch: 140, Avg. Loss: 0.03014571378007531\n",
      "Epoch: 23, Batch: 150, Avg. Loss: 0.020052216574549676\n",
      "Epoch: 23, Batch: 160, Avg. Loss: 0.026239057444036006\n",
      "Epoch: 23, Batch: 170, Avg. Loss: 0.020610719826072453\n",
      "Epoch: 23, Batch: 180, Avg. Loss: 0.021459908317774536\n",
      "Epoch: 23, Batch: 190, Avg. Loss: 0.02643591780215502\n",
      "Epoch: 23, Batch: 200, Avg. Loss: 0.02416355274617672\n",
      "Epoch: 23, Batch: 210, Avg. Loss: 0.019746425002813338\n",
      "Epoch: 23, Batch: 220, Avg. Loss: 0.021073152869939805\n",
      "Epoch: 23, Batch: 230, Avg. Loss: 0.030018296837806702\n",
      "Epoch: 23, Batch: 240, Avg. Loss: 0.023246935103088617\n",
      "Epoch: 23, Batch: 250, Avg. Loss: 0.03473348198458552\n",
      "Epoch: 23, Batch: 260, Avg. Loss: 0.19953115954995154\n",
      "Epoch: 23, Batch: 270, Avg. Loss: 0.06170077631250024\n",
      "Epoch: 23, Batch: 280, Avg. Loss: 0.03919794596731663\n",
      "Epoch: 23, Batch: 290, Avg. Loss: 0.02825840190052986\n",
      "Epoch: 23, Batch: 300, Avg. Loss: 0.019997138064354658\n",
      "Epoch: 23, Batch: 310, Avg. Loss: 0.025027368776500226\n",
      "Epoch: 23, Batch: 320, Avg. Loss: 0.021801707893610002\n",
      "Epoch: 23, Batch: 330, Avg. Loss: 0.04188219867646694\n",
      "Epoch: 23, Batch: 340, Avg. Loss: 0.027899802662432194\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 24, Batch: 10, Avg. Loss: 0.023794923909008503\n",
      "Epoch: 24, Batch: 20, Avg. Loss: 0.023120265267789365\n",
      "Epoch: 24, Batch: 30, Avg. Loss: 0.026166163757443427\n",
      "Epoch: 24, Batch: 40, Avg. Loss: 0.022708786465227605\n",
      "Epoch: 24, Batch: 50, Avg. Loss: 0.15081500113010407\n",
      "Epoch: 24, Batch: 60, Avg. Loss: 0.08185759317129851\n",
      "Epoch: 24, Batch: 70, Avg. Loss: 0.030363824777305128\n",
      "Epoch: 24, Batch: 80, Avg. Loss: 0.05505706686526537\n",
      "Epoch: 24, Batch: 90, Avg. Loss: 0.12649155054241418\n",
      "Epoch: 24, Batch: 100, Avg. Loss: 0.13123688604682684\n",
      "Epoch: 24, Batch: 110, Avg. Loss: 0.06337139029055834\n",
      "Epoch: 24, Batch: 120, Avg. Loss: 0.020904389210045338\n",
      "Epoch: 24, Batch: 130, Avg. Loss: 0.02493107635527849\n",
      "Epoch: 24, Batch: 140, Avg. Loss: 0.02417263574898243\n",
      "Epoch: 24, Batch: 150, Avg. Loss: 0.036543922126293184\n",
      "Epoch: 24, Batch: 160, Avg. Loss: 0.028022526856511833\n",
      "Epoch: 24, Batch: 170, Avg. Loss: 0.060310174617916344\n",
      "Epoch: 24, Batch: 180, Avg. Loss: 0.024166515190154315\n",
      "Epoch: 24, Batch: 190, Avg. Loss: 0.027763029839843512\n",
      "Epoch: 24, Batch: 200, Avg. Loss: 0.07663576807826758\n",
      "Epoch: 24, Batch: 210, Avg. Loss: 0.02721345890313387\n",
      "Epoch: 24, Batch: 220, Avg. Loss: 0.025880878511816263\n",
      "Epoch: 24, Batch: 230, Avg. Loss: 0.02970179310068488\n",
      "Epoch: 24, Batch: 240, Avg. Loss: 0.10557201690971851\n",
      "Epoch: 24, Batch: 250, Avg. Loss: 0.027466746419668196\n",
      "Epoch: 24, Batch: 260, Avg. Loss: 0.025561440084129573\n",
      "Epoch: 24, Batch: 270, Avg. Loss: 0.027088071033358575\n",
      "Epoch: 24, Batch: 280, Avg. Loss: 0.03921149205416441\n",
      "Epoch: 24, Batch: 290, Avg. Loss: 0.025550044886767865\n",
      "Epoch: 24, Batch: 300, Avg. Loss: 0.02315943520516157\n",
      "Epoch: 24, Batch: 310, Avg. Loss: 0.032893705368041995\n",
      "Epoch: 24, Batch: 320, Avg. Loss: 0.021306092757731675\n",
      "Epoch: 24, Batch: 330, Avg. Loss: 0.03826049212366343\n",
      "Epoch: 24, Batch: 340, Avg. Loss: 0.02343403482809663\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 25, Batch: 10, Avg. Loss: 0.023818278685212135\n",
      "Epoch: 25, Batch: 20, Avg. Loss: 0.022388988733291627\n",
      "Epoch: 25, Batch: 30, Avg. Loss: 0.03006769102066755\n",
      "Epoch: 25, Batch: 40, Avg. Loss: 0.04038132466375828\n",
      "Epoch: 25, Batch: 50, Avg. Loss: 0.02691783681511879\n",
      "Epoch: 25, Batch: 60, Avg. Loss: 0.046807458810508254\n",
      "Epoch: 25, Batch: 70, Avg. Loss: 0.021724974736571312\n",
      "Epoch: 25, Batch: 80, Avg. Loss: 0.02836516806855798\n",
      "Epoch: 25, Batch: 90, Avg. Loss: 0.025316887907683848\n",
      "Epoch: 25, Batch: 100, Avg. Loss: 0.02269696807488799\n",
      "Epoch: 25, Batch: 110, Avg. Loss: 0.03151999209076166\n",
      "Epoch: 25, Batch: 120, Avg. Loss: 0.021086972765624525\n",
      "Epoch: 25, Batch: 130, Avg. Loss: 0.028332906775176525\n",
      "Epoch: 25, Batch: 140, Avg. Loss: 0.05743702556937933\n",
      "Epoch: 25, Batch: 150, Avg. Loss: 0.07641559932380915\n",
      "Epoch: 25, Batch: 160, Avg. Loss: 0.03262677136808634\n",
      "Epoch: 25, Batch: 170, Avg. Loss: 0.023663024231791497\n",
      "Epoch: 25, Batch: 180, Avg. Loss: 0.04350547986105084\n",
      "Epoch: 25, Batch: 190, Avg. Loss: 0.025769704021513462\n",
      "Epoch: 25, Batch: 200, Avg. Loss: 0.027807454578578472\n",
      "Epoch: 25, Batch: 210, Avg. Loss: 0.024743462540209295\n",
      "Epoch: 25, Batch: 220, Avg. Loss: 0.02023612791672349\n",
      "Epoch: 25, Batch: 230, Avg. Loss: 0.021104643307626247\n",
      "Epoch: 25, Batch: 240, Avg. Loss: 0.02879772409796715\n",
      "Epoch: 25, Batch: 250, Avg. Loss: 0.022813028749078514\n",
      "Epoch: 25, Batch: 260, Avg. Loss: 0.02763224858790636\n",
      "Epoch: 25, Batch: 270, Avg. Loss: 0.0257258053869009\n",
      "Epoch: 25, Batch: 280, Avg. Loss: 0.06498337853699923\n",
      "Epoch: 25, Batch: 290, Avg. Loss: 0.021285395976155995\n",
      "Epoch: 25, Batch: 300, Avg. Loss: 0.02100556520745158\n",
      "Epoch: 25, Batch: 310, Avg. Loss: 0.02284577302634716\n",
      "Epoch: 25, Batch: 320, Avg. Loss: 0.02023111442103982\n",
      "Epoch: 25, Batch: 330, Avg. Loss: 0.06232427712529898\n",
      "Epoch: 25, Batch: 340, Avg. Loss: 0.030976052023470403\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 26, Batch: 10, Avg. Loss: 0.15404934976249934\n",
      "Epoch: 26, Batch: 20, Avg. Loss: 0.026746041141450405\n",
      "Epoch: 26, Batch: 30, Avg. Loss: 0.019754953123629092\n",
      "Epoch: 26, Batch: 40, Avg. Loss: 0.02265165625140071\n",
      "Epoch: 26, Batch: 50, Avg. Loss: 0.020024140086025\n",
      "Epoch: 26, Batch: 60, Avg. Loss: 0.022193858213722707\n",
      "Epoch: 26, Batch: 70, Avg. Loss: 0.021155648212879897\n",
      "Epoch: 26, Batch: 80, Avg. Loss: 0.021594001073390247\n",
      "Epoch: 26, Batch: 90, Avg. Loss: 0.023216151259839536\n",
      "Epoch: 26, Batch: 100, Avg. Loss: 0.02333678975701332\n",
      "Epoch: 26, Batch: 110, Avg. Loss: 0.020009199716150762\n",
      "Epoch: 26, Batch: 120, Avg. Loss: 0.023364836908876897\n",
      "Epoch: 26, Batch: 130, Avg. Loss: 0.025788588635623454\n",
      "Epoch: 26, Batch: 140, Avg. Loss: 0.021963387727737427\n",
      "Epoch: 26, Batch: 150, Avg. Loss: 0.0198260935023427\n",
      "Epoch: 26, Batch: 160, Avg. Loss: 0.02362569682300091\n",
      "Epoch: 26, Batch: 170, Avg. Loss: 0.024258569162338973\n",
      "Epoch: 26, Batch: 180, Avg. Loss: 0.02208731006830931\n",
      "Epoch: 26, Batch: 190, Avg. Loss: 0.017477141600102185\n",
      "Epoch: 26, Batch: 200, Avg. Loss: 0.022350667603313924\n",
      "Epoch: 26, Batch: 210, Avg. Loss: 0.021377786248922347\n",
      "Epoch: 26, Batch: 220, Avg. Loss: 0.019204191956669094\n",
      "Epoch: 26, Batch: 230, Avg. Loss: 0.023570451140403747\n",
      "Epoch: 26, Batch: 240, Avg. Loss: 0.02296380205079913\n",
      "Epoch: 26, Batch: 250, Avg. Loss: 0.03183762803673744\n",
      "Epoch: 26, Batch: 260, Avg. Loss: 0.022576175816357135\n",
      "Epoch: 26, Batch: 270, Avg. Loss: 0.020403533428907394\n",
      "Epoch: 26, Batch: 280, Avg. Loss: 0.02230756189674139\n",
      "Epoch: 26, Batch: 290, Avg. Loss: 0.019356308318674565\n",
      "Epoch: 26, Batch: 300, Avg. Loss: 0.022892555221915245\n",
      "Epoch: 26, Batch: 310, Avg. Loss: 0.027045083232223988\n",
      "Epoch: 26, Batch: 320, Avg. Loss: 0.02227593818679452\n",
      "Epoch: 26, Batch: 330, Avg. Loss: 0.02140080165117979\n",
      "Epoch: 26, Batch: 340, Avg. Loss: 0.01935308240354061\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 27, Batch: 10, Avg. Loss: 0.0212590167298913\n",
      "Epoch: 27, Batch: 20, Avg. Loss: 0.027382721100002526\n",
      "Epoch: 27, Batch: 30, Avg. Loss: 0.017333810683339834\n",
      "Epoch: 27, Batch: 40, Avg. Loss: 0.026345957722514867\n",
      "Epoch: 27, Batch: 50, Avg. Loss: 0.039486156590282914\n",
      "Epoch: 27, Batch: 60, Avg. Loss: 0.04858117857947945\n",
      "Epoch: 27, Batch: 70, Avg. Loss: 0.018995219096541404\n",
      "Epoch: 27, Batch: 80, Avg. Loss: 0.042776485346257685\n",
      "Epoch: 27, Batch: 90, Avg. Loss: 0.021949598379433156\n",
      "Epoch: 27, Batch: 100, Avg. Loss: 0.022352248430252075\n",
      "Epoch: 27, Batch: 110, Avg. Loss: 0.0367389352992177\n",
      "Epoch: 27, Batch: 120, Avg. Loss: 0.023170132469385863\n",
      "Epoch: 27, Batch: 130, Avg. Loss: 0.02194294799119234\n",
      "Epoch: 27, Batch: 140, Avg. Loss: 0.019834384229034184\n",
      "Epoch: 27, Batch: 150, Avg. Loss: 0.023280811589211227\n",
      "Epoch: 27, Batch: 160, Avg. Loss: 0.020867957547307015\n",
      "Epoch: 27, Batch: 170, Avg. Loss: 0.018872226215898992\n",
      "Epoch: 27, Batch: 180, Avg. Loss: 0.01905501205474138\n",
      "Epoch: 27, Batch: 190, Avg. Loss: 0.022434788383543493\n",
      "Epoch: 27, Batch: 200, Avg. Loss: 0.01830908199772239\n",
      "Epoch: 27, Batch: 210, Avg. Loss: 0.02142792958766222\n",
      "Epoch: 27, Batch: 220, Avg. Loss: 0.15258582159876824\n",
      "Epoch: 27, Batch: 230, Avg. Loss: 0.04869651980698109\n",
      "Epoch: 27, Batch: 240, Avg. Loss: 0.04659101087599993\n",
      "Epoch: 27, Batch: 250, Avg. Loss: 0.020570012833923103\n",
      "Epoch: 27, Batch: 260, Avg. Loss: 0.021744952630251647\n",
      "Epoch: 27, Batch: 270, Avg. Loss: 0.02346519725397229\n",
      "Epoch: 27, Batch: 280, Avg. Loss: 0.035876397881656884\n",
      "Epoch: 27, Batch: 290, Avg. Loss: 0.0240022549405694\n",
      "Epoch: 27, Batch: 300, Avg. Loss: 0.024057865235954524\n",
      "Epoch: 27, Batch: 310, Avg. Loss: 0.02945043696090579\n",
      "Epoch: 27, Batch: 320, Avg. Loss: 0.024938809126615523\n",
      "Epoch: 27, Batch: 330, Avg. Loss: 0.024175463151186703\n",
      "Epoch: 27, Batch: 340, Avg. Loss: 0.062105574551969765\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 28, Batch: 10, Avg. Loss: 0.023274812288582324\n",
      "Epoch: 28, Batch: 20, Avg. Loss: 0.061193259060382844\n",
      "Epoch: 28, Batch: 30, Avg. Loss: 0.09356917720288038\n",
      "Epoch: 28, Batch: 40, Avg. Loss: 0.022553442884236573\n",
      "Epoch: 28, Batch: 50, Avg. Loss: 0.022301561664789915\n",
      "Epoch: 28, Batch: 60, Avg. Loss: 0.022446733340620993\n",
      "Epoch: 28, Batch: 70, Avg. Loss: 0.026210851967334747\n",
      "Epoch: 28, Batch: 80, Avg. Loss: 0.03292999779805541\n",
      "Epoch: 28, Batch: 90, Avg. Loss: 0.023290217481553556\n",
      "Epoch: 28, Batch: 100, Avg. Loss: 0.020934958942234516\n",
      "Epoch: 28, Batch: 110, Avg. Loss: 0.032015534676611425\n",
      "Epoch: 28, Batch: 120, Avg. Loss: 0.025760242715477943\n",
      "Epoch: 28, Batch: 130, Avg. Loss: 0.025677382480353117\n",
      "Epoch: 28, Batch: 140, Avg. Loss: 0.021197614260017872\n",
      "Epoch: 28, Batch: 150, Avg. Loss: 0.022221196629106998\n",
      "Epoch: 28, Batch: 160, Avg. Loss: 0.02373320357874036\n",
      "Epoch: 28, Batch: 170, Avg. Loss: 0.12235311269760132\n",
      "Epoch: 28, Batch: 180, Avg. Loss: 0.03472804203629494\n",
      "Epoch: 28, Batch: 190, Avg. Loss: 0.11184728480875492\n",
      "Epoch: 28, Batch: 200, Avg. Loss: 0.03812695499509573\n",
      "Epoch: 28, Batch: 210, Avg. Loss: 0.02659955769777298\n",
      "Epoch: 28, Batch: 220, Avg. Loss: 0.049418932385742666\n",
      "Epoch: 28, Batch: 230, Avg. Loss: 0.029675308614969254\n",
      "Epoch: 28, Batch: 240, Avg. Loss: 0.026158117689192295\n",
      "Epoch: 28, Batch: 250, Avg. Loss: 0.023617443814873695\n",
      "Epoch: 28, Batch: 260, Avg. Loss: 0.024643957894295455\n",
      "Epoch: 28, Batch: 270, Avg. Loss: 0.026254774630069734\n",
      "Epoch: 28, Batch: 280, Avg. Loss: 0.0222574888728559\n",
      "Epoch: 28, Batch: 290, Avg. Loss: 0.03265600921586156\n",
      "Epoch: 28, Batch: 300, Avg. Loss: 0.029076347686350347\n",
      "Epoch: 28, Batch: 310, Avg. Loss: 0.024741853680461647\n",
      "Epoch: 28, Batch: 320, Avg. Loss: 0.02050069607794285\n",
      "Epoch: 28, Batch: 330, Avg. Loss: 0.05512280836701393\n",
      "Epoch: 28, Batch: 340, Avg. Loss: 0.03847350934520364\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 29, Batch: 10, Avg. Loss: 0.028934656362980603\n",
      "Epoch: 29, Batch: 20, Avg. Loss: 0.09849797710776328\n",
      "Epoch: 29, Batch: 30, Avg. Loss: 0.025883883610367774\n",
      "Epoch: 29, Batch: 40, Avg. Loss: 0.02442513229325414\n",
      "Epoch: 29, Batch: 50, Avg. Loss: 0.024232211895287036\n",
      "Epoch: 29, Batch: 60, Avg. Loss: 0.025492923427373172\n",
      "Epoch: 29, Batch: 70, Avg. Loss: 0.025521994940936564\n",
      "Epoch: 29, Batch: 80, Avg. Loss: 0.032102945167571305\n",
      "Epoch: 29, Batch: 90, Avg. Loss: 0.02031916743144393\n",
      "Epoch: 29, Batch: 100, Avg. Loss: 0.019562456011772155\n",
      "Epoch: 29, Batch: 110, Avg. Loss: 0.021451608277857304\n",
      "Epoch: 29, Batch: 120, Avg. Loss: 0.02324596615508199\n",
      "Epoch: 29, Batch: 130, Avg. Loss: 0.020435368176549673\n",
      "Epoch: 29, Batch: 140, Avg. Loss: 0.020813980139791965\n",
      "Epoch: 29, Batch: 150, Avg. Loss: 0.030219823028892277\n",
      "Epoch: 29, Batch: 160, Avg. Loss: 0.017739542294293642\n",
      "Epoch: 29, Batch: 170, Avg. Loss: 0.020817933790385722\n",
      "Epoch: 29, Batch: 180, Avg. Loss: 0.11252248175442219\n",
      "Epoch: 29, Batch: 190, Avg. Loss: 0.026605727337300777\n",
      "Epoch: 29, Batch: 200, Avg. Loss: 0.022324414737522603\n",
      "Epoch: 29, Batch: 210, Avg. Loss: 0.02133539579808712\n",
      "Epoch: 29, Batch: 220, Avg. Loss: 0.022467379085719587\n",
      "Epoch: 29, Batch: 230, Avg. Loss: 0.02450409857556224\n",
      "Epoch: 29, Batch: 240, Avg. Loss: 0.02215932421386242\n",
      "Epoch: 29, Batch: 250, Avg. Loss: 0.019438447058200838\n",
      "Epoch: 29, Batch: 260, Avg. Loss: 0.02096640281379223\n",
      "Epoch: 29, Batch: 270, Avg. Loss: 0.020260290522128344\n",
      "Epoch: 29, Batch: 280, Avg. Loss: 0.016901320219039916\n",
      "Epoch: 29, Batch: 290, Avg. Loss: 0.01918546771630645\n",
      "Epoch: 29, Batch: 300, Avg. Loss: 0.019849395472556354\n",
      "Epoch: 29, Batch: 310, Avg. Loss: 0.01689176829531789\n",
      "Epoch: 29, Batch: 320, Avg. Loss: 0.018928019888699056\n",
      "Epoch: 29, Batch: 330, Avg. Loss: 0.020108955912292004\n",
      "Epoch: 29, Batch: 340, Avg. Loss: 0.022043017111718653\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 30, Batch: 10, Avg. Loss: 0.01746406313031912\n",
      "Epoch: 30, Batch: 20, Avg. Loss: 0.0778464381583035\n",
      "Epoch: 30, Batch: 30, Avg. Loss: 0.018881256226450205\n",
      "Epoch: 30, Batch: 40, Avg. Loss: 0.0214286963455379\n",
      "Epoch: 30, Batch: 50, Avg. Loss: 0.02862346712499857\n",
      "Epoch: 30, Batch: 60, Avg. Loss: 0.020752887707203627\n",
      "Epoch: 30, Batch: 70, Avg. Loss: 0.02142951814457774\n",
      "Epoch: 30, Batch: 80, Avg. Loss: 0.0214117843657732\n",
      "Epoch: 30, Batch: 90, Avg. Loss: 0.018397162575274704\n",
      "Epoch: 30, Batch: 100, Avg. Loss: 0.028096459154039622\n",
      "Epoch: 30, Batch: 110, Avg. Loss: 0.018760131672024727\n",
      "Epoch: 30, Batch: 120, Avg. Loss: 0.021881158463656902\n",
      "Epoch: 30, Batch: 130, Avg. Loss: 0.020999081991612913\n",
      "Epoch: 30, Batch: 140, Avg. Loss: 0.024030703864991666\n",
      "Epoch: 30, Batch: 150, Avg. Loss: 0.033700276538729666\n",
      "Epoch: 30, Batch: 160, Avg. Loss: 0.025466037075966598\n",
      "Epoch: 30, Batch: 170, Avg. Loss: 0.022773223742842675\n",
      "Epoch: 30, Batch: 180, Avg. Loss: 0.023176324646919967\n",
      "Epoch: 30, Batch: 190, Avg. Loss: 0.020345956552773714\n",
      "Epoch: 30, Batch: 200, Avg. Loss: 0.03849039152264595\n",
      "Epoch: 30, Batch: 210, Avg. Loss: 0.022331465408205985\n",
      "Epoch: 30, Batch: 220, Avg. Loss: 0.025029340386390687\n",
      "Epoch: 30, Batch: 230, Avg. Loss: 0.0199756926856935\n",
      "Epoch: 30, Batch: 240, Avg. Loss: 0.018769589997828007\n",
      "Epoch: 30, Batch: 250, Avg. Loss: 0.015942239854484796\n",
      "Epoch: 30, Batch: 260, Avg. Loss: 0.01667180946096778\n",
      "Epoch: 30, Batch: 270, Avg. Loss: 0.0165231266990304\n",
      "Epoch: 30, Batch: 280, Avg. Loss: 0.02420121394097805\n",
      "Epoch: 30, Batch: 290, Avg. Loss: 0.019251562654972076\n",
      "Epoch: 30, Batch: 300, Avg. Loss: 0.029088763054460287\n",
      "Epoch: 30, Batch: 310, Avg. Loss: 0.02172407750040293\n",
      "Epoch: 30, Batch: 320, Avg. Loss: 0.01946638561785221\n",
      "Epoch: 30, Batch: 330, Avg. Loss: 0.020010208152234553\n",
      "Epoch: 30, Batch: 340, Avg. Loss: 0.02030415078625083\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 31, Batch: 10, Avg. Loss: 0.024531730357557534\n",
      "Epoch: 31, Batch: 20, Avg. Loss: 0.023361727874726058\n",
      "Epoch: 31, Batch: 30, Avg. Loss: 0.02409408651292324\n",
      "Epoch: 31, Batch: 40, Avg. Loss: 0.04354321509599686\n",
      "Epoch: 31, Batch: 50, Avg. Loss: 0.032525623217225075\n",
      "Epoch: 31, Batch: 60, Avg. Loss: 0.020261739660054446\n",
      "Epoch: 31, Batch: 70, Avg. Loss: 0.05817938763648271\n",
      "Epoch: 31, Batch: 80, Avg. Loss: 0.04779597884044051\n",
      "Epoch: 31, Batch: 90, Avg. Loss: 0.021045692451298236\n",
      "Epoch: 31, Batch: 100, Avg. Loss: 0.021532166004180908\n",
      "Epoch: 31, Batch: 110, Avg. Loss: 0.04979952415451407\n",
      "Epoch: 31, Batch: 120, Avg. Loss: 0.031549060344696046\n",
      "Epoch: 31, Batch: 130, Avg. Loss: 0.023068753816187382\n",
      "Epoch: 31, Batch: 140, Avg. Loss: 0.02137088617309928\n",
      "Epoch: 31, Batch: 150, Avg. Loss: 0.02582274116575718\n",
      "Epoch: 31, Batch: 160, Avg. Loss: 0.0208842852152884\n",
      "Epoch: 31, Batch: 170, Avg. Loss: 0.028231027908623217\n",
      "Epoch: 31, Batch: 180, Avg. Loss: 0.020086669269949196\n",
      "Epoch: 31, Batch: 190, Avg. Loss: 0.023109066672623156\n",
      "Epoch: 31, Batch: 200, Avg. Loss: 0.03319982821121812\n",
      "Epoch: 31, Batch: 210, Avg. Loss: 0.02071527661755681\n",
      "Epoch: 31, Batch: 220, Avg. Loss: 0.01936387103050947\n",
      "Epoch: 31, Batch: 230, Avg. Loss: 0.021203309949487447\n",
      "Epoch: 31, Batch: 240, Avg. Loss: 0.17926498595625162\n",
      "Epoch: 31, Batch: 250, Avg. Loss: 0.020191772282123564\n",
      "Epoch: 31, Batch: 260, Avg. Loss: 0.02351811435073614\n",
      "Epoch: 31, Batch: 270, Avg. Loss: 0.024501494597643614\n",
      "Epoch: 31, Batch: 280, Avg. Loss: 0.023132290691137314\n",
      "Epoch: 31, Batch: 290, Avg. Loss: 0.02371091563254595\n",
      "Epoch: 31, Batch: 300, Avg. Loss: 0.028490840550512077\n",
      "Epoch: 31, Batch: 310, Avg. Loss: 0.02166689420118928\n",
      "Epoch: 31, Batch: 320, Avg. Loss: 0.19059341214597225\n",
      "Epoch: 31, Batch: 330, Avg. Loss: 0.025242796912789345\n",
      "Epoch: 31, Batch: 340, Avg. Loss: 0.027113974466919898\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 32, Batch: 10, Avg. Loss: 0.030611911322921515\n",
      "Epoch: 32, Batch: 20, Avg. Loss: 0.02493600994348526\n",
      "Epoch: 32, Batch: 30, Avg. Loss: 0.02190077882260084\n",
      "Epoch: 32, Batch: 40, Avg. Loss: 0.01880680676549673\n",
      "Epoch: 32, Batch: 50, Avg. Loss: 0.03296388108283281\n",
      "Epoch: 32, Batch: 60, Avg. Loss: 0.020200200099498033\n",
      "Epoch: 32, Batch: 70, Avg. Loss: 0.028284834511578084\n",
      "Epoch: 32, Batch: 80, Avg. Loss: 0.021791147254407405\n",
      "Epoch: 32, Batch: 90, Avg. Loss: 0.01904509300366044\n",
      "Epoch: 32, Batch: 100, Avg. Loss: 0.06956872250884771\n",
      "Epoch: 32, Batch: 110, Avg. Loss: 0.026112650334835053\n",
      "Epoch: 32, Batch: 120, Avg. Loss: 0.03760492205619812\n",
      "Epoch: 32, Batch: 130, Avg. Loss: 0.022599908895790576\n",
      "Epoch: 32, Batch: 140, Avg. Loss: 0.018133619334548712\n",
      "Epoch: 32, Batch: 150, Avg. Loss: 0.0245660494081676\n",
      "Epoch: 32, Batch: 160, Avg. Loss: 0.031173028238117694\n",
      "Epoch: 32, Batch: 170, Avg. Loss: 0.02093065157532692\n",
      "Epoch: 32, Batch: 180, Avg. Loss: 0.019353974051773547\n",
      "Epoch: 32, Batch: 190, Avg. Loss: 0.01852498920634389\n",
      "Epoch: 32, Batch: 200, Avg. Loss: 0.026321205124258996\n",
      "Epoch: 32, Batch: 210, Avg. Loss: 0.032471550069749354\n",
      "Epoch: 32, Batch: 220, Avg. Loss: 0.025929454993456603\n",
      "Epoch: 32, Batch: 230, Avg. Loss: 0.017553833685815333\n",
      "Epoch: 32, Batch: 240, Avg. Loss: 0.018740964122116566\n",
      "Epoch: 32, Batch: 250, Avg. Loss: 0.01830886472016573\n",
      "Epoch: 32, Batch: 260, Avg. Loss: 0.025830210372805595\n",
      "Epoch: 32, Batch: 270, Avg. Loss: 0.01889334199950099\n",
      "Epoch: 32, Batch: 280, Avg. Loss: 0.016314368788152935\n",
      "Epoch: 32, Batch: 290, Avg. Loss: 0.018244235683232544\n",
      "Epoch: 32, Batch: 300, Avg. Loss: 0.03119307765737176\n",
      "Epoch: 32, Batch: 310, Avg. Loss: 0.02298649325966835\n",
      "Epoch: 32, Batch: 320, Avg. Loss: 0.01945845875889063\n",
      "Epoch: 32, Batch: 330, Avg. Loss: 0.025132528226822614\n",
      "Epoch: 32, Batch: 340, Avg. Loss: 0.01923750964924693\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 33, Batch: 10, Avg. Loss: 0.041898753680288794\n",
      "Epoch: 33, Batch: 20, Avg. Loss: 0.0350597869604826\n",
      "Epoch: 33, Batch: 30, Avg. Loss: 0.02940931050106883\n",
      "Epoch: 33, Batch: 40, Avg. Loss: 0.024104006495326756\n",
      "Epoch: 33, Batch: 50, Avg. Loss: 0.03424101863056421\n",
      "Epoch: 33, Batch: 60, Avg. Loss: 0.022655214369297027\n",
      "Epoch: 33, Batch: 70, Avg. Loss: 0.02020788248628378\n",
      "Epoch: 33, Batch: 80, Avg. Loss: 0.017925046291202305\n",
      "Epoch: 33, Batch: 90, Avg. Loss: 0.04833963559940457\n",
      "Epoch: 33, Batch: 100, Avg. Loss: 0.022919770888984205\n",
      "Epoch: 33, Batch: 110, Avg. Loss: 0.019592013955116273\n",
      "Epoch: 33, Batch: 120, Avg. Loss: 0.023735920898616314\n",
      "Epoch: 33, Batch: 130, Avg. Loss: 0.020697962306439877\n",
      "Epoch: 33, Batch: 140, Avg. Loss: 0.0208307845517993\n",
      "Epoch: 33, Batch: 150, Avg. Loss: 0.02292501861229539\n",
      "Epoch: 33, Batch: 160, Avg. Loss: 0.01915248651057482\n",
      "Epoch: 33, Batch: 170, Avg. Loss: 0.02905804682523012\n",
      "Epoch: 33, Batch: 180, Avg. Loss: 0.01699677836149931\n",
      "Epoch: 33, Batch: 190, Avg. Loss: 0.027035048790276052\n",
      "Epoch: 33, Batch: 200, Avg. Loss: 0.022792972903698683\n",
      "Epoch: 33, Batch: 210, Avg. Loss: 0.018552135676145554\n",
      "Epoch: 33, Batch: 220, Avg. Loss: 0.02046543061733246\n",
      "Epoch: 33, Batch: 230, Avg. Loss: 0.020147900469601153\n",
      "Epoch: 33, Batch: 240, Avg. Loss: 0.018301511742174627\n",
      "Epoch: 33, Batch: 250, Avg. Loss: 0.018337061908096076\n",
      "Epoch: 33, Batch: 260, Avg. Loss: 0.02585674300789833\n",
      "Epoch: 33, Batch: 270, Avg. Loss: 0.058196204155683516\n",
      "Epoch: 33, Batch: 280, Avg. Loss: 0.10610887631773949\n",
      "Epoch: 33, Batch: 290, Avg. Loss: 0.02690683538094163\n",
      "Epoch: 33, Batch: 300, Avg. Loss: 0.017691203486174346\n",
      "Epoch: 33, Batch: 310, Avg. Loss: 0.020089078322052957\n",
      "Epoch: 33, Batch: 320, Avg. Loss: 0.0221012894064188\n",
      "Epoch: 33, Batch: 330, Avg. Loss: 0.023251653742045165\n",
      "Epoch: 33, Batch: 340, Avg. Loss: 0.020555593073368073\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 34, Batch: 10, Avg. Loss: 0.021091135405004024\n",
      "Epoch: 34, Batch: 20, Avg. Loss: 0.019278082903474568\n",
      "Epoch: 34, Batch: 30, Avg. Loss: 0.018038176745176316\n",
      "Epoch: 34, Batch: 40, Avg. Loss: 0.019983030017465354\n",
      "Epoch: 34, Batch: 50, Avg. Loss: 0.06929072719067335\n",
      "Epoch: 34, Batch: 60, Avg. Loss: 0.02963267741724849\n",
      "Epoch: 34, Batch: 70, Avg. Loss: 0.02218978265300393\n",
      "Epoch: 34, Batch: 80, Avg. Loss: 0.022536682710051537\n",
      "Epoch: 34, Batch: 90, Avg. Loss: 0.01792909549549222\n",
      "Epoch: 34, Batch: 100, Avg. Loss: 0.025439014285802843\n",
      "Epoch: 34, Batch: 110, Avg. Loss: 0.01895703552290797\n",
      "Epoch: 34, Batch: 120, Avg. Loss: 0.02953782621771097\n",
      "Epoch: 34, Batch: 130, Avg. Loss: 0.047461255360394715\n",
      "Epoch: 34, Batch: 140, Avg. Loss: 0.024070538766682147\n",
      "Epoch: 34, Batch: 150, Avg. Loss: 0.02757545169442892\n",
      "Epoch: 34, Batch: 160, Avg. Loss: 0.020378613285720347\n",
      "Epoch: 34, Batch: 170, Avg. Loss: 0.020517974719405176\n",
      "Epoch: 34, Batch: 180, Avg. Loss: 0.01954741347581148\n",
      "Epoch: 34, Batch: 190, Avg. Loss: 0.016261009871959685\n",
      "Epoch: 34, Batch: 200, Avg. Loss: 0.03010594015941024\n",
      "Epoch: 34, Batch: 210, Avg. Loss: 0.021933601796627046\n",
      "Epoch: 34, Batch: 220, Avg. Loss: 0.02632332472130656\n",
      "Epoch: 34, Batch: 230, Avg. Loss: 0.031451376155018806\n",
      "Epoch: 34, Batch: 240, Avg. Loss: 0.09007553728297353\n",
      "Epoch: 34, Batch: 250, Avg. Loss: 0.041154999658465384\n",
      "Epoch: 34, Batch: 260, Avg. Loss: 0.029642380215227603\n",
      "Epoch: 34, Batch: 270, Avg. Loss: 0.02860562251880765\n",
      "Epoch: 34, Batch: 280, Avg. Loss: 0.022536930814385413\n",
      "Epoch: 34, Batch: 290, Avg. Loss: 0.02471918435767293\n",
      "Epoch: 34, Batch: 300, Avg. Loss: 0.022354514431208374\n",
      "Epoch: 34, Batch: 310, Avg. Loss: 0.028758406173437834\n",
      "Epoch: 34, Batch: 320, Avg. Loss: 0.019418149068951607\n",
      "Epoch: 34, Batch: 330, Avg. Loss: 0.02044045561924577\n",
      "Epoch: 34, Batch: 340, Avg. Loss: 0.026399439387023448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 35, Batch: 10, Avg. Loss: 0.017474417574703693\n",
      "Epoch: 35, Batch: 20, Avg. Loss: 0.019433115143328905\n",
      "Epoch: 35, Batch: 30, Avg. Loss: 0.02226144466549158\n",
      "Epoch: 35, Batch: 40, Avg. Loss: 0.02055045636370778\n",
      "Epoch: 35, Batch: 50, Avg. Loss: 0.01754258116707206\n",
      "Epoch: 35, Batch: 60, Avg. Loss: 0.018660937808454035\n",
      "Epoch: 35, Batch: 70, Avg. Loss: 0.015536917559802532\n",
      "Epoch: 35, Batch: 80, Avg. Loss: 0.018812293745577337\n",
      "Epoch: 35, Batch: 90, Avg. Loss: 0.020329683553427458\n",
      "Epoch: 35, Batch: 100, Avg. Loss: 0.017547122202813625\n",
      "Epoch: 35, Batch: 110, Avg. Loss: 0.019100217334926128\n",
      "Epoch: 35, Batch: 120, Avg. Loss: 0.019098932668566704\n",
      "Epoch: 35, Batch: 130, Avg. Loss: 0.020495612267404796\n",
      "Epoch: 35, Batch: 140, Avg. Loss: 0.06786495512351394\n",
      "Epoch: 35, Batch: 150, Avg. Loss: 0.0199546217918396\n",
      "Epoch: 35, Batch: 160, Avg. Loss: 0.03804182726889849\n",
      "Epoch: 35, Batch: 170, Avg. Loss: 0.018719039019197227\n",
      "Epoch: 35, Batch: 180, Avg. Loss: 0.017035776749253273\n",
      "Epoch: 35, Batch: 190, Avg. Loss: 0.02104152925312519\n",
      "Epoch: 35, Batch: 200, Avg. Loss: 0.01796104507520795\n",
      "Epoch: 35, Batch: 210, Avg. Loss: 0.01859819535166025\n",
      "Epoch: 35, Batch: 220, Avg. Loss: 0.02646077275276184\n",
      "Epoch: 35, Batch: 230, Avg. Loss: 0.01772926589474082\n",
      "Epoch: 35, Batch: 240, Avg. Loss: 0.023135099560022354\n",
      "Epoch: 35, Batch: 250, Avg. Loss: 0.03717950098216534\n",
      "Epoch: 35, Batch: 260, Avg. Loss: 0.017056792229413986\n",
      "Epoch: 35, Batch: 270, Avg. Loss: 0.02389529747888446\n",
      "Epoch: 35, Batch: 280, Avg. Loss: 0.07737988820299506\n",
      "Epoch: 35, Batch: 290, Avg. Loss: 0.04495764784514904\n",
      "Epoch: 35, Batch: 300, Avg. Loss: 0.034085522405803204\n",
      "Epoch: 35, Batch: 310, Avg. Loss: 0.022458663675934076\n",
      "Epoch: 35, Batch: 320, Avg. Loss: 0.03973142970353365\n",
      "Epoch: 35, Batch: 330, Avg. Loss: 0.30303608868271115\n",
      "Epoch: 35, Batch: 340, Avg. Loss: 0.055710052885115144\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 36, Batch: 10, Avg. Loss: 0.022206597588956357\n",
      "Epoch: 36, Batch: 20, Avg. Loss: 0.023034120071679355\n",
      "Epoch: 36, Batch: 30, Avg. Loss: 0.023125299252569675\n",
      "Epoch: 36, Batch: 40, Avg. Loss: 0.021153473854064943\n",
      "Epoch: 36, Batch: 50, Avg. Loss: 0.022171258460730314\n",
      "Epoch: 36, Batch: 60, Avg. Loss: 0.022343402076512576\n",
      "Epoch: 36, Batch: 70, Avg. Loss: 0.030980774853378534\n",
      "Epoch: 36, Batch: 80, Avg. Loss: 0.02893913723528385\n",
      "Epoch: 36, Batch: 90, Avg. Loss: 0.01859108777716756\n",
      "Epoch: 36, Batch: 100, Avg. Loss: 0.038527658022940156\n",
      "Epoch: 36, Batch: 110, Avg. Loss: 0.028338637948036195\n",
      "Epoch: 36, Batch: 120, Avg. Loss: 0.022005647234618664\n",
      "Epoch: 36, Batch: 130, Avg. Loss: 0.023763232585042714\n",
      "Epoch: 36, Batch: 140, Avg. Loss: 0.019783271383494137\n",
      "Epoch: 36, Batch: 150, Avg. Loss: 0.019672534428536892\n",
      "Epoch: 36, Batch: 160, Avg. Loss: 0.01925484333187342\n",
      "Epoch: 36, Batch: 170, Avg. Loss: 0.042563235573470595\n",
      "Epoch: 36, Batch: 180, Avg. Loss: 0.031217629462480544\n",
      "Epoch: 36, Batch: 190, Avg. Loss: 0.025418811850249766\n",
      "Epoch: 36, Batch: 200, Avg. Loss: 0.027781290095299484\n",
      "Epoch: 36, Batch: 210, Avg. Loss: 0.10000262754037977\n",
      "Epoch: 36, Batch: 220, Avg. Loss: 0.03295695744454861\n",
      "Epoch: 36, Batch: 230, Avg. Loss: 0.024772815220057965\n",
      "Epoch: 36, Batch: 240, Avg. Loss: 0.019915287848562002\n",
      "Epoch: 36, Batch: 250, Avg. Loss: 0.047628249041736126\n",
      "Epoch: 36, Batch: 260, Avg. Loss: 0.029215708281844853\n",
      "Epoch: 36, Batch: 270, Avg. Loss: 0.027881605736911296\n",
      "Epoch: 36, Batch: 280, Avg. Loss: 0.026268013380467893\n",
      "Epoch: 36, Batch: 290, Avg. Loss: 0.018684401456266642\n",
      "Epoch: 36, Batch: 300, Avg. Loss: 0.08090133238583803\n",
      "Epoch: 36, Batch: 310, Avg. Loss: 0.022463957127183676\n",
      "Epoch: 36, Batch: 320, Avg. Loss: 0.021560881286859512\n",
      "Epoch: 36, Batch: 330, Avg. Loss: 0.027500084694474937\n",
      "Epoch: 36, Batch: 340, Avg. Loss: 0.020966603700071574\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 37, Batch: 10, Avg. Loss: 0.032891209609806536\n",
      "Epoch: 37, Batch: 20, Avg. Loss: 0.023121183458715677\n",
      "Epoch: 37, Batch: 30, Avg. Loss: 0.018209931533783676\n",
      "Epoch: 37, Batch: 40, Avg. Loss: 0.02308103470131755\n",
      "Epoch: 37, Batch: 50, Avg. Loss: 0.019866159837692975\n",
      "Epoch: 37, Batch: 60, Avg. Loss: 0.018858899269253014\n",
      "Epoch: 37, Batch: 70, Avg. Loss: 0.019013902638107538\n",
      "Epoch: 37, Batch: 80, Avg. Loss: 0.025556295551359652\n",
      "Epoch: 37, Batch: 90, Avg. Loss: 0.017300599720329046\n",
      "Epoch: 37, Batch: 100, Avg. Loss: 0.02058890676125884\n",
      "Epoch: 37, Batch: 110, Avg. Loss: 0.01800938444212079\n",
      "Epoch: 37, Batch: 120, Avg. Loss: 0.018628845736384392\n",
      "Epoch: 37, Batch: 130, Avg. Loss: 0.023222426045686008\n",
      "Epoch: 37, Batch: 140, Avg. Loss: 0.0211449864320457\n",
      "Epoch: 37, Batch: 150, Avg. Loss: 0.017130331415683032\n",
      "Epoch: 37, Batch: 160, Avg. Loss: 0.03106395062059164\n",
      "Epoch: 37, Batch: 170, Avg. Loss: 0.02961410377174616\n",
      "Epoch: 37, Batch: 180, Avg. Loss: 0.02575482418760657\n",
      "Epoch: 37, Batch: 190, Avg. Loss: 0.05433856965973973\n",
      "Epoch: 37, Batch: 200, Avg. Loss: 0.1484073710627854\n",
      "Epoch: 37, Batch: 210, Avg. Loss: 0.02983381263911724\n",
      "Epoch: 37, Batch: 220, Avg. Loss: 0.037195260263979436\n",
      "Epoch: 37, Batch: 230, Avg. Loss: 0.02576783876866102\n",
      "Epoch: 37, Batch: 240, Avg. Loss: 0.03534378129988909\n",
      "Epoch: 37, Batch: 250, Avg. Loss: 0.020723121147602795\n",
      "Epoch: 37, Batch: 260, Avg. Loss: 0.04983255174010992\n",
      "Epoch: 37, Batch: 270, Avg. Loss: 0.06169149018824101\n",
      "Epoch: 37, Batch: 280, Avg. Loss: 0.027728596329689027\n",
      "Epoch: 37, Batch: 290, Avg. Loss: 0.04633817784488201\n",
      "Epoch: 37, Batch: 300, Avg. Loss: 0.021430531330406666\n",
      "Epoch: 37, Batch: 310, Avg. Loss: 0.019319791160523892\n",
      "Epoch: 37, Batch: 320, Avg. Loss: 0.02223181938752532\n",
      "Epoch: 37, Batch: 330, Avg. Loss: 0.01962971445173025\n",
      "Epoch: 37, Batch: 340, Avg. Loss: 0.020826940890401602\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 38, Batch: 10, Avg. Loss: 0.02091945391148329\n",
      "Epoch: 38, Batch: 20, Avg. Loss: 0.13392657274380326\n",
      "Epoch: 38, Batch: 30, Avg. Loss: 0.028229380305856467\n",
      "Epoch: 38, Batch: 40, Avg. Loss: 0.0322813019156456\n",
      "Epoch: 38, Batch: 50, Avg. Loss: 0.026225318480283023\n",
      "Epoch: 38, Batch: 60, Avg. Loss: 0.037530264165252444\n",
      "Epoch: 38, Batch: 70, Avg. Loss: 0.10755816157907247\n",
      "Epoch: 38, Batch: 80, Avg. Loss: 0.04259080681949854\n",
      "Epoch: 38, Batch: 90, Avg. Loss: 0.02918879669159651\n",
      "Epoch: 38, Batch: 100, Avg. Loss: 0.04038298353552818\n",
      "Epoch: 38, Batch: 110, Avg. Loss: 0.0334995137527585\n",
      "Epoch: 38, Batch: 120, Avg. Loss: 0.025890854280442\n",
      "Epoch: 38, Batch: 130, Avg. Loss: 0.018916661757975815\n",
      "Epoch: 38, Batch: 140, Avg. Loss: 0.020054213423281907\n",
      "Epoch: 38, Batch: 150, Avg. Loss: 0.026175558939576148\n",
      "Epoch: 38, Batch: 160, Avg. Loss: 0.0343283542431891\n",
      "Epoch: 38, Batch: 170, Avg. Loss: 0.02506480673328042\n",
      "Epoch: 38, Batch: 180, Avg. Loss: 0.028930303826928138\n",
      "Epoch: 38, Batch: 190, Avg. Loss: 0.022602987475693226\n",
      "Epoch: 38, Batch: 200, Avg. Loss: 0.019967680145055056\n",
      "Epoch: 38, Batch: 210, Avg. Loss: 0.02345547517761588\n",
      "Epoch: 38, Batch: 220, Avg. Loss: 0.018673725333064793\n",
      "Epoch: 38, Batch: 230, Avg. Loss: 0.017152857128530742\n",
      "Epoch: 38, Batch: 240, Avg. Loss: 0.027406871505081653\n",
      "Epoch: 38, Batch: 250, Avg. Loss: 0.019044203963130713\n",
      "Epoch: 38, Batch: 260, Avg. Loss: 0.017697402834892274\n",
      "Epoch: 38, Batch: 270, Avg. Loss: 0.024286168813705444\n",
      "Epoch: 38, Batch: 280, Avg. Loss: 0.022946417890489103\n",
      "Epoch: 38, Batch: 290, Avg. Loss: 0.2092957967892289\n",
      "Epoch: 38, Batch: 300, Avg. Loss: 0.023880556412041187\n",
      "Epoch: 38, Batch: 310, Avg. Loss: 0.025367143843322993\n",
      "Epoch: 38, Batch: 320, Avg. Loss: 0.027531221602112056\n",
      "Epoch: 38, Batch: 330, Avg. Loss: 0.02428422709926963\n",
      "Epoch: 38, Batch: 340, Avg. Loss: 0.02207195907831192\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 39, Batch: 10, Avg. Loss: 0.019636577926576138\n",
      "Epoch: 39, Batch: 20, Avg. Loss: 0.02122522396966815\n",
      "Epoch: 39, Batch: 30, Avg. Loss: 0.05069559570401907\n",
      "Epoch: 39, Batch: 40, Avg. Loss: 0.05365895740687847\n",
      "Epoch: 39, Batch: 50, Avg. Loss: 0.0283385100774467\n",
      "Epoch: 39, Batch: 60, Avg. Loss: 0.024777357652783393\n",
      "Epoch: 39, Batch: 70, Avg. Loss: 0.026010114606469868\n",
      "Epoch: 39, Batch: 80, Avg. Loss: 0.019902490451931952\n",
      "Epoch: 39, Batch: 90, Avg. Loss: 0.02272381829097867\n",
      "Epoch: 39, Batch: 100, Avg. Loss: 0.020942911505699158\n",
      "Epoch: 39, Batch: 110, Avg. Loss: 0.041190659068524836\n",
      "Epoch: 39, Batch: 120, Avg. Loss: 0.02540199588984251\n",
      "Epoch: 39, Batch: 130, Avg. Loss: 0.02093713339418173\n",
      "Epoch: 39, Batch: 140, Avg. Loss: 0.01849349169060588\n",
      "Epoch: 39, Batch: 150, Avg. Loss: 0.019886481296271085\n",
      "Epoch: 39, Batch: 160, Avg. Loss: 0.016407907381653784\n",
      "Epoch: 39, Batch: 170, Avg. Loss: 0.02885585865005851\n",
      "Epoch: 39, Batch: 180, Avg. Loss: 0.01974573601037264\n",
      "Epoch: 39, Batch: 190, Avg. Loss: 0.018224680237472056\n",
      "Epoch: 39, Batch: 200, Avg. Loss: 0.018413943983614445\n",
      "Epoch: 39, Batch: 210, Avg. Loss: 0.029121638834476472\n",
      "Epoch: 39, Batch: 220, Avg. Loss: 0.01916369013488293\n",
      "Epoch: 39, Batch: 230, Avg. Loss: 0.022985428385436536\n",
      "Epoch: 39, Batch: 240, Avg. Loss: 0.02345558684319258\n",
      "Epoch: 39, Batch: 250, Avg. Loss: 0.02481999546289444\n",
      "Epoch: 39, Batch: 260, Avg. Loss: 0.03125862441956997\n",
      "Epoch: 39, Batch: 270, Avg. Loss: 0.024870949517935514\n",
      "Epoch: 39, Batch: 280, Avg. Loss: 0.02046032752841711\n",
      "Epoch: 39, Batch: 290, Avg. Loss: 0.09314808901399374\n",
      "Epoch: 39, Batch: 300, Avg. Loss: 0.04864718690514565\n",
      "Epoch: 39, Batch: 310, Avg. Loss: 0.02440404938533902\n",
      "Epoch: 39, Batch: 320, Avg. Loss: 0.020362044125795363\n",
      "Epoch: 39, Batch: 330, Avg. Loss: 0.017131010442972182\n",
      "Epoch: 39, Batch: 340, Avg. Loss: 0.01838906276971102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 40, Batch: 10, Avg. Loss: 0.017506203427910805\n",
      "Epoch: 40, Batch: 20, Avg. Loss: 0.07090301979333162\n",
      "Epoch: 40, Batch: 30, Avg. Loss: 0.059258452337235215\n",
      "Epoch: 40, Batch: 40, Avg. Loss: 0.033839542604982856\n",
      "Epoch: 40, Batch: 50, Avg. Loss: 0.0394747257232666\n",
      "Epoch: 40, Batch: 60, Avg. Loss: 0.025366654433310033\n",
      "Epoch: 40, Batch: 70, Avg. Loss: 0.025723767466843128\n",
      "Epoch: 40, Batch: 80, Avg. Loss: 0.020388986729085446\n",
      "Epoch: 40, Batch: 90, Avg. Loss: 0.02574766203761101\n",
      "Epoch: 40, Batch: 100, Avg. Loss: 0.046541440114378926\n",
      "Epoch: 40, Batch: 110, Avg. Loss: 0.06027431543916464\n",
      "Epoch: 40, Batch: 120, Avg. Loss: 0.05463138921186328\n",
      "Epoch: 40, Batch: 130, Avg. Loss: 0.030944319628179073\n",
      "Epoch: 40, Batch: 140, Avg. Loss: 0.02430858341977\n",
      "Epoch: 40, Batch: 150, Avg. Loss: 0.09486057022586465\n",
      "Epoch: 40, Batch: 160, Avg. Loss: 0.02369951708242297\n",
      "Epoch: 40, Batch: 170, Avg. Loss: 0.05503168636932969\n",
      "Epoch: 40, Batch: 180, Avg. Loss: 0.022125876136124135\n",
      "Epoch: 40, Batch: 190, Avg. Loss: 0.021229850687086584\n",
      "Epoch: 40, Batch: 200, Avg. Loss: 0.019419409800320864\n",
      "Epoch: 40, Batch: 210, Avg. Loss: 0.04913672171533108\n",
      "Epoch: 40, Batch: 220, Avg. Loss: 0.021394333243370055\n",
      "Epoch: 40, Batch: 230, Avg. Loss: 0.03790053147822618\n",
      "Epoch: 40, Batch: 240, Avg. Loss: 0.050902537535876036\n",
      "Epoch: 40, Batch: 250, Avg. Loss: 0.023166446574032308\n",
      "Epoch: 40, Batch: 260, Avg. Loss: 0.03061946826055646\n",
      "Epoch: 40, Batch: 270, Avg. Loss: 0.02480635028332472\n",
      "Epoch: 40, Batch: 280, Avg. Loss: 0.022956672217696907\n",
      "Epoch: 40, Batch: 290, Avg. Loss: 0.021070105768740178\n",
      "Epoch: 40, Batch: 300, Avg. Loss: 0.019655685778707264\n",
      "Epoch: 40, Batch: 310, Avg. Loss: 0.019406209606677292\n",
      "Epoch: 40, Batch: 320, Avg. Loss: 0.02151904981583357\n",
      "Epoch: 40, Batch: 330, Avg. Loss: 0.018015812244266273\n",
      "Epoch: 40, Batch: 340, Avg. Loss: 0.025949941854923962\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 41, Batch: 10, Avg. Loss: 0.033141127321869135\n",
      "Epoch: 41, Batch: 20, Avg. Loss: 0.022880942188203336\n",
      "Epoch: 41, Batch: 30, Avg. Loss: 0.026358132530003787\n",
      "Epoch: 41, Batch: 40, Avg. Loss: 0.01897438960149884\n",
      "Epoch: 41, Batch: 50, Avg. Loss: 0.02251374749466777\n",
      "Epoch: 41, Batch: 60, Avg. Loss: 0.04154119519516826\n",
      "Epoch: 41, Batch: 70, Avg. Loss: 0.03376526990905404\n",
      "Epoch: 41, Batch: 80, Avg. Loss: 0.03990826578810811\n",
      "Epoch: 41, Batch: 90, Avg. Loss: 0.13257379755377768\n",
      "Epoch: 41, Batch: 100, Avg. Loss: 0.042167661059647796\n",
      "Epoch: 41, Batch: 110, Avg. Loss: 0.021747193485498428\n",
      "Epoch: 41, Batch: 120, Avg. Loss: 0.0218840042129159\n",
      "Epoch: 41, Batch: 130, Avg. Loss: 0.03335005026310682\n",
      "Epoch: 41, Batch: 140, Avg. Loss: 0.020239053387194873\n",
      "Epoch: 41, Batch: 150, Avg. Loss: 0.02652333751320839\n",
      "Epoch: 41, Batch: 160, Avg. Loss: 0.024837435875087976\n",
      "Epoch: 41, Batch: 170, Avg. Loss: 0.154472484998405\n",
      "Epoch: 41, Batch: 180, Avg. Loss: 0.023467160761356354\n",
      "Epoch: 41, Batch: 190, Avg. Loss: 0.02645377805456519\n",
      "Epoch: 41, Batch: 200, Avg. Loss: 0.02245063502341509\n",
      "Epoch: 41, Batch: 210, Avg. Loss: 0.022186465654522182\n",
      "Epoch: 41, Batch: 220, Avg. Loss: 0.07596581485122442\n",
      "Epoch: 41, Batch: 230, Avg. Loss: 0.020739257894456388\n",
      "Epoch: 41, Batch: 240, Avg. Loss: 0.026936381962150334\n",
      "Epoch: 41, Batch: 250, Avg. Loss: 0.02139115184545517\n",
      "Epoch: 41, Batch: 260, Avg. Loss: 0.021004699543118475\n",
      "Epoch: 41, Batch: 270, Avg. Loss: 0.020936540514230727\n",
      "Epoch: 41, Batch: 280, Avg. Loss: 0.050595182459801435\n",
      "Epoch: 41, Batch: 290, Avg. Loss: 0.06370138311758637\n",
      "Epoch: 41, Batch: 300, Avg. Loss: 0.030550373159348963\n",
      "Epoch: 41, Batch: 310, Avg. Loss: 0.02005591578781605\n",
      "Epoch: 41, Batch: 320, Avg. Loss: 0.07125713285058737\n",
      "Epoch: 41, Batch: 330, Avg. Loss: 0.02573783751577139\n",
      "Epoch: 41, Batch: 340, Avg. Loss: 0.02286106627434492\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 42, Batch: 10, Avg. Loss: 0.08480818932875991\n",
      "Epoch: 42, Batch: 20, Avg. Loss: 0.04077617842704058\n",
      "Epoch: 42, Batch: 30, Avg. Loss: 0.03318395428359509\n",
      "Epoch: 42, Batch: 40, Avg. Loss: 0.025241916999220848\n",
      "Epoch: 42, Batch: 50, Avg. Loss: 0.024094396829605104\n",
      "Epoch: 42, Batch: 60, Avg. Loss: 0.02202026089653373\n",
      "Epoch: 42, Batch: 70, Avg. Loss: 0.03357061902061105\n",
      "Epoch: 42, Batch: 80, Avg. Loss: 0.04418885800987482\n",
      "Epoch: 42, Batch: 90, Avg. Loss: 0.043246276397258046\n",
      "Epoch: 42, Batch: 100, Avg. Loss: 0.04531576838344335\n",
      "Epoch: 42, Batch: 110, Avg. Loss: 0.027819164097309113\n",
      "Epoch: 42, Batch: 120, Avg. Loss: 0.021457758825272323\n",
      "Epoch: 42, Batch: 130, Avg. Loss: 0.02600379679352045\n",
      "Epoch: 42, Batch: 140, Avg. Loss: 0.01931993579491973\n",
      "Epoch: 42, Batch: 150, Avg. Loss: 0.02132656630128622\n",
      "Epoch: 42, Batch: 160, Avg. Loss: 0.020671392418444158\n",
      "Epoch: 42, Batch: 170, Avg. Loss: 0.07567480402067303\n",
      "Epoch: 42, Batch: 180, Avg. Loss: 0.07724358290433883\n",
      "Epoch: 42, Batch: 190, Avg. Loss: 0.03460023310035467\n",
      "Epoch: 42, Batch: 200, Avg. Loss: 0.022705882042646407\n",
      "Epoch: 42, Batch: 210, Avg. Loss: 0.02270114393904805\n",
      "Epoch: 42, Batch: 220, Avg. Loss: 0.032040704507380724\n",
      "Epoch: 42, Batch: 230, Avg. Loss: 0.02469145767390728\n",
      "Epoch: 42, Batch: 240, Avg. Loss: 0.02280516717582941\n",
      "Epoch: 42, Batch: 250, Avg. Loss: 0.02252850467339158\n",
      "Epoch: 42, Batch: 260, Avg. Loss: 0.03845422193408012\n",
      "Epoch: 42, Batch: 270, Avg. Loss: 0.03307430259883404\n",
      "Epoch: 42, Batch: 280, Avg. Loss: 0.024509725254029037\n",
      "Epoch: 42, Batch: 290, Avg. Loss: 0.031164674181491138\n",
      "Epoch: 42, Batch: 300, Avg. Loss: 0.0178558774292469\n",
      "Epoch: 42, Batch: 310, Avg. Loss: 0.035146059654653075\n",
      "Epoch: 42, Batch: 320, Avg. Loss: 0.022464038617908955\n",
      "Epoch: 42, Batch: 330, Avg. Loss: 0.02406864631921053\n",
      "Epoch: 42, Batch: 340, Avg. Loss: 0.0217370530590415\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 43, Batch: 10, Avg. Loss: 0.019329363387078045\n",
      "Epoch: 43, Batch: 20, Avg. Loss: 0.048138966970145705\n",
      "Epoch: 43, Batch: 30, Avg. Loss: 0.01688096849247813\n",
      "Epoch: 43, Batch: 40, Avg. Loss: 0.019807590171694756\n",
      "Epoch: 43, Batch: 50, Avg. Loss: 0.028683648258447648\n",
      "Epoch: 43, Batch: 60, Avg. Loss: 0.021125087141990663\n",
      "Epoch: 43, Batch: 70, Avg. Loss: 0.020536987390369178\n",
      "Epoch: 43, Batch: 80, Avg. Loss: 0.02098269909620285\n",
      "Epoch: 43, Batch: 90, Avg. Loss: 0.07011551083996892\n",
      "Epoch: 43, Batch: 100, Avg. Loss: 0.023861123155802487\n",
      "Epoch: 43, Batch: 110, Avg. Loss: 0.01870868792757392\n",
      "Epoch: 43, Batch: 120, Avg. Loss: 0.049512917548418044\n",
      "Epoch: 43, Batch: 130, Avg. Loss: 0.02244771979749203\n",
      "Epoch: 43, Batch: 140, Avg. Loss: 0.021612047217786312\n",
      "Epoch: 43, Batch: 150, Avg. Loss: 0.026377613376826047\n",
      "Epoch: 43, Batch: 160, Avg. Loss: 0.01977271130308509\n",
      "Epoch: 43, Batch: 170, Avg. Loss: 0.01990915648639202\n",
      "Epoch: 43, Batch: 180, Avg. Loss: 0.018789125327020883\n",
      "Epoch: 43, Batch: 190, Avg. Loss: 0.018518385104835035\n",
      "Epoch: 43, Batch: 200, Avg. Loss: 0.019622115697711707\n",
      "Epoch: 43, Batch: 210, Avg. Loss: 0.07465490577742458\n",
      "Epoch: 43, Batch: 220, Avg. Loss: 0.023744495026767252\n",
      "Epoch: 43, Batch: 230, Avg. Loss: 0.045893794111907485\n",
      "Epoch: 43, Batch: 240, Avg. Loss: 0.021428743470460178\n",
      "Epoch: 43, Batch: 250, Avg. Loss: 0.017751883063465358\n",
      "Epoch: 43, Batch: 260, Avg. Loss: 0.023757010139524935\n",
      "Epoch: 43, Batch: 270, Avg. Loss: 0.025513699185103177\n",
      "Epoch: 43, Batch: 280, Avg. Loss: 0.02001076200976968\n",
      "Epoch: 43, Batch: 290, Avg. Loss: 0.0254049071110785\n",
      "Epoch: 43, Batch: 300, Avg. Loss: 0.026378171984106302\n",
      "Epoch: 43, Batch: 310, Avg. Loss: 0.018747063167393208\n",
      "Epoch: 43, Batch: 320, Avg. Loss: 0.01802355432882905\n",
      "Epoch: 43, Batch: 330, Avg. Loss: 0.018237470742315055\n",
      "Epoch: 43, Batch: 340, Avg. Loss: 0.11632086541503668\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 44, Batch: 10, Avg. Loss: 0.02989755179733038\n",
      "Epoch: 44, Batch: 20, Avg. Loss: 0.023734497278928755\n",
      "Epoch: 44, Batch: 30, Avg. Loss: 0.01773286731913686\n",
      "Epoch: 44, Batch: 40, Avg. Loss: 0.019446094892919062\n",
      "Epoch: 44, Batch: 50, Avg. Loss: 0.024750057980418204\n",
      "Epoch: 44, Batch: 60, Avg. Loss: 0.021699889563024044\n",
      "Epoch: 44, Batch: 70, Avg. Loss: 0.025516430009156467\n",
      "Epoch: 44, Batch: 80, Avg. Loss: 0.021763438917696477\n",
      "Epoch: 44, Batch: 90, Avg. Loss: 0.025158895179629326\n",
      "Epoch: 44, Batch: 100, Avg. Loss: 0.02214484540745616\n",
      "Epoch: 44, Batch: 110, Avg. Loss: 0.018124295957386495\n",
      "Epoch: 44, Batch: 120, Avg. Loss: 0.01946812504902482\n",
      "Epoch: 44, Batch: 130, Avg. Loss: 0.016292066499590873\n",
      "Epoch: 44, Batch: 140, Avg. Loss: 0.01918021347373724\n",
      "Epoch: 44, Batch: 150, Avg. Loss: 0.016620251443237068\n",
      "Epoch: 44, Batch: 160, Avg. Loss: 0.017709523253142834\n",
      "Epoch: 44, Batch: 170, Avg. Loss: 0.021155636198818682\n",
      "Epoch: 44, Batch: 180, Avg. Loss: 0.023210232704877855\n",
      "Epoch: 44, Batch: 190, Avg. Loss: 0.027910412196069954\n",
      "Epoch: 44, Batch: 200, Avg. Loss: 0.0398626571521163\n",
      "Epoch: 44, Batch: 210, Avg. Loss: 0.026144123077392577\n",
      "Epoch: 44, Batch: 220, Avg. Loss: 0.03323595337569714\n",
      "Epoch: 44, Batch: 230, Avg. Loss: 0.019451937172561884\n",
      "Epoch: 44, Batch: 240, Avg. Loss: 0.04820914231240749\n",
      "Epoch: 44, Batch: 250, Avg. Loss: 0.029052693489938976\n",
      "Epoch: 44, Batch: 260, Avg. Loss: 0.030916288681328296\n",
      "Epoch: 44, Batch: 270, Avg. Loss: 0.03285099286586046\n",
      "Epoch: 44, Batch: 280, Avg. Loss: 0.16651866538450122\n",
      "Epoch: 44, Batch: 290, Avg. Loss: 0.026247433200478554\n",
      "Epoch: 44, Batch: 300, Avg. Loss: 0.025894082523882388\n",
      "Epoch: 44, Batch: 310, Avg. Loss: 0.02226084191352129\n",
      "Epoch: 44, Batch: 320, Avg. Loss: 0.0173093824647367\n",
      "Epoch: 44, Batch: 330, Avg. Loss: 0.026365276239812375\n",
      "Epoch: 44, Batch: 340, Avg. Loss: 0.019934452977031468\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 45, Batch: 10, Avg. Loss: 0.026966812461614607\n",
      "Epoch: 45, Batch: 20, Avg. Loss: 0.026847579702734947\n",
      "Epoch: 45, Batch: 30, Avg. Loss: 0.020696615800261497\n",
      "Epoch: 45, Batch: 40, Avg. Loss: 0.03280889093875885\n",
      "Epoch: 45, Batch: 50, Avg. Loss: 0.06438609166070819\n",
      "Epoch: 45, Batch: 60, Avg. Loss: 0.03372367937117815\n",
      "Epoch: 45, Batch: 70, Avg. Loss: 0.048897534236311914\n",
      "Epoch: 45, Batch: 80, Avg. Loss: 0.040822113212198016\n",
      "Epoch: 45, Batch: 90, Avg. Loss: 0.02296058479696512\n",
      "Epoch: 45, Batch: 100, Avg. Loss: 0.03395231980830431\n",
      "Epoch: 45, Batch: 110, Avg. Loss: 0.027956202253699304\n",
      "Epoch: 45, Batch: 120, Avg. Loss: 0.03977329283952713\n",
      "Epoch: 45, Batch: 130, Avg. Loss: 0.04797448702156544\n",
      "Epoch: 45, Batch: 140, Avg. Loss: 0.031058116629719735\n",
      "Epoch: 45, Batch: 150, Avg. Loss: 0.024962925259023903\n",
      "Epoch: 45, Batch: 160, Avg. Loss: 0.021483417227864267\n",
      "Epoch: 45, Batch: 170, Avg. Loss: 0.0346344449557364\n",
      "Epoch: 45, Batch: 180, Avg. Loss: 0.021359019819647072\n",
      "Epoch: 45, Batch: 190, Avg. Loss: 0.024255546554923058\n",
      "Epoch: 45, Batch: 200, Avg. Loss: 0.020951705519109964\n",
      "Epoch: 45, Batch: 210, Avg. Loss: 0.017570089362561703\n",
      "Epoch: 45, Batch: 220, Avg. Loss: 0.017615672945976258\n",
      "Epoch: 45, Batch: 230, Avg. Loss: 0.035176661983132365\n",
      "Epoch: 45, Batch: 240, Avg. Loss: 0.027319548651576042\n",
      "Epoch: 45, Batch: 250, Avg. Loss: 0.024250745121389628\n",
      "Epoch: 45, Batch: 260, Avg. Loss: 0.023011990636587144\n",
      "Epoch: 45, Batch: 270, Avg. Loss: 0.04599294736981392\n",
      "Epoch: 45, Batch: 280, Avg. Loss: 0.03145589511841536\n",
      "Epoch: 45, Batch: 290, Avg. Loss: 0.06065494492650032\n",
      "Epoch: 45, Batch: 300, Avg. Loss: 0.020565244648605586\n",
      "Epoch: 45, Batch: 310, Avg. Loss: 0.0222163419239223\n",
      "Epoch: 45, Batch: 320, Avg. Loss: 0.027818342484533787\n",
      "Epoch: 45, Batch: 330, Avg. Loss: 0.020458107255399226\n",
      "Epoch: 45, Batch: 340, Avg. Loss: 0.052670141123235224\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 46, Batch: 10, Avg. Loss: 0.026408591959625482\n",
      "Epoch: 46, Batch: 20, Avg. Loss: 0.018217867985367776\n",
      "Epoch: 46, Batch: 30, Avg. Loss: 0.02087794542312622\n",
      "Epoch: 46, Batch: 40, Avg. Loss: 0.02220918666571379\n",
      "Epoch: 46, Batch: 50, Avg. Loss: 0.02080789441242814\n",
      "Epoch: 46, Batch: 60, Avg. Loss: 0.02659165132790804\n",
      "Epoch: 46, Batch: 70, Avg. Loss: 0.01852298527956009\n",
      "Epoch: 46, Batch: 80, Avg. Loss: 0.018288598768413065\n",
      "Epoch: 46, Batch: 90, Avg. Loss: 0.024176644161343575\n",
      "Epoch: 46, Batch: 100, Avg. Loss: 0.019412229023873805\n",
      "Epoch: 46, Batch: 110, Avg. Loss: 0.017284634243696927\n",
      "Epoch: 46, Batch: 120, Avg. Loss: 0.048013133183121684\n",
      "Epoch: 46, Batch: 130, Avg. Loss: 0.020557732228189705\n",
      "Epoch: 46, Batch: 140, Avg. Loss: 0.11370595777407289\n",
      "Epoch: 46, Batch: 150, Avg. Loss: 0.02444447558373213\n",
      "Epoch: 46, Batch: 160, Avg. Loss: 0.022722477745264768\n",
      "Epoch: 46, Batch: 170, Avg. Loss: 0.0337206581607461\n",
      "Epoch: 46, Batch: 180, Avg. Loss: 0.01926238052546978\n",
      "Epoch: 46, Batch: 190, Avg. Loss: 0.022176796197891237\n",
      "Epoch: 46, Batch: 200, Avg. Loss: 0.02444271221756935\n",
      "Epoch: 46, Batch: 210, Avg. Loss: 0.035455957893282174\n",
      "Epoch: 46, Batch: 220, Avg. Loss: 0.01676243245601654\n",
      "Epoch: 46, Batch: 230, Avg. Loss: 0.02938490463420749\n",
      "Epoch: 46, Batch: 240, Avg. Loss: 0.017803003918379544\n",
      "Epoch: 46, Batch: 250, Avg. Loss: 0.14091139659285545\n",
      "Epoch: 46, Batch: 260, Avg. Loss: 0.034123612195253374\n",
      "Epoch: 46, Batch: 270, Avg. Loss: 0.02467819880694151\n",
      "Epoch: 46, Batch: 280, Avg. Loss: 0.04169989340007305\n",
      "Epoch: 46, Batch: 290, Avg. Loss: 0.02211548378691077\n",
      "Epoch: 46, Batch: 300, Avg. Loss: 0.02526144217699766\n",
      "Epoch: 46, Batch: 310, Avg. Loss: 0.021697486657649277\n",
      "Epoch: 46, Batch: 320, Avg. Loss: 0.025213117804378272\n",
      "Epoch: 46, Batch: 330, Avg. Loss: 0.025718983076512814\n",
      "Epoch: 46, Batch: 340, Avg. Loss: 0.026683233119547366\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 47, Batch: 10, Avg. Loss: 0.04339863499626517\n",
      "Epoch: 47, Batch: 20, Avg. Loss: 0.02072732960805297\n",
      "Epoch: 47, Batch: 30, Avg. Loss: 0.034114365186542275\n",
      "Epoch: 47, Batch: 40, Avg. Loss: 0.019326962530612946\n",
      "Epoch: 47, Batch: 50, Avg. Loss: 0.035670223832130435\n",
      "Epoch: 47, Batch: 60, Avg. Loss: 0.026650615502148867\n",
      "Epoch: 47, Batch: 70, Avg. Loss: 0.03764642821624875\n",
      "Epoch: 47, Batch: 80, Avg. Loss: 0.020852349046617747\n",
      "Epoch: 47, Batch: 90, Avg. Loss: 0.031820419058203694\n",
      "Epoch: 47, Batch: 100, Avg. Loss: 0.024344371818006038\n",
      "Epoch: 47, Batch: 110, Avg. Loss: 0.0484501488506794\n",
      "Epoch: 47, Batch: 120, Avg. Loss: 0.02080058827996254\n",
      "Epoch: 47, Batch: 130, Avg. Loss: 0.02004224844276905\n",
      "Epoch: 47, Batch: 140, Avg. Loss: 0.020890169497579335\n",
      "Epoch: 47, Batch: 150, Avg. Loss: 0.017111749015748502\n",
      "Epoch: 47, Batch: 160, Avg. Loss: 0.031175658479332923\n",
      "Epoch: 47, Batch: 170, Avg. Loss: 0.018888607807457446\n",
      "Epoch: 47, Batch: 180, Avg. Loss: 0.025562736857682466\n",
      "Epoch: 47, Batch: 190, Avg. Loss: 0.019149348605424166\n",
      "Epoch: 47, Batch: 200, Avg. Loss: 0.018119968380779027\n",
      "Epoch: 47, Batch: 210, Avg. Loss: 0.017009516898542642\n",
      "Epoch: 47, Batch: 220, Avg. Loss: 0.02734078820794821\n",
      "Epoch: 47, Batch: 230, Avg. Loss: 0.01897579664364457\n",
      "Epoch: 47, Batch: 240, Avg. Loss: 0.040758103039115666\n",
      "Epoch: 47, Batch: 250, Avg. Loss: 0.018016659561544655\n",
      "Epoch: 47, Batch: 260, Avg. Loss: 0.02713468438014388\n",
      "Epoch: 47, Batch: 270, Avg. Loss: 0.036467140261083844\n",
      "Epoch: 47, Batch: 280, Avg. Loss: 0.02772825974971056\n",
      "Epoch: 47, Batch: 290, Avg. Loss: 0.022956766374409198\n",
      "Epoch: 47, Batch: 300, Avg. Loss: 0.021114705502986907\n",
      "Epoch: 47, Batch: 310, Avg. Loss: 0.08447788981720805\n",
      "Epoch: 47, Batch: 320, Avg. Loss: 0.021941953245550393\n",
      "Epoch: 47, Batch: 330, Avg. Loss: 0.018881464563310146\n",
      "Epoch: 47, Batch: 340, Avg. Loss: 0.018147591035813093\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 48, Batch: 10, Avg. Loss: 0.017225620802491903\n",
      "Epoch: 48, Batch: 20, Avg. Loss: 0.022617760486900805\n",
      "Epoch: 48, Batch: 30, Avg. Loss: 0.01836921591311693\n",
      "Epoch: 48, Batch: 40, Avg. Loss: 0.023489045910537243\n",
      "Epoch: 48, Batch: 50, Avg. Loss: 0.021568094845861197\n",
      "Epoch: 48, Batch: 60, Avg. Loss: 0.02440583985298872\n",
      "Epoch: 48, Batch: 70, Avg. Loss: 0.03720952402800322\n",
      "Epoch: 48, Batch: 80, Avg. Loss: 0.028954711370170118\n",
      "Epoch: 48, Batch: 90, Avg. Loss: 0.01981349093839526\n",
      "Epoch: 48, Batch: 100, Avg. Loss: 0.01851747464388609\n",
      "Epoch: 48, Batch: 110, Avg. Loss: 0.021815126482397317\n",
      "Epoch: 48, Batch: 120, Avg. Loss: 0.020894992258399726\n",
      "Epoch: 48, Batch: 130, Avg. Loss: 0.022944807726889848\n",
      "Epoch: 48, Batch: 140, Avg. Loss: 0.031376985181123015\n",
      "Epoch: 48, Batch: 150, Avg. Loss: 0.02006179401651025\n",
      "Epoch: 48, Batch: 160, Avg. Loss: 0.03813912821933627\n",
      "Epoch: 48, Batch: 170, Avg. Loss: 0.019189340807497502\n",
      "Epoch: 48, Batch: 180, Avg. Loss: 0.01683597154915333\n",
      "Epoch: 48, Batch: 190, Avg. Loss: 0.02290815096348524\n",
      "Epoch: 48, Batch: 200, Avg. Loss: 0.0177551981061697\n",
      "Epoch: 48, Batch: 210, Avg. Loss: 0.016421806626021863\n",
      "Epoch: 48, Batch: 220, Avg. Loss: 0.018923659436404706\n",
      "Epoch: 48, Batch: 230, Avg. Loss: 0.017107769008725883\n",
      "Epoch: 48, Batch: 240, Avg. Loss: 0.0302201172336936\n",
      "Epoch: 48, Batch: 250, Avg. Loss: 0.01970396749675274\n",
      "Epoch: 48, Batch: 260, Avg. Loss: 0.02622874267399311\n",
      "Epoch: 48, Batch: 270, Avg. Loss: 0.017271606717258692\n",
      "Epoch: 48, Batch: 280, Avg. Loss: 0.01686803940683603\n",
      "Epoch: 48, Batch: 290, Avg. Loss: 0.037382949236780406\n",
      "Epoch: 48, Batch: 300, Avg. Loss: 0.017582759633660315\n",
      "Epoch: 48, Batch: 310, Avg. Loss: 0.044792765937745574\n",
      "Epoch: 48, Batch: 320, Avg. Loss: 0.01722600609064102\n",
      "Epoch: 48, Batch: 330, Avg. Loss: 0.01935032121837139\n",
      "Epoch: 48, Batch: 340, Avg. Loss: 0.13365360694006084\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 49, Batch: 10, Avg. Loss: 0.02262277891859412\n",
      "Epoch: 49, Batch: 20, Avg. Loss: 0.018560412619262934\n",
      "Epoch: 49, Batch: 30, Avg. Loss: 0.01762776607647538\n",
      "Epoch: 49, Batch: 40, Avg. Loss: 0.017729188222438096\n",
      "Epoch: 49, Batch: 50, Avg. Loss: 0.02618871545419097\n",
      "Epoch: 49, Batch: 60, Avg. Loss: 0.017338594514876605\n",
      "Epoch: 49, Batch: 70, Avg. Loss: 0.03277635267004371\n",
      "Epoch: 49, Batch: 80, Avg. Loss: 0.05039684260264039\n",
      "Epoch: 49, Batch: 90, Avg. Loss: 0.02745002619922161\n",
      "Epoch: 49, Batch: 100, Avg. Loss: 0.028182591777294874\n",
      "Epoch: 49, Batch: 110, Avg. Loss: 0.020709244534373283\n",
      "Epoch: 49, Batch: 120, Avg. Loss: 0.032987811416387555\n",
      "Epoch: 49, Batch: 130, Avg. Loss: 0.021335441898554564\n",
      "Epoch: 49, Batch: 140, Avg. Loss: 0.020853819325566292\n",
      "Epoch: 49, Batch: 150, Avg. Loss: 0.019547561928629876\n",
      "Epoch: 49, Batch: 160, Avg. Loss: 0.025606995448470116\n",
      "Epoch: 49, Batch: 170, Avg. Loss: 0.03429132690653205\n",
      "Epoch: 49, Batch: 180, Avg. Loss: 0.020246604364365338\n",
      "Epoch: 49, Batch: 190, Avg. Loss: 0.02510680155828595\n",
      "Epoch: 49, Batch: 200, Avg. Loss: 0.022273668367415667\n",
      "Epoch: 49, Batch: 210, Avg. Loss: 0.017696177028119563\n",
      "Epoch: 49, Batch: 220, Avg. Loss: 0.01834847927093506\n",
      "Epoch: 49, Batch: 230, Avg. Loss: 0.027928685396909715\n",
      "Epoch: 49, Batch: 240, Avg. Loss: 0.05373178478330374\n",
      "Epoch: 49, Batch: 250, Avg. Loss: 0.021881952043622734\n",
      "Epoch: 49, Batch: 260, Avg. Loss: 0.021833206247538327\n",
      "Epoch: 49, Batch: 270, Avg. Loss: 0.015793364308774472\n",
      "Epoch: 49, Batch: 280, Avg. Loss: 0.024928897526115178\n",
      "Epoch: 49, Batch: 290, Avg. Loss: 0.016882294043898582\n",
      "Epoch: 49, Batch: 300, Avg. Loss: 0.020569274201989174\n",
      "Epoch: 49, Batch: 310, Avg. Loss: 0.01928830547258258\n",
      "Epoch: 49, Batch: 320, Avg. Loss: 0.024856486916542055\n",
      "Epoch: 49, Batch: 330, Avg. Loss: 0.022258606739342213\n",
      "Epoch: 49, Batch: 340, Avg. Loss: 0.016167942993342878\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 50, Batch: 10, Avg. Loss: 0.0174301334656775\n",
      "Epoch: 50, Batch: 20, Avg. Loss: 0.017930567730218172\n",
      "Epoch: 50, Batch: 30, Avg. Loss: 0.017293901834636926\n",
      "Epoch: 50, Batch: 40, Avg. Loss: 0.019795206375420094\n",
      "Epoch: 50, Batch: 50, Avg. Loss: 0.016765189170837403\n",
      "Epoch: 50, Batch: 60, Avg. Loss: 0.019358512479811907\n",
      "Epoch: 50, Batch: 70, Avg. Loss: 0.01656135097146034\n",
      "Epoch: 50, Batch: 80, Avg. Loss: 0.032668265700340274\n",
      "Epoch: 50, Batch: 90, Avg. Loss: 0.03307020617648959\n",
      "Epoch: 50, Batch: 100, Avg. Loss: 0.016943917702883483\n",
      "Epoch: 50, Batch: 110, Avg. Loss: 0.01692933663725853\n",
      "Epoch: 50, Batch: 120, Avg. Loss: 0.019334614649415015\n",
      "Epoch: 50, Batch: 130, Avg. Loss: 0.02081892667338252\n",
      "Epoch: 50, Batch: 140, Avg. Loss: 0.01949770525097847\n",
      "Epoch: 50, Batch: 150, Avg. Loss: 0.030851007997989656\n",
      "Epoch: 50, Batch: 160, Avg. Loss: 0.023371260054409503\n",
      "Epoch: 50, Batch: 170, Avg. Loss: 0.021372138150036336\n",
      "Epoch: 50, Batch: 180, Avg. Loss: 0.01848873244598508\n",
      "Epoch: 50, Batch: 190, Avg. Loss: 0.018277149833738803\n",
      "Epoch: 50, Batch: 200, Avg. Loss: 0.023424627538770438\n",
      "Epoch: 50, Batch: 210, Avg. Loss: 0.11935080178081989\n",
      "Epoch: 50, Batch: 220, Avg. Loss: 0.031625171564519404\n",
      "Epoch: 50, Batch: 230, Avg. Loss: 0.021590552292764187\n",
      "Epoch: 50, Batch: 240, Avg. Loss: 0.021493437699973583\n",
      "Epoch: 50, Batch: 250, Avg. Loss: 0.031968752201646564\n",
      "Epoch: 50, Batch: 260, Avg. Loss: 0.01619091061875224\n",
      "Epoch: 50, Batch: 270, Avg. Loss: 0.017657630052417515\n",
      "Epoch: 50, Batch: 280, Avg. Loss: 0.02116578835994005\n",
      "Epoch: 50, Batch: 290, Avg. Loss: 0.015584715735167265\n",
      "Epoch: 50, Batch: 300, Avg. Loss: 0.01959318071603775\n",
      "Epoch: 50, Batch: 310, Avg. Loss: 0.019184667523950337\n",
      "Epoch: 50, Batch: 320, Avg. Loss: 0.016819853708148\n",
      "Epoch: 50, Batch: 330, Avg. Loss: 0.0185739703476429\n",
      "Epoch: 50, Batch: 340, Avg. Loss: 0.025752370059490205\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 51, Batch: 10, Avg. Loss: 0.032324941642582414\n",
      "Epoch: 51, Batch: 20, Avg. Loss: 0.022607067320495843\n",
      "Epoch: 51, Batch: 30, Avg. Loss: 0.01855022544041276\n",
      "Epoch: 51, Batch: 40, Avg. Loss: 0.01625017374753952\n",
      "Epoch: 51, Batch: 50, Avg. Loss: 0.021558296494185926\n",
      "Epoch: 51, Batch: 60, Avg. Loss: 0.01796935237944126\n",
      "Epoch: 51, Batch: 70, Avg. Loss: 0.016010234784334897\n",
      "Epoch: 51, Batch: 80, Avg. Loss: 0.01996215982362628\n",
      "Epoch: 51, Batch: 90, Avg. Loss: 0.017613517679274084\n",
      "Epoch: 51, Batch: 100, Avg. Loss: 0.02036439860239625\n",
      "Epoch: 51, Batch: 110, Avg. Loss: 0.02179209142923355\n",
      "Epoch: 51, Batch: 120, Avg. Loss: 0.019377640914171934\n",
      "Epoch: 51, Batch: 130, Avg. Loss: 0.018316311948001384\n",
      "Epoch: 51, Batch: 140, Avg. Loss: 0.01906526768580079\n",
      "Epoch: 51, Batch: 150, Avg. Loss: 0.019679361768066884\n",
      "Epoch: 51, Batch: 160, Avg. Loss: 0.019522680994123222\n",
      "Epoch: 51, Batch: 170, Avg. Loss: 0.01603029565885663\n",
      "Epoch: 51, Batch: 180, Avg. Loss: 0.03345061456784606\n",
      "Epoch: 51, Batch: 190, Avg. Loss: 0.021273654792457818\n",
      "Epoch: 51, Batch: 200, Avg. Loss: 0.023490204010158777\n",
      "Epoch: 51, Batch: 210, Avg. Loss: 0.09216560963541269\n",
      "Epoch: 51, Batch: 220, Avg. Loss: 0.0201504934579134\n",
      "Epoch: 51, Batch: 230, Avg. Loss: 0.02411271510645747\n",
      "Epoch: 51, Batch: 240, Avg. Loss: 0.016656388714909553\n",
      "Epoch: 51, Batch: 250, Avg. Loss: 0.01964981937780976\n",
      "Epoch: 51, Batch: 260, Avg. Loss: 0.0812691131606698\n",
      "Epoch: 51, Batch: 270, Avg. Loss: 0.027921421639621257\n",
      "Epoch: 51, Batch: 280, Avg. Loss: 0.09835466183722019\n",
      "Epoch: 51, Batch: 290, Avg. Loss: 0.02207699930295348\n",
      "Epoch: 51, Batch: 300, Avg. Loss: 0.02014023493975401\n",
      "Epoch: 51, Batch: 310, Avg. Loss: 0.034746012464165685\n",
      "Epoch: 51, Batch: 320, Avg. Loss: 0.020562821347266436\n",
      "Epoch: 51, Batch: 330, Avg. Loss: 0.026756424736231566\n",
      "Epoch: 51, Batch: 340, Avg. Loss: 0.022360512521117926\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 52, Batch: 10, Avg. Loss: 0.021486374735832214\n",
      "Epoch: 52, Batch: 20, Avg. Loss: 0.0235461357049644\n",
      "Epoch: 52, Batch: 30, Avg. Loss: 0.02827974371612072\n",
      "Epoch: 52, Batch: 40, Avg. Loss: 0.02150599006563425\n",
      "Epoch: 52, Batch: 50, Avg. Loss: 0.025500195659697057\n",
      "Epoch: 52, Batch: 60, Avg. Loss: 0.02191718267276883\n",
      "Epoch: 52, Batch: 70, Avg. Loss: 0.019908702839165925\n",
      "Epoch: 52, Batch: 80, Avg. Loss: 0.019885410089045763\n",
      "Epoch: 52, Batch: 90, Avg. Loss: 0.0210761034861207\n",
      "Epoch: 52, Batch: 100, Avg. Loss: 0.028002059366554023\n",
      "Epoch: 52, Batch: 110, Avg. Loss: 0.023620176967233418\n",
      "Epoch: 52, Batch: 120, Avg. Loss: 0.019197140447795392\n",
      "Epoch: 52, Batch: 130, Avg. Loss: 0.02080580350011587\n",
      "Epoch: 52, Batch: 140, Avg. Loss: 0.026585396751761435\n",
      "Epoch: 52, Batch: 150, Avg. Loss: 0.026373192854225635\n",
      "Epoch: 52, Batch: 160, Avg. Loss: 0.019523076340556146\n",
      "Epoch: 52, Batch: 170, Avg. Loss: 0.01526649845764041\n",
      "Epoch: 52, Batch: 180, Avg. Loss: 0.027401279751211406\n",
      "Epoch: 52, Batch: 190, Avg. Loss: 0.06430940460413695\n",
      "Epoch: 52, Batch: 200, Avg. Loss: 0.03237780639901757\n",
      "Epoch: 52, Batch: 210, Avg. Loss: 0.027918516471982003\n",
      "Epoch: 52, Batch: 220, Avg. Loss: 0.027129092905670404\n",
      "Epoch: 52, Batch: 230, Avg. Loss: 0.024671074096113445\n",
      "Epoch: 52, Batch: 240, Avg. Loss: 0.02030039094388485\n",
      "Epoch: 52, Batch: 250, Avg. Loss: 0.02572743333876133\n",
      "Epoch: 52, Batch: 260, Avg. Loss: 0.018782186135649682\n",
      "Epoch: 52, Batch: 270, Avg. Loss: 0.02529222834855318\n",
      "Epoch: 52, Batch: 280, Avg. Loss: 0.02061951784417033\n",
      "Epoch: 52, Batch: 290, Avg. Loss: 0.01983195459470153\n",
      "Epoch: 52, Batch: 300, Avg. Loss: 0.02141855759546161\n",
      "Epoch: 52, Batch: 310, Avg. Loss: 0.04674775693565607\n",
      "Epoch: 52, Batch: 320, Avg. Loss: 0.028356457035988568\n",
      "Epoch: 52, Batch: 330, Avg. Loss: 0.02008458934724331\n",
      "Epoch: 52, Batch: 340, Avg. Loss: 0.022620368842035533\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 53, Batch: 10, Avg. Loss: 0.021603945177048445\n",
      "Epoch: 53, Batch: 20, Avg. Loss: 0.029852553363889457\n",
      "Epoch: 53, Batch: 30, Avg. Loss: 0.01984814992174506\n",
      "Epoch: 53, Batch: 40, Avg. Loss: 0.02480581421405077\n",
      "Epoch: 53, Batch: 50, Avg. Loss: 0.021500447951257228\n",
      "Epoch: 53, Batch: 60, Avg. Loss: 0.020963916461914776\n",
      "Epoch: 53, Batch: 70, Avg. Loss: 0.020267552975565196\n",
      "Epoch: 53, Batch: 80, Avg. Loss: 0.018245616275817157\n",
      "Epoch: 53, Batch: 90, Avg. Loss: 0.024555283784866332\n",
      "Epoch: 53, Batch: 100, Avg. Loss: 0.030217294953763484\n",
      "Epoch: 53, Batch: 110, Avg. Loss: 0.022380887437611817\n",
      "Epoch: 53, Batch: 120, Avg. Loss: 0.020230257138609885\n",
      "Epoch: 53, Batch: 130, Avg. Loss: 0.06800361378118396\n",
      "Epoch: 53, Batch: 140, Avg. Loss: 0.04196232343092561\n",
      "Epoch: 53, Batch: 150, Avg. Loss: 0.021519948728382587\n",
      "Epoch: 53, Batch: 160, Avg. Loss: 0.022273290157318115\n",
      "Epoch: 53, Batch: 170, Avg. Loss: 0.020054235775023698\n",
      "Epoch: 53, Batch: 180, Avg. Loss: 0.01584606375545263\n",
      "Epoch: 53, Batch: 190, Avg. Loss: 0.0183811747469008\n",
      "Epoch: 53, Batch: 200, Avg. Loss: 0.015102859027683735\n",
      "Epoch: 53, Batch: 210, Avg. Loss: 0.040594193432480094\n",
      "Epoch: 53, Batch: 220, Avg. Loss: 0.042325690388679504\n",
      "Epoch: 53, Batch: 230, Avg. Loss: 0.019607122428715228\n",
      "Epoch: 53, Batch: 240, Avg. Loss: 0.01448931535705924\n",
      "Epoch: 53, Batch: 250, Avg. Loss: 0.026717082224786283\n",
      "Epoch: 53, Batch: 260, Avg. Loss: 0.02043296741321683\n",
      "Epoch: 53, Batch: 270, Avg. Loss: 0.01601661155000329\n",
      "Epoch: 53, Batch: 280, Avg. Loss: 0.02010304555296898\n",
      "Epoch: 53, Batch: 290, Avg. Loss: 0.021090015396475793\n",
      "Epoch: 53, Batch: 300, Avg. Loss: 0.06694179521873593\n",
      "Epoch: 53, Batch: 310, Avg. Loss: 0.0590693611651659\n",
      "Epoch: 53, Batch: 320, Avg. Loss: 0.02061557350680232\n",
      "Epoch: 53, Batch: 330, Avg. Loss: 0.02255146224051714\n",
      "Epoch: 53, Batch: 340, Avg. Loss: 0.0236633506603539\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 54, Batch: 10, Avg. Loss: 0.02229918148368597\n",
      "Epoch: 54, Batch: 20, Avg. Loss: 0.024646592140197755\n",
      "Epoch: 54, Batch: 30, Avg. Loss: 0.017933863028883935\n",
      "Epoch: 54, Batch: 40, Avg. Loss: 0.05677516469731927\n",
      "Epoch: 54, Batch: 50, Avg. Loss: 0.02120302217081189\n",
      "Epoch: 54, Batch: 60, Avg. Loss: 0.02224518060684204\n",
      "Epoch: 54, Batch: 70, Avg. Loss: 0.028045104909688236\n",
      "Epoch: 54, Batch: 80, Avg. Loss: 0.02147012921050191\n",
      "Epoch: 54, Batch: 90, Avg. Loss: 0.01946399752050638\n",
      "Epoch: 54, Batch: 100, Avg. Loss: 0.01759126326069236\n",
      "Epoch: 54, Batch: 110, Avg. Loss: 0.022005429212003946\n",
      "Epoch: 54, Batch: 120, Avg. Loss: 0.041062054503709075\n",
      "Epoch: 54, Batch: 130, Avg. Loss: 0.023381223529577257\n",
      "Epoch: 54, Batch: 140, Avg. Loss: 0.01900371937081218\n",
      "Epoch: 54, Batch: 150, Avg. Loss: 0.021791479364037514\n",
      "Epoch: 54, Batch: 160, Avg. Loss: 0.04977089911699295\n",
      "Epoch: 54, Batch: 170, Avg. Loss: 0.02171286232769489\n",
      "Epoch: 54, Batch: 180, Avg. Loss: 0.027381295152008534\n",
      "Epoch: 54, Batch: 190, Avg. Loss: 0.027189633436501028\n",
      "Epoch: 54, Batch: 200, Avg. Loss: 0.015894387383013964\n",
      "Epoch: 54, Batch: 210, Avg. Loss: 0.015971588809043168\n",
      "Epoch: 54, Batch: 220, Avg. Loss: 0.020441474951803686\n",
      "Epoch: 54, Batch: 230, Avg. Loss: 0.02315077045932412\n",
      "Epoch: 54, Batch: 240, Avg. Loss: 0.016995720006525515\n",
      "Epoch: 54, Batch: 250, Avg. Loss: 0.02919671656563878\n",
      "Epoch: 54, Batch: 260, Avg. Loss: 0.04195790840312839\n",
      "Epoch: 54, Batch: 270, Avg. Loss: 0.02036859802901745\n",
      "Epoch: 54, Batch: 280, Avg. Loss: 0.026002193987369537\n",
      "Epoch: 54, Batch: 290, Avg. Loss: 0.01883889837190509\n",
      "Epoch: 54, Batch: 300, Avg. Loss: 0.02018377110362053\n",
      "Epoch: 54, Batch: 310, Avg. Loss: 0.023802289832383396\n",
      "Epoch: 54, Batch: 320, Avg. Loss: 0.021215138491243124\n",
      "Epoch: 54, Batch: 330, Avg. Loss: 0.02354550305753946\n",
      "Epoch: 54, Batch: 340, Avg. Loss: 0.01921307696029544\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 55, Batch: 10, Avg. Loss: 0.024505022913217545\n",
      "Epoch: 55, Batch: 20, Avg. Loss: 0.023117038328200577\n",
      "Epoch: 55, Batch: 30, Avg. Loss: 0.018435159139335154\n",
      "Epoch: 55, Batch: 40, Avg. Loss: 0.022160129435360432\n",
      "Epoch: 55, Batch: 50, Avg. Loss: 0.020850476808845997\n",
      "Epoch: 55, Batch: 60, Avg. Loss: 0.016567870043218136\n",
      "Epoch: 55, Batch: 70, Avg. Loss: 0.018692351039499046\n",
      "Epoch: 55, Batch: 80, Avg. Loss: 0.018563029915094377\n",
      "Epoch: 55, Batch: 90, Avg. Loss: 0.0336227536201477\n",
      "Epoch: 55, Batch: 100, Avg. Loss: 0.048441323824226855\n",
      "Epoch: 55, Batch: 110, Avg. Loss: 0.0211300908587873\n",
      "Epoch: 55, Batch: 120, Avg. Loss: 0.02625318253412843\n",
      "Epoch: 55, Batch: 130, Avg. Loss: 0.02549343928694725\n",
      "Epoch: 55, Batch: 140, Avg. Loss: 0.01992295207455754\n",
      "Epoch: 55, Batch: 150, Avg. Loss: 0.018851158022880555\n",
      "Epoch: 55, Batch: 160, Avg. Loss: 0.020989622361958025\n",
      "Epoch: 55, Batch: 170, Avg. Loss: 0.06707115396857262\n",
      "Epoch: 55, Batch: 180, Avg. Loss: 0.04370704377070069\n",
      "Epoch: 55, Batch: 190, Avg. Loss: 0.02254292815923691\n",
      "Epoch: 55, Batch: 200, Avg. Loss: 0.022193935234099627\n",
      "Epoch: 55, Batch: 210, Avg. Loss: 0.021712211333215235\n",
      "Epoch: 55, Batch: 220, Avg. Loss: 0.02010528426617384\n",
      "Epoch: 55, Batch: 230, Avg. Loss: 0.02151604425162077\n",
      "Epoch: 55, Batch: 240, Avg. Loss: 0.02403188878670335\n",
      "Epoch: 55, Batch: 250, Avg. Loss: 0.018542136158794166\n",
      "Epoch: 55, Batch: 260, Avg. Loss: 0.01832572277635336\n",
      "Epoch: 55, Batch: 270, Avg. Loss: 0.018840641248971224\n",
      "Epoch: 55, Batch: 280, Avg. Loss: 0.024666082486510275\n",
      "Epoch: 55, Batch: 290, Avg. Loss: 0.019868138153105973\n",
      "Epoch: 55, Batch: 300, Avg. Loss: 0.018753363844007255\n",
      "Epoch: 55, Batch: 310, Avg. Loss: 0.017520471289753915\n",
      "Epoch: 55, Batch: 320, Avg. Loss: 0.02001111852005124\n",
      "Epoch: 55, Batch: 330, Avg. Loss: 0.023770039808005093\n",
      "Epoch: 55, Batch: 340, Avg. Loss: 0.017689668014645575\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 56, Batch: 10, Avg. Loss: 0.016583166923373936\n",
      "Epoch: 56, Batch: 20, Avg. Loss: 0.018913337867707013\n",
      "Epoch: 56, Batch: 30, Avg. Loss: 0.02183798495680094\n",
      "Epoch: 56, Batch: 40, Avg. Loss: 0.01692511225119233\n",
      "Epoch: 56, Batch: 50, Avg. Loss: 0.018109389673918487\n",
      "Epoch: 56, Batch: 60, Avg. Loss: 0.02154310941696167\n",
      "Epoch: 56, Batch: 70, Avg. Loss: 0.020007228944450617\n",
      "Epoch: 56, Batch: 80, Avg. Loss: 0.11965207858011126\n",
      "Epoch: 56, Batch: 90, Avg. Loss: 0.020636084489524364\n",
      "Epoch: 56, Batch: 100, Avg. Loss: 0.02104969210922718\n",
      "Epoch: 56, Batch: 110, Avg. Loss: 0.020379562117159366\n",
      "Epoch: 56, Batch: 120, Avg. Loss: 0.022373832948505878\n",
      "Epoch: 56, Batch: 130, Avg. Loss: 0.022010031808167695\n",
      "Epoch: 56, Batch: 140, Avg. Loss: 0.020904449000954627\n",
      "Epoch: 56, Batch: 150, Avg. Loss: 0.032109668012708426\n",
      "Epoch: 56, Batch: 160, Avg. Loss: 0.04246116746217012\n",
      "Epoch: 56, Batch: 170, Avg. Loss: 0.01933680707588792\n",
      "Epoch: 56, Batch: 180, Avg. Loss: 0.018572827242314814\n",
      "Epoch: 56, Batch: 190, Avg. Loss: 0.02183252712711692\n",
      "Epoch: 56, Batch: 200, Avg. Loss: 0.024986839015036823\n",
      "Epoch: 56, Batch: 210, Avg. Loss: 0.03498797807842493\n",
      "Epoch: 56, Batch: 220, Avg. Loss: 0.015803530206903817\n",
      "Epoch: 56, Batch: 230, Avg. Loss: 0.01660032048821449\n",
      "Epoch: 56, Batch: 240, Avg. Loss: 0.021590066608041525\n",
      "Epoch: 56, Batch: 250, Avg. Loss: 0.0332983111962676\n",
      "Epoch: 56, Batch: 260, Avg. Loss: 0.08915594778954983\n",
      "Epoch: 56, Batch: 270, Avg. Loss: 0.02456778446212411\n",
      "Epoch: 56, Batch: 280, Avg. Loss: 0.024277258664369583\n",
      "Epoch: 56, Batch: 290, Avg. Loss: 0.019875517301261424\n",
      "Epoch: 56, Batch: 300, Avg. Loss: 0.021651876345276832\n",
      "Epoch: 56, Batch: 310, Avg. Loss: 0.18229313185438514\n",
      "Epoch: 56, Batch: 320, Avg. Loss: 0.04210768193006516\n",
      "Epoch: 56, Batch: 330, Avg. Loss: 0.031992288492619994\n",
      "Epoch: 56, Batch: 340, Avg. Loss: 0.02613906655460596\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 57, Batch: 10, Avg. Loss: 0.027057368494570255\n",
      "Epoch: 57, Batch: 20, Avg. Loss: 0.02558235302567482\n",
      "Epoch: 57, Batch: 30, Avg. Loss: 0.03583652330562472\n",
      "Epoch: 57, Batch: 40, Avg. Loss: 0.019046462047845124\n",
      "Epoch: 57, Batch: 50, Avg. Loss: 0.02312166811898351\n",
      "Epoch: 57, Batch: 60, Avg. Loss: 0.019358584005385638\n",
      "Epoch: 57, Batch: 70, Avg. Loss: 0.024521020706743002\n",
      "Epoch: 57, Batch: 80, Avg. Loss: 0.05150970397517085\n",
      "Epoch: 57, Batch: 90, Avg. Loss: 0.028801348991692066\n",
      "Epoch: 57, Batch: 100, Avg. Loss: 0.018663277756422757\n",
      "Epoch: 57, Batch: 110, Avg. Loss: 0.020279239863157272\n",
      "Epoch: 57, Batch: 120, Avg. Loss: 0.016552777588367464\n",
      "Epoch: 57, Batch: 130, Avg. Loss: 0.022392695397138597\n",
      "Epoch: 57, Batch: 140, Avg. Loss: 0.020211380161345004\n",
      "Epoch: 57, Batch: 150, Avg. Loss: 0.03826896799728274\n",
      "Epoch: 57, Batch: 160, Avg. Loss: 0.042478936817497016\n",
      "Epoch: 57, Batch: 170, Avg. Loss: 0.02846804717555642\n",
      "Epoch: 57, Batch: 180, Avg. Loss: 0.01459595439955592\n",
      "Epoch: 57, Batch: 190, Avg. Loss: 0.020439997594803572\n",
      "Epoch: 57, Batch: 200, Avg. Loss: 0.01769371796399355\n",
      "Epoch: 57, Batch: 210, Avg. Loss: 0.020156927220523358\n",
      "Epoch: 57, Batch: 220, Avg. Loss: 0.018869660701602696\n",
      "Epoch: 57, Batch: 230, Avg. Loss: 0.01826744945719838\n",
      "Epoch: 57, Batch: 240, Avg. Loss: 0.02327994080260396\n",
      "Epoch: 57, Batch: 250, Avg. Loss: 0.017700116243213417\n",
      "Epoch: 57, Batch: 260, Avg. Loss: 0.016597420535981657\n",
      "Epoch: 57, Batch: 270, Avg. Loss: 0.019222984649240972\n",
      "Epoch: 57, Batch: 280, Avg. Loss: 0.01953464252874255\n",
      "Epoch: 57, Batch: 290, Avg. Loss: 0.018206525407731534\n",
      "Epoch: 57, Batch: 300, Avg. Loss: 0.014906325656920672\n",
      "Epoch: 57, Batch: 310, Avg. Loss: 0.019574780110269786\n",
      "Epoch: 57, Batch: 320, Avg. Loss: 0.0179192615672946\n",
      "Epoch: 57, Batch: 330, Avg. Loss: 0.020910188648849727\n",
      "Epoch: 57, Batch: 340, Avg. Loss: 0.018503725063055754\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 58, Batch: 10, Avg. Loss: 0.019467676617205144\n",
      "Epoch: 58, Batch: 20, Avg. Loss: 0.01806672280654311\n",
      "Epoch: 58, Batch: 30, Avg. Loss: 0.021491196192800998\n",
      "Epoch: 58, Batch: 40, Avg. Loss: 0.019392982311546802\n",
      "Epoch: 58, Batch: 50, Avg. Loss: 0.019317675661295653\n",
      "Epoch: 58, Batch: 60, Avg. Loss: 0.014888748619705438\n",
      "Epoch: 58, Batch: 70, Avg. Loss: 0.021531488094478846\n",
      "Epoch: 58, Batch: 80, Avg. Loss: 0.020851888973265887\n",
      "Epoch: 58, Batch: 90, Avg. Loss: 0.015505951177328826\n",
      "Epoch: 58, Batch: 100, Avg. Loss: 0.031424072291702035\n",
      "Epoch: 58, Batch: 110, Avg. Loss: 0.017174415569752455\n",
      "Epoch: 58, Batch: 120, Avg. Loss: 0.019413370173424482\n",
      "Epoch: 58, Batch: 130, Avg. Loss: 0.01885837912559509\n",
      "Epoch: 58, Batch: 140, Avg. Loss: 0.030225309170782567\n",
      "Epoch: 58, Batch: 150, Avg. Loss: 0.025462070107460023\n",
      "Epoch: 58, Batch: 160, Avg. Loss: 0.016582620423287155\n",
      "Epoch: 58, Batch: 170, Avg. Loss: 0.07550778621807694\n",
      "Epoch: 58, Batch: 180, Avg. Loss: 0.024831514991819858\n",
      "Epoch: 58, Batch: 190, Avg. Loss: 0.016941407322883607\n",
      "Epoch: 58, Batch: 200, Avg. Loss: 0.01972420308738947\n",
      "Epoch: 58, Batch: 210, Avg. Loss: 0.020400571078062056\n",
      "Epoch: 58, Batch: 220, Avg. Loss: 0.0231723427772522\n",
      "Epoch: 58, Batch: 230, Avg. Loss: 0.016834283340722324\n",
      "Epoch: 58, Batch: 240, Avg. Loss: 0.05974858552217484\n",
      "Epoch: 58, Batch: 250, Avg. Loss: 0.030142008606344462\n",
      "Epoch: 58, Batch: 260, Avg. Loss: 0.017298922594636678\n",
      "Epoch: 58, Batch: 270, Avg. Loss: 0.0148070621304214\n",
      "Epoch: 58, Batch: 280, Avg. Loss: 0.03962547015398741\n",
      "Epoch: 58, Batch: 290, Avg. Loss: 0.020959915686398746\n",
      "Epoch: 58, Batch: 300, Avg. Loss: 0.020979025680571795\n",
      "Epoch: 58, Batch: 310, Avg. Loss: 0.01897556409239769\n",
      "Epoch: 58, Batch: 320, Avg. Loss: 0.019944998249411584\n",
      "Epoch: 58, Batch: 330, Avg. Loss: 0.01858086436986923\n",
      "Epoch: 58, Batch: 340, Avg. Loss: 0.020814694557338954\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 59, Batch: 10, Avg. Loss: 0.02208250090479851\n",
      "Epoch: 59, Batch: 20, Avg. Loss: 0.01613830402493477\n",
      "Epoch: 59, Batch: 30, Avg. Loss: 0.01730356877669692\n",
      "Epoch: 59, Batch: 40, Avg. Loss: 0.03341960553079844\n",
      "Epoch: 59, Batch: 50, Avg. Loss: 0.04971176255494356\n",
      "Epoch: 59, Batch: 60, Avg. Loss: 0.09955582353286445\n",
      "Epoch: 59, Batch: 70, Avg. Loss: 0.0197479953058064\n",
      "Epoch: 59, Batch: 80, Avg. Loss: 0.01949335327371955\n",
      "Epoch: 59, Batch: 90, Avg. Loss: 0.03236579578369856\n",
      "Epoch: 59, Batch: 100, Avg. Loss: 0.03143991800025105\n",
      "Epoch: 59, Batch: 110, Avg. Loss: 0.02555711418390274\n",
      "Epoch: 59, Batch: 120, Avg. Loss: 0.029983154963701963\n",
      "Epoch: 59, Batch: 130, Avg. Loss: 0.023420116864144802\n",
      "Epoch: 59, Batch: 140, Avg. Loss: 0.028482986520975827\n",
      "Epoch: 59, Batch: 150, Avg. Loss: 0.0205072021111846\n",
      "Epoch: 59, Batch: 160, Avg. Loss: 0.016491985600441694\n",
      "Epoch: 59, Batch: 170, Avg. Loss: 0.017329645436257125\n",
      "Epoch: 59, Batch: 180, Avg. Loss: 0.017172196321189402\n",
      "Epoch: 59, Batch: 190, Avg. Loss: 0.01807828601449728\n",
      "Epoch: 59, Batch: 200, Avg. Loss: 0.01695965314283967\n",
      "Epoch: 59, Batch: 210, Avg. Loss: 0.02639965433627367\n",
      "Epoch: 59, Batch: 220, Avg. Loss: 0.015433876309543848\n",
      "Epoch: 59, Batch: 230, Avg. Loss: 0.019440733920782806\n",
      "Epoch: 59, Batch: 240, Avg. Loss: 0.017443455941975116\n",
      "Epoch: 59, Batch: 250, Avg. Loss: 0.13196882009506225\n",
      "Epoch: 59, Batch: 260, Avg. Loss: 0.01850170362740755\n",
      "Epoch: 59, Batch: 270, Avg. Loss: 0.01519214166328311\n",
      "Epoch: 59, Batch: 280, Avg. Loss: 0.022130193933844567\n",
      "Epoch: 59, Batch: 290, Avg. Loss: 0.24557313732802868\n",
      "Epoch: 59, Batch: 300, Avg. Loss: 0.04153278451412916\n",
      "Epoch: 59, Batch: 310, Avg. Loss: 0.03493324927985668\n",
      "Epoch: 59, Batch: 320, Avg. Loss: 0.02714554276317358\n",
      "Epoch: 59, Batch: 330, Avg. Loss: 0.023764598555862902\n",
      "Epoch: 59, Batch: 340, Avg. Loss: 0.03217574879527092\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 60, Batch: 10, Avg. Loss: 0.020415440388023853\n",
      "Epoch: 60, Batch: 20, Avg. Loss: 0.030249252635985612\n",
      "Epoch: 60, Batch: 30, Avg. Loss: 0.022192289121448994\n",
      "Epoch: 60, Batch: 40, Avg. Loss: 0.019353210646659135\n",
      "Epoch: 60, Batch: 50, Avg. Loss: 0.2574309045448899\n",
      "Epoch: 60, Batch: 60, Avg. Loss: 0.023451162874698638\n",
      "Epoch: 60, Batch: 70, Avg. Loss: 0.022993850894272326\n",
      "Epoch: 60, Batch: 80, Avg. Loss: 0.028795071691274644\n",
      "Epoch: 60, Batch: 90, Avg. Loss: 0.02258122619241476\n",
      "Epoch: 60, Batch: 100, Avg. Loss: 0.03411717712879181\n",
      "Epoch: 60, Batch: 110, Avg. Loss: 0.026850062143057584\n",
      "Epoch: 60, Batch: 120, Avg. Loss: 0.04626507759094238\n",
      "Epoch: 60, Batch: 130, Avg. Loss: 0.06654533529654146\n",
      "Epoch: 60, Batch: 140, Avg. Loss: 0.024946072604507208\n",
      "Epoch: 60, Batch: 150, Avg. Loss: 0.020144104771316052\n",
      "Epoch: 60, Batch: 160, Avg. Loss: 0.028264278545975685\n",
      "Epoch: 60, Batch: 170, Avg. Loss: 0.015371937677264214\n",
      "Epoch: 60, Batch: 180, Avg. Loss: 0.02410225700587034\n",
      "Epoch: 60, Batch: 190, Avg. Loss: 0.03360882680863142\n",
      "Epoch: 60, Batch: 200, Avg. Loss: 0.016585825569927694\n",
      "Epoch: 60, Batch: 210, Avg. Loss: 0.019968968629837037\n",
      "Epoch: 60, Batch: 220, Avg. Loss: 0.01704041799530387\n",
      "Epoch: 60, Batch: 230, Avg. Loss: 0.015961688198149204\n",
      "Epoch: 60, Batch: 240, Avg. Loss: 0.024035016447305678\n",
      "Epoch: 60, Batch: 250, Avg. Loss: 0.017972375638782977\n",
      "Epoch: 60, Batch: 260, Avg. Loss: 0.02247302159667015\n",
      "Epoch: 60, Batch: 270, Avg. Loss: 0.020165197271853685\n",
      "Epoch: 60, Batch: 280, Avg. Loss: 0.015420345682650804\n",
      "Epoch: 60, Batch: 290, Avg. Loss: 0.016448712348937987\n",
      "Epoch: 60, Batch: 300, Avg. Loss: 0.022817873861640692\n",
      "Epoch: 60, Batch: 310, Avg. Loss: 0.018632652517408133\n",
      "Epoch: 60, Batch: 320, Avg. Loss: 0.02392927436158061\n",
      "Epoch: 60, Batch: 330, Avg. Loss: 0.023501545563340186\n",
      "Epoch: 60, Batch: 340, Avg. Loss: 0.025472614355385302\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 61, Batch: 10, Avg. Loss: 0.030977797601372002\n",
      "Epoch: 61, Batch: 20, Avg. Loss: 0.03844830524176359\n",
      "Epoch: 61, Batch: 30, Avg. Loss: 0.02273627547547221\n",
      "Epoch: 61, Batch: 40, Avg. Loss: 0.04381017982959747\n",
      "Epoch: 61, Batch: 50, Avg. Loss: 0.02328194575384259\n",
      "Epoch: 61, Batch: 60, Avg. Loss: 0.020280169136822224\n",
      "Epoch: 61, Batch: 70, Avg. Loss: 0.02016545897349715\n",
      "Epoch: 61, Batch: 80, Avg. Loss: 0.018954090401530267\n",
      "Epoch: 61, Batch: 90, Avg. Loss: 0.01840839758515358\n",
      "Epoch: 61, Batch: 100, Avg. Loss: 0.020070185605436563\n",
      "Epoch: 61, Batch: 110, Avg. Loss: 0.020157606899738313\n",
      "Epoch: 61, Batch: 120, Avg. Loss: 0.01993875131011009\n",
      "Epoch: 61, Batch: 130, Avg. Loss: 0.04789652694016695\n",
      "Epoch: 61, Batch: 140, Avg. Loss: 0.02233481118455529\n",
      "Epoch: 61, Batch: 150, Avg. Loss: 0.015215486846864223\n",
      "Epoch: 61, Batch: 160, Avg. Loss: 0.022681509703397752\n",
      "Epoch: 61, Batch: 170, Avg. Loss: 0.019882192276418208\n",
      "Epoch: 61, Batch: 180, Avg. Loss: 0.01790457423776388\n",
      "Epoch: 61, Batch: 190, Avg. Loss: 0.017554966174066065\n",
      "Epoch: 61, Batch: 200, Avg. Loss: 0.017487009521573782\n",
      "Epoch: 61, Batch: 210, Avg. Loss: 0.017028104700148105\n",
      "Epoch: 61, Batch: 220, Avg. Loss: 0.04511632602661848\n",
      "Epoch: 61, Batch: 230, Avg. Loss: 0.04096920685842633\n",
      "Epoch: 61, Batch: 240, Avg. Loss: 0.05034117680042982\n",
      "Epoch: 61, Batch: 250, Avg. Loss: 0.022305572405457497\n",
      "Epoch: 61, Batch: 260, Avg. Loss: 0.025167746655642986\n",
      "Epoch: 61, Batch: 270, Avg. Loss: 0.01996039329096675\n",
      "Epoch: 61, Batch: 280, Avg. Loss: 0.02121510887518525\n",
      "Epoch: 61, Batch: 290, Avg. Loss: 0.01785699585452676\n",
      "Epoch: 61, Batch: 300, Avg. Loss: 0.018887326307594775\n",
      "Epoch: 61, Batch: 310, Avg. Loss: 0.1056281098164618\n",
      "Epoch: 61, Batch: 320, Avg. Loss: 0.016051710676401855\n",
      "Epoch: 61, Batch: 330, Avg. Loss: 0.017130313161760568\n",
      "Epoch: 61, Batch: 340, Avg. Loss: 0.0169303129427135\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 62, Batch: 10, Avg. Loss: 0.04232291653752327\n",
      "Epoch: 62, Batch: 20, Avg. Loss: 0.01927771270275116\n",
      "Epoch: 62, Batch: 30, Avg. Loss: 0.02040409464389086\n",
      "Epoch: 62, Batch: 40, Avg. Loss: 0.016725555900484322\n",
      "Epoch: 62, Batch: 50, Avg. Loss: 0.021222126111388205\n",
      "Epoch: 62, Batch: 60, Avg. Loss: 0.017449550237506627\n",
      "Epoch: 62, Batch: 70, Avg. Loss: 0.01836144095286727\n",
      "Epoch: 62, Batch: 80, Avg. Loss: 0.01741294115781784\n",
      "Epoch: 62, Batch: 90, Avg. Loss: 0.020400426536798476\n",
      "Epoch: 62, Batch: 100, Avg. Loss: 0.02689854148775339\n",
      "Epoch: 62, Batch: 110, Avg. Loss: 0.016421453095972538\n",
      "Epoch: 62, Batch: 120, Avg. Loss: 0.016809549648314714\n",
      "Epoch: 62, Batch: 130, Avg. Loss: 0.018861925881356\n",
      "Epoch: 62, Batch: 140, Avg. Loss: 0.016245554946362973\n",
      "Epoch: 62, Batch: 150, Avg. Loss: 0.01602023122832179\n",
      "Epoch: 62, Batch: 160, Avg. Loss: 0.02274117898195982\n",
      "Epoch: 62, Batch: 170, Avg. Loss: 0.019495802372694014\n",
      "Epoch: 62, Batch: 180, Avg. Loss: 0.020530499145388605\n",
      "Epoch: 62, Batch: 190, Avg. Loss: 0.0850928507745266\n",
      "Epoch: 62, Batch: 200, Avg. Loss: 0.040226563904434444\n",
      "Epoch: 62, Batch: 210, Avg. Loss: 0.017753675021231173\n",
      "Epoch: 62, Batch: 220, Avg. Loss: 0.03119467981159687\n",
      "Epoch: 62, Batch: 230, Avg. Loss: 0.03835200611501932\n",
      "Epoch: 62, Batch: 240, Avg. Loss: 0.026952372677624226\n",
      "Epoch: 62, Batch: 250, Avg. Loss: 0.02225059662014246\n",
      "Epoch: 62, Batch: 260, Avg. Loss: 0.02499540541321039\n",
      "Epoch: 62, Batch: 270, Avg. Loss: 0.026554943714290857\n",
      "Epoch: 62, Batch: 280, Avg. Loss: 0.018798968661576508\n",
      "Epoch: 62, Batch: 290, Avg. Loss: 0.01810982935130596\n",
      "Epoch: 62, Batch: 300, Avg. Loss: 0.019256004225462676\n",
      "Epoch: 62, Batch: 310, Avg. Loss: 0.016767593659460546\n",
      "Epoch: 62, Batch: 320, Avg. Loss: 0.020540502853691578\n",
      "Epoch: 62, Batch: 330, Avg. Loss: 0.03198610255494714\n",
      "Epoch: 62, Batch: 340, Avg. Loss: 0.02120749857276678\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 63, Batch: 10, Avg. Loss: 0.019090188760310413\n",
      "Epoch: 63, Batch: 20, Avg. Loss: 0.017400048114359377\n",
      "Epoch: 63, Batch: 30, Avg. Loss: 0.019471278041601182\n",
      "Epoch: 63, Batch: 40, Avg. Loss: 0.07242975160479545\n",
      "Epoch: 63, Batch: 50, Avg. Loss: 0.019452056009322406\n",
      "Epoch: 63, Batch: 60, Avg. Loss: 0.020403934083878993\n",
      "Epoch: 63, Batch: 70, Avg. Loss: 0.021407707873731852\n",
      "Epoch: 63, Batch: 80, Avg. Loss: 0.017442878894507886\n",
      "Epoch: 63, Batch: 90, Avg. Loss: 0.033748140837997195\n",
      "Epoch: 63, Batch: 100, Avg. Loss: 0.02262338064610958\n",
      "Epoch: 63, Batch: 110, Avg. Loss: 0.026176073029637335\n",
      "Epoch: 63, Batch: 120, Avg. Loss: 0.0164012991823256\n",
      "Epoch: 63, Batch: 130, Avg. Loss: 0.016581748612225056\n",
      "Epoch: 63, Batch: 140, Avg. Loss: 0.018948690593242647\n",
      "Epoch: 63, Batch: 150, Avg. Loss: 0.016356670297682285\n",
      "Epoch: 63, Batch: 160, Avg. Loss: 0.015782929584383966\n",
      "Epoch: 63, Batch: 170, Avg. Loss: 0.021798062790185212\n",
      "Epoch: 63, Batch: 180, Avg. Loss: 0.018590348400175573\n",
      "Epoch: 63, Batch: 190, Avg. Loss: 0.022436813358217476\n",
      "Epoch: 63, Batch: 200, Avg. Loss: 0.01685554375872016\n",
      "Epoch: 63, Batch: 210, Avg. Loss: 0.016896669566631318\n",
      "Epoch: 63, Batch: 220, Avg. Loss: 0.01692826384678483\n",
      "Epoch: 63, Batch: 230, Avg. Loss: 0.016297202650457622\n",
      "Epoch: 63, Batch: 240, Avg. Loss: 0.03576797870919109\n",
      "Epoch: 63, Batch: 250, Avg. Loss: 0.020288729667663576\n",
      "Epoch: 63, Batch: 260, Avg. Loss: 0.06172087965533137\n",
      "Epoch: 63, Batch: 270, Avg. Loss: 0.027692246716469526\n",
      "Epoch: 63, Batch: 280, Avg. Loss: 0.021830581966787575\n",
      "Epoch: 63, Batch: 290, Avg. Loss: 0.028299361746758223\n",
      "Epoch: 63, Batch: 300, Avg. Loss: 0.015670272149145605\n",
      "Epoch: 63, Batch: 310, Avg. Loss: 0.021098439954221247\n",
      "Epoch: 63, Batch: 320, Avg. Loss: 0.04959561377763748\n",
      "Epoch: 63, Batch: 330, Avg. Loss: 0.03389686001464724\n",
      "Epoch: 63, Batch: 340, Avg. Loss: 0.01818846622481942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 64, Batch: 10, Avg. Loss: 0.021490324195474385\n",
      "Epoch: 64, Batch: 20, Avg. Loss: 0.01907002367079258\n",
      "Epoch: 64, Batch: 30, Avg. Loss: 0.018655654136091472\n",
      "Epoch: 64, Batch: 40, Avg. Loss: 0.017081504780799152\n",
      "Epoch: 64, Batch: 50, Avg. Loss: 0.016688289027661084\n",
      "Epoch: 64, Batch: 60, Avg. Loss: 0.018503494933247565\n",
      "Epoch: 64, Batch: 70, Avg. Loss: 0.023453443218022584\n",
      "Epoch: 64, Batch: 80, Avg. Loss: 0.16263681780546904\n",
      "Epoch: 64, Batch: 90, Avg. Loss: 0.022272364143282174\n",
      "Epoch: 64, Batch: 100, Avg. Loss: 0.028491457924246788\n",
      "Epoch: 64, Batch: 110, Avg. Loss: 0.052254794724285604\n",
      "Epoch: 64, Batch: 120, Avg. Loss: 0.024243149906396866\n",
      "Epoch: 64, Batch: 130, Avg. Loss: 0.02085421374067664\n",
      "Epoch: 64, Batch: 140, Avg. Loss: 0.031177620496600868\n",
      "Epoch: 64, Batch: 150, Avg. Loss: 0.021195123624056577\n",
      "Epoch: 64, Batch: 160, Avg. Loss: 0.021747072972357274\n",
      "Epoch: 64, Batch: 170, Avg. Loss: 0.037052130326628685\n",
      "Epoch: 64, Batch: 180, Avg. Loss: 0.023037758003920317\n",
      "Epoch: 64, Batch: 190, Avg. Loss: 0.044657235220074656\n",
      "Epoch: 64, Batch: 200, Avg. Loss: 0.01915876120328903\n",
      "Epoch: 64, Batch: 210, Avg. Loss: 0.01686506737023592\n",
      "Epoch: 64, Batch: 220, Avg. Loss: 0.02162846187129617\n",
      "Epoch: 64, Batch: 230, Avg. Loss: 0.025536623131483794\n",
      "Epoch: 64, Batch: 240, Avg. Loss: 0.015732515044510363\n",
      "Epoch: 64, Batch: 250, Avg. Loss: 0.022112085856497286\n",
      "Epoch: 64, Batch: 260, Avg. Loss: 0.016777943540364503\n",
      "Epoch: 64, Batch: 270, Avg. Loss: 0.01984012983739376\n",
      "Epoch: 64, Batch: 280, Avg. Loss: 0.021397309750318526\n",
      "Epoch: 64, Batch: 290, Avg. Loss: 0.02454340402036905\n",
      "Epoch: 64, Batch: 300, Avg. Loss: 0.024541345424950123\n",
      "Epoch: 64, Batch: 310, Avg. Loss: 0.028507800400257112\n",
      "Epoch: 64, Batch: 320, Avg. Loss: 0.031773447245359424\n",
      "Epoch: 64, Batch: 330, Avg. Loss: 0.05428346898406744\n",
      "Epoch: 64, Batch: 340, Avg. Loss: 0.03128482736647129\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 65, Batch: 10, Avg. Loss: 0.024621031433343887\n",
      "Epoch: 65, Batch: 20, Avg. Loss: 0.02371785193681717\n",
      "Epoch: 65, Batch: 30, Avg. Loss: 0.02393924044445157\n",
      "Epoch: 65, Batch: 40, Avg. Loss: 0.026369197014719247\n",
      "Epoch: 65, Batch: 50, Avg. Loss: 0.0334502418525517\n",
      "Epoch: 65, Batch: 60, Avg. Loss: 0.019164517242461442\n",
      "Epoch: 65, Batch: 70, Avg. Loss: 0.019789929687976836\n",
      "Epoch: 65, Batch: 80, Avg. Loss: 0.016944415029138328\n",
      "Epoch: 65, Batch: 90, Avg. Loss: 0.019371586851775646\n",
      "Epoch: 65, Batch: 100, Avg. Loss: 0.03515931712463498\n",
      "Epoch: 65, Batch: 110, Avg. Loss: 0.035417988896369934\n",
      "Epoch: 65, Batch: 120, Avg. Loss: 0.02641268167644739\n",
      "Epoch: 65, Batch: 130, Avg. Loss: 0.02565546091645956\n",
      "Epoch: 65, Batch: 140, Avg. Loss: 0.020509886741638183\n",
      "Epoch: 65, Batch: 150, Avg. Loss: 0.018407679721713067\n",
      "Epoch: 65, Batch: 160, Avg. Loss: 0.020673432759940623\n",
      "Epoch: 65, Batch: 170, Avg. Loss: 0.017343150824308394\n",
      "Epoch: 65, Batch: 180, Avg. Loss: 0.017074062768369914\n",
      "Epoch: 65, Batch: 190, Avg. Loss: 0.022538604494184256\n",
      "Epoch: 65, Batch: 200, Avg. Loss: 0.04925108654424548\n",
      "Epoch: 65, Batch: 210, Avg. Loss: 0.021051180455833672\n",
      "Epoch: 65, Batch: 220, Avg. Loss: 0.0187430864199996\n",
      "Epoch: 65, Batch: 230, Avg. Loss: 0.016474886704236268\n",
      "Epoch: 65, Batch: 240, Avg. Loss: 0.018434088677167892\n",
      "Epoch: 65, Batch: 250, Avg. Loss: 0.019490802101790904\n",
      "Epoch: 65, Batch: 260, Avg. Loss: 0.015088941622525453\n",
      "Epoch: 65, Batch: 270, Avg. Loss: 0.027117164991796016\n",
      "Epoch: 65, Batch: 280, Avg. Loss: 0.015279102232307195\n",
      "Epoch: 65, Batch: 290, Avg. Loss: 0.016376124508678914\n",
      "Epoch: 65, Batch: 300, Avg. Loss: 0.02064279280602932\n",
      "Epoch: 65, Batch: 310, Avg. Loss: 0.01670309668406844\n",
      "Epoch: 65, Batch: 320, Avg. Loss: 0.04855990679934621\n",
      "Epoch: 65, Batch: 330, Avg. Loss: 0.01921022720634937\n",
      "Epoch: 65, Batch: 340, Avg. Loss: 0.01529953135177493\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 66, Batch: 10, Avg. Loss: 0.019019772950559854\n",
      "Epoch: 66, Batch: 20, Avg. Loss: 0.016586869955062866\n",
      "Epoch: 66, Batch: 30, Avg. Loss: 0.01906424555927515\n",
      "Epoch: 66, Batch: 40, Avg. Loss: 0.019002503529191018\n",
      "Epoch: 66, Batch: 50, Avg. Loss: 0.02365133920684457\n",
      "Epoch: 66, Batch: 60, Avg. Loss: 0.015146674122661352\n",
      "Epoch: 66, Batch: 70, Avg. Loss: 0.014642823580652475\n",
      "Epoch: 66, Batch: 80, Avg. Loss: 0.019045671448111534\n",
      "Epoch: 66, Batch: 90, Avg. Loss: 0.015166316740214824\n",
      "Epoch: 66, Batch: 100, Avg. Loss: 0.02030283659696579\n",
      "Epoch: 66, Batch: 110, Avg. Loss: 0.01613721940666437\n",
      "Epoch: 66, Batch: 120, Avg. Loss: 0.016232078429311514\n",
      "Epoch: 66, Batch: 130, Avg. Loss: 0.016357843484729528\n",
      "Epoch: 66, Batch: 140, Avg. Loss: 0.04264604104682803\n",
      "Epoch: 66, Batch: 150, Avg. Loss: 0.026616435125470163\n",
      "Epoch: 66, Batch: 160, Avg. Loss: 0.025806105695664883\n",
      "Epoch: 66, Batch: 170, Avg. Loss: 0.02066817106679082\n",
      "Epoch: 66, Batch: 180, Avg. Loss: 0.019318301882594823\n",
      "Epoch: 66, Batch: 190, Avg. Loss: 0.023786166775971652\n",
      "Epoch: 66, Batch: 200, Avg. Loss: 0.015740949660539627\n",
      "Epoch: 66, Batch: 210, Avg. Loss: 0.022634331695735456\n",
      "Epoch: 66, Batch: 220, Avg. Loss: 0.04530513659119606\n",
      "Epoch: 66, Batch: 230, Avg. Loss: 0.02195645300671458\n",
      "Epoch: 66, Batch: 240, Avg. Loss: 0.024477234669029714\n",
      "Epoch: 66, Batch: 250, Avg. Loss: 0.02364670401439071\n",
      "Epoch: 66, Batch: 260, Avg. Loss: 0.022647060826420783\n",
      "Epoch: 66, Batch: 270, Avg. Loss: 0.01790970154106617\n",
      "Epoch: 66, Batch: 280, Avg. Loss: 0.020582379866391422\n",
      "Epoch: 66, Batch: 290, Avg. Loss: 0.04130341829732061\n",
      "Epoch: 66, Batch: 300, Avg. Loss: 0.06537043172866105\n",
      "Epoch: 66, Batch: 310, Avg. Loss: 0.02288511339575052\n",
      "Epoch: 66, Batch: 320, Avg. Loss: 0.020075912680476905\n",
      "Epoch: 66, Batch: 330, Avg. Loss: 0.015682906657457352\n",
      "Epoch: 66, Batch: 340, Avg. Loss: 0.01827136967331171\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 67, Batch: 10, Avg. Loss: 0.019504480063915253\n",
      "Epoch: 67, Batch: 20, Avg. Loss: 0.020795563235878944\n",
      "Epoch: 67, Batch: 30, Avg. Loss: 0.014952953718602658\n",
      "Epoch: 67, Batch: 40, Avg. Loss: 0.02033041585236788\n",
      "Epoch: 67, Batch: 50, Avg. Loss: 0.018281198851764203\n",
      "Epoch: 67, Batch: 60, Avg. Loss: 0.1475059177726507\n",
      "Epoch: 67, Batch: 70, Avg. Loss: 0.18771173283457757\n",
      "Epoch: 67, Batch: 80, Avg. Loss: 0.023567898478358985\n",
      "Epoch: 67, Batch: 90, Avg. Loss: 0.03310975385829806\n",
      "Epoch: 67, Batch: 100, Avg. Loss: 0.0168564535677433\n",
      "Epoch: 67, Batch: 110, Avg. Loss: 0.020956654846668244\n",
      "Epoch: 67, Batch: 120, Avg. Loss: 0.01846581054851413\n",
      "Epoch: 67, Batch: 130, Avg. Loss: 0.023348139319568872\n",
      "Epoch: 67, Batch: 140, Avg. Loss: 0.014106713980436326\n",
      "Epoch: 67, Batch: 150, Avg. Loss: 0.02285227831453085\n",
      "Epoch: 67, Batch: 160, Avg. Loss: 0.019767595175653695\n",
      "Epoch: 67, Batch: 170, Avg. Loss: 0.01922795604914427\n",
      "Epoch: 67, Batch: 180, Avg. Loss: 0.021973982639610767\n",
      "Epoch: 67, Batch: 190, Avg. Loss: 0.019822248816490175\n",
      "Epoch: 67, Batch: 200, Avg. Loss: 0.016159360855817796\n",
      "Epoch: 67, Batch: 210, Avg. Loss: 0.019965154025703667\n",
      "Epoch: 67, Batch: 220, Avg. Loss: 0.016555710788816215\n",
      "Epoch: 67, Batch: 230, Avg. Loss: 0.02750527486205101\n",
      "Epoch: 67, Batch: 240, Avg. Loss: 0.02397970324382186\n",
      "Epoch: 67, Batch: 250, Avg. Loss: 0.01820258963853121\n",
      "Epoch: 67, Batch: 260, Avg. Loss: 0.01630460945889354\n",
      "Epoch: 67, Batch: 270, Avg. Loss: 0.016294825356453657\n",
      "Epoch: 67, Batch: 280, Avg. Loss: 0.02409122372046113\n",
      "Epoch: 67, Batch: 290, Avg. Loss: 0.016430412605404853\n",
      "Epoch: 67, Batch: 300, Avg. Loss: 0.01762981852516532\n",
      "Epoch: 67, Batch: 310, Avg. Loss: 0.01957240393385291\n",
      "Epoch: 67, Batch: 320, Avg. Loss: 0.014819174446165562\n",
      "Epoch: 67, Batch: 330, Avg. Loss: 0.018729312624782325\n",
      "Epoch: 67, Batch: 340, Avg. Loss: 0.023630023747682572\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 68, Batch: 10, Avg. Loss: 0.01782516660168767\n",
      "Epoch: 68, Batch: 20, Avg. Loss: 0.015604617074131966\n",
      "Epoch: 68, Batch: 30, Avg. Loss: 0.02035661544650793\n",
      "Epoch: 68, Batch: 40, Avg. Loss: 0.02094093281775713\n",
      "Epoch: 68, Batch: 50, Avg. Loss: 0.021267909649759532\n",
      "Epoch: 68, Batch: 60, Avg. Loss: 0.021813717763870956\n",
      "Epoch: 68, Batch: 70, Avg. Loss: 0.019648728892207146\n",
      "Epoch: 68, Batch: 80, Avg. Loss: 0.03497622720897198\n",
      "Epoch: 68, Batch: 90, Avg. Loss: 0.017731299623847008\n",
      "Epoch: 68, Batch: 100, Avg. Loss: 0.10247539449483156\n",
      "Epoch: 68, Batch: 110, Avg. Loss: 0.017004261258989573\n",
      "Epoch: 68, Batch: 120, Avg. Loss: 0.01760724075138569\n",
      "Epoch: 68, Batch: 130, Avg. Loss: 0.020940433721989393\n",
      "Epoch: 68, Batch: 140, Avg. Loss: 0.015946421399712564\n",
      "Epoch: 68, Batch: 150, Avg. Loss: 0.016737862024456263\n",
      "Epoch: 68, Batch: 160, Avg. Loss: 0.04501319294795394\n",
      "Epoch: 68, Batch: 170, Avg. Loss: 0.018324915319681168\n",
      "Epoch: 68, Batch: 180, Avg. Loss: 0.025448801275342704\n",
      "Epoch: 68, Batch: 190, Avg. Loss: 0.019467619061470032\n",
      "Epoch: 68, Batch: 200, Avg. Loss: 0.015723732579499484\n",
      "Epoch: 68, Batch: 210, Avg. Loss: 0.017961352691054346\n",
      "Epoch: 68, Batch: 220, Avg. Loss: 0.01976790586486459\n",
      "Epoch: 68, Batch: 230, Avg. Loss: 0.017709649819880723\n",
      "Epoch: 68, Batch: 240, Avg. Loss: 0.018168652709573508\n",
      "Epoch: 68, Batch: 250, Avg. Loss: 0.016630568262189626\n",
      "Epoch: 68, Batch: 260, Avg. Loss: 0.015311891864985227\n",
      "Epoch: 68, Batch: 270, Avg. Loss: 0.021433892007917166\n",
      "Epoch: 68, Batch: 280, Avg. Loss: 0.016122728958725928\n",
      "Epoch: 68, Batch: 290, Avg. Loss: 0.0619972531683743\n",
      "Epoch: 68, Batch: 300, Avg. Loss: 0.022347430884838104\n",
      "Epoch: 68, Batch: 310, Avg. Loss: 0.02285978468134999\n",
      "Epoch: 68, Batch: 320, Avg. Loss: 0.021002100966870784\n",
      "Epoch: 68, Batch: 330, Avg. Loss: 0.021544077806174754\n",
      "Epoch: 68, Batch: 340, Avg. Loss: 0.039610070176422596\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 69, Batch: 10, Avg. Loss: 0.019269786402583124\n",
      "Epoch: 69, Batch: 20, Avg. Loss: 0.015229345113039017\n",
      "Epoch: 69, Batch: 30, Avg. Loss: 0.01923456946387887\n",
      "Epoch: 69, Batch: 40, Avg. Loss: 0.02811584444716573\n",
      "Epoch: 69, Batch: 50, Avg. Loss: 0.018674176651984453\n",
      "Epoch: 69, Batch: 60, Avg. Loss: 0.016659518145024775\n",
      "Epoch: 69, Batch: 70, Avg. Loss: 0.01772004384547472\n",
      "Epoch: 69, Batch: 80, Avg. Loss: 0.02350834272801876\n",
      "Epoch: 69, Batch: 90, Avg. Loss: 0.02099510245025158\n",
      "Epoch: 69, Batch: 100, Avg. Loss: 0.025531171169131995\n",
      "Epoch: 69, Batch: 110, Avg. Loss: 0.01777401491999626\n",
      "Epoch: 69, Batch: 120, Avg. Loss: 0.02001243121922016\n",
      "Epoch: 69, Batch: 130, Avg. Loss: 0.01941531486809254\n",
      "Epoch: 69, Batch: 140, Avg. Loss: 0.021030573826283216\n",
      "Epoch: 69, Batch: 150, Avg. Loss: 0.01782379876822233\n",
      "Epoch: 69, Batch: 160, Avg. Loss: 0.014823200833052396\n",
      "Epoch: 69, Batch: 170, Avg. Loss: 0.019785730447620154\n",
      "Epoch: 69, Batch: 180, Avg. Loss: 0.018362837936729194\n",
      "Epoch: 69, Batch: 190, Avg. Loss: 0.01897651581093669\n",
      "Epoch: 69, Batch: 200, Avg. Loss: 0.014726843498647214\n",
      "Epoch: 69, Batch: 210, Avg. Loss: 0.03588723428547382\n",
      "Epoch: 69, Batch: 220, Avg. Loss: 0.02892565317451954\n",
      "Epoch: 69, Batch: 230, Avg. Loss: 0.01764995325356722\n",
      "Epoch: 69, Batch: 240, Avg. Loss: 0.031928001437336206\n",
      "Epoch: 69, Batch: 250, Avg. Loss: 0.016617036424577236\n",
      "Epoch: 69, Batch: 260, Avg. Loss: 0.016140801087021827\n",
      "Epoch: 69, Batch: 270, Avg. Loss: 0.01916382759809494\n",
      "Epoch: 69, Batch: 280, Avg. Loss: 0.019792509824037553\n",
      "Epoch: 69, Batch: 290, Avg. Loss: 0.015869140811264514\n",
      "Epoch: 69, Batch: 300, Avg. Loss: 0.016842558328062297\n",
      "Epoch: 69, Batch: 310, Avg. Loss: 0.019965972006320953\n",
      "Epoch: 69, Batch: 320, Avg. Loss: 0.01819754745811224\n",
      "Epoch: 69, Batch: 330, Avg. Loss: 0.01574434069916606\n",
      "Epoch: 69, Batch: 340, Avg. Loss: 0.018043685983866454\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 70, Batch: 10, Avg. Loss: 0.018242936674505474\n",
      "Epoch: 70, Batch: 20, Avg. Loss: 0.014582161139696837\n",
      "Epoch: 70, Batch: 30, Avg. Loss: 0.03481361521407962\n",
      "Epoch: 70, Batch: 40, Avg. Loss: 0.016792256478220226\n",
      "Epoch: 70, Batch: 50, Avg. Loss: 0.017043325025588273\n",
      "Epoch: 70, Batch: 60, Avg. Loss: 0.01782144270837307\n",
      "Epoch: 70, Batch: 70, Avg. Loss: 0.020182587020099164\n",
      "Epoch: 70, Batch: 80, Avg. Loss: 0.020002399664372207\n",
      "Epoch: 70, Batch: 90, Avg. Loss: 0.02509246291592717\n",
      "Epoch: 70, Batch: 100, Avg. Loss: 0.15956673193722964\n",
      "Epoch: 70, Batch: 110, Avg. Loss: 0.04962563496083021\n",
      "Epoch: 70, Batch: 120, Avg. Loss: 0.02241892637684941\n",
      "Epoch: 70, Batch: 130, Avg. Loss: 0.02209287481382489\n",
      "Epoch: 70, Batch: 140, Avg. Loss: 0.01874713907018304\n",
      "Epoch: 70, Batch: 150, Avg. Loss: 0.026684000622481108\n",
      "Epoch: 70, Batch: 160, Avg. Loss: 0.029199854750186206\n",
      "Epoch: 70, Batch: 170, Avg. Loss: 0.024295248743146657\n",
      "Epoch: 70, Batch: 180, Avg. Loss: 0.020251565147191286\n",
      "Epoch: 70, Batch: 190, Avg. Loss: 0.05425250418484211\n",
      "Epoch: 70, Batch: 200, Avg. Loss: 0.020026264991611243\n",
      "Epoch: 70, Batch: 210, Avg. Loss: 0.02302625300362706\n",
      "Epoch: 70, Batch: 220, Avg. Loss: 0.018792853970080615\n",
      "Epoch: 70, Batch: 230, Avg. Loss: 0.019566155131906272\n",
      "Epoch: 70, Batch: 240, Avg. Loss: 0.02021190766245127\n",
      "Epoch: 70, Batch: 250, Avg. Loss: 0.02675664173439145\n",
      "Epoch: 70, Batch: 260, Avg. Loss: 0.02151651158928871\n",
      "Epoch: 70, Batch: 270, Avg. Loss: 0.017683932557702065\n",
      "Epoch: 70, Batch: 280, Avg. Loss: 0.021946742199361324\n",
      "Epoch: 70, Batch: 290, Avg. Loss: 0.027047288604080677\n",
      "Epoch: 70, Batch: 300, Avg. Loss: 0.022472249902784826\n",
      "Epoch: 70, Batch: 310, Avg. Loss: 0.017181811295449732\n",
      "Epoch: 70, Batch: 320, Avg. Loss: 0.018454614374786616\n",
      "Epoch: 70, Batch: 330, Avg. Loss: 0.024384918995201586\n",
      "Epoch: 70, Batch: 340, Avg. Loss: 0.018552788812667132\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 71, Batch: 10, Avg. Loss: 0.08772203149273991\n",
      "Epoch: 71, Batch: 20, Avg. Loss: 0.021568103414028882\n",
      "Epoch: 71, Batch: 30, Avg. Loss: 0.024767796322703362\n",
      "Epoch: 71, Batch: 40, Avg. Loss: 0.02316334992647171\n",
      "Epoch: 71, Batch: 50, Avg. Loss: 0.04447854477912187\n",
      "Epoch: 71, Batch: 60, Avg. Loss: 0.030402258224785327\n",
      "Epoch: 71, Batch: 70, Avg. Loss: 0.018475923221558332\n",
      "Epoch: 71, Batch: 80, Avg. Loss: 0.017695925757288934\n",
      "Epoch: 71, Batch: 90, Avg. Loss: 0.02489237617701292\n",
      "Epoch: 71, Batch: 100, Avg. Loss: 0.016639387235045433\n",
      "Epoch: 71, Batch: 110, Avg. Loss: 0.04820582484826445\n",
      "Epoch: 71, Batch: 120, Avg. Loss: 0.02475348822772503\n",
      "Epoch: 71, Batch: 130, Avg. Loss: 0.023145565763115883\n",
      "Epoch: 71, Batch: 140, Avg. Loss: 0.016154546290636063\n",
      "Epoch: 71, Batch: 150, Avg. Loss: 0.02153269909322262\n",
      "Epoch: 71, Batch: 160, Avg. Loss: 0.030720501393079757\n",
      "Epoch: 71, Batch: 170, Avg. Loss: 0.01848262408748269\n",
      "Epoch: 71, Batch: 180, Avg. Loss: 0.08474378529936075\n",
      "Epoch: 71, Batch: 190, Avg. Loss: 0.020932544860988854\n",
      "Epoch: 71, Batch: 200, Avg. Loss: 0.01717858323827386\n",
      "Epoch: 71, Batch: 210, Avg. Loss: 0.04960250230506062\n",
      "Epoch: 71, Batch: 220, Avg. Loss: 0.019310229830443858\n",
      "Epoch: 71, Batch: 230, Avg. Loss: 0.02290359577164054\n",
      "Epoch: 71, Batch: 240, Avg. Loss: 0.027870855387300254\n",
      "Epoch: 71, Batch: 250, Avg. Loss: 0.05990406945347786\n",
      "Epoch: 71, Batch: 260, Avg. Loss: 0.033741891570389274\n",
      "Epoch: 71, Batch: 270, Avg. Loss: 0.02399644339457154\n",
      "Epoch: 71, Batch: 280, Avg. Loss: 0.04009760729968548\n",
      "Epoch: 71, Batch: 290, Avg. Loss: 0.023119184374809264\n",
      "Epoch: 71, Batch: 300, Avg. Loss: 0.019367497600615024\n",
      "Epoch: 71, Batch: 310, Avg. Loss: 0.01862057102844119\n",
      "Epoch: 71, Batch: 320, Avg. Loss: 0.022006322629749775\n",
      "Epoch: 71, Batch: 330, Avg. Loss: 0.016433107573539017\n",
      "Epoch: 71, Batch: 340, Avg. Loss: 0.018226934131234884\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 72, Batch: 10, Avg. Loss: 0.01781724961474538\n",
      "Epoch: 72, Batch: 20, Avg. Loss: 0.06446076575666666\n",
      "Epoch: 72, Batch: 30, Avg. Loss: 0.03108633616939187\n",
      "Epoch: 72, Batch: 40, Avg. Loss: 0.0208690507337451\n",
      "Epoch: 72, Batch: 50, Avg. Loss: 0.045556193217635155\n",
      "Epoch: 72, Batch: 60, Avg. Loss: 0.01771702440455556\n",
      "Epoch: 72, Batch: 70, Avg. Loss: 0.02516857339069247\n",
      "Epoch: 72, Batch: 80, Avg. Loss: 0.016046345140784977\n",
      "Epoch: 72, Batch: 90, Avg. Loss: 0.02310500182211399\n",
      "Epoch: 72, Batch: 100, Avg. Loss: 0.026527001429349183\n",
      "Epoch: 72, Batch: 110, Avg. Loss: 0.02158962991088629\n",
      "Epoch: 72, Batch: 120, Avg. Loss: 0.017473378870636224\n",
      "Epoch: 72, Batch: 130, Avg. Loss: 0.017588024120777847\n",
      "Epoch: 72, Batch: 140, Avg. Loss: 0.019735475815832616\n",
      "Epoch: 72, Batch: 150, Avg. Loss: 0.02103707641363144\n",
      "Epoch: 72, Batch: 160, Avg. Loss: 0.016026184801012276\n",
      "Epoch: 72, Batch: 170, Avg. Loss: 0.015733006224036217\n",
      "Epoch: 72, Batch: 180, Avg. Loss: 0.015241486858576537\n",
      "Epoch: 72, Batch: 190, Avg. Loss: 0.019303692597895862\n",
      "Epoch: 72, Batch: 200, Avg. Loss: 0.019443096220493318\n",
      "Epoch: 72, Batch: 210, Avg. Loss: 0.018546580988913774\n",
      "Epoch: 72, Batch: 220, Avg. Loss: 0.01652652071788907\n",
      "Epoch: 72, Batch: 230, Avg. Loss: 0.01762384930625558\n",
      "Epoch: 72, Batch: 240, Avg. Loss: 0.04341430794447661\n",
      "Epoch: 72, Batch: 250, Avg. Loss: 0.020358365308493376\n",
      "Epoch: 72, Batch: 260, Avg. Loss: 0.017015373241156338\n",
      "Epoch: 72, Batch: 270, Avg. Loss: 0.07052333345636726\n",
      "Epoch: 72, Batch: 280, Avg. Loss: 0.03879440985620022\n",
      "Epoch: 72, Batch: 290, Avg. Loss: 0.03375048050656915\n",
      "Epoch: 72, Batch: 300, Avg. Loss: 0.022413946501910687\n",
      "Epoch: 72, Batch: 310, Avg. Loss: 0.022975803073495626\n",
      "Epoch: 72, Batch: 320, Avg. Loss: 0.018641748651862144\n",
      "Epoch: 72, Batch: 330, Avg. Loss: 0.03858097661286593\n",
      "Epoch: 72, Batch: 340, Avg. Loss: 0.024454914126545192\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 73, Batch: 10, Avg. Loss: 0.01935235783457756\n",
      "Epoch: 73, Batch: 20, Avg. Loss: 0.024127690866589547\n",
      "Epoch: 73, Batch: 30, Avg. Loss: 0.020199951156973837\n",
      "Epoch: 73, Batch: 40, Avg. Loss: 0.016582617443054913\n",
      "Epoch: 73, Batch: 50, Avg. Loss: 0.017041753511875868\n",
      "Epoch: 73, Batch: 60, Avg. Loss: 0.025241781678050756\n",
      "Epoch: 73, Batch: 70, Avg. Loss: 0.04225385226309299\n",
      "Epoch: 73, Batch: 80, Avg. Loss: 0.02195513816550374\n",
      "Epoch: 73, Batch: 90, Avg. Loss: 0.0252649936825037\n",
      "Epoch: 73, Batch: 100, Avg. Loss: 0.028557669930160047\n",
      "Epoch: 73, Batch: 110, Avg. Loss: 0.0509696583263576\n",
      "Epoch: 73, Batch: 120, Avg. Loss: 0.04528855821117759\n",
      "Epoch: 73, Batch: 130, Avg. Loss: 0.02056298954412341\n",
      "Epoch: 73, Batch: 140, Avg. Loss: 0.018163112085312606\n",
      "Epoch: 73, Batch: 150, Avg. Loss: 0.023106027487665416\n",
      "Epoch: 73, Batch: 160, Avg. Loss: 0.02189583359286189\n",
      "Epoch: 73, Batch: 170, Avg. Loss: 0.01771842744201422\n",
      "Epoch: 73, Batch: 180, Avg. Loss: 0.01845505777746439\n",
      "Epoch: 73, Batch: 190, Avg. Loss: 0.020604389533400536\n",
      "Epoch: 73, Batch: 200, Avg. Loss: 0.01668389430269599\n",
      "Epoch: 73, Batch: 210, Avg. Loss: 0.018257400114089252\n",
      "Epoch: 73, Batch: 220, Avg. Loss: 0.03642405420541763\n",
      "Epoch: 73, Batch: 230, Avg. Loss: 0.021362011879682542\n",
      "Epoch: 73, Batch: 240, Avg. Loss: 0.021339534036815166\n",
      "Epoch: 73, Batch: 250, Avg. Loss: 0.01973311258479953\n",
      "Epoch: 73, Batch: 260, Avg. Loss: 0.03183133751153946\n",
      "Epoch: 73, Batch: 270, Avg. Loss: 0.017797877360135318\n",
      "Epoch: 73, Batch: 280, Avg. Loss: 0.018818552233278753\n",
      "Epoch: 73, Batch: 290, Avg. Loss: 0.01773869888857007\n",
      "Epoch: 73, Batch: 300, Avg. Loss: 0.016840747743844985\n",
      "Epoch: 73, Batch: 310, Avg. Loss: 0.016175862308591603\n",
      "Epoch: 73, Batch: 320, Avg. Loss: 0.017480248119682074\n",
      "Epoch: 73, Batch: 330, Avg. Loss: 0.01507649989798665\n",
      "Epoch: 73, Batch: 340, Avg. Loss: 0.021913578640669583\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 74, Batch: 10, Avg. Loss: 0.01648527029901743\n",
      "Epoch: 74, Batch: 20, Avg. Loss: 0.015608673635870218\n",
      "Epoch: 74, Batch: 30, Avg. Loss: 0.015512458886951208\n",
      "Epoch: 74, Batch: 40, Avg. Loss: 0.019132325518876316\n",
      "Epoch: 74, Batch: 50, Avg. Loss: 0.020696935057640076\n",
      "Epoch: 74, Batch: 60, Avg. Loss: 0.018417558632791042\n",
      "Epoch: 74, Batch: 70, Avg. Loss: 0.016087292041629554\n",
      "Epoch: 74, Batch: 80, Avg. Loss: 0.017529330030083657\n",
      "Epoch: 74, Batch: 90, Avg. Loss: 0.01712454706430435\n",
      "Epoch: 74, Batch: 100, Avg. Loss: 0.0191266099922359\n",
      "Epoch: 74, Batch: 110, Avg. Loss: 0.015409044269472361\n",
      "Epoch: 74, Batch: 120, Avg. Loss: 0.018719452153891324\n",
      "Epoch: 74, Batch: 130, Avg. Loss: 0.015025914087891579\n",
      "Epoch: 74, Batch: 140, Avg. Loss: 0.01657299408689141\n",
      "Epoch: 74, Batch: 150, Avg. Loss: 0.015741962008178234\n",
      "Epoch: 74, Batch: 160, Avg. Loss: 0.019577918108552694\n",
      "Epoch: 74, Batch: 170, Avg. Loss: 0.016005851328372955\n",
      "Epoch: 74, Batch: 180, Avg. Loss: 0.03781001847237349\n",
      "Epoch: 74, Batch: 190, Avg. Loss: 0.01848245272412896\n",
      "Epoch: 74, Batch: 200, Avg. Loss: 0.02158244913443923\n",
      "Epoch: 74, Batch: 210, Avg. Loss: 0.09077297458425164\n",
      "Epoch: 74, Batch: 220, Avg. Loss: 0.02438461147248745\n",
      "Epoch: 74, Batch: 230, Avg. Loss: 0.01765858056023717\n",
      "Epoch: 74, Batch: 240, Avg. Loss: 0.016303974203765392\n",
      "Epoch: 74, Batch: 250, Avg. Loss: 0.018824896961450576\n",
      "Epoch: 74, Batch: 260, Avg. Loss: 0.01931674685329199\n",
      "Epoch: 74, Batch: 270, Avg. Loss: 0.024503538478165866\n",
      "Epoch: 74, Batch: 280, Avg. Loss: 0.028459197655320168\n",
      "Epoch: 74, Batch: 290, Avg. Loss: 0.016745388228446244\n",
      "Epoch: 74, Batch: 300, Avg. Loss: 0.017932759411633015\n",
      "Epoch: 74, Batch: 310, Avg. Loss: 0.020919009670615198\n",
      "Epoch: 74, Batch: 320, Avg. Loss: 0.015792254637926818\n",
      "Epoch: 74, Batch: 330, Avg. Loss: 0.021762203052639963\n",
      "Epoch: 74, Batch: 340, Avg. Loss: 0.02231812188401818\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 75, Batch: 10, Avg. Loss: 0.02507249005138874\n",
      "Epoch: 75, Batch: 20, Avg. Loss: 0.018519924208521842\n",
      "Epoch: 75, Batch: 30, Avg. Loss: 0.015045269299298525\n",
      "Epoch: 75, Batch: 40, Avg. Loss: 0.018464213609695433\n",
      "Epoch: 75, Batch: 50, Avg. Loss: 0.0184498468413949\n",
      "Epoch: 75, Batch: 60, Avg. Loss: 0.05344752529636025\n",
      "Epoch: 75, Batch: 70, Avg. Loss: 0.021241943631321192\n",
      "Epoch: 75, Batch: 80, Avg. Loss: 0.019523836486041547\n",
      "Epoch: 75, Batch: 90, Avg. Loss: 0.023413512110710143\n",
      "Epoch: 75, Batch: 100, Avg. Loss: 0.019085561763495205\n",
      "Epoch: 75, Batch: 110, Avg. Loss: 0.021542439982295037\n",
      "Epoch: 75, Batch: 120, Avg. Loss: 0.022854736447334288\n",
      "Epoch: 75, Batch: 130, Avg. Loss: 0.015299017541110516\n",
      "Epoch: 75, Batch: 140, Avg. Loss: 0.017332146782428025\n",
      "Epoch: 75, Batch: 150, Avg. Loss: 0.017631484661251307\n",
      "Epoch: 75, Batch: 160, Avg. Loss: 0.015801781415939332\n",
      "Epoch: 75, Batch: 170, Avg. Loss: 0.016876834724098445\n",
      "Epoch: 75, Batch: 180, Avg. Loss: 0.017726059537380934\n",
      "Epoch: 75, Batch: 190, Avg. Loss: 0.014304512180387974\n",
      "Epoch: 75, Batch: 200, Avg. Loss: 0.017546343524008988\n",
      "Epoch: 75, Batch: 210, Avg. Loss: 0.01501967767253518\n",
      "Epoch: 75, Batch: 220, Avg. Loss: 0.016684580035507678\n",
      "Epoch: 75, Batch: 230, Avg. Loss: 0.017887549102306367\n",
      "Epoch: 75, Batch: 240, Avg. Loss: 0.044373559020459655\n",
      "Epoch: 75, Batch: 250, Avg. Loss: 0.017548598814755678\n",
      "Epoch: 75, Batch: 260, Avg. Loss: 0.020163724198937416\n",
      "Epoch: 75, Batch: 270, Avg. Loss: 0.019660389795899392\n",
      "Epoch: 75, Batch: 280, Avg. Loss: 0.019479518476873636\n",
      "Epoch: 75, Batch: 290, Avg. Loss: 0.047085787449032065\n",
      "Epoch: 75, Batch: 300, Avg. Loss: 0.03298839135095477\n",
      "Epoch: 75, Batch: 310, Avg. Loss: 0.017495056614279747\n",
      "Epoch: 75, Batch: 320, Avg. Loss: 0.02243463071063161\n",
      "Epoch: 75, Batch: 330, Avg. Loss: 0.019646605104207994\n",
      "Epoch: 75, Batch: 340, Avg. Loss: 0.019233635719865562\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 76, Batch: 10, Avg. Loss: 0.027671425323933362\n",
      "Epoch: 76, Batch: 20, Avg. Loss: 0.017099743243306875\n",
      "Epoch: 76, Batch: 30, Avg. Loss: 0.01633003046736121\n",
      "Epoch: 76, Batch: 40, Avg. Loss: 0.018361444212496282\n",
      "Epoch: 76, Batch: 50, Avg. Loss: 0.022368350252509116\n",
      "Epoch: 76, Batch: 60, Avg. Loss: 0.016325865499675275\n",
      "Epoch: 76, Batch: 70, Avg. Loss: 0.018765807896852494\n",
      "Epoch: 76, Batch: 80, Avg. Loss: 0.01795344054698944\n",
      "Epoch: 76, Batch: 90, Avg. Loss: 0.032463837414979935\n",
      "Epoch: 76, Batch: 100, Avg. Loss: 0.017774781584739684\n",
      "Epoch: 76, Batch: 110, Avg. Loss: 0.017391451727598907\n",
      "Epoch: 76, Batch: 120, Avg. Loss: 0.01640828186646104\n",
      "Epoch: 76, Batch: 130, Avg. Loss: 0.024449270218610764\n",
      "Epoch: 76, Batch: 140, Avg. Loss: 0.02369381198659539\n",
      "Epoch: 76, Batch: 150, Avg. Loss: 0.01653941674157977\n",
      "Epoch: 76, Batch: 160, Avg. Loss: 0.022216454427689315\n",
      "Epoch: 76, Batch: 170, Avg. Loss: 0.016700202133506536\n",
      "Epoch: 76, Batch: 180, Avg. Loss: 0.015582752600312232\n",
      "Epoch: 76, Batch: 190, Avg. Loss: 0.01543020000681281\n",
      "Epoch: 76, Batch: 200, Avg. Loss: 0.016195632889866828\n",
      "Epoch: 76, Batch: 210, Avg. Loss: 0.022791959717869757\n",
      "Epoch: 76, Batch: 220, Avg. Loss: 0.020676435995846988\n",
      "Epoch: 76, Batch: 230, Avg. Loss: 0.01700709844008088\n",
      "Epoch: 76, Batch: 240, Avg. Loss: 0.019945583119988442\n",
      "Epoch: 76, Batch: 250, Avg. Loss: 0.015405836328864098\n",
      "Epoch: 76, Batch: 260, Avg. Loss: 0.022968357522040607\n",
      "Epoch: 76, Batch: 270, Avg. Loss: 0.017942021787166595\n",
      "Epoch: 76, Batch: 280, Avg. Loss: 0.045798981469124554\n",
      "Epoch: 76, Batch: 290, Avg. Loss: 0.02367753740400076\n",
      "Epoch: 76, Batch: 300, Avg. Loss: 0.028787859622389077\n",
      "Epoch: 76, Batch: 310, Avg. Loss: 0.019784538727253675\n",
      "Epoch: 76, Batch: 320, Avg. Loss: 0.01751503013074398\n",
      "Epoch: 76, Batch: 330, Avg. Loss: 0.024139728303998707\n",
      "Epoch: 76, Batch: 340, Avg. Loss: 0.01672730380669236\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 77, Batch: 10, Avg. Loss: 0.03635831447318196\n",
      "Epoch: 77, Batch: 20, Avg. Loss: 0.015541110839694738\n",
      "Epoch: 77, Batch: 30, Avg. Loss: 0.016149238031357527\n",
      "Epoch: 77, Batch: 40, Avg. Loss: 0.019976098369807006\n",
      "Epoch: 77, Batch: 50, Avg. Loss: 0.019222629349678756\n",
      "Epoch: 77, Batch: 60, Avg. Loss: 0.024585589580237866\n",
      "Epoch: 77, Batch: 70, Avg. Loss: 0.018918052781373262\n",
      "Epoch: 77, Batch: 80, Avg. Loss: 0.015560513734817505\n",
      "Epoch: 77, Batch: 90, Avg. Loss: 0.01667583268135786\n",
      "Epoch: 77, Batch: 100, Avg. Loss: 0.024594169203191997\n",
      "Epoch: 77, Batch: 110, Avg. Loss: 0.03253797003999352\n",
      "Epoch: 77, Batch: 120, Avg. Loss: 0.020743231754750013\n",
      "Epoch: 77, Batch: 130, Avg. Loss: 0.022000047471374275\n",
      "Epoch: 77, Batch: 140, Avg. Loss: 0.013701057340949774\n",
      "Epoch: 77, Batch: 150, Avg. Loss: 0.017394217383116483\n",
      "Epoch: 77, Batch: 160, Avg. Loss: 0.019638343155384062\n",
      "Epoch: 77, Batch: 170, Avg. Loss: 0.022869119979441167\n",
      "Epoch: 77, Batch: 180, Avg. Loss: 0.019063468743115663\n",
      "Epoch: 77, Batch: 190, Avg. Loss: 0.01907465485855937\n",
      "Epoch: 77, Batch: 200, Avg. Loss: 0.017419915087521075\n",
      "Epoch: 77, Batch: 210, Avg. Loss: 0.1043077377602458\n",
      "Epoch: 77, Batch: 220, Avg. Loss: 0.018874314706772567\n",
      "Epoch: 77, Batch: 230, Avg. Loss: 0.02120127119123936\n",
      "Epoch: 77, Batch: 240, Avg. Loss: 0.016791442036628725\n",
      "Epoch: 77, Batch: 250, Avg. Loss: 0.021554758213460444\n",
      "Epoch: 77, Batch: 260, Avg. Loss: 0.021976603381335735\n",
      "Epoch: 77, Batch: 270, Avg. Loss: 0.01774665480479598\n",
      "Epoch: 77, Batch: 280, Avg. Loss: 0.027947928942739963\n",
      "Epoch: 77, Batch: 290, Avg. Loss: 0.017927759420126678\n",
      "Epoch: 77, Batch: 300, Avg. Loss: 0.020673631224781275\n",
      "Epoch: 77, Batch: 310, Avg. Loss: 0.016384087689220905\n",
      "Epoch: 77, Batch: 320, Avg. Loss: 0.015499505400657653\n",
      "Epoch: 77, Batch: 330, Avg. Loss: 0.0410829165019095\n",
      "Epoch: 77, Batch: 340, Avg. Loss: 0.018179793655872346\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 78, Batch: 10, Avg. Loss: 0.016208588518202303\n",
      "Epoch: 78, Batch: 20, Avg. Loss: 0.017308728862553836\n",
      "Epoch: 78, Batch: 30, Avg. Loss: 0.018227626476436852\n",
      "Epoch: 78, Batch: 40, Avg. Loss: 0.051331060472875834\n",
      "Epoch: 78, Batch: 50, Avg. Loss: 0.020153935253620147\n",
      "Epoch: 78, Batch: 60, Avg. Loss: 0.025363975018262864\n",
      "Epoch: 78, Batch: 70, Avg. Loss: 0.18602965474128724\n",
      "Epoch: 78, Batch: 80, Avg. Loss: 0.02813762631267309\n",
      "Epoch: 78, Batch: 90, Avg. Loss: 0.021371334418654443\n",
      "Epoch: 78, Batch: 100, Avg. Loss: 0.03295632917433977\n",
      "Epoch: 78, Batch: 110, Avg. Loss: 0.017887656390666962\n",
      "Epoch: 78, Batch: 120, Avg. Loss: 0.028082745149731636\n",
      "Epoch: 78, Batch: 130, Avg. Loss: 0.045074719656258824\n",
      "Epoch: 78, Batch: 140, Avg. Loss: 0.05287298858165741\n",
      "Epoch: 78, Batch: 150, Avg. Loss: 0.022584139741957186\n",
      "Epoch: 78, Batch: 160, Avg. Loss: 0.03260968942195177\n",
      "Epoch: 78, Batch: 170, Avg. Loss: 0.06755251307040452\n",
      "Epoch: 78, Batch: 180, Avg. Loss: 0.021029974054545163\n",
      "Epoch: 78, Batch: 190, Avg. Loss: 0.023536325339227913\n",
      "Epoch: 78, Batch: 200, Avg. Loss: 0.02184330066666007\n",
      "Epoch: 78, Batch: 210, Avg. Loss: 0.018143279198557138\n",
      "Epoch: 78, Batch: 220, Avg. Loss: 0.027571125235408545\n",
      "Epoch: 78, Batch: 230, Avg. Loss: 0.016361260414123537\n",
      "Epoch: 78, Batch: 240, Avg. Loss: 0.02283648494631052\n",
      "Epoch: 78, Batch: 250, Avg. Loss: 0.017666344344615937\n",
      "Epoch: 78, Batch: 260, Avg. Loss: 0.027215534914284946\n",
      "Epoch: 78, Batch: 270, Avg. Loss: 0.020888811256736518\n",
      "Epoch: 78, Batch: 280, Avg. Loss: 0.019766774494200945\n",
      "Epoch: 78, Batch: 290, Avg. Loss: 0.01950828544795513\n",
      "Epoch: 78, Batch: 300, Avg. Loss: 0.016680857725441457\n",
      "Epoch: 78, Batch: 310, Avg. Loss: 0.01906781820580363\n",
      "Epoch: 78, Batch: 320, Avg. Loss: 0.015914708003401758\n",
      "Epoch: 78, Batch: 330, Avg. Loss: 0.02004326144233346\n",
      "Epoch: 78, Batch: 340, Avg. Loss: 0.02902827048674226\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 79, Batch: 10, Avg. Loss: 0.03188759451732039\n",
      "Epoch: 79, Batch: 20, Avg. Loss: 0.017588262911885977\n",
      "Epoch: 79, Batch: 30, Avg. Loss: 0.021344206854701044\n",
      "Epoch: 79, Batch: 40, Avg. Loss: 0.02557309279218316\n",
      "Epoch: 79, Batch: 50, Avg. Loss: 0.016433415468782187\n",
      "Epoch: 79, Batch: 60, Avg. Loss: 0.015948673710227013\n",
      "Epoch: 79, Batch: 70, Avg. Loss: 0.01603588443249464\n",
      "Epoch: 79, Batch: 80, Avg. Loss: 0.028374893963336943\n",
      "Epoch: 79, Batch: 90, Avg. Loss: 0.017628577444702385\n",
      "Epoch: 79, Batch: 100, Avg. Loss: 0.01874813297763467\n",
      "Epoch: 79, Batch: 110, Avg. Loss: 0.020574949216097593\n",
      "Epoch: 79, Batch: 120, Avg. Loss: 0.02341483421623707\n",
      "Epoch: 79, Batch: 130, Avg. Loss: 0.018100933451205493\n",
      "Epoch: 79, Batch: 140, Avg. Loss: 0.016253375355154275\n",
      "Epoch: 79, Batch: 150, Avg. Loss: 0.017105884104967117\n",
      "Epoch: 79, Batch: 160, Avg. Loss: 0.02905794195830822\n",
      "Epoch: 79, Batch: 170, Avg. Loss: 0.054342519212514165\n",
      "Epoch: 79, Batch: 180, Avg. Loss: 0.021547241043299435\n",
      "Epoch: 79, Batch: 190, Avg. Loss: 0.019980525132268667\n",
      "Epoch: 79, Batch: 200, Avg. Loss: 0.019057646859437227\n",
      "Epoch: 79, Batch: 210, Avg. Loss: 0.0156674450263381\n",
      "Epoch: 79, Batch: 220, Avg. Loss: 0.01838502734899521\n",
      "Epoch: 79, Batch: 230, Avg. Loss: 0.32044524820521475\n",
      "Epoch: 79, Batch: 240, Avg. Loss: 0.03208550736308098\n",
      "Epoch: 79, Batch: 250, Avg. Loss: 0.021858165320008994\n",
      "Epoch: 79, Batch: 260, Avg. Loss: 0.0451624576933682\n",
      "Epoch: 79, Batch: 270, Avg. Loss: 0.019739046227186918\n",
      "Epoch: 79, Batch: 280, Avg. Loss: 0.02241149013862014\n",
      "Epoch: 79, Batch: 290, Avg. Loss: 0.021075631957501173\n",
      "Epoch: 79, Batch: 300, Avg. Loss: 0.021532371547073124\n",
      "Epoch: 79, Batch: 310, Avg. Loss: 0.022611433640122414\n",
      "Epoch: 79, Batch: 320, Avg. Loss: 0.032848937530070545\n",
      "Epoch: 79, Batch: 330, Avg. Loss: 0.01974452557042241\n",
      "Epoch: 79, Batch: 340, Avg. Loss: 0.015320181287825108\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 80, Batch: 10, Avg. Loss: 0.019401412270963193\n",
      "Epoch: 80, Batch: 20, Avg. Loss: 0.020806518290191887\n",
      "Epoch: 80, Batch: 30, Avg. Loss: 0.016029070783406495\n",
      "Epoch: 80, Batch: 40, Avg. Loss: 0.02301756227388978\n",
      "Epoch: 80, Batch: 50, Avg. Loss: 0.05430893450975418\n",
      "Epoch: 80, Batch: 60, Avg. Loss: 0.02475960897281766\n",
      "Epoch: 80, Batch: 70, Avg. Loss: 0.11389617854729295\n",
      "Epoch: 80, Batch: 80, Avg. Loss: 0.02275215433910489\n",
      "Epoch: 80, Batch: 90, Avg. Loss: 0.04239201350137591\n",
      "Epoch: 80, Batch: 100, Avg. Loss: 0.025024445541203023\n",
      "Epoch: 80, Batch: 110, Avg. Loss: 0.02115054465830326\n",
      "Epoch: 80, Batch: 120, Avg. Loss: 0.020314845163375138\n",
      "Epoch: 80, Batch: 130, Avg. Loss: 0.021497325040400028\n",
      "Epoch: 80, Batch: 140, Avg. Loss: 0.023459721077233552\n",
      "Epoch: 80, Batch: 150, Avg. Loss: 0.02005707994103432\n",
      "Epoch: 80, Batch: 160, Avg. Loss: 0.026283032540231944\n",
      "Epoch: 80, Batch: 170, Avg. Loss: 0.020447934977710247\n",
      "Epoch: 80, Batch: 180, Avg. Loss: 0.01977012977004051\n",
      "Epoch: 80, Batch: 190, Avg. Loss: 0.020118691306561232\n",
      "Epoch: 80, Batch: 200, Avg. Loss: 0.022510747797787188\n",
      "Epoch: 80, Batch: 210, Avg. Loss: 0.020663511753082276\n",
      "Epoch: 80, Batch: 220, Avg. Loss: 0.020699914265424012\n",
      "Epoch: 80, Batch: 230, Avg. Loss: 0.0173600229434669\n",
      "Epoch: 80, Batch: 240, Avg. Loss: 0.02105792034417391\n",
      "Epoch: 80, Batch: 250, Avg. Loss: 0.016305844578891993\n",
      "Epoch: 80, Batch: 260, Avg. Loss: 0.018549064826220273\n",
      "Epoch: 80, Batch: 270, Avg. Loss: 0.019204525277018547\n",
      "Epoch: 80, Batch: 280, Avg. Loss: 0.0183882400393486\n",
      "Epoch: 80, Batch: 290, Avg. Loss: 0.01865077018737793\n",
      "Epoch: 80, Batch: 300, Avg. Loss: 0.02197965020313859\n",
      "Epoch: 80, Batch: 310, Avg. Loss: 0.02110217437148094\n",
      "Epoch: 80, Batch: 320, Avg. Loss: 0.016225260216742754\n",
      "Epoch: 80, Batch: 330, Avg. Loss: 0.019498317036777735\n",
      "Epoch: 80, Batch: 340, Avg. Loss: 0.09095264188945293\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 81, Batch: 10, Avg. Loss: 0.030145982466638088\n",
      "Epoch: 81, Batch: 20, Avg. Loss: 0.02045602388679981\n",
      "Epoch: 81, Batch: 30, Avg. Loss: 0.0158871497027576\n",
      "Epoch: 81, Batch: 40, Avg. Loss: 0.026536847837269305\n",
      "Epoch: 81, Batch: 50, Avg. Loss: 0.044827227387577294\n",
      "Epoch: 81, Batch: 60, Avg. Loss: 0.03896323414519429\n",
      "Epoch: 81, Batch: 70, Avg. Loss: 0.10413001338019967\n",
      "Epoch: 81, Batch: 80, Avg. Loss: 0.02250440903007984\n",
      "Epoch: 81, Batch: 90, Avg. Loss: 0.031503922492265704\n",
      "Epoch: 81, Batch: 100, Avg. Loss: 0.024217019509524106\n",
      "Epoch: 81, Batch: 110, Avg. Loss: 0.03417577873915434\n",
      "Epoch: 81, Batch: 120, Avg. Loss: 0.021600285172462465\n",
      "Epoch: 81, Batch: 130, Avg. Loss: 0.025306537933647632\n",
      "Epoch: 81, Batch: 140, Avg. Loss: 0.01820845967158675\n",
      "Epoch: 81, Batch: 150, Avg. Loss: 0.019242435321211816\n",
      "Epoch: 81, Batch: 160, Avg. Loss: 0.026988187991082668\n",
      "Epoch: 81, Batch: 170, Avg. Loss: 0.019157077837735414\n",
      "Epoch: 81, Batch: 180, Avg. Loss: 0.023943320754915474\n",
      "Epoch: 81, Batch: 190, Avg. Loss: 0.019443095941096545\n",
      "Epoch: 81, Batch: 200, Avg. Loss: 0.01933999489992857\n",
      "Epoch: 81, Batch: 210, Avg. Loss: 0.019315785821527244\n",
      "Epoch: 81, Batch: 220, Avg. Loss: 0.015657870378345252\n",
      "Epoch: 81, Batch: 230, Avg. Loss: 0.0181587484665215\n",
      "Epoch: 81, Batch: 240, Avg. Loss: 0.028050545323640107\n",
      "Epoch: 81, Batch: 250, Avg. Loss: 0.021120743360370398\n",
      "Epoch: 81, Batch: 260, Avg. Loss: 0.017268726881593466\n",
      "Epoch: 81, Batch: 270, Avg. Loss: 0.022429444827139378\n",
      "Epoch: 81, Batch: 280, Avg. Loss: 0.022909505106508733\n",
      "Epoch: 81, Batch: 290, Avg. Loss: 0.02501431591808796\n",
      "Epoch: 81, Batch: 300, Avg. Loss: 0.01710450267419219\n",
      "Epoch: 81, Batch: 310, Avg. Loss: 0.025250776298344137\n",
      "Epoch: 81, Batch: 320, Avg. Loss: 0.02275463528931141\n",
      "Epoch: 81, Batch: 330, Avg. Loss: 0.021423463243991137\n",
      "Epoch: 81, Batch: 340, Avg. Loss: 0.018833441101014613\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 82, Batch: 10, Avg. Loss: 0.0185424511320889\n",
      "Epoch: 82, Batch: 20, Avg. Loss: 0.018475920893251896\n",
      "Epoch: 82, Batch: 30, Avg. Loss: 0.01802798584103584\n",
      "Epoch: 82, Batch: 40, Avg. Loss: 0.023175307828933\n",
      "Epoch: 82, Batch: 50, Avg. Loss: 0.020651983469724654\n",
      "Epoch: 82, Batch: 60, Avg. Loss: 0.01726894238963723\n",
      "Epoch: 82, Batch: 70, Avg. Loss: 0.02074853554368019\n",
      "Epoch: 82, Batch: 80, Avg. Loss: 0.018333721347153185\n",
      "Epoch: 82, Batch: 90, Avg. Loss: 0.01650436148047447\n",
      "Epoch: 82, Batch: 100, Avg. Loss: 0.018380963802337648\n",
      "Epoch: 82, Batch: 110, Avg. Loss: 0.3555015565827489\n",
      "Epoch: 82, Batch: 120, Avg. Loss: 0.02009398424997926\n",
      "Epoch: 82, Batch: 130, Avg. Loss: 0.026821330655366182\n",
      "Epoch: 82, Batch: 140, Avg. Loss: 0.01671276204288006\n",
      "Epoch: 82, Batch: 150, Avg. Loss: 0.03546082377433777\n",
      "Epoch: 82, Batch: 160, Avg. Loss: 0.02338064033538103\n",
      "Epoch: 82, Batch: 170, Avg. Loss: 0.02160203577950597\n",
      "Epoch: 82, Batch: 180, Avg. Loss: 0.02146248407661915\n",
      "Epoch: 82, Batch: 190, Avg. Loss: 0.022953194845467807\n",
      "Epoch: 82, Batch: 200, Avg. Loss: 0.026581349316984415\n",
      "Epoch: 82, Batch: 210, Avg. Loss: 0.01661021439358592\n",
      "Epoch: 82, Batch: 220, Avg. Loss: 0.037060705572366716\n",
      "Epoch: 82, Batch: 230, Avg. Loss: 0.017225330974906684\n",
      "Epoch: 82, Batch: 240, Avg. Loss: 0.019353093393146992\n",
      "Epoch: 82, Batch: 250, Avg. Loss: 0.022857492230832575\n",
      "Epoch: 82, Batch: 260, Avg. Loss: 0.02310565924271941\n",
      "Epoch: 82, Batch: 270, Avg. Loss: 0.0159346591681242\n",
      "Epoch: 82, Batch: 280, Avg. Loss: 0.036373908072710036\n",
      "Epoch: 82, Batch: 290, Avg. Loss: 0.022576139960438012\n",
      "Epoch: 82, Batch: 300, Avg. Loss: 0.018509280774742363\n",
      "Epoch: 82, Batch: 310, Avg. Loss: 0.019886844884604217\n",
      "Epoch: 82, Batch: 320, Avg. Loss: 0.015174201596528292\n",
      "Epoch: 82, Batch: 330, Avg. Loss: 0.017812115140259266\n",
      "Epoch: 82, Batch: 340, Avg. Loss: 0.016449415870010854\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 83, Batch: 10, Avg. Loss: 0.01867529796436429\n",
      "Epoch: 83, Batch: 20, Avg. Loss: 0.019547358993440865\n",
      "Epoch: 83, Batch: 30, Avg. Loss: 0.019518320355564354\n",
      "Epoch: 83, Batch: 40, Avg. Loss: 0.018098268751055004\n",
      "Epoch: 83, Batch: 50, Avg. Loss: 0.01935122665017843\n",
      "Epoch: 83, Batch: 60, Avg. Loss: 0.01459873728454113\n",
      "Epoch: 83, Batch: 70, Avg. Loss: 0.01795944683253765\n",
      "Epoch: 83, Batch: 80, Avg. Loss: 0.02736341431736946\n",
      "Epoch: 83, Batch: 90, Avg. Loss: 0.015449446346610784\n",
      "Epoch: 83, Batch: 100, Avg. Loss: 0.016586754657328128\n",
      "Epoch: 83, Batch: 110, Avg. Loss: 0.015227232035249472\n",
      "Epoch: 83, Batch: 120, Avg. Loss: 0.05826975964009762\n",
      "Epoch: 83, Batch: 130, Avg. Loss: 0.01932456074282527\n",
      "Epoch: 83, Batch: 140, Avg. Loss: 0.018766557890921833\n",
      "Epoch: 83, Batch: 150, Avg. Loss: 0.020970648713409902\n",
      "Epoch: 83, Batch: 160, Avg. Loss: 0.019937399215996264\n",
      "Epoch: 83, Batch: 170, Avg. Loss: 0.022584394179284574\n",
      "Epoch: 83, Batch: 180, Avg. Loss: 0.01786771137267351\n",
      "Epoch: 83, Batch: 190, Avg. Loss: 0.018580164946615695\n",
      "Epoch: 83, Batch: 200, Avg. Loss: 0.01419659461826086\n",
      "Epoch: 83, Batch: 210, Avg. Loss: 0.017381137982010842\n",
      "Epoch: 83, Batch: 220, Avg. Loss: 0.016596297919750213\n",
      "Epoch: 83, Batch: 230, Avg. Loss: 0.015008671395480632\n",
      "Epoch: 83, Batch: 240, Avg. Loss: 0.02539835628122091\n",
      "Epoch: 83, Batch: 250, Avg. Loss: 0.15208626063540578\n",
      "Epoch: 83, Batch: 260, Avg. Loss: 0.022293701488524675\n",
      "Epoch: 83, Batch: 270, Avg. Loss: 0.017727059219032525\n",
      "Epoch: 83, Batch: 280, Avg. Loss: 0.015442762523889542\n",
      "Epoch: 83, Batch: 290, Avg. Loss: 0.01687591979280114\n",
      "Epoch: 83, Batch: 300, Avg. Loss: 0.02054139943793416\n",
      "Epoch: 83, Batch: 310, Avg. Loss: 0.023854951746761797\n",
      "Epoch: 83, Batch: 320, Avg. Loss: 0.017804610542953014\n",
      "Epoch: 83, Batch: 330, Avg. Loss: 0.01919021997600794\n",
      "Epoch: 83, Batch: 340, Avg. Loss: 0.016879467479884624\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 84, Batch: 10, Avg. Loss: 0.01668280754238367\n",
      "Epoch: 84, Batch: 20, Avg. Loss: 0.01646878821775317\n",
      "Epoch: 84, Batch: 30, Avg. Loss: 0.020784400030970575\n",
      "Epoch: 84, Batch: 40, Avg. Loss: 0.016924331057816745\n",
      "Epoch: 84, Batch: 50, Avg. Loss: 0.030102543905377387\n",
      "Epoch: 84, Batch: 60, Avg. Loss: 0.07192540122196078\n",
      "Epoch: 84, Batch: 70, Avg. Loss: 0.028646718058735133\n",
      "Epoch: 84, Batch: 80, Avg. Loss: 0.15320003535598517\n",
      "Epoch: 84, Batch: 90, Avg. Loss: 0.02152812359854579\n",
      "Epoch: 84, Batch: 100, Avg. Loss: 0.06775116380304098\n",
      "Epoch: 84, Batch: 110, Avg. Loss: 0.02491107378154993\n",
      "Epoch: 84, Batch: 120, Avg. Loss: 0.02265835339203477\n",
      "Epoch: 84, Batch: 130, Avg. Loss: 0.01943726819008589\n",
      "Epoch: 84, Batch: 140, Avg. Loss: 0.018123747780919075\n",
      "Epoch: 84, Batch: 150, Avg. Loss: 0.017889664880931376\n",
      "Epoch: 84, Batch: 160, Avg. Loss: 0.027959430404007436\n",
      "Epoch: 84, Batch: 170, Avg. Loss: 0.028316224087029697\n",
      "Epoch: 84, Batch: 180, Avg. Loss: 0.01827337993308902\n",
      "Epoch: 84, Batch: 190, Avg. Loss: 0.01975690368562937\n",
      "Epoch: 84, Batch: 200, Avg. Loss: 0.02162476386874914\n",
      "Epoch: 84, Batch: 210, Avg. Loss: 0.014706059545278549\n",
      "Epoch: 84, Batch: 220, Avg. Loss: 0.013359212130308152\n",
      "Epoch: 84, Batch: 230, Avg. Loss: 0.03191101057454944\n",
      "Epoch: 84, Batch: 240, Avg. Loss: 0.019782722648233175\n",
      "Epoch: 84, Batch: 250, Avg. Loss: 0.014822429604828357\n",
      "Epoch: 84, Batch: 260, Avg. Loss: 0.016804894711822272\n",
      "Epoch: 84, Batch: 270, Avg. Loss: 0.01631654743105173\n",
      "Epoch: 84, Batch: 280, Avg. Loss: 0.018751175422221423\n",
      "Epoch: 84, Batch: 290, Avg. Loss: 0.019602949358522893\n",
      "Epoch: 84, Batch: 300, Avg. Loss: 0.01645810282789171\n",
      "Epoch: 84, Batch: 310, Avg. Loss: 0.0189907374791801\n",
      "Epoch: 84, Batch: 320, Avg. Loss: 0.030328911356627943\n",
      "Epoch: 84, Batch: 330, Avg. Loss: 0.016858438961207867\n",
      "Epoch: 84, Batch: 340, Avg. Loss: 0.017004915047436953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 85, Batch: 10, Avg. Loss: 0.022163716331124305\n",
      "Epoch: 85, Batch: 20, Avg. Loss: 0.017319704871624708\n",
      "Epoch: 85, Batch: 30, Avg. Loss: 0.018923540506511925\n",
      "Epoch: 85, Batch: 40, Avg. Loss: 0.01877212282270193\n",
      "Epoch: 85, Batch: 50, Avg. Loss: 0.017153792642056943\n",
      "Epoch: 85, Batch: 60, Avg. Loss: 0.020701259654015303\n",
      "Epoch: 85, Batch: 70, Avg. Loss: 0.02189794573932886\n",
      "Epoch: 85, Batch: 80, Avg. Loss: 0.020418025273829698\n",
      "Epoch: 85, Batch: 90, Avg. Loss: 0.020404226798564195\n",
      "Epoch: 85, Batch: 100, Avg. Loss: 0.0322983562014997\n",
      "Epoch: 85, Batch: 110, Avg. Loss: 0.017130481824278832\n",
      "Epoch: 85, Batch: 120, Avg. Loss: 0.01789578553289175\n",
      "Epoch: 85, Batch: 130, Avg. Loss: 0.017910064943134785\n",
      "Epoch: 85, Batch: 140, Avg. Loss: 0.03195074182003736\n",
      "Epoch: 85, Batch: 150, Avg. Loss: 0.018114792089909314\n",
      "Epoch: 85, Batch: 160, Avg. Loss: 0.029951214045286178\n",
      "Epoch: 85, Batch: 170, Avg. Loss: 0.025725346896797417\n",
      "Epoch: 85, Batch: 180, Avg. Loss: 0.020766621362417935\n",
      "Epoch: 85, Batch: 190, Avg. Loss: 0.018871499877423047\n",
      "Epoch: 85, Batch: 200, Avg. Loss: 0.01842330852523446\n",
      "Epoch: 85, Batch: 210, Avg. Loss: 0.024845563620328904\n",
      "Epoch: 85, Batch: 220, Avg. Loss: 0.020315145328640937\n",
      "Epoch: 85, Batch: 230, Avg. Loss: 0.018697499111294747\n",
      "Epoch: 85, Batch: 240, Avg. Loss: 0.017932808306068183\n",
      "Epoch: 85, Batch: 250, Avg. Loss: 0.019741044752299784\n",
      "Epoch: 85, Batch: 260, Avg. Loss: 0.015873301913961767\n",
      "Epoch: 85, Batch: 270, Avg. Loss: 0.017986845690757036\n",
      "Epoch: 85, Batch: 280, Avg. Loss: 0.016594628151506186\n",
      "Epoch: 85, Batch: 290, Avg. Loss: 0.017635385133326055\n",
      "Epoch: 85, Batch: 300, Avg. Loss: 0.01893042754381895\n",
      "Epoch: 85, Batch: 310, Avg. Loss: 0.020729182939976453\n",
      "Epoch: 85, Batch: 320, Avg. Loss: 0.018180780950933693\n",
      "Epoch: 85, Batch: 330, Avg. Loss: 0.01798458332195878\n",
      "Epoch: 85, Batch: 340, Avg. Loss: 0.015606595575809479\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 86, Batch: 10, Avg. Loss: 0.017212536092847584\n",
      "Epoch: 86, Batch: 20, Avg. Loss: 0.018475363217294215\n",
      "Epoch: 86, Batch: 30, Avg. Loss: 0.020231729466468097\n",
      "Epoch: 86, Batch: 40, Avg. Loss: 0.018619841150939464\n",
      "Epoch: 86, Batch: 50, Avg. Loss: 0.03067728653550148\n",
      "Epoch: 86, Batch: 60, Avg. Loss: 0.017003412917256357\n",
      "Epoch: 86, Batch: 70, Avg. Loss: 0.019316029362380506\n",
      "Epoch: 86, Batch: 80, Avg. Loss: 0.015920854266732933\n",
      "Epoch: 86, Batch: 90, Avg. Loss: 0.019875145703554153\n",
      "Epoch: 86, Batch: 100, Avg. Loss: 0.01304660178720951\n",
      "Epoch: 86, Batch: 110, Avg. Loss: 0.016778968274593353\n",
      "Epoch: 86, Batch: 120, Avg. Loss: 0.014706903230398893\n",
      "Epoch: 86, Batch: 130, Avg. Loss: 0.01534159928560257\n",
      "Epoch: 86, Batch: 140, Avg. Loss: 0.015600421652197837\n",
      "Epoch: 86, Batch: 150, Avg. Loss: 0.01576096937060356\n",
      "Epoch: 86, Batch: 160, Avg. Loss: 0.015676910988986492\n",
      "Epoch: 86, Batch: 170, Avg. Loss: 0.014877897780388593\n",
      "Epoch: 86, Batch: 180, Avg. Loss: 0.01645235288888216\n",
      "Epoch: 86, Batch: 190, Avg. Loss: 0.015240467991679907\n",
      "Epoch: 86, Batch: 200, Avg. Loss: 0.018410270009189843\n",
      "Epoch: 86, Batch: 210, Avg. Loss: 0.030850339215248823\n",
      "Epoch: 86, Batch: 220, Avg. Loss: 0.035094691626727584\n",
      "Epoch: 86, Batch: 230, Avg. Loss: 0.01770748561248183\n",
      "Epoch: 86, Batch: 240, Avg. Loss: 0.02085472522303462\n",
      "Epoch: 86, Batch: 250, Avg. Loss: 0.019032871630042792\n",
      "Epoch: 86, Batch: 260, Avg. Loss: 0.014449229929596186\n",
      "Epoch: 86, Batch: 270, Avg. Loss: 0.01717320652678609\n",
      "Epoch: 86, Batch: 280, Avg. Loss: 0.015684487018734216\n",
      "Epoch: 86, Batch: 290, Avg. Loss: 0.017017021775245667\n",
      "Epoch: 86, Batch: 300, Avg. Loss: 0.05828391648828983\n",
      "Epoch: 86, Batch: 310, Avg. Loss: 0.018593287188559772\n",
      "Epoch: 86, Batch: 320, Avg. Loss: 0.018464011233299972\n",
      "Epoch: 86, Batch: 330, Avg. Loss: 0.02034641718491912\n",
      "Epoch: 86, Batch: 340, Avg. Loss: 0.040482177212834355\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 87, Batch: 10, Avg. Loss: 0.016091464273631572\n",
      "Epoch: 87, Batch: 20, Avg. Loss: 0.015909382700920106\n",
      "Epoch: 87, Batch: 30, Avg. Loss: 0.01887353276833892\n",
      "Epoch: 87, Batch: 40, Avg. Loss: 0.021037794928997756\n",
      "Epoch: 87, Batch: 50, Avg. Loss: 0.018344055395573378\n",
      "Epoch: 87, Batch: 60, Avg. Loss: 0.019683268573135137\n",
      "Epoch: 87, Batch: 70, Avg. Loss: 0.016624236945062876\n",
      "Epoch: 87, Batch: 80, Avg. Loss: 0.020553207211196422\n",
      "Epoch: 87, Batch: 90, Avg. Loss: 0.018869361095130443\n",
      "Epoch: 87, Batch: 100, Avg. Loss: 0.06313737472519279\n",
      "Epoch: 87, Batch: 110, Avg. Loss: 0.022529290243983268\n",
      "Epoch: 87, Batch: 120, Avg. Loss: 0.01888558464124799\n",
      "Epoch: 87, Batch: 130, Avg. Loss: 0.02474472289904952\n",
      "Epoch: 87, Batch: 140, Avg. Loss: 0.017439126782119275\n",
      "Epoch: 87, Batch: 150, Avg. Loss: 0.01830178443342447\n",
      "Epoch: 87, Batch: 160, Avg. Loss: 0.018362219911068678\n",
      "Epoch: 87, Batch: 170, Avg. Loss: 0.021909088455140592\n",
      "Epoch: 87, Batch: 180, Avg. Loss: 0.02105268044397235\n",
      "Epoch: 87, Batch: 190, Avg. Loss: 0.020663596503436566\n",
      "Epoch: 87, Batch: 200, Avg. Loss: 0.017061631381511688\n",
      "Epoch: 87, Batch: 210, Avg. Loss: 0.018776214495301247\n",
      "Epoch: 87, Batch: 220, Avg. Loss: 0.027956783771514893\n",
      "Epoch: 87, Batch: 230, Avg. Loss: 0.020492294058203697\n",
      "Epoch: 87, Batch: 240, Avg. Loss: 0.01647645905613899\n",
      "Epoch: 87, Batch: 250, Avg. Loss: 0.0437754743732512\n",
      "Epoch: 87, Batch: 260, Avg. Loss: 0.02720138933509588\n",
      "Epoch: 87, Batch: 270, Avg. Loss: 0.018626915663480757\n",
      "Epoch: 87, Batch: 280, Avg. Loss: 0.018422080762684347\n",
      "Epoch: 87, Batch: 290, Avg. Loss: 0.018016861844807865\n",
      "Epoch: 87, Batch: 300, Avg. Loss: 0.022850112337619067\n",
      "Epoch: 87, Batch: 310, Avg. Loss: 0.02205681465566158\n",
      "Epoch: 87, Batch: 320, Avg. Loss: 0.018222212605178357\n",
      "Epoch: 87, Batch: 330, Avg. Loss: 0.019881487637758256\n",
      "Epoch: 87, Batch: 340, Avg. Loss: 0.018643561098724604\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 88, Batch: 10, Avg. Loss: 0.016404022928327322\n",
      "Epoch: 88, Batch: 20, Avg. Loss: 0.018061088025569917\n",
      "Epoch: 88, Batch: 30, Avg. Loss: 0.01941924262791872\n",
      "Epoch: 88, Batch: 40, Avg. Loss: 0.018199679721146823\n",
      "Epoch: 88, Batch: 50, Avg. Loss: 0.013647411298006774\n",
      "Epoch: 88, Batch: 60, Avg. Loss: 0.020678251516073942\n",
      "Epoch: 88, Batch: 70, Avg. Loss: 0.015385430492460727\n",
      "Epoch: 88, Batch: 80, Avg. Loss: 0.026864200178533793\n",
      "Epoch: 88, Batch: 90, Avg. Loss: 0.02007783930748701\n",
      "Epoch: 88, Batch: 100, Avg. Loss: 0.017648442182689905\n",
      "Epoch: 88, Batch: 110, Avg. Loss: 0.019062304776161908\n",
      "Epoch: 88, Batch: 120, Avg. Loss: 0.022991854790598155\n",
      "Epoch: 88, Batch: 130, Avg. Loss: 0.01713451128453016\n",
      "Epoch: 88, Batch: 140, Avg. Loss: 0.020800131279975174\n",
      "Epoch: 88, Batch: 150, Avg. Loss: 0.018753109127283098\n",
      "Epoch: 88, Batch: 160, Avg. Loss: 0.01892082430422306\n",
      "Epoch: 88, Batch: 170, Avg. Loss: 0.21309762485325337\n",
      "Epoch: 88, Batch: 180, Avg. Loss: 0.018511748407036066\n",
      "Epoch: 88, Batch: 190, Avg. Loss: 0.02623502807691693\n",
      "Epoch: 88, Batch: 200, Avg. Loss: 0.022186302673071624\n",
      "Epoch: 88, Batch: 210, Avg. Loss: 0.01699210926890373\n",
      "Epoch: 88, Batch: 220, Avg. Loss: 0.029932025447487833\n",
      "Epoch: 88, Batch: 230, Avg. Loss: 0.01563640860840678\n",
      "Epoch: 88, Batch: 240, Avg. Loss: 0.01925690397620201\n",
      "Epoch: 88, Batch: 250, Avg. Loss: 0.015521654486656189\n",
      "Epoch: 88, Batch: 260, Avg. Loss: 0.020945574808865785\n",
      "Epoch: 88, Batch: 270, Avg. Loss: 0.017112951260060072\n",
      "Epoch: 88, Batch: 280, Avg. Loss: 0.01595046976581216\n",
      "Epoch: 88, Batch: 290, Avg. Loss: 0.014895454328507186\n",
      "Epoch: 88, Batch: 300, Avg. Loss: 0.018157466500997543\n",
      "Epoch: 88, Batch: 310, Avg. Loss: 0.017540667578577994\n",
      "Epoch: 88, Batch: 320, Avg. Loss: 0.02521831914782524\n",
      "Epoch: 88, Batch: 330, Avg. Loss: 0.015368126332759857\n",
      "Epoch: 88, Batch: 340, Avg. Loss: 0.01969690276309848\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 89, Batch: 10, Avg. Loss: 0.016631996165961026\n",
      "Epoch: 89, Batch: 20, Avg. Loss: 0.01573221068829298\n",
      "Epoch: 89, Batch: 30, Avg. Loss: 0.022138214856386184\n",
      "Epoch: 89, Batch: 40, Avg. Loss: 0.02407079329714179\n",
      "Epoch: 89, Batch: 50, Avg. Loss: 0.020500248670578\n",
      "Epoch: 89, Batch: 60, Avg. Loss: 0.01832736423239112\n",
      "Epoch: 89, Batch: 70, Avg. Loss: 0.014429683610796929\n",
      "Epoch: 89, Batch: 80, Avg. Loss: 0.017730283830314875\n",
      "Epoch: 89, Batch: 90, Avg. Loss: 0.014113658480346203\n",
      "Epoch: 89, Batch: 100, Avg. Loss: 0.015672456473112106\n",
      "Epoch: 89, Batch: 110, Avg. Loss: 0.032171745970845225\n",
      "Epoch: 89, Batch: 120, Avg. Loss: 0.01831272626295686\n",
      "Epoch: 89, Batch: 130, Avg. Loss: 0.022410063538700342\n",
      "Epoch: 89, Batch: 140, Avg. Loss: 0.023669546842575072\n",
      "Epoch: 89, Batch: 150, Avg. Loss: 0.018758646119385956\n",
      "Epoch: 89, Batch: 160, Avg. Loss: 0.017574031092226505\n",
      "Epoch: 89, Batch: 170, Avg. Loss: 0.018296860437840224\n",
      "Epoch: 89, Batch: 180, Avg. Loss: 0.12055025780573488\n",
      "Epoch: 89, Batch: 190, Avg. Loss: 0.01507038800045848\n",
      "Epoch: 89, Batch: 200, Avg. Loss: 0.018612158391624688\n",
      "Epoch: 89, Batch: 210, Avg. Loss: 0.026096566766500472\n",
      "Epoch: 89, Batch: 220, Avg. Loss: 0.02691182689741254\n",
      "Epoch: 89, Batch: 230, Avg. Loss: 0.022427226789295672\n",
      "Epoch: 89, Batch: 240, Avg. Loss: 0.021607282292097806\n",
      "Epoch: 89, Batch: 250, Avg. Loss: 0.02282405784353614\n",
      "Epoch: 89, Batch: 260, Avg. Loss: 0.022285931371152402\n",
      "Epoch: 89, Batch: 270, Avg. Loss: 0.021077178604900836\n",
      "Epoch: 89, Batch: 280, Avg. Loss: 0.01775604821741581\n",
      "Epoch: 89, Batch: 290, Avg. Loss: 0.04681585859507322\n",
      "Epoch: 89, Batch: 300, Avg. Loss: 0.02678381046280265\n",
      "Epoch: 89, Batch: 310, Avg. Loss: 0.022178271040320396\n",
      "Epoch: 89, Batch: 320, Avg. Loss: 0.022782016452401875\n",
      "Epoch: 89, Batch: 330, Avg. Loss: 0.05914994888007641\n",
      "Epoch: 89, Batch: 340, Avg. Loss: 0.02348844353109598\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 90, Batch: 10, Avg. Loss: 0.07168497713282704\n",
      "Epoch: 90, Batch: 20, Avg. Loss: 0.035431779082864524\n",
      "Epoch: 90, Batch: 30, Avg. Loss: 0.02665354935452342\n",
      "Epoch: 90, Batch: 40, Avg. Loss: 0.023143775388598443\n",
      "Epoch: 90, Batch: 50, Avg. Loss: 0.01825832100585103\n",
      "Epoch: 90, Batch: 60, Avg. Loss: 0.027140100859105586\n",
      "Epoch: 90, Batch: 70, Avg. Loss: 0.027205068711191417\n",
      "Epoch: 90, Batch: 80, Avg. Loss: 0.04585477346554399\n",
      "Epoch: 90, Batch: 90, Avg. Loss: 0.01695393556728959\n",
      "Epoch: 90, Batch: 100, Avg. Loss: 0.018437094520777464\n",
      "Epoch: 90, Batch: 110, Avg. Loss: 0.02509133508428931\n",
      "Epoch: 90, Batch: 120, Avg. Loss: 0.02254762714728713\n",
      "Epoch: 90, Batch: 130, Avg. Loss: 0.021762351039797068\n",
      "Epoch: 90, Batch: 140, Avg. Loss: 0.01991167850792408\n",
      "Epoch: 90, Batch: 150, Avg. Loss: 0.016432936303317547\n",
      "Epoch: 90, Batch: 160, Avg. Loss: 0.02345720576122403\n",
      "Epoch: 90, Batch: 170, Avg. Loss: 0.015491790510714054\n",
      "Epoch: 90, Batch: 180, Avg. Loss: 0.018416740000247955\n",
      "Epoch: 90, Batch: 190, Avg. Loss: 0.023653242085129023\n",
      "Epoch: 90, Batch: 200, Avg. Loss: 0.018299376405775548\n",
      "Epoch: 90, Batch: 210, Avg. Loss: 0.018670959491282703\n",
      "Epoch: 90, Batch: 220, Avg. Loss: 0.022425920236855745\n",
      "Epoch: 90, Batch: 230, Avg. Loss: 0.02442499790340662\n",
      "Epoch: 90, Batch: 240, Avg. Loss: 0.02063364805653691\n",
      "Epoch: 90, Batch: 250, Avg. Loss: 0.0181240564212203\n",
      "Epoch: 90, Batch: 260, Avg. Loss: 0.016635101567953826\n",
      "Epoch: 90, Batch: 270, Avg. Loss: 0.019088266976177694\n",
      "Epoch: 90, Batch: 280, Avg. Loss: 0.015252844709903002\n",
      "Epoch: 90, Batch: 290, Avg. Loss: 0.019350715819746254\n",
      "Epoch: 90, Batch: 300, Avg. Loss: 0.013702076487243175\n",
      "Epoch: 90, Batch: 310, Avg. Loss: 0.05129724498838186\n",
      "Epoch: 90, Batch: 320, Avg. Loss: 0.020436115562915802\n",
      "Epoch: 90, Batch: 330, Avg. Loss: 0.016313237976282834\n",
      "Epoch: 90, Batch: 340, Avg. Loss: 0.017599598783999682\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 91, Batch: 10, Avg. Loss: 0.020040340535342694\n",
      "Epoch: 91, Batch: 20, Avg. Loss: 0.025825231987982988\n",
      "Epoch: 91, Batch: 30, Avg. Loss: 0.014297714270651341\n",
      "Epoch: 91, Batch: 40, Avg. Loss: 0.016117878071963788\n",
      "Epoch: 91, Batch: 50, Avg. Loss: 0.017131580505520105\n",
      "Epoch: 91, Batch: 60, Avg. Loss: 0.016287575103342534\n",
      "Epoch: 91, Batch: 70, Avg. Loss: 0.02221892811357975\n",
      "Epoch: 91, Batch: 80, Avg. Loss: 0.01878614965826273\n",
      "Epoch: 91, Batch: 90, Avg. Loss: 0.016173498705029488\n",
      "Epoch: 91, Batch: 100, Avg. Loss: 0.0190951282158494\n",
      "Epoch: 91, Batch: 110, Avg. Loss: 0.019312955159693956\n",
      "Epoch: 91, Batch: 120, Avg. Loss: 0.025009648501873018\n",
      "Epoch: 91, Batch: 130, Avg. Loss: 0.016273848805576564\n",
      "Epoch: 91, Batch: 140, Avg. Loss: 0.019409010745584966\n",
      "Epoch: 91, Batch: 150, Avg. Loss: 0.03951185029000044\n",
      "Epoch: 91, Batch: 160, Avg. Loss: 0.020727175381034614\n",
      "Epoch: 91, Batch: 170, Avg. Loss: 0.01690217088907957\n",
      "Epoch: 91, Batch: 180, Avg. Loss: 0.024513760302215814\n",
      "Epoch: 91, Batch: 190, Avg. Loss: 0.027972775418311356\n",
      "Epoch: 91, Batch: 200, Avg. Loss: 0.01552535556256771\n",
      "Epoch: 91, Batch: 210, Avg. Loss: 0.03569047041237354\n",
      "Epoch: 91, Batch: 220, Avg. Loss: 0.017167885974049567\n",
      "Epoch: 91, Batch: 230, Avg. Loss: 0.05768717918545008\n",
      "Epoch: 91, Batch: 240, Avg. Loss: 0.032247597072273496\n",
      "Epoch: 91, Batch: 250, Avg. Loss: 0.021648065838962793\n",
      "Epoch: 91, Batch: 260, Avg. Loss: 0.01955213863402605\n",
      "Epoch: 91, Batch: 270, Avg. Loss: 0.02349126236513257\n",
      "Epoch: 91, Batch: 280, Avg. Loss: 0.019654039572924376\n",
      "Epoch: 91, Batch: 290, Avg. Loss: 0.020923677645623685\n",
      "Epoch: 91, Batch: 300, Avg. Loss: 0.017674786597490312\n",
      "Epoch: 91, Batch: 310, Avg. Loss: 0.01665008580312133\n",
      "Epoch: 91, Batch: 320, Avg. Loss: 0.016414498444646597\n",
      "Epoch: 91, Batch: 330, Avg. Loss: 0.01871454417705536\n",
      "Epoch: 91, Batch: 340, Avg. Loss: 0.014853452518582343\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 92, Batch: 10, Avg. Loss: 0.032478921487927435\n",
      "Epoch: 92, Batch: 20, Avg. Loss: 0.01736719012260437\n",
      "Epoch: 92, Batch: 30, Avg. Loss: 0.018490717839449645\n",
      "Epoch: 92, Batch: 40, Avg. Loss: 0.01641042809933424\n",
      "Epoch: 92, Batch: 50, Avg. Loss: 0.017220662254840136\n",
      "Epoch: 92, Batch: 60, Avg. Loss: 0.018575264886021615\n",
      "Epoch: 92, Batch: 70, Avg. Loss: 0.014574287645518779\n",
      "Epoch: 92, Batch: 80, Avg. Loss: 0.013235218822956085\n",
      "Epoch: 92, Batch: 90, Avg. Loss: 0.01844127392396331\n",
      "Epoch: 92, Batch: 100, Avg. Loss: 0.016993781831115485\n",
      "Epoch: 92, Batch: 110, Avg. Loss: 0.015332050528377295\n",
      "Epoch: 92, Batch: 120, Avg. Loss: 0.01471694391220808\n",
      "Epoch: 92, Batch: 130, Avg. Loss: 0.017058484442532062\n",
      "Epoch: 92, Batch: 140, Avg. Loss: 0.016928316093981266\n",
      "Epoch: 92, Batch: 150, Avg. Loss: 0.04209602875635028\n",
      "Epoch: 92, Batch: 160, Avg. Loss: 0.016119597107172014\n",
      "Epoch: 92, Batch: 170, Avg. Loss: 0.014903058297932148\n",
      "Epoch: 92, Batch: 180, Avg. Loss: 0.015983100421726702\n",
      "Epoch: 92, Batch: 190, Avg. Loss: 0.014993888419121503\n",
      "Epoch: 92, Batch: 200, Avg. Loss: 0.017185700964182614\n",
      "Epoch: 92, Batch: 210, Avg. Loss: 0.039907736517488954\n",
      "Epoch: 92, Batch: 220, Avg. Loss: 0.018687404040247203\n",
      "Epoch: 92, Batch: 230, Avg. Loss: 0.016140250489115715\n",
      "Epoch: 92, Batch: 240, Avg. Loss: 0.022282480727881193\n",
      "Epoch: 92, Batch: 250, Avg. Loss: 0.022370254900306464\n",
      "Epoch: 92, Batch: 260, Avg. Loss: 0.01850055167451501\n",
      "Epoch: 92, Batch: 270, Avg. Loss: 0.017851446475833654\n",
      "Epoch: 92, Batch: 280, Avg. Loss: 0.03345152270048857\n",
      "Epoch: 92, Batch: 290, Avg. Loss: 0.018047799915075304\n",
      "Epoch: 92, Batch: 300, Avg. Loss: 0.020443354733288288\n",
      "Epoch: 92, Batch: 310, Avg. Loss: 0.015997125674039124\n",
      "Epoch: 92, Batch: 320, Avg. Loss: 0.018285331223160027\n",
      "Epoch: 92, Batch: 330, Avg. Loss: 0.017156205791980027\n",
      "Epoch: 92, Batch: 340, Avg. Loss: 0.02116341916844249\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 93, Batch: 10, Avg. Loss: 0.01871894337236881\n",
      "Epoch: 93, Batch: 20, Avg. Loss: 0.06547452891245484\n",
      "Epoch: 93, Batch: 30, Avg. Loss: 0.01570391273126006\n",
      "Epoch: 93, Batch: 40, Avg. Loss: 0.0164543978869915\n",
      "Epoch: 93, Batch: 50, Avg. Loss: 0.027771807555109263\n",
      "Epoch: 93, Batch: 60, Avg. Loss: 0.037080561742186546\n",
      "Epoch: 93, Batch: 70, Avg. Loss: 0.021752035431563854\n",
      "Epoch: 93, Batch: 80, Avg. Loss: 0.015766187850385905\n",
      "Epoch: 93, Batch: 90, Avg. Loss: 0.018000007886439563\n",
      "Epoch: 93, Batch: 100, Avg. Loss: 0.01685716789215803\n",
      "Epoch: 93, Batch: 110, Avg. Loss: 0.021829969342797996\n",
      "Epoch: 93, Batch: 120, Avg. Loss: 0.01994930859655142\n",
      "Epoch: 93, Batch: 130, Avg. Loss: 0.032140737492591144\n",
      "Epoch: 93, Batch: 140, Avg. Loss: 0.019300776347517968\n",
      "Epoch: 93, Batch: 150, Avg. Loss: 0.015422871056944131\n",
      "Epoch: 93, Batch: 160, Avg. Loss: 0.01945744464173913\n",
      "Epoch: 93, Batch: 170, Avg. Loss: 0.02153113866224885\n",
      "Epoch: 93, Batch: 180, Avg. Loss: 0.016455861926078796\n",
      "Epoch: 93, Batch: 190, Avg. Loss: 0.032139820978045464\n",
      "Epoch: 93, Batch: 200, Avg. Loss: 0.014868254400789737\n",
      "Epoch: 93, Batch: 210, Avg. Loss: 0.014777266047894954\n",
      "Epoch: 93, Batch: 220, Avg. Loss: 0.021245852578431368\n",
      "Epoch: 93, Batch: 230, Avg. Loss: 0.06108076795935631\n",
      "Epoch: 93, Batch: 240, Avg. Loss: 0.02895513018593192\n",
      "Epoch: 93, Batch: 250, Avg. Loss: 0.021468035597354173\n",
      "Epoch: 93, Batch: 260, Avg. Loss: 0.020600274484604598\n",
      "Epoch: 93, Batch: 270, Avg. Loss: 0.024551018606871367\n",
      "Epoch: 93, Batch: 280, Avg. Loss: 0.024090972356498243\n",
      "Epoch: 93, Batch: 290, Avg. Loss: 0.020156198367476463\n",
      "Epoch: 93, Batch: 300, Avg. Loss: 0.01741801779717207\n",
      "Epoch: 93, Batch: 310, Avg. Loss: 0.029071795847266914\n",
      "Epoch: 93, Batch: 320, Avg. Loss: 0.02821400798857212\n",
      "Epoch: 93, Batch: 330, Avg. Loss: 0.020848488621413707\n",
      "Epoch: 93, Batch: 340, Avg. Loss: 0.02349742166697979\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 94, Batch: 10, Avg. Loss: 0.015559854358434677\n",
      "Epoch: 94, Batch: 20, Avg. Loss: 0.022794834244996308\n",
      "Epoch: 94, Batch: 30, Avg. Loss: 0.015149948932230473\n",
      "Epoch: 94, Batch: 40, Avg. Loss: 0.016422666050493716\n",
      "Epoch: 94, Batch: 50, Avg. Loss: 0.021642725542187692\n",
      "Epoch: 94, Batch: 60, Avg. Loss: 0.016396228037774564\n",
      "Epoch: 94, Batch: 70, Avg. Loss: 0.018265154864639043\n",
      "Epoch: 94, Batch: 80, Avg. Loss: 0.020183889381587505\n",
      "Epoch: 94, Batch: 90, Avg. Loss: 0.016184115689247845\n",
      "Epoch: 94, Batch: 100, Avg. Loss: 0.016784155368804933\n",
      "Epoch: 94, Batch: 110, Avg. Loss: 0.017452463507652283\n",
      "Epoch: 94, Batch: 120, Avg. Loss: 0.025887966435402632\n",
      "Epoch: 94, Batch: 130, Avg. Loss: 0.014867173600941896\n",
      "Epoch: 94, Batch: 140, Avg. Loss: 0.014553297869861126\n",
      "Epoch: 94, Batch: 150, Avg. Loss: 0.01961540272459388\n",
      "Epoch: 94, Batch: 160, Avg. Loss: 0.016677441634237768\n",
      "Epoch: 94, Batch: 170, Avg. Loss: 0.023316506203263997\n",
      "Epoch: 94, Batch: 180, Avg. Loss: 0.01950745228677988\n",
      "Epoch: 94, Batch: 190, Avg. Loss: 0.013839950226247311\n",
      "Epoch: 94, Batch: 200, Avg. Loss: 0.13040905250236393\n",
      "Epoch: 94, Batch: 210, Avg. Loss: 0.01892218105494976\n",
      "Epoch: 94, Batch: 220, Avg. Loss: 0.06460081483237445\n",
      "Epoch: 94, Batch: 230, Avg. Loss: 0.02382381297647953\n",
      "Epoch: 94, Batch: 240, Avg. Loss: 0.06532099414616824\n",
      "Epoch: 94, Batch: 250, Avg. Loss: 0.024120079819113016\n",
      "Epoch: 94, Batch: 260, Avg. Loss: 0.04612553184852004\n",
      "Epoch: 94, Batch: 270, Avg. Loss: 0.025414001382887363\n",
      "Epoch: 94, Batch: 280, Avg. Loss: 0.02268732450902462\n",
      "Epoch: 94, Batch: 290, Avg. Loss: 0.024580742046236993\n",
      "Epoch: 94, Batch: 300, Avg. Loss: 0.024047833308577536\n",
      "Epoch: 94, Batch: 310, Avg. Loss: 0.01795934634283185\n",
      "Epoch: 94, Batch: 320, Avg. Loss: 0.016751547902822496\n",
      "Epoch: 94, Batch: 330, Avg. Loss: 0.019461614731699228\n",
      "Epoch: 94, Batch: 340, Avg. Loss: 0.0858467124402523\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 95, Batch: 10, Avg. Loss: 0.017906177416443826\n",
      "Epoch: 95, Batch: 20, Avg. Loss: 0.031585528329014775\n",
      "Epoch: 95, Batch: 30, Avg. Loss: 0.03318510288372636\n",
      "Epoch: 95, Batch: 40, Avg. Loss: 0.027568954695016145\n",
      "Epoch: 95, Batch: 50, Avg. Loss: 0.018538189958781003\n",
      "Epoch: 95, Batch: 60, Avg. Loss: 0.017129225842654704\n",
      "Epoch: 95, Batch: 70, Avg. Loss: 0.01987381437793374\n",
      "Epoch: 95, Batch: 80, Avg. Loss: 0.019142692908644676\n",
      "Epoch: 95, Batch: 90, Avg. Loss: 0.02320722592994571\n",
      "Epoch: 95, Batch: 100, Avg. Loss: 0.01577383643016219\n",
      "Epoch: 95, Batch: 110, Avg. Loss: 0.02035581674426794\n",
      "Epoch: 95, Batch: 120, Avg. Loss: 0.018146845884621142\n",
      "Epoch: 95, Batch: 130, Avg. Loss: 0.017012793011963366\n",
      "Epoch: 95, Batch: 140, Avg. Loss: 0.01725444719195366\n",
      "Epoch: 95, Batch: 150, Avg. Loss: 0.015600986406207084\n",
      "Epoch: 95, Batch: 160, Avg. Loss: 0.019185112789273262\n",
      "Epoch: 95, Batch: 170, Avg. Loss: 0.01576185626909137\n",
      "Epoch: 95, Batch: 180, Avg. Loss: 0.015443987026810647\n",
      "Epoch: 95, Batch: 190, Avg. Loss: 0.018925409577786923\n",
      "Epoch: 95, Batch: 200, Avg. Loss: 0.02510949643328786\n",
      "Epoch: 95, Batch: 210, Avg. Loss: 0.017202331870794296\n",
      "Epoch: 95, Batch: 220, Avg. Loss: 0.01682264907285571\n",
      "Epoch: 95, Batch: 230, Avg. Loss: 0.022615656536072493\n",
      "Epoch: 95, Batch: 240, Avg. Loss: 0.018159367609769106\n",
      "Epoch: 95, Batch: 250, Avg. Loss: 0.018707434460520745\n",
      "Epoch: 95, Batch: 260, Avg. Loss: 0.01882493495941162\n",
      "Epoch: 95, Batch: 270, Avg. Loss: 0.018497211299836634\n",
      "Epoch: 95, Batch: 280, Avg. Loss: 0.025731651671230794\n",
      "Epoch: 95, Batch: 290, Avg. Loss: 0.017737780790776016\n",
      "Epoch: 95, Batch: 300, Avg. Loss: 0.016354278102517127\n",
      "Epoch: 95, Batch: 310, Avg. Loss: 0.021102279890328646\n",
      "Epoch: 95, Batch: 320, Avg. Loss: 0.02214654814451933\n",
      "Epoch: 95, Batch: 330, Avg. Loss: 0.02035350790247321\n",
      "Epoch: 95, Batch: 340, Avg. Loss: 0.025522557087242603\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 96, Batch: 10, Avg. Loss: 0.019783609360456467\n",
      "Epoch: 96, Batch: 20, Avg. Loss: 0.016135341208428144\n",
      "Epoch: 96, Batch: 30, Avg. Loss: 0.02160655502229929\n",
      "Epoch: 96, Batch: 40, Avg. Loss: 0.01594872325658798\n",
      "Epoch: 96, Batch: 50, Avg. Loss: 0.016013215482234954\n",
      "Epoch: 96, Batch: 60, Avg. Loss: 0.021669369377195834\n",
      "Epoch: 96, Batch: 70, Avg. Loss: 0.026874580699950457\n",
      "Epoch: 96, Batch: 80, Avg. Loss: 0.022328702826052906\n",
      "Epoch: 96, Batch: 90, Avg. Loss: 0.016684592049568892\n",
      "Epoch: 96, Batch: 100, Avg. Loss: 0.018136677145957947\n",
      "Epoch: 96, Batch: 110, Avg. Loss: 0.01611242974177003\n",
      "Epoch: 96, Batch: 120, Avg. Loss: 0.01405229577794671\n",
      "Epoch: 96, Batch: 130, Avg. Loss: 0.014549835957586766\n",
      "Epoch: 96, Batch: 140, Avg. Loss: 0.017324812430888414\n",
      "Epoch: 96, Batch: 150, Avg. Loss: 0.016435443237423897\n",
      "Epoch: 96, Batch: 160, Avg. Loss: 0.017311092093586923\n",
      "Epoch: 96, Batch: 170, Avg. Loss: 0.01421966515481472\n",
      "Epoch: 96, Batch: 180, Avg. Loss: 0.01882741432636976\n",
      "Epoch: 96, Batch: 190, Avg. Loss: 0.018356958590447902\n",
      "Epoch: 96, Batch: 200, Avg. Loss: 0.01555044399574399\n",
      "Epoch: 96, Batch: 210, Avg. Loss: 0.014938628301024437\n",
      "Epoch: 96, Batch: 220, Avg. Loss: 0.023378036636859178\n",
      "Epoch: 96, Batch: 230, Avg. Loss: 0.014884916041046381\n",
      "Epoch: 96, Batch: 240, Avg. Loss: 0.01917603863403201\n",
      "Epoch: 96, Batch: 250, Avg. Loss: 0.02650834508240223\n",
      "Epoch: 96, Batch: 260, Avg. Loss: 0.013825534842908382\n",
      "Epoch: 96, Batch: 270, Avg. Loss: 0.04047351283952594\n",
      "Epoch: 96, Batch: 280, Avg. Loss: 0.02015634663403034\n",
      "Epoch: 96, Batch: 290, Avg. Loss: 0.014784736465662718\n",
      "Epoch: 96, Batch: 300, Avg. Loss: 0.021870372444391252\n",
      "Epoch: 96, Batch: 310, Avg. Loss: 0.1433039671741426\n",
      "Epoch: 96, Batch: 320, Avg. Loss: 0.022499098535627128\n",
      "Epoch: 96, Batch: 330, Avg. Loss: 0.02092937836423516\n",
      "Epoch: 96, Batch: 340, Avg. Loss: 0.019352014176547527\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 97, Batch: 10, Avg. Loss: 0.015503450762480497\n",
      "Epoch: 97, Batch: 20, Avg. Loss: 0.01736493958160281\n",
      "Epoch: 97, Batch: 30, Avg. Loss: 0.021181950438767673\n",
      "Epoch: 97, Batch: 40, Avg. Loss: 0.017543940618634225\n",
      "Epoch: 97, Batch: 50, Avg. Loss: 0.016628769412636756\n",
      "Epoch: 97, Batch: 60, Avg. Loss: 0.02564153028652072\n",
      "Epoch: 97, Batch: 70, Avg. Loss: 0.023964071925729514\n",
      "Epoch: 97, Batch: 80, Avg. Loss: 0.017610051296651365\n",
      "Epoch: 97, Batch: 90, Avg. Loss: 0.026570473331958055\n",
      "Epoch: 97, Batch: 100, Avg. Loss: 0.01626472845673561\n",
      "Epoch: 97, Batch: 110, Avg. Loss: 0.012997835502028465\n",
      "Epoch: 97, Batch: 120, Avg. Loss: 0.015846538823097944\n",
      "Epoch: 97, Batch: 130, Avg. Loss: 0.016113764606416225\n",
      "Epoch: 97, Batch: 140, Avg. Loss: 0.021057141292840243\n",
      "Epoch: 97, Batch: 150, Avg. Loss: 0.01589648621156812\n",
      "Epoch: 97, Batch: 160, Avg. Loss: 0.020663826540112496\n",
      "Epoch: 97, Batch: 170, Avg. Loss: 0.01578000532463193\n",
      "Epoch: 97, Batch: 180, Avg. Loss: 0.03791097216308117\n",
      "Epoch: 97, Batch: 190, Avg. Loss: 0.017117721401154994\n",
      "Epoch: 97, Batch: 200, Avg. Loss: 0.12776456819847226\n",
      "Epoch: 97, Batch: 210, Avg. Loss: 0.017146876826882363\n",
      "Epoch: 97, Batch: 220, Avg. Loss: 0.016081321612000467\n",
      "Epoch: 97, Batch: 230, Avg. Loss: 0.018030241690576078\n",
      "Epoch: 97, Batch: 240, Avg. Loss: 0.021123291924595833\n",
      "Epoch: 97, Batch: 250, Avg. Loss: 0.018280702456831933\n",
      "Epoch: 97, Batch: 260, Avg. Loss: 0.017629496566951276\n",
      "Epoch: 97, Batch: 270, Avg. Loss: 0.016098181065171958\n",
      "Epoch: 97, Batch: 280, Avg. Loss: 0.01912386929616332\n",
      "Epoch: 97, Batch: 290, Avg. Loss: 0.029255184158682824\n",
      "Epoch: 97, Batch: 300, Avg. Loss: 0.019598114024847745\n",
      "Epoch: 97, Batch: 310, Avg. Loss: 0.01664312006905675\n",
      "Epoch: 97, Batch: 320, Avg. Loss: 0.016254810709506275\n",
      "Epoch: 97, Batch: 330, Avg. Loss: 0.01710151247680187\n",
      "Epoch: 97, Batch: 340, Avg. Loss: 0.0629930205643177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 98, Batch: 10, Avg. Loss: 0.015331149008125067\n",
      "Epoch: 98, Batch: 20, Avg. Loss: 0.01917636310681701\n",
      "Epoch: 98, Batch: 30, Avg. Loss: 0.025028990767896175\n",
      "Epoch: 98, Batch: 40, Avg. Loss: 0.017123855743557216\n",
      "Epoch: 98, Batch: 50, Avg. Loss: 0.019959009997546674\n",
      "Epoch: 98, Batch: 60, Avg. Loss: 0.018111925385892392\n",
      "Epoch: 98, Batch: 70, Avg. Loss: 0.017058749869465827\n",
      "Epoch: 98, Batch: 80, Avg. Loss: 0.0190675457008183\n",
      "Epoch: 98, Batch: 90, Avg. Loss: 0.019360929355025293\n",
      "Epoch: 98, Batch: 100, Avg. Loss: 0.013816387578845023\n",
      "Epoch: 98, Batch: 110, Avg. Loss: 0.01592995077371597\n",
      "Epoch: 98, Batch: 120, Avg. Loss: 0.015798844024538995\n",
      "Epoch: 98, Batch: 130, Avg. Loss: 0.01568145230412483\n",
      "Epoch: 98, Batch: 140, Avg. Loss: 0.014783262461423873\n",
      "Epoch: 98, Batch: 150, Avg. Loss: 0.038772592321038246\n",
      "Epoch: 98, Batch: 160, Avg. Loss: 0.01625411259010434\n",
      "Epoch: 98, Batch: 170, Avg. Loss: 0.016886756382882596\n",
      "Epoch: 98, Batch: 180, Avg. Loss: 0.01923363972455263\n",
      "Epoch: 98, Batch: 190, Avg. Loss: 0.018123439885675906\n",
      "Epoch: 98, Batch: 200, Avg. Loss: 0.01781644020229578\n",
      "Epoch: 98, Batch: 210, Avg. Loss: 0.0132788454182446\n",
      "Epoch: 98, Batch: 220, Avg. Loss: 0.01583758443593979\n",
      "Epoch: 98, Batch: 230, Avg. Loss: 0.016138290241360664\n",
      "Epoch: 98, Batch: 240, Avg. Loss: 0.01805894309654832\n",
      "Epoch: 98, Batch: 250, Avg. Loss: 0.018717847764492035\n",
      "Epoch: 98, Batch: 260, Avg. Loss: 0.015450976882129907\n",
      "Epoch: 98, Batch: 270, Avg. Loss: 0.0157657484523952\n",
      "Epoch: 98, Batch: 280, Avg. Loss: 0.019838081300258638\n",
      "Epoch: 98, Batch: 290, Avg. Loss: 0.0139446004293859\n",
      "Epoch: 98, Batch: 300, Avg. Loss: 0.020806283969432116\n",
      "Epoch: 98, Batch: 310, Avg. Loss: 0.020288905967026948\n",
      "Epoch: 98, Batch: 320, Avg. Loss: 0.016111275739967824\n",
      "Epoch: 98, Batch: 330, Avg. Loss: 0.01559102740138769\n",
      "Epoch: 98, Batch: 340, Avg. Loss: 0.08823321741074323\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 99, Batch: 10, Avg. Loss: 0.016163481399416924\n",
      "Epoch: 99, Batch: 20, Avg. Loss: 0.015128925535827875\n",
      "Epoch: 99, Batch: 30, Avg. Loss: 0.018974432814866306\n",
      "Epoch: 99, Batch: 40, Avg. Loss: 0.13744441084563733\n",
      "Epoch: 99, Batch: 50, Avg. Loss: 0.03134964201599359\n",
      "Epoch: 99, Batch: 60, Avg. Loss: 0.034907464776188134\n",
      "Epoch: 99, Batch: 70, Avg. Loss: 0.08161303550004959\n",
      "Epoch: 99, Batch: 80, Avg. Loss: 0.05219453480094671\n",
      "Epoch: 99, Batch: 90, Avg. Loss: 0.025446769222617148\n",
      "Epoch: 99, Batch: 100, Avg. Loss: 0.017448395490646362\n",
      "Epoch: 99, Batch: 110, Avg. Loss: 0.017105509899556635\n",
      "Epoch: 99, Batch: 120, Avg. Loss: 0.0872136834077537\n",
      "Epoch: 99, Batch: 130, Avg. Loss: 0.017607095930725337\n",
      "Epoch: 99, Batch: 140, Avg. Loss: 0.01877664141356945\n",
      "Epoch: 99, Batch: 150, Avg. Loss: 0.019637736957520247\n",
      "Epoch: 99, Batch: 160, Avg. Loss: 0.017944723553955554\n",
      "Epoch: 99, Batch: 170, Avg. Loss: 0.02921829782426357\n",
      "Epoch: 99, Batch: 180, Avg. Loss: 0.022436426766216756\n",
      "Epoch: 99, Batch: 190, Avg. Loss: 0.018909087032079698\n",
      "Epoch: 99, Batch: 200, Avg. Loss: 0.01792140370234847\n",
      "Epoch: 99, Batch: 210, Avg. Loss: 0.019824435748159886\n",
      "Epoch: 99, Batch: 220, Avg. Loss: 0.03668342074379325\n",
      "Epoch: 99, Batch: 230, Avg. Loss: 0.019609990157186986\n",
      "Epoch: 99, Batch: 240, Avg. Loss: 0.016595241706818344\n",
      "Epoch: 99, Batch: 250, Avg. Loss: 0.019437295384705067\n",
      "Epoch: 99, Batch: 260, Avg. Loss: 0.01785266064107418\n",
      "Epoch: 99, Batch: 270, Avg. Loss: 0.017814481165260077\n",
      "Epoch: 99, Batch: 280, Avg. Loss: 0.0174914981238544\n",
      "Epoch: 99, Batch: 290, Avg. Loss: 0.01734512746334076\n",
      "Epoch: 99, Batch: 300, Avg. Loss: 0.012776205595582724\n",
      "Epoch: 99, Batch: 310, Avg. Loss: 0.020449549611657857\n",
      "Epoch: 99, Batch: 320, Avg. Loss: 0.01549241431057453\n",
      "Epoch: 99, Batch: 330, Avg. Loss: 0.01606541536748409\n",
      "Epoch: 99, Batch: 340, Avg. Loss: 0.09305217945948244\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 100, Batch: 10, Avg. Loss: 0.020854390133172272\n",
      "Epoch: 100, Batch: 20, Avg. Loss: 0.03249334963038564\n",
      "Epoch: 100, Batch: 30, Avg. Loss: 0.02329984223470092\n",
      "Epoch: 100, Batch: 40, Avg. Loss: 0.01718690702691674\n",
      "Epoch: 100, Batch: 50, Avg. Loss: 0.018850165512412788\n",
      "Epoch: 100, Batch: 60, Avg. Loss: 0.019276976771652698\n",
      "Epoch: 100, Batch: 70, Avg. Loss: 0.015171923814341426\n",
      "Epoch: 100, Batch: 80, Avg. Loss: 0.06591074354946613\n",
      "Epoch: 100, Batch: 90, Avg. Loss: 0.025764899887144567\n",
      "Epoch: 100, Batch: 100, Avg. Loss: 0.02009710194543004\n",
      "Epoch: 100, Batch: 110, Avg. Loss: 0.06993815815076232\n",
      "Epoch: 100, Batch: 120, Avg. Loss: 0.022299562860280276\n",
      "Epoch: 100, Batch: 130, Avg. Loss: 0.0243826299905777\n",
      "Epoch: 100, Batch: 140, Avg. Loss: 0.018014175724238156\n",
      "Epoch: 100, Batch: 150, Avg. Loss: 0.018979462515562772\n",
      "Epoch: 100, Batch: 160, Avg. Loss: 0.02704693004488945\n",
      "Epoch: 100, Batch: 170, Avg. Loss: 0.035845271311700344\n",
      "Epoch: 100, Batch: 180, Avg. Loss: 0.01818615309894085\n",
      "Epoch: 100, Batch: 190, Avg. Loss: 0.04494545524939895\n",
      "Epoch: 100, Batch: 200, Avg. Loss: 0.03578869439661503\n",
      "Epoch: 100, Batch: 210, Avg. Loss: 0.149114790558815\n",
      "Epoch: 100, Batch: 220, Avg. Loss: 0.017597609665244818\n",
      "Epoch: 100, Batch: 230, Avg. Loss: 0.02307580942288041\n",
      "Epoch: 100, Batch: 240, Avg. Loss: 0.029763370845466854\n",
      "Epoch: 100, Batch: 250, Avg. Loss: 0.017818506713956593\n",
      "Epoch: 100, Batch: 260, Avg. Loss: 0.018340818490833043\n",
      "Epoch: 100, Batch: 270, Avg. Loss: 0.017016830295324324\n",
      "Epoch: 100, Batch: 280, Avg. Loss: 0.020912212878465654\n",
      "Epoch: 100, Batch: 290, Avg. Loss: 0.026451258547604085\n",
      "Epoch: 100, Batch: 300, Avg. Loss: 0.01751349223777652\n",
      "Epoch: 100, Batch: 310, Avg. Loss: 0.018368140421807767\n",
      "Epoch: 100, Batch: 320, Avg. Loss: 0.021664230432361365\n",
      "Epoch: 100, Batch: 330, Avg. Loss: 0.016659913677722217\n",
      "Epoch: 100, Batch: 340, Avg. Loss: 0.022539508622139694\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "# train your network\n",
    "n_epochs = 100 # start small, and increase when you've decided on your model structure and hyperparams\n",
    "\n",
    "train_net(n_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1, 224, 224])\n",
      "torch.Size([10, 68, 2])\n",
      "torch.Size([10, 68, 2])\n"
     ]
    }
   ],
   "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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIYAAACBCAYAAAAFfMIpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztvWtsZOl53/k7p+pUnbpfWbyz2dM9zSE5mhlpJDiOpQWUkSxYCezNRevLOraTnQCOVivJhgAZlqXVHZIymollx/Ei3mS1tjd2srCwHwwlshBYUjDWxR5pZvpONptsNskiWaz7veqcsx9qnrfeqq6e7GJ3kxKWD0Bwhl2Xc973/z6X/3M5hud5nMu5jIv5X/oCzmU65RwY5zJRzoFxLhPlHBjnMlHOgXEuE+UcGOcyUc6BcS4T5RwY5zJRzoFxLhPF/1/6AgB+67d+ywNwXZder4frukSjUeLxOD6fj7OzM7rdLt1uF9d1cRwHz/MIBALcu3ePg4MDDg8P8TwPz/Podrskk0lmZ2cxDINut8vx8TGdTod+v4/P5yMYDOK6LgD9fp9+v0+tVqPf72PbNtFoFL/fTygUUq8xTRPTNPH7/RiGQavVotls0m63cRwHy7Lo9/vqc3u9HqZp4nmeem88HicajZJOp/H5fMTjcdbW1jBNk3a7TafTIRQKkclksCwLgE6ng2mauK6Lz+fDcRx8Ph+GYdDr9QgEAlQqFRqNhlq7WCyGZVncuHGDw8NDqtUqwWCQVCrF2toaiUSCTqfDBz7wAWPSnkwFMBzHod1uA4PFdBwHv9+PbdsEAgG1KT6fj36/j+M4tFot8vk8Z2dnNBoN2u02fr8f0zSZm5sjkUgQi8VoNptUq1UqlQrtdlsBT8Dg9/txHAfDMNTCm6apNrpcLtNsNul0OgB4nke/31fA6nQ6NJtNDGOwvn6/n2AwSDweJxAIqL8DBAIB4vE4oVBIAczzPI6PjwkGgwBEo1Gi0SiWZSkQWJalwNbtdhUoYHCYBJxy7fLZ8h7P84hEIti2DcDx8TE+nw+fz/fQPZkKYHQ6HXq9Hp7nqZtxHIdut6tAAIMb7PV6dLtdarUa5XKZVqtFp9NR7zNNk36/T7fbpVQqUalUyOfztFot+v2++ux2u61eZxiGWlTLsjBNk2q1SrVaVdpAQCRarVKp0Ov11HUJcAOBAJZl4ff71ff1+30CgQAAjUYDGGxoKpXC5/PRaDTodDrYtk0wGMS2bbVpvV5PAUHuH1B/cxyHZrMJoA6RYRjqekTrhMNhkskkwWAQwzCo1+tKG06SqQCG4zjAYLEkqee6LoZh0G636Xa76oQbhkGj0aBYLNJsNtVCieoXYBwfH1Ov19VrWq2WAp6YItlAUfeyiJZl4TgO1WpVXaO8D1AnUk683+/HsixCoRCGYRAIBOh2u+p9fr+fQCBAJBIhm80SjUYJBALYto3nebRaLTKZDKlUinA4rE5zt9tV5iiRSNBoNGi1WkrjyXUChEIhLMtS5tQ0R93HSCTCwsICwWCQk5MTut2u0tKTZCqAIeZBQCE3B6hTIaDo9XrU63UFFNd1sSxLAUg+r9lsUi6XR8Cgf4dpmhiGoTZVX8h+v4/necpc9Ho9DMPAsqwRkyEaRP83MTWO4ygt6PP5lAYpFAo4jsPs7Cx+/2D52+02rVZLgUp+fD6fut5ut0sgEFAaIhwO0+/3FVAikQihUEgdAFlHkVqtRqlUYn5+nng8TqPRUNprkkwFMAQInuepE6DbZtl4z/PUqRE1HQgElHkxDEMBSD5DNgaGYBCRDZO/69pKvwZxNkU9y+fp7xEAj9+L+Cu9Xo9arYbjOHQ6HRzHIRwOEwwG1d8EbLZtk0wmMQyDTqdDIBBQ3yOmVe5V97/EQRV/Sf5fPr/T6eB5nvJ/RNtOkqkBhr7wruuqG9QXvl6vc3Z2ptSr2HN5j9zoycmJ8uTlR1ez8nnyI1pFgCCbqb9eRNc+YrYEOAJq27bVxohWEnDoPsDh4SGWZZFKpdR7AJLJpNIWjUZDASMUChGLxeh0OtTrdfW9OnB8Pp/yueRvAh5Za1m315OpAEapVBpR8QKQTqdDo9Hg6OhIRQYS8smmwkAVi+9RKpVU2CcLJs6lnCTRMICKHHQQiikBlB8hmzkOFtl82SDZLBj6TOIrAOqkJxIJLMui2WyOgDcajZJMJpWfIgD0+/0qZG80GjSbTdLpNOFwWJkk3XnXNYz4HLq21H2mSTIVwACUvRabaVkWsViMbrdLvV7HMAxs21Y3JzclJ7FQKFAoFDg7OyOTybC0tEQul8N1XarVKsViUYWswANgkM+TyAKGmkw0mDi4eqQUiUTU5+lOdKfTUSZHnEXZtFqtxuHhIYlEAhgAu9FoUKvViMVi6tqCwaDyNbrdrjJBtm3TarUIhULqmmzbHgGaaJxer0ev1yMUChEMBlVYfHx8zNnZ2cP34/+NTf1/KvoGiYhvEAgESKVS6qRLaCeIFzsLAxUcjUZZXFxUpubs7IzDw0OazebICRTVKqpdP036xshr5OTpkYmQXCK6nR+PCuQe5efs7IxSqaS0hJi6e/fuEQwGFREHjJjMd7zjHczNzbG7u8vu7i6dTkfdV7PZpF6vq8hG93PkGmQN8/n89DufMFw4UdcwWJBWq6Vsc6fT4fT0VN2shLFii23bJp1O43me4jnK5TKlUkl9vmy6fI/OIurEkUQXMOpX6AsOQ1UtpkR3dAUEOg8h9l7e5/P5qNfrKgIql8tUq1XFXMq1yufFYjHS6bTSOvV6nU6nQ6vVGlk7/aCJnwMD7SSh/jh4dZkKYOi0sajxUChEu93m4OCAF198kU6nQzQaVYsYjUYV+sV+d7tdms2m+lu5XFZspm3banFgaCbkb7oN1n0DAYcOGDEJMOqDwAAouuOsk2fCZMr9CoiEaHIch7OzM+7cuaO0ZTQaxXVdCoUCpVKJb3zjG+RyOQ4ODrh//z7dbpdgMEgoFFLX1m63FROqR16tVot6va60SiwWe+ieTAUwIpGICjdlUyTv4DgOwWAQy7JIJBL0er0RB09OlGgUcdDEa5eoQX/PeBSk8xvymSICAt1fkPeNv1Y2Ztx5FbZRXiuOtWxYp9NR99jpdKjVahQKBZLJpNI6tVqNRqPB97//fcLhMDBkRWFA8Am1L7/1ELrf71Ov1+n1eoTDYRKJhDKVk2QqgCGUcb/fV3xFIpFQp02PLsRUSI5AV/lyyl3XJRQK0ev1sCxL5Rr0zZHf8l5R1+L4yoKKw6vbav0kyutc16Xb7Y5oiVAopMgq8WX0BJwQYKIxRFsKnS/3VKvV6Ha7Suv5/X4ikYgCkjik4qeM8ycwMCFy/ZlMhkgkMv25Egk1xZcIBAKYpolt24RCIZU8g+Hi1Wo1qtWqOp16OCp0sX4idB5Dkkkw1AhicsS06D6P0NeJREItZqvVUnkO0WxyfYZhqGglFAqpKKXdblOv1+l2uyoKE+2hgzISiRCLxfD5fCrpJ2DU/SH5dyH8hMXVTZloD8/zFIgODg4Aph8Yos4lypCFlEUX+yl5BaFzm83mSL5ATr2uloUDEA3iui62bauNEA2l+x+ACgEl05vJZMhms8Bg88VOywZLBlMXIa2q1Sq1Wk0xn47jqFBcJ+ZM0yQUCikT0+12VQ5GjywAZTIl9d9oNBTDOe7viNMsYbYkBqee+dRTxUJWua7L/fv3uXv3Lvl8Hr/fP3JaJT/QbrdVKCemQk+M6aZDtI3uBIr20PMSUs8gORCfz0cymSSVSmFZFrZt0+l0CIfD6oSLRhJ/JxwO02w2abVaikwTEFuW9YC2k3WQU16r1Wg2myrSkd+ymaLpAoGAAvh4yK0zuuKrSZ2HrPXDZCqAAYMb7HQ6ygSIipVoRDxtea2uHcTMAOpkSVZT1KvUdsjG6KCR9HQymSQSiSgQAOp9wWCQcDisNk4cZAGUvEaA0Wg0CIfD9Ho9ZmZm1Em2bZtyuazAUq/XlfbSaWxhODOZjDKnMCTidOdZHE/JoQjY9VyKaMCZmRlWVlZUmPwwmQpgiPMl5kJ8A9u2iUQiI5SvaATJLPb7/RHvXKIZnbPQIwVxYEVrRCIRdeKTySSJRIJMJqMAJeCCIUEkgBDwioOrV1npNLf4JpZlUa/XabVaKpElhT4CKD2voWeMLctS4bOe9BNQCjCkiGg8IhHfR9ZLr/mYJFMBDECBQU9nC8Wtawu5IQlP9WyqnIpGozECCEDVSoTDYWZmZpQTGg6HVfQwNzenWEOd6taZWQGJqGjRXjAa4Qi/IZpGbH0qlVK2v1qtKrZSNq3b7SqQNJtNms2m8rOkuk0n4oR6j0ajNBoNFfbr4JESQjFF1Wr1AbZ3XKYCGNVqVXnPwAinISGanAJAJcGE+xdbKn5IJBJREY44tLZts7KyohJPtm0Tj8fJZrMjYSCgsrViJnRWVPwAnR/R090icmKlWkzyHTMzMwQCAWKxGEdHRypakNM+blbE0U6n0yP8iVyHhPKxWAzHcTg9PVVJO1mnVquFZVnE43G63S6VSkVps4fJVABDIgPdQweUR14qlUZS2sFgUPEBohX0XIaAAVB+SCgUYm5ujnQ6TaVSURVVsVhshImUEynmQEQcV9mwcYJNNlReoxNhetgrIDVNUzmYeuIOUJGQnggTrkLK+OS75fvkuwzDUE6rEH4S0krFWKfToVQqTT8lns/nKZfLylbLSQwEAiSTSVqtFsViERiYHCnM1UvrRI0CqpxPHM14PM7KygrZbFaBLZlMMjMzo0yGbHjQDlLpV0gH0kMHz++j2CkSN+PqGsUxhmFeQmdrBZC6vRfA1mo1TNNkdnZWMbninMo1G4ZBPB4nHh98Z6VSUWH3uNmBoVMq9RqSSRbzqh+6eDyuTMrDZCqAAcNIQ0gmAUir1VILIo6bzkCOq3m9phOGYers7KyKKnK5nGL/5HN8Ph/NVpMPv/JhttpbLPeX+UXfL+I4Dn9o/SH3vHtc8V/ho498lK6/S8bOjNDsek5FLxXUC3ZEw0kKwHEc0uk0oVBIcTJ6XkW0jH6ydTrftm3FnoqIZpFkmZhYPWcTCoUIhULqIE2SqQBGNpsdSTOLCiwUCtRqNVXHKBlISYlHIhEFBNEQMFq1HY/HWVhYIB6PEw6HlQmR+L/T7lApVogmouwV99hqb+Hict+4T+5/zvGvLv4r9t6+h2d63O7c5uPf/Dh3Zu/wiPkIH178MEQgaw+IL9EUsgnjeRVgxGREIhEVRYjoJ19CZd351RN44sQKJyEaTIgu6ZPRa1X16G3qfQxRj+Iv1Ot1qtWqKtGTU6H7DoDyEQDFUkrRrPghsViMubk5FhcXRxxZ13VxHZdPf/PTXM9cZ+PqBr/+1l9nvb7OzeZNNvc3WT9c5+8/+/cpuSX2nD2uHFzh9uJtXMNlp7/Dcy89x1ZuizVrjV9b+jVM0yQWi42EhoAKr8WX8fv9NJtNotGocpYjkYhqGJqdneXixYskk8kRRlYOgGEY6sSLE14sFhUwAoEA6XRaVbTpleoS0VWrVZWPmSRTAQxd/cvN93o9YrEY0WiUcrmsusOk7lNUr0Ql+ka4rks8HicWiynHU1fvcvpa9RbXM9dxfA7XM9fpt/t8au1TNP/HJvPX5mmsNmhaTX6++/Nc/OOLLG8t8/5n38+t2VtDkOByu30b63mL3geHJYO6lpD7kh4Y0zRVkYywpFJm4Pf7yWazZDIZRfSJQwwov0LoeNEOct9iZkQz6h13esZVLymYJFMBDLkxMSfiU4gGWVpa4q1vfSsXL17EdV22t7cVVa47YDoHkkgkyOVywECbSN5BVL1pmqRn0mx+d5Nr6WtsnG3QWelQ2Ctw/O5jrv7oVZrBJhwPrvG7b/8u++/e5z3x97D6R6ssby3zwX/0QW7kbrC5v8nsq7Pcr9ynZbZGCnpkI6SV8t7OPbpuF8MxwAI7bdM8bNJsDDiLlZUVVlZWVNVat9tVLYvtdlvlW/SGJDkUOg0uvgYMwSQaq1Kp0Gw2H8gP6TIVwBCRyEAqmW7fvo3jOLzzne+kXC7z8ssvk8vllN/gui6Hh4fKfJg+k7bZJuVPcfnyZZ566inV2yl8g6TBJS39G//Vb3BydEI73uYv/+ovR2pAvK6nQsd+v89R+4hsNMvpPzil0WvwbPRZ0r+XZvHGIu1LbZyYgw/fSLmh67oUi0XOzs74Wvtr3H7jbeyeTdtqY/cHv9f8a3zw33yQ37n4O1y6dIn5+XnC4TDHx8c0m03VnQaM1KzIZgswxD+R9L9wQ6FQSPljwrTq3XGTZCqAIadcNtC2ber1OqlUSi2M3KzUMfj9fhKJBJVKRanQb1/6NoV4gUwzw9uTb1dUtM5TCDBEBbfaLbpul3KlrIiieDxOMBhUNSGtVotSqaRaFv1+P/6Yn3AoTOO9DXYaO/Sjfcy+CcaDkUg0GiUZTbIV3ML1uTTNJhio3zeWb/Cb/81vsvnqJgvzCyQSCVW9JcDUNZ1hDPpNxIkWsOjEWK/XU30kUr0lZlrvX3nonvxn3P+HijiLerYvmUwqGlds5OzsLPPz8yqbKNS303d499V389U3fhXP8DgLnxFIBhR5JXZaeA8YlgGKo2sYBvPz89i2TSqRImWkiC5HcfoOzcMmlt8CD7ySRz/YV1XaPsuHL+vDx4NNTZJMazabtPtt1k7WuJm7qTRG0AnSslpgwK3FW3zi33wC37GPvQ/sqYhDKsV1kZwNoHwI8bWk6VkPYaUPRcJ1qQybekrcdV1OT0+VyhT7GA6HKRaLeJ7HzMwM2WyW2dlZlVyq1Wrs7++T9WfZONxgc3+Ta8vXWOgv4FQdZZ/HGUghk0TNimmZm5vD8lv4vugj80oGd83F8ll09jpcWbjCSmuF2H6M8mKZO//9HUVtC3kUi8VUXufk5IRarcbx8bHaxMcbj/PG8huxozaJSIJkNsnv9n6XQ+OQjf0NMvUMXt3j4NoBFV8FGPakioTDYWUGxSnXe26lUEe0pGgRacJOJBIj1MDDZCqAISX4UtonJFEmk6FQKNDv91WEIiYFBgze6uoqJ6ETTnOnfPHLX2RreYv8L+WJx+Mq+yiqVqeuxWlzHIdEIoFpmvT6PT53/3Ns/a0tNp7c4Df+99/g03/v01z/r6+zub/Jc19+jmK4CCXgHpAdzQzrZJtwCDKjQ05rqVQaZFMDJs1WE8/wMCyDntXDNVxMz+QtX30L/+5d/w6MYYOSFOSIKRCt2el0lGbVm4tgtBlKQtRGo6HaIl9PpgIYkUhE2UVgpMpZinEEDLdv3x6p+cxms/j9fr75t78JZehH+zy98LRKnQMjoIDhgkkiTcignfwOt3u3cX0ur154lZ/91Z/FNVww4OryVT7wDz7AjeUbALxh7w185nOfwf0nLgF76MwahoHneAQaAQLJAOHIgFTLZDJYPovSbonD0CF9p0+lXyEfyOMZHrcWblGKlMjWs2TzWaK9KDWrpiq5JK8iDc1iFqXjTqI4GDLCEqWIbyJA0utoHyZTAYxgMEitVgOGMzB2dnao1Wrk83kcx6FYLBKPx9UC9Xo9IpEIS0tLbG5usru7y8HBgWovkPoH3YTIQgijCChHtN/vc/SXRyRSCUrR0sCJNF3wwHAMLh1d4ubiTXjNLF9fvk73uEuyn8QMDoDW6/cotossfm6R5e1lmheb7L5vlxQpYuEY4Y+GyVzLMLM8w4t/70WskkVuJseJfcJcdw437uI2XApzBfqxPgF3UGsai8WUyZJaU3HIpfRATKYcKFlLqUD3+XzEYjEWFxe5cOGCqiV5mEwFMGB4qqWV7uTkhNPTUyqVCicnJxwfH7OysgKgqG4ZJRCPx1laWiISjXBUPSIajY7kF/TMp6jhYDBIr9dTSa6ZmRk21jdIHCa4/up1vrP8HeqJOpv7m9QDde7M3yHUDdG0B9nNzf1NIosRfNkB7+J6Lh/6wYe4WrnK43/9cV7YeoHwTpiV51eIHcRwLjsY2waGaxC/F+ev/W9/jeRRkjdn38yf/u0/JUSI//C3/gN226Yb7oKB2tBQKEQqlcI0TVW7ITUfOpuqa0WpVxHWUzKrpmkSjUYfcPbHZWqAEQ6HVQYyk8nwzDPPkMvlyOVy5PN57t69y1NPPaWcMdu21c3W63U81+Mzu5/hWvMa65V1PvPoZ5SGGG8mEtF7RSKRCFeuXGF5eZlLj1zix7s/Tr6aJzgb5HOhz+Hi0g61+UjqI0SJsphepP2TbXy9QThc7Ba5Vr2Gi8u1lWsUIgXyoTwb+xt4hkfloELKTdE3+lxfv87m9U1MTOYKc/zU//FT/NlP/hmO59CyWxieAd6g7E/qS/UZHVLboVdvnZycjIT7Uo8iledzc3MqA727u6sO2cNkKoAhhTqAirmTySTr6+uq0KVYLFIqlchmsyrMPDo6YnFxkWq5SufTHa79xDUcn8ON2g0q/QpBNzgydkDs7qQaS/E5xASZpslKbwXDMHhs9zFuNW+xFlnj6eWnVWpc7/LKBDNsxje5WrnKBf8F3v/s+zmOH/Po/UexXZvry9dZ319nZ3aHpt0k0o7wlS98BcuzyJxm8Nf99KKjhb568gsYCTH1YmDxJfQ0AQwHyNTrdcXfyEyyk5MT4vH4Q/dkKoChT6BxHEcVmQQCAXK5HDs7O3Q6HXZ3d7l06RJzc3OUy2WOjo4GUUzZIP39NJuPD8LV9eg6SX9SLZ7ureu9GePRifApYq+FSn7+yedp0CBlpUbS4fpG9Z3XmqMxCBwH2EvvgQlbS1uDmzQHDiwmYEDDbnAve4+Lpxc5nT2lHx3O2QBGgKuHq/L9YnoliSaNSdI6IWZC3ivAsG1b8StT73wmk0l1M+12m3g8TiKRoNvtEg6HicfjlEoltra2eOaZZ0in08zMzKi6A2zw1j1e+P0XKD9dJvzxMB7eyHgmqfHQmdBx6lr34IUydl0XE5MEiZGN0/s8XNel3C1ztXIVB4fb6ds8dvAYtxZvseAukDfz9LwehmngGR54EG6HCVthvvyzXyYYCRLpRSAChmmoXIf4CcJBNJvNkWYiGGoMvQZFL1CSUgPJrwj38kPR7V6pVNRGeZ6nOAhJkQvRVSgUODk5IZFIMDMzQzKZVKMJ3edcqIKRHDh4njs8zRK2ilkSs6VXNemnRxZe6jrltXr2Ui8KAkgFUjyeeJyrlatsFAccCJch/948v3L/VwbfwWs+j2Hy0dhH+fB/92Hum/d57OgxvvT7X6I8X+bF97z4QA2pDI0RLaFfo3T5Sy2IXFO73VZhbDAYpNVqKaczFoupaQAPk6kAhszSlLArmRyYAZlR5bquqt7a3t4mlUqp/s5arYZlWQSCAX5t/9e4fuM6m7FNPr/xeUVT6ydJV9E6ASav02s5RfSWBekdGa+c8jyP33zjb5Kv5fnMrc/wc7/6c2yENvhU9lNcPrnMdneboBmk43bYjG0SToY5uHeAZ3jcnr1NNVQlfZQm2AzSiXQeyM4KpS+AGa8v1c1mpVJRne2i5aT4SRqk5ubmXpfkmgpgLC0tqU7sYDBIMpkkFoup4hKpnWw0Gnz7299WBTh6VNHwGlyvXcfB4VrtGnW3TsKfUPkDWTidJgZGElTyeTpdLA6rDI+t1+vK6ZQeFakol9BQruN6/Tq9T/X47c/+NmedM0JeiKpTJelPUiqVuOC7wJ67x9rJGolWgvJimU64M6KddIDqhT/jfan6Jktn/Onp6ch7hC2Vksmp9zFkSIhOd7uuq0ivubk5lT73PI9qtaqih36/j+EZbHx6g80fGzifm8lNklZSaQY9EacX9Oi2GnjgROrtDLVaTVHbMGBrdX9DnLxMMMO6vc6NxqBOI/2DNL1iT1HicTOuOtc/ffnTdP1dzAsmdy7eoWpWsQqWIp7GG4sEKOPVYTBsuwRUvkSiK53TkX4WaZF8mEwFMCqVinK2pH5RL/qdnZ1VNynTfqUE3zAMuiddQtshXth6gVKsROL3Eg9QwuP/D8PSfz3HoRfNwtAvEad4fn4eQLX3STWUPvnnY5c+Rum5Epe+dwlnzaHmq+F3h6fccR1OGidk7SyZQIZ2sU0j1sCtTzZxIqKZYKjVdK0ifxOOR7Swnu3VZ4NO/WRgiRJk88V0+P1+yuUy/X6feDzO4uIihUKB7e1tDg8PmZubY3Z2lsfe+Bi9tR7WbYvMagayA0dPtIW+ODAciSDAAB5YXJnWI2lz0Szb29vs7OxwcHCAz+fj8uXLyg/o9QaRxz+r/zPuvusum+ubfP47n8dzPQUaD49P3vskW+0tLvou8oXf+wKZexmMBYOdn9nBcUeHn+j9MyK6zzTegCTgl7keomllGrF0xusab5JMBTBgmLOAYQ+rxN2S+LEsi3A4TKVSUVVRtm3TaDZofrqJr+6jN9sj68sqyli8dL0ZWP+BYae7mA/J8gowZNGlF+Mof8S94j1iRowUKRIXErQ77YH582rs9HZwTZdry9do/EmDXqGHmxio9lKvpCrR7zp3cYuDjGr6KE2gGaBlD22/7veMk3E6OCaV6Imjrb9Oak6lpOH1ZCqAIbkN2UTZHNMczNDWH9fw6KOPMjMzQ7vd5vT0VAHG8Bt8pPARru9e5/HE4/zzH/nnGBgjvsm4s6XzEiL64svAVb15udFs8O/n/z23E7dZP1nnJ3/vJwnNh7j681epdWo0jAbzxjxHxhEb+xuE58OUAiX8/ddmfTVNLpgDp/OSdQkra+E2XGorNQK5AK1qSxVDj4fHgCKw9NmhkiyTyiwxWfK72Wyyt7enCoSlIGnqnU+xddK1LpsojF4sFlMFNXquQFQtQLlbVtHA1cpVSp0SSSs54k/oCyF+hO7cjf8IeSR8SqfToebWuNW8hYvL1Zmr/PQHf5pQN0Sr18L2bFpWiyBB8KC93Cb/tjx+c3CNMtrgF9xfoNQpEWgE+Pq7v06wFaQX6WGUDeWvSKJPqs7l2oVfkaoscawl2pCkoPA1ohljsRipVIp4PM7c3NyINpkkUwEMfTa2bISYAiG4hJ4WyloIGxhscsJMsHk6qPjeLG6S9CfV5+tJNHm9njuR1+iE13j5v9DgWTvLldAVbrVu4eHh+lwadmNYwwm0vTYYsMMO9pfmybWAAAAagklEQVRs2v9DG8M38BNOTk84rBxiNAeJMrkvvzMcdi+nXUCh+xhCdAkZKGObRMOK2ZWxSnLdsViMpaUl0um08t9eT6YCGPqzPwKBAIlEQt2szNqW6EDmO/R6PVXtZds2wXaQ53/3eSp2hVQ7hfluEzc5LNCRjRf1qrOIMCxukcwkDAGl13JEo1G+9KYvcVg55PN3Ps+t1q1BDaevPdAcgRahboh2oK3aCnaKO/SiPc6KZ/yB7w84mDlgob/A36n+HYLNgbawAsP5GhLaiiYdd4xFdOdT5zGkEFjvhGu32ypE1ZOID5OpAIYktkaSUq+FrqIldMdUOrDEDIRCIfqBPoH1AOkbaYw3GDgJBwNjZPN17aCTQzBMtOmvlX+XMFF+ABbiC3zxiS9SaBWIelHq5TozX5yhsd8g3otT9VVJNVJ0rnRoWA269S4n9RMOg4d4hseR/4gnvvoEj+w8QnG+yH/8u/9RRVKyDpVKZeJa6UztuMMuPI9EH8LSlkolDg4OlGaWSOtDH/rQxD2ZCmAAI2OUYOAYynO8dDJnvOFXOYumQeszLXx1H9Hl6AippZ8OWXR99KHULUj0okcpom36/T6dboez5hmRcoRALkDP6Q1K9OoVzLhJ4wMN3L7LSe9kUCpAkX6sT7vWplwu0y62yaaynNqnZGoZVu+sYnomqcMUxzePqQfqqiprUigpZlbnMibR2mJKJESWdRUT9H9FpgIYMucbBpsoWVMZayQ9p7JYUjchw8+UijWhF+txXD8mF8mNRDci+obrZkXCUalAl8SVFO92uh3+bfjfkvfl2bi3wT/+5j/mEz/9CY4Dx+qzn9h7guf+6Dn8XT/11Trb792GznCge7FY5Im7T+BP+An2guTTeRaKC+QzefwzfpJGUmlDAcA4+SZO+Hg7hIiYvlarpTrOotEoV65cIZvNqoP3ehwGTAkw5ObkFMvi6JNypXVf1LmYF6lY8vl89Po9PrL1EW7UbrBur/PcU8898NiJcfsqoBHP/ujoiJ2dnQEgGk3CnTDBQJBSrMRhfGAGXr3wKu/7+fepQmGRq8tXBybES9E96RLIByhECrjeoMkoFA6px074/X5efM+LBFtB3LhL1pd9IH0+nr+R3JGEpaJlRXO02201WKZUKlEsFpWWyWaz5HK5B6Kbh8lUAEMiEEG7/viEs7Mzzs7O1CJFIhFSqZRyUMUUGIZBpV/hRu0GDg43GjeofaRG5vOZB+jlcd9CtFOhUKBYLnJYPaR2WuNvvvI32TzcxMBgN7HL137ha9STdTzTU4XCeAzA4cGVgytEuhF+5Rd/ZZCz2d/kI3/8EX71F36Vw8Qhc9053pV/FwErQLQfpWW3cIMuPtP3QBQk16lfs75W8luv9xT2WHeY5bPkUWB6eD71zqdUbMl/x2IxlXoXYEg+xefzMTc3p4gu2VgprxtPYFEGZgbfo58W+d1ut2k2m1QqFbq9Lv/a+tdsr24TXA3y9bd8nc39TV748gus1lZ5v/t+juvH/Kn9pxxZR2ze26Ttb3Nn8Q4AlmtxL3mPV1dexTO9gQZpVzn0DzRNPpDHC3m87U/eRvooTWmhxHd+5juYvmEXvh4BSWOQXnmmZ3ZFG0iYKxwPDJ1UiVD0JubxTrVJMhXAkDkRMOxYF1sYi8XIZrOqqlla8AAVj+sM4Ree+AKNjzZI/yCNu+7iRBz8Pf8DcbvQ3jIyyXVdnKDDnfIdPDzatMEH15avUQqXiCxGmF+b549Lf8yxd8yV4ysYGAoUGPDqhVd57y+/F8N7LVrqhlgoL5BrD1oEFt1F5vpzpI/SmO7A6Qx1QqrWc1wmZW8lhB6fTw7DMj5ZPx1kiiE2DGWGpz5XoucyxHOW/5cytWQyqXIV8Xhczf/Uq8vF3EQ/GaVb6eIlPJy+M6yc0tSwiEQ3AMlAkvX6QOPYPpu20+ZK8Aq1T9U4iB6Q+e0Md3/qLq7P5U52ACDlY7x2AB2fo8xLO9CmFWjxM0c/Q2+2R9wfpxPuUFookTpMUV4s04v0RqILPRy1LGvkaQt66CzRmj7OUtZPNIy8x7KskWounVF9mEwFMMTGi6mQkE3qQGu1Gj6fTz20Rbx2GessnIZEMabfxEsPnNi6VyfWiWGUDcz0MJMqfZ7yXTKh5qMrH6XqVAm5IVzbxdfx8cm9T7Jd3WbzTZts7G9wffk6GwcbeK7H1QtXAbh8dJmD9AGtYAvTNfHwWDtYI9lIkkwk6foHRbuW3+LlX3qZYCuIkTJI+BMqVJ6k3qWjXUg9idJkXHWxWFQOqV4aKdFdo9FQNbQyjC4ajXJ6ejoyAXBcpgIYqVRKzdzW0+GmOXwWer8/eMBcMpnk8uXLzM3Nqcl1Ou+vqqk8V0Uom6ebPP+7z8M6tD/XxvSbyrkVVSzf2+/3SRrJQRq92eOwdsh2dxsXl+sr13n0/qN4hofnvuYgugZ212Z7bnugPV47vJePLnNz8Sbve/Z9vCf5HmzTJtQJUfIGXW6BZEDlfoThlQow3exJt7t+WEKhkJrZKUAxDEPNCpU5p3NzcxSLRaV5RHvo/sfDZCqA4fMNhrhLAknnH6rVqpqwl8vleOSRR4jFYpyennLt2jV1AkTbSDha6Q0jlGvpawOq/EaK/lkfIz1a6T3OusrCNRoNsqEsF/0Xudu/yxxz3Fq+hWd4XF+5PhiL4PNo2S0VmZiOyWMHj3Fz8Sauz+XWwi1qTo2/8Yd/g+hulPrFOjf/0U0yMxkymQzhcFg9ilzuQXyB8R+Z16nXYBiGoQbISt3J6ekpruuqQ+Tz+Tg4OODo6Ih4PE46nR7pwp8kUwEMGW0op0KiFH12RSaTIZFIqKccyb+ND/9Qsyx9cTbjm1yrvZZUayfpr/XphDoqBT6eTJP/Fj9E/JvPRj9Lza1hNk0+f/x5tjpbXApegj7sODvYHZtWsMX6yTof/8OPE54P88t/95e5b9wnUUuwYC8Q3Y1iuAbRu1HCvbBKjInfIIU+Qq5JSCnmAQb+loxakjHUp6enak6oPq0YBk6oPDFBqtCq1aoyvVM/tU8YRz1BJs80c5zBIHgBRSAQUA+E0Z+HJg6cTmM//+TzlDolIm6E2ptrtO02nXaHZqdJzs7hq/sw0yZ+axj+6UPc9A7yuBGHBLww/wKnzVPCbphmq0mpXSLRSFAIFIjPx2k+1sS6YPHrx7/OX938Kwp7BQ6WD3h0+VHi+3EqSxWOO8d0b3VVtCF+kgBBHFGpmZCoSyKRZrNJJBJRQ92Akcp18dOk6l6auJvNpvpsSdM/TKYCGPV6fWRUoRTurK+vY1kWuVxOjT2Sk6Y/FE9S13oBLwDeoN+j3+/jJlyctsNnDz/LVnuLjeMN/un/9E/pX+lT+0QNK2iNcATCKejieR4GBulAGhicSMtvQRRyvZzyB2ZmZwjlQly+dJlXX32V/f19vvrjX6V/2mfmygwWlqqZkIErekJMJ6yEqpfNFXZYIgxxWuX9EtILLySPDgfUuMhJVPq4TA0wYBCepdNpZmdnmZub4+LFiyNTcSTEEspcag4eVkA7XgFVc2uqrO5G9gaVUIXU7RRu0aU/M3yumr5J4+ygXo8prKP8v23bBO0g7/ve+3il/ApPpp/kC2/4ApFuhKP4Efe9+ximoXIdQs2LZtQbmASkck1yGARM+XxehZ1ikqSqS8yKTNLRH3shn/1DMTglmUyqVv/V1VUSiYQqzpHeTOEq9GIaGFY+j/d36sUtMh5y3phnLbzGreYt1gvrJFtJWpdaNAINrJal3iunVZ9SA6MP2JN/k1BS7L4X8Xil/AqO5/By8WXqH6tz5btXWLm8QuUnKko71ut1NRBGz/TqNLae45HHnCvn+rWhdON1FeNRnaQM9L9L2eDryVQA49lnn2VlZYVOp8POzg7lcplisaiSPjKOUIpzZWiK9HuIvR2v4dR7RCS0e+7x5ziqHmEumex8bodepEev3hsBgNt3MWsmgVwAxx0FhvgFEu66rjsoRqbJkrFEOpjmydSTvFx8mSeiTxD/bhwcsO/Y/Ny7f45v3/o2Ozs77O/vj8xM12lqvatM76mFYZ3q+ENvJAzVNYEOEJ34An44TMny8jKtVovj42P29vYUeaWPHJRMoowoLJfLDzwZWW5eXxxRn2KrHcchSpRuoEs/2addbw8d336Phtfgrf/rW0nsJ6it1Hjll17BZVjXAYMFj8fjgxLDdovfafwOd527bDQ3+Bd//V/w/P/yPGfbZ2QuZfA95aP/gz720zYrT66QWE2wu7uLbdvs7++rpy6IIyl1JHK9eu2pfi/RaFSFsKLB9EhH17B6DYuwwz8UpuTk5IRyuczx8bEKTWVkMowmffTqJQHDJBkHh/48eLHBjUaDk5NBUU2v3+NPYn9CPpDn62//Oi98+QVi92I0D5u0Qq2RpJUeIdSoDdoAcLlRu8HZrTMiL0dIO2m8VzyiX4vSd/oEZgOUy2VmZ2dJp9Mkk0nu3LnD97//fXZ2dpRvILkfMZntdntkdJTMtNBzIPJb7+LX61n1tZNi4dcLVWFKgJHP59UCSBWzhGG6WtVzIqZpKrpXH7qiO4SignWVLNGPAEWqwJpmUw1Ku7pylWKkSD/Sp+AUBoW7DJJ9fp+fUCeEaZg0Wg3+Ze9f4lqDa9w43SD8yTCEgDYYbzAUqJyWox6fLc+gz2QyPP3001y7do3bt2+zu7tLq9VidnaW2dlZUqkUfr+fs7Mztre3OTs7Y29vD8MY9MxKbYfcO4weHLl/ycr+p7SELlMBDEHweEpZJ4CE45B/kwEgcvrlc+DBZhtAxfbj3eIyJ9NoGiz0Fzj0H5Lr5fjaT3wNM2VieAau59L2tUkH0vzIH/0I8XtxGhcbfOO//QZH/qPBd2Pwsd//GIZrQAtCfxDCuzg8qeIEyvA0yWX4fD4uXrzI6uqqMmnxeJxUKqWq4IUBPj095Qc/+IHSsNJRNl58o9+367qKGRWNKRnqqe921xtlpCd10k3qbKAsrnjYkiPRs5C6JpETpc+ukphe1PA/7PxDyp0yXsPDyQ4adRzX4c8W/4yT4AkX3Au88947MVyDyN0IvryPTCJDMVzkcvAyieUE3ATzCRPfo0MnTw9txV+AIckk2lHMp4SawlA6jkMymSSbzbK6uko+n+fw8JAXX3yR3d1dxRw/rABHn50h6wGvX943FcDQu7Slx1IWRBCumwDZXHnqUb1eV09GlHheRLSDhGmSUdQn6aiH4HgQ7AfpmT0cBk9TbvvbnAZP8QyPe757HKwdsHRridJCiVvHt3hH7R1ceeMVLs1eovPZDlF/lNBCSDl6YvpE68m16c9GlfsUulsOh4hpmqrbXhzPJ554go2NDYrFIltbW/z5n/85W1tbKhMdjUZVxON5HsVikVarpXJRenp/kkwFMCSSkDoD3YzI6RHtIfUTUtvY7XZpt9sjneB6GKfXTeqmRlS7iB61CC1u2zYrqRVWO6vsOrusGCvs/fQe+7V9rt6/SuWkwuzcLPOx+cGzQUJBfAnfiIbSq6YkNS7frxcky4nWWU95DpquaXSt6ff7mZ+fJ51Os7y8zM2bN7l+/TovvfQS5XJZ3bdwLfF4nMuXLyvTpD9ZaVymAhgya8u2barV6gOg0BdaRB5HXSgUVMOuaIVerzfyevHqZYGFWBI7KydZSDZp+JEo5P3B91NzawR7g9mgJaNErV5jYWGBH/3RH2VpaUnlVcQESI0EaKUAGhkl16g7iPJ6CckB5Vs1Gg0V1grxB6j7vnDhAhcuXOCZZ55he3ubq1ev8vLLL/Pqq69iGAYbGxu84x3v4F3vehcnJyfcv3+fQqHw0D2ZCmDcvn2bXC6nBqToi6WrO9EY+mgACe8ODw9JJpMj2VERvU9DL5cTR1QKX+SJSJKtFIbVDtpYjgUBVGY3m83yyCOPqNHUemebAED+X29w0u28XIMQZqZpqtkggMpx6K+VMki9pTIQCNBoNJTGXV9fZ2VlhTe/+c1861vf4saNG6rXRLKsp6enHB8PWx/GZSqAcXBwQDKZVC2H4ydJX3BgJIMoNvTw8FAVqWQyGfXZ4/G97sGLoxYKDcr6pX9FTqM0WesPwhGiKZfLMTs7q2y5XJ/enqA7xHphkJ6kEy0mIaX+4NxyuayesCgP1Q2FQkqjyfVI5AGoqMeyLNbW1sjlcmxtbXHt2jV2d3f5yle+gmEY3Lx5c/rbB9bX19WmTMpN6KLnFKLRqJqN/Rd/8Rfs7u6yuLioNkoWTXwHqZYul8sqSojH4ySTSVXfIKSSZG3FBEiNiFSsr62tsbKyokCjR0/6Cde1iaTYdYCPi/7c2QsXLqjXisOt+yDyXZJelyowAWOr1SIWi/HUU0+xtrZGo9Egn89z7949lpeXX3dPpgIYeiud3Bw8CAy9l0Iql/L5PI8++iibm5u0Wi3K5fJI7YZssD7TU3pXIpEI6XRaLbZUjAv5pV+DhL+isqVzXDSc7vyOb75oGSm90yvFdCpf3qNzOrroHXuiIfS61UgkoqIdz/PUvQjQhBuZm5vj6OiI09PTh+7JVABDjzhEa+gMpy5660A0GuXw8JC9vT3e9KY3cXZ2xtbWFnt7e1y4cIFsNjsCLoloZE6EmBDpQhPw6FXrMGykLpVK1Ot15ubmWFhYGHmo7Tj9DEP+QDdD+v3oNPt4S6L+GZ1Oh0ajwfHxsapw8zxP1X9IFbieJBsPlcXPkahrcXFRPZB4kkwFMGC44XLCXu9BbqJhcrkcR0dHfO973+Ppp5/mbW97G1euXOFb3/oWx8fHKvSVz3ZdVzmX8vmNRkM5ZTKIVk/Xi9oWjbC4uMjy8vLIEw7GU+V6HYgeiYjZ0XM/4sPIfYlWKBaLlMtlpal8Ph/hcJj5+Xnl10QikRFST75fHgmmay090pPXTv0z0WSYh8496OpVP2XjKj4ej3N8fMxLL73EI488omL7Xq9HsVhU6Xix+2LDAVXqJsSZfK44nYAqfpHXJJPJkZ4OuZ5JyTwBha619DS7hNmu67K7u0ulUuH09FSF07lcjmg0ytLSknpgj+6I69T/eE2GXpQjf5NDN2ka8rhMBTDkofR6OZ0eVgIP3LicYJk+J88hC4fDZLODR2ofHR0ph1NaHn2+weMvz87OVLgm45XFRkv5veu6lEolpern5+dJpVIsLi4q/0XXCOPhKgwfuGuag6c4y6bk83k1YK5UKqlHfIl5W11dZXV1Vc0BE45GTwrqg1P0tdGBoleiCWD0Zq6HyVQAQ9/0SWSWrv70PIKErYlEgp2dHQqFgnJehQ+RuL1SqSgzIlpAaPVUKqWcVBlDLXxCKBRiYWGBxcVFLl68CIw+H12ApoNhvEG5XC5TKpXI5/NsbW3R7/e5fPnyoD50ZoalpSVVf6JrFDkcQmKNFwzJ54876bLhuonRNYw4wFPfcCT07rhzJouh22pdq8jf6vU6uVxOZU+r1ap6vyyqgEmqv1ZXV1laWmJtbY1wOEy1WuXOnTvcvn2bl156SdlqvZVAnvuh96HIJor2GC/LEx9HHMZut8v8/DxvectbFCMrnIx+2iWakIMizut4UnEcFHJtOnDkt76GPxT1GOM5kkkybmKENNJtuIBkf39fmRn5/EwmM/IoymazSaFQUGasUCiwt7dHqVRSORj9QcDi4esOpMj4RugAlusIh8Mkk0muXLlCKBTCMIyRx4/L9et5GgGD/jNO0I1HQ+O9rPp66cShZJgfJlMBjPF0tB7T6ypavyl5nzzbDAaPz2q1WpycnGBZlnrioGVZnJ2dqR4LKcWX8BZgf3+fXq/HzMwMP/ZjP4ZlWezt7dFsNtUjtW3bJpPJjCzouDM87tCJT+D3D54snUqlVG5G51ZEJMSV+9RTA+NA0CMgAYqYV/11Yop1jaZneifuyf+tHfz/SKRKGiY/ClM/VaJ6JRsqYx0ty1JPGsxmsyN9FZ43eCyUFMaEw2G10eInzM3N0Wq1WF1dZWVlhVAohN/vV3kLeUSGOKJiq0X0E6mzkvpp10kwiZAmFfzq79c3+WFp8vHIRA+x5Wc8S61ruUkyFcCQzR5fCFlY/XWAKtWXvpJoNMrJyQnJZJJkMsmFCxc4OzsDGAlPJQHl8/lUE7UeWRQKBdUeGIlE1PQeqQ+dmZnBNE2Vo4HRUc4i+kbKaRazIT9ynwKOcXMk/ov+OfJv+m9980V07TFpvMR45DJJHg6Z/8wiFLD+W/fQJWcxvkCSFc3n8yqNvLq6yiOPPKLS1+32YGpeoVAYaWvUI5dOp6PGQ5+cnHD9+nXq9TqFQkGFipLPAUZOnq4lRGQzhfnUU/K6+hdgjW+Urn1e70fWYpxkmyQ6iF+Pw4Ap0RjibOknbJIDNb5YsujpdFo9PrJQKKghK543fDSUmAGp+JJMpTiwEq7mcjnW1taGKffXakTEKZRElmz0OBcwHiICir7WRQeE3JvuK8jnihmUVkbxbwRIusnVP1deM/5d8jdpWHqYTA0wdFs8bkJExsM1GNx8Op3m4sWL1Go1Op2O2sgnn3xSRS/ymElJtInjZZqDh9zKJgtnIYm0e/fucXx8zIULF9Rsc71QZtJ1ivMs/sPD7nk8stDvcTzxJsywDsRxp1w/WLoW0n0MWb9IJDL9aXdhL18PFDA5bpfHRqbTadUcLO1/UisqQJF6ypWVFbVA4rTKzPJsNqvIrTt37rC9vY1t2zz66KMj4Z5u98dF30D95D8M7OORhvhSQrTpNRsPS9nrn61rVPGjxLcYN1cPk6kAxiTH6mGLOC6SMRzvtJIhsjKQROZsSNpenEAp0Gm1WjSbTXZ3dymVSoNmoloN13WZm5tjZmYw+m/cydP5DFHtOq/yMLuvb6y8Z5y+FsdY77jT12Lcz9CjHxjOFNdBoV//65kS4z/lhJzL/z9laqKSc5kuOQfGuUyUc2Ccy0Q5B8a5TJRzYJzLRDkHxrlMlHNgnMtEOQfGuUyUc2Ccy0Q5B8a5TJRzYJzLRDkHxrlMlHNgnMtEOQfGuUyUc2Ccy0Q5B8a5TJRzYJzLRDkHxrlMlHNgnMtEOQfGuUyUc2Ccy0Q5B8a5TJRzYJzLRPk/AXIP7tFL57MhAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIYAAACBCAYAAAAFfMIpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztvXmUZGd55vm798ZyY4+M3Cs31Za1qlTaKBCyGcDdYOwDwsIGpm3WxrKh2yCJc3DjHkYDp6EthDHQshsvskEGe2Dsg23ATU9jeUBeBEIgSllZS9aSe1RkZux73GX+CL1f3oiKrCpJnOnUnHx18qgyMrb73ed7l+ddPs11XXZkR7pF/5/9BXZke8oOMHakp+wAY0d6yg4wdqSn7ABjR3rKDjB2pKfsAGNHesoOMHakp+wAY0d6iu9/9hcAOH78uKtpGo7jqMd0vTdmTdOk1WqhaZp6jqZp1/wM27Z7Pm4YxlVf52WGvZ/jui6apqFpGj6fD9d18fl8aJpGX18ft9xyC9PT00xMTPCXf/mXnDp1Sn2HYDBILpej2Wyi67p6L6/ouo7jOFiWhWEYaJqGYRhYlqU+x+/3EwwGAQiFQtTrdRzHodFo4DgOjuOo7+/z+RgYGCAej5PP56lWq7iuy7e+9a2ei7ctgHH48GG1EFeTQCDAzMzMFY+/EFr/Wq/1fqdeIBJwplIp1tbW2Lt3Lz//8z+vrikajXLXXXdx+PBhlpeXmZ2dJRAIkMvl0HUdwzCwbXvL6zdNE9d11U80GlXACAaDOI6Dpmm4rkssFsPv99NqtWi1WgBcvnwZXdexbZtAIICu6wqMzWZzy+veFsAol8tqx/TSGo7j4Pf7cV0XXdexLEs9vpVmeT4i7ycL1y2yY+WGaprG2NgYjuNw6NAh9u3bx5EjRxgbG8N1XarVKo1GA4Cbb76Z/fv3s3//fk6fPs36+jqNRoN6vY7P51Of7/P5sCwLx3EIBoPYtq20kd/vp6+vD5/PR7VaxbZtarWa0g62bePz+QgEApimiW3bJBIJ6vU6fr8f0zQxDEOtsXxuL9kWwBDEb2USDMPANE38fj+NRuOa6v/5ihcUckNM0wTa2ioQCHDnnXeyZ88eSqUSR44cYWpqimAwiGEYlEolCoUCjUaDlZUV8vk8pVJJvb9pmoyOjrJ//35e/epXUygUuHTpEj/4wQ+Ym5vDNE2GhobIZDJqTQzDwO/3E4/HCYfDWJZFuVym0WhgWZbSDKJxWq0WlmXRbDaxLItgMEggECCZTBKNRsnn81QqFXRdV6/tJdsGGHJhsiBekZsl2uJqSH+hIuAYGBhA13UajQb79+/n+PHj3HLLLYyPj6udPjAwQKlUotlsUiqVWFlZAWB9fZ3Lly9TLpepVqsMDAwA0Gw2KZfLhMNhBgYGiMVinDhxgr1797KxscF3v/tdDMMgEolw7tw5DMNQGmBwcJBSqUS5XMayLKU1DcPAdd2OtbNtm3q93qHhUqkU5XIZXdcJh8O4rovf799yHbYFMIAOjeHVHKK2RVWKA+d9rjhbgUCgw7xcj98ioBN1res6yWSSn/7pn+bo0aMEAgFuuukm4vE4Gxsb1Ot18vk80Lbfa2tr6oaUSiV8Ph/5fJ5yuaycZLlxAnhN00in08pPiMViJJNJDh48yNmzZykUCgwMDDA7O6u0lm3bypx2m1tZE/mbrIFt28o5LZfLJBIJLMsiFAoRDocpFApbrsu2AIZXW8CmQ2gYhrpAMR/yN9d1CYVC3Hrrrei6zmOPPcbU1BT79u3jhz/8IZlMpsPkXC1yEeAlEgkOHDjA3Xffze23347f76der1MulymVSpRKJfL5POvr69i2rSKDUChErVYjHo9TKBSU6ZNIwu/3qwgEULtd13UqlQq5XA7HcYhEIiSTScbHx3npS19KoVDgBz/4AUtLSxiGwcrKCtFotMOv0DSNer2ursO2baUlJKqR5+RyOUzTxOfzKXBsJdsCGNB542SXeZ0yCQ01TVM7xOfz0Wg0lCnSNI1CodCxg+Q1XpB0h67RaJREIsGtt97KHXfcwfHjx5WD12g0lF1eXl6m1WopZ1jet1KpYNv2FX8LhUIEAgEMwyAajVKtVrEsSzmDPp8P27ZV6Cj/bjQa1Go1hoeH+Zmf+RnW19f5p3/6J/L5PNlslkAgoBxUWQcBm1e8WrjVatFsNnEch1AohK7rSpv0km0BjN/8zd9kenqaCxcu8NnPfpZUKsVHPvIR7rvvPmq1mlL1ciPEdpbLZebn59X7LC0t4fP5cByHZrOpwjPROAI4AZGmaZimSV9fHyMjI/zcz/0cqVQKx3FYXV0lnU5TLpdVyAebkYPrumq3C5fh5VWi0SjBYJCJiQlSqRTNZpMf/ehHrK2t4TgO1WpV+QcCbNd1KRaLFItFXNdlbW2NwcFBTNPktttuw+fz0dfXx+rqqgpJxZcQMytgEa3hNaf1ep1du3aRSqUIhUJXDdW3BfP5yCOP4DgOn//858lkMvzsz/4sc3NzHDp0SO1uWXSfz0epVKLRaDA8PMzw8DAjIyOEw2HGxsYYGRkhHo8TjUaxLEu9XjxwIdJkUaLRKOPj47zmNa8hGo2i6zrZbJZ0Ok2hUFA71LZtGo2G0gqizsXrF2CI+RPyKRgM0mw2qdfr9Pf3E4vFiEQiAB3mU1R+OBxWEUM+n2dpaYmVlRVM0+TGG29E13UCgYB6vYBcfvdem4isnWwK0XLlcnnLe7ItgCHIFrV7/PhxvvOd73DixAlM01QXEwgElHoeGBjg0KFD3HrrrYyMjBCNRpmcnGRqaopUKqUcO9Ew0WiUsbExbrjhBnRdx+fzEYvFOHDgAK94xSu47bbblGO5sLBAoVBQN180gkQJ0On8Chh8Pp/6gTaIm80mtVqNdDqNZVlEo1EikQihUEgRVaLhWq0Wuq4Ti8UwTVNpxVwuRz6fx3Ecjh8/Tjgcpq+vT2kDcb5lLbtF/A7LsqjVati2rcC6lWwLUyKLOTw8zJ133sn6+jrpdJpbbrmFsbExLly4oG7K8PAw/f39VCoVKpUKrVaLvr4+pqengfauGRkZoVKpEAwGKZVKzM3N0dfXx+DgIIlEgkuXLhEOhzlw4ABvfvObmZiYYHV1VYWhuVxOqXixw0Iwec0R0GHrvX5Qq9VSZiESiSg1bxiGIq7kMfndG21Eo1Fc16VWqynnOBgM0t/fz6te9SpmZmbIZDK0Wi18Ph+1Wg3Lsjr8Ctd1lSYSbmN9ff26eKBtAQzLsnj44YdZW1sjk8nw2GOPkclkeOihhxQ3ACib6rouyWSSwcFBtePEj6hWq8peh0IhtdvHxsaUGheeYnx8nD179iibHQwGqVQq1Ot15Z/IQgvZ1C2ikUTrecEBKGe5O9ISkImJk/f28jgCxlqtpviLZDKpeA3Z8V5wyu/d4iXA0uk0pmkqk9RLtgUwHMfh1KlTtFotAoEAq6urxONxLl68SK1W64hENjY2MAyDVqvFysoKfr+fcrlMs9lUfkW9XqdUKpFIJGg2mwwNDZFIJIjH44omFp9AvPN6vU6z2VR5i+4bLAvbDRABjjikXhGt0mw2lfPrjb7k/bzOp1cEdOLTGIZBs9kkFosxOTnJwMAAS0tLHdrG+2+vIxoIBPD7/covqdfrVw3htwUwUqkU6+vrtFothoeH1c3y+/1UKhWKxaLaFeLJVyoVZmdnyeVyytkUWy109OjoKPF4XC1qIBCgVqsRDocZHR3lXe96l7ph4XCYS5cuUa1Wgc2QNhgMKqBsRZYJXyDidQi9IbbceK/p8foE8jz5u2wUv99PtVqlVCqRTCZJJpOMjIzwpje9iUcffZTFxcWO7yNhqYTc4jzL+4nvJERdL9kWwMhkMpimSSwWIxwO09/fj2EY5HI5ZSMlVpcFl5B1fX0dx3E4evQoqVQK0zQplUpsbGwwMjJCIBBA0zRKpRKmaaowMR6PE4vF2NjYUE6eqGavtvDuci+FfLXdLq/pBoiXnPM+zxtdeMHnJbFM06RQKFAqlVhfXyeRSDA8PEwymWRhYQHY1AwSwgpg5T0Nw6DRaBAKhYCtSxFgm0QlsgBeMkhCNi9lDXR48hK/12o1qtWqUufBYFBFM9BegPX1dSzLwu/3Mzw8zOte9zp0XadUKqHrukpBy+dIJCQ/3fmZXuARMHjDQ7m2bhEHtvv5vZ4nWVMh8KrVqiLJXvayl6lUgIBQNlGr1VI+TbVaVb6YF7BbybbRGJOTkyQSCYaGhqjX65w/f15RxXLRclFe7SEXu7S0pBw1SWytrKwQDocVixiPx4lEIliWxbFjx4D2Ii4uLirN4431/X6/AgZsmgDRFN7fgQ7t4tUiV9MW3lqLXsDwZk8jkQjZbJZMJqPCz6NHj3LzzTfz/e9/H2jnRIrFIvV6nVgs1sH+NptN5VsJl7KVbAuNUa1WlY8RDocpFotks1mq1SqtVkuFdnIzRD2KKnQch0qlwvz8PJlMhmKxqEyTVEDV63UajQaLi4u89rWvBdq2uNFoqLDX68AJN9DtK3Rrh25zI+K9yVe78b1e6xW5Ti+fYlkWjUYD0zRxHIef+qmfIhAIUC6XyWaz5HI5leMRADUaDUXJ+/1+IpEIQ0NDW37uttAYEq8XCgVyuRxLS0sUi0UFCu9ukx3tXWShh0ulkiJz/H4/a2trBINBpdLX19cZGxvjwIEDyqEV9k/Cx155FhHv54pf4HUkt6KYvaAQbsGrbeQatwKOPEeeL6SWMLvDw8NEIhFWVlbw+XyEw2EVYUn9SjQaxe/3Y1mWyu3EYrEt78m2AIZQtLVajdnZWS5duoRt25RKJfr6+hS7KLtGiBzTNDFNk3A4zG/8xm9w8803dySGvPyGpOfFOU2n0ySTSVX/YFmWikiE5ezmA7w3V8yON4/jFa9/I99BbL43GhEgd4Oi+3d5H4kwAAqFgsp5FAoFxbI2m82O0j2/369qMMQvK5VK25/5jMViaJpGIpFgbW2NSqXSYdcFDF6TIo9VKhV8Pp/KWXhtuLciS9M0taiSKi+VSkQiERqNhrK9ctPFt/DeoO7SAK/T2A2M7oSdN9SWv8v/BfRbOane9/T7/Sp9IL6QaZqEQiFFAIZCIVVSKKZXTKplWWSzWcrl8lVrVbYFMDRNIx6Pk06nWV1dpV6vqyJYuWmmaSqeXzKoXsbxiSee4MiRI1cU63g/A9o7WehjCWHlfb3spPc9HMvBzbv4Bn3gAjnQ45tmxZvF9JogLz3uLaDxkmGtVusKkHVXsnUnx4RbARSx9/rXv56TJ0+i67oi/ERc1yWdTqvvKJVw276CSwCQzWZZX1/H5/MpWlqQLuq4W8Vrmka1WmVubk6pUG841h3uAgoYXpBIlKPob81Ay2vQD/r9Ou6Mi3vk2feYAf2ITusTLZyCgxN30PRNTkKcRLk2L1+hzJtmQAH8/X7WamvE3BhGyUBP6Dh0Zki95krqVLxle81mk6mpKXbt2sXGxoYqE/BqIa9/JuvWizoX2RbAEJufz+cpFouq8FYqqIeHh1Vc7t2lgLK7+Xyep556ijvvvLPjvbtVsTiq+XyeZDLJxsaGKpxVWsaB2EdjGKcNmAb3rItmazjPOOSjefrsPngGuA8qqxUiuyKsf3idmq/GgDmgHFkBp0qYWQ6VlQrNUJPAZwIMzwxz7z33Mjs8y+HMYT71+U+xcXQD995nQVBwKUQKhN1wx04X7Sbhe7PZJBwOYxgGw8PDZDIZdb1e0yffpdfadIt2tT/+fyX79u1zhZEUNStOWTKZVMW03d65N2chVUnDw8O84Q1v4LbbbmNycvIKs1KtVjl//jy1Wo1IJMLi4iIbGxuEw2Hslo1e0nEdl4H3DbTBoDtkb8ySfCbJfffcx6mBUxxZOMIDf/8AD7zqAWYmZji8eJjKVIVL2iWmQ9N8bO/HGBkeUbvUcRwW5xcZ/eQo2qzGB371A8wOzjK9PM3ZsbPYho1u6xxcPsiZsTPs8e3hU1/6FP/xjv/IzOQMe8293D9wP81GU5miQCBANBolHA5jmiaNRoNvfvObfOc73+H8+fOKFu/l/4g8u57bt+HIyzrKhXi1Q7fNBVRCSJxR8fjX1tb4yle+wje/+U0+/OEPs2fPno5oolarAe12AKlJsCyLVqNF6j+l8J/x09zXxDpgoZ/Rufeee5kZmmH89eMs6Us4msMzU8/w17/018yEZ7B1m5nJGdDAweFs7SxFq0h/q199Zrlcxl/1Y8wa5EI5ZgdnsQ2bM2Nn2Le+j3ND59i7tpczY2ewDZvzznkuFy4zM9F+/7nmHOu1dWJarCNdn0wmlamIRqMq3BcOxmt+nqtsC4LLW2Ti9/tJJBIkEgkVevZCfLdDJtR4o9GgXC6Tz+f5zGc+w9zcXAcZVSqVOhqWoO0AWhsW/tN+NFsjcC7A2q+tMfPgDDODMzg4LOgL9Df60VyN4dYwg/ogo+4ouqszoU8wpU+hozNtThMhoqq9Wq0WtVqNulmntrdGspbk4NrB9uucCX42+LO8bf1tvNJ9JcONYTRXY7A+SFSPcmTxCIZjsMe3h7Adppwv02w0Owp+K5UK+XxemVRv6NvNqvb62Uq2hSnp7+93ReW+8pWvZHp6mo2NDVqtFpFIhNXVVVVRBVyhOaT4JZFIoGkaa2trAKri+n3vex/79u1TC/nkk09SLpcVI7qxsYHP8DHy2yP4z/lZPrDM3JvmKJaKfCX0FdKBNOPuOO/U34kVsIi4kXa3V8gkW88SckI4rkOFCmOJMaXexQGV5Fer0cLNu1QCFapalbHkGD6fj0wm0+YUNFjKLdEX6Gs7v0WNSrLCeHKcr6S/wuzALAfXDvLWsbei6e1IrtFoqJrVr3/96zz22GOcP3++gzS7BrO6vU2JeMmO4xCLxRRZY5omiUQC27apVCodDpU4YsFgkKNHjzI5OUmxWFTqdG1tDcuy+L3f+z0eeOABxVmUSiWy2azKQ0jPRfpDaf7z8n/mnH2OcWecdyTewb3ReyEMwWYQrahRN+o4tkMffSSGEkyZU1QqlXaupdSum5DwWiIicZzL1TLRVJTR2Ci1Wo3Lly9Tr9dJJBIqvX4kfoREIrFZUINJtVRldqBtfk4PnkZzNPzBdpW5FB5Vq1VM0ySZTF4zQXY9si2A4S1JEx4/HA6zvr6utISAQNPa5XbRaBRot/2JyZHqLSnWEZUbDAZ54okneNnLXkYmk2FwcJBwOEwgEOD06dM0m802BR9occ4+h4PDkrbESmGF0EaIAX2AA397gOh8lPqedgVZ+GIY+5DN997yPfxBP/39/YptbDabqhi4m0LXNI35+Xn6+voYGx0jWA9SDVRxHRejZFB0i1QqFQKBgKrrbDVbHFw4yOnB020zNNkORYeGhpRDLqUG8/PzHT0szxck2wYYwgBKJ3g8Hmd8fJxqtcrg4CC33XYbly5dUv0YkUgE1213eEsSLBKJUC6XVdVXLBbjV37lVwgEAly4cIFLly4xPj7O5OQkpmmqaiiAPXv28OMf/5gpfYp5Z55JfZKXHXkZo58cxTxnggsaGsHzQfLRPGEnjHZKwygaBMeCVKtVnnnmGXbt2kUsEmPt7BqRsQjxRJz+/n5WVlZwHIdsNtvuKLNdJj8ziXneJH04TaKeIHQhxPKhZeZ/cV4V2ABousa/mfg3rKXX2H1oN47rKGdbOJ6zZ8/y9NNPk81mr8rhXK9sC2B4CSBo73wpoDVNk2w2q0rvBwcH8fv9bGxsqB15+fJl1bArtlV6TrPZLPV6nYmJCSqVCtlslmQySSQSUdlVn8/H/Pw8u3fv5s3fezNmyiSqRamsVDDnTDRXw9ZssuEsH/ulj3Fq4hSHFw7jai4z5gz7z+7n3079W8bHx5k9NctLvvwSzDmT6r4qp99/GqNpqNzE0MAQbtElnU1z09xN3Pv2e1XIq92p8czEM4xZY7w9/3ZyRo5kX7KdKY7HKJaK+Pw+FZnkC3kc06Ev0EcsFuMd73gHmUyGL33pSwqIz1e2BTCE3nYch+9///sEAgF27dqFbduqjS6dTlMqlZiYmEDXdYrFIkNDQ4TDYaLRKI1Go6OVUaqnpbnY5/ORSCSUA6rrOpVqhYJdIOpEMcoGNbNGMBDkwHg7+9rwN8juypJYTnD/2+/nmYlncHQHNDg5cbId02lwdvAsD1cf5kMjHyLuxDHn2nT+h1/+YWbWZthv7ueX+36ZhUsLHPviMT7y0x9hZnKGr7/765wZOwMaPDP1THsxNFhyl/ir2l/xwH97gB+//cckk0nVViglerZj8/GVj3O+cZ5D0UPcY96D1WpHW3fffTdf+MIXKBaLzxsc2wIY0i2maRoLCwu4rsvc3NwVOQhANfZKdZckvwREAgzLsigUCkxNTSmGsFgssrGxAUCtXuMj5z/CTGmGw5cP87uf/13qe+pU3lBRoXK9Xqf80TIXVi8w05hpg8IFXAi1QtSCbf8HDRZYINfMkdqTorqnSj1Tb/MQ2JytnyU0GsI4aWCtWYqfODt6tveCaHBm1xmMosGu0C7i/XGKxWKH35Bv5ZlrzuHgcKp8ilOXT3Hp5CWCtSB9u/tIpVIdIxie8z153q/8CcrevXvZu3evygQKgSM9nMJZeItOxOmq1+vU63UFDukNsSyL1dVVFR04TrtpOBKJsLa2xmphlVOlUzg4zA7MUggVCF8I08w0FatqGAbhaJiJPRPsC+1DQwMN0KDpb3Jw/aC6hj3GHm472G5aOvNLZwh+Nsih+CEMDA6GDzIcGWb/7fsJjYY4stTmJw6vH+bG+RvRHZ1j88e4cf5GBbwji0cIDAXQUu0akWQyycrKivI7EkaCvYG96OiMu+NMJid554/fyb//zr/nNd96DeXi1l1m1yPbQmO85CUvYW1tjfPnzwOdGUagQ2NIBOMlxYTcqtVqHcU0Z86cIZfLqSgnEong9/vJ5/PklnJM6VNcci5xaP0QyVqS1oEWWp9GJBJhfX1dJcNM0+QTBz9BySnx4IUHOV05zbQ5zX3H7yPbzDI4MMhd/+ouvvIXX+Hl/9fLSa2m4Ag89OBDnCucY9AdpNVqEU/Emfv1OT4U+BCnCqcI7wozEhqhkqyw7//cR+BcgNWjq6TfkyYRTjB/yzw4UCwW1VoI1W1ZFu8y3kU1VCVKlGgzSn+6H93VGUwPQmAzgXc9fEa3bAuCa2RkxBVSCq6sb+iugdgq8+h9rvAhr33tazl8+LDiQ3w+H9lstq1mNQgNhIg6UcyGSWwiRqFYUC2OojXkPcvlMs1Wk3wrT6DZ3rkDAwM4jsPu3bt56ttPcfB/O4jmaDiGw72fuJeZ6gwHwgf4D7v+A83GZigrzmiz2Wz3uPqDBOtBAkMB0FDztaQTfnZ2luPHjysaX4awWJbF1NQU1UqVPZ/bQ2whxrnAOT7gfgDbsa+oDusGx7YmuCTE8gKg++Z3i5f2lf97ayBc12XPnj2qKCUej+O6rqqFbDQahMNhYloMzadBGGzHZmhoiH/+53/mFa94hSrDF2rbtm00NAbMAYyIoRJ31WqVdDpNI9TAPmxjzBrkb80zU2v7GKerpyk5JUJ6+/lnzpzh4MGDHWOcZD5WMBhUlH0+n1fk2OjoqDKVgMqqOo5DLpdrh+T/7gIXf3iRP/jqH7RN3guQbaExDMNwvSpPpLvYxov6XprCG/L6/X5uu+02kskkQ0NDHDx4UFU5LSws0Gg0uOGGG0gkEri2i17S8Q34CEfChMNhnnjiCQYGBjh69KgijLwTbVzXJRwOUyqVuHTpErlcjmPHjqE7Or60j/DhMO//4ft5uvA0AIfCh7i//35azTbbOjMzQyqVYmJiQpF0oVCIUChEs9kkl8sxNzdHsVhk//79qr1QTGmr1cKyLapalT5/H5VKhd/5nd/pSKDJ+nhNsYhHs/aE0LYARiwWc70d21t9p26NIP5FdzEMtKuwbr75ZlKpFH6/n1QqpWpCq9Vqm0RLxCEEh373EJELEer76mR+M0PAbI81kMr13bt3d/Sq2LatIpzFxUXi8XibhbRdBj4+gP+sH99NPvKfzPPGx9+I7doYGDw4+iC++mbvSyaTUZN/hNr21oXEYjFl1qRmRDLKjWaDR5xHmHfm2W3s5hUXX8HffOFvyJPHduwOk7EVyfXsem1fUyIpcLnhvfow5N89bGRPp8p1XcUyplIpLl++zMrKCnv37qWvr49AMMCnc5/mUuUSR+88yqfPfxpzzsTJOdhD7fLBwcFBoG3qhO6Whh/XdUmlUhw4cEBFT2bNxH/Gj+Zo2E/bJEoJbkzcyMn8SQ6EDxDX49S0mgrNp6ammJqaIp/PK20gxF4oFFLDbqUyTfIumqZR1arMO/M4OFy0L3LP1+7hrfZbmWGG+7jvBZuSbQEM2Sm9ageuUWTS8bv3tY7jqKboUqlELBbjH//xH3Fdl71799L0NblkX8LBYWZyhlw0hzlsYkUtrJqlQlZpUhKeRHIeApTl5WVF5ZsJE+uAhe+MD/1GndhkjE8lPsWl8iUSjYRqVRB/pV6vq5ZMqVrz1odKy6HMs/Ca0ChRJrVJFtwFRmujHM8ex4ePIxwhSZI8+Y616bWmV7MW2wIYXpsocq3QqltVeh/v/l3XdeW0Pf3000xOTuJ3/ezx7eGCdYHdgd1c/tBlSILhGgQDmwNXBIDewWeu226qliYeqdw2dAOXTU2Xz+d5/1PvZ7Y8y35zP++Lvg9cOkxGrVZTU3fks2Q9ulPn3gYrXdd5u/t2ym6Z//Hf/genOMURjjDDDDly8AI9hG0BjO7i3ucqV/NJxBcJBoNqcdfW1hgeHuYDfR8g18yRMBJovs3dKMW2EpF4C3vF1kuoKI/XajXqq3Wmz0yjORruMy4Xzl7gVLlNop2tn2W+Ps9IdERFM95uN69jK76SaA8Bo7d1Atr9L33RPm6+5Wbue/o+kiTJkcPFbZNxL0C2BTC8zcvXEq/zuVVsLuK6rkrFi62u1Wp84xvf4OUvfzmHDx8mbsQpuSUSVgJfxQdJlNfvbVWQUsJWq6VaJyU13mq0aK23WHFXuLTvEpNzk1R3V0nX0uw2dnPRvsioNcr8yjyV/gqHJg4xMDCgMsHSGxMKhfD7/UprdP94pdk3vCfgAAAa0UlEQVRq8ifOnzCfm8fn92EEDHKtXE/f7PnItgBGN9P5kxTx8GVYiDTrPPnkk4xPjPMHjT/ggnVhM1+yt87Ghzfa3AaboPPS9KL2w+EwQX+Q5ANJtFmNh+55iJn/dYbd7MZxHC7lLzFuj/PrrV/nb/1/y1cnvwrAdGWa30r+lirqlcmEktPpFUV0d77V9ToLzgKu5tIabtEf6ifbzP7k1u0n9k4vQERFXo94eYRria7rDA4OcvToUY4fP86RI0cUb3DgwAFs0+aCdaEzX3I+3NYcbJb9e/MytVpNaThN0/BVfBizBoVQgVMDbbNx0bnIvDuPq7ksGov899x/Z0lbUt9rrjFHwSoo7Se+jAxo6+7XlY4zL68T1drOp47O4cxh/rzw53yaT79gEyKyLTRGdwb1JyXCCuZyOaLRqKquMgyDw4cPkwgmlAN6aK2dL6nuqdIMN/F5lkbUuADD225oRS2caYfk6SRHFo+o2gpLt5idmAUNzg+f58DyAfX7vsA+wk4Yy92cxdndIORdG9icGe6dIX6PcQ+apXH7H96Ojs4RjtBHHzktB7wwc7ItCC6/3+++kKKSqzmfsViMffv2dQwMsSyLu+66q80hFPJU3AoxYgSqAdykSyQaUSrd6xR6M7mBQEAl5Xyaj+iHo2hzGus3rpNsJjFOG7z/3e/nzOgZjiwf4VN/+ilWj6yy9t41Ykasw0/ydr93s71Ax9Th7tMGBvoHGPntEcIXwsxoM3zA/QBo12gm6kw9bF/mc/fu3e7y8vJVR/9cTba6Bl1vHyQzMTGh+jmlzL6vr4+7774by7IIh8P4A36qVEkFU2oUkXeqnTikjUajQ7VLgZFrudTTdczR9gxxK2uxFlijWW8yEh3BV/VhRS3QNqf2Cji82lLCaxEvp+Ft6rZsi/XaOqZtkl3P8rU//Rob9ga2c+01vB5gbAtTIvWLXq3hdbR6ZVqvRyTs03Wdy5cvA5vVYrlcjj//8z9n9+7d3HT8Jr4a/ioX7YvsKe3hQ2Mf6uhyExrcO/zVyz/Yls3DJx9mdmCWQ08d4r599/HJ1ic5Vz0HwH57P+/vez8Vp0KgFejoPpfiZtEc3voR74+37MBxnXZEYszjz/jRHtXa3qJz9Tkdz0W2BTBkkMf1XNBzuWjpUPPOrPL6M5cvX6ZYLBLsD3Jx30VFL4c+G6L272qK05D38tL1jUaDzFqGtcIaQTuoyvtnB2axftti7p45eBZb51rneHDtQRbdRSaZ5D2B91BsFYn74hRaBRKNRMecL2/yyxueq/VyKyzQjkiaw038ph+7aHdc9/8vwlWxsddiPq/mS3j/7d1drVaLTCZDJBKhUqkoPsJxHJU1nfneDBNTEyzpSxxZPMLozCgXixdpRBodzqFUj1UqFTayG3zG/QzVeBWzYbJnZQ8Xdl3g8OJhPve6z+HqrmIfdVtnwVgADebdeR7KPkQ+ksdf92PpFsO1YX659cvEo3E1EUeuQzaMfF/XdQnaQSb0CRbtRY4uHuXdxXdzn3sfvkD7dgrL+0JkWwBDJtl4pRd5dT1mpFdeoFwuK23RnY2t1+vksjnunLmTj579KGOnx6jurtIINdDQrsjhaJoGFtgZm+pYFTSoB+u855/eQ996H7FajLfc/5Z2Esul3dNqdDrW+UgeNGjpLdAg7UvzJe1L/Krzq2o6nzic0lcjSTZd19HQ+IX5X+COr95Bf7kfR3N46aGXslpvzxaRZqoXwg9tC2B0T5v5SYn3Ziqn7dnF7c5Wnj17lsw7MpzPnSc5kMSwDXRX7+gTtSyLZrXJTQ/chFbXePhDD1MxK4SbYR498SinJk6xf3n/Nb/XqDZK2kkTaoaoBtvgShtpKlSIN+OKivem2cUxF8Bk7Sxlo0yf1sdifJHAUIBxZxzHcVQ/TrVaZXl5WSXg4Pp7TbZFVOLz+Vzgihj+hUq3py8aAzbHMQ8ODrJr1y5C4RDn7zzPsrHMlD7FPcF78Bnt3SvzR1utFu55l2OfPYaGRktr8eQHn8Qesnmg+IAaZ3Bg5QBnxs5gNk1qgRpHl47S2NdgrjmHHz9Nt8mhxUN8+k8+zQfe+QFOT5zmBv0G3uN/j/p+cmpSdyLNsi2Wckssn12mXqlj1k3qoTqO6yifSnwVGY9tGIZqy0yn06rd81k2d/tGJdIVtlW4erVM6rUe89aAyijEWCymmpf6+trVT7lGjiV9CReXeWeeRrmBHtXbFeHPkmLVahV9RMcxHfS6jmEajO8ab5+o+Cy5dWTxCFbQAvfZ7+ACDlhNCxeXBo12e8DYGcrhMp/7k8/xxP/+BNFkVJXuSdTSvWltx+aL2hdZGlgi7otz+PuHqYVq6vpkY4nvZNs22WxWHcExNTXFsWPHVCf+j370oy3vybYARiKRIJfLXfW4R5Fe9rL7MVlQNUPLM68rFAoxPT2Nz+ejXC6rEYiBYIB4IU4pUeLQ5UO8/A9eTvWGKnPvnaPRbKjSO5/Px4XfuUAsG6Pv0T7G7x+nurvKR52PYq1blEfKvPst78YxHGpmDTTa8zMclEOqaRoH1w6SrCap3FAhkoioDKswm95EmkjJKbHkW8LVXIqJIg2jQaC1eaiNPFd4D6EApDfXm6DTdZ1bbrlly3XeFsDoPmv0atLrOd3T87wciLetMZlMUqvVOH36tBo80tfX1x6NhMaBfz5ANBjlw49/GMMxiFyK4OQcLHOzC98wDHymD2PQIHAugOZohC+GqU5UiZfj+Jo+Dq61G5CDVpC6v87RhaO4uO3WxsXDvHHXG+nb38fMAzO4ic5ZFuIkd58/Yts2fstPqp4iF85xdPEo7/3Re/mjQ3+EQ+esLQGGd5pQpVLBddtDXKTGtJfTL7ItgCGD2OQskq00AHSOQfT+XSquZMeFQiGGh4fZvXs3Q0NDrK6usrKyQi6Xo1wuq3M/5JQDUfvFSpHcaI7+1X5KkyVIQsAJKHOiWgqiGs3pJoGzARq7G4QvhNFcjfhinE988xM0s02MPgMrZ6nIIRfJERgKMPfeOVzNxUlsjo0UX6L7eAvbsalSJUwYXHj9+dfzuv/7dfRX+nFwiFpR8nq+o5ve243nLfqRcLvZbKoU/1ayLYCRyWRIpVKsrq4CvWs7RYSggs7DX1qtFtFolJGREdWWCO3FmZmZYWlpiUKhoHiCUChEJBJRORCVvdTgoV0P8e7feDfzxXnclkvSlyQYDFIoFNTZ6pZtUftPNcrZMk7MQf8/dPxn/Vh7LaJz0XaxTs3F2mvBebCnbdz3uxTDRQbcgY5oB+iY5CuTgeqNOn9h/gUr+gq77F08/LKH+dhjH+NO/U766ONi5CLr9jqO5SgfCjbNipgReUw0ULlcxrbtq84T3xbAyOfzKn7fqhDYS/h4B7XKjrjhhhs4ePAgPp+v4zgLOUbbO3RFVGkv7QPQslsc+1+O8dC3H2KuMcdkc5JfC/2aOpFZ3sN2bYyBdljb+EQDu2JjR23039LRZ3XsQzatj7do5ptYMQvN0vBZPpX3EO0gVWH1ep1avUamnCGiRci38qyEV3A0hxXfCqmJFGbI5L/s+S+Em2HyWh6r3nlsh3fdurWFbBYpWtr2k4EBdeO2ijDkpsr57sFgkKGhIeLxOKZpMj09Ta1WU4flSv3E+vo6pVJJqVqZIiyVWfK4t8jXsiwupi9yvn4eR3dYdBZZr6wTM2JqdIJkWdVEYVzseNscVD5WwSgZuEkXx3UgAbZlq7DZ6zfILq7ValRrVf7Y+mOWQ8vssnbxxtobGbVGWfWtcnPyZlKBVNvcai4Fo4DV2pxPCpsH6HhrQ+V6xOkEVNRzNdkWwJCFkZOOewHEdV0CgQA333wz0WgUTdNUib3jOEh2VhbbsizW1tZUVlUSVqFQSI1D8GY4YTPrGQgESD+Vboeg4+0QNJqIUvQXqVDBdmw1WzOZTKqeE8dxVCFPq9VCW9usz3Sc9mF3kqEV1S7haT6fJ2/lWY4t42ouq75Vqm6Vj+7+KP1/3E/8e3EyRzOUqiViiZjyx2T9uqMSEal39R511eso8G7ZFsCAzmIdr2qXY6qmpqZUmlu8d03T1LytXgfRyKLLLhKHS04tlFhffBVZLF3XefLck3z+4udZ+asVBvcNsvzBZe4/eT9pf5qR1ghvK72tfXNwafgaxPW4Aod3XLM4gLJDZfdalkWj2aBkl/C3/NiWTcAJsMvaxapvlVFrlJfe+FIm45P4vucDG9xnXIK7gm2f5tk6Vi8B5k3XyzrI9XX7ZjJ9eSvZFsAQdecFRSAQ4OjRowwODhKNRikWi6r0TW60t4BFXuvz+dTRll6/QjREN/UuWkNEejnmzs+R+kKK8eY4btLFzbhcnr2Mozlc9l2mWCvir/n5gvYFFrVFJpjgveH3EvC3eYVWq4XP76OqVXGKm+egCGgs2+LL/i+zElxhVB/ljY03ggu/WPlF3JbL9KFpjh07RjQapXRbifqTddzDLplMhhFn5Io1lIJlWU+vGfFuFkkLXCuHsi2AIWg2DIMTJ04wMjKidlWz2SSTySg2T3aFFNCKiF2VZl9p5hEwydhHOXJTFslbGOOtoqrX6/z9Y3/Pm970Jmzb5gbfDR2mpS/SRzacZZHF9hxQd4G51bl2w7NhYNkWf+b7MxVRvCH/BlrN1mZyK+ywMriCq7mk/WnKbpmUP8W//rt/jTln4jvuI/GqBOFIGP4InHmHyHiE5FuSymH1hrlSSOT1MST8lbWFTXN5tVAVtgkwhoeH2bNnDyMjI2SzWbLZ7BW9JrLTvUSOV/UDHepaCmC8PRvSz+Elwbx9GoBayGAwyLe//W1+4Rd+of3YkMN/nf2vrP7VKsPTw8y8c4bwxTBjzhjL+jLDrWH8TT8blfZ80lwrx/Letr+wbCwzvzbPQGhAfR/DNRhpjpAOpNnl7OKOY3ewv38/2uc0sMF62sKsmxTt9oE+E8faVWjhcFgdTtNdwyJmw+tQe5OH3g3hNaG9ZFsA4/bbb6der6t2P6+n/VxF7KYc3y2gkAhCZnrJ+3dXasFmXkVmdsgi3vCXNzC2NoabcNF+SaPxVINDE4f4u7v+DtMxsZx2BZZt2yT9SQbrg6yZawzWBxkID+D3bY54bDaa3L1wN7GDMV79sler8U6lW0o0n2pi3mq2KXUbdX7sxsZGh+nrzqd4N46Xy/DyPUKoSYi8lWwLYKTT6Y76R7j+ZJn8W14rwJBuMimVE+6hG3Bex1NEnMVms8mpU6c4fPhwG1yGTmhXCCtj0fxhE83W6Fvs453/6p0slBY4d+4c2WyWUChEejXNz+V+jmK8iL/lp/Hsf8VikWQiyd2P303wXJDALQGG3zKM4Wt/D/PPTPSCTiXYPswnFovhOO1ju+Rmih/VLbIOknPxOqNeMwwoAG8l2wIYcH0le903VW64LJI3Gmg2m6pRWNLm1/ve8lzDMHjkkUf43Oc+11EVpfVrhG8PU/1+FfNWk6GDQ4xoI/T391MsFnn8u49z1/9zFyMbI6wNrfHFm7+I4TPYtWsXw8PD/NTRn8L/x36woflUE62goQ086xtoUAvVsJqWijykFkRudrVavWoppLf/1UvidWvJq2mMbdFw9EKkW312x/RevuK5/gB873vf49SpUyrigfbC7v7abqZ/OM3YV8dwHEd1sp86dYpz3z/H6MYohmswlBli1BzFdV0WFhZ4/PHHuZS/ROREBHxg3mZijpqKZ3HddodbKpVS5JlUcnmZy63OUfNS394w2StyLVc72/1FDQwvKIQ0kvBVYvVefRrXK5rW7kv54Ac/qIbSB4PBNqEVMolMtIe+xeNx/H4/DzzwAA8++CBz63OsjaxhazYrqRWWq8tqkiDAFx/9Ir8//fuE/ibEgb87oPwfOatNph8LF7O2tqZmjnvL/rxhuLyH1zQKALyhujwnEAgof6uXvOiA0R1FQGeCSC7c5/M9b2B0v2ZjY4O//uu/Vo97u+Elff2nf/qnpFIpbrrpJsKRMN96zbf4/Ks/z5dv/zK6oavdKQ7xyWdO8sGPf5BHH31UnUwtJxbIDZfD7+SkJ28bw1brIN/fC4ZAIKCiLejcUFuu83Yo7Ttx4sRVv8RWEUr3vArY3CmBQEDVT8BzKxv0soSShCqXy3z3u98lEmkX1UhI+A//8A+cOnWKRCJBpVIhk8mwsrJCuVymUCgo/8Z71GWr1WJlZUVleIeGhnjzm9/MHXfc0aERlpaWWF9fB2BkZIRKpcLb3vY2FX5K7YbXj/AmGiW68pJ63vS83+/n5MmT27e077mI9wKFwROyRnwL746SxXq+JsVb3/DjH/+YgwcPEo/HAVheXub06dMkEgmi0agaeD8+Pq4OFYbNjjg5NrxSqRCLxdQ8c8Mw+NrXvsbFixd561vfSrPZpFKpqJFOovKliw64oslZeA2vLyQaw6tdvNGJ+EW95EUFjG5CSwgc6beQXS7jEb3peejdF9pLk1xRa/nsmKVvfvOb9Pf3qx1bKBTYt2+fioAsy2JoaAi/38/FixevGGedTLZZy2QyqWaBzc/Ps7S0RLPZZG5ujieeeIIbb7yRQqGgTlSQ82TFLIhG6K5c63Udci3C/HqzraJle8mLChjd5I03X+LNB8jZ8MPDwySTyY65VvKc5yJyEy5cuMDi4mLH2IbBwUHy+byaSizmq1QqqRuh6+2zUL/xjW8QDAbZ2Njg93//92k2m4yOjjIzM8PCwgK2bZNOp0mlUioCkSrvZrOpfJDudZCsrcwN9a6VNyoT/kOOMn1RZFevR7y2X4DhDcnkZskCnjlzhsHBQcbGxl7Q58r7ZrNZLly4wMTEhDJZspu9Jkt6WmHzzHg5qy2bzXLrrbeqXe/3+xkfH0fXdbLZ9uCTarWKpmn09fUpIIhDGo1G1ZgnYWTlc7ciAGGztEGiHPmeW8mLChjdeRIhfsRceOs2fD4fY2NjZDIZstksExMTRKPRjpOcvWbJ+/5bia7rrK6uqppJIZ3k7PR6va7INq/TJ6ct+f1+6vU6L3nJS9RnaZqmjvaKxWIdEYWYD29DtURB3jKF7mhD2E9A9cN4xTTNjjPbesmLChiwGSV4i3K8Q8u8cXwoFGJqaop6vU4mk2FjY4Ph4WFV6wnPPVqZn5/n4sWLnDhxQs0Dl90sJy898cQTnDx5kv7+fvr7N4/ZtO32wTzj4+MqESZaY3BwUL2X9K7GYjEajYaKIBzHYWBg4IrjJkRjCdCFzveCTHiPRCLRAcAtr/W53pjtJN5CHG/mUER4hmg0SjweJx6Pd5xT1i1eZ62XCJ9w9uxZdb66GuX4LCAjkQjZbFaFy0JYiZ8jkYAcjidaxefzkUql1FFc3oyoFC87jkNfX1/HtQlfIwSZ94Z7S/jkb7Dpd2x7jXGtTKo3Te4tixNz0svEdCfehoeHrzA53SWE1xIpP1xYWFA9GZZlqfnfclTmk08+qWpRbdtm37596ghN6SP1pr+936VerytV7/f7CQQC6ob2miEi199NfYsPJPUpsnls21YnG1xNW74oNIY4ml4Ow1tnIDWWjuOo0xFlB8luAq65S64luq4rCrxarRKPtxuQ+/v76evro16v8+Uvf5lGo6FsuN/v59Zbb+Xo0aMMDQ0B8Id/+IdEIhFVYigRhVDgchPD4bDyVSRzLN1w3rWR7+blNuTzpYbVNE11AtT1mNEXDTDkR8rsvWpSLjAUCimqWha0u+j3ufgU3WJZFpcvX2bPnj3Mzs5y+fJlVZVuWRbLy8vk8/n26KZnoxHLshgeHlaD7UOhEDMzMx2FR+IQAx3nn0HnEFtd10mlUh21ml5mVzaOdwyUAKWbHb2WpnxRAMNrGryjFL0myDRN1QzkXRCvpw7P/xxSQB2+NzAwwMmTJ7lw4QKZTIZGo4Hf72d1dVV9rpw7Ijtd0zRVhxqNRnn88cc7El1ezeDtEvOW/QswpDKt2xR2M73eNHs3dX6tddgWPsb1ihfpwuBJ8Yr3HHivf/FCgNAtPp+P1dVVEokEL33pS0mn00SjUZaXl4lEIszOzipzJVrAtm0++clPArC0tKQO7n3kkUeYmppSVetevwd6q/lAIMDQ0FBH85BXS8i/u9Pp1wOEbnlRaAzYvMlCMXdPxpGmInnu9YDi+SQQ6/U61WpVJcmkscl1XdbW1jo0lvf9a7WaynmYZvv4zX/5l39RJsNxHKV5tgojXdclGo1ekScR8ZrMXq/1+mjXkhcFMLovxMv3C1gqlQqlUqnnoshu6vVzPeKNGBzHYWZmhkqlgmVZlEoldZ789PQ0N9xwgzonTXwin89HNBolmUyqSEXXdb797W+ztLREvV6nUCio89K8nET39zBNk3g8rsyP13xczVx6za847Fe7/hcFMES68x1CaAkPINXlvRb1JyHi5UtaXdPa870kKnrNa17DiRMnCIfDVzi93joKcZBPnDjB/Px8R+3lViV73lS5nJsi4g3DZZ26fSuvBpVo7UUBjG7Eey9IxJs8k2SQ8P+SqPLa3ueqGa4l8vlLS0vqRsiJBo1GQzVPy2fK87sjAwHKwMAA1WqVcDiswkuJcOTzvJ8tFLkQYyICJu+Q2F7/9jql1/I7tgUwerGW8sXFq5f6BKl3lIsV9S7PlZsmmqMXkXM9C3M1mZ+fVwRboVBQpqRcLpPL5Uin01cA28s6yvf90Y9+xOTkpJpD2iv/4RVJokWj0Z7fq5cp6d4gUvbYvd5XfNbzWpmfsHgZQW9Vlpfh9P7uTaN7HU3phPcSYt271/sar/N6PSK7P51Oq9/FEX366ac5d+4cTz755BVzNgXMImL+lpaW+M53vqOO0RR+4mrd6KIdu7+ztxTAe32SgfVyOnDlaOpu2RbAWFxcVAUr4uHLzfVqB+js+fAOdJOF8QLLm2zzgsKrYr3vI3/rFq99FufNtm11EkEul6NSqXDq1CkqlUpH6Cg8hbclUExls9nk3LlzXLhwQf1NNIXX1/Bqm0AgwODgYMffvM51t3h9Ha9ca0Nsi5rPHdl+si00xo5sP9kBxo70lB1g7EhP2QHGjvSUHWDsSE/ZAcaO9JQdYOxIT9kBxo70lB1g7EhP2QHGjvSUHWDsSE/ZAcaO9JQdYOxIT9kBxo70lB1g7EhP2QHGjvSUHWDsSE/ZAcaO9JQdYOxIT9kBxo70lB1g7EhP2QHGjvSUHWDsSE/5fwFEwju0f+BmvwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.77999186163257 1.549200046742515\n"
     ]
    }
   ],
   "source": [
    "## TODO: visualize your test output\n",
    "# you can use the same function as before, by un-commenting the line below:\n",
    "from statistics import mean \n",
    "visualize_output(test_images, test_outputs, gt_pts)\n",
    "x_axis = []\n",
    "y_axis = []\n",
    "for i in range(68):\n",
    "    a= np.square(np.subtract(test_outputs[0][i].cpu().detach().numpy(), gt_pts[0][i].numpy()))\n",
    "    x_axis.append(a[0])\n",
    "    y_axis.append(a[1])\n",
    "print(mean(x_axis)*1000, mean(y_axis)*1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you've found a good model (or two), save your model so you can load it and use it later!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## TODO: change the name to something uniqe for each new model\n",
    "model_dir = 'saved_models/'\n",
    "model_name = 'keypoints_model_2.pt'\n",
    "\n",
    "# after training, save your model parameters in the dir 'saved_models'\n",
    "torch.save(net.state_dict(), model_dir+model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": "markdown",
   "metadata": {},
   "source": [
    "### Question 1: What optimization and loss functions did you choose and why?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: ***Loss Function: Mean Square Error,*** Since we are working on regression, Mean Square Error is the great choice to detect the difference between the two pixels.\n",
    "\n",
    "   ***Optimizer: Adam,*** as it converges very fast and efficiently, it salso supports the problem of vanishing and exploding gradient and momentum helps to find the global minima."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2: What kind of network architecture did you start with and how did it change as you tried different architectures? Did you decide to add more convolutional layers or any layers to avoid overfitting the data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: I started with naimish-net(paper which was mentioned in the project) which has 4 convolutional layers along with 3 fullyconnected layers and used elu as activatiion function, I discovered that 4 layers were not performing good as the number of facial points were different, so I added one more convolutional layer which helped model to find the pattern in more efficient way. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3: How did you decide on the number of epochs and batch_size to train your model?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: ***Number of Epochs:*** It is decided on the basis of average loss, as it starts converge, training of model gets stopped for further training.\n",
    "\n",
    "***batch_size: *** size where the loss is minimum at the particular learning rate of the optimizer and number of epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Visualization\n",
    "\n",
    "Sometimes, neural networks are thought of as a black box, given some input, they learn to produce some output. CNN's are actually learning to recognize a variety of spatial patterns and you can visualize what each convolutional layer has been trained to recognize by looking at the weights that make up each convolutional kernel and applying those one at a time to a sample image. This technique is called feature visualization and it's useful for understanding the inner workings of a CNN."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, you can see how to extract a single filter (by index) from your first convolutional layer. The filter should appear as a grayscale grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the weights in the first conv layer, \"conv1\"\n",
    "# if necessary, change this to reflect the name of your first conv layer\n",
    "weights1 = net.conv1.weight.data\n",
    "\n",
    "w = weights1.cpu().numpy()\n",
    "\n",
    "filter_index = 0\n",
    "\n",
    "print(w[filter_index][0])\n",
    "print(w[filter_index][0].shape)\n",
    "\n",
    "# display the filter weights\n",
    "plt.imshow(w[filter_index][0], cmap='gray')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature maps\n",
    "\n",
    "Each CNN has at least one convolutional layer that is composed of stacked filters (also known as convolutional kernels). As a CNN trains, it learns what weights to include in it's convolutional kernels and when these kernels are applied to some input image, they produce a set of **feature maps**. So, feature maps are just sets of filtered images; they are the images produced by applying a convolutional kernel to an input image. These maps show us the features that the different layers of the neural network learn to extract. For example, you might imagine a convolutional kernel that detects the vertical edges of a face or another one that detects the corners of eyes. You can see what kind of features each of these kernels detects by applying them to an image. One such example is shown below; from the way it brings out the lines in an the image, you might characterize this as an edge detection filter.\n",
    "\n",
    "<img src='images/feature_map_ex.png' width=50% height=50%/>\n",
    "\n",
    "\n",
    "Next, choose a test image and filter it with one of the convolutional kernels in your trained CNN; look at the filtered output to get an idea what that particular kernel detects.\n",
    "\n",
    "### TODO: Filter an image to see the effect of a convolutional kernel\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n",
      "/home/ma/sparsh/scripts/P1_Facial_Keypoints/data_load.py:39: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvWtsZFt2HvbtqiLrxUfxddl9+97RzBWkAFKATOCB9MN5KFEcOEYSQUYw0QSwbEmQZcCDIICAeKQYiWHBgJJIFgwEUCLBgi3A1gNQZAuCYFsxYMQBoowe1mNsZSLNZO7t7ttNskkWWcV68FEnP8hv8zuLa586RbK7q5FeAMGqU+fss/c+e317rW+tvU/Isgxv5a28lbdCqbzuCryVt/JW5kvegsJbeStvJSdvQeGtvJW3kpO3oPBW3spbyclbUHgrb+Wt5OQtKLyVt/JWcvLSQCGE8KdDCF8OIfxxCOELL+s+b+WtvJX7lfAy8hRCCFUA/w+APwXgCYDfBPC5LMv+1b3f7K28lbdyr/KyLIVvAfDHWZZ9NcuyUwA/D+A7XtK93spbeSv3KLWXVO4jAI/l+xMA35o6eXFxMWs0GvH7ZDIBLZhqtYparYYQAgDg4uICFxcXuXNCCAghYDKZxOP2N/55Mk9ZnVpHfi6qu3c8hIBKpYJqtYpqtYpKpYJK5RL/2Tf8s/2lfaH398T2W+q8aeLdR+vktc07317r/Xn11uOTySTZvlSdi8q19dLr2RZ+1nJSn/W/N66Lxv5gMHiRZdlWslFX8rJAYaqEEP4igL8IAPV6HZ/5zGdiBw0GA4xGI9RqNaysrGBzcxO1Wg0XFxc4Pj5Gr9dDv9/HZDJBtVpFs9kEABwfH2MwGGA8HiPLMoQQsLCwgFqthoWFhdh5lUol9/A9ST3ogva4n6cJ68KBzus5SC4uLrC4uBgVW+tdq9VQq9UicLK8Wq2GTqeDTqeDjY0NtFotLCws4OLiAqenpxiPxzg7O8PZ2RlGoxFOT09xenqKs7MznJ+fA7gG41qtFu/NdrFvCc4XFxexzgQh1p+gQ8D2yuK92AcXFxe5aygLCwtYXFyMz7Rareb6kv11cXER23J+fo6zszOcnp7G76wz78XvZ2dnGA6H8RxPeA/te9aV17HNbMfFxUXsV33utVoNjUYDi4uL0EmRdWZ9z8/PYxnap+zvRqMRx4b+cWIIIaBWq+FLX/rSh2XG5MsChacA3pfv710di5Jl2U8B+CkAWF5evqF5ioAWcXWwsGMsytuyFD2lDjeO2WuKFPy+LAxv5mP5HGzaF5PJBLVaLXd/At/CwgIajQaWl5exvLwcAUGVVBVV78t+puLyjwPLzkyVSiUOfDsLKoBZwOQzAxCV02u3Pk9aPWr98D4WhC4uLrCwsICzs7Oo7LVaDePxOIIZ+7xSqeDs7Cy226u/1kutVG/8qFJ6s72eR0Xns+R9a7XaDbD1+ojXsAwVtawrlcoNUCqSlwUKvwngG0IIn8IlGHwXgP+izIWeoukgSSn+tJl/2j2LgKFsPaeV54m1ElLn6H8AcdYAEJWi0Wig3W5jeXkZKysrWF5exuLiIrIsi5bB2dlZBBrOQFRsdTvU5VAwULBgHahAVkltfyjIVCqVqWa8rZO1XNTC8ACV7R2Px7lzCBZWzs7OYnsB5IBLZ3y2mb8T5PQ5qdJq27Q/WLaCA+9Ly5jP2ratjCU7yzhUeSmgkGXZeQjh8wD+MYAqgJ/JsuxfTrvOdmoRSnrfrf/oPRC9z12kCDBu61sX3UdnZPIn/F6v17GwsIDl5WWsrq7mLIQsy3B+fh5dBJ3BgGsFZF+rO8LBrr6vKqG9NiVl+lufIZVBLRIFE8u1WN+cdZ9MJhiPx1hYWMDp6ekNd8Pe25Zt68XPdB+0XZ61oHVS4Few4/Ohy3txcREBxrZfZ3wPQGkx6z1Yn2kTj8pL4xSyLPs1AL9W9vyiiheZYalzVbxZax4lVTedqSjW1G00GlhaWkKn08Hq6moOTMgd2L6xSrCwsAAAOUvBKpuChA5crx0K0FpnWwe9zhMFJ3s/dW9Y18XFxai0i4uLkUfROrFfeV91TXgs1T4qs/IL2gYLggpG1u2g1UaxYMPzVKZZB/Zz0QTmyWsjGsuK9XeLgKGMSWXPnQYQKWvDO6eoPA5+b9bkMcstWF7FXkOlbTabWFpaii5Do9GIpKJaCLyH8jAsQwGJyqH3JyDocfXrPevNs0q8z1bZlSOys62eqzOplkW/vFqt4vz8PBKT2ndU+PPzc1Sr1WhV1ev1SPJZ/kHvqe2gUtv2an/THVCrj9frcXWRUmL7gH98xgpMGnUqK3MNCrZjvIZNM4tetlXwuq2OxcVFtNttLC0tYWlpKboSqdlGBwnBQWcyyxsoMaiKyXNpVSipmJqZLBAQlGwf2uttnWgdkFhV0lBDsVQwKrb68ZPJBKenp7HuvIafT09PI9FniUNti/7X6IP2twKpkrzWBVALRBVcFd8Cova3dSv5PeU2pWQuQEE72w6uMkpnO8r7/a7Ka12QovtZmcWfK7o/BzDvX61W0Wq1opXQbDajC1Dkh2t5OkvqvSzDbyMQ6hJw0FEZLCCkXAxPeNzLQ6EFwJlf3Rkl/2zb+Z/l2z4ELklGhm3ZboYGleDWsKmGM5W8VQsHuLayKpVKBCK20XvOXn95wJDqS9t3nktTJHMBCirWRfAIH8AP43mDUZVgFhOqSMoOfK+eXqhrViEZtbCwkLMSFhcXY92q1Srq9XpuduV1tg7W/7dK5UUT2BblOVJ97bkW+llncP1dAYkz/+LiYuQMrEuggKGhSyr+wsICzs/PUa/Xo8lP0525DKenpzfuzXpR2S3XQNDQvAKGGdV9oNgQum2vCq+11oT2uyUoPRd7LojGWYWNtiinv5chGr3YuCf6+30oqiezWggpU08HooYP6/V6zEdot9vRF1XijN81ZKiDh1aBJvSoMnmzrJrIOounyGJv1rJ9rjO4ApPHX6hrYHMZ6FLYhDUqDhOg2EcMB/IaggL7nVaA1k3/+Dw0KcrjFlh3dXf0uVt3Ql0mrb/2s72H1tVaK7PI3IBCSvShqj/mDUALCJ6vauW2pn0Zy2NaKMiCnzdLqKWhYUkOsHa7jXa7jWazmQtJ2SgBZ0ZLPKkJrK4HFUwtC51VU/F6fV6q+HbAW1JMy2dZi4uLuf5hn6rCqFlPhdesR31OSioCiNwL+YXhcIjRaBTvqbkcFhBJYrIPLajxu40c2bR9/qauB8tXYKQlpG2xoMr/9m9W93nuQQG4GeLyfk8pqKLtfdeJMisaz2KZcCbn4FFArNfraDQaqNfruYGmM6uChJrqWZblLAvtQwUFtSzoR1vlt66IknPqjxcNTu+4tpcKTeuA9dUoSq1WQ71eR71ejy6GKis5AgU/yng8Rq1Wi6BAUY7D8ik6w2tuhZ3dGcngcUvsqtgJj8/fugc2ImJdwDJWdUrmBhTsrGo713MvisSys/ctyvjOKqok2hbPfUiVT/+61WpFUND6KCNfq9VyM4slCi2Hw1lKiTzgmlzTsoFrq0Dvr26JAgeP8zo+d5thSCWmIlsfX4FIXYqFhYUIlgQMndFJHLIebB8ti16vlyMR9T5eyM+a/frMqMgEBSVFFVStEnuRIwVmO9FZ3s1eO6vMFSgQWUmuKKvNuLuaaupzqijKWp/Xu29KPL+w6HuR2Bm1bBkcQOqrhhDQarXioifOfDxffXLNQJxMJjg7O8v1myVj7W8AohXC9QQsm2nB2rfqV/M3NdMt+aeLsDS6wr4fj8c5JQ0hxEVEbJPOnOrSKHeg4McogAIg/5aWluJYY1s1hKlkoue3WyX3uAgVXcDFc73FYewfJSxt+rMCr+Vk3jj3wVMY29EWva0/5XW4IurLsBamiXVb9Pss7oNew+s4IzIvAcjPVJZUZGaf5verMuh1ek8tR+9hiT8FA71e/WSvTRQl12z/qOtkn7ECJXC9cpSEo4KC7UO2g20g4IxGowiAmpikqy11LFoiNEWgpu5tn7cldzlR2mtoNaUmPO8Zl5G5AAUVJUf43WNnVbzfizrB60TvmJrZs4CKd28Lcip6D02b1YFMM1h9WyqAdUMsa6/EmrWeqBBWKXlfjbErQWhNcJ097QxMILLtVbBXs5hWid7PE3IN2vbFxcUIlOxHZetV0RXg2P9cxlyv12NOgZKGXEeiCu71nWcx6BhQMCVPYtuqx2z/04KxxLHlut5oUFAykQ23y1TtdwUCBQZrNbBDlZ33OikFDCmZlcC0g8Ib8Oqbq/LSrAQuZ0Muemo0GrmUXh2clnBkNMEOFk1e0jra5B/+xsFMRbE+Ld0FjwfwwN3OogpWyhcAl5bHYDBAlmVxPQOtplarhXa7HUFBMxRZ78XFxQgkng9uV11q3XRFowUF7Ts+Lx7j2FOA1f8KGPysForWi2Vz/ChHYceUPq9ZshrnChQ8N4IzpM4o1ozkA7OEmZ0xtfO9AaEWxjTz3vqSVrzf7IOcdi2tAVUs4HJTmvX1dXQ6nVwoUttmyUQqQ71ej/fRpKAUf6Ln6KALIcRZV/uCsxmjFzzOlYA2lFapVDAej3Obm/B3lkF3ALh8LlzcxX0jOp0ONjc3Y5+olaFApCCl5WmbVXHtzM8+tfW0dVZFZRIZiU8SxFa5NSyp96Q1wEmB5Vt3TsHFErFvJKdQRixpA/iKqYPTih3UniJo2amZfJqkHoB9UBao7H1UGTlggfwORBodUDKNYv3tZrOZA9VUP/C/dQX0N96L9dTEKvXlK5VKtGJ0LwM7gyq4WxdJIwUMPTYaDTSbTTSbzWjy64YyNqHI5kF47SYAaa4DXbQUb6BjiqLKa8ekWrPc4EWfm7WEWXf2Ee+vEwX7S6/RMVA0CVmZG1BgYykW3ayvNO13JY/sce8hsgx9cLO4B7MgcZlyOKAajQZCCHE/gBBCjMNTAdgmbZsdYDprebsHWRNYLSztb+13TdflwAWQmzWtpUE3h/3LtnBlp9aNrgnNfl0ARZJVAUH5FQWCFEFtLRYAEXAUFJRotX1glU37S8tVRbdWhmflqsvMvuQzZp8o/2TP5zHr4pWRW4NCCOF9AD8LYBtABuCnsiz7WyGEvwbg+wHsXZ36w9nl3gpTxUM362+qKagKoYpuZzUrqvymTTd+93zt+xAdNOpLq3g+K81PWgk8jwPC1t0ONl5nFcWCp1oIqbZ7fioHLz8rd2FdDLUUyEPYWZ3gsbCwgGazGZWfANFutyO3olyHlmXdTW2fdTdplaiVYF0Jb6LRchWk9Vmqea/HLFhZvgzADQAAcGMyUEvIyquyFM4B/GCWZb8TQlgG8NshhF+/+u0nsiz7sTuUfaOT9H9K7AO2SuZdX5ZDeJmig4rCuuoiJiqQZdd5fsoNsKDCgaQKaK+zoJACBuujK7+h1yhJZkEBwA1FVsUgmDUaDTQajVw689LSEtrtdty8VGdHSz4r+Fk3yLZfyU6bW2GflXIIOpMrYLCNKtbMt8/LAjbHAvuT/T1NZgEE4A6gkGXZMwDPrj73Qgh/iMut3e8kOoAtWurMZxuqHewRRRa5i0QHyjSL4i5CxfHKsSY5cM0JMHmH7fQAlJ+13Wr6aojLA0Z1v9QEVgXQczmj6l4O9lmpCa4uDUUT07QfWAfyCHQXuNtUq9WK5J29d8pNsvyLWqR6jlo5qYlG+8O6DjpWtG52XNGt0mfvWcvsD7UuLSFKsQBYVu6FUwghfBLAvwng/wLwJwF8PoTw3QB+C5fWxGGZcvQB2VnTMwOBmyb2VX2S9yhrEaQUf1aXxBOrhAoMFhRPT09j9h6P83xNAfZcLw4gz9JSXsD6vXZQTwMulsdZ1QKanZXVUlAilb8rEOiApzlPULAAqTOq7Qets/aB+uKepWnDo/YZe2PW4600imD5Bo9wtuPauhmWL9M2KTDdxu29MyiEEJYA/BKA/yrLsuMQwk8C+BFc8gw/AuDHAXyvc1187wNXwwG4MZB0gCk4eKa2J7OQhYn2lbYIygCD1icV4bADQRch6SBjCMtro/qvRQBXZPV4gOBxFmp9sF36jgIe099ZJhVdQ4E8h26Dgl4IISYo8X9KQWx/pLgF2+8WCMq4UbS4LAjZc7R8tdJSz1CtM4IXxW7rbttVxAcVyZ1AIYSwgEtA+HtZlv2vAJBl2Y78/tMAftW7NpP3PrTb7cyamtoJNkcBQM7Xs4tXqCgpDmFW/sAqQZFMA4aie3umP0FB2xtCyC3ptcqrfafhK62/tskzfbUcz1VT818BS10FO9B5vg50IL+4i8lYeo11WVRpFSS9Gd97dtOsPSUcrcXA+1Ms0Cl4EZjt/fS4R4rSAuTaC7pkDOeSV7IApCCQymcoI3eJPgQAfxvAH2ZZ9jfl+MMrvgEAvhPAl8qWqcgI5EMqRShvlYGdnRoEtwGGlyVlHpZn1paZGSk2lq0zjz0+jZzVa+3sqXWy9dMBCuR9eroEHihMEy3HEpT2/mVEZ1j7X0GwSGgBeFaIdSfsWLWciB7T8nXhoMcF8flMs3A8uYul8CcB/DkAfxBC+N2rYz8M4HMhhE/j0n34GoAfmKVQS3x5KDtNbmMyvQ6ZBb0B3HjIqqB2AHr9ZJVezVmduVKgYwHAAom1VlRoDWhb1FIgT6D8gGfV8L/lC6yV6UnKXZgGZgrGChQqek+v/zwg9sKWth7eNeoKWR2xz+U27vNdog//BwBP+0q/68GUl/vuEYhF15Qx7b0IxCxRifuUWXgK9XU5WylwqoVlB43+WaJL3Qwd6OoSUHSw8XvqvwUpO9uyLfyNCUlqctucCz2fdfcYeu+7trUITFKiSmbXEXjX6vkWHLQ+aiV44Uqtn3Wd7P0sKFn9eVWWwisVLzzJ496s6JlNr0r5p/EKswACFdbzk22YyprSNFGtX2lBwfIKuvrOm11TAOABgt7Pfqf5qwOdbdZdniwpp3WxAJgK5Xnuhf55z8bz1+1M7EUtPHdK66tlFrk7RcBqCWg9jxOAbU9ZmUtQ0FkrFU4C/MzDMuL5aPcts3AFnqQsGB3oqjhKJFKxdBDaGZdlsQ/tQFY2XUUBKnWOPZ/nKnjp/dRK0PaTMOZ9PHNblUqJaKv8qWQme940UQXkM2C/WgtBAc0Cj22vd/8UKOg11gXkZ/7ulTVN5gYUWGnPdFWZNgu/6TINoDgQdKOPlGmsCqLKmTJp9Xc7aFOZc0WD2d6nyAJhWZpj4HEUXg6CtY70/CJ3ymuHdbdUGacBINtlw6q0KOz9UlyJ7Tt1XVIhTM/asOWUlbkBBYpFRC9SYGc3oPzW7q9TplkGRddY81o3NbGA4O0vSMvBulXWLbFWAz8rW64mqs5UKp4rYcN1tp0WALQcO6uyPL1O10t453h/KV8+JWUtU9tXnpSd4NTqsFYWQVxdTd7fq3cZmTtQAIpDbxyMXkfPixWRGgT34aaowutnm4fgWRHVahVnZ2c5a4yKYUHBAoMlKe2Mr1ELb7azs6B1QzyrQO/njQO9Xo9rf6fAhuKRcimzu8jNUAshJbM+/1RfUtg/mqNhQeONthR0RrQD0xPv93kAhPsW65MDeYW3ZGPKV1b+QC0Glj0NENSf15negoYHzLyn9avtTH0X0ExNEp6bUeQ+eEBioxgqKSDQ/kq1S/vZWr/2eWj9LC80rS6zytyAgu04HVgvK2owL5ZFSpTIU78YuMm8a/aiN/g1bGm3KdMyrUXguQFarnXvirggz1Kgyav1tv50SizI6OcUoWjPtdfY/Re0/7xIQ9FMniKL7dj2eB4+J+0Pb6MVipdUVdbVsTI3oDBNbJzaHrdiLYnXkYtAucsMyMGoeyB4HII3IDyTmwNQ9xJQ018HqDfgPXLMu69neXjWgd2tyd7PPnevTZ54gOC5G9ovRX8eT+PVx9ZJz7eKPG1MqhUWwvVWcd4qYH739lRIkZApmUtQsHyCRfki/61oZrkPn36azIrKZcXOXLZvvEVTnp+uroIt33ICej7LsHyAZymkQEHrS7GgkOIbUs/c6+8Ueeg9fwsc3ubAao2VtYrs78rFeBaEtexsfxAMdNm43ZIvy7K4jT//6/6mZWUuQQEoVm5NOVX01sGrO9UAaTIqJUXk1DS5D/Dx/G+7IMy+k9D6l6psCqr8s4uZvPt7CptKn7Xmv5arz0vPsyBkLQKdKXmPlI/vWTjKiQD+rGnLszkeVCy2Q9uloMXPdM1seJ1l8zo9ppvBWnCgVKtVLC0tYXNzE1tbW1hdXcXKygqWlpYAXL5Y5+joCN1uF91uF4eHh+h2u3F/zLIyN6DghR7tsSJSxeMHUr6j/i/rs5aVuwKCZ47zuGfCWjJKy9DByoGmHEWRgts6TRtUKf9Zy+B9LWB5s6Pe0wKBlld0P+9cBUVtk8fFqKWgM64FIq9vdIbnZ91ERQEiBQjAdSi40WhgZWUFDx48wPvvv4/3338fm5ubWF1dRbPZjFbC0dERDg4O8OLFCzx79gyLi4vo9XoYDofJvrIyN6CgMiv5N6si2gHjgcnrshBUvHpx+Szv5UVrLCikCCiP4OLv3gxs68L/SnxZotJTfo9boHjAYqMj3vOxgKL30dnfu6+6F+pG6G7QXM7sLc32Quf8PQWUGka0gOBZFvV6HRsbG3jvvffw9V//9fjggw+wtbWFpaWlyCWMx2Osra2h0+lgbW0tbl33/Plztw4pmUtQmCZF5q4VG7sF8sqbytSzZrfKtFDTbcVrgzWd7bsMU0qvCqRcgW5Xzt8oqtRFolaGBYIii8Eqq20zr2e7+XtqNtbrrDLZ2Z4KZpXaumZUfFoG9MsVFLwZXceK7cNU9iHvY8tSYCOPsLm5iUePHuGDDz7AJz7xCWxtbSGEgG63Gy0B7tJVrVaxtrYWX3E3Go1wenqa7D8rcwkKqUGZcgf0wVuSatrCEDtAptWB5d63lFFE/ieJlNq9V9Nr+Z0DVUNXKbfAa5+GLxVUppVl2+iBeVEd7H2spKwYHRM2kmCfuYYi9XwvNGn7O2XZ2N+VQ/AITZZrcxAqlQpWVlawtbWFBw8eYHNzE41GA+PxOHIH+/v7ODk5wfn5ebQSOp0O2u02Njc3MRgMMBqN3P7zZK5AwUPUMjLN1J1WTuqBvwpLYNbrLy4u34jMWUBNTp1VdZcmWghqNQDpjVKL6j6razdtlmfZdrafVp+iNF5VPMsNWDPdmvAWELxZXNul/ccybc4AOQndLctep1ZbpVKJlmC1WsXW1ha2t7extbWFer2Oo6MjPH78GM+ePcPOzg729/cxGo1wcXGBjY0NPHr0CJ/61KfQarWwvr4eXYuyMjegoDN12YGnM8FtFc6azPcJBHcFAeBmCJEmLc1aO4t5roQ1xVUprNJ6dbbn6Xf7m+U4LAnKe9hnXQQMZcSWb2d9j0hMtZfiLWzyftf6hhBy+04CyLkeCgx6jQqfOSMYrVYLlUoFo9EIH330EU5OTrC3t4eDgwMcHR1hMBhEpefLfBcXF/HgwQOsrKxgdXUVGxsbpfvyPjZu/RqAHoALAOdZln0mhLAO4BcAfBKXuy99Niu5ozNQHDWwomgrdcpdV0SUqR88b4Bg667EU5H7oOKF0LTtlryzAKNAoGVqLolaJx5AaP1vq/SeeK5Lkdtg8w+KwqrsK5arSUMpvoB9ontE8L58XilAsH3D/uSOVefn59FNODw8jNbB6elprsxerxdfuMtX6jWbTayurpbu1/uyFP69LMteyPcvAPinWZb9aAjhC1ff/8ptC1d/uuicMrzBtHt411HKDOYiJZ2mwEX+sX7XZdN2plfXQWe41IysfINnCrNM/WzLtt+9a1i2Z12k2j4tQc2zcCw4eFZC0TjS64D0uLDAwD/vXRkeGKTaZMus1Wo4PT3F4eEhjo6OcHJyEl0FvhRHwYf1Z2iy1WphbW2t1EtjKC/LffgOAN929fnvAvhnuAMoqPAhpUzeskSWNWmt3Gamt9fcB4cAIPqW9HX5mX6oKrZVVGsp2EFrk4qK3Au1ADjILAB5boa2RUHKM78p1i+3IOX1k/aXdRXKWJqpa9iOWq0Wd1i2VoRaStqf3rZyeq2CjmdhcWNW3jeEEF+sqy/CVa6JHMZwOMRwOMTKyspM1tl9gEIG4J+EEDIA/0t2uXX7dna9o/NzXL5vMich8d6HWKhjOicrYMzeWVDRljPt99SAnCZlCDPPolHOg3860Ghi6j1S5j1/s/2jM42CAutildfOiB742M82r0JBSaXI9bD1KVJ4dSP0XE+sFeFFKdjmhYWFG29yImBoP+off+d366raiU77RglivhGL79Lk27JarRZOT08xGAzQ7/dxcnKCwWCAs7MzDIfDmd3i+wCFfyvLsqchhHcA/HoI4f/WH7Msy64AA+Z47r0Pd6lACm1nEWuiq6RmrFksjRRn4fm20/xulq3+K5XZmu/WbeD5to4c+GUy9jSykQIFXqtlq0IXrerz7pn6Ta0b2yZ+956FV7Z+VneApKE+v/F4HIleLlSiKGhoWxXQrXAcqNuwuLiIZrOJVquF5eXl+DJdvkeT7xSlpbC0tITl5WUcHh7Gtpyenr76PIUsy55e/d8NIfwygG8BsBOu3v8QQngIYLdEObnvZf13bxCUNZWmuRCpMqdxF5S7EJd2AYvG0kl6cTGMvo3Ym2FVoSyIqMmtloKd2VXKAoIH0DyeYu6nWWI8p+gZ2KhU2Wds3S8FBM+aDSHE55FyW7U8PsPxeJzLX+Dv7Cu+YZtgsLS0FKMIfJmuggLB/PT0FMPhEJVKJbobWXa9SKqs3PUNUW0AlezyBbNtAP8hgL8O4FcA/HkAP3r1/x+WKCs3A6pvBiBnevEB6LZkKVApM+N6fq89565uAts1zVrwoin8zHaGENBqteIAsW961kQjbwZSUFDlV/PZM80tYWnP0f6zAKUDn+fwf+ocq9Qpv5+/k3y1eyLoPb3ogeYOaDsJvPV6Pfk8GQq0fWVfg8dnwnCyuid8LnxWzWYTnU4HnU4Hy8vLWF9fj+DAF+o2m834nowQAs7OzjAej+PbpFgvvg38lYECLrmCX756qDUAfz/Lsn8UQvhNAL8YQvg+AB8C+GzZAsv4lPctZRV+mtw1pFkUAVEHzJpZAAAgAElEQVQ+gbODVaKUqL9sBy8V2M7qSjzyPAUTz1JQsbNk6hwLHGoJEOwsN+D1T0o8q6JoEqCoi0TLrFarRcuAYhOdeK3d+4DnKn+gZC1dgFqtFi0EgsHa2lq0HPhXr9ejpRBCyC2hZmqzupOvDBSyLPsqgH/DOb4P4NtnLU8HEjvMdrhzr5zpZ31oPa+MC3AXSVkClLK/2ZmMv9sZTdtqowep8ofDIRYWFuKg1fOVh+CgVQBQs99yA1bRLKDYYyyPazFSHALPVX/cgpqXe8ExlHIxU8e0HM7gXD+j4MYIEF03tWy5VLlarWJxcTEXGRiNRpFzYPnkBQCg2WxiY2MDDx48wMOHD6OFQDem2WxicXExEpD6fJrNZqwjQ5VZluHo6OjNTHP2LARvJtSBCZTbVcYzb73vd5WXkfxkgayovda3t+3WAauK7rU/xQPY52SfUcqH90DCc/HsfbXNCroWBPQaKgP/W2sr1Z9en2sfKVgqtwNcZy2qO0ZFVrfMK5+WRaVSiRuo6Gv0CJwERiU4syxDvV7PPRdyEouLi5hMJuj3+2/mJispU7WswlpLAMivVmOsn+dSrAK9KkkBktbX+r9KoGnfWKWl8nAgaZlAPmSZ6meraNb3t8dmAdoyz1XdCK8877lpuzXC4oGBirpVHtehfcsZ+Pz8HKenp9FiYDksq1qtRgVn3Sgch56loASyAq4SwbRcSIDq+SyXb/HmjlxvJChQygCCPe4hMM1KldQM9qrEDkxrVnszuwWGojItMKR8aboi6i/PIgouLNf2vffZ+842aN2K2kxiUAGKZeg4sMStdy+tk87sWp4FFHI6Z2dnuXLUgiF4EBSyLLux7Jp9T8XmrD6ZTDAajXB8fIwQAsbjMVZWVmK/KIFJApRksz5/nnN+fo7xePxmLoii6AykoRwrRQRbCkw8lr8MUXcf4s1UqWNl3BA15dW89kxlnXWVdKRy8bppFoNtjyphynLw3Bn7OSWpvrAulZ3RrbVgFdbWQTkIsvkUG7mh+W4nLh1bIYTcLH5xcYF6vY7xeBxnbCoxsxK5vgEARqMRDg8PMRqNMBwOIwBZApMLpZi7oP3DepF0fKNBAfC5BCA/E+qDtoSLJ/w9pXBlMg7vQzyCCygGMjtjWWtAc+s9F8pTWl5ntxGfdcZXZbDAknLNrJXk3cMSrymrj2BX1iXRa229dZal1XB+fo56vR7Xm3DWJYjwXEaEGDbmZie8D/90RldLodFoRJeEGYlHR0fo9/sYjUaRHNb/p6enyLIMjUYDIYRYTwARwEajUSyjrMwNKNiNVgFfUazZeFe5T3JwmpR1A/SYDmTOgCqTySTu3qtJNFQSz6y0IbUyig2k97soc30RJ2D5DQsIHq9iy5rFDbRtUpCgpUGF1bwHug4EDM99ItnImZvga10bWiX1ej3mHVCJuWHKxcUFhsMh+v1+5B0ICHyGi4uLGI1GsT7an7yWy6vLylyAgmdOe2bntJngTRALQilFs26AVV41jZn37hGI9jMHq7oUlpMpIh+t9WB3J7aS4h0olgi0Fo32xX0CuG0H+4L1JSBo33PiIrjaOvG1fIzwZFl+RasKLYR2ux2TkmiVVCqXSVG6+Iqunlp4CwsL0XKp1+u5MDP5CO7u/MaBAqXIXC06bpnjWX9/nTILt6HtUPOdZBJnskajkYtQ6EyoCqjRGIKHdcfUJSPrDeRnZ3sNf9f2pcTmEqjC6T1SiV32r6jvKNayUFLRs6iolFRQRheyLIurEgHE2Vz3dWT5duzVajW02+2YtchIAbdU0z5st9sRDAgWymuolaZtGg6H6PV66PV6b6b7QLGhJE1Z1XNS4JAS9T09uSto3Lcb4pnEqpz6x8QYmq5knjUj0Jr4rLM939bB+uwKYsp1pGZ8bYtnEdr7KenJY/Z+VlKgMO27Pe5ZKfaYEpHn5+e5UCL7p1qtYjQa5RLO2L/sv0ajgdXVVWxubsbkJJ5L16LRaMQMR6Yxd7tdHB8fYzAYxBwGTUJTkBiNRuh2u3FT17Iyd6DADicQcC9Cznyauw/cREcb0vLMVuuO2AFVxGXYe3mSGvyzZjuqYtDHZZKMbvHFLdo4a4VwuTaC5ZJ3UP+Wfi8BgYkw2ifad5awnKagOuPbPtP+V+uEdbd5GHqu9peCgVcfBURLTHp1UetG26/PmkpIV6LZbMbvIYToOhAQbEIT27C8vIytrS08fPgwEoTcPKXZbGJlZSUuglpbW8NoNMLR0RGePXsWdUBTnu1S9izL4lLqMjt0qcwNKHi+tS500uQjz1wqKxZE7G9FlsSs5d+HaHleGNLWmf2mg5OLcFTxAOSIMw5igqqa8Ly38hMqqjwKsArQOmvyz7ZHiWbr6nj9qiBllTcFWp51U2YSsIBUq9VQr9ejW0Fw1nZ7/USScnV1Fdvb23j33XdRrVYxHA5jGFI3baU7CFxaJsvLy3Gi1NfHKfHJSYOgwC3byspcgILtPDZg2jZWRbN16vzUvVP3ULPbHi9T/l3FM8m9mVpnIfYbQ2R2s1DGvTWZhj7q+fn5DcKK5dsFPtaasC6P1tGCAq9XjgLIv4dDN49JWSUUrUeKZ7AWwrQytWzWleY9VyNyfOhGukoG80/XT9B1oKVQqVTQ7XYjacjQpHIT7GtmKtJ1YTqzcjPkmLi1+3A4fPNAQSWF9nZWUf8WmD0sZe9pP9vZ184URWV4328rasoC/nsBNLGG91U3gYMVQHxrEPtPrTEqPgkzBSH69OwLj+NRcLDmf0pR1bS2boTWrWhiSCm/92ctLPuZYjkNy0mRS1CTXd0GLoSy0ZkQLvMJ2u02lpeXsbq6GgH4+PgYvV4vKvTR0REqlUoEIM745BmUd9D6k5AcDAYYDofu1gJFMjegYK0FL2lHZdpgUUUuIhCLBpsFhjJlFNVnVtGZFMiv/deNWz2ehUtl1drSFFmWpa4GcDnY2eea96BEn6dA6vNb/mGay2bfsaDx9mn9mirbAyEPQIC8wloeQ/+njmnIUpdBW26CvAMTndhXdEWazSYajUYkKanYvV4vPkuOa10wZXkgXnt6ehotjzfaUqAQ1S1zTvF8w6KyUt/V+pglIaqs6cmybyPeAGRbqexKQnJjUTU59d0QjIGr+a+hM5KNWm8F1lQUw86WHJz8zgHpWRgKvqpYBKW79p22pWiM8D7qNnnWgi2b/IKmInNm57lMOFIgZ6LSaDSKwMD9Fsfjcexr7qbE/iaAM/FJ934k8GdZlgME9nVZuTUohBD+NVy+24HyAYD/FkAHwPcD2Ls6/sNZlv1amTLLEIjauGl7LXiETxFAqCmrM1zq+mkm2X2EKT3Og2a/RX91ExQ4eJ4m1ijfoHwChcpJZdfdpDVxiqLn8nwLErY/LEBYKXLTUr6/vda6DOqe8nfvOdsyU+Sqji8laHVSY/mqwOfn5zg5OcHR0VEsr16v53Ze1jRoAqh9xiSRWT5wOQ6Y2sxQZJG1bOXWoJBl2ZcBfPrqhlUATwH8MoDvAfATWZb92CzlWRPNPjzn/rn/U+o6M+egM5h3/asABOCmsvC+avZrPQmU9kW0FFVqAgvJRZatEQj+14U4NtLAmY8KwsGvpCQVKKWAtr+0/z1LSfuCYmd4z53wLEw18a3bqPcvUixNemJ/kOfRqAqfUZZlGI/H6Pf70UpgmJF9pe6eWlNKajLsqbzC2dlZ3NWZgPFKQMHItwP4SpZlH85ycxU7WNRH5W/WSijLB2gZwM0ZKqXAFhhSvujLFgVIBUztMx0QZ2dncZZQ81HNc1sugUAtCz4D7g1AZdcB6rkQNrzI89Wy8ZSX9bHX2nM9t5EgpErEuqS4DY2G6PmWOC0jBARyIeqG6HeWzXRz8gaq7OQYuCQayCdHaWRB12RwpeV4PMbx8fGNXZ7Kyn2BwncB+Dn5/vkQwncD+C0AP5jN8Mq4aWJZ1ml8gpUyiuz5zbNcf5/iRVg4gDgAdfVcCNd79JF5Bq7TicfjcU4BdAb1zGrO/Bx4uqGHl2mqIEulsDkP9rPez7Y5NZiLXAHPQtBz7b0U6Ly6aVn62boHbK+6obwH/X26A0w4YqSArgGvY7/pzkt8/pr7wWfEsOTJyQl6vR6Oj4+j6+DlTBTJfbxLchHAfwrgh64O/SSAHwGQXf3/cQDf61yXexlMyl2Y5vOVmeWnnetJitx8naIzKvuLIStu4UXmmjMGwYMDiqQVZyoOLG0bLQpexwU3BAEy3hZMPKLR7mFoxd7fztCW8NOxYN0IDZday4LtsYrM34qUxpt0bGRM66h9o1ZVCJeRB+7CrW9/UuJY9aFarcbkJdtWAgSti4uLi8hTHB8fz7SHgsp9WAr/EYDfybJs56rSO/whhPDTAH7Vuyib8WUwns9pPxeBRmrGKVJ0BYbXCQjezKebdXBwtdvt6GuyvgQGrqQ8ODiIg1IjEXbGJTDwNzvTKjFprRlGPlh+lmW5MJzeR/MpqFBUDs66SuBp/Tw3KmU58D7WhVFwTVmd9pjnvthnpK6C7r9oU5MJCiGE6P8TDJgLQYVXy0x5CK59GQ6H6Ha7ODw8jJmM2raych+g8DmI6xCuXgJz9fU7AXypTCF2JrGdbX8rirtqByhSF0kKWF63deCJHZAcICQO2YZarYbBYBAJp7OzM3S7XZydnaHZbOaILDvQqahsP8vWHAL+rvyOJROzLHNfpMJ2sFx9nhreVL9cXTpLGKponWx7VGH1HlREll+m71lne77yCHS3siyLeQj6EhfgOopGUCBYsAy6GRpt07pyUVy3242vqB8MBrnw7izj+D5eBvOnAPyAHP4fQgifxqX78DXz20yiJNjV/ZImIMWag5qAkxJe47Hj9toyhM19Aoma/ixbk47ULK3X63HAECh6vV6cvc/OztDr9aIfa1dHUkmt780BTTNVOYnJZBJ3ALIAwH7lXypawt88pdVnr+6Jnst+YR1s5MW6NwRD3TRVxwn7VIFI72Gfr+fy6HZrPF93Z1ZSlO3XyBBdQn2rtFoSdvYfDAbY29vD06dPsbu7G91EzV0pK3d978MJgA1z7M/dtjyPkVY2mOdYs5HHTT1u+KAF7cjdS6+fVe4bEGz9tS/UV1YQpGnKwc6ZhFtzZdllcosqmoYyrTlfqVy/huz09DS3wSkHKwee7hDEXYHsANf2USFo6lpQ0ME8zZWzgEk3RsskeJLhr1Su35FARVWA8CwN+4xSVgh/V8KVfeNF1rhXI/dXYKq59q+OVfb9YDBAt9vF7u4uut1u5JVuM36BOcpotGjrPYAi8Uy4Wa8rawXchp+4rahZq0pKwNMsOZ5jtwxjiHI0GqHX60Uf1N5HlVN9V5bTaDTiUmCdxQkyzM4ja671YMhM8xZ4T8baqYA8h4BmgdEjJZUHoRJZt4aAMJlM4otTuL+hZoVa4FI3yfaZR5Ratl+tAl1spmUoCbmyshLrR8VneFn7ghZfr9fDwcEB9vb20O/3Y0bkbfmwuQEFT4osAXtOGUvAsyZSUlTeq+YZPDbeztDVajW35FYTh1ZWVqKCaPxaLQ0l4tR35e+csTnoqeBUFIZB6UqMRqMcJ0ALwiqMJQA1aUotPcC3/izbT0tBTWYtU10JmvL6xiwFBVVYrYPO1h7npXkSBBz+bi09XVlJ4FQCkc/DglyWXeakHB8f48WLF9jd3cX+/n5uRaSC9iwyN6BAk0sfnFW+WRIwKNYlsJLqMB2AtzXD7kN0MOlDtoMFuM7b0JmW5iiv29/fzxF8Siha60yPqWJxcxEuntI0XG79xQGtSmhnYdZJLQTdGdk+NztJWFAgMOhLXFmOWizq3qiPb2dxa4l4BKe6DHq+EpnaDvtnfX115TRLVK03/nZycoLj42Ps7e1hf38fJycnuW3kdZzMInMDCtZ90IFQJoJQhIaWl/DOLwKc1wEMRdaNNZM5sEhE6QxFBaZS7O7uRlNfB5oOXlUEHtcZtdFoRCZdt0EnCTmZTHB8fByTpyw/4UWZAOQUVXcs5nmWY7GKqKCgK0PJaSj7r1EAgpWnxNOiUcoXeBaMjeywf1iWJpfxmQ6Hw6jQ5D7URSFokEvY29uL/a31swBUVuYGFCie8in6qujMmVJ6Cyg641JSgKBlvApgSD04LxRHIo0zMsNYNCspnN25IUe73Uar1YrmPck8nZmUbNRdh/V16CTDaCXwuL78VIlLVQpLlFJqtVpMlCI42MmC11niVc/RRURcecht1FutVgQIWjtKymq5BLPUZGQtCm2f/mbrDNx0PXSjWM06VaJXLQCub+h2u3ELd2t1KPn5xi6dTvluRaIWRRnF9R5wijy0vvwsMgvxWYbbsGYr/WYmJ3GmUt/fCq0GzpI6yKy/rscUFFZXV7G8vIx2ux2ToOr1egQMzowkM3U9v/XP6f9TdNmx7h2guRS2z2zUQFl8+ucEA60vgUfDsnZ9gu69WPSc7KRlwcK22/r6zFqkhWTbrWOA0QgSjN1uN7ps5Jb0+d2G/5orUKB4ne/5orOUVaSURZZC0YDwypzGUdxG9MHqrDQejzEcDjEej2P2G4Ab7x3g/bl+gRt66CxOofIp+cftyFdWVtDpdLCysoKlpaWobNyevNVqxXsOh0MMh8O4cMf2j97XugWsh1oB1hLkOTymJB0BgFuV0V0gINKa0ZWFvJ91WWg5qYIph+G5DN53y9XwGEnYVquF5eXl+FyUZ9H7AZduIvmEo6MjnJycxGiS17/sq7IyF6Bw2xl+luuLZu6iMGMZKQKoMqA0rWy9VjPcuK9/u93GwsLCjTg2RROEOPOpb5+Kv3NQUqk4aKlYGnakMi0tLWF1dRUbGxsYDAaR+NJ1GOob64ym1oDyHTyu/UBzX92DpaWlXEiPqwxJuNJC8DI5FWz1/paMTU0Onhujv1syVK0E1o+u3WQyyYWNlXjMsstdmvf397G7u4uDg4O4WpIyazjfylyAAnBTsRSVgdu9UHba/e6DIyiyDO56v9TsSf6A234vLy/nFs0A+c1vNc7NGDbLK6pTCCFHLDabzWh2Kxgo2Vav17G0tIS1tbU4g00mk7jpBwe4vkRl1r5gBGFhYSGCUKfTiVaMLjjyrlE3weYfKJ+i2ZiWF7HPRQlKra/O8Pxs8ydYP66NABBJQz4/5Yt6vR729vbw4sWL+PYnLwz5xockKV48l5Iy14sUTjukiLBKSdmypx2ftQyKZe71dWY0I/v9Plqt1g1z2Iam6G5wBqISA9e7MpG0ZOSCZu3S0lKceQlM6utyAFerVTSbTXQ6nbijU7PZjL4v/WHuITgYDHJWCc16/tkNXqjYtFRWVlawtraG9fV1rK6uYmlpKfceBPavJlKlJhpdg6CAYBcjWRdBQUEV0QMGnfFZBvkhG/4lYatZmnxN/c7ODg4ODtDtdm/wMryPHUdlZa5AQVE0FfrRc+xMas03T6Ffh1VxF0DwQE8z3fiG4sFgEJWB55BnYDkaUaALQDP15OQkklUazmu1WlhZWYlptzZJh+Vrog9ncN5reXkZy8vLuW3MyTnQZyeAMIRIl0UBgFaKRidIfHY6ncgjeK6B7gOhz8Vm/fGZqLulloJ9bqnoiP2zx9VdYpSGfaPrJcgdMdLElZAvXrzA4eEhhsNhzh1MjdU3jlMAbuaY8xjFNtT6ZYraFtHvImXLKLIO7lIPy35brkAtBSqynk8TmgpHnxW4XKBDYGGs3loRnU4Ha2trMctOTVqu+7e+MiMA9O03NjawsbERX3bCOp+cnKBarUYyki4IiTe6ARpSJJiRHyAQEEBsWNGSlNOeieWaNP1aj2s5VERvZaYHJJpUxegEgZnRHp5H7oiWHt8i/eLFi5ibYF3HojaVkbkABTWNbWjNMqip8I/KbUjDMoNEpWiWTw28WdwNKi6V2u4DQLOz3+/j8PAwmppc5MMVjVQUMvPb29sx+kCAGI1G2N/fx4sXL7C/vx/fP7iysoJ3330Xn/jEJ+JMrO+E4MBnXTSMyE1fqKQ0kWmacz0G1/73er0cMcmXnugeBAwnMg/BZiiyL5Xj0P6yfa5+vcdpeea/fa6eFaCTmwUFLYdW72AwwNnZGY6OjtBoNGI/hxAwHA5xcnKSe16M/BDIU9Epr55lZC5AAcgvGilCNvXNUmLDQNPKmxUQ7nqu3jslXpKVDng+ePqZo9Eomp422UnJLM6sHGRUHM62miJN8m51dTWX6OOlH3umso2asA76DJeXl2Pokq4QV3Aqh6BRA7UMWQ4tKu0jL6rkJfGoEqsyq+/vtck+Q2shWBfXe958zicnJzGU3G63Y3vH4zEqlUq0lABEjoeWGvMT9B7W7XwjOQX1i2wqrD1PxUN4b09AT+7KFbwO0UGv/igzG+ky2KiA+uoamuO5nU4Hk8kk8hNnZ2e5eD/5ilRqsfIWWkfgJkuvrl6j0YhJTuQZaC2wHJvIY2dAJWPZLwo8lkewMzrP80hFayXofb1j3p/tKwvWtJzIudA64sY5q6ur8bnSZVpZWYkZn9pGfrYh3lmkFCiEEH4GwH8MYDfLsn/96tg6Lt/78Elcbqby2SzLDsNlD/wtAH8GwADAX8iy7Hem3YMP3XvwswDEfc7u0zr0tubZLKKDx7sXZwrdj0Az9JTJptnNGV+JR33T8eHhIU5OTnKJPzRn2W5NqtF6cCb2THYCtio6w530q7mYin86axe5hUWumSqI+v5q3heFIcuIZylRLCgoT0Q5Pz/H0dERjo6OorXQbrcBXFpxrA+f1erqao7nUTBWoANmd6fLWgp/B8D/BOBn5dgXAPzTLMt+NITwhavvfwWXezZ+w9Xft+JyI9dvnalWKKdk9hxLKr1KsTNU6hzg5pqKaeV6n1kOFUZXw+lMHELIWQl2gw8mPKl1pWnDdp8BnZV1prVA5bVDd23SvlDLkMlS+oJVL4ynE4jyS6k+VrfB8/mt+2ABwVN2+yxSz81zMRS8SS4SsAiu4/E41+9ceNZqtbCxsYFWq3XDCmIfqrug5H0ZKQUKWZb97yGET5rD3wHg264+/10A/wyXoPAdAH42u+yJ3wghdEJ+38bUPeJ/77Mn+uDsLPYqRJVaGeky1wHTLRuPV7Ci0QDdSk1dB3UfrI/JmYWDTtcoqNluLTnWf5qyaDv13l42oRLNzNDU/RFYTwWBIp/fq5+6DRYoFGBtmNWb+cvcx55n68A6Kyeg61qYf6LWUqvVwtbWVuQedM3DfYz9u3AK26LozwFsX31+BOCxnPfk6lghKHioDfgP3vsP+JllL1tYPw5mVeKigZQ6ZkXbouagztCMcTNrUWdSvRcBgAqmisqQmL5VSFfuaXlW8SwgWxDwAEMVjuWrFcFoFJWUS7RTUQF7zPvuWQWst2d1Ka+hJGaRstv26qRl+4TRGO0Dtp+AyKQxRleq1WrcNKfT6aDZbMat3Ivc2VdONGZZloUQZnKqg3nvA4AbfqPNN7Dkj224JaTuw89PdWZRPXnMKr0HVtOiKHZ25XE196nozFbkve05nrnPY9zF5+DgIG7WQSVQwioVIVLXQvvCMvH63DT7zu6PyMxNG4a2S7EtAFizX9N/dYZWUFJQ0MxO77laKQIf/c6yCDTkFfjKNwAxDMs+Z2hWt2bjeWtrazGt20tzvovcBRR26BaEEB4C2L06/hTA+3Lee1fHcpKZ9z5YFJ9mjtpz7CzDY7OId09dimqFg0kfGBVIN90oqss0q8aSeZaA1bwOxvk52Gl2qrms7gEHJwFlf38/koze/VgfuiNW0XRPB1UE3tsqNOunuRTec9Q1DPS7vcxXS+JZAFBgVEtBnx+zK9VK8PqB5fN/6o/1svdWy8SSrpSLi4uYm6HPkDkgq6urMdNUXZG7yl1A4VcA/HkAP3r1/x/K8c+HEH4elwTjUTaFTwBwYxClQMGb7Sh3dR1msS6sKehlUpaZYco8RLbLzgIcTBS6EbqngloSOitxVry4uIhrEPr9ftzDUVNteT7rTNNeBzhncQUbzdlXZWO53FeSOyBNJpMb74jwLEKNSHgWgF5nVxja823ZlrT1iDx9fh4QWGLPG1M8V1+ooxmRfOYETF0By4xRJm15e1V4E2ZZKRuS/DlckoqbIYQnAP47XILBL4YQvg/AhwA+e3X6r+EyHPnHuAxJfk+Zeyjxow+Mi2xU7AxxVccyt7l3UfOzqOOn1dcDCR0gnKFt8g3BIsuyXCjPAhVBQLkP3b2p3+/HlYzA9QIizsw2QrCwsJBTSnX9+Cx1oxW72GgymcTyz87O4i7LmhWpZKQFgZQFoGa092ev9dwPtSBmtRAsMLEu1lpjPXXjVm1fCCFuI2cBTDdl0a32bX21HbNI2ejD5xI/fbtzbgbgL89SCWtmqV8H3EQ69closlLsuWV9rGkWgmdG2+9FwETlKlu+HtPfFBh05gghxAUztBbsoGD2o85KBIWTk5O4XLfRaMR1CyyX7gj7fHFx8Uaij9ZLt24fjUZxoJNZPz09zdVLFef8/Dy3CxGFv3ngUAYwio6zfJ2lLTmo3EPqT5U35brZNRK8t+ZlMJuTC8t0/02mrOsCONbPEt7eBDpN5iajkTJNOW/TyJchd/XfdFa1x4n6XjvVYrDsPsGSrgIXNylRx8U16kOPx+OYZru0tIT19XU8ePAAGxsbERhYvp21tXy9P60EWhBW0ehu0F3R9xrQCrFukDX/vRlaQaLouFVMa26raP/afkgBi15r+00BjGnfmp9AAKY1wDppUpr9bpP+7jI25w4UZpUiEJkH8FDxzLhpx1IWhDcjAIhJL0z+UWUCkDPfK5XrF8XwNWMrKyvY3t7Go0ePsLKyEhdY8R6q+JbQ48Cmy6ADX0OMtDL6/T4ODg5QqVSiywMgZlByObW6Lt6sbJXesyK8/AMLBqm+t0qu9bBlqbVhz6V4gGRzRLgTE1dAar6JRoOsNaPHyuS5eDIXoDALqhU1MhUmu+86vE6xoT/rTvA1YughB0sAACAASURBVKPRCO12Oyo+TXTdI4CzNd2NVquFzc1NbG9vY2NjI7dluyo+uQnOTjRvdfMUdTnoCnBWpNJUq1U8fvw4ggjboOSjDTOrWMvB+vPTrAk9DyhOgLPcgwcK1nXwrqXwmalLYUGB+1iQN9AENGt1cGwo7wPcbmKcC1D4/4OUjWzoeZYbsQ+cxxUYLi4uIigwTZYKa9l/4Np94I5J3MGo3W7fCF8SVMiG04zlcV0aDSAu4OEGqgxBsg2j0ShuL3Z8fBzL4KpMJu14JnJqpk71adljdsa1olaXx0/wHBVbR+URuF+D7rxEMOVCNA0D01IgSczrtP7q2ioRXVbmGhQ8JaAous/S4Ncp3kxXZsBm2XVkwzMTmfHHhz8cDuNyar7/UU16XsvBeHFxEVffERAWFxdz53NmAq6jD6wLB7d9CQvz9HWVpZLHi4uLud2jdEv4TqcTXQ/daNVmaqrC2T602ZX8rua3xydY/sNaCSlew55H8fIq1G3QvAibs6Dum76Pk26aul33wScAcw4KwE30LpoR3jQpm6PgAZ+auOr7kmsgKOjsnGWXYUtNXwaufVzgOpKhlgGtBY0WDAaDnClLF4U8APdu4Atj9H6qqExY4stNyK7zPHU91K9WQNKZt0jZreuVOo/HaZ1pmWppedd6IEGXy6ujLvjSMCRfrsP+Y2ieroRun8/+1GdnAeKNthRSob43xecvI0UPKmX+eXxJypKi9UBGn0IlpzlqlcMSdhoaVqZb34PAMkhsEpjoNjBF1yoA60OlZ+iz1+tFYMuy7MYO0tx3UhcQpcJvngWgGaoWAFSKgCblp3vWhOc6WLeDlgRDvSsrK/GFO9xhiWFafu71euj3+7nt8+5LR+YOFFSmhYbKXPM6JMVg28GUqqsCgjeQ7e8p31ctAOA6qUhnbYILXQAqN3kImqe6GSqAnBugpixdGRKMmoatIMNr+Co75kkMBoNcFGE8HkflYP+x/pqjwuSfFMHnkYf2mVnA8oTKbAHV3tO6GQpgKcCoVqtotVpYXV2Nf9zyXTfE4Xsf+GYoO3EWAVcZmQtQKKvI1mebBwCwkgonThuUnnjEl7LwCg4qtAj4ByCnjPTtbc7/eDyOBCV3/VFfV+P8vA8VnlYJk264PyNdFiZV2XdQMIf/4uIi97ajfr8PADmQ4ua0NLM91yHl16f6SvvMU3SPU0j99wBBy7Nug2Y20t3iOyx0qzyN4oRwuW/j3t4e+v1+btk0y9boym1kLkCBkmrIbTIUX7UUgcFtpcgiUD5Bj7N/dN0BcJ01yEGk/mmWXb+Crt/vYzgcxpmZf5yJdVay4UhrJRBEuHMzF2xRyYHLnIS1tbXcOyu4iSvBQ8N22k7WX/vDKqL2ZYqf8fpRy9CZ1ws7psBAAUuv5XnqbumLbRh94TXM8VBQ2N/fj6DghU+99pWVuQKFlNgGzRswlAWE2wCEzQL0iFfvHhomVLOfi6IuLi5y2XSj0QjVahXdbjfGx2nua7iMysg2k7vQ8CU5DboDh4eHOD4+Rr/fj9GFLMvQbrextbUV94JUV4Y7PKtoWwlAvB/r5PE1lqfh7+qOecx9yiqwdVJltynoPE5Qtn9sB1PLO50OlpeXoyXEXbktych3PvB32+5ZiEUrcw0K1odOSeqcWcDDM8FnuS4VDipihFVSym3LmcXVoomuFgGAOJA0s46ZkL1eD71eD0tLSznmnNeyvcoV2AgFrYOjoyMcHh5id3c35/9ya7gQQgxV8h0Uyk/QWuBSbt6f9+C1uhGM10cppfdAQs38WSVlOVhCkVYCZ/lGo4GNjY2YI0IeQQGGId7JZBLfEkXrjKAI5K0Rfte6lZG5BAWdlZRl1zRV4Bo0lBnn9bOIjX3Th7Z1Svmj3kC00QElxNSMpQmudS5jEfCYDgAbjaCia/Yi+1VdCz02GAwiKCgnoL48y9aBTkKUKcv9fh/Pnj3D06dPsbu7G9Oo2+02Op0ONjY24j1oHrfb7QgGfGEMcyXYBoYmKfq2bY4bmwHJ52kBQfkC3oPtKjMR6WcvyqDjVe+jOSMkFplFurq6GsPIOoYYzaF7R+7FGxdWR2YlHucGFDQtkw9QzUn9fdpM6ymv7ZSi9QVe+Trj23M9QLDibTtvOYNpdQCKCVZrXtNVsOSkggDP5WzPGV5DhQo66krogFOzfzQaodvt5t6KXK1Wc0QaX4qracx8Oe3GxkasG7ebJ2AB+dWS5D60HNtPCsqWW/BIQb3eIwt1LKkboGLPsVEXRoG4AG1rawudTidaA2p5cUv+EAK63S729vawt7cXl7nbrQXYZt57FgsTmCNQ0AfgmXqp+HNZF6OI+feutQMiZfqnFNs77h2zZl5RHafNYNoX6st62YBqjVHRqXjdbjcXUmQMnISYXqvPjJEFvuuQb5qqVCrRQiAoMGuS19IK0GgEABwfH0fXgzF5IL+oSN9hoeSjkqH2GO9Z5DakACHlHlj3QQGDf3TpsiyLOQkEBWYrUtlZR+ZqTCYTdLvd+BYvri9J8Sgca6mJNCVzAwplpIhVtWRc6jxbVlFnlenIIl8/FTUo4xro+TrLeaKuic5wai3Y2L7OXmrmjkajGA7kmn0OVvvmZkuenZ+f4+TkBN1uFwcHBzg7O4usOl8y2+l04makOpip5FyDsba2FrmHhYUFHB0d5d4FoTxGyoKzac66jJv31vqrsqf4BhWr+Hqut9CJrsNoNIrv01hfX8f6+jpWVlZin+qYqFQqccs1WmDdbjcCh4JgaizpGCojU0Eh+C+C+R8B/CcATgF8BcD3ZFnWDSF8EsAfAvjy1eW/kWXZXypdmytJmXKphnm+4jSZBTnLkolF5dsy7HnTHpw3CxSJhsE0rKi7IpNAVNBh1IADlLsisf+p6CT7lBzkXo/c+HVhYQHNZjNm5/HdkBo1AG6uGKTJzPrzXPrTuuGILiVWoPfGgVV4XX5ur/f63/vT39SXVwJWLTICca1Ww9LSUtx8VXee0mgRQZJcTbfbRb/fv5GEpu3W8XKbSF0ZS+Hv4OaLYH4dwA9lWXYeQvjvAfwQLt/5AABfybLs07NWJEWGeP5eqqEpK+E2ksoD0N/s73pNSonvq35lCCSdwak8nFk0jEhF5GxNM12tCZ3lNKdA90/gH+vExVB8b6W+cNbOxgQgJS25FZkFTt4zhJDbkoz9SyvBM5s9xU9ZAtP6XBXe/lkrDEAEBQDRTVpZWUG73Y4WHJ8R+4jhysnkMruz2+3i5OQk9ou6g/bZ31amgkLmvAgmy7J/Il9/A8B/dusa3LzfDSbeY/4tlzANEMpkExa5HR43oMfv4sNpWUUP1yO/7Lk2AgFcr9LjgCOzbc1/WgM6qKvValRWWhDquzNPgSnRk8kkZ/ZTaclr6P2Aa3fGU1a6LLrDMQGDzDsBIvV8yaN4z0OtELUWUkDCazQV2roQlkPQKM1kMompzCsrK1hbW4vvhGTb+IwI4uy34XCIo6MjdLtdDAYD13pOkaazyn1wCt+Ly3dKUj4VQvgXAI4B/NUsy/65d1GQ9z7QVLw6nvuszHZqZrQJPupjO/d1P6ckxRnYMKYy39MU15Oia6ypWhZw9DwmK2lkh+XpfSyw8DOBQWdy5S2YfUiw4JJffW08y9O2KDBZ01zN/MXFRSwtLcX6nJycYDQaxbCrBW22kfX0okdF3I49V7kCBQUPBGwoUqM7tID43ga+dl6VWffCpGU1HA5xcHCAo6MjjEajGyF0S3reRe4ECiGE/wbAOYC/d3XoGYBPZFm2H0L4EwD+QQjhm7MsO7bXZvLeh+Xl5czOEJ54ZBJw08VIhRtnsSSsVZDiFayS6bneLO/9pua0AqC22VpP9pgVS6Z5+QSWpLN9qAqtr7u3HIAqCs/nLKw7L9lZO8uyyGtoO1muzrAsW/ufSqA8B9unfUnryLbX9pM+VxXrXiiAse0KmhbkCApZdhkpWV5ejgRjs9m8YS2ptcC29Pv9GHXgpjjsA43KpMbKLHJrUAgh/AVcEpDfnl21JsuyMYDx1effDiF8BcA3Avit297nqqwk0ciHb2eJaTNqkbvhWQWetaD3nybTZnfW2TMHrZTxF+39LMueUgQdmPzTkCaVlr4xBzB3SeLmINwLQLcit7soqdKwjrQePDJUuQbNfNT6alvUyuQ52kZ+9txC/d3yBlbZ7VulUiBSq9XQarWwvr4eozCabWpdYgBxr8put4udnR30ej2Mx+Ncne1Ecle5FSiEEP40gP8awL+bZdlAjm8BOMiy7CKE8AEu3zz91WnlWfPYDnrr06WkyO+3x6YpaZFlUHR+qo46+KYptSW0UqTltDIUaFQJOYCo8FYpU1aXtk9JMb7ujG8uIrFIEk0tBQUFG/VQQNCoBmdg7lHIfAa7aMgDBtt+25/63QN47a8UIOh7LYomI27GurGxEdeX2C3a+V9dp/F4HNPFuYeCWotFoFZ0PCVlQpLei2B+CEAdwK9f3ZChx38HwF8PIZwBmAD4S1mWHZSpiFWAFOqllLLI/ZjWaSnuwbMY9HcPrLxBpZ+ntdMDBOvrq/lt2+iVpeBAMxbI70eg9dMVljRVdfNXNefb7XYMOdI64B93I1YzWP/0/REhhBhqJDjoOyxOT09zYFCpXK4ZoOnOvrfbt2lfpVwl/c26GOrGaP9oIhL7Sl1A604yX2NjYwMbGxtYXl7O5YwoOPA7U7oPDg6wt7eHFy9exJ2WeB7vay0ijZDMGpUrE33wXgTztxPn/hKAXyp995vX58ibLMtv7mFJHc48JLWmWREUr4PKWAC2rl45tg48x67bSJVpgSZlNaXcGf5moyD03zVkyF2UmGHHOnLL92636xJsXJwTQojRAd0UhINZN4zV9lUqlVwoUZ8t28zt33XJtYKQMvaqXNo/qnBqKajrQ9El5qyT9i/JVF3QZHeh5kpGXR9yenoaX97y6NEjvP/++3jvvfdiPymAsU4khbng64tf/CJ+7/d+D1/72tdijoK60yGE3FoW9sltZa4yGj0/yRJG6lvST+Ug9BQ45VKUkSKuoCyXUNbP86yOMuRrqiydKXQAWaCxswyP6ezImZvX6sxI5eHya7oJWg8NzXHgqvWg57IfuL/DeDzGYDCIkQ3dBIbKRzdGZ2nPhfB4Fttv6uKptaYbrBIUNKuSVo+++5F1Y4bm2tpaDjjV8tPIjI6tXq+HZ8+e4fDwMLfWgVGVlyFzBQoU7RSvw5iVp/nuFhlTBJJnMcwKFmXOvy3xYwdqyhUqul5nRS1P+QM9X/kSfrccj87kajWwDKZHe8poFYnrMfgseW8+azX9dcPT0WgUFZE7VTMXwron2h6KpiJrX2ob+Z0AoNfaDV8IdJyY6CrpvWjdEBT0BTsKXjreOZ6zLEO/38fHH3+Mo6OjuNKUz0ef0bSxdq/uw6sUNkx9Mjuj6D4ARGi1JigeMVhENE6biWfpVJ2VbdtUUoSX/WzvXQYYvHJ05rd+LMtN9ZcSlbyeCUTcbs1u9qEmPBWNpBwtFA2/cTUgoxdLS0uRMxgMBjHFmWnU5+fnkV/gik4FFx0Xmqdg+1lBzkYQ2J+6ylETkXT7Oe6DwM1x6QJ0Oh2sra3dWBmq9VRRd+fo6ChGHZT70IxJtQw9uXei8XUJFd7OKMA1MHixduDmUtJZCMZZZBo/oJ9TSO65DSo2jDbrA7b30gHEPvSsE7oE7Etdr6BKo3s02DUN1tqg8LmqC2hJy06ng06ng/Pz87ipCP8ICCcnJ3Gc1Ov1wtnSAhrbqaFGte48d0otJnUZ+FepXL+PgaDHLda4xoGgoJaC5hwQKJhBuru7GxdAqfVrSd/7lLkEBTVpOXCIrvzd80dT+QRlTPD7UDotSwdYykqYxeS7bb08V0DFs2p4HU1YHbA6+yszr5ZZavYLIcT0Z++/rqZkxh+thMPDw6h4XJJNoo/7Qdr+tlYSj9nIgroDnpIpICh5qfkZ9kWxWZZFoFtdXcX6+jqWlpai66ChWS+axO3uuWsV3SivPtOe/6wyN6BAdNSO0b0Ai0g3DdeVDb/YvIJZOm9W8lBnpml1siTjtKjKtHKKACFVT50ZFSzpylkF0nwFDnhN1Q0hRAaeZjYjCJoCTX6AKykZFalUKnHPSJbZ7/fjy2NUsUnwaX9b39v2DfkOtte6UdoX6uLanAvmLWTZ5ZutuL5BFz7pi10UDLRefJXe3t4enj9/Hjdo5XPwrJiiaNSsMjegANxUfLv/nlVkPVcthbu6BXeRsgpszVhKypyfBRg8Vl0VwZuZ7EyrSkCl14QZ/ikg6OInfXkLf9dsx9XV1Wgl8J4EGvWbAURQ0bUPAHL+NEOEXJRlN1zRNnp/avkoqW3JUuCa5+J443HWlzsqdTodrK+vY21tLZezQc7B3lstr+PjY+zs7GB3dzcHdDpxqqUzbTKcRSfmAhSsmcyHadNi9SF5cpfYrCdFFsFdfLlUueoy2fO9sKFek7qP9pcqnCUEU9cTZKn0ugcBAYGbsTCurlmH+tq4SqUS91Vgii+VhLs+kUzU2Y/WATdmIfnI3Zg0yYqApAquCqh/msmpyuZZFjxHiVHtQ7VS6vU6VldXsbGxgc3NzRiG1LUbysnotbQ4Dg8P8fz5cxweHt5IRkpxHymZdZKcC1DQgakhKpqjs7Dts4o3q97lHncFEtvWFB+hn71rPJeAimwtLlUQG30gi04F14QjJQi5Q5Nu3UbLQJ8jrQPWWdOZ+U4I7nJsc0wIONy1SDMauVKyUqnEjWFoMRBkPTDQ9isQ2X5j39i8GH2pLoC4qQwtBO4ypW32nhXvQ3Dc29vDkydP0O12c1EU68boYq/7krkABQofHgcA0ViV6T7Z1rKAkJJZz9frPGLPe7Ceqa/f7cyvMq2vdLZSQpHKRd9XlVEVnGBB01h3VgaQ21NBORLWmS+FodlPUNC2a9uoHOqOUCkZpQCQU/CidnuRB9vfyvFwTNq9IQgydI2Yyry+vh55BOU3rOugn0kw7u3t4dmzZzg+vrHA+MaztenqnswCGnMBCvaha8jKznqW/OIAvqvPXfbc1HVlO70MkKjvbuvhgUMRMFixrhr3I+B91Q/Xe7GfCRDKGdB9WFhYyKUq67Ji5YboU08mk/huh9FoFMk+3V+D9VDfni5mvV6Pqce8Vjc9Lcp0tWUqYaefta/UneW1vB/TvdfX17G9vY133nkHnU4nviDWWness92ybTwe4+DgAC9evIhp3ho5IVir3OdECcwJKGiHWUY3NavehUz0QGSWjk35cyki1Iqtv7USvMiBV0aqXh6xqFyNmsv05xWILJlHn50msF0Gzes0HKczrEaGCBhk6vluBxKEbBeBQXkFbTt3QqY5z7Ady2b5NpmJfyQTte8s8arWjeW1lBTVJdHcmXl1dTW6VSRp1SqhhaPcx/n5Ofr9PnZ2dvDixQscHR3lSMbbyG30ZC5AAcgnK7EhXtxYBxiQTvi5TRRAj3mfWU/veKouKUk9LEsO2rZMIxa9cjQrlCaqfSWcrZMOYr6ghW3UiAEVxOYvqEWnPIOSa6PRCL1eLwKCEoMKOOrn8ze+rZr7NVB5SFKybboXhJ1w1EJNPQePr9FxubCwgFarhbW1tUgsMieBHIzN76B1oG4bQ73Hx8d48uRJXBGpz4KAZGWa4s/KN8wNKADpHAM7e/GYvTYlKWW1M6oe967V2eU2JlsZ1+Eu+Qm8hw54Jdls33Jw01LIsuuVfvV6/cYuQtwslT4sIxLNZjOGHvUelrPQbcQYPej3+7FuCggaztRcFc1n0fyAlZUVVCqV3Nbn1rpQEFPlVqtGrRJ1Z9VKoJDbIBhsbW1FQNBNallHXXLtbVHf6/VwcHCA/f39+Ko8b9wr8chj9xmGnwtQ8NwBGwoCrv3au/AHWn7Rce+6++58SiqRapZ7lXUx2C5PMThAaZprZIADm3J6ehq5hPPz86jEaslp+M5aFN6bqpXdV1BQ60yXSbM9JDuB60VfXvSF7eZxVVQFHnW5tN+0jyqVSi70uL29HcOP5BEItLpmglwC+53nnJ+f4/j4OL5EhwCqQGQ5Hv7Gut3X2Lztex/+GoDvB7B3ddoPZ1n2a1e//RCA7wNwAeC/zLLsH5epiK5zUPHM99vOolqmXu/5kym5y309JVVfl+do/ZRUShGbHpfAsvV8VRQdTOpqVCqV+H5DNfE1156kIP+YaqxhRPunfczIw2QyiXsU2nUEmhehzL0CGQGF1gqtDK6mpHjuoZah57AP9JnolnAaiVleXsbm5ibeeecdbG9vx2iDvm5Psz8JDuqyhXD9Zq39/X3s7e2h3+/H7M0UKKTGk5VZXQfg9u99AICfyLLsx0wFvgnAdwH4ZgDvAvjfQgjfmGXZBaaIzRCze96p6EwB5LMd7W+UlNJbQHhZkspUtDNS0fkqZaMNQH5g6IxFhahWq9EaAIDV1VW899570ccFENca8HmoX6wr/lL39gCjWq3GpcTkB5jboHkPnE35R2uBUQzbD6yjWkPsL/3NE2/1oo6RhYWFuBR6c3MT29vbePDgAdbX1+M+CbxOSU+7ylLvwZe87O/vx30T1GJMAf20Ccq6T2XlVu99KJDvAPDz2eUGrv9vCOGPAXwLgP+z6CJ2EB8+UdV7cNb391h7/e4Bil5/F0CY1Vyz53sDuojI9M7z7qGmpGeBKDAoE08QXllZwSc/+UlkWYa9vT0MBoPcALU7EHlkrRVmPtJFoNIzu5ErCBnapBtB98HuhcA26h9/J5FqrQHWM2VxKSmp7VWXgVGGra0tbG9v49GjR3Grdkvo6ji2L4fRc2kl0HXQzWit+5MaLyk+rmisJJ/VTGfn5fMhhO/G5U7NP5hl2SGAR7h8OQzlydWxGxLkvQ/2vYLszFRH6HkpxVQT2ZNZogqezAoIXhumPazbApZaTdYlUyuB5esMXqvVsLm5iQ8++AALCwtYXl7G0dER9vf3EUKIm9swvVi3Nrd1IEkXQojLopmNSDDY2NhAs9mMyU/6fggNJ1pFtjOpnk93xK4Z0D7V89QS0edCxdZkKYLB9vY2tra2Yv1tCjO5A93pmdYVgMij0B1jCFLzElIAoO0g4WrlNm4D5bag8JMAfgRAdvX/x3H5UpjSksl7H1ZWVrKrY3H20cUwmlCjIS8Ve8zjDaZFNmZRwlmJndTD884rM/MWiZ1hPFDQGdNaX/V6HRsbG6jX6xiPx2i1WhgMBnGwMm+BW6PZsKYSllQoWgPtdjtu8soMQM17sJEGzYPwxE4mCiRKxllTWjM1mXRlAY7lNBqN+HLcBw8e4N1338X6+nrMRfCiLgRMdbnYBt1/gXth7uzs5N4krWIB8a7jY5rcChSyLNvh5xDCTwP41auvTwG8L6e+d3WsTJmRgNKtsDQkBdx0CTRE43VWWUW/zaw8y4N5GVELT1JWFU1wy9VYIkv3UKRvT6XV9QbD4TBmFHLg0zVgWFP3S+CqwU6nE3cgsisZ1Z1iWTYKZUlSy3HYSJUVdRF0GzWmVyu3wmXcjDA8ePAADx48wPb2tpvarbkd3nspeH8uHgOAw8NDdLvduOUaF3bpWC6ymIuO31Zu+96Hh1mWPbv6+p0AvnT1+VcA/P0Qwt/EJdH4DQC+WKZMdRt0wF7dD0A+mUl/V39Yy/M+a3lAubctTXsoZSUFPLchDO1xzxLywrz6x2MECyooybR2ux2BgTsbLS0tIYQQ9zfg7Mr76b6ZGlbklu/Ly8uRkNM2KVHJsUCFUuvGAoTuqqyp0tYyS0VFaL5rqrRaB6urq3jnnXewtbUV8xBWV1dzy8QtcGkegrpVjLDQXR4MBnj+/DmePXsW3+lA4pb9oH3kWXYa2bH6clu57Xsfvi2E8Glcug9fA/ADV5X9lyGEXwTwr3D5Orm/XCbyACDHZnMQqH+p7oGnXB6pmFLCMlaBd84sjL9Xv9v4fmXDrzrj63ePQafoYGL/cnUj3xhNcOj3+wAQZ/hWq5VLa6ZJroCg+Qecdfk6erXsVGE565MsVEVjfW2OxdnZWYyOkOuwJK7yDdpHFxcXcfs0KjDzNAgEBAVd9ehlKtr1DNZFU3dlPB6j1+vh448/xtOnT3FwcBBdNLuTlLXmisaDN55mtVLv9b0PV+f/DQB/Y5ZKqJVgd9H1/CuPEOJvKqlQjpWUy+FZGCnmuox4IckisfcrK0og8nsqvGsJPSqv3RCFb5xW18A+C/I/mnNiwYnAr/4+k4eo4L1eL+6tQHBQC0BdRiq57hSt/aefPWuEZbM+3BXqwYMHePjwIR49ehQ3XeWeCPreSn1GBDPdAp/31jyMSqWCk5MTPH/+HB9++CGePXuW25jV5k5Q7Hj2xr2duMpYwlbmIqMRQG42oFQqlYi+wM3Zzpu5y7gBZc+/b1+NkspPsCRjylrx6lfUL+oyFLVJeQPOaEtLS3j48CFOTk5wcnKS211IlSzF5ivfo9mDNLt7vV40+7n8ud/vYzAYxPtZnknL1cxBgoZamJydeb5dYMR6EhDpIrz77rvY3t7GxsZGtJa46pJ9rSFHdaV0HCvHwk1ozs/PcXBwgMePH98ABM3VKXKBddxa8PNkFmthbkBBw1vA9aADEEHBIuAss+h9sLVF9ytSNp0xlABTFFfz1Sq+dSGsJaO+ZAocNIHH+p5Uimq1Gs17WgNLS0t47733sLOzg+fPn+fe+EQAsFmHNgdCyUTlLs7OzmLCzvHxcXyzNd2BwWCQcyGs6WzzFFgHLpJiLgQtGFop7COCBX9vtVqRSHz48GG0ENgfBAQC28XFRe61cbrhCq0Zu0UdgLhL8+PHj3PrHOyCLW88eFI09m4z7ucGFNTEpQnlbUumZuiswPA6ROuXMv/sedOkSPn5uzdQCD7W5FfFYLSAoMxchc3NzZh1NxwOcXR0FBVeyTMAOeuOaxEYSeBr66j0T58+xeHhIY6OjuJsC+CGb+65eEousz+zLIuvxszq6wAAIABJREFUaiNBqrs56QzMV9iTAF1bW8PDhw+jtcClz+rqUDTfw5KLwHXUTPmVhYUFnJ6exjUOTGm2HIi1iqbxCPctcwMK1o9iKmtRptasuQKvWqziEvDYRuuTpkSthdvyDFoPa2HwM0lG3VaNoPDOO+/EFY27u7s4OTmJYNRoNABcbw1GXx3AjRk+y7K4t+LR0RF2d3dxfHyMk5OTGG2wdfXAVE1sTiK8F68h8cgIBScZJUAZcuReCJubmzFDkYSi9hnrYgFLZ3Z1pTRDs1ar4fj4GLu7u9jb28P+/n6MfOg4tsllr1rmBhQA5B7yNO5Ar3mThBaQWjpFFsMsIOApuyWkrK+q5VcqlRvZebVaDe12G++8805MaWauPl9QorkNducmBQgq/Xg8jlbH/v5+bsWgAj2V37o7aiFaDkqVNoSQ29SVszUtgFarhZWVlbgHwvr6ekywIpmoIKOJVDZ8butRqVy/AZtWCyMOH330UYw4DIfDHCioq1TmWetzvC+ZG1DQAeuRh7OE81Id+rKIwyLRGUZnNW9fvWmchQ76sm3xYvtKrlHoU2seP+9RrVbRbrexsbGRCx0fHBzEtyCfnp6i3+/fSDYDrrdgo5INh8NoHaibwXaVUQi1ClJ9pBMMMwXVRdKEJOYkcE9Fb2dwfV5ev2o9NFJDLoJJSk+ePIlcgn0OWoa1Ttimly1zAQqeSWvDjZZDUJJsXiUVPSAwFLlGRTKrC2HNXO9aug6dTifuGEQyDbjcHm1lZSVn2XA2JTAMBoMcWWafJds9GAzQ6/XiLMnzUysXgXxOhV3gBFxbDxrmZLs0VBlCiBuykEN47733cjtEaw6Cvb9+11ldrS0NzbIsLnp68uQJnjx5gsPDw2jB2LUXtt2vWuYCFADfDbBWg/UtvTDNbWP/92lFpMJHqeMa1isrqXCkrQcHL8krC8AkBbkZa6fTwdLSUi6rjkDCTL+1tbVoMdRqtWgGa06BzfTTeoxGo3g+cDNjsegZepaBBz48VwlrEoInJycYjUao1WpYW1vDo0eXa/aoxF7IWPvBWgccp7rtnK7n4A7NT548wccff4z9/f24vZ19nlpmGUB4GdbvXIACO0BnA/tAy3IKRYPqVbgVKcX3zmFbFRy83AUVL8MxZTV5Sumdc35+Ht/2vLq6GolDvUZnQmb80SSv1+vxNW7MDuTsSFKR4TpNS1bLIMWwW+UoStixk4i1LMhvMOdiMplE64jjTRd3WSEYKMnI/tcEMHIJdBFPTk6ws7ODp0+fxrwE3cp+3mQuQAG4ni2A66Wx1iRMWQ1WvN80jv6yuIUygGCPWSuhqH7sh1SWWioMaWc2m9dAEo2cQrPZjEqioMJjBALupry0tIRerxdfEc9zjo+P0e1243HdrYnmvF2foMqmboAn1n2wgKGWB8fUxcUFTk5OovsSQogp2+PxOL6/UpOU2E9ZluXCpjaky2gNrS5yKd1uF48fP8bTp0+xu7uLwWDg7tKcAsZpz/i+ZW5AoYx47Loep6SU41UAQ6pORfVSVnuW3IsUOKhyedEG/czkI8bpuT8Ay7WrKm2STqVyufEIQQVAJPP29/exs7MTw4NHR0c3gInPQiMLHqM/TTyzW8OJOnYGgwF2dnbw4Ycf4vnz5xgMBjfW2Vhz3patooQsMyh1d+bnz5/j8ePH2NnZiVut6fNTy1HLfF182dyAAgcwO0PDW5bZLfKhVbwoBpDnI+4THLRuXrn0N+3spyBlQ3IUnVFt2XaRjy1H3TK1vqrVapwd2+12zPdvt9sxosAsQ36n6U+XgLMq90jQnZSePn2KLMvw+PHjnCVoZ0Sb2WnP0fp717MP+DtDpTTfWSazCw8ODvD8+XN88YtfxKNHj/BN3/RN2NraQrPZjHWhpaBAoC6U1odgoPtFAsDx8TG+/OUv4/d///fxB3/wB3HPBHU/UmSzWsiey+j13X3JXGT+2AFgfbdp13rMsP5mRSMaNiZchM6ehaJkHgegKkBRPbU+NtwF3HzHRZHYerAcXQNgAVUBhFmJVBya20Xkmr0/Z/zT01McHh7i448/xkcffRQz97w6e+2397HPs4h78Nwr5W2ouFl2udXc06dPsbe3FzdKZflqIWlfaVuZuqyLwGhxDIdDHB4e4smTJ3j69GlMVOLz5J91P9SdtMe9UO/LkLmwFDxFUZIrRTamZhwt0+MjANwYhF5c2pMUqVcEXt7slzrP1rPIQrD18NwI9l+tVsulkaufDFxvqqIpzizfgp5adR5D3+/30ev18JWvfAVf/epXsbu7i/F4nBv0WmevPioKZkUkYOoaLZeKPB6Psb+/j2fPnuHZs2f4uq/7upxlZXkDK5oMxfMUeAeDAXZ3d+MqyIODgxsAY/tCLQ/2ZdF4eFkyF6AA+MDAmS5laqbEnp8Chmn3nyZlTTYdoEWmoC27zACwZfNYEbNvlRzAjfcuqrWmBKG1rDQvAUBcF7Gzs4OdnR0cHR3l6pJqu2d53EZ0MrFtt9YOAWxvbw/D4TC2h9mQdlUm/zM/Q/ub6xwIxN1uF8+ePcPz589xfHyc40mstWUnsKJ+ehUyddSFEH4mhLAbQviSHPuFEMLvXv19LYTwu1fHPxlCGMpv//NtK2ZNSztLpSRlWur/+5BZH5ol07zy7Ex524Hhzd787N0TyMfoqTy60MfuRsx2KLEGICrZ48eP8eLFi5jYVGTlWAVOAUQZVzIFhqqQVOgsy+IbnhUU1M9X14l9a4GQ/cC+o5WgOQl6f/1vXddp4/tVyK3e+5Bl2X/OzyGEHwdwJOd/JcuyT89aEX1gekz9QQBJM78sYZgyT2eVsjO+zeMvc/00q6ZIbNi2iAPgXwghmsK8XsFAQUHbpDOkRhh2dnZiKi+VzWsj65jqjzIAWYZL0rHF/xxHo9EI+/v7uTdvE8CVFFYewP7pAqvBYIDDw0M8fvwYjx8/jvtFpFY96nh/3WBAudN7H8LlCPosgH//fqsV7633unFMjwN369T7fiAeKaTRFT2mYk3VMmIJxCJTnGUqeaUzHUFYtxZTl0EVS5WLxBrdhsPDwwgIGmbU+njkqip0GcvAlpfiJXQyUQBktqFu2Kr9Yy08L1rAc+iOPH36FE+fPo3hTq8dXharx7e8Drkrp/BvA9jJsuyP5NinQgj/AsAxgL+aZdk/n7VQi6TTuIBpSuQ9RF6rZdyXeA88BXBlLQ4rtg1em1RB7P29GY/nqdugy3gtG06SjVuovXjxAs+fP4/vMLD94W2UomJn0SJJkbcpF1GfBWd2ggLTnnV9BP/rZz1m+yLLskhefvjhhzlLScdXaiym2vc65K6g8DkAPyffnwH4RJZl+yGEPwHgH4QQvjnLsmN7YZCXwdj3OqhSTSaTyMYWdaD32zTm/mUAQapsDp6iWaNsnfQcz4Ka5pboYFYuIcUnKGvO+6k5fnJygoODA3z88cd48eJFfPckfW+9v3VnUhZgGZlmEdl7qDBScH5+jsFgEEGBY1H7iWXb8iqVStyqfTwe48WLF/joo4/wR3/0R3F35lnc1bv0xX3KreMbIYQagD8L4Bd4LMuycZZl+1effxvAVwB8o3d9lmU/lWXZZ7Is+0yKJ/BmOWWOLQmZa5iJ975MmQYIKbnPenntTLXdAoMuAtKog93sVYFkYWEBk8nl9ujdbhe7u7vY2dmJPjSQJw5TBJpaNHYJchnxzp9mWepnpjdr6nWqr7y+IzAOh8PIpXz00Ucx4vCq5D5DlXcp6T8A8P+1d22hkWXXdZ1Sq54qqdTdqpZGrZ7WjLsz9nw4HowzEGMCgST2zyQ/wT+JHQwhYEMMCWQS//jTCcTgQDBMsMEOxibEDvZHAnFMQshHnNjGHrvT8WMm6mlJJalbaj3qpSpJJx9V6/SurXNfpZKqZGqBUNWt+9j33nPW2a+zz/9aa1e5wRgzZ4yZ6H5+Dp11H96MczJtXwY5xvS+vmMuIpbL6/iSTeLCNyLo0SipN5qNVW8L+tPagjQfpI2uCYH1Buv1Oh49eoTNzU08fvzY1QiQqdu+BDFt2oQ5GaOgR/Gg9+BrQ8zUlPfrk1H7X0igQMd8qtfrqFQqWF1ddb4EypMESUwoiUESUJyQ5JfRWSD2F4wxq8aYj3R/+iB6TQcAeB+A100nRPn3AP7AWrvTj2B6hJGNK6rBXBRDJyWCOHL5zpeE5HwyyQ4jV0jyORq1P0d741n3MJPJoFaruQKkW1tbboUjGYLUmpxu9EHkn6QzBflugp63lEk+E5ocOs9FRhlocgA4FcFYXV11qczMkIzyiQXJN0z0u+4DrLUf9mz7KoCvnl2sDrQ32JinxUnCnDc8Vu8XhH4cjfplRxFVnJEvSIa4iUzyPLLzafVfq7/yu5SXZMGMT2YDMjIh6w3u7e2h2WyeUrV9fhRpAsrftTbRzyjr+6xBUtDPge1FakY6AqEd4HLSE1Omm80mMplMj+8hbkcftj8BGJG5D1HQKqhk+qiXD/Sqgr6/QSBohB7kNeJC2+h65NPFRIDTSTuyUzC3n+suWmuxv7+Pzc1NVCqVnqIhsiNIk0PKFiSz/O/TloKIUZsFPl+UvCcfdLhRk4Lcj+aTMcatGM05Dru7uz37kpjDrjtqGNk05yCbkL/psF8/apo+d9zjw64VZifrfeJcT99nkHYiRzJdIpy/y+Ip3CYzEmXH005GLhYLwGXsMfyo6wNIQtCdVHdMTe5h2pKU3acFUbvhZ3kuOZ9AQm6T+/vkkCO+McYVsF1fX8fKyoorsSbrW0qtKOy++DloP989Bckmt/WDkSIFneXFB8CHwfAkIdW/KI9zkJ2tP0d1VHmtqFEvaluYvFKWIEKQo5B8RtpJSOTzeaRSKRd+k5qAHhXl5CmG3jiRaG9vD+vr69jY2HAdwUfqPhNG3ofWpPR96neU1OEa9l1enyapNhW0hqCJjnkJLLN2cHCA4+NjNzdCk5YPQZqkjwD4TOPAlysTFyNDCpoxff6AIObj/nF8B1FIojEENXTKlOS6QYi6N1/olRqANB84ZfjKlSun8g8AuDUSpeYlaw1OTk7i+PgYe3t7qFQqePDgQU99AF6T19PvKuwZhDX2sOOCSEMSEr8HEQqdp7IKNc0lfpeEwO/MXnz48CHW19exs7PjtCVrrStLF9SetImTJGEr7vak+xAjQQo+gX0ZjVpT4LFhnTiJky4OIQSd7ywvrF8EdSY9SgOdhj4zM4NUKtVDCtQUNCmwE0xOTiKXy7lOQLNhY2MDu7u7ODw8dGTDc2uTIYgoqIloJG3ken+pnWg1HugdXLg0Htd5pAniI2ISr7UWtVrNJSttbGz0zAaNGyWLIoS4hBh2jn4wEqQA+KdEaydNmF0lvcm+3+JoEnEaaNioE3VsvwiT3+eQo5bAKAELqFy9ehXA03U7af9K80BrG6yzUK/XUa/XsbGx4Wb/NZtNTExMuDoMxhg0Go1ThU2j7Gp5H7ozhSU86WcUdl6CGYtsU7qsvVyBWp9Hmg/7+/tYX1/Hm2++6YrISF+ClEv6OeQ9hN3foNDPuUaGFAhti0UhrqofpTEEvTyg18ZPYl7o45PIG3SeKN8Jn53s+KzSXC6Xe+YycB1DqUIbY9ycBgDuMzvBysoK1tfXsbu7i5OTE+eA5HvzkXuSkJxEVIeJOmdQSJDRLADI5XK4evUqstnsKTOBSUpysGEG5NbWFtbW1vD48eNTM0Hj+rD0ABjlM0jSwc+iOYwMKUQ57/R+hOwocTzYUaaE7nj6ZSYlBh/BxDk2aMThb77nIHF0dORqKqbTabcaEkdya60rKMIai9QWZH0EYwza7bYrGsKJPozFkxS4n08mH1EQvkhEmDodxwaPIhOaT9Zap0ExQ1NHs7RjWzpaSY4yP0NGQcLk8PmczuqgHhRGghR83t4kntYkCLItw7y10r8RJFMS2ziKGPrVRLRGQ7mz2Szm5uZQLpexv7/fY/MeHx+7RVanpqaQzWadUzGVSuHw8NBlLjLa0Gw2kc1mkc/nUSwWUSgUvE6+QY5sSduCdPJJzYCLs3D163w+j9nZWWc60Y9C0mS74PWr1SoqlYqrzlyv110Gp3xvvtL0SZzQUfd7nlmPI0EKhBxZgpxQYWG6KE0gTiRDwxcVkbLqsKm+XlJiiEMIPu1Img5yhiNHw5mZGeTzedTrdZemzNEwl8shn8+7JdNkzgIrOnPp+FQqhWKxiGKxiGw26yo3Hx8fo9FooNlsuoIlce4lSZRG/n4Wk4TP5sqVK5ienka5XHY5GDKrUV6XxPLkyRM8ePDALRDLcKzM8ZDmrx5IwjSEOE7ui8BIkQIQHI/WISFu0/BFKOS5pTdaE0PcRqzTgQdFDEkIwddoJSFw1p+1FrlcDtPT044ImLLMc2WzWUcUdC7K88sVnfL5vDMxWM68VCoBAGq1Gvb3908lM8noQ5RpMMiGH/Q86QilhnTjxg2X2MVOLLUpfufkr5WVFVQqFbeOhfY78Npacwu67zi4KEIARowUdKMI6/z9OuyCiCHJ+Xzh0jBIdf4saa2+/A1NCGxkzFHgatLFYtF1elmOnL8XCgVks9keu/jo6AiNRsMtsZZOpzE1NYXj42OnbudyORfSKxaLqFQqzs6WI6cmdD7DOH6COJ1LwxeV0ecrFAoolUoolUrOpyCPl0TVbDbx6NEjvPXWW3jw4IGbESojEr5Ilf4cV8PRJmC/iKuFSIwEKSQdJc7iwY86n1bL+1VTzws+E0Z+lh3MWuvmK1Dd57JmdBBy+Tf6E2RjrNfrripRKpVyhEAb+uSksxYjF4I5Pj5GoVBwGX2Ug9DmW5RjUR6XlBh8+8gOTEKj7HJBXe4rB49ms+mKsXKOQ6vVcmbHIDEof5qvfcTBSJAC0DtyBKnUQewvR24N+TCS5CkkaXyDJqkkkB1L2640pTia5/N55HI5NJtNpz3Q0TYzM4NcLgdjjAu77e7uutmPmUzGOeTkorE0IbhMfT6fd2FMyqDzLHw2dtiI1q+TUZONJFOaTfSj6MlLWo7Dw0M3AWxrawu1Wg0AkMlkep691NqA3qpiceTWGuAwMDKkAAQnrshJOtLe5QvUampYIwoL9flGI/1i5D7aHPD5EyS0ryMOmYRpKgyZMVLABsk/ru84NTWFQqHgOjBNi3a7jVwu58iBJoH0SRhj3Eiay+Wwv7/fU9Mwk8mgUCigUCg4p6ZMd/Y9O9/9hZGB7CzSvPGB+8r3o0d9JnUdHh6i2Wz2rDTtI4R6vY7t7W2XuWitPdXZeT15X/qefR3d5zAOIoSwMGeQid2PryaSFIwxS+iUd78BwAJ4zVr7GWPMVXRKsd0GsALgt621T0xHus8A+ACAOoAPW2u/F3UdSQj6hcuXq1+ez15V8ns/6/NLRMWYfZEHX3gzSHWOCz0JRyIokiJHLXZk+gzkOofWWpfDIEORwNOMRwAuG3JqasqlNGezWdTrdbTbbUxOTjoNhOYESSHo+clnE0QcmpR9nVU/F7Yhab+TEEjIJERZh1IXbdWjtZwmXq1WYYxxPoggcpIdUt+z3IfnkGabT7vt14z1nTMKcTSFIwB/ZK39njGmCOC7xphvAvgwgG9Zaz9ljHkVwKsA/gTA+9Epw3YHwC8B+Gz3f2IMWzUfNsI89mGjg9zOFaALhYLTBqj2p9Npl4AkRzYmPvF3TqI6PDxEKpVCNptFtVp1KrTseIxuyNHc13mpXvvqIsr95LMI2sdnNsnsVI7sDEeenHQyMa9du4Z0Oo1arYZ6ve4Ij+fjPW9ubuLhw4d49OiRqxshIe9Pd+g4ndG3n0+jDTs+CgMlBWttBZ0qzbDWHhhj7gNYBPAKgF/p7vYFAP+GDim8AuCLtiPFfxpjSsaYhe55QhH1EIPUz7g4D5LxRQS4/aLhuz7nLsg/1iXMZDLIZrPI5XIuqafVaqFer7uVqEkK1ArY+eW6CUBvsg47vU4bl7MIg0ghKPsxyEwLIg5GXhiRofZTq9WQyWRQKpVw9+5dlMtltNtt5yeRFZO4UO7a2hpWV1dd4pZPk5WyDcoH4rtHff9R543rzJVI5FMwxtwG8C4A3wZwQ3T0DXTMC6BDGA/FYavdbZGkEAY6zbQdr8OKSfwJ/UKPxr5zX0TUQt+rVL35XGTHz2QyyOVyPZoATQMAzrnYaDRwfHyMUqnkogmtVqtnFmE6ncbR0ZGrISD9FLIqM21vdkyg1wHp6/w62sBjNHQ74DbdRlh0ptlsYm9vD+VyGc8//zxeeuklLC0twdpObYRGo4FCoeBkYFUlkoIsOXfW6EBUZEA7HYN+80V09Hl14dwoxCYFY8wUOvUXP26t3VdsbY0xiZ6SEes++KZDe/bvsb36QRJNIcwvIK9/lryDQUCOAowctFotV1eRiUnpdNo5HjlS7+/vO7W6Xq+j1Wphe3sbxhjk8/me9RFJBJxFmM1mnZbAEVaum0DnITu+TKailqBJQfqM+J6Dnm+Q34KQ52baMv0os7OzWF5ext27d7GwsOCWppfOU2s706NZnZnFWPnM5XWC3ouWJ+i3oDYdpTUHmRi8dz5rH/mGIRYpGGMm0SGEL1lrv9bdvEmzwBizAGCru30NwJI4/GZ3m76p1wC8BgCZTMZ2t8nfe4gghozuvx5l9OdBIsh8OE/okdD3O+WRfgNOfALgIg+UnSP+9vY2isUiZmZmepakp69gcnLSzaZsNBo4OTnpIQU6LLWJwBAmOyfJTEce9AjoGzG1I1HuJ217kgrTtanRzM7O4tlnn8Xt27cxMzPjXVW73W67iU9yoVyphUU5U+X7CINu90kGPZ8WoTWxgTsau9GEzwG4b639tPjpGwA+BOBT3f9fF9s/Zoz5CjoOxr04/oQg9gwiBm026GPiIkrNH1QkYdAIG6HYCKSmILMXgQ4pFAoFZ2szj79Wq6FYLDo/A8/JKAi3cbo1/Q4khenpaRQKBfcu2u22W1eBmgLPKf+C4MtvkLL43oWc8gzAZWbSUXrt2jUsLi6iXC6jUCigXq+jWq32dKJqteoKstJsiHr+2nwLQ5gmobdFZd3yXFI7kP+T9ok4msIvA/gdAD803SXnAfwZOmTwd6azDsQDdBaaBYB/RCcc+TN0QpK/F1saD3x2chhZxPHkEoNQ/ftJk06CpH4Jdhj+l1OhU6mnKyRTg6BqX61WcXh46LSLQqHQUzREj86y3DuzJjkKF4tFXLlyxanjvtWmwmxqrR3oY7Rm4Xv2Mhx5ctLJSDw5OcH09DQWFhawsLCAXC7nTAeaXVwtqlKpYG1tzSUqhYVQteMz7J3FHbGTvncd/ZDXSdo240Qf/gNA0Fl/1bO/BfDRRFL4r+vt9En9CXEeSByn4KilO/tAIpCkIJdJl2HDVKozRZgJPNVqFe12282RkEVHdHiR5+YUawAuT2F2dhalUgmZTMaRglRhg5yj+j54Lb2fHBW5bxjp8zdWmbp69SoWFxfxzDPPuPkfAFyiVr1eR6PRwMrKSk8YUppkGnE1BF+HlfcS5xxBkReNsLyWKIxERqMmAK1iaps9yqY+L/iIYViyRIHPUBYkBXpHUHYIqtXFYhGLi4sufq8df/IYAC5F2Frr9n/++eexubmJ+/fvO48/ScQ36kvIDk7i8hEKZWJHlkRFZ6v2W6RSKczPz+Pll1/Giy++iMXFRacpAXBO1Hv37uGNN97AvXv3XGUlXpNzPvQ8ibi+BR/CHJBR55RaHJ+vjr5oEyQORoIUgGSx17j7nodKH0djuAiNIqiByAQdnwNLz5KUdRg5cUrXatQjoYwKsCOzs0xPT6NUKmFmZsaRhlRtg0wIeR75Xd+v7OzSuZhKpVynlanu9JlYa1EqlfD2t78dN27ccBOZNFHt7u5ibW3NRRx4DZ8sccjAZ/IEHau3B4Vc9fl0qrgvuzYJRoIUgvwCsqFoL3jQBBuJMALxPfAouXhOTQx8IRdFQrozSX8L5ZFgx5DVhZjDwBwFJvXICU0+v40MMdI8ISHQNmd6dS6Xw5UrV1zeg5RdmiU8v3QcUk5JIpIISAayQ0tySqVSLimJORdLS0u4desWpqene54bS9KlUik0Gg1Uq9WepenpE5HE64PPPJJ+MN+xYaZHkPNRng9Aj2yyn/Q7OI0EKQRBk4IenQjJopIoogihnweoR06fZ1yjX6eP737CvMnaoy+fmc8MyGQyPdOgOTdCl3rnudmB2EkY1ZDzChjLZ8JUOp1GvV4/JbNMq+Z1SFb6/rUMWn2XZib/rLWuapQxBteuXcPNmzdx69atnuiIVt9rtRoODg5cDsbExITTNKLebdDg1E+kQhKMHu19RBMUiekHI0cKspHoB57Efu/3AZ2nfyCpTFH3G9RIqbkwJMncAXZ+GT1g42NokROn9HXY4ZvNZs8EIq21cX86K6XfQcqsCY6dmeaM3MY8A33PvB9qDCQoGVE5Pj7G1NQUFhcXcevWLczNzbmsRdkZj46OUKvVsL29jf39fbeYS1hOQtS7i4ug84e1lzDtMcpZGYWRI4VBIInfQaIfQuj3WnGRxBHF/dmQmcbMkKQeqdPptNMQOPLLSs68JhOUWKuRiUDa+UvS4DwJplWz1JlMfyYpSDLgdi0vzRKtCRGSYGTy0dHREfL5PObn57G8vIzFxUUUi0VHHNIHUa/Xsbu76xbL1ZrZRUMPilEII6+k7frnjhTO0knjaiJB5+/XTIiCHFG1k04754CnPg6aCExxlsfTB8Al4diRfSnnnF7M2YSyejGfF/c5ODhwlZo4r4JxfkkmhNQO+F2GUdnR6cOQmoF0KvLeqOrTh1EqlXD79m3cvXsXS0tLbhYki8tS02k2m9je3sbOzg7q9bp7lknnDfSDJD6tpOfRWlwcXEpSCLOrz9IZJSGcRdUftFxxoEdL4Omy6UHVf6h+ayegBMOKBwcHODg4wOHhISYnJ1EoFBzRMDlob2/Pqd/sxCziws7carUcafGZ0eEkMcV/AAAJ10lEQVRJOWhy8Po+X4rPl0N5OHlrZmYGi4uLWF5exvz8PKanp09laVKunZ0dbG5u4uDgwP3GAjZ8lkB4NWYiqequR/igth1lxvj8Nv20u0tJCmHoR1OQIx6/+z77Ok2QXX8eJBBnxGJ+PwCXuRil/eiGLzvc0dGRq9VYq9XQbrfdeeXy7kyAYmUmrmotOzwJqNVq9YTRstksrl275uYfyPoO3JdysaFrR52MZBjTmdA1NzeH5557Dnfu3MH169edGSP3I+ltbW2hUqmgVqu5Cl9yX/n8B6U5BEUkfDiLr+vnSlOIuhlfuKxfv0DS64clMulQ2yAIQtuY8loER1MZjdELx+rwHiMKAHoyH7lPq9VyZoNMRJJFXhnypBOS5c1IHvl83jkfmf4MdBZWATrZkPPz827NCDoVad7IiIL2Y5BsjDHuPjKZDK5fv44XX3wR73znO3Hnzh0Ui0UA6CGdiYkJNBoNbG9vY21tDWtra24FLZ/W51vgRSNOB5d+iqSEEKYt+LSES68pBHXOqJH3vJ19RJTz5yzmRz/X1fkRsqPrKkjA01FVLhZDO58jvwwVsuAK13JotVqu3Jq0uZvNZk/lZ3ZsdlKaMdZaNy8CgJuVyLUXaKJUq9Ue7z8htQL+yTkd3FYqlXDr1i288MILeNvb3obFxUX3fOT07uPjY9RqNTx69MgVZJU1H8LSrPX2QSHO+c6SgxAHI0MKUQ8jyhs8KGKIOkdQB5UjbNA5grSYOC84yoyRNq+0iaXdz9FWrjPJzsvOLmWic5GzBK21ruIz3wOJg9oE51JwqjTvjc7EfD7vsgnptJyamkK5XHYJRyx5xlmV8k+eT5ICSW1ychLPPPMMlpeX8cILL+D27dsol8tuQVwdxahWq9jY2MDGxgZ2dnZO1YQgwpaBS/Iew5CEYDQx+NqWDgPHxciQQhIMuvNrdT/usXFMlfPMewCeVrjWDZIdRs59oBNSVjOmt16WWGPno5bA1anlCMskpXa7farCs7yOJKOJiQlMTU25a+zu7rqwIc0RJkbxGrLAKq9JM0R2DC4Bd/36dczPz+PZZ5/F0tISyuUypqennUbEZ2Ntp6jKkydPUKlUsL29jVqt5ohUZlPq8Kt8xucVmdBmkm5H2g82SHkuJSkM4sajSKAfZ2Xcc58V0hzQPhU+G6rU6XTaqdZs4LLjAegJXbJjNhoNHBwcYG9vz60hKT33JIBWq+XWmWRkQWtzzAugX4Hn4TJ2LCIroxOSDGSa8eTkJEqlkluVSlYWKpVKKJfLmJ+fR7lcdvtls1lXPo4mBu9hZ2cH6+vrLmGJv5NspNkgj5W/XQT69ZcBydvjpSQFiUERBP8ncc5E7edzVvUjry9kFXUeFkFhh5AJO7K2ATUEuWxcq9XCwcEBnjx5gv39fVfanaMTIxJXrlzpKfTqK5OuU7UpFx2RLPDKHAM6GQH0kMLJyYmT8+bNm5ibm8PU1JTLj+ACN7Ozs66mg1ytilmaMuuRmsLGxgYODg56tBo96up3fRGEIDuzry0FtT9tVlxa8yHIqUNVlr/LBBZ+jxOBCAsdavMhji3mU9X0/jpH3Uc41p6eYKUhNQDfebSqSe85Zz/K8ubsaHTksZPKOQyseiyzF3k+Xu/k5MQ5FOk/kFWWdJRDe9y5ChW1BWl+yPuSEZJ0Oo1isYibN2/i5s2bKBaLTpvZ3d3tKQoD+Bdk4b03m02srq5idXUVjx8/dnkVYaOxdJzyPs4TScLdQdGMfjSMkSGFICaWziXtMON3nYUnCSOM7cOuf1b5ef04x0URgw7FAejJEdD7UtWmpjAxMdFjMkhnG+dASBudJgE7vZwvATx1urFjM6WYxKDLrsmsQJmrcHR0hGKx6NKMdfq0JjrOvpybm8PCwoKb0clRn9eSzlbKIH0lzWYTu7u7rijrkydPTr2vMG3svMkACB5gKJuvvfkSq2SfiYuRIQX5AoI+6/0vIgwZhkGZGYOSQ3YimgXShtdzDzj6s8oSO6wc9aVzTp5fjvZSWyD5SN+GMQbtdrsnr0FOTQbgjufUaxk5oWlhjHErXukVtLkP52CQaH2zB6vVKjY3N/HWW29he3v7VGhXQna0ICI+D/jadxxiIM7S5sxFOksChTDmEYAagMfDluUMuI7LLT9w+e/hsssPnO89PGutnYvaaSRIAQCMMd+x1r572HL0i8suP3D57+Gyyw+Mxj2MXnHBMcYYY6gYk8IYY4zRg1EihdeGLcAZcdnlBy7/PVx2+YERuIeR8SmMMcYYo4FR0hTGGGOMEcDQScEY8xvGmB8bY35mjHl12PLEhTFmxRjzQ2PM940x3+luu2qM+aYx5qfd/7PDllPCGPN5Y8yWMeZHYptXZtPBX3Xfy+vGmJeGJ7mT1Sf/J40xa9338H1jzAfEb3/alf/HxphfH47UT2GMWTLG/Ksx5n+MMfeMMX/Y3T5a70BPTb3IPwATAN4A8ByANIAfAHjHMGVKIPsKgOtq218AeLX7+VUAfz5sOZV87wPwEoAfRcmMznqg/wTAAHgZwLdHVP5PAvhjz77v6LanDIDlbjubGLL8CwBe6n4uAvhJV86RegfD1hTeA+Bn1to3rbUtAF8B8MqQZToLXgHwhe7nLwD4zSHKcgrW2n8HsKM2B8n8CoAv2g7+E0DJGLNwMZL6ESB/EF4B8BVr7aG19v/QWfD4PecmXAxYayvW2u91Px8AuA9gESP2DoZNCosAHorvq91tlwEWwD8bY75rjPn97rYb1tpK9/MGgBvDES0RgmS+TO/mY131+vPCZBtp+Y0xtwG8C8C3MWLvYNikcJnxXmvtSwDeD+Cjxpj3yR9tR/+7VKGdyygzgM8CeB7ALwKoAPjL4YoTDWPMFICvAvi4tXZf/jYK72DYpLAGYEl8v9ndNvKw1q51/28B+Ad0VNNNqnfd/1vDkzA2gmS+FO/GWrtprT221p4A+Bs8NRFGUn5jzCQ6hPAla+3XuptH6h0MmxT+G8AdY8yyMSYN4IMAvjFkmSJhjCkYY4r8DODXAPwIHdk/1N3tQwC+PhwJEyFI5m8A+N2uB/xlAHtCxR0ZKBv7t9B5D0BH/g8aYzLGmGUAdwD810XLJ2E6Uxc/B+C+tfbT4qfRegfD9MYKD+tP0PEOf2LY8sSU+Tl0PNs/AHCPcgO4BuBbAH4K4F8AXB22rEruL6OjYrfRsU8/EiQzOh7vv+6+lx8CePeIyv+3XfleR6cTLYj9P9GV/8cA3j8C8r8XHdPgdQDf7/59YNTewTijcYwxxujBsM2HMcYYY8QwJoUxxhijB2NSGGOMMXowJoUxxhijB2NSGGOMMXowJoUxxhijB2NSGGOMMXowJoUxxhijB/8PRCbemtmg2lYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "##TODO: load in and display any image from the transformed test dataset\n",
    "\n",
    "## TODO: Using cv's filter2D function,\n",
    "## apply a specific set of filter weights (like the one displayed above) to the test image\n",
    "dataiter = iter(test_loader)\n",
    "dataset =  dataiter.next()\n",
    "images, labels = dataset['image'], dataset['keypoints']\n",
    "images = images.numpy()\n",
    "# select an image by index\n",
    "idx = 3\n",
    "img = np.squeeze(images[idx])\n",
    "\n",
    "# Use OpenCV's filter2D function \n",
    "# apply a specific set of filter weights (like the one's displayed above) to the test image\n",
    "\n",
    "import cv2\n",
    "plt.imshow(img, cmap='gray')\n",
    "\n",
    "weights = net.conv1.weight.data\n",
    "w = weights.cpu().numpy()\n",
    "fig=plt.figure(figsize=(12, 4))\n",
    "columns = 5*2\n",
    "rows = 2\n",
    "c = cv2.filter2D(img, -1, w[0][0])\n",
    "plt.imshow(c, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4: Choose one filter from your trained CNN and apply it to a test image; what purpose do you think it plays? What kind of feature do you think it detects?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: It detects horizontal lines and darkens all the brightest pixels and lightens all the dark pixels, we can see the suit color changes towards bright. It tries to detect the light pixels as face belongs to light pixels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Moving on!\n",
    "\n",
    "Now that you've defined and trained your model (and saved the best model), you are ready to move on to the last notebook, which combines a face detector with your saved model to create a facial keypoint detection system that can predict the keypoints on *any* face in an image!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (sota-seg-py35)",
   "language": "python",
   "name": "sota-seg-py35"
  },
  "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}