lab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n",
    "    </a>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Land usage classification in Agriculture**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estaimted time needed: **2** hours\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this laboratory, we will explore how land use types can be classified based on aerial and satellite photographs of the earth's surface. We will learn to build our own photo masks based on ready-made masks and display them on the screen.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determining how land is used is a huge problem today. After all, its improper and illegal use can lead to both economic and natural disasters. One of the ways to assess the use is the analysis of aerial and satellite images of the earth's surface. A big problem is to build a mathematical model that can determine the type of land use based on colors. If you have ready-made photos and masks of land use, you can use the methods of artificial intelligence and big data to build a model-classifier.\n",
    "\n",
    "In this lab, we will learn how to upload photos, transform pixels and colors into a data set. Then we will learn how to build a classifier and predict land use masks based on it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Materials and methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, we will learn the basic methods of images transformation classification. The laboratory consists of four stages:\n",
    "* Download and visualization of images\n",
    "* DataSet creation\n",
    "* Classification model creation\n",
    "* Create your own mask of land use\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statistical data was obtained from https://www.kaggle.com/humansintheloop/semantic-segmentation-of-aerial-imagery under [CC0: Public Domain](https://creativecommons.org/publicdomain/zero/1.0/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) license.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites\n",
    "* [Python](https://www.python.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - basic level\n",
    "* [numpy](https://numpy.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - middle level\n",
    "* [SeaBorn](https://seaborn.pydata.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - basic level\n",
    "* [Matplotlib](https://matplotlib.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - basic level\n",
    "* [scikit-learn](https://scikit-learn.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - middle level\n",
    "* [pandas](https://pandas.pydata.org/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01) - basic level\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After completing this lab, you will be able to:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Download and transform images.\n",
    "* Create a DataSet of the colors of images.\n",
    "* Build a classification model.\n",
    "* Build land use masks based on a classifier.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download and visualization of images\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install the required libraries \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to install additional libraries and upgrade existing ones in the lab.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda install matplotlib >= 3.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda config --add channels conda-forge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda install scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda install -c conda-forge opencv "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda install -c conda-forge colormap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda install -c intel scikit-learn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import the required libraries \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use libraries os and glob to work with files and folders. \n",
    "We will also use Matplotlib and Seaborn for visualizing our dataset to gain a better understanding of the images we are going to be handling.\n",
    "NumPy will be used for arrays of images. Scikit-Learn - for classical classification models. Pandas - for DataSet creation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt \n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "from glob import glob\n",
    "import json\n",
    "from PIL import Image\n",
    "\n",
    "#Classifier\n",
    "from sklearn.linear_model import LogisticRegression \n",
    "from sklearn.metrics import precision_recall_curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading of data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, let's create a function that downloads all and displays the last images of land and masks from a specified directory.\n",
    "All training pictures and their masks have to be placed in differend directories.\n",
    "Separate a csv file that contains the description of land use classes.\n",
    "\n",
    "The function has to work in the following way:\n",
    "1. Download a csv file **[json.load()](https://docs.python.org/3/library/json.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)** and display classes description.\n",
    "2. Download all images from a specific directory:\n",
    " **[Image.open()](https://pillow.readthedocs.io/en/stable/reference/Image.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**.\n",
    "3. Display the last image + mask.\n",
    "4. Form and return a DataSet that has to be an array of tuples [image, mask].\n",
    "\n",
    "Remark: the downloaded directories contain 72 images and their masks located in different subfolders according to image resolutions. Due to the fact that the dataset for training will represent each point in the form of a separate record - the size of the dataset will be too large to conduct the training on a local computer. Therefore, we will select a separate folder that contains 9 photos and their masks.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '\\\\tmp\\\\skills-network--4242408148593930961-Semantic_segmentation_dataset.zip'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[8], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mskillsnetwork\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[39mawait\u001b[39;00m skillsnetwork\u001b[39m.\u001b[39mprepare(\u001b[39m\"\u001b[39m\u001b[39mhttps://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/data-science-in-agriculture-land-use-classification/Semantic_segmentation_dataset.zip\u001b[39m\u001b[39m\"\u001b[39m, overwrite\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n",
      "File \u001b[1;32mc:\\Users\\Lintang\\anaconda3\\envs\\MS20_1\\lib\\site-packages\\skillsnetwork\\core.py:249\u001b[0m, in \u001b[0;36mprepare\u001b[1;34m(url, path, verbose, overwrite)\u001b[0m\n\u001b[0;32m    246\u001b[0m tmp_download_file \u001b[39m=\u001b[39m Path(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m/tmp/\u001b[39m\u001b[39m{\u001b[39;00mdname\u001b[39m}\u001b[39;00m\u001b[39m-\u001b[39m\u001b[39m{\u001b[39;00mfilename\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[0;32m    247\u001b[0m \u001b[39m# Download the dataset to tmp_download_file file\u001b[39;00m\n\u001b[0;32m    248\u001b[0m \u001b[39m# File will be overwritten if it already exists\u001b[39;00m\n\u001b[1;32m--> 249\u001b[0m \u001b[39mawait\u001b[39;00m download(url, tmp_download_file, verbose\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[0;32m    251\u001b[0m \u001b[39m# Delete extract_dir directory if it already exists\u001b[39;00m\n\u001b[0;32m    252\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m _is_jupyterlite():\n",
      "File \u001b[1;32mc:\\Users\\Lintang\\anaconda3\\envs\\MS20_1\\lib\\site-packages\\skillsnetwork\\core.py:186\u001b[0m, in \u001b[0;36mdownload\u001b[1;34m(url, path, verbose, chunk_size)\u001b[0m\n\u001b[0;32m    184\u001b[0m     \u001b[39mif\u001b[39;00m path\u001b[39m.\u001b[39mis_dir():\n\u001b[0;32m    185\u001b[0m         path \u001b[39m/\u001b[39m\u001b[39m=\u001b[39m filename\n\u001b[1;32m--> 186\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39;49m(path, \u001b[39m\"\u001b[39;49m\u001b[39mwb\u001b[39;49m\u001b[39m\"\u001b[39;49m) \u001b[39mas\u001b[39;00m f:  \u001b[39m# Will raise FileNotFoundError if invalid path\u001b[39;00m\n\u001b[0;32m    187\u001b[0m     \u001b[39masync\u001b[39;00m \u001b[39mfor\u001b[39;00m chunk \u001b[39min\u001b[39;00m _get_chunks(url, chunk_size):\n\u001b[0;32m    188\u001b[0m         f\u001b[39m.\u001b[39mwrite(chunk)\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '\\\\tmp\\\\skills-network--4242408148593930961-Semantic_segmentation_dataset.zip'"
     ]
    }
   ],
   "source": [
    "import skillsnetwork\n",
    "\n",
    "await skillsnetwork.prepare(\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/data-science-in-agriculture-land-use-classification/Semantic_segmentation_dataset.zip\", overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(folder, file):\n",
    "    # download json\n",
    "    f = open(folder + \"/\" + file,)\n",
    "    data = json.load(f)\n",
    "    f.close()\n",
    "    cl = {}\n",
    "    # Create a dictionary with classes\n",
    "    for i, c in enumerate(data['classes']):\n",
    "        cl[i] = dict(c)\n",
    "        \n",
    "    for k, v in cl.items():\n",
    "        print('Class', k)\n",
    "        for k2, v2 in v.items():\n",
    "            print(\"   \", k2, v2)\n",
    "    data = []\n",
    "    \n",
    "    # download images\n",
    "    sd = [item for item in os.listdir(folder) if os.path.isdir(folder + '/' + item)] # a list of subdirectories\n",
    "    print(\"Subdirectories: \", sd)\n",
    "    for f in sd[1:2]: #choose one of the subdirectories to download\n",
    "        print(\"Downloading: \", f)\n",
    "        images = glob(folder + \"/\" + f + \"/images\" + \"/*.jpg\") # create a list of image files\n",
    "        for im in images:\n",
    "            mask_f = im.replace(\"images\", \"masks\").replace(\"jpg\", \"png\") # create a list of mask files\n",
    "            image = Image.open(im) \n",
    "            mask = Image.open(mask_f)\n",
    "            if len(np.array(mask).shape) > 2:\n",
    "                data.append([image, mask])\n",
    "        fig = plt.figure(figsize = (10,10)) #display the last image + mask\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(image)\n",
    "        plt.subplot(1,2,2)\n",
    "        plt.imshow(mask)\n",
    "        plt.show()\n",
    "\n",
    "    return (data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = \"Semantic segmentation dataset\"\n",
    "f = \"classes.json\"\n",
    "data = get_data(d, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the csv file contains a description of 6 land use classes. Each class has its own color in the mask file.\n",
    "We downloaded all the pictures and their masks from a separate directory and formed a set of data lists consisting of tuples of picture-mask.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataSet creation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how many images we downloaded:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we dowloaded 9 images.\n",
    "Let's use first 4 images and masks for training and last 5 - for tests.\n",
    "\n",
    "Let's make a function that will create a DataSet.\n",
    "\n",
    "Each image is a set of points. Each point is represented by a tuple of RGB (red, green, blue). Every color is a number [0-1) for float or [0, 255) for int. \n",
    "Therefore, every image is a 3D array (height, width, color). Or a 2D array for gray scale.\n",
    "\n",
    "To establish the dependence of color -> land use class, we need to convert each image into a dataset of the form (r, g, b) -> class.\n",
    "\n",
    "To do this, we need to transform the image into a color matrix **[np.asarray()](https://numpy.org/doc/stable/reference/generated/numpy.asarray.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**, and then transform it into a one-dimensional form **[np.flatten()](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**.\n",
    "To construct the output field, we need to additionally convert the color tuple (r, g, b) from the mask file into hex format: **[rgb2hex()](https://pythonhosted.org/colormap/references.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_DataSet(data):\n",
    "    DS = pd.DataFrame()\n",
    "    for image, mask in data:\n",
    "        # transform image to matrix\n",
    "        im = np.asarray(image) \n",
    "        mk = np.asarray(mask)\n",
    "        # transform a one-dimension array of r, g, b colors\n",
    "        red = im[:,:,0].flatten()\n",
    "        green = im[:,:,1].flatten()\n",
    "        blue = im[:,:,2].flatten()\n",
    "        im_f = np.array([red, green, blue])\n",
    "        red = ##YOUR CODE GOES HERE##\n",
    "        green = ##YOUR CODE GOES HERE##\n",
    "        blue = ##YOUR CODE GOES HERE##\n",
    "        # calculate hex classes\n",
    "        h = np.array([rgb2hex(*m) for m in zip(red, green, blue)])\n",
    "        mk_f = np.array([red, green, blue, h])      \n",
    "        d = np.concatenate((im_f, mk_f), axis=0)\n",
    "        # create a DataSet\n",
    "        DS_new = pd.DataFrame(np.transpose(d), columns = ['Im_Red', 'Im_Green', 'Im_Blue', 'Mk_Red', 'Mk_Green', 'Mk_Blue', 'HEX'])\n",
    "        if len(DS) == 0:\n",
    "            DS = DS_new\n",
    "        else:\n",
    "            DS = DS.append(DS_new)\n",
    "    return DS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "        red = mk[:,:,0].flatten()\n",
    "        green = mk[:,:,1].flatten()\n",
    "        blue = mk[:,:,2].flatten()\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Create a training DataSet\")\n",
    "train = create_DataSet(data[:4])\n",
    "print(train)\n",
    "print(\"Create a test DataSet\")\n",
    "test = ##YOUR CODE GOES HERE##\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "print(\"Create test DataSet\")\n",
    "test = create_DataSet(data[4:])\n",
    "print(test)\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, our training DataSet consists of 2 050 681 rows and 7 columns. The test one consists of 2 566 340 rows.\n",
    "\n",
    "Let's study the column types of training and test DataSets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, all the columns have object type. \n",
    "\n",
    "The last column 'HEX' contains colors in hex format. Therefore, it is necessary to change the type of this data to categorical.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.loc[:, 'HEX'] = train['HEX'].astype('category')\n",
    "train['HEX']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.loc[:, 'HEX'] =  ##YOUR CODE GOES HERE##\n",
    "test['HEX']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "test.loc[:, 'HEX'] = test['HEX'].astype('category')\n",
    "test['HEX']\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All other columns contain colors in int format, therefore we should change their types:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cl = ##YOUR CODE GOES HERE##\n",
    "train[cl] = train[cl].astype('int64')\n",
    "test[cl] = test[cl].##YOUR CODE GOES HERE##\n",
    "print (train.info())\n",
    "print (test.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "cl = ['Im_Red', 'Im_Green', 'Im_Blue', 'Mk_Red', 'Mk_Green', 'Mk_Blue']\n",
    "train[cl] = train[cl].astype('int64')\n",
    "test[cl] = test[cl].astype('int64')\n",
    "print (train.info())\n",
    "print (test.info())\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s visualize our data and see what exactly we are working with. We use seaborn to plot the number of pixel classes and you can see what the output looks like.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = pd.DataFrame(train['HEX'])\n",
    "sns.set_style('darkgrid')\n",
    "sns.countplot(x=\"HEX\", data=c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = pd.DataFrame( ##YOUR CODE GOES HERE##)\n",
    "sns.set_style('darkgrid')\n",
    "sns.countplot( ##YOUR CODE GOES HERE##)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "c = pd.DataFrame(test['HEX'])\n",
    "sns.set_style('darkgrid')\n",
    "sns.countplot(x=\"HEX\", data=c)\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the DataSet consist of 6 land use classes. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The training and test DataSets contain similar distribution of images classes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification model creation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use **[sklearn.linear_model.LogisticRegression()](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)** classifier for mask analysis. It is a very fast and simple classifier. In the next lab we will compare different classifiers.\n",
    "\n",
    "We will use first 3 columns (RGB of image pixel) as imput parameters, and the last column (HEX color of mask picture) as an output.\n",
    "\n",
    "The **[fit()](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01&highlight=logisticregression#sklearn.linear_model.LogisticRegression.fit)** and **[score()](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01&highlight=logisticregression#sklearn.linear_model.LogisticRegression.fit)** functions are used for training and evaluating the accuracy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use function **[plot_confusion_matrix()](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)** for analysis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = LogisticRegression(max_iter=100, n_jobs=-1)\n",
    "c = train.columns\n",
    "clf.fit(##YOUR CODE GOES HERE##)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "clf = LogisticRegression(max_iter=100, n_jobs=-1)\n",
    "c = train.columns\n",
    "clf.fit(train[c[0:3]], train[c[-1:]].values.ravel())\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_train = clf.score(train[c[0:3]], train[c[-1:]].values.ravel())\n",
    "scores_test = clf.score(test[c[0:3]], test[c[-1:]].values.ravel())\n",
    "print('Accuracy train DataSet: {: .1%}'.format(scores_train), 'Accuracy test DataSet: {: .1%}'.format(scores_test))\n",
    "plot_confusion_matrix(clf, test[c[0:3]], test[c[-1:]].values.ravel())  \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the accuracy is not bad. The difference between the training and test sets is little. It means that the model is not bad, and for increasing the accuracy we should increase our DataSet. You can test it yourself by adding all the directories with images.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create your own mask of land use\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build your own mask based on our classifier model.\n",
    "\n",
    "First of all, you need to choose a few images from the downloaded data list and build your DataSet.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_image = 8 # choose the number of images from the data list\n",
    "mask_test = data[test_image:test_image+1] # Test Image + Mask\n",
    "mask_test_DataSet = create_DataSet(mask_test) #Build a DataSet\n",
    "print(mask_test_DataSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, calculate the hex colour of classes using our model:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = mask_test_DataSet.columns\n",
    "mask_test_predict = clf.predict(mask_test_DataSet[c[0:3]])\n",
    "print(mask_test_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Further, we need to transform the 1D array of colors into a 2D matrix of Hex color using **[numpy.reshape()](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "size = mask_test[0][1].size #get original image size\n",
    "print(size)\n",
    "predict_img = np.array(mask_test_predict).reshape((size[1], size[0])) #reshaping array of HEX colour\n",
    "print(predict_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Than we create a 3D image matrix with an RGB colour map using **[colormap.hex2rgb()](https://pythonhosted.org/colormap/references.html?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rgb_size = ##YOUR CODE GOES HERE##\n",
    "print(\"Image size: \", rgb_size)\n",
    "predict_img_rgb = np.zeros(rgb_size)\n",
    "for i, r in enumerate(predict_img):\n",
    "    for j, c in enumerate(r):\n",
    "        predict_img_rgb[i, j, 0], predict_img_rgb[i, j, 1], predict_img_rgb[i, j, 2] = hex2rgb(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click <b>here</b> for the solution</summary> <code>\n",
    "rgb_size = np.array(mask_test[0][0]).shape\n",
    "print(\"Image size: \", rgb_size)\n",
    "predict_img_rgb = np.zeros(rgb_size)\n",
    "for i, r in enumerate(predict_img):\n",
    "    for j, c in enumerate(r):\n",
    "        predict_img_rgb[i, j, 0], predict_img_rgb[i, j, 1], predict_img_rgb[i, j, 2] = hex2rgb(c)\n",
    "</code></details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare our mask with the original one.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict_img_rgb = predict_img_rgb.astype('int')\n",
    "print(\"Model mask\")\n",
    "plt.imshow(predict_img_rgb)\n",
    "plt.show()\n",
    "print(\"Real mask\")\n",
    "plt.imshow(mask_test[0][1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that these masks are very similar and you just have to increase the DataSets to improve the accuracy.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, we have studied how to create an expert system based on classifiers, which allows to obtain the classification of land, based on aero and satellite images. These principles can be used for any type of images and any types of land use.\n",
    "\n",
    "In this lab, we have learned to upload and convert images. We have mastered extracting image colors and building / training / testing sets of classifiers. We have calculated the accuracy and studied how to build our own mask based on a classifier.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Authors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Yaroslav Vyklyuk, prof., PhD., DrSc](http://vyklyuk.bukuniver.edu.ua/en/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Copyright &copy; 2020 IBM Corporation. This notebook and its source code are released under the terms of the [MIT License](https://cognitiveclass.ai/mit-license/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkGuidedProjectsdatascienceinagriculturelanduseclassification462-2022-01-01).\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MS20_1",
   "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}