maiha.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Categorize rice leafs by their diseases\n",
    "This notebook consists of the leaf detection part, and the neural net part."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Detection functions\n",
    "Here we detect the borders of the leaf in the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "from scipy import ndimage\n",
    "import numpy as np\n",
    "from math import sqrt, pi, atan2, atan\n",
    "\n",
    "sharpen_cnn = np.array([[0, 0, 0, -1, 0, 0, 0],\n",
    "                        [0, 0, -1, -1, -1, 0, 0],\n",
    "                        [0, -1, -1, -1, -1, -1, 0],\n",
    "                        [-1, -1, -1, 24, -1, -1, -1],\n",
    "                        [0, -1, -1, -1, -1, -1, 0],\n",
    "                        [0, 0, -1, -1, -1, 0, 0],\n",
    "                        [0, 0, 0, -1, 0, 0, 0]])\n",
    "\n",
    "len_threshold_1 = 0.40\n",
    "len_threshold_other = 0.8\n",
    "angle_diff_threshold = 10 * (pi / 180)\n",
    "OUT_W, OUT_H = 800, 100\n",
    "RECIZE_SZ = 1024\n",
    "\n",
    "def find_longest_lines_in_contour(contours) -> list:\n",
    "    full_list = []\n",
    "    for c in contours:\n",
    "        peri = cv2.arcLength(c, True)\n",
    "        poly = cv2.approxPolyDP(c, 0.02 * peri, True)\n",
    "        for lin_i in range(len(poly))[:-1]:\n",
    "            full_list.append(((poly[lin_i][0][0], poly[lin_i][0][1]), (poly[lin_i + 1][0][0], poly[lin_i + 1][0][1])))\n",
    "    full_list = sorted(full_list, key=lambda x: -(x[0][0] - x[1][0]) ** 2 - (x[0][1] - x[1][1]) ** 2)\n",
    "    return full_list\n",
    "\n",
    "# k = (y1 - y2) / (x1 - x2)\n",
    "# b = y2 - k*x2\n",
    "def line_koeff(line: tuple[tuple[int, int], tuple[int, int]]) -> tuple[float, float]:\n",
    "    k = (line[0][1] - line[1][1]) / (line[0][0] - line[1][0])\n",
    "    b = line[1][1] - k * line[1][0]\n",
    "    return k, b\n",
    "\n",
    "def angle_diff(lhs, rhs) -> float:\n",
    "    k_l, _ = line_koeff(lhs)\n",
    "    k_r, _ = line_koeff(rhs)\n",
    "    return abs(atan(k_l) - atan(k_r))\n",
    "\n",
    "def line_len_f(x):\n",
    "    return sqrt((x[0][0] - x[1][0]) ** 2 + (x[0][1] - x[1][1]) ** 2)\n",
    "\n",
    "def find_candidate_lines(image_data) -> list:\n",
    "    gray = cv2.cvtColor(image_data, cv2.COLOR_BGR2GRAY) # convert image into monochannel\n",
    "\n",
    "    grad_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=9) # former: 21\n",
    "    grad_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=9) # changed for the perfomance\n",
    "\n",
    "    grad = np.sqrt(grad_x ** 2 + grad_y ** 2) # unite horizontal and vertical Sobel filtered images into one\n",
    "    grad = (grad * 255 / grad.max()).astype(np.uint8) # make image be an 2D-array of numbers [0..255]\n",
    "    grad[np.abs(grad) < 64] = 0 # zero out noizes\n",
    "    grad = grad.astype(np.float) # here we have image, that consists only from edges\n",
    "    grad = ndimage.convolve(grad, sharpen_cnn, mode='constant', cval=0.0) # sharpen the edges, because there are a lot of images that are quite blured\n",
    "    grad[grad > 255] = 255 # just normalize, nothing interesting\n",
    "    grad[grad < 64] = 0\n",
    "    grad = grad.astype(np.uint8) # convert it back\n",
    "\n",
    "    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7)) # make dots more looking like a line\n",
    "    closed = cv2.morphologyEx(grad, cv2.MORPH_CLOSE, kernel)\n",
    "\n",
    "    (cnts, _) = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # finally find the contours\n",
    "    all_lines = find_longest_lines_in_contour(cnts) # here we use all contours just as a set of lines from point to point\n",
    "    longest = all_lines[:min(10, len(all_lines))] # longest 10 lines\n",
    "\n",
    "    # here we filter dicks that are not big enough\n",
    "    if len(longest) <= 2:\n",
    "        return longest\n",
    "    target = list()\n",
    "    target.append(longest[0])  # at least 1 should be here\n",
    "    current_thr = len_threshold_1\n",
    "    for line in longest[1:]:\n",
    "        prev_len = line_len_f(target[-1])\n",
    "        current_len = line_len_f(line)\n",
    "        if current_len < prev_len * current_thr: # filter lines by length\n",
    "            break\n",
    "        if angle_diff(target[0], line) > angle_diff_threshold: # line should not be an angle\n",
    "            continue\n",
    "        target.append(line)\n",
    "        current_thr = len_threshold_other\n",
    "\n",
    "    return target\n",
    "\n",
    "def restrict(x, mn, mx): # just a normalize function, nothing interesting\n",
    "    return int(max(mn, min(mx, x)))\n",
    "\n",
    "# given two lines formed by f(x)=k*x+b and point on the first line, find the intersection of the second line with the first line's perpendicular in that point\n",
    "def find_intersection(k1: float, b1: float, k2: float, b2: float, x1: float, size: int, recursive: bool = True) -> tuple[float, float]:\n",
    "    y1 = k1 * x1 + b1\n",
    "    x_r = (y1 + x1 / k1 - b2) / (k2 + 1 / k1)\n",
    "    y_r = x_r * k2 + b2\n",
    "    if x_r < -1:\n",
    "        if not recursive:\n",
    "            return int(0), int(b2)\n",
    "        res = find_intersection(k2, b2, k1, b1, 1, size, False)\n",
    "        return find_intersection(k1, b1, k2, b2, res[0], size, False)\n",
    "    elif y_r < -1:\n",
    "        if not recursive:\n",
    "            return int(-b2 / k2), int(0)\n",
    "        res = find_intersection(k2, b2, k1, b1, (-b2) / k2, size, False)\n",
    "        return find_intersection(k1, b1, k2, b2, res[0], size, False)\n",
    "    elif x_r > size:\n",
    "        if not recursive:\n",
    "            return int(size - 1), int((size - 1) * k2 + b2)\n",
    "        res = find_intersection(k2, b2, k1, b1, (size - 1), size, False)\n",
    "        return find_intersection(k1, b1, k2, b2, res[0], size, False)\n",
    "    elif y_r > size:\n",
    "        if not recursive:\n",
    "            return int((size - 1) - b2 / k2), int((size - 1))\n",
    "        res = find_intersection(k2, b2, k1, b1, (((size - 1) - b2) / k2), size, False)\n",
    "        return find_intersection(k1, b1, k2, b2, res[0], size, False)\n",
    "    return x_r, y_r\n",
    "\n",
    "# sort points counterclockwise\n",
    "def sort_counterclock(pts: tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]) -> tuple[\n",
    "    tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]:\n",
    "    avg_x, avg_y = (pts[0][0] + pts[1][0] + pts[2][0] + pts[3][0]) / 4, (\n",
    "            pts[0][1] + pts[1][1] + pts[2][1] + pts[3][1]) / 4\n",
    "    result = list(pts)\n",
    "    result = sorted(result, key=lambda pt: atan2((pt[0] - avg_x), (pt[1] - avg_y)))\n",
    "    if line_len_f((result[0], result[1])) > line_len_f((result[1], result[2])):\n",
    "        return result[1], result[2], result[3], result[0]\n",
    "    return result[0], result[1], result[2], result[3]\n",
    "\n",
    "def normalize_fit_tetragon(tetragon: tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]],\n",
    "                           size: int) -> tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]:\n",
    "    result = list()\n",
    "    for x in tetragon:\n",
    "        result.append((restrict(x[0], 0, size), restrict(x[1], 0, size)))\n",
    "    return result[0], result[1], result[2], result[3]\n",
    "\n",
    "# take image and four points and extract image within this tetragon into OUT_WxOUT_H image\n",
    "def extract_maiha(image: np.ndarray, tetragon: tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]) -> np.ndarray:\n",
    "    stetra = sort_counterclock(tetragon)\n",
    "    inp_pts = np.array(stetra, dtype=np.float32)\n",
    "    outp_pts = np.array([[0, 0], [0, OUT_H], [OUT_W, OUT_H], [OUT_W, 0]], dtype=np.float32)\n",
    "    transform_mat = cv2.getPerspectiveTransform(inp_pts, outp_pts)\n",
    "    return cv2.warpPerspective(image, transform_mat, (OUT_W, OUT_H), flags=cv2.INTER_LINEAR)\n",
    "\n",
    "# take pointed line and functional line and return four points of tetragon, needed to extract image\n",
    "def find_rect_by_two_lines(line_ichi: tuple[tuple[int, int], tuple[int, int]], k2: float, b2: float, size: int) -> tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]:\n",
    "    k1, b1 = line_koeff(line_ichi)\n",
    "    sanme_point = find_intersection(k1, b1, k2, b2, line_ichi[0][0], size)\n",
    "    yonme_point = find_intersection(k1, b1, k2, b2, line_ichi[1][0], size)\n",
    "    sanme_point = restrict(sanme_point[0], 0, size - 1), restrict(sanme_point[1], 0, size - 1)\n",
    "    yonme_point = restrict(yonme_point[0], 0, size - 1), restrict(yonme_point[1], 0, size - 1)\n",
    "    return normalize_fit_tetragon((line_ichi[0], line_ichi[1], sanme_point, yonme_point), size)\n",
    "\n",
    "def is_valid_rect(rect: tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]], size: int) -> bool:\n",
    "    for x in rect:\n",
    "        if x[0] >= size or x[1] >= size or x[0] < 0 or x[1] < 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "# remove background from image\n",
    "# as it does remove parts of the leafs too, it is used only in scoring the image\n",
    "def rm_background(image: np.ndarray) -> np.ndarray:\n",
    "    lower = np.array([128, 64, 128])\n",
    "    upper = np.array([255, 255, 255])\n",
    "    thresh = cv2.inRange(image, lower, upper)\n",
    "    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))\n",
    "    morph = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)\n",
    "    mask = 255 - morph\n",
    "    result = cv2.bitwise_and(image, image, mask=mask)\n",
    "    return result\n",
    "\n",
    "def compute_image_score(image: np.ndarray, hght: float) -> float:  # we should keep it as low as possible\n",
    "    blured = cv2.blur(image, (9, 9)) # blur, because some parts of the leafs may be black, and worthen the score\n",
    "    nonz = float(np.count_nonzero(blured))\n",
    "    all_pix = blured.shape[0] * blured.shape[1] * blured.shape[2]\n",
    "    score = -((hght) ** (1)) + (((all_pix - nonz + 1) / all_pix * 256) ** 2) # less is better\n",
    "    return score\n",
    "\n",
    "# this algo is similar to binary search around the main line\n",
    "# we build lines +-step and look at the score\n",
    "# then choose the less one and divide step by 2\n",
    "def find_rect_no_hint(image: np.ndarray, line: tuple[tuple[int, int], tuple[int, int]], size: int) -> tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]:\n",
    "    b_step = 2 ** 8\n",
    "    k1, b1 = line_koeff(line)\n",
    "    result: tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]] = (0, 0), (0, 0), (0, 0), (0, 0)\n",
    "    k_c, b_c = k1, b1\n",
    "    scoring_image = rm_background(image)\n",
    "    while b_step >= 1:\n",
    "        kl, bl = k_c, b_c + b_step  # low\n",
    "        kh, bh = k_c, b_c - b_step  # high\n",
    "        rect_l, rect_h = find_rect_by_two_lines(line, kl, bl, size), find_rect_by_two_lines(line, kh, bh, size)\n",
    "        img_l = extract_maiha(scoring_image, rect_l)\n",
    "        img_h = extract_maiha(scoring_image, rect_h)\n",
    "        score_l = compute_image_score(img_l, abs(b1 - bl))\n",
    "        score_h = compute_image_score(img_h, abs(b1 - bh))\n",
    "        if score_l < score_h:\n",
    "            k_c, b_c = kl, bl\n",
    "            result = rect_l\n",
    "        else:\n",
    "            k_c, b_c = kh, bh\n",
    "            result = rect_h\n",
    "        b_step = int(b_step / 2)\n",
    "    return result\n",
    "\n",
    "\n",
    "def get_rect_no_hint(image: np.ndarray, line: tuple[tuple[int, int], tuple[int, int]], size: int) -> np.ndarray:\n",
    "    tetragon = find_rect_no_hint(image, line, size)\n",
    "    return extract_maiha(image, tetragon)\n",
    "\n",
    "# in previous works there was usage of other lines too, but we decided to continue with\n",
    "# main line only, because it gives less distorted results\n",
    "def process_image(image: np.ndarray, size: int) -> np.ndarray:\n",
    "    lines = find_candidate_lines(image)\n",
    "    if len(lines) >= 1:\n",
    "        return get_rect_no_hint(image, lines[0], size)\n",
    "    return cv2.resize(image, (OUT_W, OUT_H))\n",
    "\n",
    "def process_image_from_file_to_file(path: str, store_path: str):\n",
    "    image = cv2.imread(path)\n",
    "    image = cv2.resize(image, (RECIZE_SZ, RECIZE_SZ))\n",
    "    image = process_image(image, RECIZE_SZ)\n",
    "    cv2.imwrite(store_path, image)\n",
    "\n",
    "def read_from_origin(path: str) -> np.ndarray:\n",
    "    image = cv2.imread(path)\n",
    "    image = cv2.resize(image, (RECIZE_SZ, RECIZE_SZ))\n",
    "    return process_image(image, RECIZE_SZ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total images cached:  0\n",
      "CPU times: user 373 µs, sys: 0 ns, total: 373 µs\n",
      "Wall time: 221 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import os\n",
    "from os.path import join as pjoin, isfile\n",
    "\n",
    "CACHE_DIR = \"maihacache\"\n",
    "READ_DIR = \"RiceLeafs\"\n",
    "counter = 0\n",
    "\n",
    "def precache_leafs(path: str, store_path: str):\n",
    "    global counter\n",
    "    os.mkdir(store_path)\n",
    "    for entry in os.listdir(path):\n",
    "        fpath = pjoin(path, entry) # folded\n",
    "        ftarget = pjoin(store_path, entry)\n",
    "        if isfile(fpath):\n",
    "            process_image_from_file_to_file(fpath, ftarget)\n",
    "            counter += 1\n",
    "        else:\n",
    "            precache_leafs(fpath, ftarget)\n",
    "\n",
    "# precache_leafs(READ_DIR, CACHE_DIR)\n",
    "print(\"Total images cached: \", counter)\n",
    "counter = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-01-26 03:08:42.058139: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU'), PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n",
      "[LogicalDevice(name='/device:GPU:0', device_type='GPU')]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-01-26 03:08:42.094139: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.094378: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.113895: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-01-26 03:08:42.115092: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.115334: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.115517: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.641414: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.641654: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.641838: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:939] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2022-01-26 03:08:42.641994: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1627 MB memory:  -> device: 0, name: NVIDIA GeForce MX150, pci bus id: 0000:01:00.0, compute capability: 6.1\n",
      "2022-01-26 03:08:42.642254: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "\n",
    "# tf.debugging.set_log_device_placement(True)\n",
    "tf.config.set_soft_device_placement(True)\n",
    "\n",
    "print(tf.config.experimental.list_physical_devices())\n",
    "\n",
    "gpu = tf.config.list_logical_devices('GPU')\n",
    "#tf.config.experimental.set_memory_growth(gpu[0], True)\n",
    "\n",
    "print(gpu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"Maiha\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 798, 98, 6)        168       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 399, 49, 6)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 397, 47, 8)        440       \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 198, 23, 8)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 194, 19, 10)       2010      \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 48, 4, 10)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 1920)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 128)               245888    \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 128)               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 4)                 516       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 249,022\n",
      "Trainable params: 249,022\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "LEARNING_RATE = 0.001\n",
    "\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Conv2D(6, (3, 3), activation = 'relu', input_shape = (OUT_W, OUT_H, 3)),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Conv2D(8, (3, 3), activation = 'relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Conv2D(10, (5, 5), activation = 'relu'),\n",
    "    tf.keras.layers.MaxPooling2D(4, 4),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(128, activation = 'relu'),\n",
    "    tf.keras.layers.Dropout(0.2),\n",
    "    tf.keras.layers.Dense(4, activation = 'softmax')\n",
    "],    name = 'Maiha')\n",
    "\n",
    "model.summary()\n",
    "\n",
    "model.compile(optimizer = tf.keras.optimizers.Adam(),\n",
    "              loss = tf.keras.losses.CategoricalCrossentropy(),\n",
    "              metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BrownSpot', 'LeafBlast', 'Healthy', 'Hispa']\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "train_dir = pjoin(CACHE_DIR, 'train')\n",
    "test_dir = pjoin(CACHE_DIR, 'validation')\n",
    "classes = []\n",
    "for file in os.listdir(train_dir):\n",
    "    classes += [file]\n",
    "print(classes)\n",
    "print(len(classes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "brownSpot = [train_dir + '/BrownSpot/' + img for img in os.listdir(train_dir + '/BrownSpot')[:9]]\n",
    "healthy = [train_dir  + '/Healthy/' + img for img in os.listdir(train_dir + '/Healthy')[:9]]\n",
    "hispa = [train_dir  + '/Hispa/' + img for img in os.listdir(train_dir + '/Hispa')[:9]]\n",
    "leafBlast = [train_dir  + '/LeafBlast/' + img for img in os.listdir(train_dir + '/LeafBlast')[:9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def load_dataset(datadir: str):\n",
    "    target_set = list()\n",
    "    shape=(OUT_W, OUT_H)\n",
    "    counter = 0\n",
    "    for file in os.listdir(datadir):\n",
    "        path=os.path.join(datadir, file)\n",
    "        for im in os.listdir(path):\n",
    "            image = tf.keras.preprocessing.image.load_img(os.path.join(path, im), grayscale=False, color_mode='rgb', target_size=shape)\n",
    "            image = tf.keras.preprocessing.image.img_to_array(image)\n",
    "            image = image / 255.0\n",
    "            target_set += [[image, counter]]\n",
    "        counter += 1\n",
    "    return target_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "dataset = load_dataset(train_dir)\n",
    "testset = load_dataset(test_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2147, 800, 100, 3)\n",
      "(537, 800, 100, 3)\n",
      "(2147, 4)\n",
      "(537, 4)\n"
     ]
    }
   ],
   "source": [
    "data, trainlabels = zip(*dataset)\n",
    "test, testlabels = zip(*testset)\n",
    "labels = np.array(tf.keras.utils.to_categorical(trainlabels, num_classes=4))\n",
    "data = np.array(data)\n",
    "test = np.array(test)\n",
    "trainx, testx, trainy, testy = train_test_split(data, labels, test_size=0.2, random_state=42)\n",
    "print(trainx.shape)\n",
    "print(testx.shape)\n",
    "print(trainy.shape)\n",
    "print(testy.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "del dataset[:]\n",
    "del dataset\n",
    "del testset[:]\n",
    "del testset\n",
    "dataset = None\n",
    "testset = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "datagen = tf.keras.preprocessing.image.ImageDataGenerator(horizontal_flip=True, vertical_flip=True, rotation_range=5, zoom_range=0.2, width_shift_range=0.1,height_shift_range=0.1,shear_range=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-01-26 03:08:50.796359: I tensorflow/stream_executor/cuda/cuda_dnn.cc:366] Loaded cuDNN version 8300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68/68 [==============================] - 37s 487ms/step - loss: 1.2925 - accuracy: 0.4425 - val_loss: 1.1709 - val_accuracy: 0.5382\n",
      "Epoch 2/20\n",
      "68/68 [==============================] - 32s 469ms/step - loss: 1.2072 - accuracy: 0.4946 - val_loss: 1.1308 - val_accuracy: 0.5419\n",
      "Epoch 3/20\n",
      "68/68 [==============================] - 33s 479ms/step - loss: 1.1857 - accuracy: 0.5105 - val_loss: 1.1107 - val_accuracy: 0.5419\n",
      "Epoch 4/20\n",
      "68/68 [==============================] - 33s 485ms/step - loss: 1.1571 - accuracy: 0.5128 - val_loss: 1.1102 - val_accuracy: 0.5345\n",
      "Epoch 5/20\n",
      "68/68 [==============================] - 32s 474ms/step - loss: 1.1509 - accuracy: 0.5128 - val_loss: 1.1260 - val_accuracy: 0.5251\n",
      "Epoch 6/20\n",
      "68/68 [==============================] - 33s 479ms/step - loss: 1.1378 - accuracy: 0.5170 - val_loss: 1.0709 - val_accuracy: 0.5773\n",
      "Epoch 7/20\n",
      "68/68 [==============================] - 33s 477ms/step - loss: 1.1181 - accuracy: 0.5282 - val_loss: 1.0445 - val_accuracy: 0.6089\n",
      "Epoch 8/20\n",
      "68/68 [==============================] - 34s 500ms/step - loss: 1.0895 - accuracy: 0.5356 - val_loss: 1.0052 - val_accuracy: 0.5885\n",
      "Epoch 9/20\n",
      "68/68 [==============================] - 34s 500ms/step - loss: 1.0394 - accuracy: 0.5692 - val_loss: 1.0972 - val_accuracy: 0.5866\n",
      "Epoch 10/20\n",
      "68/68 [==============================] - 33s 482ms/step - loss: 1.0460 - accuracy: 0.5794 - val_loss: 1.0232 - val_accuracy: 0.6108\n",
      "Epoch 11/20\n",
      "68/68 [==============================] - 32s 477ms/step - loss: 1.0143 - accuracy: 0.5785 - val_loss: 1.0436 - val_accuracy: 0.6089\n",
      "Epoch 12/20\n",
      "68/68 [==============================] - 33s 481ms/step - loss: 0.9893 - accuracy: 0.5962 - val_loss: 0.9322 - val_accuracy: 0.6555\n",
      "Epoch 13/20\n",
      "68/68 [==============================] - 33s 478ms/step - loss: 0.9890 - accuracy: 0.5892 - val_loss: 0.9367 - val_accuracy: 0.6443\n",
      "Epoch 14/20\n",
      "68/68 [==============================] - 32s 476ms/step - loss: 0.9768 - accuracy: 0.5934 - val_loss: 0.9599 - val_accuracy: 0.6592\n",
      "Epoch 15/20\n",
      "68/68 [==============================] - 33s 479ms/step - loss: 0.9656 - accuracy: 0.6018 - val_loss: 0.9800 - val_accuracy: 0.6387\n",
      "Epoch 16/20\n",
      "68/68 [==============================] - 33s 480ms/step - loss: 0.9388 - accuracy: 0.6190 - val_loss: 0.9184 - val_accuracy: 0.6499\n",
      "Epoch 17/20\n",
      "68/68 [==============================] - 33s 477ms/step - loss: 0.9749 - accuracy: 0.6088 - val_loss: 0.9579 - val_accuracy: 0.6443\n",
      "Epoch 18/20\n",
      "68/68 [==============================] - 32s 476ms/step - loss: 0.9388 - accuracy: 0.6293 - val_loss: 0.9025 - val_accuracy: 0.6778\n",
      "Epoch 19/20\n",
      "68/68 [==============================] - 32s 477ms/step - loss: 0.9288 - accuracy: 0.6306 - val_loss: 0.9140 - val_accuracy: 0.6704\n",
      "Epoch 20/20\n",
      "68/68 [==============================] - 32s 476ms/step - loss: 0.9377 - accuracy: 0.6157 - val_loss: 0.9549 - val_accuracy: 0.6667\n"
     ]
    }
   ],
   "source": [
    "his = model.fit(datagen.flow(trainx, trainy, batch_size=32), validation_data=(testx, testy), epochs=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "get_acc = his.history['accuracy']\n",
    "value_acc = his.history['val_accuracy']\n",
    "get_loss = his.history['loss']\n",
    "validation_loss = his.history['val_loss']\n",
    "\n",
    "epochs = range(len(get_acc))\n",
    "plt.plot(epochs, get_acc, 'r', label='Accuracy of Training data')\n",
    "plt.plot(epochs, value_acc, 'b', label='Accuracy of Validation data')\n",
    "plt.title('Training vs validation accuracy')\n",
    "plt.legend(loc=0)\n",
    "plt.figure()\n",
    "plt.show()\n",
    "\n",
    "plt.plot(epochs, get_loss, 'orange', label='Loss of Training data')\n",
    "plt.plot(epochs, validation_loss, 'green', label='Loss of Validation data')\n",
    "plt.title('Training vs validation loss')\n",
    "plt.legend(loc=0)\n",
    "plt.figure()\n",
    "plt.show()"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}