ML_KNN_on_Iris_Datset_ex.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ML- KNN on Iris Datset ex.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dinbav/Machine-Learning-Tutorials/blob/main/ML_KNN_on_Iris_Datset_ex.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vxOsyr691EM7"
      },
      "source": [
        "# KNN (using scikit-learn) on Iris dataset.\n",
        "#### Building a model to classify the species of Iris flower based on the sepal length, speal width, petal length and petal width\n",
        "###please follow [this tutorial](https://www.datacamp.com/community/tutorials/k-nearest-neighbor-classification-scikit-learn) and implement here. \n",
        "Detailed documentation on KNN is available [here](http://scikit-learn.org/stable/modules/neighbors.html).\n",
        "\n",
        "In this exercise will implement KNN on iris dataset using scikit-learn library. Iris dataset has 50 samples for each different species of Iris flower(total of 150). For each sample we have sepal length, width and petal length and width and a species name(class/label).\n",
        "\n",
        "\n",
        "Your task is to build a KNN model which classifies the new species based on the sepal and petal measurements. Iris dataset is available in scikit-learn and we can make use of it build our KNN."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Xuo_o0FGQE0"
      },
      "source": [
        "###Step1: Import the required data and check the features.\n",
        "Import the load_iris function form scikit-learen datasets module and create a iris Bunch object(bunch is a scikitlearn’s special object type for storing datasets and its attributes)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LibhfGaA1ENE"
      },
      "source": [
        "## Load the Iris data set and check the features"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "exN_RwOO1ENF"
      },
      "source": [
        "#Import the load_iris function from datsets module\n",
        "from sklearn.datasets import load_iris"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mOY3Wt2L1ENI"
      },
      "source": [
        "#Create bunch object containing iris dataset and its attributes.\n",
        "iris = load_iris()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Xtb52DZI-xv"
      },
      "source": [
        "####Exploring Data\n",
        "After you have loaded the dataset, you might want to know a little bit more about it. You can check feature and target names."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NUg1K4ei1ENM",
        "outputId": "07970f05-c4e2-4655-9ce3-70bd555076a0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 163
        }
      },
      "source": [
        "type(iris)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-2566266fcf46>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miris\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'iris' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9t_RqdyA1ENP"
      },
      "source": [
        "#Print the iris data\n",
        "iris.data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZonWB33JGxpM"
      },
      "source": [
        "Each observation represents one flower and 4 columns represents 4 measurements.We can see the features(measures) under ‘data’ attribute, where as labels under ‘features_names’. As we can see below, labels/responses are encoded as 0,1 and 2. Because the features and repose should be numeric (Numpy arrays) for scikit-learn models and they should have a specific shape.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fNiLYd-C1ENU"
      },
      "source": [
        "#Names of 4 features (column names)\n",
        "# print the names of the features\n",
        "#your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y9XZFguQ1ENY"
      },
      "source": [
        "#Integers representing the species: 0 = setosa, 1=versicolor, 2=virginica\n",
        "# print the label species\n",
        "#your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oVn1PtaqJJ8N"
      },
      "source": [
        "Let's check records of the target set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iMjwetMo1ENb"
      },
      "source": [
        "# 3 classes of target\n",
        "# print target_names\n",
        "#your code here\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BDkNANkN1ENf"
      },
      "source": [
        "print(type(iris.data))\n",
        "print(type(iris.target))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4g-yDkdzJl6O"
      },
      "source": [
        "check the shape of the dataset using shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "99J-Xb3Y1ENj"
      },
      "source": [
        "# print data(feature)shape\n",
        "#your code here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AarA9B-B1ENm"
      },
      "source": [
        "# Feature matrix in a object named X\n",
        "X = iris.data\n",
        "# response vector in a object named y\n",
        "y = iris.target"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VIX4wxI1ENr"
      },
      "source": [
        "print(X.shape)\n",
        "print(y.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJPoqTDF1ENv"
      },
      "source": [
        "# Train the Model "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPcwNpUSG5Sm"
      },
      "source": [
        "###Step 2: Split the data and Train the Model.\n",
        "Training and testing on the same data is not an optimal approach, so we do split the data into two pieces, training set and testing set. We use ‘train_test_split’ function to split the data. Optional parameter ‘test-size’ determines the split percentage. ‘random_state’ parameter makes the data split the same way every time you run. Since we are training and testing on different sets of data, the resulting testing accuracy will be a better estimate of how well the model is likely to perform on unseen data.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "og9Ei02q1ENw"
      },
      "source": [
        "# Import train_test_split function (if  cross_validation dosen't work Try substituting with model_selection)\n",
        "\n",
        "__________________ = ______________(X,y,test_size=_____,random_state=4) # 80% training and 20% test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FYEbtycE1ENy"
      },
      "source": [
        "#shape of train and test objects\n",
        "print(X_train.shape)\n",
        "print(X_test.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6W89isoi1EN0"
      },
      "source": [
        "# shape of new y objects\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hWYTkjFHKXs"
      },
      "source": [
        "Scikit-learn is carefully organized into modules, so that we can import the relevant classes easily. Import the class ‘KNeighborsClassifer’ from ‘neighbors’ module and Instantiate the estimator (‘estimator’ is scikit-learn’s term for a model). We are calling model as estimator because their primary role is to estimate unknown quantities.\n",
        "In our example we are creating an instance (‘knn’ ) of the class ‘KNeighborsClassifer’, in other words we have created an object called ‘knn’ which knows how to do KNN classification once we provide the data. The parameter ‘n_neighbors’ is the tuning parameter/hyper parameter (k) . All other parameters are set to default values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RANk_64n6RNo"
      },
      "source": [
        "##Generating Model for K\n",
        "Choose two diffrent K and build KNN classifier model for them"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fYO-8Lmq7IYP"
      },
      "source": [
        "### First K chosen"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_QRGEfBY6puT"
      },
      "source": [
        "#Import knearest neighbors Classifier model\n",
        "\n",
        "\n",
        "#Create KNN Classifier\n",
        "\n",
        "\n",
        "#Train the model using the training sets\n",
        "\n",
        "\n",
        "#Predict the response for test dataset\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4G4D5Mr86y38"
      },
      "source": [
        "####Model Evaluation for k\n",
        "Let's estimate, how accurately the classifier or model can predict the type of cultivars.\n",
        "\n",
        "Accuracy can be computed by comparing actual test set values and predicted values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LcCt9PlY6_Ri"
      },
      "source": [
        "#Import scikit-learn metrics module for accuracy calculation\n",
        "\n",
        "# Model Accuracy, how often is the classifier correct?\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wXsUAop7UZb"
      },
      "source": [
        "### Second K chosen"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4t_YRxof7UZh"
      },
      "source": [
        "#Import knearest neighbors Classifier model\n",
        "\n",
        "\n",
        "#Create KNN Classifier\n",
        "\n",
        "\n",
        "#Train the model using the training sets\n",
        "\n",
        "\n",
        "#Predict the response for test dataset\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rwHNOjRr7UZo"
      },
      "source": [
        "####Model Evaluation for k\n",
        "Let's estimate, how accurately the classifier or model can predict the type of cultivars.\n",
        "\n",
        "Accuracy can be computed by comparing actual test set values and predicted values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VbpnXyyM7UZq"
      },
      "source": [
        "#Import scikit-learn metrics module for accuracy calculation\n",
        "\n",
        "# Model Accuracy, how often is the classifier correct?\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J4xWlJGz8EbC"
      },
      "source": [
        "##Please explain in hebrew as simple as can (for dummies) the following:\n",
        "\n",
        "\n",
        "\n",
        "1.   The results- and its meaning\n",
        "2.   KNN pros\n",
        "1.   KNN cons\n",
        "2.   How to improve KNN?\n",
        "2.   Your Conclusion and feedback\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZZyoraM9oZ0"
      },
      "source": [
        "write your answers here"
      ]
    }
  ]
}