Land_usage_classification_in_Agriculture.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bTNUsESGTCx_"
      },
      "source": [
        "## **Land usage classification in Agriculture**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4U1e_D4uTCyA"
      },
      "source": [
        "## Abstract\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B5C93TbwTCyA"
      },
      "source": [
        "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": {
        "id": "soCumeLITCyB"
      },
      "source": [
        "## Introduction\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eGG6ByNJTCyB"
      },
      "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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Orc5CGtSTCyC"
      },
      "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": {
        "id": "rBNthcw8TCyD"
      },
      "source": [
        "# Download and visualization of images\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuEbyDdRTCyD"
      },
      "source": [
        "## Install the required libraries\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yRH0265TCyD"
      },
      "source": [
        "We need to install additional libraries and upgrade existing ones in the lab.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "tags": [],
        "id": "_uJ-gANJTCyE"
      },
      "outputs": [],
      "source": [
        "!pip install matplotlib>=3.4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "EIJdwKIpTCyG"
      },
      "outputs": [],
      "source": [
        "!pip install scikit-learn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "ctBm8kWnTCyG"
      },
      "outputs": [],
      "source": [
        "!pip install opencv-python"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "f-pJKJOoTCyH"
      },
      "outputs": [],
      "source": [
        "!pip install colormap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "lGvAYtcJTCyH"
      },
      "outputs": [],
      "source": [
        "!pip install scikit-learn-intelex"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LyEtcGi9TCyH"
      },
      "source": [
        "## Import the required libraries\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lSWBDkyYTCyH"
      },
      "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": 18,
      "metadata": {
        "tags": [],
        "id": "lhXRXAqxTCyI"
      },
      "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",
        "from colormap import rgb2hex, hex2rgb\n",
        "\n",
        "#Classifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.metrics import ConfusionMatrixDisplay"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCmXF4GXTCyI"
      },
      "source": [
        "## Loading of data\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dPaFY_1tTCyI"
      },
      "source": [
        "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": null,
      "metadata": {
        "tags": [],
        "id": "teCOE4TMTCyI"
      },
      "outputs": [],
      "source": [
        "!pip install skillsnetwork\n",
        "\n",
        "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": 36,
      "metadata": {
        "tags": [],
        "id": "2p3Q6ah_TCyJ"
      },
      "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]]:  # Choose the last subdirectory 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": {
        "tags": [],
        "id": "3M037r1uTCyJ"
      },
      "outputs": [],
      "source": [
        "d = \"Semantic segmentation dataset\"\n",
        "f = \"classes.json\"\n",
        "data = get_data(d, f)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bombKw-RTCyJ"
      },
      "source": [
        "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": {
        "id": "e7XzUv12TCyJ"
      },
      "source": [
        "# DataSet creation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zqu98XeSTCyK"
      },
      "source": [
        "Let's see how many images we downloaded:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "qoq2muv0TCyK"
      },
      "outputs": [],
      "source": [
        "len(data)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "etgcLvmMTCyK"
      },
      "source": [
        "Using 40% images and masks for training and 60% for tests.\n",
        "\n",
        "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, there's need to convert each image into a dataset of the form (r, g, b) -> class.\n",
        "\n",
        "To do this, 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": 39,
      "metadata": {
        "tags": [],
        "id": "GErAMmb2TCyK"
      },
      "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 = mk[:,:,0].flatten()\n",
        "        green = mk[:,:,1].flatten()\n",
        "        blue = mk[:,:,2].flatten()\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": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "3T_Wr1RBTCyL"
      },
      "outputs": [],
      "source": [
        "print(\"Create a training DataSet\")\n",
        "train = create_DataSet(data[:4])\n",
        "print(train)\n",
        "print(\"Create a test DataSet\")\n",
        "test = create_DataSet(data[4:])\n",
        "print(test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VrYcouhpTCyW"
      },
      "source": [
        "Study the column types of training and test DataSets.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "-xz3Wx6XTCyX"
      },
      "outputs": [],
      "source": [
        "train.info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "hF4KVtESTCyX"
      },
      "outputs": [],
      "source": [
        "test.info()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jh2YrKd6TCyX"
      },
      "source": [
        "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": {
        "tags": [],
        "id": "cr8qqA2QTCyX"
      },
      "outputs": [],
      "source": [
        "train.loc[:, 'HEX'] = train['HEX'].astype('category')\n",
        "train['HEX']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "VWrw9boJTCyX"
      },
      "outputs": [],
      "source": [
        "test.loc[:, 'HEX'] =  test['HEX'].astype('category')\n",
        "test['HEX']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fE-RQf4WTCyY"
      },
      "source": [
        "All other columns contain colors in int format, therefore we should change their types:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "GsghO32sTCyY"
      },
      "outputs": [],
      "source": [
        "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())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gIodiqRjTCyY"
      },
      "source": [
        "Visualize the data and see what exactly we are working with. 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": {
        "tags": [],
        "id": "CWcKlVjMTCyZ"
      },
      "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": {
        "tags": [],
        "id": "xAHMK6BOTCyZ"
      },
      "outputs": [],
      "source": [
        "c = pd.DataFrame(test['HEX'])\n",
        "sns.set_style('darkgrid')\n",
        "sns.countplot(x=\"HEX\", data=c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubtfMfC7TCya"
      },
      "source": [
        "The training and test DataSets contain similar distribution of images classes.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uVnEsi6wTCya"
      },
      "source": [
        "# Classification model creation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9WTdBEyTCya"
      },
      "source": [
        "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",
        "Using the 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?highlight=logisticregression#sklearn.linear_model.LogisticRegression.score)** functions are used for training and evaluating the accuracy.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0PcDOy-VTCya"
      },
      "source": [
        "We will use function **[ConfusionMatrixDisplay.from_estimator()](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.ConfusionMatrixDisplay.html)** for analysis.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "gS1bOZcgTCyb"
      },
      "outputs": [],
      "source": [
        "clf = LogisticRegression(max_iter=500, n_jobs=-1)\n",
        "c = train.columns\n",
        "clf.fit(train[c[0:3]], train[c[-1:]].values.ravel())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "b3Oo6LyITCyb"
      },
      "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",
        "ConfusionMatrixDisplay.from_estimator(clf, test[c[0:3]], test[c[-1:]].values.ravel())\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ydtuJbgTCyb"
      },
      "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": {
        "id": "1pXzGZrpTCyb"
      },
      "source": [
        "# Create your own mask of land use\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jC3BVk8TCyb"
      },
      "source": [
        "To build a mask based on the classifier model, you would need to choose a few images from the downloaded data list and build your DataSet.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "rL5jov3rTCyb"
      },
      "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": {
        "id": "4cNAt1F1TCyc"
      },
      "source": [
        "Then, calculate the hex colour of classes using the model:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "tags": [],
        "id": "AY0Gf-SKTCyc"
      },
      "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": {
        "id": "RkNbFRPeTCyc"
      },
      "source": [
        "Further, there's 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": {
        "tags": [],
        "id": "uDgVYTaTTCyc"
      },
      "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": {
        "id": "_FXLF-mKTCyd"
      },
      "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": {
        "tags": [],
        "id": "wXwuA_BPTCye"
      },
      "outputs": [],
      "source": [
        "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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fjIfMlx-TCye"
      },
      "source": [
        "Let's compare the mask with the original one.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zYMXwEHkTCyf"
      },
      "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": {
        "id": "PlxTBBdtTCyf"
      },
      "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": {
        "id": "A9R6PCuaTCyf"
      },
      "source": [
        "## Conclusions\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MoYFWtOtTCyf"
      },
      "source": [
        "Created an expert system based on classifiers, which allows one 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",
        "Uploaded and converted images. Mastered extracting image colors and building / training / testing sets of classifiers. Calculated the accuracy and studied how to build a mask based on a classifier.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxaEWJSQTCyg"
      },
      "source": [
        "## Authors\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1utPkZQ9TCyg"
      },
      "source": [
        "[Elomunait John Omoding](https://www.linkedin.com/in/johnelomunait)\n",
        "\n",
        "[Yaroslav Vyklyuk, prof., PhD., DrSc](https://author.skills.network/instructors/yaroslav_vyklyuk_2)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9qd9iJpJTCyg"
      },
      "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": "Python",
      "language": "python",
      "name": "conda-env-python-py"
    },
    "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.12"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}