Add files using upload-large-folder tool

25. Face Recognition with VGGFace/2.1 Download VGG Face Weights.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1dgQU8cV9rToR23cFArk68rgY1C0B_N3P/view?usp=sharing";</script>

25. Face Recognition with VGGFace/2.2 Download VGG Face Weights.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1dgQU8cV9rToR23cFArk68rgY1C0B_N3P/view?usp=sharing";</script>

25. Face Recognition with VGGFace/3. Face Recognition using WebCam & Identifying Friends TV Show Characters in Video.html

@@ -0,0 +1 @@
+<p><strong>Intro and Lesson:</strong></p><p>In this section, we use the VGGFace model to identify yourself (you'll need to include a picture of yourself in the directory stated in the code).</p><p>It uses one-shot learning, so we only need one picture for our recognition system!</p><p><strong>The iPython Notebooks to load first are:</strong></p><ul><li><p>25.3 Face Recognition - One Shot Learning.ipynb</p></li></ul><p><br></p><p><br></p>

26. Credit Card/26. Credit Card Reader.ipynb

@@ -0,0 +1,1066 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Let's Create Our Credit Card Dataset\n",
+    "- There two main font variations used in credit cards"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "\n",
+    "cc1 = cv2.imread('creditcard_digits1.jpg', 0)\n",
+    "cv2.imshow(\"Digits 1\", cc1)\n",
+    "cv2.waitKey(0)\n",
+    "cc2 = cv2.imread('creditcard_digits2.jpg', 0)\n",
+    "cv2.imshow(\"Digits 2\", cc2)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cc1 = cv2.imread('creditcard_digits2.jpg', 0)\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"Digits 2 Thresholded\", th2)\n",
+    "cv2.waitKey(0)\n",
+    "    \n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now let's get generate an Augumentated Dataset from these two samples \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "./credit_card/train/0\n",
+      "./credit_card/train/1\n",
+      "./credit_card/train/2\n",
+      "./credit_card/train/3\n",
+      "./credit_card/train/4\n",
+      "./credit_card/train/5\n",
+      "./credit_card/train/6\n",
+      "./credit_card/train/7\n",
+      "./credit_card/train/8\n",
+      "./credit_card/train/9\n",
+      "./credit_card/test/0\n",
+      "./credit_card/test/1\n",
+      "./credit_card/test/2\n",
+      "./credit_card/test/3\n",
+      "./credit_card/test/4\n",
+      "./credit_card/test/5\n",
+      "./credit_card/test/6\n",
+      "./credit_card/test/7\n",
+      "./credit_card/test/8\n",
+      "./credit_card/test/9\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Create our dataset directories\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "def makedir(directory):\n",
+    "    \"\"\"Creates a new directory if it does not exist\"\"\"\n",
+    "    if not os.path.exists(directory):\n",
+    "        os.makedirs(directory)\n",
+    "        return None, 0\n",
+    "    \n",
+    "for i in range(0,10):\n",
+    "    directory_name = \"./credit_card/train/\"+str(i)\n",
+    "    print(directory_name)\n",
+    "    makedir(directory_name) \n",
+    "\n",
+    "for i in range(0,10):\n",
+    "    directory_name = \"./credit_card/test/\"+str(i)\n",
+    "    print(directory_name)\n",
+    "    makedir(directory_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's make our Data Augmentation Functions\n",
+    "These are used to perform image manipulation and pre-processing tasks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np \n",
+    "import random\n",
+    "import cv2\n",
+    "from scipy.ndimage import convolve\n",
+    "\n",
+    "def DigitAugmentation(frame, dim = 32):\n",
+    "    \"\"\"Randomly alters the image using noise, pixelation and streching image functions\"\"\"\n",
+    "    frame = cv2.resize(frame, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC)\n",
+    "    frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)\n",
+    "    random_num = np.random.randint(0,9)\n",
+    "\n",
+    "    if (random_num % 2 == 0):\n",
+    "        frame = add_noise(frame)\n",
+    "    if(random_num % 3 == 0):\n",
+    "        frame = pixelate(frame)\n",
+    "    if(random_num % 2 == 0):\n",
+    "        frame = stretch(frame)\n",
+    "    frame = cv2.resize(frame, (dim, dim), interpolation = cv2.INTER_AREA)\n",
+    "\n",
+    "    return frame \n",
+    "\n",
+    "def add_noise(image):\n",
+    "    \"\"\"Addings noise to image\"\"\"\n",
+    "    prob = random.uniform(0.01, 0.05)\n",
+    "    rnd = np.random.rand(image.shape[0], image.shape[1])\n",
+    "    noisy = image.copy()\n",
+    "    noisy[rnd < prob] = 0\n",
+    "    noisy[rnd > 1 - prob] = 1\n",
+    "    return noisy\n",
+    "\n",
+    "def pixelate(image):\n",
+    "    \"Pixelates an image by reducing the resolution then upscaling it\"\n",
+    "    dim = np.random.randint(8,12)\n",
+    "    image = cv2.resize(image, (dim, dim), interpolation = cv2.INTER_AREA)\n",
+    "    image = cv2.resize(image, (16, 16), interpolation = cv2.INTER_AREA)\n",
+    "    return image\n",
+    "\n",
+    "def stretch(image):\n",
+    "    \"Randomly applies different degrees of stretch to image\"\n",
+    "    ran = np.random.randint(0,3)*2\n",
+    "    if np.random.randint(0,2) == 0:\n",
+    "        frame = cv2.resize(image, (32, ran+32), interpolation = cv2.INTER_AREA)\n",
+    "        return frame[int(ran/2):int(ran+32)-int(ran/2), 0:32]\n",
+    "    else:\n",
+    "        frame = cv2.resize(image, (ran+32, 32), interpolation = cv2.INTER_AREA)\n",
+    "        return frame[0:32, int(ran/2):int(ran+32)-int(ran/2)]\n",
+    "    \n",
+    "def pre_process(image, inv = False):\n",
+    "    \"\"\"Uses OTSU binarization on an image\"\"\"\n",
+    "    try:\n",
+    "        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
+    "    except:\n",
+    "        gray_image = image\n",
+    "        pass\n",
+    "    \n",
+    "    if inv == False:\n",
+    "        _, th2 = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
+    "    else:\n",
+    "        _, th2 = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "    resized = cv2.resize(th2, (32,32), interpolation = cv2.INTER_AREA)\n",
+    "    return resized"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing our augmentation functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cc1 = cv2.imread('creditcard_digits2.jpg', 0)\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"cc1\", th2)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()\n",
+    "\n",
+    "# This is the coordinates of the region enclosing  the first digit\n",
+    "# This is preset and was done manually based on this specific image\n",
+    "region = [(0, 0), (35, 48)]\n",
+    "\n",
+    "# Assigns values to each region for ease of interpretation\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "for i in range(0,1): #We only look at the first digit in testing out augmentation functions\n",
+    "    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "    for j in range(0,10):\n",
+    "        roi2 = DigitAugmentation(roi)\n",
+    "        roi_otsu = pre_process(roi2, inv = False)\n",
+    "        cv2.imshow(\"otsu\", roi_otsu)\n",
+    "        cv2.waitKey(0)\n",
+    "        \n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating our Training Data (1000 variations of each font type)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Augmenting Digit -  0\n",
+      "Augmenting Digit -  1\n",
+      "Augmenting Digit -  2\n",
+      "Augmenting Digit -  3\n",
+      "Augmenting Digit -  4\n",
+      "Augmenting Digit -  5\n",
+      "Augmenting Digit -  6\n",
+      "Augmenting Digit -  7\n",
+      "Augmenting Digit -  8\n",
+      "Augmenting Digit -  9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Creating 2000 Images for each digit in creditcard_digits1 - TRAINING DATA\n",
+    "\n",
+    "# Load our first image\n",
+    "cc1 = cv2.imread('creditcard_digits1.jpg', 0)\n",
+    "\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"cc1\", th2)\n",
+    "cv2.imshow(\"creditcard_digits1\", cc1)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()\n",
+    "\n",
+    "region = [(2, 19), (50, 72)]\n",
+    "\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "for i in range(0,10):   \n",
+    "    # We jump the next digit each time we loop\n",
+    "    if i > 0:\n",
+    "        top_left_x = top_left_x + 59\n",
+    "        bottom_right_x = bottom_right_x + 59\n",
+    "\n",
+    "    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "    print(\"Augmenting Digit - \", str(i))\n",
+    "    # We create 200 versions of each image for our dataset\n",
+    "    for j in range(0,2000):\n",
+    "        roi2 = DigitAugmentation(roi)\n",
+    "        roi_otsu = pre_process(roi2, inv = True)\n",
+    "        cv2.imwrite(\"./credit_card/train/\"+str(i)+\"./_1_\"+str(j)+\".jpg\", roi_otsu)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creating 2000 Images for each digit in creditcard_digits2 - TRAINING DATA\n",
+    "\n",
+    "cc1 = cv2.imread('creditcard_digits2.jpg', 0)\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"cc1\", th2)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()\n",
+    "\n",
+    "region = [(0, 0), (35, 48)]\n",
+    "\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "for i in range(0,10):   \n",
+    "    if i > 0:\n",
+    "        # We jump the next digit each time we loop\n",
+    "        top_left_x = top_left_x + 35\n",
+    "        bottom_right_x = bottom_right_x + 35\n",
+    "\n",
+    "    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "    print(\"Augmenting Digit - \", str(i))\n",
+    "    # We create 200 versions of each image for our dataset\n",
+    "    for j in range(0,2000):\n",
+    "        roi2 = DigitAugmentation(roi)\n",
+    "        roi_otsu = pre_process(roi2, inv = False)\n",
+    "        cv2.imwrite(\"./credit_card/train/\"+str(i)+\"./_2_\"+str(j)+\".jpg\", roi_otsu)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Augmenting Digit -  0\n",
+      "Augmenting Digit -  1\n",
+      "Augmenting Digit -  2\n",
+      "Augmenting Digit -  3\n",
+      "Augmenting Digit -  4\n",
+      "Augmenting Digit -  5\n",
+      "Augmenting Digit -  6\n",
+      "Augmenting Digit -  7\n",
+      "Augmenting Digit -  8\n",
+      "Augmenting Digit -  9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Creating 200 Images for each digit in creditcard_digits1 - TEST DATA\n",
+    "\n",
+    "# Load our first image\n",
+    "cc1 = cv2.imread('creditcard_digits1.jpg', 0)\n",
+    "\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"cc1\", th2)\n",
+    "cv2.imshow(\"creditcard_digits1\", cc1)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()\n",
+    "\n",
+    "region = [(2, 19), (50, 72)]\n",
+    "\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "for i in range(0,10):   \n",
+    "    # We jump the next digit each time we loop\n",
+    "    if i > 0:\n",
+    "        top_left_x = top_left_x + 59\n",
+    "        bottom_right_x = bottom_right_x + 59\n",
+    "\n",
+    "    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "    print(\"Augmenting Digit -\", str(i))\n",
+    "    # We create 200 versions of each image for our dataset\n",
+    "    for j in range(0,2000):\n",
+    "        roi2 = DigitAugmentation(roi)\n",
+    "        roi_otsu = pre_process(roi2, inv = True)\n",
+    "        cv2.imwrite(\"./credit_card/test/\"+str(i)+\"./_1_\"+str(j)+\".jpg\", roi_otsu)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Augmenting Digit -  0\n",
+      "Augmenting Digit -  1\n",
+      "Augmenting Digit -  2\n",
+      "Augmenting Digit -  3\n",
+      "Augmenting Digit -  4\n",
+      "Augmenting Digit -  5\n",
+      "Augmenting Digit -  6\n",
+      "Augmenting Digit -  7\n",
+      "Augmenting Digit -  8\n",
+      "Augmenting Digit -  9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Creating 200 Images for each digit in creditcard_digits2 - TEST DATA\n",
+    "\n",
+    "cc1 = cv2.imread('creditcard_digits2.jpg', 0)\n",
+    "_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
+    "cv2.imshow(\"cc1\", th2)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()\n",
+    "\n",
+    "region = [(0, 0), (35, 48)]\n",
+    "\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "for i in range(0,10):   \n",
+    "    if i > 0:\n",
+    "        # We jump the next digit each time we loop\n",
+    "        top_left_x = top_left_x + 35\n",
+    "        bottom_right_x = bottom_right_x + 35\n",
+    "\n",
+    "    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "    print(\"Augmenting Digit - \", str(i))\n",
+    "    # We create 200 versions of each image for our dataset\n",
+    "    for j in range(0,2000):\n",
+    "        roi2 = DigitAugmentation(roi)\n",
+    "        roi_otsu = pre_process(roi2, inv = False)\n",
+    "        cv2.imwrite(\"./credit_card/test/\"+str(i)+\"./_2_\"+str(j)+\".jpg\", roi_otsu)\n",
+    "        #cv2.imshow(\"otsu\", roi_otsu)\n",
+    "        #print(\"-\")\n",
+    "        #cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. Creating our Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 20254 images belonging to 10 classes.\n",
+      "Found 40000 images belonging to 10 classes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense\n",
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D\n",
+    "from tensorflow.keras import optimizers\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "input_shape = (32, 32, 3)\n",
+    "img_width = 32\n",
+    "img_height = 32\n",
+    "num_classes = 10\n",
+    "nb_train_samples = 10000\n",
+    "nb_validation_samples = 2000\n",
+    "batch_size = 16\n",
+    "epochs = 1\n",
+    "\n",
+    "train_data_dir = './credit_card/train'\n",
+    "validation_data_dir = './credit_card/test'\n",
+    "\n",
+    "# Creating our data generator for our test data\n",
+    "validation_datagen = ImageDataGenerator(\n",
+    "    # used to rescale the pixel values from [0, 255] to [0, 1] interval\n",
+    "    rescale = 1./255)\n",
+    "\n",
+    "# Creating our data generator for our training data\n",
+    "train_datagen = ImageDataGenerator(\n",
+    "      rescale = 1./255,              # normalize pixel values to [0,1]\n",
+    "      rotation_range = 10,           # randomly applies rotations\n",
+    "      width_shift_range = 0.25,       # randomly applies width shifting\n",
+    "      height_shift_range = 0.25,      # randomly applies height shifting\n",
+    "      shear_range=0.5,\n",
+    "      zoom_range=0.5,\n",
+    "      horizontal_flip = False,        # randonly flips the image\n",
+    "      fill_mode = 'nearest')         # uses the fill mode nearest to fill gaps created by the above\n",
+    "\n",
+    "# Specify criteria about our training data, such as the directory, image size, batch size and type \n",
+    "# automagically retrieve images and their classes for train and validation sets\n",
+    "train_generator = train_datagen.flow_from_directory(\n",
+    "        train_data_dir,\n",
+    "        target_size = (img_width, img_height),\n",
+    "        batch_size = batch_size,\n",
+    "        class_mode = 'categorical')\n",
+    "\n",
+    "validation_generator = validation_datagen.flow_from_directory(\n",
+    "        validation_data_dir,\n",
+    "        target_size = (img_width, img_height),\n",
+    "        batch_size = batch_size,\n",
+    "        class_mode = 'categorical',\n",
+    "        shuffle = False)    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating out Model based on the LeNet CNN Architecture"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential_1\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "conv2d_2 (Conv2D)            (None, 32, 32, 20)        1520      \n",
+      "_________________________________________________________________\n",
+      "activation_4 (Activation)    (None, 32, 32, 20)        0         \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_2 (MaxPooling2 (None, 16, 16, 20)        0         \n",
+      "_________________________________________________________________\n",
+      "conv2d_3 (Conv2D)            (None, 16, 16, 50)        25050     \n",
+      "_________________________________________________________________\n",
+      "activation_5 (Activation)    (None, 16, 16, 50)        0         \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_3 (MaxPooling2 (None, 8, 8, 50)          0         \n",
+      "_________________________________________________________________\n",
+      "flatten_1 (Flatten)          (None, 3200)              0         \n",
+      "_________________________________________________________________\n",
+      "dense_2 (Dense)              (None, 500)               1600500   \n",
+      "_________________________________________________________________\n",
+      "activation_6 (Activation)    (None, 500)               0         \n",
+      "_________________________________________________________________\n",
+      "dense_3 (Dense)              (None, 10)                5010      \n",
+      "_________________________________________________________________\n",
+      "activation_7 (Activation)    (None, 10)                0         \n",
+      "=================================================================\n",
+      "Total params: 1,632,080\n",
+      "Trainable params: 1,632,080\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create model\n",
+    "model = Sequential()\n",
+    "\n",
+    "# 2 sets of CRP (Convolution, RELU, Pooling)\n",
+    "model.add(Conv2D(20, (5, 5),\n",
+    "                 padding = \"same\", \n",
+    "                 input_shape = input_shape))\n",
+    "model.add(Activation(\"relu\"))\n",
+    "model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))\n",
+    "\n",
+    "model.add(Conv2D(50, (5, 5),\n",
+    "                 padding = \"same\"))\n",
+    "model.add(Activation(\"relu\"))\n",
+    "model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))\n",
+    "\n",
+    "# Fully connected layers (w/ RELU)\n",
+    "model.add(Flatten())\n",
+    "model.add(Dense(500))\n",
+    "model.add(Activation(\"relu\"))\n",
+    "\n",
+    "# Softmax (for classification)\n",
+    "model.add(Dense(num_classes))\n",
+    "model.add(Activation(\"softmax\"))\n",
+    "           \n",
+    "model.compile(loss = 'categorical_crossentropy',\n",
+    "              optimizer = tf.keras.optimizers.Adadelta(),\n",
+    "              metrics = ['accuracy'])\n",
+    "    \n",
+    "print(model.summary())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training our Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:sample_weight modes were coerced from\n",
+      "  ...\n",
+      "    to  \n",
+      "  ['...']\n",
+      "WARNING:tensorflow:sample_weight modes were coerced from\n",
+      "  ...\n",
+      "    to  \n",
+      "  ['...']\n",
+      "Train for 1250 steps, validate for 250 steps\n",
+      "1249/1250 [============================>.] - ETA: 0s - loss: 0.2923 - accuracy: 0.9020\n",
+      "Epoch 00001: val_loss improved from inf to 0.00030, saving model to creditcard.h5\n",
+      "1250/1250 [==============================] - 150s 120ms/step - loss: 0.2922 - accuracy: 0.9020 - val_loss: 3.0485e-04 - val_accuracy: 1.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.optimizers import RMSprop\n",
+    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
+    "                   \n",
+    "checkpoint = ModelCheckpoint(\"creditcard.h5\",\n",
+    "                             monitor=\"val_loss\",\n",
+    "                             mode=\"min\",\n",
+    "                             save_best_only = True,\n",
+    "                             verbose=1)\n",
+    "\n",
+    "earlystop = EarlyStopping(monitor = 'val_loss', \n",
+    "                          min_delta = 0, \n",
+    "                          patience = 3,\n",
+    "                          verbose = 1,\n",
+    "                          restore_best_weights = True)\n",
+    "\n",
+    "# we put our call backs into a callback list\n",
+    "callbacks = [earlystop, checkpoint]\n",
+    "\n",
+    "# Note we use a very small learning rate \n",
+    "model.compile(loss = 'categorical_crossentropy',\n",
+    "              optimizer = RMSprop(lr = 0.001),\n",
+    "              metrics = ['accuracy'])\n",
+    "\n",
+    "nb_train_samples = 20000\n",
+    "nb_validation_samples = 4000\n",
+    "epochs = 1\n",
+    "batch_size = 16\n",
+    "\n",
+    "history = model.fit_generator(\n",
+    "    train_generator,\n",
+    "    steps_per_epoch = nb_train_samples // batch_size,\n",
+    "    epochs = epochs,\n",
+    "    callbacks = callbacks,\n",
+    "    validation_data = validation_generator,\n",
+    "    validation_steps = nb_validation_samples // batch_size)\n",
+    "\n",
+    "model.save(\"creditcard.h5\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3. Extract a Credit Card from the backgroud\n",
+    "#### NOTE:\n",
+    "You may need to install imutils \n",
+    "run *pip install imutils* in terminal and restart your kernal to install"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting scikit-image\n",
+      "  Downloading scikit_image-0.17.2-cp37-cp37m-win_amd64.whl (11.5 MB)\n",
+      "Requirement already satisfied, skipping upgrade: numpy>=1.15.1 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (1.16.5)\n",
+      "Requirement already satisfied, skipping upgrade: networkx>=2.0 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (2.3)\n",
+      "Requirement already satisfied, skipping upgrade: pillow!=7.1.0,!=7.1.1,>=4.3.0 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (6.2.0)\n",
+      "Requirement already satisfied, skipping upgrade: scipy>=1.0.1 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (1.4.1)\n",
+      "Requirement already satisfied, skipping upgrade: matplotlib!=3.0.0,>=2.0.0 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (3.1.1)\n",
+      "Collecting tifffile>=2019.7.26\n",
+      "  Downloading tifffile-2020.6.3-py3-none-any.whl (133 kB)\n",
+      "Requirement already satisfied, skipping upgrade: imageio>=2.3.0 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from scikit-image) (2.6.0)\n",
+      "Collecting PyWavelets>=1.1.1\n",
+      "  Downloading PyWavelets-1.1.1-cp37-cp37m-win_amd64.whl (4.2 MB)\n",
+      "Requirement already satisfied, skipping upgrade: decorator>=4.3.0 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from networkx>=2.0->scikit-image) (4.4.0)\n",
+      "Requirement already satisfied, skipping upgrade: cycler>=0.10 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image) (0.10.0)\n",
+      "Requirement already satisfied, skipping upgrade: kiwisolver>=1.0.1 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image) (1.1.0)\n",
+      "Requirement already satisfied, skipping upgrade: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image) (2.4.2)\n",
+      "Requirement already satisfied, skipping upgrade: python-dateutil>=2.1 in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image) (2.8.0)\n",
+      "Requirement already satisfied, skipping upgrade: six in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from cycler>=0.10->matplotlib!=3.0.0,>=2.0.0->scikit-image) (1.12.0)\n",
+      "Requirement already satisfied, skipping upgrade: setuptools in c:\\programdata\\anaconda3\\envs\\cv\\lib\\site-packages (from kiwisolver>=1.0.1->matplotlib!=3.0.0,>=2.0.0->scikit-image) (41.4.0)\n",
+      "Installing collected packages: tifffile, PyWavelets, scikit-image\n",
+      "  Attempting uninstall: PyWavelets\n",
+      "    Found existing installation: PyWavelets 1.0.3\n",
+      "    Uninstalling PyWavelets-1.0.3:\n",
+      "      Successfully uninstalled PyWavelets-1.0.3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<pip._vendor.urllib3.connection.VerifiedHTTPSConnection object at 0x000002C6B8509088>: Failed to establish a new connection: [Errno 11001] getaddrinfo failed')': /packages/6e/c7/6411a4ce983bf06db8c3b8093b04b268c2580816f61156a5848e24e97118/scikit_image-0.17.2-cp37-cp37m-win_amd64.whl\n",
+      "ERROR: keras-vis 0.4.1 requires keras, which is not installed.\n",
+      "ERROR: Could not install packages due to an EnvironmentError: [WinError 5] Access is denied: 'c:\\\\programdata\\\\anaconda3\\\\envs\\\\cv\\\\lib\\\\site-packages\\\\~ywt\\\\_extensions\\\\_cwt.cp37-win_amd64.pyd'\n",
+      "Consider using the `--user` option or check the permissions.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -U scikit-image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'filter' from 'skimage' (C:\\ProgramData\\Anaconda3\\envs\\cv\\lib\\site-packages\\skimage\\__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-24-83690ff69298>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mimutils\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m#from skimage.filters import threshold_adaptive\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mskimage\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mfilter\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mImportError\u001b[0m: cannot import name 'filter' from 'skimage' (C:\\ProgramData\\Anaconda3\\envs\\cv\\lib\\site-packages\\skimage\\__init__.py)"
+     ]
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import imutils\n",
+    "#from skimage.filters import threshold_adaptive\n",
+    "from skimage import filter\n",
+    "import os\n",
+    "\n",
+    "def order_points(pts):\n",
+    "    # initialzie a list of coordinates that will be ordered\n",
+    "    # such that the first entry in the list is the top-left,\n",
+    "    # the second entry is the top-right, the third is the\n",
+    "    # bottom-right, and the fourth is the bottom-left\n",
+    "    rect = np.zeros((4, 2), dtype = \"float32\")\n",
+    "\n",
+    "    # the top-left point will have the smallest sum, whereas\n",
+    "    # the bottom-right point will have the largest sum\n",
+    "    s = pts.sum(axis = 1)\n",
+    "    rect[0] = pts[np.argmin(s)]\n",
+    "    rect[2] = pts[np.argmax(s)]\n",
+    "\n",
+    "    # now, compute the difference between the points, the\n",
+    "    # top-right point will have the smallest difference,\n",
+    "    # whereas the bottom-left will have the largest difference\n",
+    "    diff = np.diff(pts, axis = 1)\n",
+    "    rect[1] = pts[np.argmin(diff)]\n",
+    "    rect[3] = pts[np.argmax(diff)]\n",
+    "\n",
+    "    # return the ordered coordinates\n",
+    "    return rect\n",
+    "\n",
+    "def four_point_transform(image, pts):\n",
+    "    # obtain a consistent order of the points and unpack them\n",
+    "    # individually\n",
+    "    rect = order_points(pts)\n",
+    "    (tl, tr, br, bl) = rect\n",
+    "\n",
+    "    # compute the width of the new image, which will be the\n",
+    "    # maximum distance between bottom-right and bottom-left\n",
+    "    # x-coordiates or the top-right and top-left x-coordinates\n",
+    "    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))\n",
+    "    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))\n",
+    "    maxWidth = max(int(widthA), int(widthB))\n",
+    "\n",
+    "    # compute the height of the new image, which will be the\n",
+    "    # maximum distance between the top-right and bottom-right\n",
+    "    # y-coordinates or the top-left and bottom-left y-coordinates\n",
+    "    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))\n",
+    "    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))\n",
+    "    maxHeight = max(int(heightA), int(heightB))\n",
+    "\n",
+    "    # now that we have the dimensions of the new image, construct\n",
+    "    # the set of destination points to obtain a \"birds eye view\",\n",
+    "    # (i.e. top-down view) of the image, again specifying points\n",
+    "    # in the top-left, top-right, bottom-right, and bottom-left\n",
+    "    # order\n",
+    "    dst = np.array([\n",
+    "        [0, 0],\n",
+    "        [maxWidth - 1, 0],\n",
+    "        [maxWidth - 1, maxHeight - 1],\n",
+    "        [0, maxHeight - 1]], dtype = \"float32\")\n",
+    "\n",
+    "    # compute the perspective transform matrix and then apply it\n",
+    "    M = cv2.getPerspectiveTransform(rect, dst)\n",
+    "    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))\n",
+    "\n",
+    "    # return the warped image\n",
+    "    return warped\n",
+    "\n",
+    "def doc_Scan(image):\n",
+    "    orig_height, orig_width = image.shape[:2]\n",
+    "    ratio = image.shape[0] / 500.0\n",
+    "\n",
+    "    orig = image.copy()\n",
+    "    image = imutils.resize(image, height = 500)\n",
+    "    orig_height, orig_width = image.shape[:2]\n",
+    "    Original_Area = orig_height * orig_width\n",
+    "    \n",
+    "    # convert the image to grayscale, blur it, and find edges\n",
+    "    # in the image\n",
+    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
+    "    gray = cv2.GaussianBlur(gray, (5, 5), 0)\n",
+    "    edged = cv2.Canny(gray, 75, 200)\n",
+    "\n",
+    "    cv2.imshow(\"Image\", image)\n",
+    "    cv2.imshow(\"Edged\", edged)\n",
+    "    cv2.waitKey(0)\n",
+    "    # show the original image and the edge detected image\n",
+    "\n",
+    "    # find the contours in the edged image, keeping only the\n",
+    "    # largest ones, and initialize the screen contour\n",
+    "    _, contours, hierarchy  = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\n",
+    "    contours = sorted(contours, key = cv2.contourArea, reverse = True)[:5]\n",
+    "    \n",
+    "    # loop over the contours\n",
+    "    for c in contours:\n",
+    "\n",
+    "        # approximate the contour\n",
+    "        area = cv2.contourArea(c)\n",
+    "        if area < (Original_Area/3):\n",
+    "            print(\"Error Image Invalid\")\n",
+    "            return(\"ERROR\")\n",
+    "        peri = cv2.arcLength(c, True)\n",
+    "        approx = cv2.approxPolyDP(c, 0.02 * peri, True)\n",
+    "\n",
+    "        # if our approximated contour has four points, then we\n",
+    "        # can assume that we have found our screen\n",
+    "        if len(approx) == 4:\n",
+    "            screenCnt = approx\n",
+    "            break\n",
+    "\n",
+    "    # show the contour (outline) of the piece of paper\n",
+    "    cv2.drawContours(image, [screenCnt], -1, (0, 255, 0), 2)\n",
+    "    cv2.imshow(\"Outline\", image)\n",
+    "\n",
+    "    warped = four_point_transform(orig, screenCnt.reshape(4, 2) * ratio)\n",
+    "    # convert the warped image to grayscale, then threshold it\n",
+    "    # to give it that 'black and white' paper effect\n",
+    "    cv2.resize(warped, (640,403), interpolation = cv2.INTER_AREA)\n",
+    "    cv2.imwrite(\"credit_card_color.jpg\", warped)\n",
+    "    warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)\n",
+    "    warped = warped.astype(\"uint8\") * 255\n",
+    "    cv2.imshow(\"Extracted Credit Card\", warped)\n",
+    "    cv2.waitKey(0)\n",
+    "    cv2.destroyAllWindows()\n",
+    "    return warped"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extract our Credit Card and the Region of Interest (ROI)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = cv2.imread('test_card.jpg')\n",
+    "image = doc_Scan(image)\n",
+    "\n",
+    "region = [(55, 210), (640, 290)]\n",
+    "\n",
+    "top_left_y = region[0][1]\n",
+    "bottom_right_y = region[1][1]\n",
+    "top_left_x = region[0][0]\n",
+    "bottom_right_x = region[1][0]\n",
+    "\n",
+    "# Extracting the area were the credit numbers are located\n",
+    "roi = image[top_left_y:bottom_right_y, top_left_x:bottom_right_x]\n",
+    "cv2.imshow(\"Region\", roi)\n",
+    "cv2.imwrite(\"credit_card_extracted_digits.jpg\", roi)\n",
+    "cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading our trained model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.models import load_model\n",
+    "import keras\n",
+    "\n",
+    "classifier = load_model('creditcard.h5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Let's test on our extracted image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n",
+      "3\n",
+      "5\n",
+      "5\n",
+      "2\n",
+      "2\n",
+      "0\n",
+      "3\n",
+      "2\n",
+      "3\n",
+      "9\n",
+      "0\n"
+     ]
+    }
+   ],
+   "source": [
+    "def x_cord_contour(contours):\n",
+    "    #Returns the X cordinate for the contour centroid\n",
+    "    if cv2.contourArea(contours) > 10:\n",
+    "        M = cv2.moments(contours)\n",
+    "        return (int(M['m10']/M['m00']))\n",
+    "    else:\n",
+    "        pass\n",
+    "\n",
+    "img = cv2.imread('credit_card_extracted_digits.jpg')\n",
+    "orig_img = cv2.imread('credit_card_color.jpg')\n",
+    "gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
+    "cv2.imshow(\"image\", img)\n",
+    "cv2.waitKey(0)\n",
+    "\n",
+    "# Blur image then find edges using Canny \n",
+    "blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n",
+    "#cv2.imshow(\"blurred\", blurred)\n",
+    "#cv2.waitKey(0)\n",
+    "\n",
+    "edged = cv2.Canny(blurred, 30, 150)\n",
+    "#cv2.imshow(\"edged\", edged)\n",
+    "#cv2.waitKey(0)\n",
+    "\n",
+    "# Find Contours\n",
+    "_, contours, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
+    "\n",
+    "#Sort out contours left to right by using their x cordinates\n",
+    "contours = sorted(contours, key=cv2.contourArea, reverse=True)[:13] #Change this to 16 to get all digits\n",
+    "contours = sorted(contours, key = x_cord_contour, reverse = False)\n",
+    "\n",
+    "# Create empty array to store entire number\n",
+    "full_number = []\n",
+    "\n",
+    "# loop over the contours\n",
+    "for c in contours:\n",
+    "    # compute the bounding box for the rectangle\n",
+    "    (x, y, w, h) = cv2.boundingRect(c)    \n",
+    "    if w >= 5 and h >= 25 and cv2.contourArea(c) < 1000:\n",
+    "        roi = blurred[y:y + h, x:x + w]\n",
+    "        #ret, roi = cv2.threshold(roi, 20, 255,cv2.THRESH_BINARY_INV)\n",
+    "        cv2.imshow(\"ROI1\", roi)\n",
+    "        roi_otsu = pre_process(roi, True)\n",
+    "        cv2.imshow(\"ROI2\", roi_otsu)\n",
+    "        roi_otsu = cv2.cvtColor(roi_otsu, cv2.COLOR_GRAY2RGB)\n",
+    "        roi_otsu = keras.preprocessing.image.img_to_array(roi_otsu)\n",
+    "        roi_otsu = roi_otsu * 1./255\n",
+    "        roi_otsu = np.expand_dims(roi_otsu, axis=0)\n",
+    "        image = np.vstack([roi_otsu])\n",
+    "        label = str(classifier.predict_classes(image, batch_size = 10))[1]\n",
+    "        print(label)\n",
+    "        (x, y, w, h) = (x+region[0][0], y+region[0][1], w, h)\n",
+    "        cv2.rectangle(orig_img, (x, y), (x + w, y + h), (0, 255, 0), 2)\n",
+    "        cv2.putText(orig_img, label, (x , y + 90), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 255, 0), 2)\n",
+    "        cv2.imshow(\"image\", orig_img)\n",
+    "        cv2.waitKey(0) \n",
+    "        \n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

26. The Computer Vision World/4. Popular Computer Vision Conferences & Finding Datasets.srt

@@ -0,0 +1,127 @@
+1
+00:00:01,180 --> 00:00:07,450
+So welcome to Chapter 25 point to where we talk about some popular API is complete a vision API is provided
+
+2
+00:00:07,450 --> 00:00:08,790
+by these big players here.
+
+3
+00:00:10,650 --> 00:00:16,160
+So what do these computer division API do well and why are they even there.
+
+4
+00:00:16,650 --> 00:00:21,480
+Well if you didn't want to go through all the trouble of creating your own model and deploying it in
+
+5
+00:00:21,480 --> 00:00:26,730
+production and mentoring this and making sure I can scale up properly with traffic you could very well
+
+6
+00:00:26,790 --> 00:00:31,400
+pay pretty low costs to use someone else's complete division API.
+
+7
+00:00:31,710 --> 00:00:38,160
+And there are some very good services out there that provide these features such as object detection
+
+8
+00:00:38,490 --> 00:00:44,900
+face recognition image classification image and station video analysis and text recognition.
+
+9
+00:00:45,090 --> 00:00:46,680
+So let's take a look at what's out there.
+
+10
+00:00:48,910 --> 00:00:54,810
+So these other major popular ones right now Google's cloud vision and Microsoft vision.
+
+11
+00:00:55,050 --> 00:00:59,300
+To me these are the two best ones followed by Amazon and terrifying.
+
+12
+00:00:59,550 --> 00:01:04,570
+I haven't used IBM since visual recognition much but I've heard good things about it.
+
+13
+00:01:04,860 --> 00:01:13,780
+And Chiro's which is excellent for perhaps the best in facial recognition.
+
+14
+00:01:13,800 --> 00:01:18,390
+OK so moving on and we're now into chapter twenty five point three.
+
+15
+00:01:18,950 --> 00:01:25,390
+Basically this is about popular computer vision conferences and a way to find interesting data sets.
+
+16
+00:01:25,400 --> 00:01:31,340
+So these are the big conferences you are going to want to be a wealth CVP is perhaps the biggest one
+
+17
+00:01:31,340 --> 00:01:36,970
+any industry conference in could be the vision and pattern recognition is also Nap's nips is more of
+
+18
+00:01:36,970 --> 00:01:43,940
+a machine than in conference but you see a lot of the groundbreaking CNN image.
+
+19
+00:01:44,210 --> 00:01:49,400
+I guess you can a computer vision type machine learning algorithms being introduced at MIPS.
+
+20
+00:01:49,730 --> 00:01:55,690
+There's also the I c c v and e CCV these Ole's have pretty big as well.
+
+21
+00:01:55,700 --> 00:01:57,560
+So keep an eye on these conferences.
+
+22
+00:01:59,560 --> 00:02:00,710
+And how about this.
+
+23
+00:02:00,730 --> 00:02:03,940
+Where do you find it interesting computer vision data sets.
+
+24
+00:02:03,940 --> 00:02:09,460
+Now I've been looking a lot for discourse and one of the best places I found was Kaggle.
+
+25
+00:02:09,530 --> 00:02:14,350
+There are a lot of Kaggle contests out there with some really really good data sets and some really
+
+26
+00:02:14,350 --> 00:02:16,180
+good community support.
+
+27
+00:02:16,270 --> 00:02:20,120
+So you can actually see what other people have done and interact with them.
+
+28
+00:02:20,140 --> 00:02:27,490
+So it's quite cool these links may also provide some listings of other good data sets you can feel free
+
+29
+00:02:27,490 --> 00:02:28,740
+to try them.
+
+30
+00:02:28,750 --> 00:02:34,390
+There's a lot of good stuff out there so keep exploring and use your knowledge in discourse to create
+
+31
+00:02:34,390 --> 00:02:35,610
+your own classifiers.
+
+32
+00:02:35,680 --> 00:02:39,030
+Or perhaps if you're feeling adventurous create your own data set.

26. The Computer Vision World/5. Building a Deep Learning Machine vs. Cloud GPUs.srt

@@ -0,0 +1,219 @@
+1
+00:00:01,230 --> 00:00:08,750
+And welcome the chapter 25 point four on building depleting machines or do we do it just kludgey Pew's.
+
+2
+00:00:08,790 --> 00:00:10,050
+So let's take a look.
+
+3
+00:00:11,510 --> 00:00:17,330
+So basically I have some hardware recommendations that I've actually learned a lot from the sky on his
+
+4
+00:00:17,330 --> 00:00:17,820
+blog.
+
+5
+00:00:17,960 --> 00:00:21,360
+He basically did a lot of benchmarking with DGP use.
+
+6
+00:00:21,410 --> 00:00:24,260
+So it building on your budget and needs.
+
+7
+00:00:24,440 --> 00:00:26,260
+I have some recommendations for you.
+
+8
+00:00:26,570 --> 00:00:33,620
+Now this is as of November 2013 the best card you can buy for building a deploying machine is a Titan
+
+9
+00:00:33,640 --> 00:00:40,640
+V from Nvidia and you're only going to want to buy Nvidia cards since only Nvidia supports kuda which
+
+10
+00:00:40,640 --> 00:00:41,820
+is used in deploying.
+
+11
+00:00:41,820 --> 00:00:49,490
+It basically accelerated tremendously accelerate our depleting algorithms on Gippi use.
+
+12
+00:00:49,520 --> 00:00:54,570
+So the best consumer card that you can buy though because the Tyson V is a basically a pro user card
+
+13
+00:00:55,280 --> 00:00:59,940
+that's consumer level called game card is the TR x 28.
+
+14
+00:01:00,320 --> 00:01:03,360
+So awesome video card games and for deep cleaning.
+
+15
+00:01:03,360 --> 00:01:05,850
+So at this price it better be awesome.
+
+16
+00:01:05,850 --> 00:01:13,440
+At 12 mentioned US and if you want to go people get it RTX 2070 half the price and it's also very good
+
+17
+00:01:14,100 --> 00:01:16,370
+in the next slide you'll see the benchmark figures here.
+
+18
+00:01:16,740 --> 00:01:21,560
+And the best budget invalid GP is still the GTX 10:52 II.
+
+19
+00:01:21,840 --> 00:01:26,600
+A call actually was going to buy two years ago.
+
+20
+00:01:26,820 --> 00:01:32,460
+So some other recommendations to always make sure you have at least 16 gigs from because when you are
+
+21
+00:01:32,460 --> 00:01:39,270
+losing a data sets and doing a lot of pre-processing that's done in around not in GP you memory yet.
+
+22
+00:01:39,270 --> 00:01:47,490
+So you still need a lot of from also an SSD will help a lot when you're doing a lot of data processing.
+
+23
+00:01:47,490 --> 00:01:54,130
+All us know that and what you should be aware of is that while these are quite good they don't have
+
+24
+00:01:54,130 --> 00:01:55,590
+a lot of storage space.
+
+25
+00:01:55,690 --> 00:02:00,010
+So if you're dealing with super large image assets you're going to want to have a large harddrive to
+
+26
+00:02:00,010 --> 00:02:02,480
+just dump these assets after you create them.
+
+27
+00:02:03,830 --> 00:02:05,530
+And lastly you do need a CPA.
+
+28
+00:02:05,550 --> 00:02:12,320
+You know I think most modern DCP is a cost of 100 US are going to be fast enough.
+
+29
+00:02:12,510 --> 00:02:15,310
+However just make sure it's at least a quad core.
+
+30
+00:02:15,450 --> 00:02:24,170
+M.D. reizen line is very good as well as pretty much any modern i 5 7 0 9 by Intel.
+
+31
+00:02:24,180 --> 00:02:26,750
+So these are some GP performance charts here.
+
+32
+00:02:26,790 --> 00:02:33,170
+So this is Google's T-P you specialize in the cloud can see they actually provide by far the best performance.
+
+33
+00:02:33,210 --> 00:02:41,040
+However look at the Titan V that is actually very close and it's relatively affordable if you're a serious
+
+34
+00:02:41,040 --> 00:02:42,320
+Duplin.
+
+35
+00:02:43,140 --> 00:02:45,600
+Now what about RTX 28:18.
+
+36
+00:02:45,950 --> 00:02:48,690
+It is very very close to Tyson V.
+
+37
+00:02:48,810 --> 00:02:51,510
+So I would definitely buy discard overtighten Wii.
+
+38
+00:02:52,230 --> 00:02:56,270
+And as you can see performance is denormalized performance here.
+
+39
+00:02:56,520 --> 00:02:59,870
+It probably gets decent around the same.
+
+40
+00:03:00,150 --> 00:03:04,690
+So if I were you would probably get a GTX 10 HDI D-I.
+
+41
+00:03:05,170 --> 00:03:14,100
+Or if you if you don't want to spend that much the GTX 10 70 is actually a very good car attendee and
+
+42
+00:03:14,100 --> 00:03:14,840
+this is a performance.
+
+43
+00:03:14,850 --> 00:03:22,260
+But all it can see the RTX 2070 coming up on top next would be the GTX 10 60 and discards here.
+
+44
+00:03:26,290 --> 00:03:31,720
+So there are also a number of places where we can find a cloud GP as is AWOS Google.
+
+45
+00:03:31,740 --> 00:03:37,420
+How does all tons of them actually and most of their rates are relatively affordable.
+
+46
+00:03:37,420 --> 00:03:40,140
+Some saw as little as 20 cents per hour.
+
+47
+00:03:40,150 --> 00:03:45,490
+However if you think about it if you're if you're a serious guy who's going to train models for days
+
+48
+00:03:45,490 --> 00:03:49,130
+a week sometimes you don't want to be doing this continuously.
+
+49
+00:03:49,180 --> 00:03:55,660
+So you may actually want to invest in something affordable like this or perhaps one of these cards here.
+
+50
+00:03:56,200 --> 00:03:57,540
+Not this one or this one.
+
+51
+00:03:57,550 --> 00:04:02,180
+Probably these and that's mainly because of price.
+
+52
+00:04:02,180 --> 00:04:09,440
+By the way however one of the best places I've seen for good value and good clergy abuse.
+
+53
+00:04:09,760 --> 00:04:12,570
+As of November 20 it is paper space.
+
+54
+00:04:12,700 --> 00:04:16,230
+Go to the site and check it out they're actually very easy to use.
+
+55
+00:04:16,240 --> 00:04:21,200
+Got some very good tutorials and their prices are some of the cheapest online that I've seen.

27. BONUS - Build a Credit Card Number Reader/1. Step 1 - Creating a Credit Card Number Dataset.html

@@ -0,0 +1,246 @@
+<h4><strong>Step 1 - Exploring the Credit Card Font</strong></h4><p><br></p><p><strong>NOTE</strong>: Download all code in resources</p><p><strong>Open the file titled: </strong><code><strong><em>Credit Card Reader.ipynb</em></strong></code></p><p>Unfortunately, there isn't an official standard credit card number font - some of the fonts used go by the names <strong>Farrington 7B</strong>, <strong>OCR-B</strong>, <strong>SecurePay</strong>, <strong>OCR-A</strong> and <strong>MICR E13B. </strong>However, in my experience there seem to be two main font variations used in credit cards:</p><p><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_05-56-32-af03064a01e050776ae191c8c61fb2aa.jpg"></p><p>and</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_05-56-51-ac5823c68461a928b659677c5d7b438f.jpg"></figure><p>Note the differences, especially in the 1, 7 and 8.</p><p><br></p><p>Let's open these images in Python using OpenCV</p><pre class="prettyprint linenums">import cv2
+
+cc1 = cv2.imread('creditcard_digits1.jpg', 0)
+cv2.imshow("Digits 1", cc1)
+cv2.waitKey(0)
+cc2 = cv2.imread('creditcard_digits2.jpg', 0)
+cv2.imshow("Digits 2", cc2)
+cv2.waitKey(0)
+cv2.destroyAllWindows()</pre><p><br></p><p>Let's experiment with testing OTSU Binarization. Remember binarization converts a grayscale image to two colors, black and white. Values under a certain threshold (typically 127  out of 255) are clipped to 0, while the values greater than 127 are clipped to 255. It looks like this below. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-00-29-855d880d0b635790c33d3f0402f8158f.JPG"></figure><p>The code to perform this is:</p><pre class="prettyprint linenums">cc1 = cv2.imread('creditcard_digits2.jpg', 0)
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+cv2.imshow("Digits 2 Thresholded", th2)
+cv2.waitKey(0)
+    
+cv2.destroyAllWindows()</pre><p><br></p><h4><strong>Step 2 - Creating our Dataset Directories</strong></h4><p>This sets up our training and test directories for the digits (0 to 9).</p><pre class="prettyprint linenums">#Create our dataset directories
+
+import os
+
+def makedir(directory):
+    """Creates a new directory if it does not exist"""
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+        return None, 0
+    
+for i in range(0,10):
+    directory_name = "./credit_card/train/"+str(i)
+    print(directory_name)
+    makedir(directory_name) 
+
+for i in range(0,10):
+    directory_name = "./credit_card/test/"+str(i)
+    print(directory_name)
+    makedir(directory_name)</pre><h4></h4><h4><strong>Step 3 - Creating our Data Augmentation Functions</strong></h4><p>Let's now create some functions to create more data. What we're doing here is taking the two samples of each digit we saw above, and adding small variations to the digit. This is very similar to Keras's Data Augmentation, however, we're using OpenCV to create an augmented dataset instead. We will further use Keras to Augment this even further. </p><p>We've created 5 functions here, let's discuss each: </p><ul><li><p><strong><em>DigitAugmentation()</em></strong> - This one simply uses the other image manipulating functions, but calls them randomly. Examine to code to see how it's done.</p></li><li><p><strong><em>add_noise() </em>-</strong> This function introduces some noise elements to the image</p></li><li><p><strong><em>pixelate()</em></strong> - This function re-sizes the image then upscales/upsamples it. This degrades the quality and is meant to simulate blur to the image from either a shakey or poor quality camera. </p></li><li><p><strong><em>stretch() </em></strong>- This simulates some variation in re-sizing where it stretches the image to a small random amount</p></li><li><p>pre_process() - This is a simple function that applies OTSU Binarization to the image and re-sizes it. We use this on the extracted digits. To create a clean dataset akin to the MNIST style format. </p><p><br></p></li></ul><pre class="prettyprint linenums">import cv2
+import numpy as np 
+import random
+import cv2
+from scipy.ndimage import convolve
+
+def DigitAugmentation(frame, dim = 32):
+    """Randomly alters the image using noise, pixelation and streching image functions"""
+    frame = cv2.resize(frame, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC)
+    frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
+    random_num = np.random.randint(0,9)
+
+    if (random_num % 2 == 0):
+        frame = add_noise(frame)
+    if(random_num % 3 == 0):
+        frame = pixelate(frame)
+    if(random_num % 2 == 0):
+        frame = stretch(frame)
+    frame = cv2.resize(frame, (dim, dim), interpolation = cv2.INTER_AREA)
+
+    return frame 
+
+def add_noise(image):
+    """Addings noise to image"""
+    prob = random.uniform(0.01, 0.05)
+    rnd = np.random.rand(image.shape[0], image.shape[1])
+    noisy = image.copy()
+    noisy[rnd &lt; prob] = 0
+    noisy[rnd &gt; 1 - prob] = 1
+    return noisy
+
+def pixelate(image):
+    "Pixelates an image by reducing the resolution then upscaling it"
+    dim = np.random.randint(8,12)
+    image = cv2.resize(image, (dim, dim), interpolation = cv2.INTER_AREA)
+    image = cv2.resize(image, (16, 16), interpolation = cv2.INTER_AREA)
+    return image
+
+def stretch(image):
+    "Randomly applies different degrees of stretch to image"
+    ran = np.random.randint(0,3)*2
+    if np.random.randint(0,2) == 0:
+        frame = cv2.resize(image, (32, ran+32), interpolation = cv2.INTER_AREA)
+        return frame[int(ran/2):int(ran+32)-int(ran/2), 0:32]
+    else:
+        frame = cv2.resize(image, (ran+32, 32), interpolation = cv2.INTER_AREA)
+        return frame[0:32, int(ran/2):int(ran+32)-int(ran/2)]
+    
+def pre_process(image, inv = False):
+    """Uses OTSU binarization on an image"""
+    try:
+        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    except:
+        gray_image = image
+        pass
+    
+    if inv == False:
+        _, th2 = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    else:
+        _, th2 = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    resized = cv2.resize(th2, (32,32), interpolation = cv2.INTER_AREA)
+    return resized
+</pre><p>We can test our augmentation by using this bit of code:</p><pre class="prettyprint linenums">cc1 = cv2.imread('creditcard_digits2.jpg', 0)
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+cv2.imshow("cc1", th2)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+# This is the coordinates of the region enclosing  the first digit
+# This is preset and was done manually based on this specific image
+region = [(0, 0), (35, 48)]
+
+# Assigns values to each region for ease of interpretation
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+for i in range(0,1): #We only look at the first digit in testing out augmentation functions
+    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+    for j in range(0,10):
+        roi2 = DigitAugmentation(roi)
+        roi_otsu = pre_process(roi2, inv = False)
+        cv2.imshow("otsu", roi_otsu)
+        cv2.waitKey(0)
+        
+cv2.destroyAllWindows()</pre><p>Typically it looks like this:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-11-17-38e732423b5d5dcecc18371c022619eb.JPG"></figure><p><br></p><p>You can try more adventurous forms of varying the original image. My suggestion would be to try dilation and erosion on these. </p><h4><strong>Step 4 - Creating our dataset</strong></h4><p>Let's create 1000 variations of the first font we're sampling (note 1000 is perhaps way too much, but the data sizes were small and quick to train so why not use the arbitrary number of 1000).</p><pre class="prettyprint linenums"># Creating 2000 Images for each digit in creditcard_digits1 - TRAINING DATA
+
+# Load our first image
+cc1 = cv2.imread('creditcard_digits1.jpg', 0)
+
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+cv2.imshow("cc1", th2)
+cv2.imshow("creditcard_digits1", cc1)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+region = [(2, 19), (50, 72)]
+
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+for i in range(0,10):   
+    # We jump the next digit each time we loop
+    if i &gt; 0:
+        top_left_x = top_left_x + 59
+        bottom_right_x = bottom_right_x + 59
+
+    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+    print("Augmenting Digit - ", str(i))
+    # We create 200 versions of each image for our dataset
+    for j in range(0,2000):
+        roi2 = DigitAugmentation(roi)
+        roi_otsu = pre_process(roi2, inv = True)
+        cv2.imwrite("./credit_card/train/"+str(i)+"./_1_"+str(j)+".jpg", roi_otsu)
+cv2.destroyAllWindows()
+
+</pre><p>Next, let's make 1000 variations to each digit of the second font type.</p><pre class="prettyprint linenums"># Creating 2000 Images for each digit in creditcard_digits2 - TRAINING DATA
+
+cc1 = cv2.imread('creditcard_digits2.jpg', 0)
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+cv2.imshow("cc1", th2)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+region = [(0, 0), (35, 48)]
+
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+for i in range(0,10):   
+    if i &gt; 0:
+        # We jump the next digit each time we loop
+        top_left_x = top_left_x + 35
+        bottom_right_x = bottom_right_x + 35
+
+    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+    print("Augmenting Digit - ", str(i))
+    # We create 200 versions of each image for our dataset
+    for j in range(0,2000):
+        roi2 = DigitAugmentation(roi)
+        roi_otsu = pre_process(roi2, inv = False)
+        cv2.imwrite("./credit_card/train/"+str(i)+"./_2_"+str(j)+".jpg", roi_otsu)
+        cv2.imshow("otsu", roi_otsu)
+        print("-")
+        cv2.waitKey(0)
+
+cv2.destroyAllWindows()</pre><p><br></p><p><strong>Making our Test Data </strong></p><p>- Note is a VERY bad practice to create a test dataset like this. Even though we're adding random variations, our test data here is too similar to our training data. Ideally, you'd want to use some real life unseen data from another source. In our case, we're sampling for the same dataset.</p><pre class="prettyprint linenums"># Creating 200 Images for each digit in creditcard_digits1 - TEST DATA
+
+# Load our first image
+cc1 = cv2.imread('creditcard_digits1.jpg', 0)
+
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+cv2.imshow("cc1", th2)
+cv2.imshow("creditcard_digits1", cc1)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+region = [(2, 19), (50, 72)]
+
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+for i in range(0,10):   
+    # We jump the next digit each time we loop
+    if i &gt; 0:
+        top_left_x = top_left_x + 59
+        bottom_right_x = bottom_right_x + 59
+
+    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+    print("Augmenting Digit - ", str(i))
+    # We create 200 versions of each image for our dataset
+    for j in range(0,2000):
+        roi2 = DigitAugmentation(roi)
+        roi_otsu = pre_process(roi2, inv = True)
+        cv2.imwrite("./credit_card/test/"+str(i)+"./_1_"+str(j)+".jpg", roi_otsu)
+cv2.destroyAllWindows()</pre><pre class="prettyprint linenums"># Creating 200 Images for each digit in creditcard_digits2 - TEST DATA
+
+cc1 = cv2.imread('creditcard_digits2.jpg', 0)
+_, th2 = cv2.threshold(cc1, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+cv2.imshow("cc1", th2)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+region = [(0, 0), (35, 48)]
+
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+for i in range(0,10):   
+    if i &gt; 0:
+        # We jump the next digit each time we loop
+        top_left_x = top_left_x + 35
+        bottom_right_x = bottom_right_x + 35
+
+    roi = cc1[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+    print("Augmenting Digit - ", str(i))
+    # We create 200 versions of each image for our dataset
+    for j in range(0,2000):
+        roi2 = DigitAugmentation(roi)
+        roi_otsu = pre_process(roi2, inv = False)
+        cv2.imwrite("./credit_card/test/"+str(i)+"./_2_"+str(j)+".jpg", roi_otsu)
+        cv2.imshow("otsu", roi_otsu)
+        print("-")
+        cv2.waitKey(0)
+cv2.destroyAllWindows()
+</pre><p><br></p>

27. BONUS - Build a Credit Card Number Reader/1.1 Download Credit Card Files and Data.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1bMcHna6h6YWDmMQm1XYedYVcEPXJ_S3v/view?usp=sharing";</script>

27. BONUS - Build a Credit Card Number Reader/2. Step 2 - Training Our Model.html

@@ -0,0 +1,116 @@
+<h4><strong>Creating our Classifier in Keras</strong></h4><p>Now that we have our dataset we can dive in your  using the Keras code you're now so familiar with :)</p><p>Let's now take advantage of Keras's Data Augmentation and apply some small rotations, shifts, shearing and zooming. </p><p><br></p><pre class="prettyprint linenums">import os
+import numpy as np
+from keras.models import Sequential
+from keras.layers import Activation, Dropout, Flatten, Dense
+from keras.preprocessing.image import ImageDataGenerator
+from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
+from keras import optimizers
+import keras
+
+input_shape = (32, 32, 3)
+img_width = 32
+img_height = 32
+num_classes = 10
+nb_train_samples = 10000
+nb_validation_samples = 2000
+batch_size = 16
+epochs = 1
+
+train_data_dir = './credit_card/train'
+validation_data_dir = './credit_card/test'
+
+# Creating our data generator for our test data
+validation_datagen = ImageDataGenerator(
+    # used to rescale the pixel values from [0, 255] to [0, 1] interval
+    rescale = 1./255)
+
+# Creating our data generator for our training data
+train_datagen = ImageDataGenerator(
+      rescale = 1./255,              # normalize pixel values to [0,1]
+      rotation_range = 10,           # randomly applies rotations
+      width_shift_range = 0.25,       # randomly applies width shifting
+      height_shift_range = 0.25,      # randomly applies height shifting
+      shear_range=0.5,
+      zoom_range=0.5,
+      horizontal_flip = False,        # randonly flips the image
+      fill_mode = 'nearest')         # uses the fill mode nearest to fill gaps created by the above
+
+# Specify criteria about our training data, such as the directory, image size, batch size and type 
+# automagically retrieve images and their classes for train and validation sets
+train_generator = train_datagen.flow_from_directory(
+        train_data_dir,
+        target_size = (img_width, img_height),
+        batch_size = batch_size,
+        class_mode = 'categorical')
+
+validation_generator = validation_datagen.flow_from_directory(
+        validation_data_dir,
+        target_size = (img_width, img_height),
+        batch_size = batch_size,
+        class_mode = 'categorical',
+        shuffle = False)    </pre><p><strong>Let's use the effective and famous (on MNIST) LeNET Convolutional Neural Network Architecture</strong></p><pre class="prettyprint linenums"># create model
+model = Sequential()
+
+# 2 sets of CRP (Convolution, RELU, Pooling)
+model.add(Conv2D(20, (5, 5),
+                 padding = "same", 
+                 input_shape = input_shape))
+model.add(Activation("relu"))
+model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
+
+model.add(Conv2D(50, (5, 5),
+                 padding = "same"))
+model.add(Activation("relu"))
+model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
+
+# Fully connected layers (w/ RELU)
+model.add(Flatten())
+model.add(Dense(500))
+model.add(Activation("relu"))
+
+# Softmax (for classification)
+model.add(Dense(num_classes))
+model.add(Activation("softmax"))
+           
+model.compile(loss = 'categorical_crossentropy',
+              optimizer = keras.optimizers.Adadelta(),
+              metrics = ['accuracy'])
+    
+print(model.summary())
+</pre><p><strong>And now let's train our model for 5 EPOCHS.</strong></p><pre class="prettyprint linenums">from keras.optimizers import RMSprop
+from keras.callbacks import ModelCheckpoint, EarlyStopping
+                   
+checkpoint = ModelCheckpoint("/home/deeplearningcv/DeepLearningCV/Trained Models/creditcard.h5",
+                             monitor="val_loss",
+                             mode="min",
+                             save_best_only = True,
+                             verbose=1)
+
+earlystop = EarlyStopping(monitor = 'val_loss', 
+                          min_delta = 0, 
+                          patience = 3,
+                          verbose = 1,
+                          restore_best_weights = True)
+
+# we put our call backs into a callback list
+callbacks = [earlystop, checkpoint]
+
+# Note we use a very small learning rate 
+model.compile(loss = 'categorical_crossentropy',
+              optimizer = RMSprop(lr = 0.001),
+              metrics = ['accuracy'])
+
+nb_train_samples = 20000
+nb_validation_samples = 4000
+epochs = 5
+batch_size = 16
+
+history = model.fit_generator(
+    train_generator,
+    steps_per_epoch = nb_train_samples // batch_size,
+    epochs = epochs,
+    callbacks = callbacks,
+    validation_data = validation_generator,
+    validation_steps = nb_validation_samples // batch_size)
+
+model.save("/home/deeplearningcv/DeepLearningCV/Trained Models/creditcard.h5")</pre><p><br></p><p>Perfect, now you have an extremely accurate (on our limited test data) model. </p><p><br></p><p><strong>In the next section we will build a Credit Card Extractor using OpenCV</strong></p>

27. BONUS - Build a Credit Card Number Reader/3. Step 3 - Extracting A Credit Card from the Background.html

@@ -0,0 +1,139 @@
+<h4><strong>Extracting a Credit Card</strong></h4><p><br></p><p><strong>NOTE</strong>: This example extracts only 12 of the 16 digits because, this is a working credit card :) </p><p><br></p><p>The code below does contains the functions we use to do the following:</p><p><br></p><p>1. It loads the image, image we're using our mobile phone camera to take this picture. (Note: ideally place the card on a contrasting background)</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-31-06-6e0ea340958fbce841a07b78d48215f2.JPG"></figure><p>2. We use Canny Edge detection to identify the edges of card</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-31-32-83ee0c50b79d9008b9823bfa98da7be9.JPG"></figure><p>3. We using cv2.findContours() to extract the largest contour (which we assume will be the credit card)</p><p><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-31-14-fee84b836e81142e2829fb266dec2244.JPG"></p><p>4. This is where we use the function <strong>four_point_transform() </strong>and <strong>order_points() </strong>to adjust the perspective of the card. It creates a top-down type view that is useful because:</p><ul><li><p>It standardizes the view of the card so that the credit card digits are always roughly in the same area.</p></li><li><p>It removes/reduces skew and warped perspectives from the image when taken from a camera. All cameras unless taken exactly top down, will introduce some skew to text/digits. This is why scanners always produce more realistic looking images.</p></li></ul><figure><img height="214" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-31-39-48dc83992e0158333fdffecfbeeaf78b.JPG" width="340"><img height="214" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-31-44-5c9e8bd1c39030b2f38f2dd72936c08d.JPG" width="341"></figure><pre class="prettyprint linenums">import cv2
+import numpy as np
+import imutils
+from skimage.filters import threshold_adaptive
+import os
+
+def order_points(pts):
+    # initialize a list of coordinates that will be ordered
+    # such that the first entry in the list is the top-left,
+    # the second entry is the top-right, the third is the
+    # bottom-right, and the fourth is the bottom-left
+    rect = np.zeros((4, 2), dtype = "float32")
+
+    # the top-left point will have the smallest sum, whereas
+    # the bottom-right point will have the largest sum
+    s = pts.sum(axis = 1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+
+    # now, compute the difference between the points, the
+    # top-right point will have the smallest difference,
+    # whereas the bottom-left will have the largest difference
+    diff = np.diff(pts, axis = 1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+
+    # return the ordered coordinates
+    return rect
+
+def four_point_transform(image, pts):
+    # obtain a consistent order of the points and unpack them
+    # individually
+    rect = order_points(pts)
+    (tl, tr, br, bl) = rect
+
+    # compute the width of the new image, which will be the
+    # maximum distance between bottom-right and bottom-left
+    # x-coordinates or the top-right and top-left x-coordinates
+    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
+    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
+    maxWidth = max(int(widthA), int(widthB))
+
+    # compute the height of the new image, which will be the
+    # maximum distance between the top-right and bottom-right
+    # y-coordinates or the top-left and bottom-left y-coordinates
+    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
+    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
+    maxHeight = max(int(heightA), int(heightB))
+
+    # now that we have the dimensions of the new image, construct
+    # the set of destination points to obtain a "birds eye view",
+    # (i.e. top-down view) of the image, again specifying points
+    # in the top-left, top-right, bottom-right, and bottom-left
+    # order
+    dst = np.array([
+        [0, 0],
+        [maxWidth - 1, 0],
+        [maxWidth - 1, maxHeight - 1],
+        [0, maxHeight - 1]], dtype = "float32")
+
+    # compute the perspective transform matrix and then apply it
+    M = cv2.getPerspectiveTransform(rect, dst)
+    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
+
+    # return the warped image
+    return warped
+
+def doc_Scan(image):
+    orig_height, orig_width = image.shape[:2]
+    ratio = image.shape[0] / 500.0
+
+    orig = image.copy()
+    image = imutils.resize(image, height = 500)
+    orig_height, orig_width = image.shape[:2]
+    Original_Area = orig_height * orig_width
+    
+    # convert the image to grayscale, blur it, and find edges
+    # in the image
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    gray = cv2.GaussianBlur(gray, (5, 5), 0)
+    edged = cv2.Canny(gray, 75, 200)
+
+    cv2.imshow("Image", image)
+    cv2.imshow("Edged", edged)
+    cv2.waitKey(0)
+    # show the original image and the edge detected image
+
+    # find the contours in the edged image, keeping only the
+    # largest ones, and initialize the screen contour
+    _, contours, hierarchy  = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    contours = sorted(contours, key = cv2.contourArea, reverse = True)[:5]
+    
+    # loop over the contours
+    for c in contours:
+
+        # approximate the contour
+        area = cv2.contourArea(c)
+        if area &lt; (Original_Area/3):
+            print("Error Image Invalid")
+            return("ERROR")
+        peri = cv2.arcLength(c, True)
+        approx = cv2.approxPolyDP(c, 0.02 * peri, True)
+
+        # if our approximated contour has four points, then we
+        # can assume that we have found our screen
+        if len(approx) == 4:
+            screenCnt = approx
+            break
+
+    # show the contour (outline) of the piece of paper
+    cv2.drawContours(image, [screenCnt], -1, (0, 255, 0), 2)
+    cv2.imshow("Outline", image)
+
+    warped = four_point_transform(orig, screenCnt.reshape(4, 2) * ratio)
+    # convert the warped image to grayscale, then threshold it
+    # to give it that 'black and white' paper effect
+    cv2.resize(warped, (640,403), interpolation = cv2.INTER_AREA)
+    cv2.imwrite("credit_card_color.jpg", warped)
+    warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
+    warped = warped.astype("uint8") * 255
+    cv2.imshow("Extracted Credit Card", warped)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+    return warped</pre><p><br></p><p>We now need to extract the credit card number region. If you looked at the code in the above example we are always re-sizing our extracted credit card image to a size of 640 x 403. The odd choice of 403 was chosen because 640:403 is the actual ratio of a credit card. We are trying to maintain as accurate as possible the length and width dimensions so that we don't necessarily warp the image too much.</p><p><strong>NOTE</strong>: I know we're re-sizing all extracted digits to 32 x 32, but even still keeping the initial ratio correct will only help our classifier accuracy. </p><p><br></p><p>As such, because of the fixed size, we can now extract the region ([(55, 210), (640, 290)]) easily from our image. </p><pre class="prettyprint linenums">image = cv2.imread('test_card.jpg')
+image = doc_Scan(image)
+
+region = [(55, 210), (640, 290)]
+
+top_left_y = region[0][1]
+bottom_right_y = region[1][1]
+top_left_x = region[0][0]
+bottom_right_x = region[1][0]
+
+# Extracting the area were the credit numbers are located
+roi = image[top_left_y:bottom_right_y, top_left_x:bottom_right_x]
+cv2.imshow("Region", roi)
+cv2.imwrite("credit_card_extracted_digits.jpg", roi)
+cv2.waitKey(0)
+cv2.destroyAllWindows()</pre><p>This is what our extracted region looks like.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-42-43-3d2f27840197bd5ff18b47aa759b74b4.JPG"></figure><p>In the next section, we're going to using some OpenCV techniques to extract each digit and pass it to our classifier for identification. </p>

27. BONUS - Build a Credit Card Number Reader/4. Step 4 - Use our Model to Identify the Digits & Display it onto our Credit Card.html

@@ -0,0 +1,60 @@
+<h4><strong>Classifying Digits on a real Credit Card</strong></h4><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-46-01-1309a41efbd20f05579ceca7b62c163b.JPG"></figure><p>In this section we're going to write the code to make the above!</p><p>Firstly, let's load the model we created by:</p><pre class="prettyprint linenums">from keras.models import load_model
+import keras
+
+classifier = load_model('/home/deeplearningcv/DeepLearningCV/Trained Models/creditcard.h5')</pre><p><br></p><p>Now let's do some OpenCV magic and extract the digits from the image below:</p><p> </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-04_06-47-23-51bd1976506279715b6324297b86b22b.JPG"></figure><p>The algorithm we follow to do this is really quite simple:</p><ol><li><p>We first load our grayscale extracted image and the original color (note we could have just loaded the color and grayscaled it)</p></li><li><p>We apply the Canny Edge algorithm (typically we apply blur first to reduce noise in finding the edges). </p></li><li><p>We then use findCountours to isolate the digits</p></li><li><p>We sort the contours by size (so that smaller irrelevant contours aren't used)</p></li><li><p>We then sort it left to right by creating a function that returns the x-cordinate of a contour. </p></li><li><p>Once we have our cleaned up contours, we find the bounding rectange of the contour which gives us an enclosed rectangle around the digit. (To ensure these contours are valid we do extract only contours meeting the minimum width and height expectations). Also because I've created a black square around the last 4 digits, we discard contours of large area so that it isn't fed into our classifier. </p></li><li><p>We then take each extracted digit, use our pre_processing function (which applies OTSU Binarization and re-sizes it) then breakdown that image array so that it can be loaded into our classifier.</p></li></ol><p>The full code to do this is shown below:</p><pre class="prettyprint linenums">def x_cord_contour(contours):
+    #Returns the X cordinate for the contour centroid
+    if cv2.contourArea(contours) &gt; 10:
+        M = cv2.moments(contours)
+        return (int(M['m10']/M['m00']))
+    else:
+        pass
+
+img = cv2.imread('credit_card_extracted_digits.jpg')
+orig_img = cv2.imread('credit_card_color.jpg')
+gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+cv2.imshow("image", img)
+cv2.waitKey(0)
+
+# Blur image then find edges using Canny 
+blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+#cv2.imshow("blurred", blurred)
+#cv2.waitKey(0)
+
+edged = cv2.Canny(blurred, 30, 150)
+#cv2.imshow("edged", edged)
+#cv2.waitKey(0)
+
+# Find Contours
+_, contours, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+#Sort out contours left to right by using their x cordinates
+contours = sorted(contours, key=cv2.contourArea, reverse=True)[:13] #Change this to 16 to get all digits
+contours = sorted(contours, key = x_cord_contour, reverse = False)
+
+# Create empty array to store entire number
+full_number = []
+
+# loop over the contours
+for c in contours:
+    # compute the bounding box for the rectangle
+    (x, y, w, h) = cv2.boundingRect(c)    
+    if w &gt;= 5 and h &gt;= 25 and cv2.contourArea(c) &lt; 1000:
+        roi = blurred[y:y + h, x:x + w]
+        #ret, roi = cv2.threshold(roi, 20, 255,cv2.THRESH_BINARY_INV)
+        cv2.imshow("ROI1", roi)
+        roi_otsu = pre_process(roi, True)
+        cv2.imshow("ROI2", roi_otsu)
+        roi_otsu = cv2.cvtColor(roi_otsu, cv2.COLOR_GRAY2RGB)
+        roi_otsu = keras.preprocessing.image.img_to_array(roi_otsu)
+        roi_otsu = roi_otsu * 1./255
+        roi_otsu = np.expand_dims(roi_otsu, axis=0)
+        image = np.vstack([roi_otsu])
+        label = str(classifier.predict_classes(image, batch_size = 10))[1]
+        print(label)
+        (x, y, w, h) = (x+region[0][0], y+region[0][1], w, h)
+        cv2.rectangle(orig_img, (x, y), (x + w, y + h), (0, 255, 0), 2)
+        cv2.putText(orig_img, label, (x , y + 90), cv2.FONT_HERSHEY_COMPLEX, 2, (255, 0, 0), 2)
+        cv2.imshow("image", orig_img)
+        cv2.waitKey(0) 
+        
+cv2.destroyAllWindows()</pre>

28. BONUS - Use Cloud GPUs on PaperSpace/1. Why use Cloud GPUs and How to Setup a PaperSpace Gradient Notebook.html

@@ -0,0 +1 @@
+<h4><strong>Why GPU's are better for Deep Learning</strong> </h4><p><a href="https://www.quora.com/Why-are-GPUs-well-suited-to-deep-learning" rel="noopener noreferrer" target="_blank">https://www.quora.com/Why-are-GPUs-well-suited-to-deep-learning</a></p><p><br></p><p>As many have said GPUs are so fast because they are so efficient for matrix multiplication and convolution, but nobody gave a real explanation for why this is so. The real reason for this is memory bandwidth and not necessarily parallelism.</p><p>First of all, you have to understand that CPUs are latency optimized while GPUs are bandwidth optimized. You can visualize this as a CPU being a Ferrari and a GPU being a big truck. The task of both is to pick up packages from a random location A and to transport those packages to another random location B. The CPU (Ferrari) can fetch some memory (packages) in your RAM quickly while the GPU (big truck) is slower in doing that (much higher latency). However, the CPU (Ferrari) needs to go back and forth many times to do its job (location A $\rightarrow$ pick up 2 packages $\rightarrow$ location B ... repeat) while the GPU can fetch much more memory at once (location A $\rightarrow$ pick up 100 packages $\rightarrow$ location B ... repeat).</p><p>So, in other words, the CPU is good at fetching small amounts of memory quickly (5 * 3 * 7) while the GPU is good at fetching large amounts of memory (Matrix multiplication: (A*B)*C). The best CPUs have about 50GB/s while the best GPUs have 750GB/s memory bandwidth. So the more memory your computational operations require, the more significant the advantage of GPUs over CPUs. But there is still the latency that may hurt performance in the case of the GPU. A big truck may be able to pick up a lot of packages with each tour, but the problem is that you are waiting a long time until the next set of packages arrives. Without solving this problem, GPUs would be very slow even for large amounts of data. So how is this solved?</p><p>If you ask a big truck to make many tours to fetch packages you will always wait for a long time for the next load of packages once the truck has departed to do the next tour — the truck is just slow. However, if you now use a fleet of either Ferraris and big trucks (thread parallelism), and you have a big job with many packages (large chunks of memory such as matrices) then you will wait for the first truck a bit, but after that you will have no waiting time at all — unloading the packages takes so much time that all the trucks will queue in unloading location B so that you always have direct access to your packages (memory). This effectively hides latency so that GPUs offer high bandwidth while hiding their latency under thread parallelism — so for large chunks of memory GPUs provide the best memory bandwidth while having almost no drawback due to latency via thread parallelism. This is the second reason why GPUs are faster than CPUs for deep learning. As a side note, you will also see why more threads do not make sense for CPUs: A fleet of Ferraris has no real benefit in any scenario.</p><p>But the advantages for the GPU do not end here. This is the first step where the memory is fetched from the main memory (RAM) to the local memory on the chip (L1 cache and registers). This second step is less critical for performance but still adds to the lead for GPUs. All computation that ever is executed happens in registers which are directly attached to the execution unit (a core for CPUs, a stream processor for GPUs). Usually, you have the fast L1 and register memory very close to the execution engine, and you want to keep these memories small so that access is fast. Increased distance to the execution engine dramatically reduces memory access speed, so the larger the distance to access it the slower it gets. If you make your memory larger and larger, then, in turn, it gets slower to access its memory (on average, finding what you want to buy in a small store is faster than finding what you want to buy in a huge store, even if you know where that item is). So the size is limited for register files - we are just at the limits of physics here and every nanometer counts, we want to keep them small.</p><p>The advantage of the GPU is here that it can have a small pack of registers for every processing unit (stream processor, or SM), of which it has many. Thus we can have in total a lot of register memory, which is very small and thus very fast. This leads to the aggregate GPU registers size being more than 30 times larger compared to CPUs and still twice as fast which translates to up to 14MB register memory that operates at a whopping 80TB/s. As a comparison, the CPU L1 cache only operates at about 5TB/s which is quite slow and has the size of roughly 1MB; CPU registers usually have sizes of around 64-128KB and operate at 10-20TB/s. Of course, this comparison of numbers is a bit flawed because registers operate a bit differently than GPU registers (a bit like apples and oranges), but the difference in size here is more crucial than the difference in speed, and it does make a difference.</p><p>As a side note, full register utilization in GPUs seems to be difficult to achieve at first because it is the smallest unit of computation which needs to be fine-tuned by hand for good performance. However, NVIDIA has developed helpful compiler tools which indicate when you are using too much or too few registers per stream processor. It is easy to tweak your GPU code to make use of the right amount of registers and L1 cache for fast performance. This gives GPUs an advantage over other architectures like Xeon Phis where this utilization is complicated to achieve and painful to debug which in the end makes it difficult to maximize performance on a Xeon Phi.</p><p>What this means, in the end, is that you can store a lot of data in your L1 caches and register files on GPUs to reuse convolutional and matrix multiplication tiles. For example the best matrix multiplication algorithms use 2 tiles of 64x32 to 96x64 numbers for 2 matrices in L1 cache, and a 16x16 to 32x32 number register tile for the outputs sums per thread block (1 thread block = up to 1024 threads; you have 8 thread blocks per stream processor, there are 60 stream processors in total for the entire GPU). If you have a 100MB matrix, you can split it up in smaller matrices that fit into your cache and registers, and then do matrix multiplication with three matrix tiles at speeds of 10-80TB/s — that is fast! This is the third reason why GPUs are so much faster than CPUs, and why they are so well suited for deep learning.</p><p>Keep in mind that the slower memory always dominates performance bottlenecks. If 95% of your memory movements take place in registers (80TB/s), and 5% in your main memory (0.75TB/s), then you still spend most of the time on memory access of main memory (about six times as much).</p><p>Thus in order of importance: (1) High bandwidth main memory, (2) hiding memory access latency under thread parallelism, and (3) large and fast register and L1 memory which is easily programmable are the components which make GPUs so well suited for deep learning.</p><p>However, building your own deep learning rig is a pricey affair. Factor in costs of a fast and powerful GPU, CPU, SSD, compatible motherboard and power supply, air-conditioning bills, maintenance and damage to components. On top of it, you run the risk of falling behind on the latest hardware in this rapidly advancing industry.</p><p>Moreover, just assembling the components is not enough. You need to setup all the required libraries and compatible drivers before you can start training your first model. <a href="https://medium.com/towards-data-science/building-your-own-deep-learning-box-47b918aea1eb" rel="noopener noreferrer" target="_blank">People</a> still go along this route, and if you plan to use deep learning extensively (&gt;150 hrs/mo), <a href="https://medium.com/towards-data-science/build-a-deep-learning-rig-for-800-4434e21a424f" rel="noopener noreferrer" target="_blank">building your own deep learning workstation</a> might be the right move.</p><p>A better and cheaper alternative is to use cloud-based GPU servers provided by the likes of Amazon, Google, Microsoft and others, especially if you are just breaking into this domain and plan to use the computing power for learning and experimenting. I have been using AWS, Paperspace and FloydHub for the past 4–5 months. Google Cloud Platform and Microsoft Azure were similar to AWS in their pricing and offerings, hence, I stuck to the previously mentioned three.</p><p><br></p><p>However, the reason you WANT to use Cloud GPUs is because GPU Architecture</p><p><img src="https://cdn-images-1.medium.com/max/1200/1*kG_TBX339Kv-s4QtJuDpFg.png"></p><p>Source - <a href="https://www.nvidia.com/en-us/data-center/tesla-v100/" rel="noopener noreferrer" target="_blank">https://www.nvidia.com/en-us/data-center/tesla-v100/</a></p><p><br></p><h4><strong>Now that we know we want to use GPUs - Sign up and Create a Gradient Notebook with Keras and TensorFlow pre-installed</strong></h4><p><br></p><p>In my opinion <strong>PaperSpace's </strong>Gradient containers are some of quickest and simplest ways to started using a cloud GPU. In a matter of minutes you'll be training a CNN!</p><p>Of course you're free to use other Cloud GPU services, AWS, Azure, Floydhub, Google Cloud (GPUs and TPUs), Vast.AI and many others.</p><p>Here's an entite list of Cloud GPU providers - <a href="https://towardsdatascience.com/list-of-deep-learning-cloud-service-providers-579f2c769ed6" rel="noopener noreferrer" target="_blank">https://towardsdatascience.com/list-of-deep-learning-cloud-service-providers-579f2c769ed6</a></p><p><br></p><h4><strong>Using PaperSpace's GPU and Gradient Notebooks</strong></h4><p><strong>Step 1</strong></p><p>Go to <a href="http://www.paperspace.com" rel="noopener noreferrer" target="_blank">www.paperspace.com</a></p><p><strong>Step 2</strong></p><p>Sign up using your GitHub account or a regular email and password:</p><figure><img height="548" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-01-28-2731b9ed9c55a05ef3173c51e167b280.jpg" width="772"></figure><p><br></p><p><strong>Step 3A - Adding Credit Card and using my Referral Code to get $10 Free Credit</strong></p><p>Verify your email and sign in to PaperSpace, you'll be greeted by this page. It may not immediately appear, but notice <strong>Error Alert box in pink below (see yellow box I drew over it)</strong>.</p><figure><img height="669" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-20-58-1f3fa9e8e3520ee03e0b3c210236ca08.jpg" width="776"></figure><p><br></p><p><strong>STEP 3B - Go to the Billing Page</strong></p><figure><img height="664" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-24-18-8946a909736e325b2a3ea3d1bd664c59.jpg" width="770"></figure><p><br></p><p><strong>Step 3C</strong> - Enter Credit Card Info and Referral code </p><h4><strong>Get $5 Free Credit by using Referral Code - 2DSSNCI</strong></h4><p><strong>or click below</strong></p><p><a href="https://paperspace.io/&amp;R=2DSSNCI" rel="noopener noreferrer" target="_blank">https://paperspace.io/&amp;R=2DSSNCI</a></p><p>This gives you ~10 hours of usage on a P4000 GPU</p><p>After the user must enter their credit card information, otherwise you won't be able to launch a gradient machine<img height="711" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-25-51-fbc69be7fa153b677f79199325f8bc3a.jpg" width="813"></p><p><br></p><p><strong>Step 4A - Creating a Gradient Notebook</strong></p><p>Go back to the <strong>Home </strong>landing page and click on the Gradient Box shown below.</p><figure><img height="704" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-41-53-11d27f6f8a2ce11310545188c0281cfc.jpg" width="796"></figure><p><br></p><p><strong>Step 4B</strong> - Click on box in yellow to create your first notebook</p><figure><img height="716" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-41-53-0c7321f58c7d5390e46b0bd13f3d1130.jpg" width="816"></figure><p><strong>Step 4C</strong> -Under the<strong> Public Containers Tab</strong> (should be shown by default), click on the u<strong>foym/deepo:all-py36-jupyter</strong> container box (shown in the yellow box below).</p><p>This container contains many essential Deep Learning Libraries including Keras and TensorFlow. The main libraries included are:</p><ul><li><p>darknet latest (git)</p></li><li><p>python 3.6 (apt)</p></li><li><p>torch latest (git)</p></li><li><p>chainer latest (pip)</p></li><li><p>jupyter latest (pip)</p></li><li><p>mxnet latest (pip)</p></li><li><p>onnx latest (pip)</p></li><li><p>pytorch latest (pip)</p></li><li><p>tensorflow latest (pip)</p></li><li><p>theano latest (git)</p></li><li><p>keras latest (pip)</p></li><li><p>lasagne latest (git)</p></li><li><p>opencv 4.0.1 (git)</p></li><li><p>sonnet latest (pip)</p></li><li><p>caffe latest (git)</p></li><li><p>cntk latest (pip)</p></li></ul><figure><img height="466" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-17_04-19-17-440063cb83a37d599dcbc4f53114dc70.jpg" width="762"></figure><p><strong>Step 4D </strong>- Select the following instance, the <strong>P4000</strong>. Note feel free to select other more expensive GPUs, but as a cost per value system, the P4000 is excellent. </p><figure><img height="727" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_22-22-15-46c43d464f8855522ce902c70489b44b.jpg" width="767"></figure><p><strong>Step 4E</strong> - Name your Notebook (or keep the default name, it's your choice). I chose<em> "DL CV P4000"</em>.</p><p><strong>Next </strong>you should see the Create Notebook button below in green, click that to create your notebook!</p><p><strong>Note</strong>: You can ignore the 04. Auto-Shutdown are for now, but remember to shutdown your notebook after use (will show you how soon) so that your credit does not run down.</p><figure><img height="690" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_21-41-53-180261afb3d050de2477dee1716e0e84.jpg" width="748"></figure><p><strong><br>Step 5 - Launching your notebook</strong></p><p>Your notebook will now show up in the Notebook section shown below.</p><p>Click the greyed out <strong>Start </strong>button (located in the Actions column) to boot it up.</p><figure><img height="509" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_22-30-22-6d05506ee36de6474990c673cde31048.jpg" width="764"></figure><p>This window will now appear, click <strong>Start Notebook </strong>below. </p><figure><img height="812" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-16_22-30-22-b6600eb8d9457dce80b1655c85ed081d.jpg" width="796"></figure><p>Status will change from <strong>Stopped </strong>to <strong>Pending </strong>-&gt; <strong>Provisioned </strong>-&gt; <strong>Running</strong></p><p>Once it's running you'll be able to launch it by pressing <strong>Open</strong></p><figure><img height="262" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-17_04-24-00-a14237a295cc12888557706d1ec983e7.jpg" width="766"></figure>

28. BONUS - Use Cloud GPUs on PaperSpace/2. Train a AlexNet on PaperSpace.html

@@ -0,0 +1,100 @@
+<h4><strong>Training  AlexNet on the CIFAR10 Dataset</strong></h4><p><br></p><p>Upon clicking start from our previous section, we'll now be greeted with this screen:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_05-55-38-8807e87ad20b67082d7a81ddc676a32c.JPG"></figure><p>Looks a fairly harmless Notebook, but this cloud system will allow us to training AlexNet almost 100X faster!</p><p>But first, let's explore our new PaperSpace Gradient Notebook.</p><p>Observe the two directories that are setup (see above) by the PaperSpace Gradient system:</p><ul><li><p><strong>datasets </strong>- contains some common datasets some of which you'd recognize from earlier in our course, these are there as test data to check performance of new CNNs or even to aid in transfer learning etc. (See below for a screenshot)</p></li><li><p><strong>storage </strong>- This is where you'd preferably want to keep files (ipynb notebooks and data) (see below)</p></li></ul><p><strong>Datasets </strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_05-59-00-9a7284073358f7814397a6c36cbc5b14.JPG"></figure><p><strong>Storage</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_05-59-47-7b0b7bf1bfbe814402932a98f2b1ab1a.png"></figure><p><strong>Note</strong>: data stored in the storage folder is persistent across all gradient machines in your account.</p><p>Data saved in the main workspace area (i.e. the default directory which is /home/paperspace) will be lost when your terminate the session - do not save important files there or they will be lost!</p><p><strong>lost+found</strong> can be ignored as it's a directory created in Unix systems where corrupted data is temporarily stored (if you do lose files it's possible they maybe stored there)</p><p><br></p><p><strong>There are two easy ways to use PaperSpace Gradients</strong></p><p>1. Go to the <strong>storage </strong>directory Click on New and....</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_06-06-40-9cfc7503e060112e2a3ac23fd1eb21a0.png"></figure><p>Start a new Python3 notebook</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_06-07-19-a39201c771b5bf3630df8ac67a936b53.JPG"></figure><p>This launches a new python3 notebook where you can import Keras, TensorFlow etc and use just like you do on your local machine or Virtual Machine. Except we're now taking advantage of their lightening quick GPUs! Feel free to copy and paste your existing code into these notebooks.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_06-09-34-9d435dac8a1c8f5da9db5454054de554.JPG"></figure><h4><strong>OR</strong></h4><p>2. Upload your existing notebooks and datasets by using the Upload button. (see resources for AlexNet CIFAR10 .ipynb)</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_06-10-04-b5db0ae7ef26b044b83e1fcf1b986c00.png"></figure><p><strong>It's that simple!</strong></p><p><br></p><h4><strong>Now let's try our AlexNet CIFAR10 CNN</strong></h4><p><br></p><p>Either upload the notebook in the attached resources or copy and paste this code into </p><p><br></p><pre class="prettyprint linenums">#Keras Imports and Loading Our CIFAR10 Dataset
+from __future__ import print_function
+import keras
+from keras.datasets import cifar10
+from keras.preprocessing.image import ImageDataGenerator
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Activation, Flatten
+from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
+from keras.layers.normalization import BatchNormalization
+from keras.regularizers import l2
+
+# Loads the CIFAR dataset
+(x_train, y_train), (x_test, y_test) = cifar10.load_data()
+
+# Display our data shape/dimensions
+print('x_train shape:', x_train.shape)
+print(x_train.shape[0], 'train samples')
+print(x_test.shape[0], 'test samples')
+
+# Now we one hot encode outputs
+num_classes = 10
+y_train = keras.utils.to_categorical(y_train, num_classes)
+y_test = keras.utils.to_categorical(y_test, num_classes)</pre><p><br></p><pre class="prettyprint linenums">#Defining our AlexNet Convolutional Neural Network
+l2_reg = 0
+
+
+# Initialize model
+model = Sequential()
+
+# 1st Conv Layer 
+model.add(Conv2D(96, (11, 11), input_shape=x_train.shape[1:],
+    padding='same', kernel_regularizer=l2(l2_reg)))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+# 2nd Conv Layer 
+model.add(Conv2D(256, (5, 5), padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+# 3rd Conv Layer 
+model.add(ZeroPadding2D((1, 1)))
+model.add(Conv2D(512, (3, 3), padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+# 4th Conv Layer 
+model.add(ZeroPadding2D((1, 1)))
+model.add(Conv2D(1024, (3, 3), padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+
+# 5th Conv Layer 
+model.add(ZeroPadding2D((1, 1)))
+model.add(Conv2D(1024, (3, 3), padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+# 1st FC Layer
+model.add(Flatten())
+model.add(Dense(3072))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(Dropout(0.5))
+
+# 2nd FC Layer
+model.add(Dense(4096))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(Dropout(0.5))
+
+# 3rd FC Layer
+model.add(Dense(num_classes))
+model.add(BatchNormalization())
+model.add(Activation('softmax'))
+
+print(model.summary())
+
+model.compile(loss = 'categorical_crossentropy',
+              optimizer = keras.optimizers.Adadelta(),
+              metrics = ['accuracy'])</pre><p><br></p><pre class="prettyprint linenums"># Training Parameters
+batch_size = 32
+epochs = 10
+
+history = model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=epochs,
+          validation_data=(x_test, y_test),
+          shuffle=True)
+
+model.save("./Models/CIFAR10_AlexNet_10_Epoch.h5")
+
+# Evaluate the performance of our trained model
+scores = model.evaluate(x_test, y_test, verbose=1)
+print('Test loss:', scores[0])
+print('Test accuracy:', scores[1])</pre><p><strong>Our Cloud GPU as trained almost 60-100X faster than our CPU!</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_07-36-41-b5a56c95d46e10a12f1ab13fbd1ea5bd.png"></figure><p>We've trained 10 EPOCHs are 80% Accuracy in just bout 45 minutes. A CPU only system that would have taken over well over 24 hours.</p><p><br></p><p><strong>Our Training Loss and Accuracy Graphs</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_07-44-07-a687596eb0b9344a5634548668ed7560.JPG"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-18_07-44-07-bdd067ec83d59a05da0ad2399ed246ce.JPG"></figure>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/1. Install and Run Flask.html

@@ -0,0 +1,9 @@
+<h4><strong>Introduction</strong></h4><p><br></p><p>We're about to create a <strong>Computer Vision (CV) API </strong>and<strong> Web App.</strong> But first, why would we want to do this? </p><ul><li><p>Ever wanted to share your Computer Vision App on the web to show a friend using their PC&nbsp;or Phone?</p></li><li><p>Want to sell or commercialize your python computer vision code, but not sure how to distribute Python?</p></li></ul><p>Well if you want to make your CV code available to the world you need to make it accessible from the web.&nbsp;There are three main ways you can do this:</p><p>1. Create an <strong>API</strong>, which allows any other application (whether it's an iOS, Android or within any other software) to access it via the API&nbsp;protocol. APIs are Application Programming Interfaces that facilitate access to complex external applications via a simplified interface. In our example, we'll be using the RESTful&nbsp;API protocol which allows us to run our Python CV via the web.</p><p>2. Create a <strong>Web App</strong>, this is basically the same as an API, except we'll be allowing users to access or run our CV app via any web browser.</p><p>3. Run the CV code natively on another platform. This is the more difficult option is it requires you to re-code your Python CV code into another language. This is far more difficult and requires you learning an entirely new language e.g. Java if making an Android App. But the local access reduces the need to send data over the web and can perform real-time operations. This method won't be shown in this tutorial.</p><h4></h4><p><br></p><h4><strong>Introducing Flask </strong></h4><p><br></p><p>Before we begin installing Flask and setting up everything on AWS, let me first explain what exactly is <strong>Flask,</strong> and why we need it.</p><figure><img height="138" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_22-32-59-b6e6be615ec9b18d3f348b500492faca.JPG" width="340"></figure><p><strong>Flask </strong>is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries. It has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions. This allows us to easily build simple APIs without much effort. </p><p><strong>Step 1: Installing Flask</strong></p><p>If using your VM, activate your environment (so that we can use OpenCV and Keras).</p><p><code>source activate cv</code> or whatever your environment is named </p><p> <code>pip install flask</code></p><p>That's it, Flask is ready to go!</p><p>Let's run a simple Flask test.</p><p><strong>Step 2:&nbsp;</strong>Installing a code editor since we won't be using Ipython Notebooks. I recommend Sublime, but VSCode, Atom,&nbsp;Spyder, and PyCharm are all great!</p><p>If using Windows or Mac, visit the Sublime website to get the download link - <a href="https://www.sublimetext.com/download" rel="noopener noreferrer" target="_blank">https://www.sublimetext.com/download</a></p><p>Ubuntu/VM users can bring up the Ubuntu Software app, search for Sublime and install it from there.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_22-53-13-6613cddd9daf61ecf9d07c4d56e2c38c.JPG"></figure><p>Open up your chosen Text/Code Editor and copy the code below into it and save it in an easy to find directory, e.g. </p><p><code>/home/deeplearningcv/MyFlaskProjects</code></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-00-53-bfd6feec89e093ff03e58bc52e8d3e94.JPG"></figure><p>This is code for your first simple Flask app, the 'hello world' app. </p><p><strong>Also, see Resources to download all code required for this section</strong></p><pre class="prettyprint linenums">from flask import Flask
+app = Flask(__name__)
+ 
+@app.route("/")
+def hello():
+    return "Hello World!"
+ 
+if __name__ == "__main__":
+    app.run()</pre><p>Once your code is saved in the path, use Terminal or Command Prompt and navigate to the folder where you saved your helloworld.py file.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-26-30-dbbc9629d30892671866580522faea9f.JPG"></figure><p>Upon executing this code, you'll see the following: </p><p>This means your server is running successfully and you can now go to your web browser and view your hello world project!</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-32-38-e41640a083fa6900739c4eddf0143da9.JPG"></figure><p>You should see this if you enter <code>127.0.0.1:5000 </code>in your browser. This means you Flask server is pushing/serving the text "Hello World!" to your localhost on Port 5000. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-34-14-2a757fe288b275bff67d55a208fef895.JPG"></figure><p>Remember to press <strong>CTRL+C t</strong>o exit (when in Terminal).</p><p>Congratulations! Now you're ready to start testing your Computer&nbsp;Vision&nbsp;API locally, which we'll do in the next chapter!</p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/1.1 Download CV API Files.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1ScD6jTBcYW5RkTP1OwCCFoWXYYtZJguJ/view?usp=sharing";</script>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/2. Running Your Computer Vision Web App on Flask Locally.html

@@ -0,0 +1,86 @@
+<h4><strong>Our Flask&nbsp;WebApp Template Code </strong></h4><p><br></p><p>In the previous chapter, we created a simple Hello World app. We're now going create a simple App that does the following:</p><ul><li><p>Allows you to upload an image</p></li><li><p>Uses OpenCV and Keras to do some operations on the image</p></li><li><p>Returns the outputs of our operations to the user</p></li></ul><p>We'll be making a simple App that users OpenCV to find the dominant color (Red vs Green vs Blue) and determines whether the animal in the picture is a Cat or Dog.</p><p><br></p><p><strong>Our Web&nbsp;App 1:</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-58-35-80e8fa501f933728e7f9ed8d002e9713.JPG"></figure><p><strong>Our Web&nbsp;App 2:</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-59-43-e3f4f1bffc29b2e9a51a7a354e9d87ac.JPG"></figure><p><strong>Our Web&nbsp;App 3:</strong></p><figure><img height="261" src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-58-35-170c078ea8cbb82743a7f77bbaf78b6a.JPG" width="434"></figure><p><strong>Our Web&nbsp;App 4:</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-22_23-58-35-98e72167229d356fe6e3429e79a43e33.JPG"></figure><p><br></p><h4><strong>NOTE</strong>: Download the code in the resources section</h4><p>The code for our web app is as follows:</p><pre class="prettyprint linenums">import os
+from flask import Flask, flash, request, redirect, url_for, jsonify
+from werkzeug.utils import secure_filename
+import cv2
+import keras
+import numpy as np
+from keras.models import load_model
+from keras import backend as K
+
+UPLOAD_FOLDER = './uploads/'
+ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])
+DEBUG = True
+app = Flask(__name__)
+app.config.from_object(__name__)
+app.config['SECRET_KEY'] = '7d441f27d441f27567d441f2b6176a'
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+def allowed_file(filename):
+	return '.' in filename and \
+		   filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.route('/', methods=['GET', 'POST'])
+def upload_file():
+	if request.method == 'POST':
+		# check if the post request has the file part
+		if 'file' not in request.files:
+			flash('No file part')
+			return redirect(request.url)
+		file = request.files['file']
+		if file.filename == '':
+			flash('No selected file')
+			return redirect(request.url)
+		if file and allowed_file(file.filename):
+			filename = secure_filename(file.filename)
+			file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+			image = cv2.imread(os.path.dirname(os.path.realpath(__file__))+"/uploads/"+filename)
+			color_result = getDominantColor(image)
+			result = catOrDog(image)
+			redirect(url_for('upload_file',filename=filename))
+			return '''
+			&lt;!doctype html&gt;
+			&lt;title&gt;Results&lt;/title&gt;
+			&lt;h1&gt;Image contains a - '''+result+'''&lt;/h1&gt;
+			&lt;h2&gt;Dominant color is - '''+color_result+'''&lt;/h2&gt;
+			&lt;form method=post enctype=multipart/form-data&gt;
+			  &lt;input type=file name=file&gt;
+			  &lt;input type=submit value=Upload&gt;
+			&lt;/form&gt;
+			'''
+	return '''
+	&lt;!doctype html&gt;
+	&lt;title&gt;Upload new File&lt;/title&gt;
+	&lt;h1&gt;Upload new File&lt;/h1&gt;
+	&lt;form method=post enctype=multipart/form-data&gt;
+	  &lt;input type=file name=file&gt;
+	  &lt;input type=submit value=Upload&gt;
+	&lt;/form&gt;
+	'''
+
+def catOrDog(image):
+	'''Determines if the image contains a cat or dog'''
+	classifier = load_model('./models/cats_vs_dogs_V1.h5')
+	image = cv2.resize(image, (150,150), interpolation = cv2.INTER_AREA)
+	image = image.reshape(1,150,150,3) 
+	res = str(classifier.predict_classes(image, 1, verbose = 0)[0][0])
+	print(res)
+	print(type(res))
+	if res == "0":
+		res = "Cat"
+	else:
+		res = "Dog"
+	K.clear_session()
+	return res
+
+def getDominantColor(image):
+	'''returns the dominate color among Blue, Green and Reds in the image '''
+	B, G, R = cv2.split(image)
+	B, G, R = np.sum(B), np.sum(G), np.sum(R)
+	color_sums = [B,G,R]
+	color_values = {"0": "Blue", "1":"Green", "2": "Red"}
+	return color_values[str(np.argmax(color_sums))]
+	
+if __name__ == "__main__":
+	app.run()
+
+</pre><p>Running our web app in Terminal (or Command Prompt, it should be exactly the same). </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_00-01-02-ece80015f52c109880a2dcb76dfeede8.JPG"></figure><p><br></p><p><strong>Brief Code Description:</strong></p><p><strong>Lines 1 to 8:</strong> Importing our flask functions and other relevant functions/Libraries we'll be using in this program such as <em>werkzeug, keras, numpy </em>and <em>opencv</em></p><p><strong>Line 10 to 16: </strong>Defining our paths, allowed files and setting our Flask Parameters. Look up the Flask documentation to better understand</p><p><strong>Line 18 to 10:</strong> Our 'allowed files function', it simply checks the extension of the selected file to ensure only images are uploaded.</p><p><strong>Line 22:</strong>&nbsp;The route()&nbsp;function of Flask. It is a decorator that tells the Application which URL should call the associated function.</p><p><strong>Line 23 to 58:</strong> Our main function, it results to both GET&nbsp;or POST&nbsp;Requests.&nbsp;These are HTTP&nbsp;methods that form the basis of data communication over the internet. GET Sends data in unencrypted form to the server. Most common method. POS is used to send HTML form data to the server. Data received by POST method is not cached by the server. We're using an unconventional method of serving the HTML to our client Typically Flask apps used templates stored in a Templates folder which contains our HTML. However, this is a simple web app and it's better for your understanding if we server the HTML like this. Note we have two blocks of code, one is the default HTML used prompting the user to upload an image. The second block sends the response to the user. </p><p><strong>Line 60 to 73:&nbsp;</strong>This is our Cats vs Dogs function that takes an image and outputs a string stating which animal is found in the image, either "Cat" or "Dog".</p><p><strong>Line 75 to 81: </strong>This function sums all the Blue, Green and Red color components of an image and returns the color with the largest sum. </p><p><strong>Line 83 to 84:</strong> Our main code that runs the Flask app by calling the app.run() function. </p><p><br></p><p><strong>Our Folder Setup:</strong></p><p><code>MyFlaskProjects/</code></p><p><code>------Models/&nbsp;</code>(where our Keras catsvsdogs.h5 is stored)</p><p><code>------Uploads/</code> (where our uploaded files are stored)</p><p><code>------webapp.py</code> </p><p><br></p><p>Feel free to experiment with different images! Let's now move on to a variation of this code that acts as a standalone API.</p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/3. Running Your Computer Vision API.html

@@ -0,0 +1,76 @@
+<h4><strong>Our Flask API Template Code </strong></h4><p><br></p><p>In the previous chapter, we created a Web App that's accessible via the web browser. Pretty cool! but what if we wanted to call this API from different Apps e.g. a Native Android or iOS App?</p><p><br>Let's turn it into RESTful API that returns simple JSON responses encapsulating the results. </p><p><strong>NOTE</strong>: A <strong>RESTful API</strong> is an application program interface (<strong>API</strong>) that uses HTTP requests to GET, PUT, POST and DELETE data.</p><p><br></p><p><strong>Step 1: </strong>Firstly, install <strong>Postman </strong>to test our API </p><ul><li><p>Windows/Max - <a href="https://www.getpostman.com/downloads/" rel="noopener noreferrer" target="_blank">Download and install here </a></p></li><li><p>Ubuntu Users - Launch Ubuntu Software and Install </p></li></ul><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_06-16-17-a75ad1a8a678b5837139fcab17cd4f6f.JPG"></figure><p><strong>Step 2: </strong>Our Flask API Code</p><pre class="prettyprint linenums">import os
+from flask import Flask, flash, request, redirect, url_for, jsonify
+from werkzeug.utils import secure_filename
+import cv2
+import numpy as np
+import keras
+from keras.models import load_model
+from keras import backend as K
+
+UPLOAD_FOLDER = './uploads/'
+ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])
+DEBUG = True
+app = Flask(__name__)
+app.config.from_object(__name__)
+app.config['SECRET_KEY'] = '7d441f27d441f27567d441f2b6176a'
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+def allowed_file(filename):
+	return '.' in filename and \
+		   filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.route('/', methods=['GET', 'POST'])
+def upload_file():
+	if request.method == 'POST':
+		# check if the post request has the file part
+		if 'file' not in request.files:
+			flash('No file part')
+			return redirect(request.url)
+		file = request.files['file']
+		# if user does not select file, browser also
+		# submit an empty part without filename
+		if file.filename == '':
+			flash('No selected file')
+			return redirect(request.url)
+		if file and allowed_file(file.filename):
+			filename = secure_filename(file.filename)
+			file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+			image = cv2.imread(os.path.dirname(os.path.realpath(__file__))+"/uploads/"+filename)
+			color_result = getDominantColor(image)
+			dogOrCat = catOrDog(image)
+			#return redirect(url_for('upload_file',filename=filename)), jsonify({"key":
+			return jsonify({"MainColor": color_result, "catOrDog": dogOrCat} )
+	return '''
+	&lt;!doctype html&gt;
+	&lt;title&gt;API&lt;/title&gt;
+	&lt;h1&gt;API Running Successfully&lt;/h1&gt;'''
+
+def catOrDog(image):
+	'''Determines if the image contains a cat or dog'''
+	classifier = load_model('./models/cats_vs_dogs_V1.h5')
+	image = cv2.resize(image, (150,150), interpolation = cv2.INTER_AREA)
+	image = image.reshape(1,150,150,3) 
+	res = str(classifier.predict_classes(image, 1, verbose = 0)[0][0])
+	print(res)
+	print(type(res))
+	if res == "0":
+		res = "Cat"
+	else:
+		res = "Dog"
+	K.clear_session()
+	return res
+
+def getDominantColor(image):
+	'''returns the dominate color among Blue, Green and Reds in the image '''
+	B, G, R = cv2.split(image)
+	B, G, R = np.sum(B), np.sum(G), np.sum(R)
+	color_sums = [B,G,R]
+	color_values = {"0": "Blue", "1":"Green", "2": "Red"}
+	return color_values[str(np.argmax(color_sums))]
+
+
+if __name__ == "__main__":
+	app.run()</pre><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_00-48-49-5db46541ad63d65d835cdd569211c973.JPG"></figure><p><strong>Using Postman (see image above and the corresponding numbered steps below:</strong></p><ol><li><p>Change the protocol to POST</p></li><li><p>Enter the local host address: http://127.0.0.1:5000/</p></li><li><p>Change Tab to Body</p></li><li><p>Select the form-data radio button</p></li><li><p>From the drop-down, select Key type to be file</p></li><li><p>For Value, select one of our test images</p></li><li><p>Click send to send our image to our API</p></li><li><p>Our response will be shown in the window below.</p></li></ol><p>The output is JSON file containing:</p><pre class="prettyprint linenums">{
+    "MainColor": "Red",
+    "catOrDog": "Cat"
+}</pre><p>The cool thing about using Postman is that we can generate the code to call this API in several different languages:</p><p>See blue box to bring up the code box:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_00-54-19-04fa84ce24394a4b9df2347dee6ac632.jpg"></figure><p>Code Generator</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_00-55-22-1aaeea8249c6c70d464a1ece0466b273.JPG"></figure><p><strong>Now that you've got your Flask API and Web App working, let's look at deploying this on AWS using an EC2 Instance.</strong></p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/4. Setting Up An AWS Account.html

@@ -0,0 +1 @@
+<h4><strong>Setting up AWS</strong></h4><p><br></p><p><strong>Step 1: </strong>Go to <a href="https://aws.amazon.com/" rel="noopener noreferrer" target="_blank">https://aws.amazon.com/</a> and click on Complete Sign Up </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-06-56-916201cbff1910166f9da1db21d28155.JPG"></figure><p><strong>Step 2: </strong>Create New Account</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-08-34-ff0bf36b97e2c4609d84a5e41b302e7a.JPG"></figure><p><strong>Step 3:</strong> Enter your main account details </p><p><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-05-33-d59697bc4760ae5f6188b43575779bbf.JPG"></p><p><strong>Step 4: </strong>Enter Contact Info</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-10-38-f288864877ba579880e7dcf59fca8bc2.JPG"></figure><p><strong>Step 5: </strong>Enter your verification code</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-11-02-19874a11e64e4bb498c83e8f009f7519.JPG"></figure><p><strong>Step 6: </strong>Select the Free Basic Plan</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-05-33-41a548a0f53eab00e4df36218f53f6d9.JPG"></figure><p><strong>Step 7: </strong>Sign up is now complete! Sign in to your account now.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-05-33-cd82af8c20fc8cb5fd4382c0b02e599a.JPG"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_01-05-33-5276c92f7ea948c9ca03d7d26fbe8368.JPG"></figure><p>Your AWS Account is Complete!</p><p>Let's now create our EC2 Instance.</p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/5. Setting Up Your AWS EC2 Instance & Installing Keras, TensorFlow, OpenCV & Flask.html

@@ -0,0 +1,9 @@
+<h4><strong>Launching Your E2C Instance</strong></h4><p><br></p><p><strong>Step 1: </strong>Your landing page upon logging in should be the AWS Management Console (see below). Click on the area highlighted in yellow that says "<strong>Launch a virtual Machine" with EC2. </strong></p><p><strong>What is EC2?</strong> Amazon Elastic Compute Cloud <strong>(Amazon EC2</strong>) provides scalable computing capacity in the Amazon Web Services (AWS) cloud. Using Amazon EC2 eliminates your need to invest in hardware up front, so you can develop and deploy applications faster.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-0aee9b0a53c5ff7d333b8dd78c366150.png">.</figure><p><strong>Step 2: </strong>As a Basic Plan (FREE) User, you're eligible to launch and use any of the "Free tier" AMIs. The one we'll be using in this project is the <strong>Ubuntu Server 18.04 LTS (HVM), SSD Volume Type. </strong>See image below, you'll have to scroll down a bit to find it amongst the many AMIs. We use this image as it's quite easy to get everything up and running.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-4d7f42fec9fa73be91dd3f3a3220528e.JPG"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-d96a0fbdc7d781c023e2757b48448c94.png"></figure><p><strong>Step 3: </strong>Choosing an Instance Type - We already have chosen the type of OS we want to use (Ubuntu 18.04), now we have to choose a hardware configuration. We aren't given much of a choice due to our Free Tier limitations. The <strong>t2.micro </strong>will suffice for our application needs for now. Click<strong> Review and Launch</strong> (highlighted in yellow)</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-ed95c62d0d19c294264eaeb85edcccca.png"></figure><p><strong>Step 4: </strong>Reviewing and launching. No need to change anything here, the defaults are fine. Click <strong>Launch </strong>(highlighted in yellow)</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-0025d77e49af0f8a63c75d9e48eaaff7.png"></figure><p><strong>Step 5A:</strong> Creating a new Key Pair. If this is your first time you will need to create a new Key Pair. Click on the drop-down highlighted in yellow below. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-86bd4ffddae1ee4571d968a8f83eb03c.png"></figure><p><strong>Step 5B:</strong> GIve you key a name e.g. my_aws_key and Download Key Pair (please don't lose this file otherwise you won't be able to log in to your EC2 instance). </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-abdb2db33153383c11e9b9b2ba8d3507.png"></figure><p><strong>Step 5C:</strong> Your Instance has been launched, it will take a few mins for AWS to create and have your instance up and running </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-4cb08dac37637149ccea79e3ac7c5308.JPG"></figure><p><strong>Step 6A: </strong>Clicking View instances brings up the EC2 Dashboard. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_04-43-09-5ca178d2ec6fd40b8d12cb7cfb4be0aa.JPG"></figure><p><strong>Step 6B: </strong>To view the details of the individual instance you just launched, click on Instances under Instances on the left panel. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_04-42-05-97d85a5b7eddd3f6b1daa5f13e628bbb.JPG"></figure><p><strong>Step 7:</strong> Viewing your Instance public IP. Note your IP as you'll need it later when connecting to your instance.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-7078b5ec1ac74f7cef875bcb375f4491.JPG"></figure><p><strong>Step 8:</strong> Assuming you're using Ubuntu on the VM (if not it's highly recommended as I find using Putty and SSH keys over windows to be sometimes problematic). Note Windows isn't always, so you're welcome to try using the guide here: <a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-windows-launch-instance.html" rel="noopener noreferrer" target="_blank">https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-windows-launch-instance.html</a>) </p><p>Mac instructions would be the same as the Ubuntu instructions.</p><p>Let's chmod your downloaded key to protect it from overwriting. If you've never used ssh on your VM, create a ./ssh folder in the home director. The following commands also assume your key is in the downloaded directory.</p><pre class="prettyprint linenums">mkdir ${HOME}/.ssh
+cp ~/Downloads/my_aws_key.pem ~/.ssh
+chmod 400 ~/.ssh/my_aws_key.pem
+</pre><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-801b1770189ee4cf1c938303db5c8e1a.JPG"></figure><p><strong>Step 9: </strong>Connecting to your EC2 instance via Terminal, by running this:</p><pre class="prettyprint linenums">ssh -i ~/.ssh/my_aws_key.pem ubuntu@18.224.96.38</pre><p>You'll be prompted by the following, type yes and hit Enter.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_04-55-08-2c5ae7fb992ca463892c46e286737ec1.JPG"></figure><p>You'll now be greeted by this! Congratulations, you've connected to your EC2 Instance successfully!</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-2dd7621c922e4b091bff0b7ad3946f5a.JPG"></figure><p><strong>Step 10:</strong> Installing the necessary packages by executing the following commands:</p><pre class="prettyprint linenums">sudo apt update
+sudo apt install python3-pip
+sudo pip3 install tensorflow
+sudo pip3 install keras
+sudo pip3 install flask</pre><p><strong>Note</strong>: As of April 2019, <code>sudo pip3 install opencv-python</code> appears to be broken, if importing cv2 fails, run <code>sudo apt install python3-opencv</code></p><pre class="prettyprint linenums">sudo pip3 install opencv-python
+sudo apt install python3-opencv </pre><p>Screenshots of the TensorFlow install:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-24960fe6ebff21df1e02c50823526ade.jpg"></figure><p>Screenshots of the Keras install:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-403c9055c8dddcf04c44cff5c7a2ec17.jpg"></figure><p>Screenshots of the Flask install:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_03-06-48-cf2ee18e183e6455ff9d01957dece8af.jpg"></figure><p>We've successfully installed all libraries needed for our API and Web App on our EC2 Instance!</p><p><strong>In the next chapters, we'll:</strong></p><ul><li><p>Setup Filezilla to transfer our code to your EC2</p></li><li><p>Setup our Security Group on AWS to allow TCP traffic.</p></li></ul>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/6. Changing your EC2 Security Group.html

@@ -0,0 +1 @@
+<h4><strong>Changing your EC2 Security Group to allow HTTP traffic</strong></h4><p><br></p><p><strong>Step 1:</strong> Go to <strong>Instances </strong>on the left panel of your AWS EC2 Console and click on <strong>Instances. </strong>Then click on the blue text under the <strong>Security Groups column.</strong> It may either be named '<strong>default' </strong>or '<strong>launch-wizard-1'. </strong>This brings up the <strong>Security Group Page.</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-41-31-98f629ee997a6a8436f8283d628ae498.jpg"></figure><p><strong>Step 2A: </strong>Changing the Security Group Inbound Rules. Right click on the security group shown below.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-41-31-9b235eb73431c4e7f70aeb86d4e3fca1.JPG"></figure><p><strong>Step 2B:</strong> Click on <strong>Edit Inbound Rules</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-41-31-98d9f2ee4cfa0e45ed3ea763a6644724.jpg"></figure><p><strong>Step 2C: </strong>Change the Rules to as shown below.</p><p><strong>Type </strong>- All Traffic (Protocol will be automatically set to All and Port Range to 0-65535)</p><p><strong>Source </strong>- Custom which should autofill the box the right to, 0.0.0.0/0 (this indicates we are accepting traffic from all IPs).</p><p>Click Save and that's it, your Security Group settings are now set.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-41-31-15840abd9ac7b2c2c15daceffc695821.JPG"></figure>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/7. Using FileZilla to transfer files to your EC2 Instance.html

@@ -0,0 +1,2 @@
+<h4><strong>Using FileZilla to Connect to Your EC2 Instance to Allow Transferring of Files</strong></h4><p><br></p><p><strong>Step 1: Install FileZilla</strong></p><ul><li><p>Windows and Mac Users can go here and download and install - <a href="https://filezilla-project.org/" rel="noopener noreferrer" target="_blank">https://filezilla-project.org/</a></p></li><li><p>Ubuntu users can open the Terminal and install as follows:</p></li><li><pre class="prettyprint linenums">sudo apt-get update
+sudo apt-get install filezilla   </pre></li></ul><figure>After installing you can find and launch FileZilla by simply searching for it:<img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-4136243a8af88a3f38b752a9adbeb7bb.JPG"></figure><p><strong>Step 2:</strong> Let's load our SSH Key into FileZilla. Open FileZilla, and click Preferences in the main toolbar (should be the same for Windows and Mac users)</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-392a1cbb6dc5cd76196f692d6a2bca80.JPG"></figure><p><strong>Step 3A: </strong>In the left panel, select <strong>SFTP </strong>and then click <strong>Add key file...</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-b8ac3f9c8b4d1633f472204099911d28.JPG"></figure><p><strong>Step 3B: </strong>To find your ssh key, navigate to your "./ssh" directory, as it is a hidden directory, in Ubuntu, you can hit CTRL+L which changes the Location bar to an address bar. Simply type ".ssh/" as shown below to find your ssh key directory. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-fd67f533da61e4b6e6a3f8173c7fd18f.JPG"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-e861aeafa0d05fdc4b1221c283cd52fd.JPG"></figure><p><strong>Step 4A: Connecting to your EC2.</strong> Now that you've added your key we can create a new connection.</p><p>On the main toolbar again, click <strong>File </strong>and <strong>Site Manager</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-59-7094ce39622c5205fc7a199c97eabead.JPG"></figure><p><strong>Step 4B: </strong>This brings up the Site Manager window. Click<strong> New Site</strong> as shown below</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-3ebedc419bfba9facc83d3ca94ee6aed.JPG"></figure><p><strong>Step 4C: </strong>Enter the IP (<strong>IPv4 Public IP)</strong> of your EC2 Instance (can be found under Instances in your AWS Console Manager).</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-119a9990f34809b4d270b44a0920be88.JPG"></figure><p><strong>Step 4D: </strong>Change the <strong>Protocol </strong>to <strong>SFTP</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-c70e300f0e3bea0e4e019569b9aae7cb.JPG"></figure><p><strong>Step 4E:</strong> Change the<strong> Logon Type</strong> to <strong>Normal </strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-5ec407abfc844c69d20c216b7e701bfb.JPG"></figure><p><strong>Step 4F:</strong> Put the <strong>Username </strong>as <strong>ubuntu.</strong> Leave the password field alone.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-272f537a13d6ca250ac3e5e12035f2cd.JPG"></figure><p><strong>Step 4G:</strong> <strong>Check </strong>the "Always trust this host, add the key to the cache box" and click on <strong>OK</strong>.</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-7deb4172c6ab15ff64fa4e6de5bcc977.JPG"></figure><p><strong>Step 5: We've Connected! </strong></p><p>The numbered boxes below show the main windows we'll be using in FileZilla. </p><p>1. Is the connection status box that shows the logs as the system connects to your EC2 instance.</p><p>2. These are your local files on your system</p><p>3. These are the files on your EC2 VM. By default both these </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-17-24-382888a7caaa7e085dbed8ba415276ee.JPG"></figure><p><strong>Step 6: </strong>Navigate to your Flask python files you downloaded in the previous resource section and drag them accross to your EC2 home directory (default directory).</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-36-01-9339191f4d972516df58fda9846a758f.JPG"></figure><p><strong>Great! You're almost ready to have a fully working CV API live on the web!</strong></p><p>Next, we need to change the security group of our EC2 to allow HTTP inbound traffic.</p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/8. Running your CV Web App on EC2.html

@@ -0,0 +1 @@
+<h4><strong>Running Our CV Web App</strong></h4><p><br></p><p><strong>Step 1</strong>: Let's go back to your terminal in our VM or local OS and connect to our EC2 system </p><p><code>ssh -i ~/.ssh/my_aws_key.pem ubuntu@18.224.96.38</code></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-055aacf3331c034d10cb070afd33191b.JPG"></figure><p><strong>Step 2: </strong>Check to see if the files we transferred using FileZilla are indeed located on our EC2 Instance. Running <code>ls</code> should display the following files:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-11abbea6c691e37aed4e7ee95c7559d0.JPG"></figure><p><strong>Step 3: </strong>Launch our Web App by running this line:</p><p><code>sudo python3 webapp.py</code></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-6eca288bff15051487a40c55bb77c6a1.JPG"></figure><p>If you see the above, Flask is running our CV Web App! Let's go the our web browser and access it:</p><p><strong>Step 4: </strong>Enter the EC2 IP in your web browser and your should see the following.</p><p><strong>Congratulations</strong>! You've just launched a simple Computer Vision API for anyone in the world to use! Let's upload some test images to see our Web App in action!</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-467b63c0ea3e8de2a4b9cb0c33db2693.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-1d6c77e1e20a7dd571cefa84d2fd6ea7.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-47742e4675b799abf7c93f81765e6101.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_05-55-04-8d41647668253e2f92f8c4ac6de5d166.png"></figure><p>Awesome!</p><p><strong>Note: </strong></p><ol><li><p>This isn't a production grade Web App, there are many things needed to make this ready for public consumption (mainly in terms of security, scalability and appearance), however as of now, it's perfect to demo friends, colleagues, potential investors etc. </p></li><li><p>To keep our API running constantly launch the python code using this instead:</p></li></ol><p><code>sudo nohup python3 forms.py &amp; screen</code></p><p><br></p><p><strong>Finally, let's deploy our API version of this App and test using Postman.</strong></p>

29. BONUS - Create a Computer Vision API & Web App Using Flask and AWS/9. Running your CV API on EC2.html

@@ -0,0 +1,4 @@
+<h4><strong>Running your CV API on EC2</strong></h4><p><br>Postman is an extremely useful app used to test APIs. We'll be using it to demonstrate our CV API </p><p><br></p><p><strong>Step 1: Install Postman</strong></p><p>Windows/Mac Users - <a href="https://www.getpostman.com/downloads/" rel="noopener noreferrer" target="_blank">https://www.getpostman.com/downloads/</a></p><p>Ubuntu - Open Ubuntu Software, search for Postman and install </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_06-06-41-8ce224de735c72f9cee7fd145abcbab4.JPG"></figure><p><br></p><p><strong>Step 2: </strong>Setting up Postman for testing your EC2 API</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_06-12-53-d966f3cbf2ec41dac34a0b3e943572bc.jpg"></figure><p><strong>Using Postman (see image above and the corresponding numbered steps below:</strong></p><ol><li><p>Change the protocol to POST</p></li><li><p>Enter the Public IP Address of your EC2 Instance: <strong>http://18.224.96.38</strong></p></li><li><p>Change Tab to Body</p></li><li><p>Select the form-data radio button</p></li><li><p>From the drop down, select Key type to be file</p></li><li><p>For Value, select one of our test images</p></li><li><p>Click send to send our image to our API</p></li><li><p>Our response will be shown in the window below.</p></li></ol><p><strong>The output is JSON file containing:</strong></p><pre class="prettyprint linenums">{
+    "MainColor": "Red",
+    "catOrDog": "Cat"
+}</pre><p>The cool thing about using Postman is that we can generate the code to call this API in several different languages:</p><p>See blue box to bring up the <strong>code </strong>box:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_06-15-21-9b7592ec57e8a4769ac2d8d8d649580c.jpg"></figure><p><strong>Code Generator</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-23_00-55-22-1aaeea8249c6c70d464a1ece0466b273.JPG"></figure><p><strong>Note</strong>: To keep our API running constantly launch the python code using this instead:</p><p><code>sudo nohup python3 forms.py &amp; screen</code></p><p><br></p><h4><strong>Conclusion</strong></h4><p><br></p><p>So you've just successfully deployed a Computer Vision Web App and API that can be used by users anywhere in the world! This facilitates many possibilities from developing Mobile Apps, startup products and research tools. However, it should be noted there are many improvements that can be made:</p><ul><li><p>Saving our uploaded image to as S3 Bucket. We don't want to store all these images on our API server and it wasn't designed for mass storage. It's quite easy to configure and S3 bucket and store all uploaded images there. If privacy is a concern we can forget that entirely and use Python to delete the image after it's been processed.</p></li><li><p>Using Nginx or Gunicorn or something similar to be the main server for our API</p></li><li><p>Using a more scalable design (this far from my expertise, but if you ever wanted to support simultaneous users, you'll need to make some adjustments. </p></li></ul><p><br></p>

3. Installation Guide/3. Setting up your Deep Learning Virtual Machine (Download Code, VM & Slides here!).srt

@@ -0,0 +1,651 @@
+1
+00:00:00,550 --> 00:00:00,880
+All right.
+
+2
+00:00:00,880 --> 00:00:05,500
+So welcome to chapter tree where we set up a planning development machine.
+
+3
+00:00:05,500 --> 00:00:10,160
+So now that you've gone through the intro you're now ready to get started setting up your machine.
+
+4
+00:00:10,240 --> 00:00:11,730
+So let's get to it.
+
+5
+00:00:11,740 --> 00:00:17,380
+So now the first step in setting up a deepening virtual machine is you need to download Virtual Box
+
+6
+00:00:17,440 --> 00:00:24,100
+Virtual Box is a software that allows us to actually start an entirely new operating system whether
+
+7
+00:00:24,130 --> 00:00:30,460
+it be Linux Windows or Mac OS although it's not fully supported for Mac OS but you can actually run
+
+8
+00:00:30,490 --> 00:00:33,500
+an entire new operating system with in a virtual box.
+
+9
+00:00:33,510 --> 00:00:34,170
+It's super cool.
+
+10
+00:00:34,160 --> 00:00:35,560
+It's called ritualize.
+
+11
+00:00:35,800 --> 00:00:43,960
+And it is super fast on new use didn't experience any slowdown really and it is entirely useful for
+
+12
+00:00:43,960 --> 00:00:49,580
+us to set up our deepening machine because deepening software on Windows is not well-supported.
+
+13
+00:00:49,660 --> 00:00:55,450
+However on Linux or Ubuntu it is a very good environment for running on our software.
+
+14
+00:00:55,780 --> 00:01:01,740
+So what you do now is you download either to Windows OS X versions according to what you're using.
+
+15
+00:01:01,960 --> 00:01:03,480
+So I'm not going to be Windows.
+
+16
+00:01:03,480 --> 00:01:05,020
+I've really done with it here.
+
+17
+00:01:05,380 --> 00:01:13,390
+So now what you do as well is you download from the link in the resources file download the deepening
+
+18
+00:01:13,420 --> 00:01:15,100
+C-v open to that.
+
+19
+00:01:15,180 --> 00:01:15,950
+File.
+
+20
+00:01:16,210 --> 00:01:21,450
+This is your wish your machine that we're going to set up so that you have those two files.
+
+21
+00:01:21,760 --> 00:01:23,840
+Here we are ready to get started.
+
+22
+00:01:23,890 --> 00:01:27,250
+So now we have to firstly install virtual box.
+
+23
+00:01:27,250 --> 00:01:30,050
+Now I know this file is quite huge just nine gigs.
+
+24
+00:01:30,220 --> 00:01:35,470
+So you probably would have wanted to leave this overnight if you have a relatively slow broadband connection.
+
+25
+00:01:35,470 --> 00:01:38,350
+However if you're a fast connection should take about an hour.
+
+26
+00:01:38,790 --> 00:01:40,870
+Either way let's install virtual box
+
+27
+00:01:43,800 --> 00:01:46,150
+so you get to run standard procedure.
+
+28
+00:01:49,150 --> 00:01:52,600
+I'm not going to do the Mac install video because I don't have access to a Mac.
+
+29
+00:01:52,690 --> 00:01:55,590
+But as soon as I do upload a video for you Mac users.
+
+30
+00:01:55,720 --> 00:02:00,340
+However it's a standard installation procedure and all the settings are the same but generally for Mac
+
+31
+00:02:00,400 --> 00:02:01,370
+and Windows.
+
+32
+00:02:01,420 --> 00:02:04,150
+So this should relate to you as well.
+
+33
+00:02:04,810 --> 00:02:06,810
+So you leave all the details here as well.
+
+34
+00:02:06,840 --> 00:02:08,480
+It's best next.
+
+35
+00:02:08,500 --> 00:02:17,590
+Next again you can optionally can do this if you want find this is fine press yes install.
+
+36
+00:02:17,610 --> 00:02:18,150
+Do we go
+
+37
+00:02:23,490 --> 00:02:23,840
+OK.
+
+38
+00:02:23,870 --> 00:02:27,600
+So we've finished installation process and now you can start.
+
+39
+00:02:27,650 --> 00:02:31,130
+You'll get your rocks off and I'll show you how to get everything set up.
+
+40
+00:02:31,130 --> 00:02:31,470
+All right.
+
+41
+00:02:31,470 --> 00:02:37,550
+So here we are on a virtual box manage your software so please ignore these two virtual machines I have
+
+42
+00:02:37,550 --> 00:02:37,820
+a break.
+
+43
+00:02:37,820 --> 00:02:42,930
+No yours is going to be blank right now since semanticists and you're going to be using this.
+
+44
+00:02:42,950 --> 00:02:46,730
+So go to file and import appliance.
+
+45
+00:02:46,940 --> 00:02:52,470
+And now go to the directory where you downloaded your virtual box start of the file.
+
+46
+00:02:52,500 --> 00:02:53,330
+All right.
+
+47
+00:02:53,460 --> 00:02:57,260
+So go to open and press next.
+
+48
+00:02:57,260 --> 00:03:03,070
+Now I have it set to my virtual machine to use force use and use it to exit from.
+
+49
+00:03:03,170 --> 00:03:05,370
+That is basically of course CPI.
+
+50
+00:03:05,390 --> 00:03:10,550
+So I have it logical cause and I have and get 16 gig of ram in my system.
+
+51
+00:03:10,550 --> 00:03:17,110
+So you're going to want to put it to at least half of what your host system can support.
+
+52
+00:03:17,120 --> 00:03:20,690
+So if you have a dual call you can use two here.
+
+53
+00:03:20,750 --> 00:03:24,330
+And if you have it is a Frahm you can use for gigs here.
+
+54
+00:03:24,680 --> 00:03:27,960
+So we can make those adjustments and leave everything else the same.
+
+55
+00:03:27,960 --> 00:03:32,830
+It's fine and good to import.
+
+56
+00:03:33,020 --> 00:03:37,840
+And now this time is basically a lie it's going to take maybe about 10 20 minutes.
+
+57
+00:03:37,840 --> 00:03:42,820
+So I'm going to pause the video here and when it's done we can start off with your machine and I'll
+
+58
+00:03:42,820 --> 00:03:43,780
+show you how to use it.
+
+59
+00:03:43,780 --> 00:03:47,580
+It's quite easy and we'll get done it and set up whole code.
+
+60
+00:03:47,710 --> 00:03:48,960
+And that should be at
+
+61
+00:03:51,780 --> 00:03:52,140
+OK.
+
+62
+00:03:52,160 --> 00:03:53,000
+So that's it.
+
+63
+00:03:53,000 --> 00:03:56,430
+We have just installed virtual machine.
+
+64
+00:03:56,460 --> 00:04:00,050
+So now this is the new one here because I already have it working here.
+
+65
+00:04:00,050 --> 00:04:02,960
+It came up as under school one knows is going to be this one.
+
+66
+00:04:02,960 --> 00:04:04,980
+So either way it's the same machine.
+
+67
+00:04:05,000 --> 00:04:09,230
+So let's just start this one fresh one I just installed.
+
+68
+00:04:10,160 --> 00:04:21,270
+It takes about maybe tity seconds to boot up at least on my system.
+
+69
+00:04:21,430 --> 00:04:24,340
+This is all normal by the way it's a pudding's screenful and Ventoux
+
+70
+00:04:33,510 --> 00:04:34,120
+There we go.
+
+71
+00:04:34,320 --> 00:04:35,650
+So we're loaded.
+
+72
+00:04:35,880 --> 00:04:36,770
+Oh yes.
+
+73
+00:04:36,780 --> 00:04:37,670
+This is pretty cool.
+
+74
+00:04:37,670 --> 00:04:41,470
+So now you're actually running Ubuntu within Windows.
+
+75
+00:04:41,850 --> 00:04:45,660
+And it's because it's using of which lies those features on your CD.
+
+76
+00:04:46,020 --> 00:04:47,430
+It's going to run pretty quick.
+
+77
+00:04:47,430 --> 00:04:49,460
+You're not going to notice much of a slowdown.
+
+78
+00:04:49,470 --> 00:04:52,110
+So what I want to do is two things I want to show you.
+
+79
+00:04:52,110 --> 00:04:55,580
+First of all your password for your virtual machine.
+
+80
+00:04:55,800 --> 00:05:01,950
+Whenever you do sudo or any sort of flick system settings we change users and stuff the password for
+
+81
+00:05:01,950 --> 00:05:05,960
+this user is 1 1 2 2 treat 3 4 4.
+
+82
+00:05:06,180 --> 00:05:11,820
+It's going to be in the touch resources of your file and I'm going to display it on screen as well.
+
+83
+00:05:11,940 --> 00:05:13,260
+So you don't forget it.
+
+84
+00:05:13,290 --> 00:05:17,130
+So let's just see something here.
+
+85
+00:05:17,130 --> 00:05:23,090
+So what I want to show you is that we have our old machine this is all file structure here.
+
+86
+00:05:23,160 --> 00:05:25,640
+So this is a home directory right now.
+
+87
+00:05:25,890 --> 00:05:28,690
+We have a bunch of things installed here right now.
+
+88
+00:05:29,190 --> 00:05:33,380
+Basically this these things are a lot of deepening libraries.
+
+89
+00:05:33,420 --> 00:05:38,550
+And I have some instructions as well you don't need to use these right now but what I want to show you
+
+90
+00:05:38,550 --> 00:05:42,310
+is to basically set up your code and train models.
+
+91
+00:05:42,330 --> 00:05:42,880
+OK.
+
+92
+00:05:43,170 --> 00:05:44,300
+So stay tuned.
+
+93
+00:05:44,650 --> 00:05:44,950
+OK.
+
+94
+00:05:44,970 --> 00:05:53,210
+So what I'm going to need you to do is open Firefox that's a web browser on the buntu by default and
+
+95
+00:05:53,210 --> 00:06:01,800
+what to do is when Firefox boots up I want you to go to your dummy account when you come and with the
+
+96
+00:06:01,840 --> 00:06:07,460
+attached resources to this lesson which is also the deep linning code library.
+
+97
+00:06:07,540 --> 00:06:11,950
+Let's just wait for it to boot up here I think my system has a lot of stuff running right now.
+
+98
+00:06:12,110 --> 00:06:14,820
+But either way just go to your dummy dot com
+
+99
+00:06:17,690 --> 00:06:19,650
+and is like Friday so we're on right now.
+
+100
+00:06:19,650 --> 00:06:20,750
+Nice.
+
+101
+00:06:20,780 --> 00:06:24,290
+So what to do is basically log into your account.
+
+102
+00:06:24,470 --> 00:06:25,840
+However you've done it before.
+
+103
+00:06:25,880 --> 00:06:32,300
+Whichever method you use and download the resources for this for the course that's the code and Treen
+
+104
+00:06:32,300 --> 00:06:38,270
+model is zip file and download it and it's going to save in your Downloads folder right here.
+
+105
+00:06:38,270 --> 00:06:39,470
+This is the same file.
+
+106
+00:06:40,010 --> 00:06:42,620
+And this is a file once you extract.
+
+107
+00:06:42,740 --> 00:06:50,720
+So double click and this file is going to take a bit to 10 seconds or so to open it's a big file.
+
+108
+00:06:50,750 --> 00:06:53,990
+So it's reasonable.
+
+109
+00:06:54,180 --> 00:07:00,120
+And this file here I want you to extract it to your home directory here.
+
+110
+00:07:00,660 --> 00:07:02,370
+So let's go ahead and do that
+
+111
+00:07:05,210 --> 00:07:08,020
+let's just reduce this clutter in the background.
+
+112
+00:07:09,010 --> 00:07:13,630
+And this takes about a minute actually less much less 10 minutes to extract
+
+113
+00:07:22,690 --> 00:07:31,350
+and when it's done you will see all the code that we need for this course is in a convenient location.
+
+114
+00:07:31,480 --> 00:07:33,130
+So just quit this
+
+115
+00:07:35,680 --> 00:07:36,270
+close
+
+116
+00:07:39,700 --> 00:07:40,850
+and doing something.
+
+117
+00:07:40,880 --> 00:07:42,750
+But that's fine.
+
+118
+00:07:42,760 --> 00:07:48,510
+What I want to do is go to home and now you see just Eritrea de-planing CV and it is also a shortcut
+
+119
+00:07:48,630 --> 00:07:50,530
+to do the same directory.
+
+120
+00:07:50,850 --> 00:07:52,770
+And let's go back to it here.
+
+121
+00:07:52,830 --> 00:07:55,620
+This is decomp.
+
+122
+00:07:55,620 --> 00:08:00,020
+The contents of this are actually sortable and list here.
+
+123
+00:08:00,030 --> 00:08:05,360
+These are this is all the code entery Mullins is going to need the discourse and it's conveniently extracted
+
+124
+00:08:05,360 --> 00:08:07,210
+now within your virtual machine.
+
+125
+00:08:07,220 --> 00:08:09,070
+So now let's go back to Python.
+
+126
+00:08:09,080 --> 00:08:10,460
+Sorry Otunnu.
+
+127
+00:08:10,880 --> 00:08:13,150
+So let's play this.
+
+128
+00:08:13,160 --> 00:08:16,580
+So what if we wanted to test our code.
+
+129
+00:08:16,880 --> 00:08:26,090
+So what do you do you go to you press source type source activate C-v that's what the plumbing environment
+
+130
+00:08:26,090 --> 00:08:27,100
+for computer vision.
+
+131
+00:08:27,440 --> 00:08:28,680
+And it's instantly done.
+
+132
+00:08:28,730 --> 00:08:30,860
+And now you type python.
+
+133
+00:08:31,420 --> 00:08:34,890
+Notebook and magic happens.
+
+134
+00:08:34,890 --> 00:08:39,390
+What this does it starts a local server that hosts your it on the browser.
+
+135
+00:08:39,900 --> 00:08:45,240
+So now this is where we run all our Python code and I'm going is going to do a brief tutorial on that
+
+136
+00:08:45,260 --> 00:08:45,870
+here.
+
+137
+00:08:46,130 --> 00:08:51,100
+So now just good de-planing CV that's just good chapter for getting started.
+
+138
+00:08:51,450 --> 00:08:54,990
+And let's run our Actually let's run our life sketching
+
+139
+00:08:59,390 --> 00:09:03,020
+because this loads much quicker and we don't need any files for this.
+
+140
+00:09:03,020 --> 00:09:06,870
+So let's run this block of code.
+
+141
+00:09:07,070 --> 00:09:11,450
+I put on the books are basically just blocks of code we can run and all the variables everything is
+
+142
+00:09:11,450 --> 00:09:13,460
+stored inside of it.
+
+143
+00:09:13,910 --> 00:09:19,400
+So you press shift and still control and to shift and to run it here.
+
+144
+00:09:19,430 --> 00:09:25,820
+This takes about maybe five seconds or less every print division up and see that we're we're using 3.4.
+
+145
+00:09:26,150 --> 00:09:29,440
+If you press Allt and you get a new line below.
+
+146
+00:09:29,480 --> 00:09:34,690
+So that's sometimes convenient sometimes not shift into just runs it with our precinct producing this
+
+147
+00:09:34,700 --> 00:09:36,020
+new cell here.
+
+148
+00:09:36,170 --> 00:09:38,890
+And to delete that espress cut.
+
+149
+00:09:38,960 --> 00:09:46,460
+So now let's run our sketch now before we do this we're going to have to go with devices here webcams
+
+150
+00:09:46,490 --> 00:09:48,930
+and take off integrated webcam.
+
+151
+00:09:49,280 --> 00:09:54,490
+And now let's press shift into to run this block of gold.
+
+152
+00:09:54,530 --> 00:09:55,050
+There we go.
+
+153
+00:09:55,130 --> 00:09:59,320
+So this is our browser all lives this is me chatting here.
+
+154
+00:09:59,540 --> 00:10:00,590
+This is my microphone.
+
+155
+00:10:00,590 --> 00:10:01,910
+The door is in the back.
+
+156
+00:10:01,910 --> 00:10:04,450
+So this is pretty cool isn't it.
+
+157
+00:10:04,850 --> 00:10:08,480
+So that's close us and that is it.
+
+158
+00:10:08,480 --> 00:10:10,270
+So we have all of the code here.
+
+159
+00:10:10,310 --> 00:10:16,020
+Everything is preinstalled all the terror Karris tends to flow a bunch of supporting libraries.
+
+160
+00:10:16,080 --> 00:10:21,410
+The lib is installed a lot of things are stored Actually it probably takes about an hour to do even
+
+161
+00:10:21,600 --> 00:10:23,400
+with some sometimes to install everything.
+
+162
+00:10:23,750 --> 00:10:24,350
+So that's it.
+
+163
+00:10:24,350 --> 00:10:27,930
+You have your full video machine running here.

3. Installation Guide/3.1 Download Your Deep Learning Virtual Machine HERE.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1XK_rbOwAweGBeaFX_EF9b6j6Fs8OvFB6/view?usp=sharing";</script>

3. Installation Guide/3.1 Slides.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/14ji_XyZEIR6jyQoX9CfAtMrlouF-zmmL/view?usp=sharing";</script>

3. Installation Guide/3.2 Code.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1YKJnrir2-lRoJaSs89pxG2RUsJD_Ig09/view?usp=sharing";</script>

3. Installation Guide/3.2 Slides.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/14ji_XyZEIR6jyQoX9CfAtMrlouF-zmmL/view?usp=sharing";</script>

3. Installation Guide/3.3 Code.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1YKJnrir2-lRoJaSs89pxG2RUsJD_Ig09/view?usp=sharing";</script>

3. Installation Guide/3.3 Download Your Deep Learning Virtual Machine HERE.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1XK_rbOwAweGBeaFX_EF9b6j6Fs8OvFB6/view?usp=sharing";</script>

3. Installation Guide/3.4 MIRROR - Download Your Deep Learning Virtual Machine HERE.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://1drv.ms/u/s!AkTkTuTv8A66axQZQWaLla8zKgU";</script>

3. Installation Guide/4. Optional - Troubleshooting Guide for VM Setup & for resolving some MacOS Issues.html

@@ -0,0 +1 @@
+<h4><strong>Troubleshooting guide</strong></h4><p><br></p><p>If you get any issues (happens on various systems and configurations, please look at the guide below for the possible solutions). If not, please post a screenshot of your error in the class forum and we'll try to assist.</p><p><strong>Summary of this document.</strong></p><ol><li><p>ERROR # 1: Failed to Import Appliance</p></li><li><p>ERROR #&nbsp;2: Failed to open a session for the virtual machine Deep Learning CV Ubuntu</p></li><li><p>ERROR&nbsp;#&nbsp;3 - (May appear as Warnings) Broken links to shared folder found?</p></li><li><p>ERROR&nbsp;# 4 - On Macs it's advised you install the feature the feature pack for virtualbox</p></li><li><p>ERROR&nbsp;#&nbsp;5 (Common) - VirtualBox fails with “Implementation of the USB 2.0 controller not found” after upgrading</p></li><li><p><br></p></li><li><p>MAC&nbsp;OS&nbsp;Guide - Installing VirtualBox Extension Pack on MacOS (required to access webcam)</p></li></ol><p><br></p><p><strong>NOTE 2019 Update:</strong></p><p>With newer versions of windows there are more Virtualbox issues.</p><p>The following need to be turned off in windows features for VM to run:</p><ul><li><p>&lt;any&gt; Guard</p></li><li><p>Containers</p></li><li><p>Hyper-V</p></li><li><p>Virtual Machine Platform</p></li><li><p>Windows Hypervisor Platform</p></li><li><p>Windows Sandbox</p></li><li><p>Windows Subsystem for Linux (WSL)</p></li></ul><h4><strong>ERROR # 1: Failed to Import Appliance</strong></h4><p><br></p><p> If you get the following error:</p><p><br></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-14_02-04-35-b413486faaa3f008838cbdb1c7a870c9.jpg"></figure><p>1. Move the .vmdk file to your second (bigger) disk. To do this click on <strong><em>"Global tools"</em></strong>, choose the correct vmdk file and select move. It requires few minutes to do it.</p><p>2. Create a new virtual machine clicking on the new button.</p><p>3. Select Linux -&gt; Ubuntu 64 bit.</p><p>4. Choose either 8192 or 4096 megabytes of RAM. Rule of thumb is half of your installed RAM.</p><p>5. On the next screen choose <strong><em>"Use an existing fixed virtual disk"</em></strong> and selected the just created .vmdk file</p><p><br></p><p>If for some reason this doesn't work. Try this:</p><p>1. Go the properties:</p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-14_02-28-46-c332017914bd027e9c6dca365cdc0901.jpg"></figure><p>2. Click on remove to delete your virtual hard disk</p><p>3. Do the procedure of importing the virtual machine again from the start (only once) and you will get the error again.&nbsp; </p><p>4. Then try the above procedure again</p><p><br></p><p><strong>Thanks to student PierLuigi for this guide!</strong></p><p><br></p><h4><strong>Alternative option:</strong></h4><p><br></p><ul><li><p>Import OVA using <a href="https://www.vmware.com/" rel="noopener noreferrer" target="_blank">VMWare</a> </p></li></ul><p><br></p><h4><strong>ERROR #&nbsp;2: Failed to open a session for the virtual machine Deep Learning CV Ubuntu</strong></h4><p>Implementation of the USB 2.0 controller not found!</p><p>Because the USB 2.0 controller state is part of the saved VM state, the VM cannot be started. To fix this problem, either install the <strong>'Oracle VM VirtualBox Extension Pack'</strong> or disable USB 2.0 support in the VM settings.</p><p>Note! This error could also mean that an incompatible version of the <strong>'Oracle VM VirtualBox Extension Pack'</strong> is installed (VERR_NOT_FOUND).</p><p>Result Code: E_FAIL (0x80004005)Component: ConsoleWrapInterface: IConsole {872da645-4a9b-1727-bee2-5585105b9eed}</p><p><strong>SOLUTION HERE</strong>&nbsp;- <a href="https://www.virtualbox.org/ticket/8182" rel="noopener noreferrer" target="_blank">https://www.virtualbox.org/ticket/8182</a></p><p>Simply:</p><ul><li><p>Right click on the vm image &gt; USB &gt; USB 1.1</p></li></ul><p><br></p><p><br></p><h4><strong>ERROR&nbsp;#&nbsp;3 - Broken links to shared folder </strong></h4><p>Ignore those messages and if needed setup your own shared folder (see Lecture 9).</p><h4></h4><h4><strong>ERROR&nbsp;# 4 - On Macs it's advised you install the feature the feature pack for virtualbox</strong></h4><p><br></p><h4><strong>ERROR&nbsp;#&nbsp;5 (Common) - </strong><a href="https://askubuntu.com/questions/453393/virtualbox-fails-with-implementation-of-the-usb-2-0-controller-not-found-after" rel="noopener noreferrer" target="_blank"><strong>VirtualBox fails with “Implementation of the USB 2.0 controller not found” after upgrading</strong></a></h4><p><br></p><p><strong> Disable USB Controller</strong> when first loading if USB&nbsp;Error. Uncheck the Enable USB&nbsp;Controller box. </p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-04-27_15-14-37-2a9596158be15bdd38eb67e9348089f8.png"></figure><p><br></p><p>Then after loaded up, install the Guest Additions by finding it here from the top toolbar menu.</p><p><img alt="Image result for install guest additions virtualbox" src="https://www.liberiangeek.net/wp-content/uploads/2013/01/ubuntu_guest_machine_virtualbox_thumb.png"></p><p><br></p><p><strong>ERROR 6: E_FAIL(0x8004005)</strong></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2019-08-30_16-54-20-055edba0a3aa98e4deac73d849f0e3a3.png"></figure><p>Solution: <a href="http://youtube.com/watch?reload=9&amp;v=u0AWnCr80Ws" rel="noopener noreferrer" target="_blank">youtube.com/watch?reload=9&amp;v=u0AWnCr80Ws</a></p><h4><strong>Installing VirtualBox Extension Pack on MacOS (required to access webcam)</strong></h4><p>Credit for these steps goes to one of your yellow students, Erwin. </p><p><br></p><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-9c9f231990eb2ee9e6cd3d68ec15f8c4.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-c31318cf7ab409e52d353ca5ecc176bd.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-99ac6eebfe76a5881d32f6ae31c1839a.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-36e8f6edbb68720a47b8ff8f0d4b1431.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-a3e46f9d1bd5a43346c5dc4bc0b2846c.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-e44b63802431cc75e76bbcf781cd7942.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-17670b449a0e1a61c518806c39f9a090.png"></figure><figure><img src="https://udemy-images.s3.amazonaws.com:443/redactor/raw/2018-12-21_17-47-28-b41c3f03a46225655b3fcf63478bcff7.png"></figure><p><br></p>

4. Get Started! Handwritting Recognition, Simple Object Classification & OpenCV Demo/4.1 - Handwritten Digit Classification Demo (MNIST).ipynb

@@ -0,0 +1,656 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Let's load a Handwritten Digit classifier we'll be building very soon!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T16:02:55.674903Z",
+     "start_time": "2025-03-13T16:02:41.962641Z"
+    }
+   },
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "import tensorflow.keras\n",
+    "from tensorflow.keras.datasets import mnist\n",
+    "from tensorflow.keras.models import load_model\n",
+    "\n"
+   ],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-03-13 21:32:43.419874: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-03-13 21:32:43.428343: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-03-13 21:32:43.459714: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1741881763.520586   24229 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1741881763.535534   24229 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2025-03-13 21:32:43.581360: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T15:53:32.218716Z",
+     "start_time": "2025-03-13T15:53:31.940957Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "classifier = load_model('mnist_simple_cnn.h5' )",
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-03-13 21:23:31.971561: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:152] failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: UNKNOWN ERROR (303)\n",
+      "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    }
+   ],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "jupyter": {
+     "is_executing": true
+    },
+    "ExecuteTime": {
+     "start_time": "2025-03-13T15:53:54.412494Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "print(classifier.summary())\n",
+    "# loads the MNIST dataset\n",
+    "(x_train, y_train), (x_test, y_test)  = mnist.load_data()\n",
+    "\n",
+    "def draw_test(name, pred, input_im):\n",
+    "    BLACK = [0,0,0]\n",
+    "    expanded_image = cv2.copyMakeBorder(input_im, 0, 0, 0, imageL.shape[0] ,cv2.BORDER_CONSTANT,value=BLACK)\n",
+    "    expanded_image = cv2.cvtColor(expanded_image, cv2.COLOR_GRAY2BGR)\n",
+    "    cv2.putText(expanded_image, str(pred), (152, 70) , cv2.FONT_HERSHEY_COMPLEX_SMALL,4, (0,255,0), 2)\n",
+    "    cv2.imshow(name, expanded_image)\n",
+    "\n",
+    "for i in range(0,10):\n",
+    "    rand = np.random.randint(0,len(x_test))\n",
+    "    input_im = x_test[rand]\n",
+    "\n",
+    "    imageL = cv2.resize(input_im, None, fx=4, fy=4, interpolation = cv2.INTER_CUBIC)\n",
+    "    input_im = input_im.reshape(1,28,28,1)\n",
+    "\n",
+    "    ## Get Prediction\n",
+    "    res = str(classifier.predict(input_im, 1, verbose = 0)[0])\n",
+    "    draw_test(\"Prediction\", res, imageL)\n",
+    "    cv2.waitKey(0)\n",
+    "\n",
+    "\n",
+    "cv2.destroyAllWindows()\n"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1mModel: \"sequential_3\"\u001B[0m\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_3\"</span>\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001B[1m \u001B[0m\u001B[1mLayer (type)                   \u001B[0m\u001B[1m \u001B[0m┃\u001B[1m \u001B[0m\u001B[1mOutput Shape          \u001B[0m\u001B[1m \u001B[0m┃\u001B[1m \u001B[0m\u001B[1m      Param #\u001B[0m\u001B[1m \u001B[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (\u001B[38;5;33mConv2D\u001B[0m)               │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m26\u001B[0m, \u001B[38;5;34m26\u001B[0m, \u001B[38;5;34m32\u001B[0m)     │           \u001B[38;5;34m320\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (\u001B[38;5;33mConv2D\u001B[0m)               │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m24\u001B[0m, \u001B[38;5;34m24\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │        \u001B[38;5;34m18,496\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (\u001B[38;5;33mMaxPooling2D\u001B[0m)  │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (\u001B[38;5;33mDropout\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (\u001B[38;5;33mFlatten\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m9216\u001B[0m)           │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (\u001B[38;5;33mDense\u001B[0m)                 │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m128\u001B[0m)            │     \u001B[38;5;34m1,179,776\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (\u001B[38;5;33mDropout\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m128\u001B[0m)            │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (\u001B[38;5;33mDense\u001B[0m)                 │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m10\u001B[0m)             │         \u001B[38;5;34m1,290\u001B[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">24</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">24</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">9216</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │     <span style=\"color: #00af00; text-decoration-color: #00af00\">1,179,776</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,290</span> │\n",
+       "└──���──────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Total params: \u001B[0m\u001B[38;5;34m1,199,884\u001B[0m (4.58 MB)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,199,884</span> (4.58 MB)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Trainable params: \u001B[0m\u001B[38;5;34m1,199,882\u001B[0m (4.58 MB)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,199,882</span> (4.58 MB)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Non-trainable params: \u001B[0m\u001B[38;5;34m0\u001B[0m (0.00 B)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Optimizer params: \u001B[0m\u001B[38;5;34m2\u001B[0m (12.00 B)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Optimizer params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2</span> (12.00 B)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "execution_count": null
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T16:05:45.557030Z",
+     "start_time": "2025-03-13T16:05:45.541940Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "import numpy",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing our classifier on a real image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "jupyter": {
+     "is_executing": true
+    },
+    "ExecuteTime": {
+     "start_time": "2025-03-13T16:05:47.832541Z"
+    }
+   },
+   "source": [
+    "import numpy as np\n",
+    "import cv2\n",
+    "from preprocessors import x_cord_contour, makeSquare, resize_to_pixel\n",
+    "       \n",
+    "image = cv2.imread('images/numbers.jpg')\n",
+    "gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\n",
+    "cv2.imshow(\"image\", image)\n",
+    "cv2.waitKey(0)\n",
+    "\n",
+    "# Blur image then find edges using Canny \n",
+    "blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n",
+    "#cv2.imshow(\"blurred\", blurred)\n",
+    "#cv2.waitKey(0)\n",
+    "\n",
+    "edged = cv2.Canny(blurred, 30, 150)\n",
+    "#cv2.imshow(\"edged\", edged)\n",
+    "#cv2.waitKey(0)\n",
+    "\n",
+    "# Find Contours\n",
+    "contours, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
+    "\n",
+    "#Sort out contours left to right by using their x cordinates\n",
+    "contours = sorted(contours, key = x_cord_contour, reverse = False)\n",
+    "\n",
+    "# Create empty array to store entire number\n",
+    "full_number = []\n",
+    "\n",
+    "# loop over the contours\n",
+    "for c in contours:\n",
+    "    # compute the bounding box for the rectangle\n",
+    "    (x, y, w, h) = cv2.boundingRect(c)    \n",
+    "\n",
+    "    if w >= 5 and h >= 25:\n",
+    "        roi = blurred[y:y + h, x:x + w]\n",
+    "        ret, roi = cv2.threshold(roi, 127, 255,cv2.THRESH_BINARY_INV)\n",
+    "        roi = makeSquare(roi)\n",
+    "        roi = resize_to_pixel(28, roi)\n",
+    "        cv2.imshow(\"ROI\", roi)\n",
+    "        roi = roi / 255.0       \n",
+    "        roi = roi.reshape(1,28,28,1) \n",
+    "\n",
+    "        ## Get Prediction\n",
+    "        res = str(classifier.predict_classes(roi, 1, verbose = 0)[0])\n",
+    "        full_number.append(res)\n",
+    "        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)\n",
+    "        cv2.putText(image, res, (x , y + 155), cv2.FONT_HERSHEY_COMPLEX, 2, (255, 0, 0), 2)\n",
+    "        cv2.imshow(\"image\", image)\n",
+    "        cv2.waitKey(0) \n",
+    "        \n",
+    "cv2.destroyAllWindows()\n",
+    "print (\"The number is: \" + ''.join(full_number))"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training this Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T13:12:31.511869Z",
+     "start_time": "2025-03-13T12:29:08.572403Z"
+    }
+   },
+   "source": [
+    "from tensorflow.keras.datasets import mnist\n",
+    "from tensorflow.keras.utils import to_categorical\n",
+    "from tensorflow.keras.optimizers import Adadelta\n",
+    "from tensorflow.keras.datasets import mnist\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout, Flatten\n",
+    "from tensorflow.keras.layers import Conv2D, MaxPooling2D ,Input\n",
+    "from tensorflow.keras import backend as K\n",
+    "\n",
+    "# Training Parameters\n",
+    "batch_size = 128\n",
+    "epochs = 20\n",
+    "\n",
+    "# loads the MNIST dataset\n",
+    "(x_train, y_train), (x_test, y_test)  = mnist.load_data()\n",
+    "\n",
+    "# Lets store the number of rows and columns\n",
+    "img_rows = x_train[0].shape[0]\n",
+    "img_cols = x_train[1].shape[0]\n",
+    "\n",
+    "# Getting our date in the right 'shape' needed for Keras\n",
+    "# We need to add a 4th dimenion to our date thereby changing our\n",
+    "# Our original image shape of (60000,28,28) to (60000,28,28,1)\n",
+    "x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
+    "x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
+    "\n",
+    "# store the shape of a single image \n",
+    "input_shape = (img_rows, img_cols, 1)\n",
+    "\n",
+    "# change our image type to float32 data type\n",
+    "x_train = x_train.astype('float32')\n",
+    "x_test = x_test.astype('float32')\n",
+    "\n",
+    "# Normalize our data by changing the range from (0 to 255) to (0 to 1)\n",
+    "x_train /= 255\n",
+    "x_test /= 255\n",
+    "\n",
+    "print('x_train shape:', x_train.shape)\n",
+    "print(x_train.shape[0], 'train samples')\n",
+    "print(x_test.shape[0], 'test samples')\n",
+    "\n",
+    "# Now we one hot encode outputs\n",
+    "y_train = to_categorical(y_train)\n",
+    "y_test = to_categorical(y_test)\n",
+    "\n",
+    "# Let's count the number columns in our hot encoded matrix \n",
+    "print (\"Number of Classes: \" + str(y_test.shape[1]))\n",
+    "\n",
+    "num_classes = y_test.shape[1]\n",
+    "num_pixels = x_train.shape[1] * x_train.shape[2]\n",
+    "\n",
+    "# create model\n",
+    "model = Sequential()\n",
+    "\n",
+    "model.add(Input(shape=(28,28,1)))\n",
+    "model.add(Conv2D(32, kernel_size=(3, 3),\n",
+    "                 activation='relu',\n",
+    "                 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(num_classes, activation='softmax'))\n",
+    "\n",
+    "model.compile(loss = 'categorical_crossentropy',\n",
+    "              optimizer = Adadelta(),\n",
+    "              metrics = ['accuracy'])\n",
+    "\n",
+    "print(model.summary())\n",
+    "\n",
+    "history = model.fit(x_train, y_train,\n",
+    "          batch_size=batch_size,\n",
+    "          epochs=epochs,\n",
+    "          verbose=1,\n",
+    "          validation_data=(x_test, y_test))\n",
+    "\n",
+    "score = model.evaluate(x_test, y_test, verbose=0)\n",
+    "print('Test loss:', score[0])\n",
+    "print('Test accuracy:', score[1])"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x_train shape: (60000, 28, 28, 1)\n",
+      "60000 train samples\n",
+      "10000 test samples\n",
+      "Number of Classes: 10\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1mModel: \"sequential_3\"\u001B[0m\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_3\"</span>\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001B[1m \u001B[0m\u001B[1mLayer (type)                   \u001B[0m\u001B[1m \u001B[0m┃\u001B[1m \u001B[0m\u001B[1mOutput Shape          \u001B[0m\u001B[1m \u001B[0m┃\u001B[1m \u001B[0m\u001B[1m      Param #\u001B[0m\u001B[1m \u001B[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (\u001B[38;5;33mConv2D\u001B[0m)               │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m26\u001B[0m, \u001B[38;5;34m26\u001B[0m, \u001B[38;5;34m32\u001B[0m)     │           \u001B[38;5;34m320\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (\u001B[38;5;33mConv2D\u001B[0m)               │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m24\u001B[0m, \u001B[38;5;34m24\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │        \u001B[38;5;34m18,496\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (\u001B[38;5;33mMaxPooling2D\u001B[0m)  │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (\u001B[38;5;33mDropout\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m12\u001B[0m, \u001B[38;5;34m64\u001B[0m)     │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (\u001B[38;5;33mFlatten\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m9216\u001B[0m)           │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (\u001B[38;5;33mDense\u001B[0m)                 │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m128\u001B[0m)            │     \u001B[38;5;34m1,179,776\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (\u001B[38;5;33mDropout\u001B[0m)             │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m128\u001B[0m)            │             \u001B[38;5;34m0\u001B[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (\u001B[38;5;33mDense\u001B[0m)                 │ (\u001B[38;5;45mNone\u001B[0m, \u001B[38;5;34m10\u001B[0m)             │         \u001B[38;5;34m1,290\u001B[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">26</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">24</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">24</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">9216</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │     <span style=\"color: #00af00; text-decoration-color: #00af00\">1,179,776</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,290</span> │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Total params: \u001B[0m\u001B[38;5;34m1,199,882\u001B[0m (4.58 MB)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,199,882</span> (4.58 MB)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Trainable params: \u001B[0m\u001B[38;5;34m1,199,882\u001B[0m (4.58 MB)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,199,882</span> (4.58 MB)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\u001B[1m Non-trainable params: \u001B[0m\u001B[38;5;34m0\u001B[0m (0.00 B)\n"
+      ],
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+       "</pre>\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n",
+      "Epoch 1/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-03-13 17:59:09.869544: W external/local_xla/xla/tsl/framework/cpu_allocator_impl.cc:83] Allocation of 188160000 exceeds 10% of free system memory.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m110s\u001B[0m 229ms/step - accuracy: 0.1052 - loss: 2.3000 - val_accuracy: 0.2693 - val_loss: 2.2488\n",
+      "Epoch 2/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m162s\u001B[0m 271ms/step - accuracy: 0.2265 - loss: 2.2399 - val_accuracy: 0.4505 - val_loss: 2.1755\n",
+      "Epoch 3/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m101s\u001B[0m 215ms/step - accuracy: 0.3401 - loss: 2.1674 - val_accuracy: 0.5460 - val_loss: 2.0756\n",
+      "Epoch 4/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m98s\u001B[0m 208ms/step - accuracy: 0.4168 - loss: 2.0707 - val_accuracy: 0.6309 - val_loss: 1.9400\n",
+      "Epoch 5/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m101s\u001B[0m 216ms/step - accuracy: 0.4859 - loss: 1.9388 - val_accuracy: 0.7004 - val_loss: 1.7650\n",
+      "Epoch 6/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m148s\u001B[0m 228ms/step - accuracy: 0.5514 - loss: 1.7740 - val_accuracy: 0.7517 - val_loss: 1.5543\n",
+      "Epoch 7/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m106s\u001B[0m 225ms/step - accuracy: 0.5989 - loss: 1.5901 - val_accuracy: 0.7860 - val_loss: 1.3342\n",
+      "Epoch 8/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m141s\u001B[0m 224ms/step - accuracy: 0.6395 - loss: 1.4047 - val_accuracy: 0.8053 - val_loss: 1.1347\n",
+      "Epoch 9/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m106s\u001B[0m 226ms/step - accuracy: 0.6621 - loss: 1.2518 - val_accuracy: 0.8213 - val_loss: 0.9769\n",
+      "Epoch 10/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m118s\u001B[0m 252ms/step - accuracy: 0.6848 - loss: 1.1299 - val_accuracy: 0.8310 - val_loss: 0.8569\n",
+      "Epoch 11/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m140s\u001B[0m 298ms/step - accuracy: 0.7070 - loss: 1.0295 - val_accuracy: 0.8393 - val_loss: 0.7659\n",
+      "Epoch 12/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m139s\u001B[0m 297ms/step - accuracy: 0.7191 - loss: 0.9594 - val_accuracy: 0.8467 - val_loss: 0.6961\n",
+      "Epoch 13/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m139s\u001B[0m 297ms/step - accuracy: 0.7353 - loss: 0.8954 - val_accuracy: 0.8541 - val_loss: 0.6418\n",
+      "Epoch 14/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m141s\u001B[0m 301ms/step - accuracy: 0.7501 - loss: 0.8407 - val_accuracy: 0.8598 - val_loss: 0.5981\n",
+      "Epoch 15/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m145s\u001B[0m 309ms/step - accuracy: 0.7608 - loss: 0.8010 - val_accuracy: 0.8637 - val_loss: 0.5631\n",
+      "Epoch 16/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m140s\u001B[0m 299ms/step - accuracy: 0.7708 - loss: 0.7630 - val_accuracy: 0.8675 - val_loss: 0.5345\n",
+      "Epoch 17/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m140s\u001B[0m 294ms/step - accuracy: 0.7818 - loss: 0.7294 - val_accuracy: 0.8720 - val_loss: 0.5091\n",
+      "Epoch 18/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m136s\u001B[0m 290ms/step - accuracy: 0.7874 - loss: 0.7058 - val_accuracy: 0.8745 - val_loss: 0.4890\n",
+      "Epoch 19/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m141s\u001B[0m 301ms/step - accuracy: 0.7911 - loss: 0.6918 - val_accuracy: 0.8777 - val_loss: 0.4711\n",
+      "Epoch 20/20\n",
+      "\u001B[1m469/469\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m144s\u001B[0m 306ms/step - accuracy: 0.7922 - loss: 0.6763 - val_accuracy: 0.8803 - val_loss: 0.4562\n",
+      "Test loss: 0.4561978578567505\n",
+      "Test accuracy: 0.880299985408783\n"
+     ]
+    }
+   ],
+   "execution_count": 19
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": ""
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T13:19:19.771353Z",
+     "start_time": "2025-03-13T13:19:19.412004Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "model.save(\"mnist_simple_cnn.h5\")",
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
+     ]
+    }
+   ],
+   "execution_count": 20
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T13:20:22.752001Z",
+     "start_time": "2025-03-13T13:20:14.810410Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "score = model.evaluate(x_test, y_test, verbose=0)\n",
+   "outputs": [],
+   "execution_count": 22
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": ""
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

4. Get Started! Handwritting Recognition, Simple Object Classification & OpenCV Demo/4.2 - Image Classifier - CIFAR10.ipynb

@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Let's run a simple image classifier, using the CIFAR 10 dataset of 10 image categories\n",
+    "* CIFAR's 10 categories:\n",
+    " * airplane\n",
+    " * automobile\n",
+    " * bird\n",
+    " * cat\n",
+    " * deer\n",
+    " * dog\n",
+    " * frog\n",
+    " * horse\n",
+    " * ship\n",
+    " * truck"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T16:11:52.999533Z",
+     "start_time": "2025-03-13T16:11:47.171043Z"
+    }
+   },
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "from tensorflow.keras.models import load_model\n",
+    "from tensorflow.keras.datasets import cifar10 \n",
+    "\n",
+    "img_row, img_height, img_depth = 32,32,3\n",
+    "\n",
+    "classifier = load_model('cifar_simple_cnn.h5')\n",
+    "\n",
+    "# Loads the CIFAR dataset\n",
+    "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
+    "color = True \n",
+    "scale = 8\n",
+    "\n",
+    "def draw_test(name, res, input_im, scale, img_row, img_height):\n",
+    "    BLACK = [0,0,0]\n",
+    "    res = int(res)\n",
+    "    if res == 0:\n",
+    "        pred = \"airplane\"\n",
+    "    if res == 1:\n",
+    "        pred = \"automobile\"\n",
+    "    if res == 2:\n",
+    "        pred = \"bird\"\n",
+    "    if res == 3:\n",
+    "        pred = \"cat\"\n",
+    "    if res == 4:\n",
+    "        pred = \"deer\"\n",
+    "    if res == 5:\n",
+    "        pred = \"dog\"\n",
+    "    if res == 6:\n",
+    "        pred = \"frog\"\n",
+    "    if res == 7:\n",
+    "        pred = \"horse\"\n",
+    "    if res == 8:\n",
+    "        pred = \"ship\"\n",
+    "    if res == 9:\n",
+    "        pred = \"truck\"\n",
+    "        \n",
+    "    expanded_image = cv2.copyMakeBorder(input_im, 0, 0, 0, imageL.shape[0]*2 ,cv2.BORDER_CONSTANT,value=BLACK)\n",
+    "    if color == False:\n",
+    "        expanded_image = cv2.cvtColor(expanded_image, cv2.COLOR_GRAY2BGR)\n",
+    "    cv2.putText(expanded_image, str(pred), (300, 80) , cv2.FONT_HERSHEY_COMPLEX_SMALL,4, (0,255,0), 2)\n",
+    "    cv2.imshow(name, expanded_image)\n",
+    "\n",
+    "\n",
+    "for i in range(0,10):\n",
+    "    rand = np.random.randint(0,len(x_test))\n",
+    "    input_im = x_test[rand]\n",
+    "    imageL = cv2.resize(input_im, None, fx=scale, fy=scale, interpolation = cv2.INTER_CUBIC) \n",
+    "    input_im = input_im.reshape(1,img_row, img_height, img_depth) \n",
+    "    \n",
+    "    ## Get Prediction\n",
+    "    res = str(classifier.predict_classes(input_im, 1, verbose = 0)[0])\n",
+    "    \n",
+    "    draw_test(\"Prediction\", res, imageL, scale, img_row, img_height) \n",
+    "    cv2.waitKey(0)\n",
+    "\n",
+    "cv2.destroyAllWindows()"
+   ],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-03-13 21:41:47.742478: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-03-13 21:41:47.746738: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-03-13 21:41:47.759288: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1741882307.783990   24522 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1741882307.790137   24522 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2025-03-13 21:41:47.814207: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "/home/newton/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+      "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "Kernel shape must have the same length as input, but received kernel of shape (3, 3, 3, 32) and input of shape (None, None, 32, 32, 3).",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mValueError\u001B[0m                                Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[1], line 8\u001B[0m\n\u001B[1;32m      4\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mtensorflow\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mkeras\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mdatasets\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m cifar10 \n\u001B[1;32m      6\u001B[0m img_row, img_height, img_depth \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m32\u001B[39m,\u001B[38;5;241m32\u001B[39m,\u001B[38;5;241m3\u001B[39m\n\u001B[0;32m----> 8\u001B[0m classifier \u001B[38;5;241m=\u001B[39m load_model(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mcifar_simple_cnn.h5\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m     10\u001B[0m \u001B[38;5;66;03m# Loads the CIFAR dataset\u001B[39;00m\n\u001B[1;32m     11\u001B[0m (x_train, y_train), (x_test, y_test) \u001B[38;5;241m=\u001B[39m cifar10\u001B[38;5;241m.\u001B[39mload_data()\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/saving/saving_api.py:196\u001B[0m, in \u001B[0;36mload_model\u001B[0;34m(filepath, custom_objects, compile, safe_mode)\u001B[0m\n\u001B[1;32m    189\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m saving_lib\u001B[38;5;241m.\u001B[39mload_model(\n\u001B[1;32m    190\u001B[0m         filepath,\n\u001B[1;32m    191\u001B[0m         custom_objects\u001B[38;5;241m=\u001B[39mcustom_objects,\n\u001B[1;32m    192\u001B[0m         \u001B[38;5;28mcompile\u001B[39m\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mcompile\u001B[39m,\n\u001B[1;32m    193\u001B[0m         safe_mode\u001B[38;5;241m=\u001B[39msafe_mode,\n\u001B[1;32m    194\u001B[0m     )\n\u001B[1;32m    195\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mstr\u001B[39m(filepath)\u001B[38;5;241m.\u001B[39mendswith((\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m.h5\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m.hdf5\u001B[39m\u001B[38;5;124m\"\u001B[39m)):\n\u001B[0;32m--> 196\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m legacy_h5_format\u001B[38;5;241m.\u001B[39mload_model_from_hdf5(\n\u001B[1;32m    197\u001B[0m         filepath, custom_objects\u001B[38;5;241m=\u001B[39mcustom_objects, \u001B[38;5;28mcompile\u001B[39m\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mcompile\u001B[39m\n\u001B[1;32m    198\u001B[0m     )\n\u001B[1;32m    199\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28mstr\u001B[39m(filepath)\u001B[38;5;241m.\u001B[39mendswith(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m.keras\u001B[39m\u001B[38;5;124m\"\u001B[39m):\n\u001B[1;32m    200\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m    201\u001B[0m         \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mFile not found: filepath=\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mfilepath\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m. \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    202\u001B[0m         \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPlease ensure the file is an accessible `.keras` \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    203\u001B[0m         \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mzip file.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    204\u001B[0m     )\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/legacy/saving/legacy_h5_format.py:133\u001B[0m, in \u001B[0;36mload_model_from_hdf5\u001B[0;34m(filepath, custom_objects, compile)\u001B[0m\n\u001B[1;32m    130\u001B[0m model_config \u001B[38;5;241m=\u001B[39m json_utils\u001B[38;5;241m.\u001B[39mdecode(model_config)\n\u001B[1;32m    132\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m saving_options\u001B[38;5;241m.\u001B[39mkeras_option_scope(use_legacy_config\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m):\n\u001B[0;32m--> 133\u001B[0m     model \u001B[38;5;241m=\u001B[39m saving_utils\u001B[38;5;241m.\u001B[39mmodel_from_config(\n\u001B[1;32m    134\u001B[0m         model_config, custom_objects\u001B[38;5;241m=\u001B[39mcustom_objects\n\u001B[1;32m    135\u001B[0m     )\n\u001B[1;32m    137\u001B[0m     \u001B[38;5;66;03m# set weights\u001B[39;00m\n\u001B[1;32m    138\u001B[0m     load_weights_from_hdf5_group(f[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmodel_weights\u001B[39m\u001B[38;5;124m\"\u001B[39m], model)\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/legacy/saving/saving_utils.py:85\u001B[0m, in \u001B[0;36mmodel_from_config\u001B[0;34m(config, custom_objects)\u001B[0m\n\u001B[1;32m     81\u001B[0m \u001B[38;5;66;03m# TODO(nkovela): Swap find and replace args during Keras 3.0 release\u001B[39;00m\n\u001B[1;32m     82\u001B[0m \u001B[38;5;66;03m# Replace keras refs with keras\u001B[39;00m\n\u001B[1;32m     83\u001B[0m config \u001B[38;5;241m=\u001B[39m _find_replace_nested_dict(config, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeras.\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeras.\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m---> 85\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m serialization\u001B[38;5;241m.\u001B[39mdeserialize_keras_object(\n\u001B[1;32m     86\u001B[0m     config,\n\u001B[1;32m     87\u001B[0m     module_objects\u001B[38;5;241m=\u001B[39mMODULE_OBJECTS\u001B[38;5;241m.\u001B[39mALL_OBJECTS,\n\u001B[1;32m     88\u001B[0m     custom_objects\u001B[38;5;241m=\u001B[39mcustom_objects,\n\u001B[1;32m     89\u001B[0m     printable_module_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mlayer\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m     90\u001B[0m )\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/legacy/saving/serialization.py:495\u001B[0m, in \u001B[0;36mdeserialize_keras_object\u001B[0;34m(identifier, module_objects, custom_objects, printable_module_name)\u001B[0m\n\u001B[1;32m    490\u001B[0m cls_config \u001B[38;5;241m=\u001B[39m _find_replace_nested_dict(\n\u001B[1;32m    491\u001B[0m     cls_config, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeras.\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkeras.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    492\u001B[0m )\n\u001B[1;32m    494\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcustom_objects\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;129;01min\u001B[39;00m arg_spec\u001B[38;5;241m.\u001B[39margs:\n\u001B[0;32m--> 495\u001B[0m     deserialized_obj \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39mfrom_config(\n\u001B[1;32m    496\u001B[0m         cls_config,\n\u001B[1;32m    497\u001B[0m         custom_objects\u001B[38;5;241m=\u001B[39m{\n\u001B[1;32m    498\u001B[0m             \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mobject_registration\u001B[38;5;241m.\u001B[39mGLOBAL_CUSTOM_OBJECTS,\n\u001B[1;32m    499\u001B[0m             \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mcustom_objects,\n\u001B[1;32m    500\u001B[0m         },\n\u001B[1;32m    501\u001B[0m     )\n\u001B[1;32m    502\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m    503\u001B[0m     \u001B[38;5;28;01mwith\u001B[39;00m object_registration\u001B[38;5;241m.\u001B[39mCustomObjectScope(custom_objects):\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/models/sequential.py:359\u001B[0m, in \u001B[0;36mSequential.from_config\u001B[0;34m(cls, config, custom_objects)\u001B[0m\n\u001B[1;32m    354\u001B[0m     \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m    355\u001B[0m         layer \u001B[38;5;241m=\u001B[39m serialization_lib\u001B[38;5;241m.\u001B[39mdeserialize_keras_object(\n\u001B[1;32m    356\u001B[0m             layer_config,\n\u001B[1;32m    357\u001B[0m             custom_objects\u001B[38;5;241m=\u001B[39mcustom_objects,\n\u001B[1;32m    358\u001B[0m         )\n\u001B[0;32m--> 359\u001B[0m     model\u001B[38;5;241m.\u001B[39madd(layer)\n\u001B[1;32m    360\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m (\n\u001B[1;32m    361\u001B[0m     \u001B[38;5;129;01mnot\u001B[39;00m model\u001B[38;5;241m.\u001B[39m_functional\n\u001B[1;32m    362\u001B[0m     \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mbuild_input_shape\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mlocals\u001B[39m()\n\u001B[1;32m    363\u001B[0m     \u001B[38;5;129;01mand\u001B[39;00m build_input_shape\n\u001B[1;32m    364\u001B[0m     \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(build_input_shape, (\u001B[38;5;28mtuple\u001B[39m, \u001B[38;5;28mlist\u001B[39m))\n\u001B[1;32m    365\u001B[0m ):\n\u001B[1;32m    366\u001B[0m     model\u001B[38;5;241m.\u001B[39mbuild(build_input_shape)\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/models/sequential.py:122\u001B[0m, in \u001B[0;36mSequential.add\u001B[0;34m(self, layer, rebuild)\u001B[0m\n\u001B[1;32m    120\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers\u001B[38;5;241m.\u001B[39mappend(layer)\n\u001B[1;32m    121\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m rebuild:\n\u001B[0;32m--> 122\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_maybe_rebuild()\n\u001B[1;32m    123\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m    124\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mbuilt \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mFalse\u001B[39;00m\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/models/sequential.py:141\u001B[0m, in \u001B[0;36mSequential._maybe_rebuild\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m    139\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers[\u001B[38;5;241m0\u001B[39m], InputLayer) \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m1\u001B[39m:\n\u001B[1;32m    140\u001B[0m     input_shape \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers[\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39mbatch_shape\n\u001B[0;32m--> 141\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mbuild(input_shape)\n\u001B[1;32m    142\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28mhasattr\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers[\u001B[38;5;241m0\u001B[39m], \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124minput_shape\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m1\u001B[39m:\n\u001B[1;32m    143\u001B[0m     \u001B[38;5;66;03m# We can build the Sequential model if the first layer has the\u001B[39;00m\n\u001B[1;32m    144\u001B[0m     \u001B[38;5;66;03m# `input_shape` property. This is most commonly found in Functional\u001B[39;00m\n\u001B[1;32m    145\u001B[0m     \u001B[38;5;66;03m# model.\u001B[39;00m\n\u001B[1;32m    146\u001B[0m     input_shape \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers[\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39minput_shape\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/layers/layer.py:228\u001B[0m, in \u001B[0;36mLayer.__new__.<locals>.build_wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m    226\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m obj\u001B[38;5;241m.\u001B[39m_open_name_scope():\n\u001B[1;32m    227\u001B[0m     obj\u001B[38;5;241m.\u001B[39m_path \u001B[38;5;241m=\u001B[39m current_path()\n\u001B[0;32m--> 228\u001B[0m     original_build_method(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m    229\u001B[0m \u001B[38;5;66;03m# Record build config.\u001B[39;00m\n\u001B[1;32m    230\u001B[0m signature \u001B[38;5;241m=\u001B[39m inspect\u001B[38;5;241m.\u001B[39msignature(original_build_method)\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/models/sequential.py:187\u001B[0m, in \u001B[0;36mSequential.build\u001B[0;34m(self, input_shape)\u001B[0m\n\u001B[1;32m    185\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m layer \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_layers[\u001B[38;5;241m1\u001B[39m:]:\n\u001B[1;32m    186\u001B[0m     \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m--> 187\u001B[0m         x \u001B[38;5;241m=\u001B[39m layer(x)\n\u001B[1;32m    188\u001B[0m     \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mNotImplementedError\u001B[39;00m:\n\u001B[1;32m    189\u001B[0m         \u001B[38;5;66;03m# Can happen if shape inference is not implemented.\u001B[39;00m\n\u001B[1;32m    190\u001B[0m         \u001B[38;5;66;03m# TODO: consider reverting inbound nodes on layers processed.\u001B[39;00m\n\u001B[1;32m    191\u001B[0m         \u001B[38;5;28;01mreturn\u001B[39;00m\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/utils/traceback_utils.py:122\u001B[0m, in \u001B[0;36mfilter_traceback.<locals>.error_handler\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m    119\u001B[0m     filtered_tb \u001B[38;5;241m=\u001B[39m _process_traceback_frames(e\u001B[38;5;241m.\u001B[39m__traceback__)\n\u001B[1;32m    120\u001B[0m     \u001B[38;5;66;03m# To get the full stack trace, call:\u001B[39;00m\n\u001B[1;32m    121\u001B[0m     \u001B[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001B[39;00m\n\u001B[0;32m--> 122\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m e\u001B[38;5;241m.\u001B[39mwith_traceback(filtered_tb) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m    123\u001B[0m \u001B[38;5;28;01mfinally\u001B[39;00m:\n\u001B[1;32m    124\u001B[0m     \u001B[38;5;28;01mdel\u001B[39;00m filtered_tb\n",
+      "File \u001B[0;32m~/miniconda3/envs/dl/lib/python3.12/site-packages/keras/src/ops/operation_utils.py:184\u001B[0m, in \u001B[0;36mcompute_conv_output_shape\u001B[0;34m(input_shape, filters, kernel_size, strides, padding, data_format, dilation_rate)\u001B[0m\n\u001B[1;32m    182\u001B[0m     kernel_shape \u001B[38;5;241m=\u001B[39m kernel_size \u001B[38;5;241m+\u001B[39m (input_shape[\u001B[38;5;241m1\u001B[39m], filters)\n\u001B[1;32m    183\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(kernel_shape) \u001B[38;5;241m!=\u001B[39m \u001B[38;5;28mlen\u001B[39m(input_shape):\n\u001B[0;32m--> 184\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m    185\u001B[0m         \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mKernel shape must have the same length as input, but received \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    186\u001B[0m         \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mkernel of shape \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mkernel_shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m and \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    187\u001B[0m         \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124minput of shape \u001B[39m\u001B[38;5;132;01m{\u001B[39;00minput_shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m    188\u001B[0m     )\n\u001B[1;32m    189\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(dilation_rate, \u001B[38;5;28mint\u001B[39m):\n\u001B[1;32m    190\u001B[0m     dilation_rate \u001B[38;5;241m=\u001B[39m (dilation_rate,) \u001B[38;5;241m*\u001B[39m \u001B[38;5;28mlen\u001B[39m(spatial_shape)\n",
+      "\u001B[0;31mValueError\u001B[0m: Kernel shape must have the same length as input, but received kernel of shape (3, 3, 3, 32) and input of shape (None, None, 32, 32, 3)."
+     ]
+    }
+   ],
+   "execution_count": 1
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

4. Get Started! Handwritting Recognition, Simple Object Classification & OpenCV Demo/4.3. Live Sketching.ipynb

@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T12:18:54.614963Z",
+     "start_time": "2025-03-13T12:18:52.126661Z"
+    }
+   },
+   "source": [
+    "#import keras\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "print (cv2.__version__)"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4.11.0\n"
+     ]
+    }
+   ],
+   "execution_count": 1
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T12:25:16.378140Z",
+     "start_time": "2025-03-13T12:25:15.608514Z"
+    }
+   },
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "\n",
+    "# Our sketch generating function\n",
+    "def sketch(image):\n",
+    "    # Convert image to grayscale\n",
+    "    img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
+    "    \n",
+    "    # Clean up image using Guassian Blur\n",
+    "    img_gray_blur = cv2.GaussianBlur(img_gray, (5,5), 0)\n",
+    "    \n",
+    "    # Extract edges\n",
+    "    canny_edges = cv2.Canny(img_gray_blur, 20, 50)\n",
+    "    \n",
+    "    # Do an invert binarize the image \n",
+    "    ret, mask = cv2.threshold(canny_edges, 70, 255, cv2.THRESH_BINARY_INV)\n",
+    "    return mask\n",
+    "\n",
+    "\n",
+    "# Initialize webcam, cap is the object provided by VideoCapture\n",
+    "# It contains a boolean indicating if it was sucessful (ret)\n",
+    "# It also contains the images collected from the webcam (frame)\n",
+    "cap = cv2.VideoCapture(2)\n",
+    "\n",
+    "while True:\n",
+    "    ret, frame = cap.read()\n",
+    "    cv2.imshow('Our Live Sketcher', sketch(frame))\n",
+    "    if cv2.waitKey(1) == 13 or cv2.waitKey(1) == 27: #13 is the Enter Key\n",
+    "        break\n",
+    "        \n",
+    "# Release camera and close windows\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()      "
+   ],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[ WARN:0@382.189] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video2): can't open camera by index\n",
+      "[ERROR:0@382.862] global obsensor_uvc_stream_channel.cpp:158 getStreamChannelGroup Camera index out of range\n",
+      "[ WARN:0@382.866] global cap_v4l.cpp:803 requestBuffers VIDEOIO(V4L2:/dev/video2): failed VIDIOC_REQBUFS: errno=19 (No such device)\n"
+     ]
+    },
+    {
+     "ename": "error",
+     "evalue": "OpenCV(4.11.0) /io/opencv/modules/imgproc/src/color.cpp:199: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31merror\u001B[0m                                     Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[6], line 27\u001B[0m\n\u001B[1;32m     25\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[1;32m     26\u001B[0m     ret, frame \u001B[38;5;241m=\u001B[39m cap\u001B[38;5;241m.\u001B[39mread()\n\u001B[0;32m---> 27\u001B[0m     cv2\u001B[38;5;241m.\u001B[39mimshow(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mOur Live Sketcher\u001B[39m\u001B[38;5;124m'\u001B[39m, sketch(frame))\n\u001B[1;32m     28\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m cv2\u001B[38;5;241m.\u001B[39mwaitKey(\u001B[38;5;241m1\u001B[39m) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m13\u001B[39m \u001B[38;5;129;01mor\u001B[39;00m cv2\u001B[38;5;241m.\u001B[39mwaitKey(\u001B[38;5;241m1\u001B[39m) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m27\u001B[39m: \u001B[38;5;66;03m#13 is the Enter Key\u001B[39;00m\n\u001B[1;32m     29\u001B[0m         \u001B[38;5;28;01mbreak\u001B[39;00m\n",
+      "Cell \u001B[0;32mIn[6], line 7\u001B[0m, in \u001B[0;36msketch\u001B[0;34m(image)\u001B[0m\n\u001B[1;32m      5\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21msketch\u001B[39m(image):\n\u001B[1;32m      6\u001B[0m     \u001B[38;5;66;03m# Convert image to grayscale\u001B[39;00m\n\u001B[0;32m----> 7\u001B[0m     img_gray \u001B[38;5;241m=\u001B[39m cv2\u001B[38;5;241m.\u001B[39mcvtColor(image, cv2\u001B[38;5;241m.\u001B[39mCOLOR_BGR2GRAY)\n\u001B[1;32m      9\u001B[0m     \u001B[38;5;66;03m# Clean up image using Guassian Blur\u001B[39;00m\n\u001B[1;32m     10\u001B[0m     img_gray_blur \u001B[38;5;241m=\u001B[39m cv2\u001B[38;5;241m.\u001B[39mGaussianBlur(img_gray, (\u001B[38;5;241m5\u001B[39m,\u001B[38;5;241m5\u001B[39m), \u001B[38;5;241m0\u001B[39m)\n",
+      "\u001B[0;31merror\u001B[0m: OpenCV(4.11.0) /io/opencv/modules/imgproc/src/color.cpp:199: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n"
+     ]
+    }
+   ],
+   "execution_count": 6
+  },
+  {
+   "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

4. Get Started! Handwritting Recognition, Simple Object Classification & OpenCV Demo/Test - Imports Keras, OpenCV and tests webcam.ipynb

@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-03-13T12:26:00.769321Z",
+     "start_time": "2025-03-13T12:25:51.814601Z"
+    }
+   },
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "\n",
+    "# Our sketch generating function\n",
+    "def sketch(image):\n",
+    "    # Convert image to grayscale\n",
+    "    img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
+    "    \n",
+    "    # Clean up image using Gaussian Blur\n",
+    "    img_gray_blur = cv2.GaussianBlur(img_gray, (5,5), 0)\n",
+    "    \n",
+    "    # Extract edges\n",
+    "    canny_edges = cv2.Canny(img_gray_blur, 10, 70)\n",
+    "    \n",
+    "    # Do an invert binarize the image \n",
+    "    ret, mask = cv2.threshold(canny_edges, 70, 255, cv2.THRESH_BINARY_INV)\n",
+    "    return mask\n",
+    "\n",
+    "\n",
+    "# Initialize webcam, cap is the object provided by VideoCapture\n",
+    "# It contains a boolean indicating if it was sucessful (ret)\n",
+    "# It also contains the images collected from the webcam (frame)\n",
+    "cap = cv2.VideoCapture(3)\n",
+    "\n",
+    "while True:\n",
+    "    ret, frame = cap.read()\n",
+    "    cv2.imshow('Our Live Sketcher', sketch(frame))\n",
+    "    if cv2.waitKey(1) == 13: #13 is the Enter Key\n",
+    "        break\n",
+    "        \n",
+    "# Release camera and close windows\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()      "
+   ],
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-02-24T14:10:10.316586Z",
+     "start_time": "2025-02-24T14:10:10.209728Z"
+    }
+   },
+   "source": "cap = cv2.VideoCapture(0)",
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[ WARN:0@1028.418] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video0): can't open camera by index\n",
+      "[ERROR:0@1028.522] global obsensor_uvc_stream_channel.cpp:158 getStreamChannelGroup Camera index out of range\n"
+     ]
+    }
+   ],
+   "execution_count": 24
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-02-24T14:10:11.179764Z",
+     "start_time": "2025-02-24T14:10:11.162834Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "cap.read()\n",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(False, None)"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 25
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "cv2.imshow('Our Live Sketcher', sketch(frame))"
+  }
+ ],
+ "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

4. Get Started! Handwritting Recognition, Simple Object Classification & OpenCV Demo/preprocessors.py

@@ -0,0 +1,65 @@
+import numpy as np
+import cv2
+
+def x_cord_contour(contour):
+    # This function take a contour from findContours
+    # it then outputs the x centroid coordinates
+    M = cv2.moments(contour)
+    return (int(M['m10']/M['m00']))
+
+
+def makeSquare(not_square):
+    # This function takes an image and makes the dimenions square
+    # It adds black pixels as the padding where needed
+    
+    BLACK = [0,0,0]
+    img_dim = not_square.shape
+    height = img_dim[0]
+    width = img_dim[1]
+    #print("Height = ", height, "Width = ", width)
+    if (height == width):
+        square = not_square
+        return square
+    else:
+        doublesize = cv2.resize(not_square,(2*width, 2*height), interpolation = cv2.INTER_CUBIC)
+        height = height * 2
+        width = width * 2
+        #print("New Height = ", height, "New Width = ", width)
+        if (height > width):
+            pad = int((height - width)/2)
+            #print("Padding = ", pad)
+            doublesize_square = cv2.copyMakeBorder(doublesize,0,0,pad,pad,cv2.BORDER_CONSTANT,value=BLACK)
+        else:
+            pad = (width - height)/2
+            #print("Padding = ", pad)
+            doublesize_square = cv2.copyMakeBorder(doublesize,pad,pad,0,0,\
+                                                   cv2.BORDER_CONSTANT,value=BLACK)
+    doublesize_square_dim = doublesize_square.shape
+    #print("Sq Height = ", doublesize_square_dim[0], "Sq Width = ", doublesize_square_dim[1])
+    return doublesize_square
+
+
+def resize_to_pixel(dimensions, image):
+    # This function then re-sizes an image to the specificied dimenions
+    
+    buffer_pix = 4
+    dimensions  = dimensions - buffer_pix
+    squared = image
+    r = float(dimensions) / squared.shape[1]
+    dim = (dimensions, int(squared.shape[0] * r))
+    resized = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
+    img_dim2 = resized.shape
+    height_r = img_dim2[0]
+    width_r = img_dim2[1]
+    BLACK = [0,0,0]
+    if (height_r > width_r):
+        resized = cv2.copyMakeBorder(resized,0,0,0,1,cv2.BORDER_CONSTANT,value=BLACK)
+    if (height_r < width_r):
+        resized = cv2.copyMakeBorder(resized,1,0,0,0,cv2.BORDER_CONSTANT,value=BLACK)
+    p = 2
+    ReSizedImg = cv2.copyMakeBorder(resized,p,p,p,p,cv2.BORDER_CONSTANT,value=BLACK)
+    img_dim = ReSizedImg.shape
+    height = img_dim[0]
+    width = img_dim[1]
+    #print("Padded Height = ", height, "Width = ", width)
+    return ReSizedImg

4. Handwriting Recognition/1. Get Started! Handwriting Recognition, Simple Object Classification OpenCV Demo.srt

@@ -0,0 +1,35 @@
+1
+00:00:00,570 --> 00:00:06,360
+Hi and welcome to chapter 4 where basically the goal of this chapter is to get you up and running quickly
+
+2
+00:00:06,420 --> 00:00:08,130
+using a developing machine.
+
+3
+00:00:08,130 --> 00:00:14,140
+So you get to actually test some already trained classify models and actually play with open C.v.
+
+4
+00:00:14,240 --> 00:00:21,990
+That's the section is broken down into tree chapters or subchapters I should say the first one we do.
+
+5
+00:00:22,020 --> 00:00:24,380
+We play with our handwriting classifier.
+
+6
+00:00:24,420 --> 00:00:30,600
+Second one we use an image classifier and Atid one we use open Sivi to basically turn what your webcam
+
+7
+00:00:30,600 --> 00:00:34,060
+sees which is going to be you into a Live sketch.
+
+8
+00:00:34,080 --> 00:00:36,130
+So stay tuned and let's get started.
+
+9
+00:00:42,120 --> 00:00:43,960
+So.

4. Handwriting Recognition/2. Experiment with a Handwriting Classifier.srt

@@ -0,0 +1,363 @@
+1
+00:00:00,600 --> 00:00:00,970
+OK.
+
+2
+00:00:01,040 --> 00:00:06,930
+So as I said in chapter four point one we're going to use an already trained and you'll understand what
+
+3
+00:00:06,930 --> 00:00:08,660
+training is later on.
+
+4
+00:00:09,030 --> 00:00:13,110
+But you're going to use something that we actually create in this course in the next couple of chapters
+
+5
+00:00:13,630 --> 00:00:15,700
+to classify handwritten digits.
+
+6
+00:00:15,810 --> 00:00:16,870
+So it's going to be pretty cool.
+
+7
+00:00:16,890 --> 00:00:17,960
+So let's get started.
+
+8
+00:00:20,430 --> 00:00:20,770
+OK.
+
+9
+00:00:20,820 --> 00:00:29,930
+So let's bring up our development environment and that source activates C-v.
+
+10
+00:00:30,040 --> 00:00:31,930
+And now let's bring up I put it in the books.
+
+11
+00:00:31,960 --> 00:00:40,410
+This type python notebook and then we go to English and launch and we should have basically O home full
+
+12
+00:00:40,420 --> 00:00:41,410
+of information here.
+
+13
+00:00:41,490 --> 00:00:48,190
+So let's go to deep learning which is where all our projects on 90 percent of our projects are located.
+
+14
+00:00:48,620 --> 00:00:50,770
+And let's go to chapter 4 of this chapter.
+
+15
+00:00:50,780 --> 00:00:52,240
+You can see all the chapters are here.
+
+16
+00:00:54,050 --> 00:00:58,580
+And it's up in this one and it should bring up this.
+
+17
+00:00:58,590 --> 00:01:03,790
+This is called an AI Python book and it has left some simple notes here some comments here.
+
+18
+00:01:04,180 --> 00:01:09,810
+This one I'm not going to actually teach much from discourse here is this code here sorry.
+
+19
+00:01:09,820 --> 00:01:11,470
+I'm just going to actually execute it.
+
+20
+00:01:11,800 --> 00:01:13,660
+And we get to see what it does.
+
+21
+00:01:13,930 --> 00:01:19,740
+So basically before I begin let me just briefly briefly discuss decode these imports here.
+
+22
+00:01:19,750 --> 00:01:26,920
+We're importing open CV non-pay which is array processing library and carious which I'll teach you about
+
+23
+00:01:26,920 --> 00:01:27,550
+later on.
+
+24
+00:01:27,610 --> 00:01:33,550
+This is basically the framework the deep leting framework we use to basically control operate tensor
+
+25
+00:01:33,550 --> 00:01:35,570
+flow which runs in the background.
+
+26
+00:01:35,920 --> 00:01:38,440
+And that does all the playing stuff.
+
+27
+00:01:38,560 --> 00:01:43,240
+So we are loading the amnesty to set here and that's how we are putting in putting this from Karris
+
+28
+00:01:43,240 --> 00:01:45,330
+here loading our model.
+
+29
+00:01:45,700 --> 00:01:51,790
+And then this is a function we use to basically draw the prediction what our model makes over the actual
+
+30
+00:01:51,790 --> 00:01:52,440
+digits.
+
+31
+00:01:52,480 --> 00:01:55,800
+And you know what let's just actually run this and see how it works.
+
+32
+00:01:57,860 --> 00:02:02,240
+It's loading districts here means it's loading.
+
+33
+00:02:02,330 --> 00:02:03,270
+There we go.
+
+34
+00:02:03,290 --> 00:02:10,200
+So now we have basically what this does it brings up a number from a tested asset test it said it's
+
+35
+00:02:10,220 --> 00:02:12,690
+basically images of the machine learning.
+
+36
+00:02:12,700 --> 00:02:18,940
+Sorry the deepening algorithm has not seen and basically tells you that it never saw digit before in
+
+37
+00:02:18,940 --> 00:02:22,790
+its life but it tells you it's able to figure out that this is a 4.
+
+38
+00:02:23,230 --> 00:02:27,890
+So now if you press enter it goes to in image and it basically does is up to 10 images.
+
+39
+00:02:27,920 --> 00:02:35,950
+You can go up to 50 100 to tell us and if you want although I don't recommend going up to 2000 this
+
+40
+00:02:35,950 --> 00:02:38,240
+is a two actually is pretty good.
+
+41
+00:02:38,240 --> 00:02:38,930
+It's an 8.
+
+42
+00:02:38,960 --> 00:02:44,330
+Good 1 1 6 8 tree 5 6.
+
+43
+00:02:44,480 --> 00:02:45,100
+Perfect.
+
+44
+00:02:45,170 --> 00:02:52,250
+So it appears this muddleheaded tree in here called this simple CNN is actually quite good at reading
+
+45
+00:02:53,030 --> 00:02:54,190
+models and numbers.
+
+46
+00:02:54,190 --> 00:02:59,210
+Sorry So can this work on the real numbers now.
+
+47
+00:02:59,550 --> 00:03:00,730
+What do you mean by real numbers.
+
+48
+00:03:00,750 --> 00:03:02,220
+We'll let's find out.
+
+49
+00:03:02,220 --> 00:03:04,520
+Let's run this.
+
+50
+00:03:04,620 --> 00:03:11,300
+If I didn't mention it to you before enter and shift on a keyboard together basically executes decode
+
+51
+00:03:11,430 --> 00:03:14,360
+in the cell block I should have mentioned that the beginning.
+
+52
+00:03:14,400 --> 00:03:15,830
+But you know you know.
+
+53
+00:03:16,170 --> 00:03:16,430
+OK.
+
+54
+00:03:16,440 --> 00:03:17,330
+So this is numbers.
+
+55
+00:03:17,400 --> 00:03:23,550
+I actually wrote and took a picture with my phone and basically what I have to could have done here.
+
+56
+00:03:23,550 --> 00:03:30,660
+It basically uses open C-v to extract the digits here and then it preprocessors it to basically make
+
+57
+00:03:30,660 --> 00:03:35,390
+it look as similar as the trading data for the amnesty to set.
+
+58
+00:03:36,480 --> 00:03:38,290
+And let's see.
+
+59
+00:03:38,290 --> 00:03:40,680
+So basically what it did it took out this one.
+
+60
+00:03:41,030 --> 00:03:47,130
+And you previously saw how the amnesty to set images were basically grayscale and white on black background.
+
+61
+00:03:47,450 --> 00:03:50,150
+So it picked this out extracted it here.
+
+62
+00:03:50,410 --> 00:03:56,730
+This is a con. We drew over it here and immediately it classifies this as one and it puts one here.
+
+63
+00:03:56,870 --> 00:03:57,630
+So that's pretty good.
+
+64
+00:03:57,710 --> 00:04:00,100
+Let's see if it gets a tree correct.
+
+65
+00:04:00,200 --> 00:04:00,780
+Bingo.
+
+66
+00:04:00,780 --> 00:04:02,890
+Got the tree exactly right.
+
+67
+00:04:03,160 --> 00:04:03,730
+The fire.
+
+68
+00:04:03,740 --> 00:04:06,330
+Exactly right 4 0.
+
+69
+00:04:06,650 --> 00:04:08,090
+Perfect.
+
+70
+00:04:08,130 --> 00:04:11,460
+So all of this is my open see the good.
+
+71
+00:04:11,870 --> 00:04:18,410
+And if you want to understand how this code works going explain it's you Torley here but this should
+
+72
+00:04:18,410 --> 00:04:19,440
+be fined.
+
+73
+00:04:20,120 --> 00:04:24,970
+But I'm actually going to tell you that if you do want to learn this look at my open 72 reel.
+
+74
+00:04:25,130 --> 00:04:31,220
+It'll teach you all these things what Gaussian Blue see edges contours how these things work how to
+
+75
+00:04:31,220 --> 00:04:36,680
+use functions and you're sorting a Kontos here and how they actually sort contours and bring them up
+
+76
+00:04:36,680 --> 00:04:42,090
+and extract them and then feed them to classify it which is what we're doing here to see him falsifier
+
+77
+00:04:42,170 --> 00:04:43,230
+we used up here.
+
+78
+00:04:44,150 --> 00:04:46,790
+So we're pretty good.
+
+79
+00:04:47,030 --> 00:04:53,400
+You just actually use a handwritten digital classifier that I built and you're going to build it soon.
+
+80
+00:04:53,570 --> 00:04:56,150
+Actually perhaps you can bill it right now.
+
+81
+00:04:56,150 --> 00:04:58,530
+This is a code where I'm not going to go through in detail.
+
+82
+00:04:58,550 --> 00:05:05,420
+As I said but this is a code that actually allows you to try and classify it is not as complicated as
+
+83
+00:05:05,420 --> 00:05:06,220
+it looks here.
+
+84
+00:05:06,740 --> 00:05:11,400
+If you're unfamiliar with it I expect you to be a little confuse what the hell is that size what are
+
+85
+00:05:11,450 --> 00:05:15,120
+you POCs what is going on here blah blah blah.
+
+86
+00:05:15,440 --> 00:05:19,000
+But don't worry all of these things will be made very simple soon.
+
+87
+00:05:19,400 --> 00:05:22,970
+And basically you understand what these lines mean here.
+
+88
+00:05:23,150 --> 00:05:26,210
+What this means here is actually the accuracy of our model.
+
+89
+00:05:26,530 --> 00:05:29,350
+Ninety nine point zero sum which is pretty good.
+
+90
+00:05:29,350 --> 00:05:32,120
+Not topical lanes to default but pretty good.
+
+91
+00:05:32,480 --> 00:05:37,790
+And stay tuned you're going to learn how to do this in the upcoming chapters.

4. Handwriting Recognition/3. Experiment with a Image Classifier.srt

@@ -0,0 +1,195 @@
+1
+00:00:01,380 --> 00:00:07,690
+So in Section Four point two we're actually going to use probably a little more complicated image Josephina
+
+2
+00:00:08,190 --> 00:00:12,380
+one that classifies 10 different objects and you'll see those objects very soon.
+
+3
+00:00:12,450 --> 00:00:13,630
+So let's get started.
+
+4
+00:00:16,130 --> 00:00:23,900
+OK so now let's open section 4.2 which I called Image toxify Safar 10 probably couldn't come up with
+
+5
+00:00:23,900 --> 00:00:24,870
+a cool name.
+
+6
+00:00:25,150 --> 00:00:25,460
+OK.
+
+7
+00:00:25,490 --> 00:00:28,180
+So I mentioned we're going to classify 10 objects.
+
+8
+00:00:28,220 --> 00:00:35,240
+What this model surfactant is it's a pretty large model data dataset that has tons of pictures of airplanes
+
+9
+00:00:35,240 --> 00:00:39,920
+automobiles birds cats dogs dogs frogs horses ships and trucks.
+
+10
+00:00:39,920 --> 00:00:45,140
+Not entirely sure how they chose these categories of images but maybe it was just for purely research
+
+11
+00:00:45,150 --> 00:00:53,590
+purposes to build image classifiers to detect how well it can pick out these images from data of intrusive
+
+12
+00:00:53,690 --> 00:00:55,580
+images that it receives.
+
+13
+00:00:55,580 --> 00:01:02,360
+So again this is a model I trained and I don't believe this model is actually super accurate but let's
+
+14
+00:01:02,360 --> 00:01:04,570
+run this model and let's find out.
+
+15
+00:01:07,200 --> 00:01:11,510
+This area here before but probably I mean the ethics that let's find out
+
+16
+00:01:15,200 --> 00:01:16,240
+didn't happen again.
+
+17
+00:01:16,490 --> 00:01:17,090
+Get it.
+
+18
+00:01:17,330 --> 00:01:21,010
+So now says this is a ship and this is clearly a call.
+
+19
+00:01:21,050 --> 00:01:24,840
+So we immediately know this model isn't great but it got the idea right.
+
+20
+00:01:24,860 --> 00:01:31,090
+At least things as they're called Shock right shock again because the frog right.
+
+21
+00:01:31,310 --> 00:01:32,170
+Looks like a frog.
+
+22
+00:01:32,180 --> 00:01:37,260
+But it was a ship it's called that automobile bed.
+
+23
+00:01:37,380 --> 00:01:40,050
+Definitely not a truck looks like a cat.
+
+24
+00:01:40,050 --> 00:01:41,530
+This is a truck.
+
+25
+00:01:41,530 --> 00:01:43,070
+So let's roll it one more time.
+
+26
+00:01:47,900 --> 00:01:50,440
+Remember to run the press shift and enter together.
+
+27
+00:01:50,870 --> 00:01:55,580
+And it usually pops up in the window here and windows it pops up on top of the screen which is quite
+
+28
+00:01:55,580 --> 00:01:55,980
+nice.
+
+29
+00:01:56,000 --> 00:02:00,470
+An event that comes up in the back room so you kind of have to look for there but it kind of doesn't
+
+30
+00:02:00,470 --> 00:02:01,610
+shimmy shake thing here.
+
+31
+00:02:01,700 --> 00:02:03,740
+So if you're paying attention you should have seen it.
+
+32
+00:02:03,950 --> 00:02:05,380
+So go to shipwright.
+
+33
+00:02:05,600 --> 00:02:07,140
+It's not a truck it's a frog.
+
+34
+00:02:07,380 --> 00:02:08,860
+It's not a dog it's a cat.
+
+35
+00:02:08,960 --> 00:02:10,160
+It's not a ship it's a bird.
+
+36
+00:02:10,160 --> 00:02:11,630
+This is a dog.
+
+37
+00:02:11,630 --> 00:02:12,470
+This is a deer.
+
+38
+00:02:12,470 --> 00:02:13,580
+This is an airplane.
+
+39
+00:02:13,580 --> 00:02:15,300
+This is called a truck.
+
+40
+00:02:15,300 --> 00:02:19,430
+And that show entirely what they would have labeled it as Truck Show truck.
+
+41
+00:02:19,430 --> 00:02:20,300
+Sure.
+
+42
+00:02:20,300 --> 00:02:24,280
+So as I said later and it isn't a very good model.
+
+43
+00:02:24,290 --> 00:02:30,110
+I think the accuracy I got on this one was 60 or 70 percent actually could have gone a lot higher if
+
+44
+00:02:30,110 --> 00:02:33,800
+I left it for longer probably didn't want to.
+
+45
+00:02:34,430 --> 00:02:39,830
+But this gives you a good idea of limitations of training a model for a short period of time which was
+
+46
+00:02:39,830 --> 00:02:41,650
+this and this was called Safar simple.
+
+47
+00:02:41,770 --> 00:02:44,380
+I think I use a very simple CNN for this one.
+
+48
+00:02:44,780 --> 00:02:48,750
+And later on in the course you're actually going to use far more complicated models.
+
+49
+00:02:48,750 --> 00:02:52,400
+We're going to train for a longer time to get even higher accuracies on these.

4. Handwriting Recognition/4. OpenCV Demo – Live Sketch with Webcam.srt

@@ -0,0 +1,251 @@
+1
+00:00:00,480 --> 00:00:06,330
+OK and no welcome back to Chapter Four point tree where we're now going to use open Sivy a bit more.
+
+2
+00:00:06,420 --> 00:00:11,800
+Now I didn't mention to you maybe I did last two chapters but we did use open C-v slightly.
+
+3
+00:00:11,880 --> 00:00:16,830
+We used up Sivy to basically draw or put a text on the images itself.
+
+4
+00:00:16,830 --> 00:00:20,530
+So when I said prediction was this I'll put a number on them.
+
+5
+00:00:20,820 --> 00:00:26,610
+And then this image basically I was I was using I was done using open C.v.
+
+6
+00:00:26,970 --> 00:00:30,780
+So that's actually use up and see if it has something a little more cool which is giving you a live
+
+7
+00:00:30,780 --> 00:00:35,300
+sketch tree or a webcam.
+
+8
+00:00:35,300 --> 00:00:37,380
+OK so now let's bring up this program.
+
+9
+00:00:37,430 --> 00:00:43,460
+This I in that book called Lives sketching and it comes up here.
+
+10
+00:00:43,490 --> 00:00:46,960
+So now you actually need this code here.
+
+11
+00:00:46,960 --> 00:00:48,430
+It just lets it into actually.
+
+12
+00:00:48,440 --> 00:00:50,610
+So you can test you imports.
+
+13
+00:00:50,630 --> 00:00:52,300
+It's not really necessary.
+
+14
+00:00:52,580 --> 00:00:57,020
+And this is the open secret code here that actually will bring up old sketch.
+
+15
+00:00:57,330 --> 00:01:02,060
+Now firstly I'm going to run this for the first time and I'm going to show you why it's not going to
+
+16
+00:01:02,060 --> 00:01:02,700
+work.
+
+17
+00:01:03,680 --> 00:01:04,430
+There we go.
+
+18
+00:01:04,790 --> 00:01:11,600
+And the area it says here basically this it is C++ code is reporting that it was supposed to get something
+
+19
+00:01:12,020 --> 00:01:14,450
+but it was empty in dysfunction.
+
+20
+00:01:14,900 --> 00:01:21,690
+And basically as you can see from the traceback on Python here this function CVT color it basically
+
+21
+00:01:21,690 --> 00:01:24,010
+it didn't get an image because it was empty.
+
+22
+00:01:24,060 --> 00:01:24,630
+All right.
+
+23
+00:01:24,890 --> 00:01:30,590
+And the reason for that fall is because in Ubuntu individual machine we actually have to be initialized
+
+24
+00:01:30,660 --> 00:01:32,200
+up come first.
+
+25
+00:01:32,210 --> 00:01:34,010
+Now that's basically a one click process.
+
+26
+00:01:34,010 --> 00:01:40,950
+You just go to devices right here and you see something called webcams here integrated webcam basically
+
+27
+00:01:40,950 --> 00:01:42,620
+by looking at it turns it on.
+
+28
+00:01:42,780 --> 00:01:44,690
+And no we run this code again.
+
+29
+00:01:46,450 --> 00:01:46,950
+There we go.
+
+30
+00:01:46,990 --> 00:01:49,260
+So this is me here slouching on my chair.
+
+31
+00:01:49,270 --> 00:01:50,270
+Sorry about that.
+
+32
+00:01:50,680 --> 00:01:54,690
+And this is me here in a sketch waving and stuff to you.
+
+33
+00:01:54,930 --> 00:01:57,190
+You can actually play with a troubles if you want.
+
+34
+00:01:57,190 --> 00:01:59,160
+After But it is pretty cool.
+
+35
+00:01:59,170 --> 00:02:01,560
+Kind of doesn't sketchy outline of me.
+
+36
+00:02:01,930 --> 00:02:10,840
+If I move my laptop around and it's this is my bocher room right here this is my bedroom in the back.
+
+37
+00:02:10,840 --> 00:02:12,800
+All right let's close this here.
+
+38
+00:02:13,300 --> 00:02:16,380
+And as I said you can actually play with it open TV functions.
+
+39
+00:02:16,540 --> 00:02:19,240
+So it opens the function that does the edges here.
+
+40
+00:02:19,240 --> 00:02:21,460
+Is this why Heckel cutting edges.
+
+41
+00:02:21,450 --> 00:02:25,080
+So I've got exactly what this 10 and 70 do.
+
+42
+00:02:25,270 --> 00:02:31,260
+But if I do remember correctly it was manipulating basically the threshold sensitivity.
+
+43
+00:02:31,270 --> 00:02:35,430
+So let's try it this is a range from five to 570.
+
+44
+00:02:35,440 --> 00:02:37,400
+So let's try from 10 to 70.
+
+45
+00:02:37,610 --> 00:02:45,820
+Let's try 5 210 and I'm pretty sure you're going to get more lines and I'll sketch Let's find out.
+
+46
+00:02:46,200 --> 00:02:50,070
+No actually we go to less Landreneau it gets the opposite.
+
+47
+00:02:50,130 --> 00:02:51,990
+So now let's undo that.
+
+48
+00:02:53,920 --> 00:02:54,790
+I tense empty.
+
+49
+00:02:54,800 --> 00:02:58,530
+And let's try to get to 50 and let's put it that way.
+
+50
+00:02:59,310 --> 00:03:02,390
+See what happens to.
+
+51
+00:03:02,650 --> 00:03:03,550
+There we go.
+
+52
+00:03:03,820 --> 00:03:08,710
+A lot more lines in R6 no image you can see the actual lines in my hand.
+
+53
+00:03:08,710 --> 00:03:10,020
+This is actually pretty cool.
+
+54
+00:03:10,360 --> 00:03:14,020
+So that was play open see if you demo here.
+
+55
+00:03:14,250 --> 00:03:19,580
+These are a lot of different open TV functions going on here is Gustin blue changing image from great
+
+56
+00:03:19,650 --> 00:03:20,220
+color.
+
+57
+00:03:21,100 --> 00:03:22,190
+I mean call it the gray.
+
+58
+00:03:22,200 --> 00:03:23,150
+Sorry.
+
+59
+00:03:23,380 --> 00:03:28,960
+Some thresholding if you really do want to learn what's going on here which is not again not necessarily
+
+60
+00:03:29,570 --> 00:03:37,510
+what a deep leading part of course please feel free to do my looping CV of course it's included free
+
+61
+00:03:37,620 --> 00:03:39,860
+in the scores trial is if it's free.
+
+62
+00:03:40,180 --> 00:03:43,100
+So go go ahead and enjoy if you want to it.
+
+63
+00:03:43,240 --> 00:03:46,180
+If not let's get started with learning about neural nets.

5. OpenCV Tutorial - Learn Classic Computer Vision & Face Detection (OPTIONAL)/1.1 Code Download.html

@@ -0,0 +1 @@
+<script type="text/javascript">window.location = "https://drive.google.com/file/d/1qMOZHzl29ib3oJcnd5a4uY0f5TsQd7Y2/view?usp=sharing";</script>

5. OpenCV Tutorial - Learn Classic Computer Vision & Face Detection (OPTIONAL)/10. Transformations, Affine And Non-Affine - The Many Ways We Can Change Images.srt

@@ -0,0 +1,123 @@
+1
+00:00:01,340 --> 00:00:07,350
+Hi and welcome to Section 3 of this course where we take a look at Image manipulations so image manipulations
+
+2
+00:00:07,350 --> 00:00:09,740
+cover a wide range of topics as you can see here.
+
+3
+00:00:09,780 --> 00:00:13,930
+However they're all very important in understanding the foundations of women's CV.
+
+4
+00:00:14,190 --> 00:00:19,500
+So we're going to take a look at some simple transforms then do some simple operations which includes
+
+5
+00:00:19,590 --> 00:00:25,590
+the important thresholding in education which actually forms a foundation of the first mini project
+
+6
+00:00:25,590 --> 00:00:28,800
+you're going to complete which is making a Live sketch of yourself.
+
+7
+00:00:31,030 --> 00:00:33,000
+So let's talk a bit about transmission's.
+
+8
+00:00:33,070 --> 00:00:35,280
+So what exactly are transmission's.
+
+9
+00:00:35,440 --> 00:00:40,660
+Simply put they're geometric distortions in acted upon an image and all these distortions can be symbolic
+
+10
+00:00:40,690 --> 00:00:43,130
+can be things like resizing rotation.
+
+11
+00:00:43,120 --> 00:00:48,460
+Translation However the more complicated distortions such as perspective issues arising from different
+
+12
+00:00:48,460 --> 00:00:50,750
+views that image was captured from.
+
+13
+00:00:51,160 --> 00:00:56,400
+So we would classify transmission's into two main categories and computer vision division fine and none
+
+14
+00:00:56,550 --> 00:00:58,430
+of.
+
+15
+00:00:58,460 --> 00:01:04,220
+So let's talk a bit about fine and I find transmission's now I find transmission's include things such
+
+16
+00:01:04,220 --> 00:01:09,320
+as Skilling rotation and translation and a key point to notice is that lines that were Parlow in the
+
+17
+00:01:09,320 --> 00:01:13,220
+original images are also Pardoe and these transformed images.
+
+18
+00:01:13,220 --> 00:01:18,230
+So where do you skill that image routed or translate parallelism between lines.
+
+19
+00:01:18,230 --> 00:01:24,890
+All of this Benty and not so in French transmissions which are also known as projective and demography
+
+20
+00:01:24,890 --> 00:01:32,950
+transforms as you can see here these lines are no longer parallel in the strands from dementia.
+
+21
+00:01:33,160 --> 00:01:40,200
+However in nunna I find transmissions culinarily an instance is minty and what is called In the early.
+
+22
+00:01:40,420 --> 00:01:46,540
+What it means is that if do all the points on display here remain still on this line and this line and
+
+23
+00:01:46,540 --> 00:01:52,830
+vice versa it's also important to note that none of French transmission's are very common in computer
+
+24
+00:01:52,830 --> 00:01:56,490
+vision and they actually originate from different camera angles.
+
+25
+00:01:56,490 --> 00:01:59,420
+So imagine you were facing the square from a top down view.
+
+26
+00:01:59,760 --> 00:02:05,800
+However you begin to move the camera this way you can imagine your viewpoint with no excuse to you've
+
+27
+00:02:05,850 --> 00:02:07,760
+actually be seeing these two points closer together.
+
+28
+00:02:07,800 --> 00:02:08,710
+Well these two fit.
+
+29
+00:02:08,730 --> 00:02:14,730
+But that is how a non alpha transmissions come about and they always and can be division that we correct
+
+30
+00:02:14,730 --> 00:02:16,640
+these which we will come to shortly.
+
+31
+00:02:18,180 --> 00:02:21,840
+So let's No actually implement some of these transmissions in open sea be called.

5. OpenCV Tutorial - Learn Classic Computer Vision & Face Detection (OPTIONAL)/11. Image Translations - Moving Images Up, Down. Left And Right.srt

@@ -0,0 +1,163 @@
+1
+00:00:00,780 --> 00:00:02,500
+So let's talk a bit about transitions.
+
+2
+00:00:02,550 --> 00:00:07,080
+Transitions are actually very simple and it's basically moving an image in one direction can be left
+
+3
+00:00:07,080 --> 00:00:09,400
+right up down or even diagonally.
+
+4
+00:00:09,400 --> 00:00:13,020
+If you implement an x and y traslation at the same time.
+
+5
+00:00:13,380 --> 00:00:19,950
+So to perform a translation we actually use Open see these C-v to walk a fine function but that function
+
+6
+00:00:19,950 --> 00:00:23,250
+requires what we call the translation matrix.
+
+7
+00:00:23,250 --> 00:00:29,280
+So we are getting into too much high school geometry a translation matrix basically is is in this form
+
+8
+00:00:29,780 --> 00:00:33,020
+and takes an x and y value as these elements here.
+
+9
+00:00:33,450 --> 00:00:39,570
+Now what misrepresents here is a shift along the x axis horizontally and Y is shift along the y axis
+
+10
+00:00:39,570 --> 00:00:40,370
+vertically.
+
+11
+00:00:40,590 --> 00:00:43,180
+And these are the directions each shift takes place.
+
+12
+00:00:43,360 --> 00:00:50,130
+So images all the start of being at the top left corner and retranslated in any direction using the
+
+13
+00:00:50,130 --> 00:00:51,680
+transition matrix here.
+
+14
+00:00:51,750 --> 00:00:53,660
+So let's implement this and quite quickly.
+
+15
+00:00:55,760 --> 00:00:58,750
+So let's implement transitions using open C-v now.
+
+16
+00:00:58,760 --> 00:01:00,230
+So we're going through line by line.
+
+17
+00:01:00,290 --> 00:01:02,580
+I'll quickly show you what's being done here.
+
+18
+00:01:02,600 --> 00:01:06,940
+The important thing to note is that are using to see V2 warp and function.
+
+19
+00:01:07,020 --> 00:01:12,920
+And that's been implemented down here so quickly going through the image as we've done before we extract
+
+20
+00:01:12,920 --> 00:01:17,390
+the height and the width of the image using non-pay see function taking only the first two elements
+
+21
+00:01:17,540 --> 00:01:21,050
+of the ship three that it retains.
+
+22
+00:01:21,290 --> 00:01:25,340
+Next I have a line here where we extract quarter of the height and width of do it.
+
+23
+00:01:25,340 --> 00:01:29,660
+That's going to be a T x and y value in our translation Matrix.
+
+24
+00:01:29,710 --> 00:01:35,400
+That's the direction or sorry the amount of pixels we're going to shift to image.
+
+25
+00:01:35,990 --> 00:01:42,140
+And we actually use not by fluke to the two that actually defines the read data type for where translations
+
+26
+00:01:42,290 --> 00:01:43,680
+matrix.
+
+27
+00:01:44,060 --> 00:01:48,660
+And by using some square brackets here we actually created a T matrix here.
+
+28
+00:01:48,770 --> 00:01:53,600
+It may or may not be important for you understand this but just take note of the form of this t matrix
+
+29
+00:01:53,600 --> 00:01:54,260
+here.
+
+30
+00:01:54,770 --> 00:01:57,270
+So the warp find function takes away image.
+
+31
+00:01:57,270 --> 00:02:04,370
+So if we look at it in the matrix that we created and all within a height as a table and it actually
+
+32
+00:02:04,820 --> 00:02:06,590
+returns the translated image.
+
+33
+00:02:06,650 --> 00:02:09,230
+So let's actually run this and see what it looks like.
+
+34
+00:02:11,040 --> 00:02:20,650
+Tulla this is a translated image here as you can see it's shifted image of an extraction a quarter of
+
+35
+00:02:20,650 --> 00:02:22,840
+the initial dimensions.
+
+36
+00:02:23,050 --> 00:02:27,740
+And similarly for the White image and we're just done with.
+
+37
+00:02:27,760 --> 00:02:32,110
+So it's important to know that we should just take a look at a T matrix to give give you an understanding
+
+38
+00:02:32,110 --> 00:02:33,620
+of what we have done here.
+
+39
+00:02:34,150 --> 00:02:36,870
+So this is exactly what we wanted in 0 2 metrics.
+
+40
+00:02:36,890 --> 00:02:44,800
+It's 1 0 in disorder anti-X and the way this being a quarter of the height and a quarter of the weight
+
+41
+00:02:45,100 --> 00:02:45,720
+respectively.

5. OpenCV Tutorial - Learn Classic Computer Vision & Face Detection (OPTIONAL)/12. Rotations - How To Spin Your Image Around And Do Horizontal Flipping.srt

@@ -0,0 +1,183 @@
+1
+00:00:02,190 --> 00:00:05,050
+So let's talk a bit about rotations now rotations.
+
+2
+00:00:05,220 --> 00:00:06,180
+Pretty simple as well.
+
+3
+00:00:06,180 --> 00:00:09,590
+HOLOVATY also more Quick's that I'll teach you quickly.
+
+4
+00:00:09,720 --> 00:00:15,980
+So using a favorite politician again Donald Trump issued exactly what a rotation is.
+
+5
+00:00:15,990 --> 00:00:20,660
+So as you can see it rotates about a point and this point here in this image is the center.
+
+6
+00:00:20,970 --> 00:00:26,010
+And just to set the image around that point so imagine that point as a pivot.
+
+7
+00:00:26,010 --> 00:00:29,710
+So similarly in no translation transformation.
+
+8
+00:00:30,160 --> 00:00:31,270
+We had a matrix.
+
+9
+00:00:31,290 --> 00:00:36,650
+Now we have an M matrix which is the shorthand used for the rotation matrix.
+
+10
+00:00:36,660 --> 00:00:38,390
+Here is the angle of rotation.
+
+11
+00:00:38,430 --> 00:00:42,920
+As you can see it's an anti-clockwise angle measured from this point here.
+
+12
+00:00:43,650 --> 00:00:50,520
+And one important thing to note is that the open Sivy function which is get tradition which is 2D actually
+
+13
+00:00:50,520 --> 00:00:55,580
+does scaling an irritation at the same time which you will see in the code.
+
+14
+00:00:56,010 --> 00:01:01,460
+So let's implement some mortician's using open C-v superstitions are very similar to translations in
+
+15
+00:01:01,470 --> 00:01:04,290
+that we actually have to generate a transformation matrix.
+
+16
+00:01:04,290 --> 00:01:09,420
+What we call the rotation matrix here and to do that we actually use an open CB function called Get
+
+17
+00:01:09,420 --> 00:01:11,450
+a rotation matrix 2d.
+
+18
+00:01:11,450 --> 00:01:13,840
+Now this function is fairly simple as well.
+
+19
+00:01:13,890 --> 00:01:21,900
+What you give it is this argument is sense of x and y Center which corresponds to width and height that's
+
+20
+00:01:21,900 --> 00:01:23,120
+the center point of the image.
+
+21
+00:01:23,130 --> 00:01:28,950
+In most cases however you can and you are free to retaliate among among any point in image for whatever
+
+22
+00:01:28,950 --> 00:01:32,780
+reason that maybe this is a theater which is an angle of addition.
+
+23
+00:01:32,790 --> 00:01:38,420
+Remember it's anti-clockwise and this is a scaling factor which will bring or bring up shortly.
+
+24
+00:01:38,820 --> 00:01:44,030
+And we use this rotation matrix again and it happens if you walk a fine function.
+
+25
+00:01:44,060 --> 00:01:46,810
+So let's run this could see what it looks like.
+
+26
+00:01:46,820 --> 00:01:47,250
+There we go.
+
+27
+00:01:47,260 --> 00:01:52,610
+So that's that image rotated 90 degrees anti-clockwise and you may have noticed that a top and bottom
+
+28
+00:01:52,610 --> 00:01:57,370
+parts of the image are cropped mainly because the canvas séjour means a seam.
+
+29
+00:01:57,440 --> 00:01:59,660
+So there are two ways we can fix that one.
+
+30
+00:02:00,110 --> 00:02:01,430
+Let's adjust the scale here.
+
+31
+00:02:01,440 --> 00:02:05,610
+So let's put this point five wiggle.
+
+32
+00:02:05,700 --> 00:02:08,520
+However it is a lot of black space around this image.
+
+33
+00:02:08,910 --> 00:02:15,450
+Now to avoid that you would actually have to actually put the specific width and height of the new rotated
+
+34
+00:02:15,450 --> 00:02:16,210
+image.
+
+35
+00:02:16,320 --> 00:02:19,880
+So whatever you anticipate it to be you can program it here.
+
+36
+00:02:20,490 --> 00:02:23,190
+However that's not often what is not.
+
+37
+00:02:23,190 --> 00:02:27,510
+It's a bit tedious to do sometimes unless you have a special case for it.
+
+38
+00:02:27,510 --> 00:02:33,420
+There's another way we can do it and that's by using the transpose function here not the transpose function
+
+39
+00:02:33,640 --> 00:02:34,990
+that's run the school and see what happens.
+
+40
+00:02:35,020 --> 00:02:39,640
+This is actually transposes image 100 percent.
+
+41
+00:02:39,660 --> 00:02:44,530
+No you may not see the bottom because it's cut off from the screen casting off here.
+
+42
+00:02:44,970 --> 00:02:52,340
+Over that image is fully done and here anti-clockwise and there's no black space around it.
+
+43
+00:02:55,230 --> 00:02:58,960
+So this is just another easy and convenient way for teaching images.
+
+44
+00:02:58,980 --> 00:03:04,470
+However when he does it in 90 degrees increments at one time so he can play around with us and actually
+
+45
+00:03:04,470 --> 00:03:10,230
+do some cool rotations without having to actually program it with a new with a new height of the new
+
+46
+00:03:10,230 --> 00:03:10,860
+canvas.