Facial-key-points.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required Data Downloads:\n",
    "\n",
    "[Kaggle facial keypoints dataset](https://www.kaggle.com/c/facial-keypoints-detection/data) (download will be named all.zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\sorgm\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import zipfile\n",
    "import numpy as np\n",
    "import os\n",
    "from skimage.transform import resize\n",
    "from sklearn.model_selection import train_test_split\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from tensorflow.python.saved_model import tag_constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.ops import gen_list_ops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unpack(filename, current_file_directory = '', extract_to_directory = ''):\n",
    "    \"\"\"\n",
    "    Extracts the zipfile in the same location of the \n",
    "    \"\"\"\n",
    "    with zipfile.ZipFile(os.path.join(current_file_directory,filename)) as (zf):\n",
    "        zf.extractall(path = extract_to_directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_IMG_VALUE = 255\n",
    "IMG_SHAPE = (1,96,96,1) # IMG_SHAPE[3] == 1 because these are greyscale imgs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "cwd = os.getcwd()\n",
    "data_dir = os.path.join(cwd,'data')\n",
    "if not os.path.exists(data_dir):\n",
    "    os.makedirs(data_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#be careful to remember where you extract to and from if you're not doing so in the working directory.\n",
    "\n",
    "unpack('all.zip', extract_to_directory = data_dir)\n",
    "unpack('test.zip', current_file_directory = data_dir, extract_to_directory = data_dir)\n",
    "unpack('training.zip', current_file_directory = data_dir, extract_to_directory = data_dir)\n",
    "\n",
    "# Keep the base all.zip files, but remove the sub zip files and just keep the final data\n",
    "try:\n",
    "    os.remove(os.path.join(data_dir, 'test.zip'))\n",
    "except OSError:\n",
    "    print('test.zip didn\\'t get unpacked from all.zip')\n",
    "\n",
    "try:\n",
    "    os.remove(os.path.join(data_dir, 'training.zip'))\n",
    "except OSError:\n",
    "    print('training.zip didn\\'t get unpacked from all.zip')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have files:\n",
    "* IdLookupTable.csv\n",
    "* training.csv\n",
    "* test.csv\n",
    "* SampleSubmission.csv (not something we'll use)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RowId,ImageId,FeatureName,Location\n",
      "\n",
      "1,1,left_eye_center_x\n",
      "\n",
      "2,1,left_eye_center_y\n",
      "\n",
      "3,1,right_eye_center_x\n",
      "\n",
      "4,1,right_eye_center_y\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(os.path.join(data_dir,'IdLookupTable.csv'), 'r') as IdLookupTable_csv:\n",
    "    print(IdLookupTable_csv.readline())\n",
    "    print(IdLookupTable_csv.readline())\n",
    "    print(IdLookupTable_csv.readline())\n",
    "    print(IdLookupTable_csv.readline())\n",
    "    print(IdLookupTable_csv.readline())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left_eye_center_x,left_eye_center_y,right_eye_center_x,right_eye_center_y,left_eye_inner_corner_x,left_eye_inner_corner_y,left_eye_outer_corner_x,left_eye_outer_corner_y,right_eye_inner_corner_x,right_eye_inner_corner_y,right_eye_outer_corner_x,right_eye_outer_corner_y,left_eyebrow_inner_end_x,left_eyebrow_inner_end_y,left_eyebrow_outer_end_x,left_eyebrow_outer_end_y,right_eyebrow_inner_end_x,right_eyebrow_inner_end_y,right_eyebrow_outer_end_x,right_eyebrow_outer_end_y,nose_tip_x,nose_tip_y,mouth_left_corner_x,mouth_left_corner_y,mouth_right_corner_x,mouth_right_corner_y,mouth_center_top_lip_x,mouth_center_top_lip_y,mouth_center_bottom_lip_x,mouth_center_bottom_lip_y,Image\n",
      "\n",
      "[[0.93333333 0.9254902  0.92941176 ... 0.98039216 0.98039216 0.98039216]\n",
      " [0.92156863 0.93333333 0.9254902  ... 0.97647059 0.98039216 0.98431373]\n",
      " [0.92941176 0.9254902  0.92941176 ... 0.98431373 0.98431373 0.98039216]\n",
      " ...\n",
      " [0.72941176 0.71764706 0.70980392 ... 0.20392157 0.22352941 0.23529412]\n",
      " [0.74117647 0.7372549  0.81176471 ... 0.23921569 0.27058824 0.30588235]\n",
      " [0.74901961 0.72156863 0.72156863 ... 0.2745098  0.29411765 0.35294118]]\n",
      "[64.33293617 34.9700766  29.9492766  33.44871489 58.85617021 35.27434894\n",
      " 70.7227234  36.18716596 36.0347234  34.36153191 24.47251064 33.14444255\n",
      " 53.98740426 28.27594894 78.63421277 30.4059234  42.72885106 26.14604255\n",
      " 16.8653617  27.05885957 48.20629787 55.66093617 56.42144681 76.352\n",
      " 35.12238298 76.04765957 46.68459574 70.26655319 45.46791489 85.48017021]\n",
      "(30,)\n",
      "[65.22573913 37.26177391 32.02309565 37.26177391]\n"
     ]
    }
   ],
   "source": [
    "with open(os.path.join(data_dir,'training.csv'), 'r') as training:\n",
    "    print(training.readline())\n",
    "    print(np.array([int(num)/MAX_IMG_VALUE for num in training.readline().split(',')[-1].split(' ')]).reshape(96,96))\n",
    "    print(np.array([float(pt) for pt in training.readline().split(',')[:-1]]))\n",
    "    print(np.array([float(pt) for pt in training.readline().split(',')[:-1]]).shape)\n",
    "    print(np.array([float(pt) for pt in training.readline().split(',')[:-1]][:4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ImageId,Image\n",
      "\n",
      "['1', '182 183 182 182 180 180 176 169 156 137 124 103 79 62 54 56 58 48 49 45 39 37 42 43 52 61 78 93 104 107 114 115 117 122 120 122 118 114 115 118 117 123 122 122 112 113 118 125 124 122 109 101 96 102 108 107 100 89 76 67 58 48 44 36 32 21 12 5 15 21 24 33 32 41 52 63 71 90 106 121 152 173 180 183 182 182 183 182 182 181 182 182 183 182 182 182 182 181 181 181 182 179 177 162 136 106 84 64 49 44 40 50 50 42 36 33 32 43 51 67 77 94 106 121 124 128 127 126 128 128 129 126 126 122 128 123 128 123 129 127 133 123 128 129 135 127 122 111 115 118 120 121 118 114 107 107 99 89 74 70 59 47 29 18 16 22 25 25 34 39 45 51 52 60 84 97 124 157 175 181 183 182 183 182 184 181 183 183 183 182 182 182 182 181 180 183 182 180 176 152 111 77 59 45 36 40 51 48 37 29 29 33 45 61 81 95 107 113 120 126 129 128 132 132 130 132 132 132 131 133 130 132 129 130 133 137 136 137 135 137 137 134 129 125 126 131 131 128 128 124 124 122 121 111 105 98 86 72 62 42 27 20 19 14 15 27 40 36 27 41 56 77 107 138 163 176 180 183 182 182 183 183 182 183 182 182 181 182 180 181 180 181 180 180 171 141 106 78 54 34 34 41 41 31 28 31 39 50 72 88 108 115 123 126 132 131 134 135 137 137 136 135 136 137 134 133 134 137 136 143 140 142 137 138 138 142 138 138 132 129 126 134 135 133 134 134 134 128 128 120 119 116 112 100 92 74 55 37 30 20 6 3 13 19 26 42 48 62 81 105 139 167 179 182 183 183 181 182 182 183 183 182 183 182 181 182 182 180 181 166 135 98 68 46 29 24 28 34 29 28 28 34 43 74 91 113 118 129 126 137 134 140 136 140 135 138 142 142 141 135 136 134 137 131 142 138 144 138 142 135 141 136 141 137 138 131 126 129 132 134 134 136 133 136 130 131 122 125 118 118 107 103 90 79 58 44 24 10 10 15 20 28 41 46 63 80 123 166 180 182 182 181 183 182 183 181 182 182 183 182 182 182 181 182 178 142 94 66 47 35 26 24 30 28 24 21 24 39 69 94 115 124 131 132 137 139 136 133 139 137 136 140 143 145 143 141 138 140 137 139 136 140 139 140 138 139 139 144 143 142 141 137 134 135 135 135 135 132 135 133 134 129 130 130 128 124 122 117 117 110 92 65 44 29 21 18 15 19 27 32 43 60 86 130 169 181 182 182 182 183 181 182 182 184 182 182 180 182 182 182 172 129 85 55 36 29 23 20 23 20 20 17 26 53 93 114 128 127 138 136 139 137 137 132 135 135 139 142 146 146 147 150 144 145 140 142 135 139 135 140 140 144 140 147 143 145 136 139 140 140 140 138 136 137 140 137 138 132 133 129 131 127 129 121 126 118 107 87 70 46 21 18 15 15 27 34 40 51 60 92 145 177 182 182 181 181 182 182 182 181 181 181 182 181 182 183 166 111 69 43 26 22 19 20 21 19 13 20 36 79 112 132 134 142 137 143 138 142 135 139 136 140 142 147 146 147 147 146 149 143 145 136 141 137 141 137 142 139 149 145 148 140 140 139 140 136 135 140 140 141 136 139 134 140 134 138 131 135 125 128 121 124 112 104 85 62 31 16 18 15 22 37 39 35 50 82 127 165 180 182 183 181 182 182 182 182 182 182 182 182 182 183 146 85 58 37 21 16 16 14 12 14 19 32 61 103 131 139 143 141 141 138 138 135 136 137 137 138 141 143 142 143 144 144 144 143 140 140 138 141 140 144 143 146 144 147 147 146 143 144 144 136 137 139 141 141 139 135 138 138 135 132 133 133 133 129 129 124 123 118 106 82 50 22 20 26 19 26 36 38 44 64 109 160 178 182 181 182 181 183 182 183 181 182 180 181 182 178 126 66 42 25 13 12 16 12 14 17 26 47 89 118 139 141 145 138 140 139 140 131 135 132 134 133 139 140 140 140 145 145 144 145 141 144 139 143 141 145 139 146 142 147 142 145 142 145 138 133 132 136 142 141 142 139 141 134 136 131 134 128 133 129 133 128 128 121 116 101 74 40 24 27 24 22 34 45 48 57 85 144 178 182 181 182 182 183 181 181 182 182 181 181 183 176 114 53 28 15 10 13 14 12 17 26 39 68 95 125 137 147 140 141 134 138 130 135 130 136 134 139 136 140 139 137 141 144 144 141 145 138 141 138 143 138 143 142 149 145 145 142 145 144 142 137 139 139 135 138 137 140 135 138 132 135 128 136 131 131 124 131 126 125 117 114 92 64 33 27 28 24 27 35 44 41 57 117 171 182 183 181 183 181 183 181 183 182 182 182 184 158 79 29 18 14 17 17 11 15 23 32 52 76 100 121 140 148 143 136 138 136 135 133 133 134 132 129 129 131 136 136 139 140 139 140 141 139 136 136 137 139 139 142 142 141 141 141 140 140 141 143 146 144 141 140 140 136 135 131 132 131 129 129 131 130 127 127 131 127 121 114 101 73 46 28 23 27 28 27 24 29 47 85 149 178 182 184 182 182 182 183 182 182 179 182 178 133 63 30 19 19 20 15 11 19 29 33 55 79 104 121 139 143 146 136 143 136 136 128 131 127 131 128 132 132 133 130 133 136 134 135 137 141 138 141 135 139 134 139 136 140 138 143 138 141 141 141 139 143 143 137 139 135 135 132 136 132 130 126 131 125 131 123 128 125 126 120 115 89 62 32 14 23 33 36 25 18 40 79 133 174 183 183 182 182 182 181 181 181 181 181 184 143 60 26 17 15 17 14 15 24 29 41 62 87 103 131 143 146 137 136 131 138 134 138 135 141 135 142 138 141 140 144 146 144 144 137 142 138 139 135 143 138 142 136 138 135 141 137 141 136 140 142 142 140 137 138 134 135 131 129 125 129 121 125 118 125 122 126 119 124 124 128 121 103 66 35 20 16 25 39 40 24 14 47 126 176 183 182 183 182 182 182 182 182 181 183 182 135 55 23 16 17 17 15 17 24 36 49 68 90 114 138 147 142 134 134 138 141 137 132 131 130 130 133 134 135 136 142 144 148 147 144 143 143 140 139 139 140 140 138 139 135 135 136 140 138 140 141 141 134 132 133 134 131 130 127 129 131 127 123 120 118 119 118 119 124 126 129 129 115 84 46 25 20 17 26 41 37 23 32 102 166 182 183 182 182 182 182 181 182 180 182 185 135 52 28 24 22 17 14 21 26 38 55 79 102 129 138 148 138 139 134 141 131 131 129 137 133 143 138 139 137 141 143 144 146 143 145 143 144 140 143 139 145 140 143 138 142 134 136 137 141 136 137 138 137 138 138 140 138 142 138 142 138 142 132 134 127 129 121 122 121 128 128 134 121 100 63 32 21 12 19 31 42 45 31 61 147 181 182 182 181 182 182 182 181 182 182 185 130 42 30 31 25 24 22 25 32 42 64 90 118 134 145 142 140 133 136 131 141 138 140 137 143 141 143 138 137 139 144 145 143 145 141 146 143 146 141 145 140 145 141 142 137 140 136 141 140 143 140 140 141 141 144 141 141 139 140 132 134 130 132 125 128 124 129 123 124 123 131 133 131 108 81 51 32 20 19 20 23 39 48 45 115 174 182 182 182 183 181 182 181 182 183 179 112 48 37 30 25 22 28 35 38 49 76 105 130 141 143 137 134 131 133 134 136 130 128 126 125 124 129 127 124 128 136 139 140 140 144 146 149 148 144 139 139 142 143 144 142 141 140 142 142 140 140 143 145 143 140 143 144 143 142 137 133 130 127 123 119 118 121 124 128 129 129 133 134 121 96 67 39 28 28 27 18 19 28 49 109 170 182 181 182 182 183 181 181 181 183 178 120 49 38 33 25 26 32 30 40 65 90 118 138 147 139 137 132 135 126 123 112 114 108 104 98 94 88 94 100 103 107 111 114 122 137 143 149 146 147 134 141 140 149 144 145 138 144 141 144 140 144 143 143 143 143 148 146 148 141 138 132 139 135 136 129 133 125 126 121 124 129 137 134 131 109 77 46 29 32 34 26 20 23 26 84 163 183 182 182 182 182 182 182 181 182 182 118 41 38 38 33 36 37 37 51 73 102 128 147 148 145 137 137 129 117 99 97 87 81 69 55 48 53 57 62 71 85 94 93 104 124 142 140 145 145 147 140 148 146 150 142 145 144 149 147 146 146 145 142 143 145 144 143 134 135 131 132 128 134 129 133 131 134 132 128 122 127 134 136 131 116 86 51 28 29 36 29 15 16 35 112 174 182 182 182 182 181 182 181 182 184 179 106 42 40 41 41 46 47 48 64 84 117 145 151 149 142 131 117 105 93 84 73 58 51 41 30 31 40 49 45 47 71 92 97 109 115 124 131 139 142 146 147 148 147 148 148 149 142 143 146 148 148 149 142 141 140 137 131 121 112 105 99 101 109 112 118 118 120 124 126 124 125 127 132 136 128 103 63 26 21 35 36 19 15 37 117 177 183 182 181 181 182 181 181 181 183 177 112 47 42 43 47 45 43 51 72 108 138 151 151 144 127 111 97 86 68 62 55 53 43 45 40 37 42 55 51 44 55 78 98 106 112 114 128 135 143 138 144 138 148 146 153 147 148 142 150 150 152 148 142 134 129 118 111 104 81 74 59 59 62 77 84 94 96 104 110 116 119 130 132 133 130 112 76 39 17 22 33 31 31 53 127 176 181 182 182 181 181 182 182 182 183 179 122 49 42 47 44 46 48 65 99 134 151 154 154 140 113 90 83 73 75 80 96 102 110 105 99 79 63 58 57 52 54 63 79 93 96 109 122 137 139 143 138 143 141 150 149 151 146 146 145 149 151 150 139 126 110 99 98 82 77 70 55 49 50 44 46 48 61 77 95 101 109 122 133 135 135 121 87 51 28 22 26 32 33 68 148 180 180 182 182 183 180 182 181 181 185 170 97 49 49 48 46 53 62 78 121 152 157 157 148 125 104 92 86 89 103 119 128 124 124 123 126 118 106 89 80 69 66 65 66 80 93 102 117 127 134 138 133 139 144 151 148 145 141 144 144 144 141 141 132 124 110 94 85 82 80 64 57 55 46 33 24 25 35 52 72 78 86 101 121 133 138 133 102 60 33 22 24 37 48 82 151 181 183 181 181 181 182 181 181 180 184 167 91 44 47 53 56 59 69 105 146 157 154 153 139 119 106 110 112 126 131 138 130 130 121 123 114 111 110 105 97 96 80 73 75 81 96 99 111 119 128 126 133 135 143 143 146 129 130 135 140 135 134 128 126 120 109 97 88 85 71 59 51 46 37 33 25 34 40 47 50 55 61 80 103 121 132 139 116 72 40 26 28 41 60 85 149 180 181 182 182 181 181 181 181 181 184 171 90 37 44 52 56 63 88 133 156 159 157 139 123 117 108 118 135 137 142 137 133 122 122 118 116 109 110 104 102 101 96 90 91 98 104 107 108 117 119 130 135 140 137 141 132 116 109 116 120 129 128 123 120 110 95 87 82 76 69 55 56 57 53 61 78 91 104 104 91 73 60 64 85 105 127 140 128 83 41 29 31 46 68 94 152 181 181 182 181 182 181 182 181 182 184 178 110 49 45 52 59 76 112 144 158 161 151 126 120 132 134 132 139 140 136 132 134 126 127 122 120 113 109 104 101 96 98 102 105 108 110 111 109 114 122 132 134 133 131 134 119 98 96 109 117 125 124 122 113 109 100 94 89 81 74 72 78 81 87 98 108 110 115 119 123 126 108 79 74 87 110 134 144 110 52 27 34 54 79 122 166 180 182 181 181 181 182 182 181 180 183 183 122 49 44 56 75 96 132 153 161 156 143 130 121 129 138 142 138 143 129 128 125 125 115 108 93 93 87 88 86 89 89 93 100 103 109 114 116 113 118 123 130 122 125 121 115 89 92 106 124 124 116 113 113 109 100 96 96 94 87 88 85 91 92 103 100 107 111 122 122 131 135 126 96 81 93 123 145 138 82 45 51 65 87 133 173 182 181 181 182 180 182 181 182 181 182 184 130 47 40 61 76 106 137 154 157 149 139 130 128 132 137 137 138 125 113 104 101 98 104 102 103 97 91 84 86 84 81 83 88 95 97 104 102 106 109 120 127 131 127 128 107 87 89 103 119 127 117 111 111 103 96 95 99 89 84 80 85 85 94 103 111 109 115 116 118 120 130 136 130 98 84 115 142 147 116 69 58 72 96 138 175 183 181 182 180 181 180 181 180 182 181 187 143 43 36 61 73 110 144 154 155 147 134 125 124 130 131 125 115 102 96 101 105 100 103 102 103 98 95 91 93 90 88 86 88 87 88 91 97 102 108 119 126 133 128 120 103 94 96 109 120 124 118 110 104 100 96 90 85 85 90 92 90 90 98 101 109 115 126 128 132 130 126 120 125 124 100 101 131 145 138 88 53 57 87 143 175 181 182 182 180 181 181 180 181 179 181 187 152 57 45 58 77 116 150 158 156 144 130 123 124 124 113 108 104 108 102 96 91 93 87 92 92 94 87 87 79 79 82 89 96 96 90 82 89 94 102 109 124 128 130 118 126 128 123 114 126 121 117 108 100 86 74 83 94 102 94 90 85 89 90 100 101 112 114 124 125 135 142 144 121 115 115 106 122 142 143 110 75 72 92 148 180 182 181 180 181 180 181 180 181 180 181 186 161 63 39 59 84 130 152 154 152 145 128 126 125 105 105 109 108 100 92 83 86 83 87 88 93 87 87 82 79 73 68 72 77 89 92 87 76 81 86 98 113 126 127 134 140 140 132 136 134 124 112 99 79 69 88 103 104 92 85 80 84 85 93 104 112 111 110 108 110 115 127 142 146 127 116 106 119 143 144 128 91 78 106 155 181 182 180 182 181 181 181 181 180 181 179 186 157 59 34 50 84 135 156 155 151 144 138 129 98 104 122 107 92 81 78 77 79 83 93 87 86 83 85 85 84 81 72 59 56 66 82 99 94 77 75 85 100 125 136 134 122 120 126 142 141 126 103 84 68 88 101 94 88 78 75 72 75 81 92 99 106 105 103 100 102 100 109 123 139 143 136 104 101 129 149 143 105 68 95 161 180 181 182 182 181 181 181 180 181 180 180 185 166 74 28 40 93 137 138 137 130 118 104 86 92 133 123 97 78 70 69 93 93 85 74 61 48 55 56 63 73 82 82 66 47 48 64 93 119 102 78 75 92 88 83 80 87 88 100 89 103 109 93 64 92 114 90 81 73 63 61 73 75 83 83 93 89 93 96 98 93 97 93 103 118 141 145 133 105 98 138 149 116 77 103 165 183 181 182 181 182 180 182 181 181 181 179 184 174 76 28 43 103 135 56 42 99 114 74 54 119 134 102 81 69 61 89 102 63 32 45 80 93 60 35 28 37 57 63 66 56 45 51 73 93 94 77 79 42 43 79 99 103 103 97 85 53 53 71 73 106 105 86 71 54 56 70 75 84 84 83 86 89 88 93 96 100 92 83 86 105 127 149 135 78 69 92 126 129 92 120 172 182 182 181 181 180 182 180 181 180 182 180 184 177 93 32 42 102 106 33 89 155 154 117 90 123 119 92 78 73 72 67 40 29 60 112 135 103 63 39 48 54 51 59 57 57 56 55 67 82 84 85 52 40 90 113 124 125 128 121 117 96 48 36 76 83 83 78 51 41 62 76 70 69 56 43 41 51 52 62 88 114 96 74 82 99 112 151 148 64 48 76 126 132 40 38 141 181 182 182 181 180 181 181 180 181 179 181 183 180 105 32 36 67 99 151 155 149 140 109 97 134 132 114 108 89 64 45 49 77 110 130 93 53 66 31 34 63 73 109 88 44 45 70 82 95 94 72 34 62 93 116 122 135 128 133 118 107 63 28 64 88 92 83 59 53 61 67 73 62 43 34 35 44 56 42 45 77 95 77 73 88 114 147 162 77 32 96 157 168 71 36 139 181 181 181 180 181 179 182 180 182 181 180 181 184 121 50 34 67 132 143 140 138 138 104 99 142 137 119 102 89 78 83 90 95 107 127 81 35 42 19 4 49 93 120 134 82 55 62 96 93 51 39 39 58 97 120 133 137 133 131 131 110 67 30 42 71 97 88 57 47 63 97 101 79 51 51 98 89 112 127 66 33 60 76 73 85 109 144 164 76 18 86 147 161 91 85 166 183 183 180 180 180 182 180 180 180 182 180 181 186 149 60 19 53 108 120 128 128 129 108 95 115 122 111 106 105 114 116 103 89 86 111 88 44 41 34 33 52 61 83 88 76 74 88 98 46 20 50 34 58 112 129 137 134 140 134 135 123 87 35 32 27 61 78 47 47 78 108 75 43 27 15 49 54 81 129 108 48 34 63 79 91 104 133 157 84 35 97 151 164 99 93 168 182 181 181 182 180 181 179 181 181 180 181 179 185 168 61 14 88 140 144 136 135 130 119 90 104 130 129 132 120 117 109 102 88 86 85 92 84 81 73 76 77 84 82 75 81 87 95 66 10 29 47 26 79 122 143 137 142 138 143 131 140 111 44 20 30 31 67 71 62 74 96 81 54 33 21 28 35 60 102 95 75 74 73 82 90 104 124 147 101 69 104 137 155 96 99 171 183 180 181 180 181 180 181 180 181 180 181 180 186 174 63 34 118 153 152 152 148 144 135 115 103 132 138 117 112 108 102 90 87 82 79 78 80 87 89 87 79 76 77 77 77 78 87 84 60 61 55 55 97 136 142 143 141 142 142 138 142 129 70 35 43 44 63 78 75 70 77 79 72 63 64 51 47 81 92 87 98 112 110 103 103 110 134 157 138 114 124 141 132 67 112 176 181 182 180 181 180 181 180 180 180 182 169 146 135 140 59 43 125 152 150 157 152 150 143 135 114 114 129 117 105 99 100 95 96 93 89 82 82 76 77 76 77 77 78 70 75 87 99 100 98 79 65 87 116 140 143 147 138 139 135 137 131 133 97 64 55 75 86 76 65 70 71 73 81 83 88 84 83 84 83 83 100 113 128 130 126 128 143 153 141 133 140 156 144 114 152 181 180 180 180 181 180 181 180 181 179 170 147 128 116 101 99 88 128 151 155 153 155 148 145 137 132 114 104 118 112 109 103 103 97 104 100 102 97 97 91 90 84 83 76 78 83 104 113 97 83 79 84 104 133 137 149 144 143 135 141 129 128 124 113 83 70 68 90 96 78 70 71 73 72 74 71 75 70 75 82 98 107 120 126 134 135 142 145 134 127 137 146 153 162 156 172 184 182 180 182 181 182 180 181 180 181 141 89 105 116 126 123 102 128 153 156 152 150 149 144 140 137 130 111 102 112 120 116 106 104 104 104 102 98 96 93 93 90 89 88 94 107 120 100 61 67 92 107 127 134 138 139 141 138 133 133 129 122 118 115 96 80 56 50 96 101 77 75 78 83 84 88 86 89 90 97 103 111 114 122 127 134 133 125 124 134 144 150 152 160 153 138 153 175 182 181 180 179 179 181 181 179 142 59 66 92 118 110 105 132 154 153 156 151 145 138 140 137 132 132 124 111 103 109 110 116 109 111 105 106 102 104 99 98 94 105 112 112 97 67 57 76 98 116 133 131 136 132 137 134 138 132 134 123 118 111 105 88 71 44 67 99 93 82 80 88 89 95 96 102 100 106 105 114 114 120 122 120 112 116 129 135 141 150 154 163 153 117 120 146 172 181 181 179 180 180 180 180 153 79 66 95 103 104 105 139 150 156 153 155 145 143 142 141 138 137 138 132 119 101 97 96 102 100 101 99 103 97 100 96 101 103 102 103 111 108 102 108 115 128 128 129 125 133 130 138 134 140 134 134 122 115 110 112 100 97 104 113 109 93 87 90 93 84 97 102 107 102 108 108 114 109 110 112 121 123 130 136 143 151 157 162 161 135 118 119 157 182 180 181 180 180 179 181 157 85 80 118 108 89 108 138 149 154 156 155 154 153 149 144 141 139 135 135 133 125 117 109 100 98 96 97 93 92 98 104 112 116 123 123 123 123 128 129 132 132 127 121 124 127 134 139 139 136 135 131 127 121 112 119 118 109 109 117 121 116 104 95 90 92 94 98 101 101 103 105 107 113 123 125 127 130 129 136 146 150 156 161 163 136 89 93 159 182 181 181 181 181 180 179 157 86 95 126 122 95 109 136 154 152 154 155 161 158 153 147 148 145 139 138 129 128 123 126 120 122 115 119 115 121 115 128 128 129 128 131 131 134 137 136 135 126 122 119 133 136 144 138 142 131 134 129 137 130 124 118 124 122 120 118 119 126 123 118 105 105 101 105 104 109 106 116 117 123 120 127 127 129 132 139 141 146 151 158 168 126 59 100 170 182 180 179 181 180 181 179 161 94 93 142 132 113 109 139 145 150 149 158 159 159 151 146 151 150 146 141 140 132 133 128 132 125 129 127 132 127 132 130 134 132 135 138 137 134 132 133 130 127 120 133 139 146 142 145 139 140 135 138 138 143 134 128 127 130 131 125 126 130 133 129 128 114 112 105 109 104 111 112 121 117 122 123 132 134 137 140 143 147 150 155 162 128 71 113 173 182 181 181 179 181 180 180 166 103 102 143 144 123 111 132 145 148 153 156 156 155 154 153 154 149 145 147 146 142 141 142 139 140 139 136 136 137 140 138 139 137 140 143 142 135 132 129 125 116 122 140 146 143 149 147 141 141 138 139 140 142 142 138 127 125 127 127 132 136 136 135 138 138 130 122 119 115 116 118 122 123 124 127 134 137 142 145 148 151 153 157 161 127 80 112 169 181 180 180 181 179 180 179 171 116 120 131 123 81 88 125 144 147 152 151 154 153 156 154 153 149 147 152 149 150 145 145 139 150 146 149 141 144 138 144 140 142 139 142 138 131 127 125 119 112 123 141 149 141 152 150 151 141 142 143 149 141 148 150 135 119 123 131 132 136 136 140 139 144 137 142 132 132 123 130 126 132 129 138 138 143 146 151 151 153 153 156 162 130 81 115 172 182 181 179 180 180 180 179 178 134 118 123 89 62 78 128 138 148 151 155 151 154 151 150 151 151 154 155 154 149 152 145 148 148 155 147 147 141 148 146 143 140 142 139 133 120 114 125 121 121 124 132 131 139 142 156 148 146 143 152 151 150 143 147 132 113 119 127 132 133 138 138 143 140 143 140 144 138 141 136 142 136 137 137 145 147 149 152 155 155 155 155 156 133 92 138 180 181 180 181 179 180 179 181 180 152 121 112 90 59 69 120 137 142 148 151 149 149 148 147 148 151 152 152 154 152 151 151 153 154 157 157 152 148 150 146 145 138 138 133 122 109 115 126 131 130 126 116 111 113 126 142 145 143 144 151 150 138 123 122 123 112 105 115 125 135 139 139 140 139 144 145 147 146 146 143 144 143 144 142 145 145 149 152 152 156 154 154 154 127 110 156 182 181 179 180 181 181 180 179 183 171 132 102 91 63 71 106 134 136 145 144 144 142 146 147 150 150 148 152 155 157 152 155 151 156 153 158 149 152 146 149 141 142 133 128 112 98 118 138 145 137 123 109 106 102 115 121 136 138 137 134 132 115 108 107 119 122 110 108 120 134 137 143 142 145 146 151 142 148 145 150 143 149 146 147 143 148 150 152 153 154 150 152 150 119 122 168 181 181 182 179 181 180 179 177 182 177 139 98 81 72 64 106 129 137 142 145 143 142 142 144 146 149 153 154 156 153 156 151 157 153 157 153 153 147 149 146 142 132 130 122 100 97 130 148 142 128 112 98 92 107 108 119 122 131 123 118 109 102 98 97 107 135 126 101 114 129 138 139 144 143 151 145 149 146 153 149 152 150 151 144 147 150 151 151 155 154 149 147 140 117 141 177 181 180 179 180 178 180 179 180 182 181 140 99 82 73 63 95 125 131 136 143 141 143 143 144 145 149 154 153 151 152 153 152 153 154 155 151 152 150 150 144 138 133 129 115 100 102 127 130 123 105 65 30 23 63 101 108 110 111 104 100 98 97 77 66 90 125 133 110 108 125 134 140 143 144 147 149 152 152 151 148 149 150 149 149 150 149 151 150 152 147 145 145 134 116 154 180 181 180 179 180 179 179 179 179 181 181 146 102 87 71 63 84 126 125 134 134 137 138 141 142 147 150 150 150 149 153 149 152 148 153 150 156 148 150 142 143 136 133 121 111 97 100 110 115 106 61 6 0 0 8 76 100 97 91 90 91 97 62 15 12 50 99 120 110 102 117 130 139 140 147 143 150 146 153 149 151 146 152 147 151 148 150 146 147 145 141 138 140 126 120 166 181 180 179 181 179 180 178 179 178 181 181 152 117 98 78 50 70 110 128 128 129 131 136 140 144 144 147 147 145 149 149 153 146 147 145 152 146 145 137 140 133 133 127 122 112 97 88 98 103 88 40 3 0 6 22 53 93 81 74 79 91 54 2 0 6 31 79 108 101 101 116 131 134 140 140 145 143 149 148 153 149 151 147 147 143 146 147 149 144 139 138 135 135 117 122 169 181 179 180 179 180 178 179 178 180 180 183 155 114 113 100 60 61 100 122 127 126 127 132 132 137 139 142 142 142 144 143 144 143 144 144 145 141 142 137 137 133 129 124 126 112 100 86 81 76 75 69 50 43 66 65 57 77 73 68 72 68 49 25 21 38 61 81 88 96 107 120 126 134 137 138 143 144 147 145 149 147 148 145 144 140 142 143 144 140 138 135 132 135 114 128 172 180 180 180 178 179 180 179 178 179 181 184 167 114 101 111 119 89 100 120 124 123 128 128 130 131 137 142 141 138 136 142 138 143 138 144 141 144 137 140 132 134 126 128 124 119 110 102 87 78 79 92 112 119 116 92 79 72 70 65 67 70 98 92 87 83 78 69 81 100 115 124 128 134 135 142 138 144 138 142 142 149 142 146 143 142 138 145 134 132 136 133 131 128 111 147 178 178 180 179 180 178 179 178 180 179 180 182 182 142 95 116 147 105 77 112 119 126 127 129 124 126 132 134 139 139 141 138 142 141 141 137 140 136 139 136 140 133 132 130 126 119 119 118 112 101 88 91 99 111 106 98 83 72 67 70 71 87 98 101 95 87 77 79 99 115 122 128 131 130 135 137 143 139 138 139 144 140 146 143 143 141 140 136 133 130 134 130 133 124 111 155 180 179 178 180 179 180 177 180 179 179 179 181 185 168 111 115 147 107 71 104 115 124 123 124 120 121 126 132 132 135 138 134 138 139 139 134 134 132 138 137 138 127 130 131 130 125 126 123 120 113 108 104 106 104 97 97 99 93 86 87 87 91 90 91 86 92 96 109 116 122 125 131 132 132 131 134 139 138 138 139 143 139 142 142 145 140 138 130 128 126 126 122 125 118 120 164 180 181 179 181 179 180 179 179 178 178 182 181 182 181 140 115 147 110 78 99 112 113 121 118 120 117 123 127 128 133 133 136 133 140 135 137 129 132 128 133 128 132 129 136 134 132 126 123 121 113 96 87 94 92 89 89 102 107 117 112 97 75 74 76 82 94 106 108 120 125 128 131 131 133 130 134 132 136 134 141 136 139 135 143 141 143 134 131 125 127 126 121 122 112 131 173 182 180 180 178 180 178 179 177 179 177 180 180 181 183 171 137 140 120 79 89 104 113 114 120 121 122 124 125 125 128 136 133 134 130 132 134 135 128 131 127 131 131 135 135 134 131 128 114 107 108 90 78 77 82 81 84 90 107 121 119 91 76 89 97 82 78 94 109 122 125 128 131 131 130 133 130 132 129 132 132 135 133 138 136 139 135 132 128 129 127 126 123 115 117 156 180 180 180 179 179 179 179 177 179 178 178 180 181 181 182 182 158 137 136 81 67 97 109 115 126 123 122 122 122 126 127 132 128 130 130 132 129 130 128 134 126 127 127 138 136 130 124 128 115 98 91 89 86 89 84 79 81 89 106 112 111 104 97 100 103 85 80 90 109 117 117 122 129 131 133 136 132 131 129 133 132 133 132 137 133 134 134 131 127 133 129 124 119 108 126 170 181 179 180 178 180 179 178 178 179 178 178 181 180 180 180 184 169 140 141 103 63 93 107 120 120 122 120 124 124 125 128 126 128 128 132 123 121 118 127 124 127 120 124 124 130 124 126 119 112 98 89 92 95 99 90 83 80 98 108 115 102 106 100 95 90 98 105 98 102 115 113 111 119 123 131 132 131 127 130 125 134 132 137 129 132 132 134 129 130 130 126 115 115 101 131 177 180 181 179 179 178 180 178 179 177 179 177 180 180 181 180 182 179 152 135 98 71 92 107 114 113 114 121 120 122 127 128 128 126 128 123 116 112 120 122 119 115 118 117 113 112 118 115 110 99 90 88 95 104 96 90 93 101 103 114 118 118 107 106 98 94 94 95 96 107 117 106 100 109 118 121 124 125 123 119 122 125 130 129 131 129 132 132 128 124 126 123 116 107 103 139 178 181 180 181 178 179 179 179 178 178 178 178 180 180 179 181 181 184 169 130 82 68 97 108 110 111 114 117 119 123 123 124 126 126 125 120 116 115 123 116 106 99 107 108 104 95 95 95 91 84 93 101 102 106 100 99 105 112 111 115 116 121 116 120 115 110 94 88 96 105 105 98 89 92 105 113 109 104 116 124 124 119 127 125 128 131 134 128 126 120 119 118 120 100 95 141 177 180 178 180 178 179 178 178 178 178 178 178 180 181 180 181 181 181 183 160 97 59 91 106 114 103 101 110 119 122 123 125 124 126 119 119 111 118 115 97 82 96 96 94 91 91 84 87 78 76 95 109 111 113 120 113 117 118 124 115 116 116 129 130 134 123 122 110 110 103 90 85 86 84 82 90 97 99 101 120 118 119 114 119 118 132 130 130 126 121 110 107 101 90 100 155 180 179 180 178 179 179 180 178 178 178 178 178 179 179 181 179 180 180 182 187 171 121 94 94 94 93 95 107 116 117 120 122 123 120 117 113 110 107 106 94 86 83 87 79 76 79 82 75 80 95 101 113 122 119 105 97 96 106 112 120 116 118 116 107 96 98 108 117 122 118 102 93 91 86 85 76 78 85 94 105 117 115 110 112 123 127 131 127 124 112 103 100 91 82 131 178 180 179 179 179 180 178 178 179 177 179 177 179 178 180 179 180 179 180 180 180 190 168 83 65 89 103 106 105 110 113 113 117 121 118 115 106 108 107 101 92 92 85 79 66 68 73 76 75 90 109 114 109 100 87 79 75 73 76 80 91 94 94 82 81 77 83 86 93 99 116 117 112 101 85 76 71 64 68 84 94 109 107 108 112 125 123 126 119 118 111 104 99 88 69 123 176 180 181 179 180 178 180 178 179 177 178 177 177 180 179 179 180 180 181 181 179 184 170 81 59 93 103 105 95 103 115 119 117 115 112 104 105 107 106 89 87 88 87 72 66 68 70 68 87 103 103 87 73 68 65 67 68 70 65 69 62 65 62 65 65 70 67 71 67 71 83 100 107 103 85 70 65 62 68 75 83 90 107 106 117 119 125 122 117 111 108 92 92 80 67 136 179 181 180 179 178 179 178 179 178 179 178 179 176 179 179 180 179 179 180 181 180 182 182 113 57 83 100 99 89 103 113 115 110 102 107 109 105 107 95 79 77 79 72 69 67 62 64 75 87 87 71 55 58 56 55 50 51 51 51 47 50 51 49 47 55 55 45 41 39 45 56 67 83 96 91 78 69 75 74 68 62 75 97 109 114 117 121 123 114 110 108 93 84 73 79 154 181 179 178 179 177 179 178 178 179 178 177 177 178 177 180 179 180 179 179 180 181 180 187 146 72 89 110 103 101 106 107 108 104 104 108 107 106 99 80 72 63 63 63 64 58 53 61 69 57 47 38 37 37 40 35 29 55 79 77 78 71 69 87 93 97 88 61 38 35 39 48 43 49 71 86 82 75 77 78 72 66 71 87 106 107 114 119 122 110 102 98 98 85 57 94 168 181 178 180 179 179 178 179 178 178 176 178 176 177 179 179 179 179 181 179 180 181 180 185 164 87 80 103 101 98 96 105 108 106 106 107 105 108 94 79 63 55 56 63 58 40 25 25 22 18 16 14 7 1 14 15 10 42 67 70 77 57 58 89 96 88 75 44 28 25 15 20 25 27 37 57 69 72 71 71 74 75 73 96 107 112 112 118 113 109 92 91 92 82 56 119 178 179 179 179 180 179 179 177 178 177 178 176 177 176 180 179 180 180 180 179 181 180 179 183 180 110 71 86 90 85 84 94 101 103 107 108 105 99 94 83 65 56 63 66 45 9 0 0 0 0 9 10 12 42 40 28 35 30 24 19 16 11 11 21 27 23 19 14 11 30 27 6 7 8 8 14 28 46 65 72 72 69 74 88 105 110 114 111 105 98 93 91 85 68 78 144 180 180 180 178 179 178 178 176 177 178 177 176 176 178 178 179 178 180 179 181 179 179 179 181 185 144 76 83 94 81 83 82 88 96 102 102 103 97 93 84 72 61 64 58 40 25 33 31 22 12 30 28 34 92 101 71 85 101 95 104 116 110 109 120 122 104 98 98 77 87 79 46 21 5 1 1 2 19 58 73 76 73 78 84 103 107 113 104 104 95 93 95 85 52 88 162 181 179 177 179 177 179 178 179 177 178 176 178 176 178 179 178 179 179 180 180 180 180 180 180 183 174 107 75 86 81 81 83 84 87 93 101 97 92 88 87 74 68 63 63 63 68 58 57 57 56 47 34 44 77 72 57 86 99 97 122 142 117 122 145 142 118 112 101 85 87 85 58 35 19 30 43 38 37 53 72 79 80 82 92 98 111 105 105 100 98 91 92 75 68 122 175 180 179 178 178 178 177 178 177 179 177 178 176 178 175 179 177 179 178 180 179 179 180 180 179 181 183 123 59 67 78 82 88 87 89 92 92 95 95 92 86 79 67 60 65 79 88 81 70 65 67 64 70 73 66 58 61 72 76 71 86 101 93 98 112 103 90 86 78 64 66 66 54 53 57 62 62 66 68 78 80 79 85 88 84 90 101 104 100 104 96 86 84 65 71 148 181 180 178 179 177 179 178 178 177 177 176 177 177 177 176 177 178 178 179 178 179 178 180 180 180 179 186 151 75 66 73 73 77 81 91 95 91 97 93 86 80 78 72 71 74 91 94 95 82 74 72 79 86 91 89 88 82 85 84 72 73 75 85 79 83 73 76 62 64 62 76 83 90 85 80 70 70 73 81 87 78 76 82 89 81 87 96 103 99 102 88 86 79 57 83 160 180 177 178 176 178 178 177 175 177 176 177 175 177 174 176 179 179 178 179 179 178 180 178 180 180 180 182 182 117 55 67 73 69 75 85 86 91 92 90 80 78 80 86 82 94 95 103 103 102 90 85 79 86 90 89 95 102 105 97 90 86 103 106 106 93 94 88 95 88 89 90 97 89 81 75 77 86 90 88 83 82 79 83 90 96 97 105 98 97 94 88 80 69 55 111 173 179 178 178 178 179 177 177 177 176 176 175 177 175 176 174 179 177 179 178 178 179 180 180 178 179 178 179 188 154 72 59 66 75 77 73 73 81 85 86 86 78 75 77 87 99 103 103 107 113 105 100 91 87 80 82 83 93 93 94 96 103 104 108 105 101 100 97 102 97 88 84 83 80 81 84 91 96 103 99 87 83 85 85 90 92 92 94 90 87 82 81 78 62 81 150 179 178 179 178 179 177 178 176 177 175 177 177 177 176 175 175 177 178 178 179 177 179 178 180 178 180 177 185 160 105 79 58 63 73 75 68 67 76 81 76 81 69 59 63 79 91 108 104 107 109 117 113 110 97 91 85 83 81 83 84 86 93 94 100 95 95 90 92 83 89 78 77 71 74 77 90 100 106 104 103 96 87 85 77 78 84 83 77 81 77 76 72 66 65 127 175 178 179 178 178 177 178 178 177 174 177 176 176 175 176 173 176 180 178 177 178 179 179 179 178 180 178 188 150 40 58 104 65 64 65 65 58 51 62 69 64 60 60 51 60 74 94 102 112 105 109 111 117 112 105 97 89 90 86 88 86 90 86 91 87 91 83 87 83 80 73 76 74 82 84 89 95 105 107 105 103 100 101 96 82 67 76 73 70 73 77 67 63 42 75 158 180 178 178 178 178 177 177 177 178 177 177 177 175 176 173 175 174 178 177 178 178 179 178 179 178 177 186 157 43 0 68 131 96 68 68 68 64 65 67 62 63 55 56 65 71 75 89 103 112 107 108 112 115 111 107 99 95 90 89 83 86 86 89 89 95 93 88 88 85 81 79 80 78 86 92 93 100 103 97 103 105 104 104 90 72 64 67 63 61 70 71 67 58 42 102 171 180 179 176 177 176 177 176 177 176 177 176 175 175 176 175 175 173 177 178 178 178 178 179 178 177 184 165 55 0 2 61 137 119 80 58 65 71 69 68 69 67 65 56 57 61 69 75 90 100 117 114 117 109 109 102 94 84 83 78 71 67 64 62 60 67 67 75 73 75 75 78 75 86 89 95 94 100 105 105 107 104 103 95 77 61 62 59 57 59 71 68 64 49 88 156 179 179 177 176 176 178 178 177 175 176 175 176 174 176 173 177 174 177 179 179 178 179 178 178 174 182 173 68 0 2 0 57 134 133 104 56 52 75 70 67 73 76 69 59 56 66 68 77 82 98 108 118 109 111 109 105 92 81 74 68 68 68 60 43 38 36 41 45 49 51 62 62 72 77 87 91 94 96 107 108 110 109 105 97 79 66 59 54 54 66 67 63 50 54 117 173 179 179 177 178 177 177 176 177 176 176 176 175 176 174 175 173 175 174 178 178 179 178 178 176 187 191 106 6 1 2 0 57 131 130 124 100 60 70 78 67 74 78 72 66 61 56 52 63 73 82 97 112 116 117 116 113 109 105 95 84 82 85 74 59 54 53 57 61 63 68 69 66 79 91 97 99 103 104 110 113 113 110 104 94 82 66 59 49 59 69 66 54 43 96 160 178 178 177 177 176 177 177 177 176 177 175 176 175 175 173 174 173 173 173 176 177 176 178 183 176 128 72 15 0 2 1 0 46 125 126 119 117 81 53 64 76 81 82 78 72 66 53 63 69 83 89 103 109 123 116 119 115 119 118 117 110 107 105 98 91 91 91 88 91 89 99 98 100 102 110 108 109 107 114 114 112 109 107 99 87 77 64 60 56 56 67 66 32 75 152 176 178 177 177 177 177 176 177 176 176 177 177 175 176 174 175 172 175 172 176 175 176 181 184 131 46 22 8 0 2 1 1 0 42 119 129 117 113 104 75 59 68 72 72 71 73 62 56 67 82 82 97 101 109 116 123 123 126 123 123 119 116 119 113 111 108 109 107 113 111 112 112 115 113 111 109 118 116 114 110 111 108 106 103 100 93 79 71 61 55 49 57 53 68 143 186 182 178 176 178 176 178 177 176 175 176 175 176 176 175 175 174 174 173 174 172 188 183 155 82 17 28 44 13 1 2 1 2 0 36 118 130 118 113 106 94 71 57 62 68 63 56 54 62 66 73 74 93 102 104 110 120 123 125 125 123 121 120 122 125 126 125 122 121 126 124 125 122 123 122 124 123 124 121 119 113 113 109 108 103 93 86 79 68 64 54 54 56 37 61 126 137 154 177 178 177 176 174 176 175 176 174 176 174 174 173 174 175 174 172 173 173 93 72 32 14 38 41 16 0 1 1 1 1 0 33 113 128 117 110 96 96 89 61 48 56 52 49 59 60 64 65 81 82 96 94 103 118 121 119 123 120 122 123 122 128 129 132 132 135 127 134 132 138 130 134 131 130 123 126 120 124 120 113 98 91 87 86 77 68 65 46 49 61 53 26 36 33 29 101 169 177 179 181 177 176 178 177 166 167 175 179 174 175 171 172 170 174 17 20 34 39 19 7 5 1 1 1 1 1 0 42 115 126 115 108 101 91 84 75 53 36 37 45 49 53 54 59 65 75 86 101 110 120 118 123 124 126 128 127 125 127 132 133 135 131 136 129 128 128 135 136 136 124 125 126 124 122 121 102 85 78 83 80 64 66 61 39 46 105 94 18 6 34 31 21 44 46 62 123 162 171 163 113 56 46 80 127 159 173 177 179 180 175 42 36 20 9 1 2 2 1 1 1 1 1 3 43 110 124 113 108 104 95 87 80 69 44 27 28 30 39 47 52 62 76 84 101 113 117 118 124 124 125 125 128 130 131 128 124 125 126 127 120 125 130 134 129 124 120 125 123 122 117 110 87 76 69 64 59 51 51 40 26 67 127 85 8 0 2 17 34 40 28 11 21 59 75 61 47 41 16 2 17 61 102 119 126 136 153 31 8 0 0 1 2 1 1 1 1 2 5 15 55 102 118 111 105 100 95 89 86 83 73 45 25 23 24 39 49 58 66 74 72 93 105 108 113 125 125 124 122 120 123 118 112 117 125 117 121 117 131 133 130 116 120 115 119 115 114 98 86 72 60 53 49 44 33 15 29 89 131 82 15 7 2 0 5 25 30 19 24 37 42 37 31 25 15 25 45 41 25 17 9 11 33 3 0 1 1 6 7 1 1 1 2 2 11 28 56 99 114 115 106 98 95 89 87 87 84 66 36 21 17 25 34 39 51 60 67 74 81 83 90 100 107 117 118 115 109 103 98 113 118 123 118 115 119 121 120 122 111 104 106 108 105 90 79 75 59 47 38 21 8 25 76 107 124 61 10 19 7 1 0 2 10 14 16 24 29 24 16 6 14 28 28 24 18 12 8 5 5\\n']\n"
     ]
    }
   ],
   "source": [
    "with open(os.path.join(data_dir,'test.csv'), 'r') as training:\n",
    "    print(training.readline())\n",
    "    print(training.readline().split(','))\n",
    "    #print(np.array([int(num)/MAX_IMG_VALUE for num in training.readline().split(',')[-1].split(' ')]).reshape(96,96))\n",
    "    #print(np.array([float(pt) for pt in training.readline().split(',')[:-1]]))\n",
    "    #print(np.array([float(pt) for pt in training.readline().split(',')[:-1]]).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_imgs_and_keypoints(file, file_path = '', resize_h = 100, resize_w = 100, max_imgs = None):\n",
    "    with open(os.path.join(file_path,file), 'r') as data:\n",
    "        #remove header\n",
    "        data.readline()\n",
    "        \n",
    "        images = np.empty((0,96,96,1), float)\n",
    "        key_points = np.empty([0,30], float)\n",
    "        \n",
    "        num_imgs = 0\n",
    "        for line in data:\n",
    "            if len(line.split(',')) <31:\n",
    "                continue\n",
    "            row = line.split(',')\n",
    "            \n",
    "   \n",
    "            row_pts = np.array([float(pt) if pt != '' else None for pt in row[:-1]])\n",
    "  \n",
    "            \n",
    "            image = np.array([float(num)/MAX_IMG_VALUE for num in row[-1].split(' ')])\n",
    "\n",
    "            image = image.reshape(IMG_SHAPE)\n",
    "            h, w = image.shape[1:3]\n",
    "\n",
    "            #try:\n",
    "            #    images = np.append(images, image, axis = 0)\n",
    "            #except:\n",
    "            #    print(image.shape)\n",
    "            \n",
    "            pts_scaled = np.array([row_pts], dtype = np.float32)\n",
    "            pts_scaled = np.array([pts_scaled[i]/h if i %2 ==0 else pts_scaled[i]/w for i in range(len(pts_scaled))])\n",
    "            pts_scaled -= 0.5\n",
    "            images = np.vstack((images,image))\n",
    "            \n",
    "            key_points = np.vstack((key_points, pts_scaled))\n",
    "            \n",
    "            num_imgs += 1\n",
    "            if max_imgs is not None and num_imgs >= max_imgs:\n",
    "                break\n",
    "    return key_points, images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_pts, imgs = parse_imgs_and_keypoints(os.path.join(data_dir,'training.csv'), max_imgs = 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only care about they eyes\n",
    "key_pts = key_pts[:,:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "key_pts.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.18784958, -0.09372631, -0.18513533, -0.12060753])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_pts[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_test_data():\n",
    "    # The test data doesn't contain key point information. It's what you're tested against in the Kaggle competition\n",
    "    # I just want the dataset so I'll make my own training and test data\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 60 - 20 -20,  train -val -test split\n",
    "imgs_train, imgs_test, key_pts_train, key_pts_test = train_test_split(imgs, key_pts, test_size = .2)\n",
    "imgs_train, imgs_val, key_pts_train, key_pts_val = train_test_split(imgs_train, key_pts_train, test_size = .25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 96, 96, 1)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.19455147, -0.1464456 , -0.18006617, -0.12344265])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARsAAAEYCAYAAABsuVKPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJztfW2sXtV55doYCIEEjMEYxx/YgCFACDgBhpa0iqCV2gaVEUpm0nYqpmLEn06bdjpq0v5pR5pKE6lqmh+jSChpRaSo+aCREiVRJ4iYMEMkhPkMxgGMsfEXYMCEBJIQYM+P+67zrve9a+997r34XF/7WX98vN9z9tl7n3PPXs+z136elHNGIBAIHG4ct9gNCAQCxwbiYxMIBAZBfGwCgcAgiI9NIBAYBPGxCQQCgyA+NoFAYBDExyYQCAyCBX1sUkq/lVJ6PKW0I6X0qberUYFA4OhDmq+oL6W0DMATAH4TwF4A9wH4vZzzY29f8wKBwNGC4xdw7VUAduScdwJASunLAG4AUPzYLF++PK9evbpYIT98r7zySlfGY/dR1LLjjjtu1rGWveMd7wAAvPOd7+zKTjjhhFnnpZTsce3eC/ndnaf3Xeh9FnJerf8OpXa7emrP09XTGhN3j7m0n+e2rnHtcde8/vrr3fHPfvYzAMDPf/7zruyXv/wlAOCtt97qyviOnn766V3ZSSedVL1Pn7ZO38eBv/cdW8WOHTteyDmvbLVnIR+bNQD2yP/3Avh30yellG4BcAsAnH322bjtttsAjDulf+h8KHfccUdXtmXLFgDAL37xi66MA6MDqA+FH5RTTjmlK9u0aRMA4NJLL+3KVq1aNeu8ZcuWdcfHHz97eNjuN998c1Z79KG4h6tlvJ4vnZbxI6jX6P30hXjjjTdmlemY1s5zHzy9D8dC62N7dGx4jZZpX1nu2q3n1erWNrix0OdG6Djy2bjztH69N8/VNvJ5nXjiibP6p89/z57xn8a2bdsm/gWAZ599FgDw6quvdmUXXnghAODGG2/syi644ILqfXjsPhL6bunfD6HjyN/5NwiMx0T76vCRj3xkd/UE1tfnpALc525Wj3POt+acr8g5X7F8+fIF3C4QCCxlLITZ7AWwTv6/FsD+1kXTX2D9SvOr+sILL3Rl7otMikraCUyaR/wSn3baaV3ZihUrZl3DmUJnzdLMR/Bcx2J0BmQ9jgHp9TqTsm5ngjhGMt2O2jWOXThmo/13rMHV7cxRx65acGPG+zimpO3RcXDP0I2Ta69jpG4cnVmn9en7ePLJJwMAdLL98Y9/DGDy/WbZoUOHujJlJ613s9Zu96wdQ3IM0o2JY/0tLITZ3AdgU0ppY0rpRAAfB/DNBdQXCASOYsyb2eSc30gp/VcA/wfAMgD/lHPe1rhs1syoX1pnNxK08RXqa1H7nMc6k3Cm6cskpo+nMR+Hq84abjZ0DMm1RfugM18ftBypzq/izm2Nk/ZLnaXTcLOv9p/PUtlOy2dRezZatxt7ZQ/8vXTv6fuVmA39iepXfNe73gUAeO2117oyjtOLL77YlalTmdfP1VGs0P63/Hw19jKfVeyFmFHIOX8HwHcWUkcgEDg2EAriQCAwCBbEbBaCmjZBaSupnFJQQsuU/pJ6q2lFx7BbxtTznLPUUc++NFLpqZo8jrY6Jx1NmdLSrzMFa8vuOu5uWbnkLJ6uR39jG7XMOctdu1w97nmUnpEz62pL8aU21saxtfTvJAJ0CgPAmWeeCQDYt29fV0Yzi+YUAPz0pz8FAOzfP15nUQdyXy2R0wI5B/h8tGDzcQx3bZj3lYFAIDAHDM5spr+mbgnVza46U/Brr2IjdRaTxeisUVMLl5Zs+ypap9uq5zkWote3lJ1uyVrvw/qd01TvPX2+Qh3BjlW5GdLNdlqPMhG3hOocu+yXc1w6x76e65bGta8tYRrRYl/aL/c7oaybEoxTTz21K+P7rIshvLc6jX/yk590x2eddVbxfoqaE38uiyEcP8c+5+OkDmYTCAQGQXxsAoHAIBjcjJqm+EqPna6D9FcpMc0kpbRKW0lXnarY6UhKdLKmH3F7ehxKmzydw7LmfG4pcnXsavugnAlSMlHc/qW+DsmWKUSU7t23zDnQ3UZcotUX9/yd9sZBz9NjvnvuHXUaHi1TM8qZNQ7uPXILBK29fM5kdtf2RTCbQCAwCBbNQezUmbt3z2we5R4RhVvGdrMHMHYMq4L43e9+N4BJRaabAd2X380AbtZwjltXpvd0DEDv59iec/LqNc7R7pZxa8re6bbX7sf76DNwu8fnuren1JaW8tVdw0WF0rOuOaed7MDtzyrJE/g+cgkcGL/j+j6yjSqR0HArfBd0nGvL13NRizt2ynem5PifK4LZBAKBQRAfm0AgMAgWXUGsCknqC7TMBSsiXVVKp7SWZpY65GgyuGtcCAU9btFtp6lxZS1zzDmf2cZSqAFnUrl7u/NduISWKeiouXP8OrOnpuUAvKnnFgj0XXBUn/dTM9E9Sxdcq6X7cXDmoQvCprov6sLUAczfVXujmzJZrpqz6faXUAuypb+7979lMvZFMJtAIDAIFs1B7JZiOdO0YtbyS6sznLIYMht1vnEGVKUxZ0s322s7WvFvHUvpG/TK7elxdc/FuVqLJ+vaUJIfOHWym9HIIEpKbHeNG3sXrMvt31LGUrumxVJbzuCaE7+lRHcMSt9RjrnKM3gfFypW++3a01qedkrr0rnTaIXY6ItgNoFAYBDExyYQCAyCRVMQO20GqbDSSGduOQrqYgsr3SZ9bMUg7gunKnW0tRWD2DlnW+pkt3m1peGpmRvOLNG6XfYF1+6SSegiELqsEW7T6XSfAO8MdpEMtR6+UyW9Ti3cRikEx3R7Wkp0NeEZE1uzK9BZrP1TV4BTBtfMp1aMYafD6hvxcD6R+oLZBAKBQRAfm0AgMAgWbTWKdNZpalyENecFVxNMtQc1zYSuCLgYN4qa3NutNrjVJEVLe8JjZyY4+T/gtSm17QytmDJuNc7V48bWtVvb41ZrXKwYZ466bSb6uzO9W1EH3fNw46Pj6eT6TmfknoczPZw5rlsUtG5G8nNoreD2vcaNvYuSGBsxA4HAEYtFdxDrrEGFpDosyXzUscsZVK912/KVxTB/spY5x66ir4PQKU2dI7WVcMw58VyqllYa35p+prX5rsW0HNN0jNQ5kFuzvWMkrNvFAdbjVr/cLN1yqk//ptc4hlNiyK7/TuVOpq7vuvv7KEXbm0aLubgYzK1okvNZTOmunfeVgUAgMAfExyYQCAyCRduI6RxydAKq9sBtluQ16jRU04uxa2g6AT6bYC2dSgt9o7yV4By7zoxywcSdhqVl/rjtAdP3AHwkw9Y2DGeOtpyvzozse78WrXfR+2r30zpbwc1dX1rbQgjVhfEdVWewS+8yn/vM5x12Wqjato/5IJhNIBAYBIMzm+kZxM1STH0BjJ1mLsSEYwB6rotv6zbDlTbQEX0dci1HcosNEY4BtDbDOSdmKy6xS2/Sd3m2tTG0tTGy5iBu9V+vcYkN6WBtbQZ1M3sr7IQLy9FaanesiTGIdTmb0ftUxqEsnw7ikgyi1p7WRkzCMX/33OaTrC6YTSAQGATxsQkEAoNgcDNqWs+gNJD0Vzes8Tw1f+hcU0day0Fa24jWijnTQi16WSlWTC1tSyv/tTP7VIldM+HUdHLtdmPmnIYuWLr2VX93plAtimCpPYTTMzmTWcfMmQ9atzPr2QfVvTgT3jnp3Xvk3nW+y1pWyt7pkgTU4P4mSu93Le1NK8ZPXwSzCQQCg2DRHMRO5cpUF/pl5+ziovIp29FlRTrfWmEgant2AM++aozEMaFS4jL2az4qTp2R6UB0IRZqy8KlPrhZzDmn3f20rKU6dtdMn68osU+yF+codYrtkqPZoRajurXvyrVdx5bv68qVK7uyQ4cOAQCee+65rkwdyBwX55xtxbd2z01RW+Z2soOIQRwIBI5YxMcmEAgMgkXbiOmck6SjrWh6zgGozmLqFJwatOXschqPviZTS+3pHH+tcBI1s0XbWNpgV2vj9D2mj2uhEVpRCZ1z1oUOcUpk57gtqZNbEegIl+u9FRGxb8Bz10ZFbQFBzf/169cDAF566aWuTFO50MzSxQC3ydOhZZq6yIkOoSAOBAJHPOJjEwgEBsGi541SSkxK6XQdLdrqKLFqGFS7M31ei4LPBy3Tw5lHzmxxGg29hv1Sak2UdC8ErynFiqmtGClYd0lT5DaTuu0T7L9boXMrecDYXHObSVurNm67izMP3Xvmtoe04gK5dmg9dAWcddZZXdkTTzzRHXO7gtNCKZxmqK+mzGm8Wlsc+iKYTSAQGASDMpuc86zZQh1SLq+30zq09CFutnNfbseQWjNb7byWOtk5eV1fWnGC3ezsZnYXiU5BR3qJzdVYnrZR9U7u2tpY6PPgc285352a2v3unMrKCtyYOG2Oc1i3dDYtVkVou7kw4kKjaHvd+0rnMTB+7jU2r/WVUHv/Q0EcCASOWMTHJhAIDIKmGZVSWgfgiwDOBvAWgFtzzp9NKa0A8BUAGwDsAvAfcs6HSvWM6ppFyZS2kv6q9oBybecgVqqqx7Wk9Qqn12k5Q2smlTMTnEmkx87Ua2UqVLg4LDWthKP/pfOdg7C28bFE0ftuV3Cmldsy0UplU9PmlBYD3EKE09TUtFAlx61rjzMt3bN00QK1nocffhgAsG/fvq5s48aNACb/jpyTvmWuOxzujZhvAPiLnPNFAK4G8McppYsBfArAnTnnTQDuHP0/EAgELJrMJud8AMCB0fFPUkrbAawBcAOAD49Ouw3AXQA+2ahrVsQwt+3excF1S7+63Pvyyy/Pul9po+Z0PaXYuDWW03LsOrbgZr6W862VFIwznzLEmiPR3cdF1dO6FbWoe6UldIdaKhu3GKCq8lYs4xqTKCXzo3O6piTWa1oOYH0eLv1LLY2Qvqu6WMINmnfffXdXRuZPNgMAy5cvBzCO/Kf16DiqhGCumzcP+0bMlNIGAJsB3Atg1ehDxA/SWYVrbkkpbU0pbXUfhEAgcGyg98cmpfQuAP8K4M9yzq+0zidyzrfmnK/IOV/BL24gEDj20Etnk1I6ATMfmi/lnL8+Kn4upbQ653wgpbQawPN96po2n5y5oXSTlFI1Ay3NBPUjujmT1zszqaRErm2g6+sgc8pdRavumhpUy110u5YWhP3TNjqHdUtnwufVinLozJpWcHPW3XK0u/FxeiQtc071lnOaUDPJbfJs5SOvmWFqOmnw/8cffxzAZAqjSy+9FACwbt26rozO4nvvvbcr27x5MwDgoosusm3kM+6rH5uPqrjJbNLM3b8AYHvO+R/kp28CuGl0fBOAb8z57oFA4JhBH2ZzDYA/BPDDlNJDo7K/BvC/AHw1pXQzgGcAfKzPDfllZD5unV0YqU8VlHSAufi1eq1jLC4UQ8ux1Vr67psmwzEONxu0HJJ9w1u0IuzVZimFu8axnfnEcnZOZdevUs5wV+YWGhzbaaVyqal73VK7i/ns4ju36nbMTvuvzmKXjohRKRVkNhqegn9HpXzz7hnVxnE+oSb6rEb9PwClmq+b8x0DgcAxiVAQBwKBQbBokfpoRmlwZ2oAlOq99tprACZNJp6ndJPb74E6/Z9PqhbnkG0FDq/l8gbq4RT6mht6rG1gv53K1WlGnJkAjMfc6W1a6VZa6tRaRkXXnlKEPVe3Mxmnfyu1u5Vuxz1XmlQ63to/vq/aL77j7h3U8XammZpWXPhQJz8dyHqtOpUJ9y60tGJ9M6I6BLMJBAKDYFBms2zZsi6gFb/2+kXevn07AODAgQNdGWcV/Zo7x5Wi5gTu63BVuK99ywHq9gs5tPbL1GbuUv2ODbiZy4X5cPW4pW+3V6kkRagFKXNhMFyCO6eQ1mPHBrU9LCvVw5lfx4xlOmZ8D90SuYsNrNerFINwS+h6P837vXr1agCTwbX4uyqDqWdThsS+qAVQk0OU0HcPlUMwm0AgMAjiYxMIBAbBoGbU66+/3mkAqKnZsGFD9zudwc8880xXRrrmNDUlHYVL29I36pijh86saW3Ec9qbFvWsmVwllXMtRYdzYracr84U7OtoLrWrlo1S703zqaUjajmkncnEzKF6rZoUPFYTjtdrG10+eqfhUrPfjbPbQMt2q+mk5hHLnUvBRTx0OrNSxMuamb0QBb0imE0gEBgE8bEJBAKDYFAz6sUXX8QXv/hFAMB1182Ij9///vd3vzMmBykvAPzoRz8CMGlG0dtOswvwdNShRf9aZlYr++H0NSVdh9sE6SLatQKnE25Vx5ktej+3+U4pM891cV9cZLyWyejivTiTSK+l+afXOi2Mvgv8XVeHqOviv8BkkHCaUW6VTc0amk+vvDIOfMD76TYCvYb30d+5wdLFrtHz3Dhq3W4lVE2v6b6Uts+4zbvORJ+PvoYIZhMIBAbBoMzmuOOO6766TtfAWUO3wZPFcCMZMP4K6yytx32duETJQewi2dU2IjpdR6mNnHX1fpztnRZEZ2kXTsPFYNb2uLpbGxZrCdmc89E9A72+5OQmHEuZvu/0McdFnb1sh9bD/Nm6OVHHgvWo6pbvo5aRdes7QSai7Lu1CdiFk3CMRMF6nKpYx5a/6/OnxqcUldE5iB04tk5V3kIwm0AgMAjiYxMIBAbB4GYUtyu4OBxO10BHmjrFSIn5L+A3vjlHqytTtByxTnNAuqqb3XjsyoAxbVX6T4quJhNNASfhB8YU3mX6dLJ+tzm1FBdouq1A3dRTx6bL0Ok0HFrGOrX/LNPzWuNMk1uduCwrRfxzJhP740wizSPvdC3uPjo+ztHuYtzos+E91Txiv5w2p5U51EWR1PffbZ+YTxybrg3zvjIQCATmgEGZTUqp+/rzK69fTc7irbzN/MLr19wxErfl3y2Ll5bDa2pZxz7UIckZR8ucs1gzTrhruGyqs5mqV138X85IOks79SnHRM/TvvJ352jXceRMqiytNDtPw7EY57jUsdP7cMx0SZspTJTZcEzdggQwjg6p7IPH7hkqs+P7qPU5Z69eQyam481rSs+a93n++XG4b7ZbkwmwnhUrVsy6VmUlOj61MCkutnJNXlJCMJtAIDAI4mMTCAQGweBm1LTzSmkk6bGaTI7+8xp10inVdc7gmuq2RAmdxoVtdFReTSJSVL1WTQvSWXVs8nqtR6n39LWAz3RIJ6aaLxwfNT05pmpG6TVqUhBOH+La6jZGaplTBk+fr+epzkqfNc0nzf7oTCunENZjtk3rdjGXnAOdz1rvd8YZZ3THa9euBTDefAyMTVN9/s5loHjhhRcATGqFWI97R9X85bNU1bSOqTO9Xa73WpbMFoLZBAKBQTAos8k5d19y94Xkl90pUZUBOYWk2xvj9nm09kY5la9z/Lo4yZx5tMzN0tpGLeNMpI49/u72UGm5zlIu7AAZjatbnZCOsTjlq2NcrX03TtHcCl/AcdT+uWOd7dkvZWa8j8oldu7c2R2TnbhYvSrTIDtRhnj22WcDmGTaTz31VHfMyJPvfe97Z9WzcuXKrsypfPXvwzFoSkNcYj+2S+vR902fO/cluvAV+tw4zsrs+yKYTSAQGATxsQkEAoNg0RTETtFIan3w4MGujJRRKSGpntJWTQlTy6/divLmNue5UA1u86I6AJ0aVik6TS41CehgVJrMYzXl1PQg9VZnoFM0uw2tHEfVaGhuaXc/F3XP5bpWuNAJLpg669S+0hmuZpJSeJ7rQiyo05zHTz/9dFemZi9/18iRbK+28eqrrwYwOU7Mqa11r1+/vjtmgHLVtbBuBjEHxs/QLZAAY5NL33UXqoPPVc0/jhkjZer9gPFzVbOOTm41rV0b+yKYTSAQGATxsQkEAoNgUDPqhBNOwKpVqwB4DQOpsgY8J+3btGlTV3b55ZcDANatW9eVtbIt0hRQHQkpqLZBzQMXN4ce/Pe85z1dGc0VlZHv3bsXAPDII490ZUqz3dYEmo9upaeESy65BMAkZSYldqs6SuWdRkVNQTVdCdJ/l5XRbRDVYy3jmOq9qQHRMaGpoxoWZ9Zp3XzGH/zgB7symm16PzUPaJJfdtllXRlN4K1bt3ZlHJPrr7++K/u1X/s1AMBdd901q93A2DTh1gJgPGZqJjloG93mZbcaqX8XxP79+wFMmlvqCqC5rjmp+HcUOptAILCksGgZMTk7qbOPs47OYtRF/OAHP5ioB5ichZT5EK2vL9tQyok8vWkUGLMFxkYGgPvuu29W2a5duwBMMoUPfehD3TF1Dbt37+7Kvv/97wPwTtwLL7ywK1Omxdnufe97X1dGZqhOVZ6nrInjrIpkFxFQ+8+ZT5mdi8vsHLYuUp/T5rg2qCLXOfSVkZJ9aBvJkNW5Svap99FnSBag9yYj0XeUTGzz5s1dGRk84DdvktE452spo6v7nfduPTcHvTef4bPPPjurTM9z0Sv7IphNIBAYBPGxCQQCg2BwnQ3powucTJrpNCVaRkcrTRFgUnpNulnK/kc4KqiU0TlQ6QR+6KGHurInn3wSwKT5c/HFFwMAbr755q7syiuv7I7pkPva177WlXEsVMPhqLBK7kn1VQpPjceWLVu6MrZNtUk0D1TXoyYVr1EThe3RNnLM9FoFr29lHp1ulx6rY9PJ+fX9oEmhzvA1a9YAmEwdpHquUtsB4KqrruqO6XzV509nsJqyql1yAd9rZaV0KhwLdc677RWsxwU3VxNM31ea3HoNx0e1R3zWEfA8EAgcsRic2VDxyi+kfkmdOpHnqaOVKM12btao5frWr70yCbbVzR7nn39+d+xUpWRpyiR0JiXUQU6GpM4+tveBBx7oyrSvN95446w+cNb5wAc+0JXREc0lUK1Hl0qVIbjIiS58Bdmqjq2OmUtb4zbYOoc9ncvKPJTZOYU1763hFOgsVke7tlE3ThJcdNAldDqV9Rmdd955AMahJLR/euziPyvcsrK+43yXVOXL90zZoLuW4+diRyt0TDimbtEkHMSBQOCIRXxsAoHAIBg8ng2pHXUfSvVI0XQDHem6llE1S6cfUI6lMv27y4ntgnwDY8WnKjfpfNVraD4ptaQTe/v27V0ZzTJgTL2vvfbarmzPnj0AgDvuuKMroyNd26XOYGo7VB/Be6uKlSaFttFF+XPR3dT5Pm0GAz5+jjO9FBw/vbdLieKCrruc2i7guz5rjoU+SyrRgbHJqdewX6qp4ft4zjnndGU0a7SfqoViH13gcIUzo7RO1qPmGk0dfUYuS6jTx7i+utz0ajISrcyZDsFsAoHAIFi0SH1dA8wspl9Xnq+zGZ19uq/E7SfSGcLFGa5FCyzV45ZsXWRAznzaX2U5XGrU/TLcY6PR9MhStP+aC52MhYplYLxUr05VFwWQderM5SK+qRKXjnrn7CzNyJzl3WyuzIazszqAOYNq/53DUmd2p9h117oUNtpu1qlhIFzYBTeOLpyGwi1Y1NiO1qP1uTzjTont0vYo++LfUt9UPiWVcw3BbAKBwCCIj00gEBgEvc2olNIyAFsB7Ms5X59S2gjgywBWAHgAwB/mnMsh8jBD70hjSfWURpPiaxlpvYvopmXO+VZSYk6f5/JSTx9P1+N0FM65pvog1bNws6RuBiStVScmncEu9AUwNqP03hw/NTNJs5VGuxAbOhbc0KhR56he1fF04+Rott6H7XF6HT2P74v22WWRdBoefUbO0a7jwzF3ObPdRlwX8FtNOWdS9s0zXzKtaB6rVsrpz9jels7MmUxqerpc8C4gfl/Mhdl8AsB2+f+nAXwm57wJwCEAN9urAoFAAD2ZTUppLYCPAPg7AP8tzXzyrgXw+6NTbgPwtwA+V6tHmQ2dV/rVpCOSS9vA2FnolvFKzMUxDZb1Pa90Tc0x5mZ7nRV1jwmXkHV5mg5dXWp1ydzcjO2cgXqe22NFtqSzlQZPYntVBU24MdFxbOWC5jUu+aCTJ6hC2OV91za6oGd879QB7NLxuEBpOrZ8Xx2LmUv/XV9cPS4AWku+weepfzMuSZ9LGuigv/G4dn4JfZnNPwL4SwBs3RkAXs45k9vuBbDGXRgIBAJAj49NSul6AM/nnO/XYnOq3cabUrolpbQ1pbRVd5kGAoFjC33MqGsA/G5K6XcAnATgVMwwneUppeNH7GYtgP3u4pzzrQBuBYD169fnaYef00yojoQ0WyOo0XFXyttM6un0AS7shFLQVsZM53wkHXXtUbrpHKS6gY59VZPHOXF1zPi7OtWdCVfLNqraG3UGO02NMyOd+eP0U62QHjx2G1/V3FbTy5kWNFFbGVG1TrZN63bqdbbRxUHW/jndi3Nyt/RKLvWQmozUablFFfeeqOnozDVn/uk1DNtxWDJi5pz/Kue8Nue8AcDHAXwv5/wHALYA+OjotJsAfGPOdw8EAscMFqKz+SRmnMU7MOPD+cLb06RAIHA0Yk7bFXLOdwG4a3S8E8BVtfOn8eabb3Y0zK0YkD6q1oERz9T7zxgmqkdRqkcK67QOrVUUZ1I5k8mZW07XoPdTikrzSlee6NNS6kwzoZSqhuOj9+HvLgqiXssNpKrV0DGlSeH670zU0vYQt3rozDG2VzesOlPXxbtRc9WZ0TWdFeDNKNbtYu649pciQ/J5luImERw/HTt9r9k2NXWdS4Hmk1vV1HFy76YLyu42HevfY1+EgjgQCAyCQTdivvnmm50Kkv/qJj/CReDTL/Kjjz4KYNIp5lJ96Ne+FuagpGtwDruaA7kVnU2ZBmc2x0i0jLNZyfnqZiS2UceRY6WxcekY1jJto5vFa0nKSjnTyV61D06JzGekzGb6vtPX8Fx1WDoNiGMN7lmqU5Xt1nvXwqC4kA36u8KxPeekdUnlnDXgoiTqeW4TZ2nj7PTv2gb2xTHbFoLZBAKBQRAfm0AgMAgGj2dDikiZvkbbc5HaWKYZBhkL5vHHH+/KNCi1C8DN+zoTpEUJHd109LYVvczFT1GK7bYeuPspPWa565c6e2luaBn1GqVIfTWTqeUM12OaOG6rgHOG6pg4k0rhniFNNB2nWkwdoL7h05mWChe8X69xDmIXa4fnaRv0PPa1FamQ4+3eo9bmZOfYVswnjk137by3mklvAAAgAElEQVSvDAQCgTlgUGYDjL+czLmsGxF1oyLBL7JuEOSGRd2cp7MYl+dqUfUAH57AwTl+3cxeW84FJmcpl0eZbXMOwlJIB7flnzO7sgIeuwRvpZm75gR2M6T2zzlpnQPVsUa3RKzMRZ817+Oi12mZS2WiIENwmw6V+bmIfi5vuUuZ0spr7sZWj/le67YfhipRuQiP3QZahY4j2+veM5duSa/ti2A2gUBgEMTHJhAIDIJFM6Oobjxw4ED3GyPDqYrTaQ+oC1FtjSoa3TWOEta0DoqWGVULVF3STBAtpS1/L2mGapsFW85ep/9wfXHaDOcMLo2Ji1Tngmk7s226jum6nRbEpZbh+1GKXcRyp05W8PeW07w1Zi52jYOODxdGmG8eGP+taDZWZ6KzLyVFO4+dSe3+PiIjZiAQOGIxKLNJKXVfWH7ZXSI1lwBNv9z8vbRd3qVWqTk7S8nVarN8q2434+o1dLC5tDVOsVnaV8Pf1UHoHJK8T0sh3EJrmZtQVuCciZxJnUOytX/NjXdrpm2lSXHL825vGH93KW9K7XF9reWcd45bYGwN6P2Yc16dxgzHogsoLnayey6t8BbuefRFMJtAIDAI4mMTCAQGweBmFGkaTSGlf9TeaJZIp84kvXOUFxhTPaWgNQ2DnueUuI7y9k354iK2abmL3lej2NNt5DUtTZFrT6tffeGucToTF0x8PulNnMJc4aLNcSy0/y79jdMC6f1YjzM33Hl6H9c/Z8Kr9kZzuLNO1c/QtNKUQNQUad2sU9voFMZu7PS5OdOyL4LZBAKBQRAfm0AgMAgG19kQjoZRer1y5cqubO3atQAmvei7du0CMKmt0ZgsjJXDiH7AWJPjVglKq1G1DZalPE6EiwyolN9pU0hx3VaA0naFWvZPd03LTHIrWDXzRu/jTCeFM+Fa41jbDKpwOhyl/yxrbZZ1Zq+LOeT0UaVcUa7tbmsK63auBa1H3yOaWfr3wZVJNeXUzTDdBu2Dgu2ZS0KAGoLZBAKBQTB4iInpTYuqx2B84p07d3ZlZCw6czG6n84KGm9127ZtACaVlldeeSWAyXi7buZuqXyJUn7waZSUr7WMiS1NiaLGulxIC6eKbd3bbSB0jt1WFDy3odHdu6W0dXnfHYtz7W459vV5ubAMtWtK/XfP2vXLxQnWPrDfVBJr3W4BwV2rkQhdG904OvbdYogOwWwCgcAgiI9NIBAYBIOaUW+99VZn7lByr1SPzrk9e/Z0ZTSjNEsmdQZ0BAPAE0880R3T0az09aWXXgIwGanObapz1NvJ511cFOfsLJlOzvRwtN3FeFGazetdqhdnErmk9C0nraIWu8dlZdQ+qMOW5+o4Ol2LM61c1EK3EdPpXlpRGV27nabGmXUlqb8LwO9MeI6FOnvVYV3LxtkyI116G72Pi2fjtgU5LVBfBLMJBAKDYHAFMb+s/Fq6BGDqxDp48CAAYPXq1bPKlNmwDBh/fXVp3G187LupzMUydk5DN+OUIsMRbjnYORRLm/hqs5hew/67nNlug6jexzm5ndLWsQutX+txMYFrqWPc7AqMZ1jddOhCbPSNwevCRGh7HCNzS/99WYyLeVxyNNfYsNuU3Np86hTGbmwVtYWNFoLZBAKBQRAfm0AgMAgGVxCT2rlA3vxN9SFUUN5zzz1dmctU6FSeSi2pJla67cyIhaS3KOW6nj5Pj9WscRs/3f0UzonJfisNpoZJ4wJxw6s6CtWEdbFyapkTFU6J7Zzvarbxuenz55ioqtaZeno/9lVVs2y3jrfrizNbWpoZd61zaDuT2jmxXQQ9oK5Najn5WyYVF2ycedzSmfVFMJtAIDAIFo3ZuNAIziHJ31U16cJO6OzsltU5G3LWA8bL4DqTtvYBOdZUY2kudYqWO8evm6VKCdDIXpSRsEzHjGpqza2ue9BcX13Ii5rTuLTHzIWB6Bv/2LFd57hUBkgWpAyIbdMoh3o/t6zsUv3UUtk4hyvgncE8V6/hM3QsHagzjVYKHrahJPPgfZzD2j3rFuN2CGYTCAQGQXxsAoHAIBhcZzOtd2g5Vfm7C6CtVFaVwU51SzCKGTB2Fjs9hrbHOftawavdtU5h29rQ6bQXasLRLNR+UaXtzCgdJ9atbXBaIWcKupQwep6aPY7CEy70gVOVq5O65UCnSa2bc3kfHTs1qVx7eK7TZjmUdDY0qdw4OtPbmZh6TSsb5/RvwPh5ONNS29tKPTTdlrkgmE0gEBgEi5akzs2Qzknltstzlmupat1SozqS3dfcLU87qAOwlo/bzR7aL7fU7vZTuZkSGM9UGiiM+8BUVU21teb/5ixeci66JX2nxK0t45f6yOtd7nXnkFb25diQMjYyVh2T6T150/ch9D5sj4tLrWAftC8ur7tbatf6XGqVVlgSx3xZT2lxgugbTsT9nc1HSRzMJhAIDIL42AQCgUEweKQ+0staCpLWpkKipCB2tJW0T02Q2oZFoB6qwd27b3iC6bYRTsPAulX5rBtQeaz6IZoP+/fv78poemqsZj6Dkhq0Zv60wmkoaLr0NdFK+ain76f1tDQjfO903F1KHBfewTlsndK2lG7GaXMcqLNRzVQrdMT0b3rsNmdqWcul4MZxIQhmEwgEBkF8bAKBwCAYXGdDSl3L4Oi86K6spH9wUdmcyeRWq1oJ6ltm33Q9pZWeVhoZgn1RyqumIPU1+jtNLqX/PHaaodYKnNuI2BonHXuaBS7guXtGakYQJRPFrQTyerdCqeao0xe5AORuTJw2y5kggN847M6jFkZX0VrB713/ib5xb6bPJdj/2IgZCASWFBbNQVybGV3EN+cALjkk3VeX9Sgr4AxY0gzUdDZuc5qbKUppQGpb/rWvZC46I6ta2IUvYD2aE5raFNXeMMSEzpjKKpx6m3oWZU0udq6qd51z0qmO+bv2j7O81q3vB5my6oc49hpOg9drG1x7tMwpf13cahff1+lsnHrX5bAvMQ4+G10MYL9Ue8SxcGOrcM55vZ97Ri4qYV/0YjYppeUppdtTSj9KKW1PKf1KSmlFSumOlNKTo39Pn/PdA4HAMYO+ZtRnAfxbzvm9AC4DsB3ApwDcmXPeBODO0f8DgUDAomlGpZROBfDrAP4zAOScXwfwekrpBgAfHp12G4C7AHyyVd900Ga3Ea1VJm2bVa+e28pHTdOkpH+o5Z5umUyujlY0NecM5rFGqnPOYKcPUjOKwd/VRGEURKX/TIMDjPNIqznClDpnn312V+a0QGpGkf7rfdg2F5tHTb0dO3YAmMxuqmbd+vXrAUzG6WHdTlOj/dcxc5tF+Vz1PJpRfTNe6u/OFaDPks+41EaOo26w5Tirforj4+IIlTQztWiLLuXLfNCH2ZwL4CCAf04pPZhS+nxK6RQAq3LOBwBg9O9Z7uKU0i0ppa0ppa3a6EAgcGyhj4P4eAAfAPAnOed7U0qfxRxMppzzrQBuBYBVq1bNmvqdWtg5j1sqTldPKSoZwZlEv/YaysClznAzg9tU6PrS2hjn8mj3VYvqbE8Hoc52ZDbaPx6vWrWqKzvvvPO6Y5cyh+1xTEqZjdsYqv2ic1rbyJlbZ0+257LLLuvKXDiRVrodF9/X/e5CWTgG7Zz9pfzXLpIfj90yvz5Ldfyy3ytWrOjKHCOrbWjVd9Q5+Z1TufUO9kUfZrMXwN6c872j/9+OmY/Pcyml1QAw+vf5wvWBQCDQ/tjknJ8FsCeldOGo6DoAjwH4JoCbRmU3AfjGYWlhIBA4KtBXZ/MnAL6UUjoRwE4Af4SZD9VXU0o3A3gGwMdaleScrWqVqGlvVB/jaGmL1rpA5XSuuc2Zer3TXrhocm7zXUlB7DZ5OpNg+rfpY9J+dQbSLNKMoKTWzmms12of6ARWU4fOSx2zF154AcDYXALGzmdgbFI5lbeaNdTMqFlH57S2UU049x65bJvsv5oohw4dmtUvpzBuKX9dnmxn6upzo3nkzPJSXCAe6+98/s6Ed66FEmp9VdS0Zy30+tjknB8CcIX56bp53zkQCBxTWLQYxC5NRC2cRGv/Tmv2cZHxOCPpbKYztksZ40JjuJmE9ys5hV0fHZNys6LOzmy7sg8uA+t5bLdLZVKKqsd76ji6KIkuzIWrR9mJY5+s2+2hcnIIPVfHzEV35LHWre0h+9Jl51roDMekS3m0a/13Y+/2S+m57j7OKnCq8hJzcVH5pn8DxgwqYhAHAoEjFvGxCQQCg2BwM2ranCmpgKfL3ObK0gZKR6N5P5f9Us0oF9zZZSVUJ2VJXzHdhla6DYoelcq7zaJq6lGvovoY6mzUachjp48p6XocbXfmKM9TzYhT5+o1dJCqjoTPRk09Z1o7fUgtPIf2y6WgAfyY1czjloPYmd4u7IS+ey6YeCtKnltwcZEjnRZM4cwotzG0tsDTQjCbQCAwCOJjEwgEBsHg8Wym6a6j9U6v4Eymks7Geebdygo3GqomRFd1SOfdSoiLQ9KivK28QfxdtTC8t27E1NgtGzdunNVuN2aOok8HnwcmzRreW80j1q3PjXXqtU6HpCYM++gi7OmWAWcSaHtr0R1bpoXem89at0LQrO0b8L4U3N4FfKf5pGZUa+9gTYfmzEj3jjqtk8KVuW1Bh2u7QiAQCCwYi6azcXBb8WtwrADwjj0XLuDRRx8FMKl83bx5c3e8cuXKYnucjkLr7vvlb6UlYd3qNNWQD1QBq6aC7VBHct8c1a0QAu750bFbSlXj4uRyFtdrOMtrG846ayaYgPZf6+Gxjr3biEinu7I0rZPj6LJtKhyTcmzXKce13QyZoe+e22zsFicUzrFby1qqcEzMReVzLK4Vg9ohmE0gEBgE8bEJBAKDYFAz6q233upobC0OiYKU2jmunPwbGFNlpZGkzLt37+7Ktm3bBmDSIeu2CrScz25LQU0zVPqdcGOiMns1o1iPRsZjJDcdT5oJajq4zaBOP6TXcGw1Xg3P0zYqrad5pA5Q1uM2Hbr+a1+cc7rl+GZfdXOqOmdZp8aK6btg0VogYDv0ft/+9rcn2goA11xzzax2u3fGxalxjm+nGXNxbxSur/PZmuAQzCYQCAyCwR3ENUclv6BuA5miphAGfLoNOkvJZoAxG9CZRGcfl3u7lkbGOUVLCmnnDHezpnMQu82kujTOjZFaj4tHW1siVmgoBl7jnJla5p6HOqxrrMqpal1SOD12jFMZkGNX2h7KCXQc2W5lALyPvhOOkem9Wf7EE090Zffff/+s9p577rkAgPPPP78ra8kpagp79+6V6nNOZfe3V5OitBDMJhAIDIL42AQCgUEwqBkFzM685yLjOVrf2tCoIFVUVS1Vwvv37591vlJe1T041XEtAp+af04z40wml7e6FRhdqfCBAwdmtdttOqTOhBs3gbGjueQAZD1qbtRySzvTQfvjHO3OPHIbP1U1reYa++UUy1pG80h1Nvq7y8bpcsa7zJEuj7bqdXjv733ve10Znfj6rLdu3Qpgsv9nnHFGd0x1s5rU7nm4uEjuvVXz0CnDCRfxz5nRLQSzCQQCg2BwZjO9R8UxBOd8asVTdc7ZXbt2dWUPPvgggMm0JLyfzmZkCtpWda5ylm+10alGHbNxZU756WZhYDwTaR84FjorutQpnH1L8Y3ZDhf/V9lVK1yIiwnM2VmXojmmjtnpLKxMw82wzonNMXPPEhiPn+uX7tViu7WNzkGsxw899NDEv/q7jtPDDz8MAHjkkUe6MqrYgXEERn2u/H316tVdGZ+xUwO7cBnAeHyV2XBMXI7yiNQXCASOWMTHJhAIDIJFM6NIZ52ZoZTZRQsjlVNNxJ49e7pj6hkYQgIY6ywc1dU2qDLWUW9n/tS0QKUg2DWTyTkf1UxSHYrLqFhLQaOaGfZV+6KUmWPvck+7zaJapqYHzRmn9dG+EG7RQJ+LMwVchD01k+iQ1fu1UuLUTAa3yVffWzXHv/Od7wCYDAjvQjW4Ms1xrsfTUMf/unXrAACXX355V0YTrKSF4ljp++Q2L/M4QkwEAoEjFoMzm+mcw63t6zzWpd0nn3wSwKQiU3+v3bcFnUFdmhS2R2dNNwP23Yrvlsbd7KOzottjpDMNGZ8GBWM9eh77xyRzwOQeK0KXcZ1j1zlp9XfuPXNL0S5BoFPnarv0mHXq/ja20Sm2de8TGUDpGrfnqfaOal+++93vdsePPfbYRFun71MrKyU5nG6PMlYe874AsGHDBgDAxRdf3JWdc8453TGfsTJSx7TIbNy+qhaC2QQCgUEQH5tAIDAIBjejCKe6JR1X2sqNk9TJAJOmznR908dEX4eWOp1J153j02ld1LnozBYXya0VlZB9KYWv4D3VlHEmAZ3lLp6ymmVPPfVUd0zT48wzz+zKaIa4CHI6TmpScEz1PmyvU11rX6iV2rFjR1emJjPNtQsvvLAro3mg5i8j/qkeRceU7dWyWv5rbTefweOPP96VbdmypTt2Gpe+6BuWxNWtf0ccPx1HzanOvO50JAPj8VMTleZTpHIJBAJHLOJjEwgEBsHgqVxIzV38DVJmjTnz9NNPAygnlte63fFcoSsdalJN31s3w7locS7mjqPjbtOhS8FSqoerCGp68HeaDgBwwQUXAJhceaI5qtfqfbiapdoUXqOSeULPU4ruUqJwY+W+ffu6Mhdsnfopff66isQ+qs6EEv41a9bMao+aVmrqsV9Ow6Pt4uqfPn9qeL71rW91ZaqJWUj6k75wdTvXgp6nq5U81r89ms8XXXRRV8YxU3OrL4LZBAKBQbBoCmJ++X/4wx92v1E340IVtDQKbxdULcvZzt3PJXZzqVxKbXVOQ8eQXHIx1Ti4eLs8Vq2LS4BHp3EpvjGvV40Pn4eyGM7s6rhVZzAZojJFOtpbIT3ISJRJuHATymJ4rGyH93MRBIEx41GnKp+nS3miz+juu+8GMBl97+2K2/t2oaXhIbT/fD9UiX/XXXcBCGYTCASOYMTHJhAIDIJBzajXXnuti9XBf5083plMh8N0cnWq05CmQiu4s9sMSPOmFKnPxe5xfXUpOJxzXctoZriUIGqCUHOippM+D56rJhNNKzV/nnnmGQCTZolu6OO46O80PTW4N+E2Q6oZpcc0f9QhTbPQxXMpPUu3wZZtVDOT5phulWEEPjUdhzL7F4K+TmV3jTr2+yKYTSAQGASDMptXX30V99xzz0TZUCymL3Tmc5scHdNwZc6R6NSpThnsHMSl6HQs1w10LpSDm7nJEFy0QK1TneYcE8fSlAG5kA/KEBz7YL+0DexfKVIfy/UaslOXNK8UGsTF8mXbnENeNzlqeJOjCX0Vyy0VfHfNglsUCAQCPRAfm0AgMAgWLZ6NUzQuFpROq2OT0da0jKaFSy3j4n5ogHWl/9S7tPKDu9/UQUq44N4KUl2XqkPb5YKbq4lGaLudI9nl3ta62V4XlVHb41S8CppM2i91ghO1NEHA+B3QsXWRE52p63JiHwnv9eFEROoLBAJHLBYtxMSR9OV3EfaA8b4sXeZ1szyhMzKXiLVul2fahSrQa5yz182qWjfb0UoTU4v5DIzZgtur5Zy0yq5ULcyxUFbB+zi1uIuJrExKGRTPdWxP63bhS/TYOadd0kAuh6tEoJXXPTCDXswmpfTnKaVtKaVHU0r/klI6KaW0MaV0b0rpyZTSV1JKs/8qAoFAYITmxyaltAbAnwK4Iuf8PgDLAHwcwKcBfCbnvAnAIQA3H86GBgKBpY2+ZtTxAN6ZUvolgJMBHABwLYDfH/1+G4C/BfC5t7uBi4ndu3cDmMysyYhmTh/k1KlqorjIcC6Vjatbr9U6XSoXl4Kj5iB1EfSAsbJYzUgXdoNt07bovWn2aB9oPrqwHA5qoqgpS7NGf+fYal9dKh/3bLT/LGOObWDs8D948GBXFiZTPzSZTc55H4C/B/AMZj4yPwZwP4CXc840evcCWOOuTyndklLamlLa+vY0ORAILEX0MaNOB3ADgI0A3gPgFAC/bU61n/ec86055ytyzlcspKGBQGBpo48Z9RsAns45HwSAlNLXAfwqgOUppeNH7GYtgP2Hr5mLA8ZpefTRR7sy5t3RzYu1mDtqJrn8SroVwMnsaWZo3U5T41aR3MqTW91ysWf0GqcPcpkzta9uu4KWccw0J5UzrdzY6n1c5EeOn44j++0i8QHjMXXjrONNM8qtUOkmXu1rYAZ9VqOeAXB1SunkNPPkrwPwGIAtAD46OucmAN84PE0MBAJHA5rMJud8b0rpdgAPAHgDwIMAbgXwbQBfTin9z1HZFw5nQw8n3EZLYDxT6aY7am8uueSSrswxFrc5U2dsl7aEbMFl2yyBM7bTq+i1vLdjBW4To0K1QC5yIH8v5SDnNS7PtnOqO3WyqoLdRk1lSNT1uI2fziE/3R+C2h2NVEhnuTqpyXLVaRyYjV6rUTnnvwHwN1PFOwFc9ba3KBAIHJWI7QqBQGAQLNp2haUETX/CVBdMFwKM04k4Kl6KfOZivNB8UJOoFSWQ16jDmg5fdVLyPDUdXBZINUdoCmnSepZp3XQqqx6ntCmTYP9dtlFNt8JjDd7uxsyZUbqFwfVf28Uxd853dZrTQazOZd57PlkijyXE6AQCgUEQzKYCzr666W7nzp0AgPXr13dlnEFVaeo2FTpmo2WcGd2GxdJSqstH7SLwcWZ3Ce5caAy9Xp2zrFsdyc5JW+r39DVODaz18DxlHDoWjsVNXwuMx7TksHfPi7IEzS3PsVKmRfal57loi8c6gtkEAoFBEB+bQCAwCMKMqsDFiqHmgulLgHHmRadiVbjA0K5MHbY8ViquJgzpul5D7Y3T/yhc3BvV1PB3NRlojuiY8PeS89WlraGp5KL3uaiEOp5qZtLUUV0Pz3XRFBU6pmybi9qofXWqarZRTcJS8PdjGcFsAoHAIAhm0wM6I7sQA3v37gUwudR6xhlnAPCJ4rROF57AqVyVAeg1nHXVqeoUxH1zPet9eG/nxNac4WQATjWs12sbeKwMwYXTcNcq0+KYK5Oo9V9ZigutoayRS97K9mp71UqJ9Nz+tWMRwWwCgcAgiI9NIBAYBGFGVUA67sI3aGiI5557DsCkE5O0XdWwaqK4jZE1c0Npu+peWI+mjCFtV90PzRU1W5y50dL98HfV4zglssIFLafp4cJSqEnooiCq+cM6tV8s03azjWrquRAc+lw5jm4jqpbxfuogds7iMKMCgUBgAASz6QGdfTmr6gzIMt1DRZbjlL3AeCbW2c7FCXb7pZQhkTkpa+DyvJZxed4thzsmpW3UWZyztDIEl4JG9xO5+L6u/24pnvdxLAUYszzHqnTM+Ly0L+65ut9dvna3rK7PRZ+1cz4fiwhmEwgEBkF8bAKBwCAIM6oC55xlmdJtpzTlpjyl1qpNIc12WhC3gVKpvB6zfppJ2l41dXjsohKWwmC4qHw8Vme4U0GrGeHqcXGLncOaUJPIZcd0sYxVe8Pr9bm5/OE6Pi5NjjOtnCM9MBsxOoFAYBDExyYQCAyCMKMqqCW6d6tRLnqdS50C+Eh9Lt2IMyn0PjQFnLmmpgzbq9dS9u+Cl0+fO90ePc9pWJyZ4Va6XPwct2qj4+AClWtbGX/IxdwpbRYlXHRDbSP77WIT6ZhoDCSOfSmw/rGCYDaBQGAQBLOZIzgz6ixOZqNlZBXqNHazoVOxus2beq3O8i4CndOCsG6XhK60ydM5cQnHgLSv+rsL+cD7uM2bjl04Bqi/673pGHZq6RK7cI5f9sFtYtW62V6N1ayKbvcMj0UEswkEAoMgPjaBQGAQhBnVA87UcZJ6NQlIwZ1WA/B5pGlmOO2N0nbXNjU9nGlFs07NG029Qqi54vJssz8tDYuOGa9XE4VOU6cf0mvZHpd2BRhvEdHnwS0cOrbOhHHBz7WeWswddQDv3r0bAPDss892ZU7Dc6wjmE0gEBgEwWx6wIU3UCbB2V5nM7fc6zb+ufu4iH5OVaznOqepWzZXpS1VxwyRAQD79++fVbfLs63Mhv3WpWZlH7xnSQVNsI8ub7myFB0LLvNrOA322zl23f30WNkOGY0+K/aROd8BYNeuXQB8dMLAGMFsAoHAIIiPTSAQGARhRvWAUmLSaNWr0CGppgU3YmqkPjVrSLnV9KgpbdX8UWUwzRE1PRglTk0Vp+thexicffp3mleatoYmhUsno3AmhTP/XMoXBc3DM888sytbsWJFd8y+us2k6tjm+JTU2TSjnDpbnyvNp6eeempWX8N0qiOYTSAQGATBbOYIzsia15kOVI07S+ajS8lO0aqOT7IFp751alfAhzVgPdoezuJub5DO5soaTjvtNACTy7xcLn/xxRe7Mh7rfjFlLLynhthg3dp+shhlbty/5VTT2nbHGluhKnScWe6i+zFVDwA89thjACaZbTCafghmEwgEBkF8bAKBwCBILS3C23qzlA4CeBXAC61zlwjOxNHTF+Do6k/0ZTick3Ne2Tpp0I8NAKSUtuacrxj0pocJR1NfgKOrP9GXIw9hRgUCgUEQH5tAIDAIFuNjc+si3PNw4WjqC3B09Sf6coRhcJ9NIBA4NhFmVCAQGATxsQkEAoNg0I9NSum3UkqPp5R2pJQ+NeS9F4qU0rqU0paU0vaU0raU0idG5StSSneklJ4c/Xt6q64jBSmlZSmlB1NK3xr9f2NK6d5RX76SUvJ5aI4wpJSWp5RuTyn9aPR8fmWpPpeU0p+P3q9HU0r/klI6aak+l2kM9rFJKS0D8L8B/DaAiwH8Xkrp4qHu/zbgDQB/kXO+CMDVAP541P5PAbgz57wJwJ2j/y8VfALAdvn/pwF8ZtSXQwBuXpRWzR2fBfBvOef3ArgMM31acs8lpbQGwJ8CuCLn/D4AywB8HEv3uUxgSGZzFYAdOeedOefXAXwZwA0D3n9ByDkfyDk/MDr+CWZe6DWY6cNto9NuA/DvF6eFc0NKaS2AjwD4/Oj/CcC1AG4fnZ4Jn2wAAAJWSURBVLIk+pJSOhXArwP4AgDknF/POb+MJfpcMLM5+p0ppeMBnAzgAJbgc3EY8mOzBsAe+f/eUdmSQ0ppA4DNAO4FsCrnfACY+SABOGvxWjYn/COAvwTAbeBnAHg558wt4Evl+ZwL4CCAfx6ZhJ9PKZ2CJfhccs77APw9gGcw85H5MYD7sTSfyywM+bFx+/CX3Lp7SuldAP4VwJ/lnF9Z7PbMByml6wE8n3O+X4vNqUvh+RwP4AMAPpdz3oyZvXdHvMnkMPIr3QBgI4D3ADgFM26HaSyF5zILQ35s9gJYJ/9fC2B/4dwjEimlEzDzoflSzvnro+LnUkqrR7+vBvD8YrVvDrgGwO+mlHZhxpy9FjNMZ/mIvgNL5/nsBbA353zv6P+3Y+bjsxSfy28AeDrnfDDn/EsAXwfwq1iaz2UWhvzY3Adg08izfiJmHF/fHPD+C8LIp/EFANtzzv8gP30TwE2j45sAfGPots0VOee/yjmvzTlvwMxz+F7O+Q8AbAHw0dFpS6UvzwLYk1K6cFR0HYDHsASfC2bMp6tTSieP3jf2Zck9F4ehQ0z8DmZm0GUA/inn/HeD3XyBSCl9CMD/BfBDjP0cf40Zv81XAazHzMvysZzz7OxvRyhSSh8G8N9zztenlM7FDNNZAeBBAP8p5/yL2vVHAlJKl2PG0X0igJ0A/ggzE+mSey4ppf8B4D9iZvXzQQD/BTM+miX3XKYR2xUCgcAgCAVxIBAYBPGxCQQCgyA+NoFAYBDExyYQCAyC+NgEAoFBEB+bQCAwCOJjEwgEBsH/B5yvgQBeUGHrAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example image\n",
    "%matplotlib inline\n",
    "from skimage.io import imshow\n",
    "imshow(imgs_train[3,:,:,0])\n",
    "key_pts_train[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Circle may be useful for drawing points on face\n",
    "# See matplotlib documentation for more info\n",
    "from matplotlib.patches import Circle\n",
    "\n",
    "def visualize_points(img, points):\n",
    "    # Write here function which obtains image and normalized\n",
    "    # coordinates and visualizes points on image\n",
    "    cur_img = img[:,:,0]\n",
    "    cur_points = points[:] + .5\n",
    "    cur_points *= cur_img.shape[0]\n",
    "    fig, ax = plt.subplots(1)\n",
    "    ax.set_aspect('equal')\n",
    "    \n",
    "    ax.imshow(cur_img, cmap = \"gray\")\n",
    "    for i in range(0,len(cur_points),2):\n",
    "        c = Circle((int(cur_points[i]), int(cur_points[i+1])), 2, color = 'red')\n",
    "        #print((int(cur_points[i]), int(cur_points[i+1])))\n",
    "        ax.add_patch(c)\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "visualize_points(imgs_train[0], key_pts_train[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(96, 96, 1)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs_train[3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "comparisson_img = 4\n",
    "visualize_points(imgs_train[comparisson_img], key_pts_train[comparisson_img])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def flip_img(img, points):\n",
    "    \n",
    "    img_flipped = np.flip(img, axis = 1)\n",
    "    \n",
    "    #flipped_points = np.array([-(points[i] - int(img.shape[0]/2)) + int(img.shape[0]/2) if i%2 == 0 else points[i] for i in range(len(points))])\n",
    "    flipped_points = np.array([-points[i] if i%2 == 0 else points[i] for i in range(len(points))])\n",
    "    #flipped_points = points[:]\n",
    "    #flipped_points[::2] = -1*flipped_points[::2]\n",
    "    return(img_flipped, flipped_points)\n",
    "        \n",
    "\n",
    "f_img, f_points = flip_img(imgs_train[comparisson_img], key_pts_train[comparisson_img])\n",
    "visualize_points(f_img, f_points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "aug_imgs_train, aug_points_train = zip(*[flip_img(imgs_train[i], key_pts_train[i]) for i in range(len(imgs_train))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add to train imgs_train, imgs_val, points_train, points_val\n",
    "imgs_train = np.vstack((imgs_train, aug_imgs_train))\n",
    "key_pts_train = np.vstack((key_pts_train, aug_points_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "comparisson_img2 = 2\n",
    "visualize_points(imgs_train[comparisson_img2], key_pts_train[comparisson_img2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_points(aug_imgs_train[comparisson_img2], aug_points_train[comparisson_img2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import (\n",
    "    Conv2D, MaxPooling2D, Flatten,\n",
    "    Dense, Dropout\n",
    ")\n",
    "\n",
    "outputs = key_pts.shape[1] # 30\n",
    "input_shape = imgs.shape[1:] # (96,96,1)\n",
    "\n",
    "model = Sequential()\n",
    "# Define here your model\n",
    "model.add(Conv2D(32, kernel_size = (3,3), activation = 'relu', padding = 'same', input_shape = input_shape))\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(outputs, activation='softmax'))\n",
    "#model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(graph, num_out_classes, input_shape = IMG_SHAPE):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    input_shape     -- list    [1] -- scalar, height of an input image\n",
    "                               [2] -- scalar, width of an input image\n",
    "                               [3] -- scalar, number of channels of the input\n",
    "    num_out_classes -- scalar, number of classes\n",
    "        \n",
    "    Returns:\n",
    "    X -- placeholder for the data input, of shape [None, input_shape[1], input_shape[2], input_shape[3] and dtype \"float\"\n",
    "    Y -- placeholder for the input labels, of shape [None, n_y] and dtype \"float\"\n",
    "    \"\"\"\n",
    "    with graph.as_default():\n",
    "        X = tf.placeholder(tf.float32, shape = [None, input_shape[1], input_shape[2], input_shape[3]], name = 'X')\n",
    "        Y = tf.placeholder(tf.float32, shape = [None, num_out_classes], name = 'Y')\n",
    "\n",
    "        return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters(graph, conv_params = [[3,3,1,16], [3,3,16,32], [3,3,32,64], [3,3,64,128]], dense_params = [[35344, 512]], seed = 0):\n",
    "    \"\"\"\n",
    "    Initializes weight parameters to build a neural network with tensorflow. \n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing parameters\n",
    "    \"\"\"\n",
    "    with graph.as_default():\n",
    "        if seed:\n",
    "            tf.set_random_seed(seed)            \n",
    "\n",
    "        i = 0\n",
    "        parameters = {}\n",
    "\n",
    "        if conv_params:\n",
    "            for cp in conv_params:\n",
    "                parameters[\"Wc\" + str(i+1)] = \\\n",
    "                          tf.get_variable(\"Wc\" + str(i+1),  \n",
    "                                          cp, \n",
    "                                          initializer = tf.contrib.layers.xavier_initializer_conv2d()\n",
    "                                         )\n",
    "                i += 1\n",
    "                # initializer = tf.contrib.layers.variance_scaling_initializer(seed = seed)\n",
    "                # initializer = tf.contrib.layers.xavier_initializer_conv2d(seed = 0)\n",
    "\n",
    "        if dense_params:\n",
    "            for dp in dense_params:\n",
    "                feature_weights = dp\n",
    "                bias_terms = dp[1]\n",
    "                parameters[\"Wfc\" + str(i + 1)] = \\\n",
    "                    tf.Variable( tf.random_uniform( dp , minval=0.1, maxval=0.9, dtype=tf.float32 ))\n",
    "\n",
    "                parameters[\"b\" + str(i + 1)] = \\\n",
    "                    tf.Variable( tf.random_uniform( [dp[1]] , minval=0.1, maxval=0.9, dtype=tf.float32 ))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_net_v1(X, parameters, keep_prob = .8):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED -> DROPCONNECT -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"W2\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Y_pred -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['Wc1']\n",
    "    W2 = parameters['Wc2']\n",
    "    \n",
    "    Wfc3 = parameters['Wfc3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    # CONV2D: stride of 1, padding 'SAME'\n",
    "    Z1_stride = 1\n",
    "    Z1 = tf.nn.conv2d(X,W1, strides = [1,Z1_stride,Z1_stride,1], padding = 'SAME')\n",
    "    # RELU\n",
    "    A1 = tf.nn.relu(Z1)\n",
    "    \n",
    "    # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "    P1_w = 2\n",
    "    P1_s = 2\n",
    "    P1 = tf.nn.max_pool(A1, ksize = [1,P1_w,P1_w,1], strides = [1,P1_s,P1_s,1], padding = 'SAME')\n",
    "    \n",
    "    # CONV2D: filters W2, stride 1, padding 'SAME'\n",
    "    Z2_s = 1\n",
    "    Z2 = tf.nn.conv2d(P1,W2, strides = [1,Z2_s,Z2_s,1], padding = 'SAME')\n",
    "    \n",
    "    # RELU\n",
    "    A2 = tf.nn.relu(Z2)\n",
    "    \n",
    "    # MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2_w = 2\n",
    "    P2_s = 2\n",
    "    P2 = tf.nn.max_pool(A2, ksize = [1,P2_w,P2_w,1], strides = [1,P2_s,P2_s,1], padding = 'SAME')\n",
    "    \n",
    "    # FLATTEN \n",
    "    # input shape of 96. First max pool means 96/2, second means 48/2\n",
    "    # 24 *24 * 64\n",
    "    P2 = tf.contrib.layers.flatten(P2)\n",
    "    \n",
    "    # DROPCONNECT\n",
    "    dropConnect = tf.nn.dropout( Wfc3, keep_prob ) * keep_prob\n",
    "    \n",
    "    \n",
    "    # FULLY-CONNECTED\n",
    "    Z3_output = 128\n",
    "    Z3 = tf.nn.relu( tf.matmul( P2, dropConnect ) + b3 ) \n",
    "    \n",
    "    #Z3 = tf.contrib.layers.fully_connected(P2, Z3_output, activation_fn = tf.nn.relu)   \n",
    "    \n",
    "    # FULLY-CONNECTED output layer\n",
    "    \n",
    "    Z4_output = key_pts.shape[1]\n",
    "    Y_pred = tf.contrib.layers.fully_connected(Z3, Z4_output, activation_fn = None)\n",
    "\n",
    "\n",
    "    return Y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_net_v2(graph, X, parameters, keep_prob = .8):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> \n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> \n",
    "    FLATTEN -> FULLYCONNECTED -> DROPCONNECT -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"W2\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Y_pred -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    with graph.as_default():\n",
    "        # Retrieve the parameters from the dictionary \"parameters\" \n",
    "        W1 = parameters['Wc1']\n",
    "        W2 = parameters['Wc2']\n",
    "        W3 = parameters['Wc3']\n",
    "        W4 = parameters['Wc4']\n",
    "\n",
    "        Wfc5 = parameters['Wfc5']\n",
    "        b5 = parameters['b5']\n",
    "\n",
    "        # CONV2D: stride of 1\n",
    "        Z1_stride = 1\n",
    "        if X.dtype == 'float64':\n",
    "            X = tf.cast(X, 'float32')\n",
    "        Z1 = tf.nn.conv2d(X,W1, strides = [1,Z1_stride,Z1_stride,1], padding = \"VALID\")\n",
    "        # RELU\n",
    "        A1 = tf.nn.relu(Z1)\n",
    "\n",
    "        # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "        P1_w = 2\n",
    "        P1_s = 2\n",
    "        P1 = tf.nn.max_pool(A1, ksize = [1,P1_w,P1_w,1], strides = [1,P1_s,P1_s,1], padding = 'SAME')\n",
    "\n",
    "        # CONV2D: filters W2, stride 1\n",
    "        Z2_s = 1\n",
    "        Z2 = tf.nn.conv2d(P1,W2, strides = [1,Z2_s,Z2_s,1], padding = \"VALID\")\n",
    "\n",
    "        # RELU\n",
    "        A2 = tf.nn.relu(Z2)\n",
    "\n",
    "        # MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "        P2_w = 2\n",
    "        P2_s = 2\n",
    "        P2 = tf.nn.max_pool(A2, ksize = [1,P2_w,P2_w,1], strides = [1,P2_s,P2_s,1], padding = 'SAME')\n",
    "\n",
    "\n",
    "        # CONV2D: stride of 1\n",
    "        Z3_stride = 1\n",
    "        Z3 = tf.nn.conv2d(X,W1, strides = [1,Z3_stride,Z3_stride,1], padding = \"VALID\")\n",
    "        # RELU\n",
    "        A3 = tf.nn.relu(Z3)\n",
    "\n",
    "        # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "        P3_w = 2\n",
    "        P3_s = 2\n",
    "        P3 = tf.nn.max_pool(A3, ksize = [1,P3_w,P3_w,1], strides = [1,P3_s,P3_s,1], padding = 'SAME')\n",
    "\n",
    "\n",
    "        # CONV2D: stride of 1\n",
    "        Z4_stride = 1\n",
    "        Z4 = tf.nn.conv2d(X,W1, strides = [1,Z4_stride,Z4_stride,1], padding = \"VALID\")\n",
    "        # RELU\n",
    "        A4 = tf.nn.relu(Z4)\n",
    "\n",
    "        # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n",
    "        P4_w = 2\n",
    "        P4_s = 2\n",
    "        P4 = tf.nn.max_pool(A4, ksize = [1,P4_w,P4_w,1], strides = [1,P4_s,P4_s,1], padding = 'SAME')     \n",
    "\n",
    "\n",
    "        # FLATTEN \n",
    "        # input shape of 96. First max pool means 96/2, second means 48/2\n",
    "        # 24 *24 * 64\n",
    "        P4 = tf.contrib.layers.flatten(P4)\n",
    "\n",
    "        # DROPCONNECT\n",
    "        dropConnect = tf.nn.dropout( Wfc5, keep_prob ) * keep_prob\n",
    "\n",
    "\n",
    "        # FULLY-CONNECTED\n",
    "        Z5_output = 128\n",
    "        Z5 =  tf.matmul( P4, dropConnect )\n",
    "        Z5 = tf.nn.relu(Z5 + b5)\n",
    "\n",
    "        #Z3 = tf.contrib.layers.fully_connected(P2, Z3_output, activation_fn = tf.nn.relu)   \n",
    "\n",
    "        # FULLY-CONNECTED output layer\n",
    "\n",
    "        Z5_output = key_pts.shape[1]\n",
    "        Y_pred = tf.contrib.layers.fully_connected(Z5, Z5_output, activation_fn = None)\n",
    "        \n",
    "        \n",
    "\n",
    "        return Y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(graph, Y_pred, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\n",
    "    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
    "    Y -- \"true\" labels vector placeholder, same shape as Z3\n",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "    with graph.as_default():\n",
    "        return tf.losses.mean_squared_error(Y, Y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
    "    \"\"\"\n",
    "    Creates a list of random minibatches from (X, Y)\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, of shape (input size, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    mini_batch_size - size of the mini-batches, integer\n",
    "    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n",
    "    \n",
    "    Returns:\n",
    "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]                  # number of training examples\n",
    "    mini_batches = []\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # Step 1: Shuffle (X, Y)\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[:, permutation]\n",
    "    shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))\n",
    "\n",
    "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
    "    num_complete_minibatches = np.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning\n",
    "    for k in range(0, num_complete_minibatches):\n",
    "        mini_batch_X = shuffled_X[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch_Y = shuffled_Y[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    # Handling the end case (last mini-batch < mini_batch_size)\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
    "    \"\"\"\n",
    "    Creates a list of random minibatches from (X, Y)\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input data, of shape (input size, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)\n",
    "    mini_batch_size - size of the mini-batches, integer\n",
    "    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n",
    "    \n",
    "    Returns:\n",
    "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[0]                  # number of training examples\n",
    "    mini_batches = []\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # Step 1: Shuffle (X, Y)\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[permutation, :]\n",
    "    shuffled_Y = Y[permutation, :].reshape((m, Y.shape[1]))\n",
    "\n",
    "    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n",
    "    num_complete_minibatches = int(np.floor(m/mini_batch_size)) # number of mini batches of size mini_batch_size in your partitionning\n",
    "    for k in range(0, num_complete_minibatches):\n",
    "        mini_batch_X = shuffled_X[k * mini_batch_size : k * mini_batch_size + mini_batch_size, :]\n",
    "        mini_batch_Y = shuffled_Y[k * mini_batch_size : k * mini_batch_size + mini_batch_size, :]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    # Handling the end case (last mini-batch < mini_batch_size)\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m, :]\n",
    "        mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m, :]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost = 54118788.0\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "graph_v2 = tf.Graph()\n",
    "\n",
    "with graph_v2.as_default():\n",
    "    with tf.Session() as sess:\n",
    "        np.random.seed(1)\n",
    "        X, Y = create_placeholders(graph_v2, key_pts.shape[1], IMG_SHAPE)\n",
    "        parameters = initialize_parameters(graph_v2)\n",
    "        Y_pred = conv_net_v2(graph_v2, X, parameters)\n",
    "        cost = compute_cost(graph_v2, Y_pred, Y)\n",
    "        init = tf.global_variables_initializer()\n",
    "        sess.run(init)\n",
    "        a = sess.run(cost, {X: np.random.randn(4,96,96,1), Y: np.random.randn(4,4)})\n",
    "        print(\"cost = \" + str(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.2578125"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "35344/2048"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### TODO: https://www.tensorflow.org/guide/saved_model\n",
    "\n",
    "##### EVEN MORE TODO: http://vict0rsch.github.io/2018/05/17/restore-tf-model-dataset/\n",
    "\n",
    "### https://www.tensorflow.org/hub/creating\n",
    "\n",
    "#### EVEN MORRRRREE TODO: https://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Directory  checkpoints  Created \n"
     ]
    }
   ],
   "source": [
    "dirName = 'checkpoints'\n",
    "\n",
    "if not os.path.exists(dirName):\n",
    "    os.mkdir(dirName)\n",
    "    print(\"Directory \" , dirName ,  \" Created \")\n",
    "else:    \n",
    "    print(\"Directory \" , dirName ,  \" already exists\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_train_v2(X_train, Y_train, X_test, Y_test, learning_rate = 0.009,\n",
    "          num_epochs = 100, minibatch_size = 64, print_cost = True, seed = 3):\n",
    "    \"\"\"\n",
    "    Implements a three-layer ConvNet in Tensorflow:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_train -- test set, of shape (None, num_out_classes = 6)\n",
    "    X_test -- training set, of shape (None, 64, 64, 3)\n",
    "    Y_test -- test set, of shape (None, num_out_classes = 6)\n",
    "    learning_rate -- learning rate of the optimization\n",
    "    num_epochs -- number of epochs of the optimization loop\n",
    "    minibatch_size -- size of a minibatch\n",
    "    print_cost -- True to print the cost every 100 epochs\n",
    "    \n",
    "    Returns:\n",
    "    train_accuracy -- real number, accuracy on the train set (X_train)\n",
    "    test_accuracy -- real number, testing accuracy on the test set (X_test)\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "    \"\"\"\n",
    "    \n",
    "    #ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "    \n",
    "    graph_v2 = tf.Graph()\n",
    "    with graph_v2.as_default():\n",
    "        tf.set_random_seed(1)                             # to keep results consistent (tensorflow seed)\n",
    "        seed = seed                                          # to keep results consistent (numpy seed)\n",
    "        (m, n_H0, n_W0, n_C0) = X_train.shape             \n",
    "        num_out_classes = Y_train.shape[1]                            \n",
    "        costs = []                                        # To keep track of the cost\n",
    "\n",
    "        test_costs = []\n",
    "        epochs_of_test_costs = []\n",
    "\n",
    "\n",
    "        # Create Placeholders of the correct shape\n",
    "        X = tf.placeholder(tf.float32, shape = [None, n_H0, n_W0, n_C0], name = 'X')\n",
    "        Y = tf.placeholder(tf.float32, shape = [None, num_out_classes], name = 'Y')\n",
    "        #X, Y = create_placeholders(graph_v2, n_y, X_train.shape)\n",
    "\n",
    "\n",
    "        # Initialize parameters\n",
    "        parameters = initialize_parameters(graph_v2)\n",
    "\n",
    "\n",
    "        # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "        Y_pred = conv_net_v2(graph_v2, X, parameters)\n",
    "\n",
    "\n",
    "        # Cost function: Add cost function to tensorflow graph\n",
    "        cost = compute_cost(graph_v2, Y_pred, Y)\n",
    "\n",
    "\n",
    "        # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.\n",
    "        optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "\n",
    "\n",
    "        # Initialize all the variables globally\n",
    "        init = tf.global_variables_initializer()\n",
    "\n",
    "\n",
    "        # add ops to save and restore all the variables\n",
    "        saver = tf.train.Saver()\n",
    "\n",
    "        # Start the session to compute the tensorflow graph\n",
    "        with tf.Session() as sess:\n",
    "\n",
    "            # Run the initialization\n",
    "            sess.run(init)\n",
    "\n",
    "            # Do the training loop\n",
    "            for epoch in range(num_epochs):\n",
    "\n",
    "                minibatch_cost = 0.\n",
    "                num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "                seed = seed + 1\n",
    "                minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "                for minibatch in minibatches:\n",
    "\n",
    "                    # Select a minibatch\n",
    "                    (minibatch_X, minibatch_Y) = minibatch\n",
    "                    # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                    # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).\n",
    "\n",
    "                    _ , temp_cost = sess.run([optimizer,cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})\n",
    "\n",
    "\n",
    "                    minibatch_cost += temp_cost / num_minibatches\n",
    "\n",
    "\n",
    "                # Print the cost every epoch\n",
    "                if print_cost == True and epoch % 5 == 0:\n",
    "                    print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n",
    "                if print_cost == True and epoch % 1 == 0:\n",
    "                    costs.append(minibatch_cost)\n",
    "\n",
    "                if print_cost == True and epoch % 10 == 0 and epoch > 0:\n",
    "                    test_cost = sess.run([cost], feed_dict = {X: X_test, Y: Y_test})\n",
    "                    test_costs.append(test_cost)\n",
    "                    epochs_of_test_costs.append(epoch)\n",
    "                    print (\"\\nTest cost after epoch %i: %f\\n\" % (epoch, test_cost[0]))\n",
    "                    '''\n",
    "                    # Calculate the correct predictions\n",
    "                    predict_op = tf.argmax(Y_pred, 1)\n",
    "                    correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n",
    "\n",
    "                    # Calculate accuracy on the test set\n",
    "                    accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "                    mse = tf.losses.mean_squared_error(Y_pred, Y)\n",
    "                    test_accuracy = mse.eval({X: X_test, Y: Y_test})\n",
    "                    print (\"Test Accuracy after epoch %i: %f\" % (epoch, test_accuracy))\n",
    "                '''\n",
    "\n",
    "            # plot the cost without the first wildly off epoch\n",
    "            plt.plot(np.squeeze(costs[10:]), 'b-')\n",
    "            plt.plot(epochs_of_test_costs, test_costs, 'g-')\n",
    "            plt.ylabel('cost')\n",
    "            plt.xlabel('iterations (per tens)')\n",
    "            plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "            plt.show()\n",
    "\n",
    "\n",
    "            train_cost = cost.eval({X: X_train, Y: Y_train})\n",
    "            test_cost = cost.eval({X: X_test, Y: Y_test})\n",
    "            print(\"Train Cost:\", train_cost)\n",
    "            print(\"Test Cost:\", test_cost)\n",
    "            #print(Y_pred.eval({X: X_test, Y: Y_test}))\n",
    "\n",
    "\n",
    "            #save_path = saver.save(sess, os.path.join(os.getcwd(),'model_v2.ckpt'))\n",
    "            #saver.save(sess, os.path.join(os.getcwd(),'model_v2'),global_step=1000)\n",
    "            #print(\"Model saved in %s\" % save_path)\n",
    "            \n",
    "            path = os.path.join(os.getcwd(), 'model_v2_2')\n",
    "            inputs_dict = {\n",
    "                'X': X,\n",
    "                'Y': Y\n",
    "            }\n",
    "            \n",
    "            outputs_dict = {\n",
    "                'Y_pred': Y_pred\n",
    "            } \n",
    "            tf.saved_model.simple_save(\n",
    "                sess, path, inputs_dict, outputs_dict\n",
    "            )\n",
    "            \n",
    "            saver.save(sess, os.path.join(os.getcwd(), 'checkpoints', 'model_v2_chkpt'), global_step = 100)\n",
    "\n",
    "            return train_cost, test_cost, parameters, path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 9706162.625000\n",
      "Cost after epoch 5: 43521.443848\n",
      "Cost after epoch 10: 24.172334\n",
      "\n",
      "Test cost after epoch 10: 6.127032\n",
      "\n",
      "Cost after epoch 15: 17.530119\n",
      "Cost after epoch 20: 16.785570\n",
      "\n",
      "Test cost after epoch 20: 6.283937\n",
      "\n",
      "Cost after epoch 25: 16.401092\n",
      "Cost after epoch 30: 16.249947\n",
      "\n",
      "Test cost after epoch 30: 6.300441\n",
      "\n",
      "Cost after epoch 35: 16.150889\n",
      "Cost after epoch 40: 16.019902\n",
      "\n",
      "Test cost after epoch 40: 6.203420\n",
      "\n",
      "Cost after epoch 45: 15.930531\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Cost: 7.855172\n",
      "Test Cost: 6.095293\n",
      "INFO:tensorflow:Assets added to graph.\n",
      "INFO:tensorflow:No assets to write.\n",
      "INFO:tensorflow:SavedModel written to: G:\\Projects\\celebrity-recognition\\model_v2_2\\saved_model.pb\n"
     ]
    }
   ],
   "source": [
    "# imgs_train, imgs_test, key_pts_train, key_pts_test\n",
    "\n",
    "train_acc, test_acc, parameters, model_v2_path = model_train_v2(imgs_train, key_pts_train, imgs_test, key_pts_test, num_epochs = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Restoring...\n",
      "INFO:tensorflow:Restoring parameters from G:\\Projects\\celebrity-recognition\\model_v2_2\\variables\\variables\n",
      "[[ 4.79433   -2.3088012  4.023412  -2.2254388]\n",
      " [ 3.5900059 -1.4276024  2.8311691 -1.3736593]\n",
      " [ 3.5900059 -1.4276024  2.8311691 -1.3736593]\n",
      " [ 3.8479395 -1.6373782  3.1245325 -1.5832689]\n",
      " [ 3.7219713 -1.5251255  2.955474  -1.4511937]\n",
      " [ 3.9018278 -1.6424117  3.1327162 -1.588082 ]\n",
      " [ 3.5900059 -1.4276024  2.8311691 -1.3736593]\n",
      " [ 3.6952257 -1.5291579  2.9580295 -1.4546863]\n",
      " [ 4.1120224 -1.793756   3.3264904 -1.776594 ]\n",
      " [ 3.5900059 -1.4276024  2.8311691 -1.3736593]\n",
      " [ 3.665842  -1.4793017  2.9137678 -1.4336444]\n",
      " [ 3.5900059 -1.4276024  2.8311691 -1.3736593]\n",
      " [ 7.0776644 -3.881476   6.140025  -3.8627038]\n",
      " [ 3.6058433 -1.4354644  2.8458285 -1.3800155]\n",
      " [ 3.615553  -1.4419662  2.8551004 -1.3958668]\n",
      " [ 3.6098747 -1.4466431  2.8573558 -1.39279  ]\n",
      " [ 3.6056914 -1.4377925  2.8443675 -1.3808817]\n",
      " [ 3.928791  -1.6545535  3.0989494 -1.5804175]\n",
      " [ 3.7332358 -1.513602   2.974341  -1.478457 ]\n",
      " [ 3.8699608 -1.6724707  3.1091518 -1.5717111]]\n"
     ]
    }
   ],
   "source": [
    "graph2 = tf.Graph()\n",
    "with graph2.as_default():\n",
    "    with tf.Session(graph=graph2) as sess:\n",
    "        # Restore saved values\n",
    "        print('\\nRestoring...')\n",
    "        tf.saved_model.loader.load(\n",
    "            sess,\n",
    "            [tag_constants.SERVING],\n",
    "            model_v2_path\n",
    "        )\n",
    "\n",
    "        # Get restored placeholders\n",
    "        Y = graph2.get_tensor_by_name('Y:0')\n",
    "        X = graph2.get_tensor_by_name('X:0')\n",
    "        \n",
    "        # Get restored model output\n",
    "        restored_logits = graph2.get_tensor_by_name('fully_connected/BiasAdd:0')\n",
    "        \n",
    "        \n",
    "        print(sess.run(restored_logits, {X: imgs_val, Y: key_pts_val}))\n",
    "        # Get dataset initializing operation\n",
    "        #dataset_init_op = graph2.get_operation_by_name('dataset_init')\n",
    "           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from G:\\Projects\\celebrity-recognition\\checkpoints\\model_v2_chkpt-100\n",
      "[[ 4.7144265 -2.2701817  3.9632232 -2.170995 ]\n",
      " [ 3.5304315 -1.4064914  2.791821  -1.337472 ]\n",
      " [ 3.5304315 -1.4064914  2.791821  -1.337472 ]\n",
      " [ 3.782043  -1.610051   3.07794   -1.5408825]\n",
      " [ 3.6591012 -1.5013173  2.913219  -1.4122592]\n",
      " [ 3.83053   -1.6120335  3.0818982 -1.5422313]\n",
      " [ 3.5304315 -1.4064914  2.791821  -1.337472 ]\n",
      " [ 3.6319196 -1.503729   2.9137962 -1.4146703]\n",
      " [ 4.046484  -1.766954   3.2811646 -1.7338251]\n",
      " [ 3.5304315 -1.4064914  2.791821  -1.337472 ]\n",
      " [ 3.6047752 -1.4568431  2.8726718 -1.395826 ]\n",
      " [ 3.5304315 -1.4064914  2.791821  -1.337472 ]\n",
      " [ 6.9650583 -3.8174994  6.049202  -3.7790706]\n",
      " [ 3.54593   -1.4141475  2.806155  -1.3436439]\n",
      " [ 3.5556343 -1.4205941  2.8154044 -1.3592569]\n",
      " [ 3.5487826 -1.423978   2.815948  -1.3550196]\n",
      " [ 3.545138  -1.4160002  2.8041885 -1.3441938]\n",
      " [ 3.864991  -1.6292526  3.0558953 -1.540286 ]\n",
      " [ 3.6688707 -1.4890919  2.9302714 -1.4386544]\n",
      " [ 3.8078425 -1.6478087  3.0666354 -1.5325708]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    " \n",
    "sess=tf.Session()    \n",
    "#First let's load meta graph and restore weights\n",
    "saver = tf.train.import_meta_graph(os.path.join(os.getcwd(), 'checkpoints','model_v2_chkpt-100.meta'))\n",
    "#saver.restore(sess,tf.train.latest_checkpoint('./'))\n",
    "saver.restore(sess,tf.train.latest_checkpoint(os.path.join(os.getcwd(), 'checkpoints')))\n",
    "\n",
    "graph = tf.get_default_graph()\n",
    "Y = graph.get_tensor_by_name('Y:0')\n",
    "X= graph.get_tensor_by_name('X:0')\n",
    "feed_dict ={X: imgs_val, Y: key_pts_val}\n",
    " \n",
    "#Now, access the op that you want to run. \n",
    "op_to_restore = graph.get_tensor_by_name('fully_connected/BiasAdd:0')\n",
    " \n",
    "print(sess.run(op_to_restore,feed_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Y:0' shape=(?, 30) dtype=float32>"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'fully_connected/BiasAdd:0' shape=(?, 30) dtype=float32>"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "restored_logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Restoring...\n",
      "INFO:tensorflow:Restoring parameters from G:\\Projects\\celebrity-recognition\\model_v2_2\\variables\\variables\n",
      "['losses', 'model_variables', 'train_op', 'trainable_variables', 'variables']\n"
     ]
    }
   ],
   "source": [
    "graph2 = tf.Graph()\n",
    "with graph2.as_default():\n",
    "    with tf.Session(graph=graph2) as sess:\n",
    "        # Restore saved values\n",
    "        print('\\nRestoring...')\n",
    "        tf.saved_model.loader.load(\n",
    "            sess,\n",
    "            [tag_constants.SERVING],\n",
    "            model_v2_path\n",
    "        )\n",
    "        print(graph2.get_all_collection_keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Restoring...\n",
      "INFO:tensorflow:Restoring parameters from G:\\Projects\\celebrity-recognition\\model_v2_2\\variables\\variables\n",
      "<tf.Variable 'fully_connected/weights:0' shape=(512, 4) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/biases:0' shape=(4,) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "graph2 = tf.Graph()\n",
    "with graph2.as_default():\n",
    "    with tf.Session(graph=graph2) as sess:\n",
    "        # Restore saved values\n",
    "        print('\\nRestoring...')\n",
    "        tf.saved_model.loader.load(\n",
    "            sess,\n",
    "            [tag_constants.SERVING],\n",
    "            model_v2_path\n",
    "        )\n",
    "        i = 0\n",
    "        for v in graph2.get_collection(\"model_variables\"):\n",
    "            print(v)\n",
    "            i +=1\n",
    "            #if i > 10:\n",
    "            #   break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Restoring...\n",
      "INFO:tensorflow:Restoring parameters from G:\\Projects\\celebrity-recognition\\model_v2_2\\variables\\variables\n",
      "[<tf.Operation 'X' type=Placeholder>, <tf.Operation 'Y' type=Placeholder>, <tf.Operation 'Wc1/Initializer/random_uniform/shape' type=Const>, <tf.Operation 'Wc1/Initializer/random_uniform/min' type=Const>, <tf.Operation 'Wc1/Initializer/random_uniform/max' type=Const>, <tf.Operation 'Wc1/Initializer/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'Wc1/Initializer/random_uniform/sub' type=Sub>, <tf.Operation 'Wc1/Initializer/random_uniform/mul' type=Mul>, <tf.Operation 'Wc1/Initializer/random_uniform' type=Add>, <tf.Operation 'Wc1' type=VariableV2>, <tf.Operation 'Wc1/Assign' type=Assign>, <tf.Operation 'Wc1/read' type=Identity>, <tf.Operation 'Wc2/Initializer/random_uniform/shape' type=Const>, <tf.Operation 'Wc2/Initializer/random_uniform/min' type=Const>, <tf.Operation 'Wc2/Initializer/random_uniform/max' type=Const>, <tf.Operation 'Wc2/Initializer/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'Wc2/Initializer/random_uniform/sub' type=Sub>, <tf.Operation 'Wc2/Initializer/random_uniform/mul' type=Mul>, <tf.Operation 'Wc2/Initializer/random_uniform' type=Add>, <tf.Operation 'Wc2' type=VariableV2>, <tf.Operation 'Wc2/Assign' type=Assign>, <tf.Operation 'Wc2/read' type=Identity>, <tf.Operation 'Wc3/Initializer/random_uniform/shape' type=Const>, <tf.Operation 'Wc3/Initializer/random_uniform/min' type=Const>, <tf.Operation 'Wc3/Initializer/random_uniform/max' type=Const>, <tf.Operation 'Wc3/Initializer/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'Wc3/Initializer/random_uniform/sub' type=Sub>, <tf.Operation 'Wc3/Initializer/random_uniform/mul' type=Mul>, <tf.Operation 'Wc3/Initializer/random_uniform' type=Add>, <tf.Operation 'Wc3' type=VariableV2>, <tf.Operation 'Wc3/Assign' type=Assign>, <tf.Operation 'Wc3/read' type=Identity>, <tf.Operation 'Wc4/Initializer/random_uniform/shape' type=Const>, <tf.Operation 'Wc4/Initializer/random_uniform/min' type=Const>, <tf.Operation 'Wc4/Initializer/random_uniform/max' type=Const>, <tf.Operation 'Wc4/Initializer/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'Wc4/Initializer/random_uniform/sub' type=Sub>, <tf.Operation 'Wc4/Initializer/random_uniform/mul' type=Mul>, <tf.Operation 'Wc4/Initializer/random_uniform' type=Add>, <tf.Operation 'Wc4' type=VariableV2>, <tf.Operation 'Wc4/Assign' type=Assign>, <tf.Operation 'Wc4/read' type=Identity>, <tf.Operation 'random_uniform/shape' type=Const>, <tf.Operation 'random_uniform/min' type=Const>, <tf.Operation 'random_uniform/max' type=Const>, <tf.Operation 'random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'random_uniform/sub' type=Sub>, <tf.Operation 'random_uniform/mul' type=Mul>, <tf.Operation 'random_uniform' type=Add>, <tf.Operation 'Variable' type=VariableV2>, <tf.Operation 'Variable/Assign' type=Assign>, <tf.Operation 'Variable/read' type=Identity>, <tf.Operation 'random_uniform_1/shape' type=Const>, <tf.Operation 'random_uniform_1/min' type=Const>, <tf.Operation 'random_uniform_1/max' type=Const>, <tf.Operation 'random_uniform_1/RandomUniform' type=RandomUniform>, <tf.Operation 'random_uniform_1/sub' type=Sub>, <tf.Operation 'random_uniform_1/mul' type=Mul>, <tf.Operation 'random_uniform_1' type=Add>, <tf.Operation 'Variable_1' type=VariableV2>, <tf.Operation 'Variable_1/Assign' type=Assign>, <tf.Operation 'Variable_1/read' type=Identity>, <tf.Operation 'Conv2D' type=Conv2D>, <tf.Operation 'Relu' type=Relu>, <tf.Operation 'MaxPool' type=MaxPool>, <tf.Operation 'Conv2D_1' type=Conv2D>, <tf.Operation 'Relu_1' type=Relu>, <tf.Operation 'MaxPool_1' type=MaxPool>, <tf.Operation 'Conv2D_2' type=Conv2D>, <tf.Operation 'Relu_2' type=Relu>, <tf.Operation 'MaxPool_2' type=MaxPool>, <tf.Operation 'Conv2D_3' type=Conv2D>, <tf.Operation 'Relu_3' type=Relu>, <tf.Operation 'MaxPool_3' type=MaxPool>, <tf.Operation 'Flatten/flatten/Shape' type=Shape>, <tf.Operation 'Flatten/flatten/strided_slice/stack' type=Const>, <tf.Operation 'Flatten/flatten/strided_slice/stack_1' type=Const>, <tf.Operation 'Flatten/flatten/strided_slice/stack_2' type=Const>, <tf.Operation 'Flatten/flatten/strided_slice' type=StridedSlice>, <tf.Operation 'Flatten/flatten/Reshape/shape/1' type=Const>, <tf.Operation 'Flatten/flatten/Reshape/shape' type=Pack>, <tf.Operation 'Flatten/flatten/Reshape' type=Reshape>, <tf.Operation 'dropout/keep_prob' type=Const>, <tf.Operation 'dropout/Shape' type=Const>, <tf.Operation 'dropout/random_uniform/min' type=Const>, <tf.Operation 'dropout/random_uniform/max' type=Const>, <tf.Operation 'dropout/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'dropout/random_uniform/sub' type=Sub>, <tf.Operation 'dropout/random_uniform/mul' type=Mul>, <tf.Operation 'dropout/random_uniform' type=Add>, <tf.Operation 'dropout/add' type=Add>, <tf.Operation 'dropout/Floor' type=Floor>, <tf.Operation 'dropout/div' type=RealDiv>, <tf.Operation 'dropout/mul' type=Mul>, <tf.Operation 'mul/y' type=Const>, <tf.Operation 'mul' type=Mul>, <tf.Operation 'MatMul' type=MatMul>, <tf.Operation 'add' type=Add>, <tf.Operation 'Relu_4' type=Relu>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/shape' type=Const>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/min' type=Const>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/max' type=Const>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/RandomUniform' type=RandomUniform>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/sub' type=Sub>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform/mul' type=Mul>, <tf.Operation 'fully_connected/weights/Initializer/random_uniform' type=Add>, <tf.Operation 'fully_connected/weights' type=VariableV2>, <tf.Operation 'fully_connected/weights/Assign' type=Assign>, <tf.Operation 'fully_connected/weights/read' type=Identity>, <tf.Operation 'fully_connected/biases/Initializer/zeros' type=Const>, <tf.Operation 'fully_connected/biases' type=VariableV2>, <tf.Operation 'fully_connected/biases/Assign' type=Assign>, <tf.Operation 'fully_connected/biases/read' type=Identity>, <tf.Operation 'fully_connected/MatMul' type=MatMul>, <tf.Operation 'fully_connected/BiasAdd' type=BiasAdd>, <tf.Operation 'mean_squared_error/SquaredDifference' type=SquaredDifference>, <tf.Operation 'mean_squared_error/assert_broadcastable/weights' type=Const>, <tf.Operation 'mean_squared_error/assert_broadcastable/weights/shape' type=Const>, <tf.Operation 'mean_squared_error/assert_broadcastable/weights/rank' type=Const>, <tf.Operation 'mean_squared_error/assert_broadcastable/values/shape' type=Shape>, <tf.Operation 'mean_squared_error/assert_broadcastable/values/rank' type=Const>, <tf.Operation 'mean_squared_error/assert_broadcastable/static_scalar_check_success' type=NoOp>, <tf.Operation 'mean_squared_error/ToFloat/x' type=Const>, <tf.Operation 'mean_squared_error/Mul' type=Mul>, <tf.Operation 'mean_squared_error/Const' type=Const>, <tf.Operation 'mean_squared_error/Sum' type=Sum>, <tf.Operation 'mean_squared_error/num_present/Equal/y' type=Const>, <tf.Operation 'mean_squared_error/num_present/Equal' type=Equal>, <tf.Operation 'mean_squared_error/num_present/zeros_like' type=Const>, <tf.Operation 'mean_squared_error/num_present/ones_like/Shape' type=Const>, <tf.Operation 'mean_squared_error/num_present/ones_like/Const' type=Const>, <tf.Operation 'mean_squared_error/num_present/ones_like' type=Fill>, <tf.Operation 'mean_squared_error/num_present/Select' type=Select>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/assert_broadcastable/weights/shape' type=Const>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/assert_broadcastable/weights/rank' type=Const>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/assert_broadcastable/values/shape' type=Shape>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/assert_broadcastable/values/rank' type=Const>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/assert_broadcastable/static_scalar_check_success' type=NoOp>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/ones_like/Shape' type=Shape>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/ones_like/Const' type=Const>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights/ones_like' type=Fill>, <tf.Operation 'mean_squared_error/num_present/broadcast_weights' type=Mul>, <tf.Operation 'mean_squared_error/num_present/Const' type=Const>, <tf.Operation 'mean_squared_error/num_present' type=Sum>, <tf.Operation 'mean_squared_error/Const_1' type=Const>, <tf.Operation 'mean_squared_error/Sum_1' type=Sum>, <tf.Operation 'mean_squared_error/Greater/y' type=Const>, <tf.Operation 'mean_squared_error/Greater' type=Greater>, <tf.Operation 'mean_squared_error/Equal/y' type=Const>, <tf.Operation 'mean_squared_error/Equal' type=Equal>, <tf.Operation 'mean_squared_error/ones_like/Shape' type=Const>, <tf.Operation 'mean_squared_error/ones_like/Const' type=Const>, <tf.Operation 'mean_squared_error/ones_like' type=Fill>, <tf.Operation 'mean_squared_error/Select' type=Select>, <tf.Operation 'mean_squared_error/div' type=RealDiv>, <tf.Operation 'mean_squared_error/zeros_like' type=Const>, <tf.Operation 'mean_squared_error/value' type=Select>, <tf.Operation 'gradients/Shape' type=Const>, <tf.Operation 'gradients/grad_ys_0' type=Const>, <tf.Operation 'gradients/Fill' type=Fill>, <tf.Operation 'gradients/mean_squared_error/value_grad/zeros_like' type=Const>, <tf.Operation 'gradients/mean_squared_error/value_grad/Select' type=Select>, <tf.Operation 'gradients/mean_squared_error/value_grad/Select_1' type=Select>, <tf.Operation 'gradients/mean_squared_error/value_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/mean_squared_error/value_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/mean_squared_error/value_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/mean_squared_error/div_grad/Shape' type=Const>, <tf.Operation 'gradients/mean_squared_error/div_grad/Shape_1' type=Const>, <tf.Operation 'gradients/mean_squared_error/div_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/mean_squared_error/div_grad/RealDiv' type=RealDiv>, <tf.Operation 'gradients/mean_squared_error/div_grad/Sum' type=Sum>, <tf.Operation 'gradients/mean_squared_error/div_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/div_grad/Neg' type=Neg>, <tf.Operation 'gradients/mean_squared_error/div_grad/RealDiv_1' type=RealDiv>, <tf.Operation 'gradients/mean_squared_error/div_grad/RealDiv_2' type=RealDiv>, <tf.Operation 'gradients/mean_squared_error/div_grad/mul' type=Mul>, <tf.Operation 'gradients/mean_squared_error/div_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/mean_squared_error/div_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/div_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/mean_squared_error/div_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/mean_squared_error/div_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/mean_squared_error/Sum_1_grad/Reshape/shape' type=Const>, <tf.Operation 'gradients/mean_squared_error/Sum_1_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/Sum_1_grad/Const' type=Const>, <tf.Operation 'gradients/mean_squared_error/Sum_1_grad/Tile' type=Tile>, <tf.Operation 'gradients/mean_squared_error/Sum_grad/Reshape/shape' type=Const>, <tf.Operation 'gradients/mean_squared_error/Sum_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/Sum_grad/Shape' type=Shape>, <tf.Operation 'gradients/mean_squared_error/Sum_grad/Tile' type=Tile>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Shape' type=Shape>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Shape_1' type=Const>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Mul' type=Mul>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Sum' type=Sum>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Mul_1' type=Mul>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/mean_squared_error/Mul_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Shape' type=Shape>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Shape_1' type=Shape>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/scalar' type=Const>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/mul' type=Mul>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/sub' type=Sub>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/mul_1' type=Mul>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Sum' type=Sum>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/Neg' type=Neg>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/mean_squared_error/SquaredDifference_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/fully_connected/BiasAdd_grad/BiasAddGrad' type=BiasAddGrad>, <tf.Operation 'gradients/fully_connected/BiasAdd_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/fully_connected/BiasAdd_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/fully_connected/BiasAdd_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/fully_connected/MatMul_grad/MatMul' type=MatMul>, <tf.Operation 'gradients/fully_connected/MatMul_grad/MatMul_1' type=MatMul>, <tf.Operation 'gradients/fully_connected/MatMul_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/fully_connected/MatMul_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/fully_connected/MatMul_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/Relu_4_grad/ReluGrad' type=ReluGrad>, <tf.Operation 'gradients/add_grad/Shape' type=Shape>, <tf.Operation 'gradients/add_grad/Shape_1' type=Const>, <tf.Operation 'gradients/add_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/add_grad/Sum' type=Sum>, <tf.Operation 'gradients/add_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/add_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/add_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/add_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/add_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/add_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/MatMul_grad/MatMul' type=MatMul>, <tf.Operation 'gradients/MatMul_grad/MatMul_1' type=MatMul>, <tf.Operation 'gradients/MatMul_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/MatMul_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/MatMul_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/Flatten/flatten/Reshape_grad/Shape' type=Shape>, <tf.Operation 'gradients/Flatten/flatten/Reshape_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mul_grad/Shape' type=Const>, <tf.Operation 'gradients/mul_grad/Shape_1' type=Const>, <tf.Operation 'gradients/mul_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/mul_grad/Mul' type=Mul>, <tf.Operation 'gradients/mul_grad/Sum' type=Sum>, <tf.Operation 'gradients/mul_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/mul_grad/Mul_1' type=Mul>, <tf.Operation 'gradients/mul_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/mul_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/mul_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/mul_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/mul_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/MaxPool_3_grad/MaxPoolGrad' type=MaxPoolGrad>, <tf.Operation 'gradients/dropout/mul_grad/Mul' type=Mul>, <tf.Operation 'gradients/dropout/mul_grad/Mul_1' type=Mul>, <tf.Operation 'gradients/dropout/mul_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/dropout/mul_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/dropout/mul_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/Relu_3_grad/ReluGrad' type=ReluGrad>, <tf.Operation 'gradients/dropout/div_grad/Shape' type=Const>, <tf.Operation 'gradients/dropout/div_grad/Shape_1' type=Const>, <tf.Operation 'gradients/dropout/div_grad/BroadcastGradientArgs' type=BroadcastGradientArgs>, <tf.Operation 'gradients/dropout/div_grad/RealDiv' type=RealDiv>, <tf.Operation 'gradients/dropout/div_grad/Sum' type=Sum>, <tf.Operation 'gradients/dropout/div_grad/Reshape' type=Reshape>, <tf.Operation 'gradients/dropout/div_grad/Neg' type=Neg>, <tf.Operation 'gradients/dropout/div_grad/RealDiv_1' type=RealDiv>, <tf.Operation 'gradients/dropout/div_grad/RealDiv_2' type=RealDiv>, <tf.Operation 'gradients/dropout/div_grad/mul' type=Mul>, <tf.Operation 'gradients/dropout/div_grad/Sum_1' type=Sum>, <tf.Operation 'gradients/dropout/div_grad/Reshape_1' type=Reshape>, <tf.Operation 'gradients/dropout/div_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/dropout/div_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/dropout/div_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'gradients/Conv2D_3_grad/ShapeN' type=ShapeN>, <tf.Operation 'gradients/Conv2D_3_grad/Conv2DBackpropInput' type=Conv2DBackpropInput>, <tf.Operation 'gradients/Conv2D_3_grad/Conv2DBackpropFilter' type=Conv2DBackpropFilter>, <tf.Operation 'gradients/Conv2D_3_grad/tuple/group_deps' type=NoOp>, <tf.Operation 'gradients/Conv2D_3_grad/tuple/control_dependency' type=Identity>, <tf.Operation 'gradients/Conv2D_3_grad/tuple/control_dependency_1' type=Identity>, <tf.Operation 'beta1_power/initial_value' type=Const>, <tf.Operation 'beta1_power' type=VariableV2>, <tf.Operation 'beta1_power/Assign' type=Assign>, <tf.Operation 'beta1_power/read' type=Identity>, <tf.Operation 'beta2_power/initial_value' type=Const>, <tf.Operation 'beta2_power' type=VariableV2>, <tf.Operation 'beta2_power/Assign' type=Assign>, <tf.Operation 'beta2_power/read' type=Identity>, <tf.Operation 'Wc1/Adam/Initializer/zeros' type=Const>, <tf.Operation 'Wc1/Adam' type=VariableV2>, <tf.Operation 'Wc1/Adam/Assign' type=Assign>, <tf.Operation 'Wc1/Adam/read' type=Identity>, <tf.Operation 'Wc1/Adam_1/Initializer/zeros' type=Const>, <tf.Operation 'Wc1/Adam_1' type=VariableV2>, <tf.Operation 'Wc1/Adam_1/Assign' type=Assign>, <tf.Operation 'Wc1/Adam_1/read' type=Identity>, <tf.Operation 'Variable/Adam/Initializer/zeros/shape_as_tensor' type=Const>, <tf.Operation 'Variable/Adam/Initializer/zeros/Const' type=Const>, <tf.Operation 'Variable/Adam/Initializer/zeros' type=Fill>, <tf.Operation 'Variable/Adam' type=VariableV2>, <tf.Operation 'Variable/Adam/Assign' type=Assign>, <tf.Operation 'Variable/Adam/read' type=Identity>, <tf.Operation 'Variable/Adam_1/Initializer/zeros/shape_as_tensor' type=Const>, <tf.Operation 'Variable/Adam_1/Initializer/zeros/Const' type=Const>, <tf.Operation 'Variable/Adam_1/Initializer/zeros' type=Fill>, <tf.Operation 'Variable/Adam_1' type=VariableV2>, <tf.Operation 'Variable/Adam_1/Assign' type=Assign>, <tf.Operation 'Variable/Adam_1/read' type=Identity>, <tf.Operation 'Variable_1/Adam/Initializer/zeros' type=Const>, <tf.Operation 'Variable_1/Adam' type=VariableV2>, <tf.Operation 'Variable_1/Adam/Assign' type=Assign>, <tf.Operation 'Variable_1/Adam/read' type=Identity>, <tf.Operation 'Variable_1/Adam_1/Initializer/zeros' type=Const>, <tf.Operation 'Variable_1/Adam_1' type=VariableV2>, <tf.Operation 'Variable_1/Adam_1/Assign' type=Assign>, <tf.Operation 'Variable_1/Adam_1/read' type=Identity>, <tf.Operation 'fully_connected/weights/Adam/Initializer/zeros/shape_as_tensor' type=Const>, <tf.Operation 'fully_connected/weights/Adam/Initializer/zeros/Const' type=Const>, <tf.Operation 'fully_connected/weights/Adam/Initializer/zeros' type=Fill>, <tf.Operation 'fully_connected/weights/Adam' type=VariableV2>, <tf.Operation 'fully_connected/weights/Adam/Assign' type=Assign>, <tf.Operation 'fully_connected/weights/Adam/read' type=Identity>, <tf.Operation 'fully_connected/weights/Adam_1/Initializer/zeros/shape_as_tensor' type=Const>, <tf.Operation 'fully_connected/weights/Adam_1/Initializer/zeros/Const' type=Const>, <tf.Operation 'fully_connected/weights/Adam_1/Initializer/zeros' type=Fill>, <tf.Operation 'fully_connected/weights/Adam_1' type=VariableV2>, <tf.Operation 'fully_connected/weights/Adam_1/Assign' type=Assign>, <tf.Operation 'fully_connected/weights/Adam_1/read' type=Identity>, <tf.Operation 'fully_connected/biases/Adam/Initializer/zeros' type=Const>, <tf.Operation 'fully_connected/biases/Adam' type=VariableV2>, <tf.Operation 'fully_connected/biases/Adam/Assign' type=Assign>, <tf.Operation 'fully_connected/biases/Adam/read' type=Identity>, <tf.Operation 'fully_connected/biases/Adam_1/Initializer/zeros' type=Const>, <tf.Operation 'fully_connected/biases/Adam_1' type=VariableV2>, <tf.Operation 'fully_connected/biases/Adam_1/Assign' type=Assign>, <tf.Operation 'fully_connected/biases/Adam_1/read' type=Identity>, <tf.Operation 'Adam/learning_rate' type=Const>, <tf.Operation 'Adam/beta1' type=Const>, <tf.Operation 'Adam/beta2' type=Const>, <tf.Operation 'Adam/epsilon' type=Const>, <tf.Operation 'Adam/update_Wc1/ApplyAdam' type=ApplyAdam>, <tf.Operation 'Adam/update_Variable/ApplyAdam' type=ApplyAdam>, <tf.Operation 'Adam/update_Variable_1/ApplyAdam' type=ApplyAdam>, <tf.Operation 'Adam/update_fully_connected/weights/ApplyAdam' type=ApplyAdam>, <tf.Operation 'Adam/update_fully_connected/biases/ApplyAdam' type=ApplyAdam>, <tf.Operation 'Adam/mul' type=Mul>, <tf.Operation 'Adam/Assign' type=Assign>, <tf.Operation 'Adam/mul_1' type=Mul>, <tf.Operation 'Adam/Assign_1' type=Assign>, <tf.Operation 'Adam' type=NoOp>, <tf.Operation 'init' type=NoOp>, <tf.Operation 'save/Const' type=Const>, <tf.Operation 'save/SaveV2/tensor_names' type=Const>, <tf.Operation 'save/SaveV2/shape_and_slices' type=Const>, <tf.Operation 'save/SaveV2' type=SaveV2>, <tf.Operation 'save/control_dependency' type=Identity>, <tf.Operation 'save/RestoreV2/tensor_names' type=Const>, <tf.Operation 'save/RestoreV2/shape_and_slices' type=Const>, <tf.Operation 'save/RestoreV2' type=RestoreV2>, <tf.Operation 'save/Assign' type=Assign>, <tf.Operation 'save/Assign_1' type=Assign>, <tf.Operation 'save/Assign_2' type=Assign>, <tf.Operation 'save/Assign_3' type=Assign>, <tf.Operation 'save/Assign_4' type=Assign>, <tf.Operation 'save/Assign_5' type=Assign>, <tf.Operation 'save/Assign_6' type=Assign>, <tf.Operation 'save/Assign_7' type=Assign>, <tf.Operation 'save/Assign_8' type=Assign>, <tf.Operation 'save/Assign_9' type=Assign>, <tf.Operation 'save/Assign_10' type=Assign>, <tf.Operation 'save/Assign_11' type=Assign>, <tf.Operation 'save/Assign_12' type=Assign>, <tf.Operation 'save/Assign_13' type=Assign>, <tf.Operation 'save/Assign_14' type=Assign>, <tf.Operation 'save/Assign_15' type=Assign>, <tf.Operation 'save/Assign_16' type=Assign>, <tf.Operation 'save/Assign_17' type=Assign>, <tf.Operation 'save/Assign_18' type=Assign>, <tf.Operation 'save/Assign_19' type=Assign>, <tf.Operation 'save/restore_all' type=NoOp>, <tf.Operation 'save_1/Const' type=Const>, <tf.Operation 'save_1/StringJoin/inputs_1' type=Const>, <tf.Operation 'save_1/StringJoin' type=StringJoin>, <tf.Operation 'save_1/num_shards' type=Const>, <tf.Operation 'save_1/ShardedFilename/shard' type=Const>, <tf.Operation 'save_1/ShardedFilename' type=ShardedFilename>, <tf.Operation 'save_1/SaveV2/tensor_names' type=Const>, <tf.Operation 'save_1/SaveV2/shape_and_slices' type=Const>, <tf.Operation 'save_1/SaveV2' type=SaveV2>, <tf.Operation 'save_1/control_dependency' type=Identity>, <tf.Operation 'save_1/MergeV2Checkpoints/checkpoint_prefixes' type=Pack>, <tf.Operation 'save_1/MergeV2Checkpoints' type=MergeV2Checkpoints>, <tf.Operation 'save_1/Identity' type=Identity>, <tf.Operation 'save_1/RestoreV2/tensor_names' type=Const>, <tf.Operation 'save_1/RestoreV2/shape_and_slices' type=Const>, <tf.Operation 'save_1/RestoreV2' type=RestoreV2>, <tf.Operation 'save_1/Assign' type=Assign>, <tf.Operation 'save_1/Assign_1' type=Assign>, <tf.Operation 'save_1/Assign_2' type=Assign>, <tf.Operation 'save_1/Assign_3' type=Assign>, <tf.Operation 'save_1/Assign_4' type=Assign>, <tf.Operation 'save_1/Assign_5' type=Assign>, <tf.Operation 'save_1/Assign_6' type=Assign>, <tf.Operation 'save_1/Assign_7' type=Assign>, <tf.Operation 'save_1/Assign_8' type=Assign>, <tf.Operation 'save_1/Assign_9' type=Assign>, <tf.Operation 'save_1/Assign_10' type=Assign>, <tf.Operation 'save_1/Assign_11' type=Assign>, <tf.Operation 'save_1/Assign_12' type=Assign>, <tf.Operation 'save_1/Assign_13' type=Assign>, <tf.Operation 'save_1/Assign_14' type=Assign>, <tf.Operation 'save_1/Assign_15' type=Assign>, <tf.Operation 'save_1/Assign_16' type=Assign>, <tf.Operation 'save_1/Assign_17' type=Assign>, <tf.Operation 'save_1/Assign_18' type=Assign>, <tf.Operation 'save_1/Assign_19' type=Assign>, <tf.Operation 'save_1/restore_shard' type=NoOp>, <tf.Operation 'save_1/restore_all' type=NoOp>]\n"
     ]
    }
   ],
   "source": [
    "graph2 = tf.Graph()\n",
    "with graph2.as_default():\n",
    "    with tf.Session(graph=graph2) as sess:\n",
    "        # Restore saved values\n",
    "        print('\\nRestoring...')\n",
    "        tf.saved_model.loader.load(\n",
    "            sess,\n",
    "            [tag_constants.SERVING],\n",
    "            model_v2_path\n",
    "        )\n",
    "        print(graph2.get_operations())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from /Users/sorg/Projects/Computer-Vision/celebrity-recogntion/model_v2-1000\n",
      "['losses', 'model_variables', 'train_op', 'trainable_variables', 'variables']\n",
      "<tf.Variable 'Wc1:0' shape=(3, 3, 1, 16) dtype=float32_ref>\n",
      "<tf.Variable 'Wc2:0' shape=(3, 3, 16, 32) dtype=float32_ref>\n",
      "<tf.Variable 'Wc3:0' shape=(3, 3, 32, 64) dtype=float32_ref>\n",
      "<tf.Variable 'Wc4:0' shape=(3, 3, 64, 128) dtype=float32_ref>\n",
      "<tf.Variable 'Variable:0' shape=(35344, 512) dtype=float32_ref>\n",
      "<tf.Variable 'Variable_1:0' shape=(512,) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/weights:0' shape=(512, 30) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/biases:0' shape=(30,) dtype=float32_ref>\n",
      "<tf.Variable 'beta1_power:0' shape=() dtype=float32_ref>\n",
      "<tf.Variable 'beta2_power:0' shape=() dtype=float32_ref>\n",
      "<tf.Variable 'Wc1/Adam:0' shape=(3, 3, 1, 16) dtype=float32_ref>\n",
      "<tf.Variable 'Wc1/Adam_1:0' shape=(3, 3, 1, 16) dtype=float32_ref>\n",
      "<tf.Variable 'Variable/Adam:0' shape=(35344, 512) dtype=float32_ref>\n",
      "<tf.Variable 'Variable/Adam_1:0' shape=(35344, 512) dtype=float32_ref>\n",
      "<tf.Variable 'Variable_1/Adam:0' shape=(512,) dtype=float32_ref>\n",
      "<tf.Variable 'Variable_1/Adam_1:0' shape=(512,) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/weights/Adam:0' shape=(512, 30) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/weights/Adam_1:0' shape=(512, 30) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/biases/Adam:0' shape=(30,) dtype=float32_ref>\n",
      "<tf.Variable 'fully_connected/biases/Adam_1:0' shape=(30,) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "sess=tf.Session()    \n",
    "#First let's load meta graph and restore weights\n",
    "saver = tf.train.import_meta_graph('model_v2-1000.meta')\n",
    "saver.restore(sess,tf.train.latest_checkpoint('./'))\n",
    "\n",
    "graph = tf.get_default_graph()\n",
    "\n",
    "print(tf.get_default_graph().get_all_collection_keys())\n",
    "for v in tf.get_default_graph().get_collection(\"variables\"):\n",
    "    print(v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from /Users/sorg/Projects/Computer-Vision/celebrity-recogntion/model_v2.ckpt\n"
     ]
    },
    {
     "ename": "FailedPreconditionError",
     "evalue": "Attempting to use uninitialized value fully_connected/biases\n\t [[node fully_connected/biases/read (defined at /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py:277)  = Identity[T=DT_FLOAT, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](fully_connected/biases)]]\n\nCaused by op 'fully_connected/biases/read', defined at:\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/runpy.py\", line 193, in _run_module_as_main\n    \"__main__\", mod_spec)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/runpy.py\", line 85, in _run_code\n    exec(code, run_globals)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py\", line 16, in <module>\n    app.launch_new_instance()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/traitlets/config/application.py\", line 658, in launch_instance\n    app.start()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelapp.py\", line 497, in start\n    self.io_loop.start()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/platform/asyncio.py\", line 132, in start\n    self.asyncio_loop.run_forever()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/base_events.py\", line 422, in run_forever\n    self._run_once()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/base_events.py\", line 1432, in _run_once\n    handle._run()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/events.py\", line 145, in _run\n    self._callback(*self._args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/platform/asyncio.py\", line 122, in _handle_events\n    handler_func(fileobj, events)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n    return fn(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 450, in _handle_events\n    self._handle_recv()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 480, in _handle_recv\n    self._run_callback(callback, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 432, in _run_callback\n    callback(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n    return fn(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 283, in dispatcher\n    return self.dispatch_shell(stream, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 233, in dispatch_shell\n    handler(stream, idents, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 399, in execute_request\n    user_expressions, allow_stdin)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/ipkernel.py\", line 208, in do_execute\n    res = shell.run_cell(code, store_history=store_history, silent=silent)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/zmqshell.py\", line 537, in run_cell\n    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2662, in run_cell\n    raw_cell, store_history, silent, shell_futures)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2785, in _run_cell\n    interactivity=interactivity, compiler=compiler, result=result)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2903, in run_ast_nodes\n    if self.run_code(code, result):\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2963, in run_code\n    exec(code_obj, self.user_global_ns, self.user_ns)\n  File \"<ipython-input-140-28113f52891e>\", line 10, in <module>\n    Y_pred = conv_net_v2(X, parameters)\n  File \"<ipython-input-98-b06d8244f314>\", line 95, in conv_net_v2\n    Y_pred = tf.contrib.layers.fully_connected(Z5, Z5_output, activation_fn = None)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1854, in fully_connected\n    outputs = layer.apply(inputs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 817, in apply\n    return self.__call__(inputs, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/layers/base.py\", line 374, in __call__\n    outputs = super(Layer, self).__call__(inputs, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 746, in __call__\n    self.build(input_shapes)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/layers/core.py\", line 953, in build\n    trainable=True)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/layers/base.py\", line 288, in add_weight\n    getter=vs.get_variable)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 609, in add_weight\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/checkpointable/base.py\", line 639, in _add_variable_with_custom_getter\n    **kwargs_for_getter)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 1487, in get_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 1237, in get_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 523, in get_variable\n    return custom_getter(**custom_getter_kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1749, in layer_variable_getter\n    return _model_variable_getter(getter, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1740, in _model_variable_getter\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py\", line 350, in model_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py\", line 277, in variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 492, in _true_getter\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 922, in _get_single_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 183, in __call__\n    return cls._variable_v1_call(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 146, in _variable_v1_call\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 125, in <lambda>\n    previous_getter = lambda **kwargs: default_variable_creator(None, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 2444, in default_variable_creator\n    expected_shape=expected_shape, import_scope=import_scope)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 187, in __call__\n    return super(VariableMetaclass, cls).__call__(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 1329, in __init__\n    constraint=constraint)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 1491, in _init_from_args\n    self._snapshot = array_ops.identity(self._variable, name=\"read\")\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/array_ops.py\", line 81, in identity\n    return gen_array_ops.identity(input, name=name)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/gen_array_ops.py\", line 3454, in identity\n    \"Identity\", input=input, name=name)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py\", line 787, in _apply_op_helper\n    op_def=op_def)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/util/deprecation.py\", line 488, in new_func\n    return func(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\", line 3274, in create_op\n    op_def=op_def)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\", line 1770, in __init__\n    self._traceback = tf_stack.extract_stack()\n\nFailedPreconditionError (see above for traceback): Attempting to use uninitialized value fully_connected/biases\n\t [[node fully_connected/biases/read (defined at /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py:277)  = Identity[T=DT_FLOAT, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](fully_connected/biases)]]\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFailedPreconditionError\u001b[0m                   Traceback (most recent call last)",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m   1333\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1334\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1335\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run_fn\u001b[0;34m(feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[1;32m   1318\u001b[0m       return self._call_tf_sessionrun(\n\u001b[0;32m-> 1319\u001b[0;31m           options, feed_dict, fetch_list, target_list, run_metadata)\n\u001b[0m\u001b[1;32m   1320\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_call_tf_sessionrun\u001b[0;34m(self, options, feed_dict, fetch_list, target_list, run_metadata)\u001b[0m\n\u001b[1;32m   1406\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1407\u001b[0;31m         run_metadata)\n\u001b[0m\u001b[1;32m   1408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFailedPreconditionError\u001b[0m: Attempting to use uninitialized value fully_connected/biases\n\t [[{{node fully_connected/biases/read}} = Identity[T=DT_FLOAT, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](fully_connected/biases)]]",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mFailedPreconditionError\u001b[0m                   Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-140-28113f52891e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mY_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconv_net_v2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mcost\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompute_cost\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mY_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mthe_cost\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcost\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mimgs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mkey_pts_test\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthe_cost\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0;31m#print(Y_pred.eval({X: imgs_test, Y: key_pts_test}, session = sess))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    927\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    928\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 929\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    930\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    931\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1150\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mhandle\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1151\u001b[0m       results = self._do_run(handle, final_targets, final_fetches,\n\u001b[0;32m-> 1152\u001b[0;31m                              feed_dict_tensor, options, run_metadata)\n\u001b[0m\u001b[1;32m   1153\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1154\u001b[0m       \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_run\u001b[0;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1326\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1327\u001b[0m       return self._do_call(_run_fn, feeds, fetches, targets, options,\n\u001b[0;32m-> 1328\u001b[0;31m                            run_metadata)\n\u001b[0m\u001b[1;32m   1329\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1330\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_prun_fn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeeds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetches\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m   1346\u001b[0m           \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1347\u001b[0m       \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0merror_interpolation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterpolate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1348\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1349\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1350\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_extend_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFailedPreconditionError\u001b[0m: Attempting to use uninitialized value fully_connected/biases\n\t [[node fully_connected/biases/read (defined at /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py:277)  = Identity[T=DT_FLOAT, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](fully_connected/biases)]]\n\nCaused by op 'fully_connected/biases/read', defined at:\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/runpy.py\", line 193, in _run_module_as_main\n    \"__main__\", mod_spec)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/runpy.py\", line 85, in _run_code\n    exec(code, run_globals)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py\", line 16, in <module>\n    app.launch_new_instance()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/traitlets/config/application.py\", line 658, in launch_instance\n    app.start()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelapp.py\", line 497, in start\n    self.io_loop.start()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/platform/asyncio.py\", line 132, in start\n    self.asyncio_loop.run_forever()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/base_events.py\", line 422, in run_forever\n    self._run_once()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/base_events.py\", line 1432, in _run_once\n    handle._run()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/asyncio/events.py\", line 145, in _run\n    self._callback(*self._args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/platform/asyncio.py\", line 122, in _handle_events\n    handler_func(fileobj, events)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n    return fn(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 450, in _handle_events\n    self._handle_recv()\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 480, in _handle_recv\n    self._run_callback(callback, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 432, in _run_callback\n    callback(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n    return fn(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 283, in dispatcher\n    return self.dispatch_shell(stream, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 233, in dispatch_shell\n    handler(stream, idents, msg)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 399, in execute_request\n    user_expressions, allow_stdin)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/ipkernel.py\", line 208, in do_execute\n    res = shell.run_cell(code, store_history=store_history, silent=silent)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel/zmqshell.py\", line 537, in run_cell\n    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2662, in run_cell\n    raw_cell, store_history, silent, shell_futures)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2785, in _run_cell\n    interactivity=interactivity, compiler=compiler, result=result)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2903, in run_ast_nodes\n    if self.run_code(code, result):\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2963, in run_code\n    exec(code_obj, self.user_global_ns, self.user_ns)\n  File \"<ipython-input-140-28113f52891e>\", line 10, in <module>\n    Y_pred = conv_net_v2(X, parameters)\n  File \"<ipython-input-98-b06d8244f314>\", line 95, in conv_net_v2\n    Y_pred = tf.contrib.layers.fully_connected(Z5, Z5_output, activation_fn = None)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1854, in fully_connected\n    outputs = layer.apply(inputs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 817, in apply\n    return self.__call__(inputs, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/layers/base.py\", line 374, in __call__\n    outputs = super(Layer, self).__call__(inputs, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 746, in __call__\n    self.build(input_shapes)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/layers/core.py\", line 953, in build\n    trainable=True)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/layers/base.py\", line 288, in add_weight\n    getter=vs.get_variable)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py\", line 609, in add_weight\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/training/checkpointable/base.py\", line 639, in _add_variable_with_custom_getter\n    **kwargs_for_getter)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 1487, in get_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 1237, in get_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 523, in get_variable\n    return custom_getter(**custom_getter_kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1749, in layer_variable_getter\n    return _model_variable_getter(getter, *args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py\", line 1740, in _model_variable_getter\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py\", line 350, in model_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/arg_scope.py\", line 182, in func_with_args\n    return func(*args, **current_args)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py\", line 277, in variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 492, in _true_getter\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 922, in _get_single_variable\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 183, in __call__\n    return cls._variable_v1_call(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 146, in _variable_v1_call\n    aggregation=aggregation)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 125, in <lambda>\n    previous_getter = lambda **kwargs: default_variable_creator(None, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variable_scope.py\", line 2444, in default_variable_creator\n    expected_shape=expected_shape, import_scope=import_scope)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 187, in __call__\n    return super(VariableMetaclass, cls).__call__(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 1329, in __init__\n    constraint=constraint)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\", line 1491, in _init_from_args\n    self._snapshot = array_ops.identity(self._variable, name=\"read\")\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/array_ops.py\", line 81, in identity\n    return gen_array_ops.identity(input, name=name)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/ops/gen_array_ops.py\", line 3454, in identity\n    \"Identity\", input=input, name=name)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py\", line 787, in _apply_op_helper\n    op_def=op_def)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/util/deprecation.py\", line 488, in new_func\n    return func(*args, **kwargs)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\", line 3274, in create_op\n    op_def=op_def)\n  File \"/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\", line 1770, in __init__\n    self._traceback = tf_stack.extract_stack()\n\nFailedPreconditionError (see above for traceback): Attempting to use uninitialized value fully_connected/biases\n\t [[node fully_connected/biases/read (defined at /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/contrib/framework/python/ops/variables.py:277)  = Identity[T=DT_FLOAT, _device=\"/job:localhost/replica:0/task:0/device:CPU:0\"](fully_connected/biases)]]\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "X, Y = create_placeholders(key_pts_test.shape[1], imgs_test.shape)\n",
    "parameters = initialize_parameters()\n",
    "\n",
    "saver = tf.train.Saver()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    # Restore variables from disk.\n",
    "    saver.restore(sess, save_path)\n",
    "    Y_pred = conv_net_v2(X, parameters)\n",
    "    cost = compute_cost(Y_pred, Y)\n",
    "    the_cost = sess.run([cost], feed_dict = {X: imgs_test, Y: key_pts_test})\n",
    "    print(the_cost)\n",
    "    #print(Y_pred.eval({X: imgs_test, Y: key_pts_test}, session = sess))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1091\u001b[0m             subfeed_t = self.graph.as_graph_element(\n\u001b[0;32m-> 1092\u001b[0;31m                 subfeed, allow_tensor=True, allow_operation=False)\n\u001b[0m\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mas_graph_element\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3489\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3490\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_as_graph_element_locked\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_tensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_operation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3491\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_as_graph_element_locked\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3568\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3569\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Tensor %s is not an element of this graph.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3570\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-116-5a34add5c319>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSession\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mY_pred\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mimgs_test\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36meval\u001b[0;34m(self, feed_dict, session)\u001b[0m\n\u001b[1;32m    711\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    712\u001b[0m     \"\"\"\n\u001b[0;32m--> 713\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_eval_using_default_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    714\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    715\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_eval_using_default_session\u001b[0;34m(tensors, feed_dict, graph, session)\u001b[0m\n\u001b[1;32m   5155\u001b[0m                        \u001b[0;34m\"the tensor's graph is different from the session's \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5156\u001b[0m                        \"graph.\")\n\u001b[0;32m-> 5157\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5159\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    927\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    928\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 929\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    930\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    931\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1094\u001b[0m             raise TypeError(\n\u001b[0;32m-> 1095\u001b[0;31m                 'Cannot interpret feed_dict key as Tensor: ' + e.args[0])\n\u001b[0m\u001b[1;32m   1096\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1097\u001b[0m           \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubfeed_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph."
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess: \n",
    "    sess.run(Y_pred.eval({X: imgs_test}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1091\u001b[0m             subfeed_t = self.graph.as_graph_element(\n\u001b[0;32m-> 1092\u001b[0;31m                 subfeed, allow_tensor=True, allow_operation=False)\n\u001b[0m\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mas_graph_element\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3489\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3490\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_as_graph_element_locked\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_tensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_operation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3491\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_as_graph_element_locked\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3568\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3569\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Tensor %s is not an element of this graph.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3570\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-114-c615bc886c68>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSession\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mY_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mimgs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mkey_pts_test\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    927\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    928\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 929\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    930\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    931\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1094\u001b[0m             raise TypeError(\n\u001b[0;32m-> 1095\u001b[0;31m                 'Cannot interpret feed_dict key as Tensor: ' + e.args[0])\n\u001b[0m\u001b[1;32m   1096\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1097\u001b[0m           \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubfeed_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph."
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess: \n",
    "    sess.run(Y_pred, feed_dict = {X: imgs_test, Y: key_pts_test})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(object):\n",
    "\n",
    "\n",
    "    def __init__(self, model_path, X_train, Y_train, X_test, Y_test, learning_rate = 0.009,\n",
    "          num_epochs = 100, minibatch_size = 64, print_cost = True):\n",
    "        \"\"\"\n",
    "        Implements a three-layer ConvNet in Tensorflow:\n",
    "        CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n",
    "\n",
    "        Arguments:\n",
    "        X_train -- training set, of shape (None, 64, 64, 3)\n",
    "        Y_train -- test set, of shape (None, n_y = 6)\n",
    "        X_test -- training set, of shape (None, 64, 64, 3)\n",
    "        Y_test -- test set, of shape (None, n_y = 6)\n",
    "        learning_rate -- learning rate of the optimization\n",
    "        num_epochs -- number of epochs of the optimization loop\n",
    "        minibatch_size -- size of a minibatch\n",
    "        print_cost -- True to print the cost every 100 epochs\n",
    "\n",
    "        Returns:\n",
    "        train_accuracy -- real number, accuracy on the train set (X_train)\n",
    "        test_accuracy -- real number, testing accuracy on the test set (X_test)\n",
    "        parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "        \"\"\"\n",
    "        self.session = tf.session()\n",
    "        \n",
    "        tf.saved_model.loader.load(\n",
    "            self.session,\n",
    "            [tf.saved_model.tag_constants.SERVING],\n",
    "            model_path)\n",
    "\n",
    "        ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "        tf.set_random_seed(1)                             # to keep results consistent (tensorflow seed)\n",
    "        seed = 3                                          # to keep results consistent (numpy seed)\n",
    "        (m, n_H0, n_W0, n_C0) = X_train.shape             \n",
    "        n_y = Y_train.shape[1]                            \n",
    "        costs = []                                        # To keep track of the cost\n",
    "\n",
    "        test_costs = []\n",
    "        epochs_of_test_costs = []\n",
    "        # Create Placeholders of the correct shape\n",
    "\n",
    "        X, Y = create_placeholders(n_y, X_train.shape)\n",
    "\n",
    "\n",
    "        # Initialize parameters\n",
    "        parameters = initialize_parameters()\n",
    "\n",
    "        # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "        Y_pred = conv_net(X, parameters)\n",
    "\n",
    "\n",
    "        # Cost function: Add cost function to tensorflow graph\n",
    "        cost = compute_cost(Y_pred, Y)\n",
    "\n",
    "\n",
    "        # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.\n",
    "        optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "\n",
    "\n",
    "        # Initialize all the variables globally\n",
    "        init = tf.global_variables_initializer()\n",
    "\n",
    "        # Start the session to compute the tensorflow graph\n",
    "        with tf.Session() as sess:\n",
    "\n",
    "            # Run the initialization\n",
    "            sess.run(init)\n",
    "\n",
    "            # Do the training loop\n",
    "            for epoch in range(num_epochs):\n",
    "\n",
    "                minibatch_cost = 0.\n",
    "                num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "                seed = seed + 1\n",
    "                minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "                for minibatch in minibatches:\n",
    "\n",
    "                    # Select a minibatch\n",
    "                    (minibatch_X, minibatch_Y) = minibatch\n",
    "                    # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                    # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).\n",
    "\n",
    "                    _ , temp_cost = sess.run([optimizer,cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})\n",
    "\n",
    "\n",
    "                    minibatch_cost += temp_cost / num_minibatches\n",
    "\n",
    "\n",
    "                # Print the cost every epoch\n",
    "                if print_cost == True and epoch % 5 == 0:\n",
    "                    print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n",
    "                if print_cost == True and epoch % 1 == 0:\n",
    "                    costs.append(minibatch_cost)\n",
    "\n",
    "                if print_cost == True and epoch % 10 == 0 and epoch > 0:\n",
    "                    test_cost = sess.run([cost], feed_dict = {X: X_test, Y: Y_test})\n",
    "                    test_costs.append(test_cost)\n",
    "                    epochs_of_test_costs.append(epoch)\n",
    "                    print (\"\\nTest cost after epoch %i: %f\\n\" % (epoch, test_cost[0]))\n",
    "                    '''\n",
    "                    # Calculate the correct predictions\n",
    "                    predict_op = tf.argmax(Y_pred, 1)\n",
    "                    correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n",
    "\n",
    "                    # Calculate accuracy on the test set\n",
    "                    accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "                    mse = tf.losses.mean_squared_error(Y_pred, Y)\n",
    "                    test_accuracy = mse.eval({X: X_test, Y: Y_test})\n",
    "                    print (\"Test Accuracy after epoch %i: %f\" % (epoch, test_accuracy))\n",
    "                '''\n",
    "\n",
    "            # plot the cost without the first wildly off epoch\n",
    "            plt.plot(np.squeeze(costs[1:]), 'b-')\n",
    "            plt.plot(epochs_of_test_costs, test_costs, 'g-')\n",
    "            plt.ylabel('cost')\n",
    "            plt.xlabel('iterations (per tens)')\n",
    "            plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "            plt.show()\n",
    "\n",
    "\n",
    "            train_cost = cost.eval({X: X_train, Y: Y_train})\n",
    "            test_cost = cost.eval({X: X_test, Y: Y_test})\n",
    "            print(\"Train Cost:\", train_cost)\n",
    "            print(\"Test Cost:\", test_cost)\n",
    "\n",
    "            return train_cost, test_cost, parameters, Y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1091\u001b[0m             subfeed_t = self.graph.as_graph_element(\n\u001b[0;32m-> 1092\u001b[0;31m                 subfeed, allow_tensor=True, allow_operation=False)\n\u001b[0m\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mas_graph_element\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3489\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3490\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_as_graph_element_locked\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_tensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_operation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3491\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_as_graph_element_locked\u001b[0;34m(self, obj, allow_tensor, allow_operation)\u001b[0m\n\u001b[1;32m   3568\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3569\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Tensor %s is not an element of this graph.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3570\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph.",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-108-6352cb3360fa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSession\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mY_pred\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mimgs_test\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36meval\u001b[0;34m(self, feed_dict, session)\u001b[0m\n\u001b[1;32m    711\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    712\u001b[0m     \"\"\"\n\u001b[0;32m--> 713\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_eval_using_default_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    714\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    715\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36m_eval_using_default_session\u001b[0;34m(tensors, feed_dict, graph, session)\u001b[0m\n\u001b[1;32m   5155\u001b[0m                        \u001b[0;34m\"the tensor's graph is different from the session's \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5156\u001b[0m                        \"graph.\")\n\u001b[0;32m-> 5157\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5158\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5159\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    927\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    928\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 929\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    930\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    931\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1093\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1094\u001b[0m             raise TypeError(\n\u001b[0;32m-> 1095\u001b[0;31m                 'Cannot interpret feed_dict key as Tensor: ' + e.args[0])\n\u001b[0m\u001b[1;32m   1096\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1097\u001b[0m           \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubfeed_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Cannot interpret feed_dict key as Tensor: Tensor Tensor(\"Placeholder:0\", shape=(?, 96, 96, 1), dtype=float32) is not an element of this graph."
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    Y_pred.eval({X: imgs_test})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "outputs = key_pts.shape[1] # 30\n",
    "input_shape = imgs.shape[1:] # (96,96,1)\n",
    "\n",
    "def conv_net(x_dict, n_classes, dropout, reuse, is_training, input_shape = IMG_SHAPE):\n",
    "    # Define a scope for reusing the variables\n",
    "    with tf.variable_scope('ConvNet', reuse=reuse):\n",
    "        # TF Estimator input is a dict, in case of multiple inputs\n",
    "        x = x_dict['imgs']\n",
    "\n",
    "        # Reshape to match picture format [Height x Width x Channel]\n",
    "        # Tensor input become 4-D: [Batch Size, Height, Width, Channel]\n",
    "\n",
    "        x = tf.reshape(x, shape=[-1, input_shape[1], input_shape[2], input_shape[3]])\n",
    "\n",
    "        # Convolution Layer with 32 filters and a kernel size of 5\n",
    "        conv1 = tf.nn.conv2d(x, 32, 5, activation=tf.nn.relu)\n",
    "        # Max Pooling (down-sampling) with strides of 2 and kernel size of 2\n",
    "        conv1 = tf.layers.max_pooling2d(conv1, 2, 2)\n",
    "\n",
    "        # Convolution Layer with 64 filters and a kernel size of 3\n",
    "        conv2 = tf.nn.conv2d(conv1, 64, 3, activation=tf.nn.relu)\n",
    "        # Max Pooling (down-sampling) with strides of 2 and kernel size of 2\n",
    "        conv2 = tf.layers.max_pooling2d(conv2, 2, 2)\n",
    "\n",
    "        # Flatten the data to a 1-D vector for the fully connected layer\n",
    "        fc1 = tf.contrib.layers.flatten(conv2)\n",
    "\n",
    "        # Fully connected layer (in tf contrib folder for now)\n",
    "        fc1 = tf.layers.dense(fc1, 1024)\n",
    "        # Apply Dropout (if is_training is False, dropout is not applied)\n",
    "        fc1 = tf.layers.dropout(fc1, rate=dropout, training=is_training)\n",
    "\n",
    "        # Output layer, class prediction\n",
    "        out = tf.layers.dense(fc1, n_classes)\n",
    "\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}