From 7fefd1cb7125e84bbc2def7a48a502ab899136c1 Mon Sep 17 00:00:00 2001
From: Srishti Chauhan <104318680+Srishtichauhan5359@users.noreply.github.com>
Date: Thu, 20 Oct 2022 00:14:43 +0530
Subject: [PATCH 1/2] Naive-Bayes

---
 ML Algorithms/NaiveBayes.ipynb | 1692 ++++++++++++++++++++++++++++++++
 1 file changed, 1692 insertions(+)
 create mode 100644 ML Algorithms/NaiveBayes.ipynb

diff --git a/ML Algorithms/NaiveBayes.ipynb b/ML Algorithms/NaiveBayes.ipynb
new file mode 100644
index 00000000..f587f9ec
--- /dev/null
+++ b/ML Algorithms/NaiveBayes.ipynb	
@@ -0,0 +1,1692 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ytmXJBL3qPjo"
+      },
+      "source": [
+        "# **Naive Bayes Classification - Implementation**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "WiC3dFzRe444"
+      },
+      "outputs": [],
+      "source": [
+        "# importing the libraries\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import pandas as pd\n",
+        "import seaborn as sns"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6zUPxkGqjlV8"
+      },
+      "source": [
+        "**Once we have imported all the required modules, the next step is to import the data set and split the data sets into inputs and outputs.** "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "BuVm9YfffLck"
+      },
+      "outputs": [],
+      "source": [
+        "# importing the dataset\n",
+        "dataset = pd.read_csv('NaiveBayes.csv')\n",
+        "\n",
+        "# split the data into inputs and outputs\n",
+        "X = dataset.iloc[:, [0,1]].values\n",
+        "y = dataset.iloc[:, 2].values"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6GNGuoJETVWF",
+        "outputId": "733a383d-e965-46b7-e01a-aec46df47f91"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "800\n"
+          ]
+        }
+      ],
+      "source": [
+        "from numpy.ma.core import count\n",
+        "print(count(X))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BgOg3hk0jvSc"
+      },
+      "source": [
+        "**The next step is to divide the input and output values into the training and testing part so that once the training of the model is complete, we can evaluate its performance using testing data.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "4R9_T3WnfOn9"
+      },
+      "outputs": [],
+      "source": [
+        "# training and testing data\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "# assign test data size 25%\n",
+        "X_train, X_test, y_train, y_test =train_test_split(X,y,test_size= 0.25, random_state=0)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KZe_MTZKSqbC",
+        "outputId": "e3fd1194-7d45-4334-e757-710575144373"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "200\n"
+          ]
+        }
+      ],
+      "source": [
+        "from numpy.ma.core import count\n",
+        "print(count(X_test))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uhIM9EN9junr"
+      },
+      "source": [
+        "**We set test_size=0.25, which means 25% of the whole data set will be assigned to the testing part and the remaining 75% will be used for the model’s training.**\n",
+        "**The next step is to scale our dataset to be ready to be used for the training.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "40RtvU4FfSbM"
+      },
+      "outputs": [],
+      "source": [
+        "# importing standard scaler\n",
+        "from sklearn.preprocessing import StandardScaler\n",
+        "\n",
+        "# scalling the input data\n",
+        "sc_X = StandardScaler() \n",
+        "X_train = sc_X.fit_transform(X_train)\n",
+        "X_test = sc_X.fit_transform(X_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DYmlUO8WSVp7",
+        "outputId": "2bea9c3a-788c-4dd4-c918-361b0661e352"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[[ 0.58164944 -0.88670699]\n",
+            " [-0.60673761  1.46173768]\n",
+            " [-0.01254409 -0.5677824 ]\n",
+            " [-0.60673761  1.89663484]\n",
+            " [ 1.37390747 -1.40858358]\n",
+            " [ 1.47293972  0.99784738]\n",
+            " [ 0.08648817 -0.79972756]\n",
+            " [-0.01254409 -0.24885782]\n",
+            " [-0.21060859 -0.5677824 ]\n",
+            " [-0.21060859 -0.19087153]\n",
+            " [-0.30964085 -1.29261101]\n",
+            " [-0.30964085 -0.5677824 ]\n",
+            " [ 0.38358493  0.09905991]\n",
+            " [ 0.8787462  -0.59677555]\n",
+            " [ 2.06713324 -1.17663843]\n",
+            " [ 1.07681071 -0.13288524]\n",
+            " [ 0.68068169  1.78066227]\n",
+            " [-0.70576986  0.56295021]\n",
+            " [ 0.77971394  0.35999821]\n",
+            " [ 0.8787462  -0.53878926]\n",
+            " [-1.20093113 -1.58254245]\n",
+            " [ 2.1661655   0.93986109]\n",
+            " [-0.01254409  1.22979253]\n",
+            " [ 0.18552042  1.08482681]\n",
+            " [ 0.38358493 -0.48080297]\n",
+            " [-0.30964085 -0.30684411]\n",
+            " [ 0.97777845 -0.8287207 ]\n",
+            " [ 0.97777845  1.8676417 ]\n",
+            " [-0.01254409  1.25878567]\n",
+            " [-0.90383437  2.27354572]\n",
+            " [-1.20093113 -1.58254245]\n",
+            " [ 2.1661655  -0.79972756]\n",
+            " [-1.39899564 -1.46656987]\n",
+            " [ 0.38358493  2.30253886]\n",
+            " [ 0.77971394  0.76590222]\n",
+            " [-1.00286662 -0.30684411]\n",
+            " [ 0.08648817  0.76590222]\n",
+            " [-1.00286662  0.56295021]\n",
+            " [ 0.28455268  0.07006676]\n",
+            " [ 0.68068169 -1.26361786]\n",
+            " [-0.50770535 -0.01691267]\n",
+            " [-1.79512465  0.35999821]\n",
+            " [-0.70576986  0.12805305]\n",
+            " [ 0.38358493  0.30201192]\n",
+            " [-0.30964085  0.07006676]\n",
+            " [-0.50770535  2.30253886]\n",
+            " [ 0.18552042  0.04107362]\n",
+            " [ 1.27487521  2.21555943]\n",
+            " [ 0.77971394  0.27301877]\n",
+            " [-0.30964085  0.1570462 ]\n",
+            " [-0.01254409 -0.53878926]\n",
+            " [-0.21060859  0.1570462 ]\n",
+            " [-0.11157634  0.24402563]\n",
+            " [-0.01254409 -0.24885782]\n",
+            " [ 2.1661655   1.11381995]\n",
+            " [-1.79512465  0.35999821]\n",
+            " [ 1.86906873  0.12805305]\n",
+            " [ 0.38358493 -0.13288524]\n",
+            " [-1.20093113  0.30201192]\n",
+            " [ 0.77971394  1.37475825]\n",
+            " [-0.30964085 -0.24885782]\n",
+            " [-1.6960924  -0.04590581]\n",
+            " [-1.00286662 -0.74174127]\n",
+            " [ 0.28455268  0.50496393]\n",
+            " [-0.11157634 -1.06066585]\n",
+            " [-1.10189888  0.59194336]\n",
+            " [ 0.08648817 -0.79972756]\n",
+            " [-1.00286662  1.54871711]\n",
+            " [-0.70576986  1.40375139]\n",
+            " [-1.29996338  0.50496393]\n",
+            " [-0.30964085  0.04107362]\n",
+            " [-0.11157634  0.01208048]\n",
+            " [-0.30964085 -0.88670699]\n",
+            " [ 0.8787462  -1.3505973 ]\n",
+            " [-0.30964085  2.24455257]\n",
+            " [ 0.97777845  1.98361427]\n",
+            " [-1.20093113  0.47597078]\n",
+            " [-1.29996338  0.27301877]\n",
+            " [ 1.37390747  1.98361427]\n",
+            " [ 1.27487521 -1.3505973 ]\n",
+            " [-0.30964085 -0.27785096]\n",
+            " [-0.50770535  1.25878567]\n",
+            " [-0.80480212  1.08482681]\n",
+            " [ 0.97777845 -1.06066585]\n",
+            " [ 0.28455268  0.30201192]\n",
+            " [ 0.97777845  0.76590222]\n",
+            " [-0.70576986 -1.49556302]\n",
+            " [-0.70576986  0.04107362]\n",
+            " [ 0.48261718  1.72267598]\n",
+            " [ 2.06713324  0.18603934]\n",
+            " [-1.99318916 -0.74174127]\n",
+            " [-0.21060859  1.40375139]\n",
+            " [ 0.38358493  0.59194336]\n",
+            " [ 0.8787462  -1.14764529]\n",
+            " [-1.20093113 -0.77073441]\n",
+            " [ 0.18552042  0.24402563]\n",
+            " [ 0.77971394 -0.30684411]\n",
+            " [ 2.06713324 -0.79972756]\n",
+            " [ 0.77971394  0.12805305]\n",
+            " [-0.30964085  0.6209365 ]\n",
+            " [-1.00286662 -0.30684411]\n",
+            " [ 0.18552042 -0.3648304 ]\n",
+            " [ 2.06713324  2.12857999]\n",
+            " [ 1.86906873 -1.26361786]\n",
+            " [ 1.37390747 -0.91570013]\n",
+            " [ 0.8787462   1.25878567]\n",
+            " [ 1.47293972  2.12857999]\n",
+            " [-0.30964085 -1.23462472]\n",
+            " [ 1.96810099  0.91086794]\n",
+            " [ 0.68068169 -0.71274813]\n",
+            " [-1.49802789  0.35999821]\n",
+            " [ 0.77971394 -1.3505973 ]\n",
+            " [ 0.38358493 -0.13288524]\n",
+            " [-1.00286662  0.41798449]\n",
+            " [-0.01254409 -0.30684411]\n",
+            " [-1.20093113  0.41798449]\n",
+            " [-0.90383437 -1.20563157]\n",
+            " [-0.11157634  0.04107362]\n",
+            " [-1.59706014 -0.42281668]\n",
+            " [ 0.97777845 -1.00267957]\n",
+            " [ 1.07681071 -1.20563157]\n",
+            " [-0.01254409 -0.13288524]\n",
+            " [-1.10189888 -1.52455616]\n",
+            " [ 0.77971394 -1.20563157]\n",
+            " [ 0.97777845  2.07059371]\n",
+            " [-1.20093113 -1.52455616]\n",
+            " [-0.30964085  0.79489537]\n",
+            " [ 0.08648817 -0.30684411]\n",
+            " [-1.39899564 -1.23462472]\n",
+            " [-0.60673761 -1.49556302]\n",
+            " [ 0.77971394  0.53395707]\n",
+            " [-0.30964085 -0.33583725]\n",
+            " [ 1.77003648 -0.27785096]\n",
+            " [ 0.8787462  -1.03167271]\n",
+            " [ 0.18552042  0.07006676]\n",
+            " [-0.60673761  0.8818748 ]\n",
+            " [-1.89415691 -1.40858358]\n",
+            " [-1.29996338  0.59194336]\n",
+            " [-0.30964085  0.53395707]\n",
+            " [-1.00286662 -1.089659  ]\n",
+            " [ 1.17584296 -1.43757673]\n",
+            " [ 0.18552042 -0.30684411]\n",
+            " [ 1.17584296 -0.74174127]\n",
+            " [-0.30964085  0.07006676]\n",
+            " [ 0.18552042  2.09958685]\n",
+            " [ 0.77971394 -1.089659  ]\n",
+            " [ 0.08648817  0.04107362]\n",
+            " [-1.79512465  0.12805305]\n",
+            " [-0.90383437  0.1570462 ]\n",
+            " [-0.70576986  0.18603934]\n",
+            " [ 0.8787462  -1.29261101]\n",
+            " [ 0.18552042 -0.24885782]\n",
+            " [-0.4086731   1.22979253]\n",
+            " [-0.01254409  0.30201192]\n",
+            " [ 0.38358493  0.1570462 ]\n",
+            " [ 0.8787462  -0.65476184]\n",
+            " [ 0.08648817  0.1570462 ]\n",
+            " [-1.89415691 -1.29261101]\n",
+            " [-0.11157634  0.30201192]\n",
+            " [-0.21060859 -0.27785096]\n",
+            " [ 0.28455268 -0.50979612]\n",
+            " [-0.21060859  1.6067034 ]\n",
+            " [ 0.97777845 -1.17663843]\n",
+            " [-0.21060859  1.63569655]\n",
+            " [ 1.27487521  1.8676417 ]\n",
+            " [-1.10189888 -0.3648304 ]\n",
+            " [-0.01254409  0.04107362]\n",
+            " [ 0.08648817 -0.24885782]\n",
+            " [-1.59706014 -1.23462472]\n",
+            " [-0.50770535 -0.27785096]\n",
+            " [ 0.97777845  0.12805305]\n",
+            " [ 1.96810099 -1.3505973 ]\n",
+            " [ 1.47293972  0.07006676]\n",
+            " [-0.60673761  1.37475825]\n",
+            " [ 1.57197197  0.01208048]\n",
+            " [-0.80480212  0.30201192]\n",
+            " [ 1.96810099  0.73690908]\n",
+            " [-1.20093113 -0.50979612]\n",
+            " [ 0.68068169  0.27301877]\n",
+            " [-1.39899564 -0.42281668]\n",
+            " [ 0.18552042  0.1570462 ]\n",
+            " [-0.50770535 -1.20563157]\n",
+            " [ 0.58164944  2.01260742]\n",
+            " [-1.59706014 -1.49556302]\n",
+            " [-0.50770535 -0.53878926]\n",
+            " [ 0.48261718  1.83864855]\n",
+            " [-1.39899564 -1.089659  ]\n",
+            " [ 0.77971394 -1.37959044]\n",
+            " [-0.30964085 -0.42281668]\n",
+            " [ 1.57197197  0.99784738]\n",
+            " [ 0.97777845  1.43274454]\n",
+            " [-0.30964085 -0.48080297]\n",
+            " [-0.11157634  2.15757314]\n",
+            " [-1.49802789 -0.1038921 ]\n",
+            " [-0.11157634  1.95462113]\n",
+            " [-0.70576986 -0.33583725]\n",
+            " [-0.50770535 -0.8287207 ]\n",
+            " [ 0.68068169 -1.37959044]\n",
+            " [-0.80480212 -1.58254245]\n",
+            " [-1.89415691 -1.46656987]\n",
+            " [ 1.07681071  0.12805305]\n",
+            " [ 0.08648817  1.51972397]\n",
+            " [-0.30964085  0.09905991]\n",
+            " [ 0.08648817  0.04107362]\n",
+            " [-1.39899564 -1.3505973 ]\n",
+            " [ 0.28455268  0.07006676]\n",
+            " [-0.90383437  0.38899135]\n",
+            " [ 1.57197197 -1.26361786]\n",
+            " [-0.30964085 -0.74174127]\n",
+            " [-0.11157634  0.1570462 ]\n",
+            " [-0.90383437 -0.65476184]\n",
+            " [-0.70576986 -0.04590581]\n",
+            " [ 0.38358493 -0.45180983]\n",
+            " [-0.80480212  1.89663484]\n",
+            " [ 1.37390747  1.28777882]\n",
+            " [ 1.17584296 -0.97368642]\n",
+            " [ 1.77003648  1.83864855]\n",
+            " [-0.90383437 -0.24885782]\n",
+            " [-0.80480212  0.56295021]\n",
+            " [-1.20093113 -1.5535493 ]\n",
+            " [-0.50770535 -1.11865214]\n",
+            " [ 0.28455268  0.07006676]\n",
+            " [-0.21060859 -1.06066585]\n",
+            " [ 1.67100423  1.6067034 ]\n",
+            " [ 0.97777845  1.78066227]\n",
+            " [ 0.28455268  0.04107362]\n",
+            " [-0.80480212 -0.21986468]\n",
+            " [-0.11157634  0.07006676]\n",
+            " [ 0.28455268 -0.19087153]\n",
+            " [ 1.96810099 -0.65476184]\n",
+            " [-0.80480212  1.3457651 ]\n",
+            " [-1.79512465 -0.59677555]\n",
+            " [-0.11157634  0.12805305]\n",
+            " [ 0.28455268 -0.30684411]\n",
+            " [ 1.07681071  0.56295021]\n",
+            " [-1.00286662  0.27301877]\n",
+            " [ 1.47293972  0.35999821]\n",
+            " [ 0.18552042 -0.3648304 ]\n",
+            " [ 2.1661655  -1.03167271]\n",
+            " [-0.30964085  1.11381995]\n",
+            " [-1.6960924   0.07006676]\n",
+            " [-0.01254409  0.04107362]\n",
+            " [ 0.08648817  1.05583366]\n",
+            " [-0.11157634 -0.3648304 ]\n",
+            " [-1.20093113  0.07006676]\n",
+            " [-0.30964085 -1.3505973 ]\n",
+            " [ 1.57197197  1.11381995]\n",
+            " [-0.80480212 -1.52455616]\n",
+            " [ 0.08648817  1.8676417 ]\n",
+            " [-0.90383437 -0.77073441]\n",
+            " [-0.50770535 -0.77073441]\n",
+            " [-0.30964085 -0.91570013]\n",
+            " [ 0.28455268 -0.71274813]\n",
+            " [ 0.28455268  0.07006676]\n",
+            " [ 0.08648817  1.8676417 ]\n",
+            " [-1.10189888  1.95462113]\n",
+            " [-1.6960924  -1.5535493 ]\n",
+            " [-1.20093113 -1.089659  ]\n",
+            " [-0.70576986 -0.1038921 ]\n",
+            " [ 0.08648817  0.09905991]\n",
+            " [ 0.28455268  0.27301877]\n",
+            " [ 0.8787462  -0.5677824 ]\n",
+            " [ 0.28455268 -1.14764529]\n",
+            " [-0.11157634  0.67892279]\n",
+            " [ 2.1661655  -0.68375498]\n",
+            " [-1.29996338 -1.37959044]\n",
+            " [-1.00286662 -0.94469328]\n",
+            " [-0.01254409 -0.42281668]\n",
+            " [-0.21060859 -0.45180983]\n",
+            " [-1.79512465 -0.97368642]\n",
+            " [ 1.77003648  0.99784738]\n",
+            " [ 0.18552042 -0.3648304 ]\n",
+            " [ 0.38358493  1.11381995]\n",
+            " [-1.79512465 -1.3505973 ]\n",
+            " [ 0.18552042 -0.13288524]\n",
+            " [ 0.8787462  -1.43757673]\n",
+            " [-1.99318916  0.47597078]\n",
+            " [-0.30964085  0.27301877]\n",
+            " [ 1.86906873 -1.06066585]\n",
+            " [-0.4086731   0.07006676]\n",
+            " [ 1.07681071 -0.88670699]\n",
+            " [-1.10189888 -1.11865214]\n",
+            " [-1.89415691  0.01208048]\n",
+            " [ 0.08648817  0.27301877]\n",
+            " [-1.20093113  0.33100506]\n",
+            " [-1.29996338  0.30201192]\n",
+            " [-1.00286662  0.44697764]\n",
+            " [ 1.67100423 -0.88670699]\n",
+            " [ 1.17584296  0.53395707]\n",
+            " [ 1.07681071  0.53395707]\n",
+            " [ 1.37390747  2.331532  ]\n",
+            " [-0.30964085 -0.13288524]\n",
+            " [ 0.38358493 -0.45180983]\n",
+            " [-0.4086731  -0.77073441]\n",
+            " [-0.11157634 -0.50979612]\n",
+            " [ 0.97777845 -1.14764529]\n",
+            " [-0.90383437 -0.77073441]\n",
+            " [-0.21060859 -0.50979612]\n",
+            " [-1.10189888 -0.45180983]\n",
+            " [-1.20093113  1.40375139]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print (X_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lx9iPWfHkV9j"
+      },
+      "source": [
+        "**Note: scaling (or standardization) of a dataset is a common requirement for many machine learning estimators: they might behave badly if the individual features do not more or less look like standard normally distributed data.**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "w2lSZnqCkZ63"
+      },
+      "source": [
+        "# Training the model using Bernolli Naive Bayes classifier"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "FP8t3In8fV9W"
+      },
+      "outputs": [],
+      "source": [
+        "# importing classifier\n",
+        "from sklearn.naive_bayes import BernoulliNB\n",
+        "\n",
+        "# initializaing the NB\n",
+        "classifer = BernoulliNB()\n",
+        "\n",
+        "# training the model\n",
+        "classifer.fit(X_train, y_train)\n",
+        "\n",
+        "# testing the model\n",
+        "y_pred = classifer.predict(X_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "K9hmZu_xoB9A",
+        "outputId": "175d79cb-3615-4534-8b79-72bc6855480a"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1,\n",
+              "       0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+              "       1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,\n",
+              "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n",
+              "       0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1], dtype=int64)"
+            ]
+          },
+          "execution_count": 12,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "y_pred"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ARx119-GkZKE"
+      },
+      "source": [
+        "**Now let us check the accuracy of the predicted values using the Bernoulli Naive Bayes classifier.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "tp-0cr1SfYwt",
+        "outputId": "a2c49250-a97b-4ed5-89a4-187b45492947"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0.8\n"
+          ]
+        }
+      ],
+      "source": [
+        "# importing accuracy score\n",
+        "from sklearn.metrics import accuracy_score\n",
+        "\n",
+        "# printing the accuracy of the model\n",
+        "print(accuracy_score(y_pred, y_test))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Nu4AMjUWkpUE"
+      },
+      "source": [
+        "# We got an accuracy of 80% when we trained our model using Bernoulli Naive Bayes classifier."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UqyqZCoxkyL-"
+      },
+      "source": [
+        "# Training model using Gaussian Naive Bayes Classifier"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "id": "V-oTMzy3fdgs"
+      },
+      "outputs": [],
+      "source": [
+        "# import Gaussian Naive Bayes classifier\n",
+        "from sklearn.naive_bayes import GaussianNB\n",
+        "\n",
+        "# create a Gaussian Classifier\n",
+        "classifer1 = GaussianNB()\n",
+        "\n",
+        "# training the model\n",
+        "classifer1.fit(X_train, y_train)\n",
+        "\n",
+        "# testing the model\n",
+        "y_pred1 = classifer1.predict(X_test)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sNXmuBvOor3d",
+        "outputId": "36255849-c7e7-44d7-a496-72f8f5a1128e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "array([0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1,\n",
+              "       0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n",
+              "       1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1,\n",
+              "       0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1,\n",
+              "       1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1])"
+            ]
+          },
+          "execution_count": 13,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "y_pred1"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HSA2ET12fg5d",
+        "outputId": "eccabdab-6a0a-4f84-9f18-4c0381e8bc68"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0.91\n"
+          ]
+        }
+      ],
+      "source": [
+        "# importing accuracy score\n",
+        "from sklearn.metrics import accuracy_score\n",
+        "\n",
+        "# printing the accuracy of the model\n",
+        "print(accuracy_score(y_test,y_pred1))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3HncFnjnk5b4"
+      },
+      "source": [
+        "# **This time we got an accuracy of 91% when we trained the model on the same dataset.**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZUc0mZdRlJHk"
+      },
+      "source": [
+        "**Confusion Matrix for Binary classification:**\n",
+        "Confusion Matrix is also known as error matrix. It is a table layout that allows visualization of the performance of a classification algorithm. Each row of the matrix represents the instances in an actual class, while each column represents the instances in a predicted class, or vice versa.\n",
+        "![confusion.PNG](data:image/png;base64,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)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "oc7U9xftl_3_"
+      },
+      "source": [
+        "Evaluation of Bernoulli Naive Bayes classifier\n",
+        "\n",
+        "Let’s evaluate ourBernoulli Naive Bayes model using a confusion matrix that will visually help us see the number of correct and incorrect classified classes. First of all, we’ll visualize our model’s results. The predicted values are stored in a variable named y_pred."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 265
+        },
+        "id": "mH3cN09Mfknn",
+        "outputId": "434c2539-4acd-4f82-b3dd-c63d85f0f69b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# importing the required modules\n",
+        "import seaborn as sns\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "\n",
+        "# passing actual and predicted values\n",
+        "cm = confusion_matrix(y_test, y_pred)\n",
+        "\n",
+        "# true write data values in each cell of the matrix\n",
+        "sns.heatmap(cm, annot=True)\n",
+        "plt.savefig('confusion.png')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5q5dpLcLmGsF"
+      },
+      "source": [
+        "The confusion matrix helps us know which class has been mispredicted.\n",
+        "\n",
+        "We can also print the classification report, which will help us further evaluate our model’s performance."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VNColYjhfn-7",
+        "outputId": "0d1ac13d-4aca-434b-ed84-dd4a5b7e6995"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       0.82      0.91      0.86        68\n",
+            "           1       0.75      0.56      0.64        32\n",
+            "\n",
+            "    accuracy                           0.80       100\n",
+            "   macro avg       0.78      0.74      0.75       100\n",
+            "weighted avg       0.79      0.80      0.79       100\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# importing classification report\n",
+        "from sklearn.metrics import classification_report\n",
+        "\n",
+        "# printing the report\n",
+        "print(classification_report(y_test, y_pred))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c8vK73wVmM4G"
+      },
+      "source": [
+        "**Note: the Gaussian naive Bayes classifier performed very well on this dataset, as shown in the confusion matrix. Let us now print out the classification report as well,**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 265
+        },
+        "id": "Bt9ZhqUOftcv",
+        "outputId": "b7bd1237-6f98-489e-d623-606ff5d29cb8"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# importing the required modules\n",
+        "import seaborn as sns\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "\n",
+        "# passing actual and predicted values\n",
+        "cm = confusion_matrix(y_test, y_pred1)\n",
+        "\n",
+        "# true write data values in each cell of the matrix\n",
+        "sns.heatmap(cm,annot=True)\n",
+        "plt.savefig('confusion.png')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "aYXctkgDfwUk",
+        "outputId": "475cf0c1-3d1a-425f-bb61-c68a5472e241"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       0.93      0.94      0.93        68\n",
+            "           1       0.87      0.84      0.86        32\n",
+            "\n",
+            "    accuracy                           0.91       100\n",
+            "   macro avg       0.90      0.89      0.90       100\n",
+            "weighted avg       0.91      0.91      0.91       100\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# importing classification report\n",
+        "from sklearn.metrics import classification_report\n",
+        "\n",
+        "# printing the report\n",
+        "print(classification_report(y_test, y_pred1))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "P6wVkNPTmSrd"
+      },
+      "source": [
+        "# Features Encoding\n",
+        "\n",
+        "**In real life, the data does not always consist of numeric values. For example, playing or not playing are not numeric values. In such scenarios, we need to convert the non-numeric data to numeric values before feeding data to our model. For example, we have the following dataset about whether players will play sport or not, depending on the weather and temperature.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "_kF2H9Q0gNqz"
+      },
+      "outputs": [],
+      "source": [
+        "# assigning features and label variables\n",
+        "weather = ['Sunny','Sunny','Overcast','Rainy','Rainy','Rainy','Overcast','Sunny','Sunny', 'Rainy','Sunny','Overcast','Overcast','Rainy','Rainy']\n",
+        "\n",
+        "# output class\n",
+        "play = ['No','No','Yes','No','Yes','No','Yes','No','Yes','Yes','Yes','Yes','Yes','No','Yes']"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "uAuoT9z5gRAt"
+      },
+      "outputs": [],
+      "source": [
+        "# Import LabelEncoder\n",
+        "from sklearn import preprocessing\n",
+        "\n",
+        "# creating LabelEncoder\n",
+        "labelCode = preprocessing.LabelEncoder()\n",
+        "\n",
+        "# Converting string labels into numbers.\n",
+        "weather_encoded=labelCode.fit_transform(weather)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ollTUMu6mbFt"
+      },
+      "source": [
+        "***Note: the input and output both are not numeric values. Before feeding this data to our model, we have to encode the non-numeric values into numeric ones. for example, Overcast = 0, Rainy = 1, Sunny = 2. This is called label encoding.***"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hioaVahZgTzj",
+        "outputId": "edd46685-d470-4bf0-d770-5e8cd7becf46"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[2 2 0 1 1 1 0 2 2 1 2 0 0 1 1]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(weather_encoded)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LuwNOD_6miJt"
+      },
+      "source": [
+        "The LabelEncoder will convert the string values to numeric values. For example, if we print the encoded weather, it will no longer contain numeric values."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "r8UkJa2QgdWN"
+      },
+      "outputs": [],
+      "source": [
+        "# import LabelEncoder\n",
+        "from sklearn import preprocessing\n",
+        "\n",
+        "# creating LabelEncoder\n",
+        "labelCode = preprocessing.LabelEncoder()\n",
+        "\n",
+        "# converting string labels into numbers.\n",
+        "label=labelCode.fit_transform(play)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SupK1QVUsV5y",
+        "outputId": "55f01cdd-d324-471f-ba33-86716cd0d99b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "array([0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1])"
+            ]
+          },
+          "execution_count": 22,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "label"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CvCfxpdVnbdx"
+      },
+      "source": [
+        "**Generating model**\n",
+        "\n",
+        "We have already seen that our input values are in a single-dimensional array. By default, the model training takes values in multi-dimensional arrays. If we feed the data without further changes, we will get the following error."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 426
+        },
+        "id": "EXIhGukIgfyt",
+        "outputId": "0e54c35d-3bff-4421-9210-c0f8c1b3ab9e"
+      },
+      "outputs": [
+        {
+          "ename": "ValueError",
+          "evalue": "ignored",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-27-0a408b19546a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# train the model using the training sets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mweather_encoded\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/naive_bayes.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m    244\u001b[0m         \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    245\u001b[0m         return self._partial_fit(\n\u001b[0;32m--> 246\u001b[0;31m             \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_refit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    247\u001b[0m         )\n\u001b[1;32m    248\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/naive_bayes.py\u001b[0m in \u001b[0;36m_partial_fit\u001b[0;34m(self, X, y, classes, _refit, sample_weight)\u001b[0m\n\u001b[1;32m    400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    401\u001b[0m         \u001b[0mfirst_call\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_partial_fit_first_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 402\u001b[0;31m         \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfirst_call\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    403\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0msample_weight\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    404\u001b[0m             \u001b[0msample_weight\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_sample_weight\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36m_validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m    579\u001b[0m                 \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_y_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    580\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 581\u001b[0;31m                 \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_X_y\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcheck_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    582\u001b[0m             \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    583\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_X_y\u001b[0;34m(X, y, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, multi_output, ensure_min_samples, ensure_min_features, y_numeric, estimator)\u001b[0m\n\u001b[1;32m    974\u001b[0m         \u001b[0mensure_min_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mensure_min_samples\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    975\u001b[0m         \u001b[0mensure_min_features\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mensure_min_features\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 976\u001b[0;31m         \u001b[0mestimator\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    977\u001b[0m     )\n\u001b[1;32m    978\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator)\u001b[0m\n\u001b[1;32m    771\u001b[0m                     \u001b[0;34m\"Reshape your data either using array.reshape(-1, 1) if \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    772\u001b[0m                     \u001b[0;34m\"your data has a single feature or array.reshape(1, -1) \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 773\u001b[0;31m                     \u001b[0;34m\"if it contains a single sample.\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    774\u001b[0m                 )\n\u001b[1;32m    775\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mValueError\u001b[0m: Expected 2D array, got 1D array instead:\narray=[2 2 0 1 1 1 0 2 2 1 2 0 0 1 1].\nReshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample."
+          ]
+        }
+      ],
+      "source": [
+        "# import Gaussian Naive Bayes model\n",
+        "from sklearn.naive_bayes import GaussianNB\n",
+        "\n",
+        "# create a Gaussian Classifier\n",
+        "model = GaussianNB()\n",
+        "\n",
+        "# train the model using the training sets\n",
+        "\n",
+        "model.fit(weather_encoded, label)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cYFFNSAAEPZL",
+        "outputId": "37046ed5-fa6f-4a10-9099-cd485f87d61d"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "array([2, 2, 0, 1, 1, 1, 0, 2, 2, 1, 2, 0, 0, 1, 1])"
+            ]
+          },
+          "execution_count": 26,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "weather_encoded"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Al_ML5RrnjxG"
+      },
+      "source": [
+        "So, we need to convert our data to the 2D array before feeding it to our model. Here we will use NumPy array and reshape() method to create a 2D array."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4hkxPdnmgqmV"
+      },
+      "outputs": [],
+      "source": [
+        "# importing numpy module\n",
+        "import numpy as np\n",
+        "\n",
+        "# converting 1D array to 2D\n",
+        "weather_2d = np.reshape(weather_encoded, (-1, 1))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ROYkyf75EGSL",
+        "outputId": "f8c55973-ac70-44ea-e022-c72e76d337ae"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "array([[2],\n",
+              "       [2],\n",
+              "       [0],\n",
+              "       [1],\n",
+              "       [1],\n",
+              "       [1],\n",
+              "       [0],\n",
+              "       [2],\n",
+              "       [2],\n",
+              "       [1],\n",
+              "       [2],\n",
+              "       [0],\n",
+              "       [0],\n",
+              "       [1]])"
+            ]
+          },
+          "execution_count": 36,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "weather_2d"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "oDNszamvhH_V",
+        "outputId": "86689611-f9c9-42c1-9475-19a568039f78"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "GaussianNB()"
+            ]
+          },
+          "execution_count": 60,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# import Gaussian Naive Bayes model\n",
+        "from sklearn.naive_bayes import GaussianNB\n",
+        "\n",
+        "# create a Gaussian Classifier\n",
+        "model = GaussianNB()\n",
+        "\n",
+        "# train the model using the training sets\n",
+        "model.fit(weather_2d, label)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IslWW4zhnqW9"
+      },
+      "source": [
+        "We had used the Gaussian Naive Bayes classifier to train our model. Let us predict the output by providing a testing input."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZHm6dbh6hNFS",
+        "outputId": "45dba2ea-0a29-448a-f81c-43cdcba35afe"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[1]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# predicting the odel\n",
+        "predicted= model.predict([[1]]) # 0:Overcast\n",
+        "\n",
+        "# printing predicted value\n",
+        "print(predicted)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QarFwQTAnt2V"
+      },
+      "source": [
+        "The output value 1 indicates that players will Play when there’s an Overcast weather."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JOWEHG_3n59c"
+      },
+      "source": [
+        "# Naive Bayes Classification with Multiple Labels"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Uf01TpNJn-NF"
+      },
+      "source": [
+        "For the training, we will use the built-in data set from the sklearn module named load_wine. This dataset results from a chemical analysis of wines grown in the same region in Italy but derived from three different cultivars.\n",
+        "\n",
+        "The dataset consists of 13 features (alcohol, malic_acid, ash, alcalinity_of_ash, magnesium, total_phenols, flavanoids, nonflavanoid_phenols, proanthocyanins, color_intensity, hue, od280/od315_of_diluted_wines, proline) and type of wine cultivar. This data has three types of wine Class_0, Class_1, and Class_3. We can build a model to classify the type of wine using Naive Bayes Classification."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LRoCA-OSoDvG"
+      },
+      "source": [
+        "# Loading and Exploring dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_53JwySShW67"
+      },
+      "outputs": [],
+      "source": [
+        "# import scikit-learn dataset library\n",
+        "from sklearn import datasets\n",
+        "\n",
+        "# load dataset\n",
+        "dataset = datasets.load_wine()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zX5zWs6voNp3"
+      },
+      "source": [
+        "Next, we can print the input/features and target/output variables names to ensure the desired dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2IFEbfPZhZ1w",
+        "outputId": "3bffd787-1459-4a55-bb45-7cf540b78c07"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Inputs:  ['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols', 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline']\n",
+            "Outputs:  ['class_0' 'class_1' 'class_2']\n"
+          ]
+        }
+      ],
+      "source": [
+        "# print the names of the 13 features\n",
+        "print (\"Inputs: \", dataset.feature_names)\n",
+        "\n",
+        "# print the label type of wine\n",
+        "print (\"Outputs: \", dataset.target_names)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "N8LphfJSoRNV"
+      },
+      "source": [
+        "We check the type of data (numeric/non-numeric) by printing three rows from the dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XDcx91huhfwx",
+        "outputId": "e2b85589-501d-4e3c-8b81-f99b2a5af06e"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[[1.423e+01 1.710e+00 2.430e+00 1.560e+01 1.270e+02 2.800e+00 3.060e+00\n",
+            "  2.800e-01 2.290e+00 5.640e+00 1.040e+00 3.920e+00 1.065e+03]\n",
+            " [1.320e+01 1.780e+00 2.140e+00 1.120e+01 1.000e+02 2.650e+00 2.760e+00\n",
+            "  2.600e-01 1.280e+00 4.380e+00 1.050e+00 3.400e+00 1.050e+03]\n",
+            " [1.316e+01 2.360e+00 2.670e+00 1.860e+01 1.010e+02 2.800e+00 3.240e+00\n",
+            "  3.000e-01 2.810e+00 5.680e+00 1.030e+00 3.170e+00 1.185e+03]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# print the wine data features\n",
+        "print(dataset.data[0:3])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hUYWPPUToUmG"
+      },
+      "source": [
+        "We can also check the output values to verify that it is a multi-class classification dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GHr8PqBShjVS",
+        "outputId": "aa84a472-1890-4ffe-837d-ec810d5912c1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
+            " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
+            " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
+            " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
+            " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# print the wine labels \n",
+        "print(dataset.target)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "baJqnPG7oXCW"
+      },
+      "source": [
+        "# Training the model using multiclass labels\n",
+        "\n",
+        "Before feeding the dataset to our model, let us split the dataset into training and testing parts to evaluate our model by providing the testing dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "owDZfBk-hofQ"
+      },
+      "outputs": [],
+      "source": [
+        "# import train_test_split function\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "# input and outputs\n",
+        "inputs = dataset.data\n",
+        "outputs = dataset.target\n",
+        "\n",
+        "# split dataset into training set and test set\n",
+        "X_train, X_test, y_train, y_test = train_test_split(inputs, outputs, test_size=0.3, random_state=1)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9-jVi-5khrhD"
+      },
+      "outputs": [],
+      "source": [
+        "# import Gaussian Naive Bayes model\n",
+        "from sklearn.naive_bayes import GaussianNB\n",
+        "\n",
+        "# create a Gaussian Classifier\n",
+        "classifer = GaussianNB()\n",
+        "\n",
+        "# train the model using the training sets\n",
+        "classifer.fit(X_train, y_train)\n",
+        "\n",
+        "# predict the response for test dataset\n",
+        "y_pred = classifer.predict(X_test)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bHUfAB8Nocn_"
+      },
+      "source": [
+        "Note: we have used the Gaussian Naive Bayes classification method for the training.\n",
+        "\n",
+        "Let us now check the accuracy of our model:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HjM-3pk_hvrN",
+        "outputId": "19bcc8f0-191e-49c3-de49-89cdb3359118"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Accuracy: 0.9814814814814815\n"
+          ]
+        }
+      ],
+      "source": [
+        "# import scikit-learn metrics module for accuracy calculation\n",
+        "from sklearn import metrics\n",
+        "\n",
+        "# printing accuracy\n",
+        "print(\"Accuracy:\", metrics.accuracy_score(y_test, y_pred))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "q0wz-x-EogI8"
+      },
+      "source": [
+        "**We got 98% accurate results, which is pretty high accuracy.**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iNgGKKVZomII"
+      },
+      "source": [
+        "**Evaluation of Naive Bayes Classifier for Multiclassification**\n",
+        "\n",
+        "Confusion Matrix is not only used to evaluate binary classification. It can also be useful in evaluating multiclass classification problems as well. The number of columns/rows will equal the number of output classes.\n",
+        "\n",
+        "Let’s evaluate our model, which was trained by multi-labeled data using a confusion matrix."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 265
+        },
+        "id": "MK-u8Y7NhzSe",
+        "outputId": "346cfc61-87c3-470f-8fae-0637ee87fc19"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# importing the required modules\n",
+        "import seaborn as sns\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "\n",
+        "# passing actual and predicted values\n",
+        "cm = confusion_matrix(y_test, y_pred)\n",
+        "\n",
+        "# true Write data values in each cell of the matrix\n",
+        "sns.heatmap(cm, annot=True)\n",
+        "plt.savefig('confusion.png')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rs3l2Gp_h2c0",
+        "outputId": "02d3aed2-7c83-4094-ab99-45ea9513dc0e"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       0.96      1.00      0.98        23\n",
+            "           1       1.00      0.95      0.97        19\n",
+            "           2       1.00      1.00      1.00        12\n",
+            "\n",
+            "    accuracy                           0.98        54\n",
+            "   macro avg       0.99      0.98      0.98        54\n",
+            "weighted avg       0.98      0.98      0.98        54\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Importing classification report\n",
+        "from sklearn.metrics import classification_report\n",
+        "\n",
+        "# printing the report\n",
+        "print(classification_report(y_test, y_pred))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pnCYm-1fqNTf"
+      },
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "oVNqnU9Ayl7O"
+      },
+      "outputs": [],
+      "source": [
+        "# importing the dataset\n",
+        "#Import scikit-learn dataset library\n",
+        "from sklearn import datasets\n",
+        "#Load dataset\n",
+        "cancer = datasets.load_breast_cancer()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "f33UdovIyxW5",
+        "outputId": "93f9ad67-5683-4da6-ca33-b810f447a39b"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'DESCR': '.. _breast_cancer_dataset:\\n\\nBreast cancer wisconsin (diagnostic) dataset\\n--------------------------------------------\\n\\n**Data Set Characteristics:**\\n\\n    :Number of Instances: 569\\n\\n    :Number of Attributes: 30 numeric, predictive attributes and the class\\n\\n    :Attribute Information:\\n        - radius (mean of distances from center to points on the perimeter)\\n        - texture (standard deviation of gray-scale values)\\n        - perimeter\\n        - area\\n        - smoothness (local variation in radius lengths)\\n        - compactness (perimeter^2 / area - 1.0)\\n        - concavity (severity of concave portions of the contour)\\n        - concave points (number of concave portions of the contour)\\n        - symmetry\\n        - fractal dimension (\"coastline approximation\" - 1)\\n\\n        The mean, standard error, and \"worst\" or largest (mean of the three\\n        worst/largest values) of these features were computed for each image,\\n        resulting in 30 features.  For instance, field 0 is Mean Radius, field\\n        10 is Radius SE, field 20 is Worst Radius.\\n\\n        - class:\\n                - WDBC-Malignant\\n                - WDBC-Benign\\n\\n    :Summary Statistics:\\n\\n    ===================================== ====== ======\\n                                           Min    Max\\n    ===================================== ====== ======\\n    radius (mean):                        6.981  28.11\\n    texture (mean):                       9.71   39.28\\n    perimeter (mean):                     43.79  188.5\\n    area (mean):                          143.5  2501.0\\n    smoothness (mean):                    0.053  0.163\\n    compactness (mean):                   0.019  0.345\\n    concavity (mean):                     0.0    0.427\\n    concave points (mean):                0.0    0.201\\n    symmetry (mean):                      0.106  0.304\\n    fractal dimension (mean):             0.05   0.097\\n    radius (standard error):              0.112  2.873\\n    texture (standard error):             0.36   4.885\\n    perimeter (standard error):           0.757  21.98\\n    area (standard error):                6.802  542.2\\n    smoothness (standard error):          0.002  0.031\\n    compactness (standard error):         0.002  0.135\\n    concavity (standard error):           0.0    0.396\\n    concave points (standard error):      0.0    0.053\\n    symmetry (standard error):            0.008  0.079\\n    fractal dimension (standard error):   0.001  0.03\\n    radius (worst):                       7.93   36.04\\n    texture (worst):                      12.02  49.54\\n    perimeter (worst):                    50.41  251.2\\n    area (worst):                         185.2  4254.0\\n    smoothness (worst):                   0.071  0.223\\n    compactness (worst):                  0.027  1.058\\n    concavity (worst):                    0.0    1.252\\n    concave points (worst):               0.0    0.291\\n    symmetry (worst):                     0.156  0.664\\n    fractal dimension (worst):            0.055  0.208\\n    ===================================== ====== ======\\n\\n    :Missing Attribute Values: None\\n\\n    :Class Distribution: 212 - Malignant, 357 - Benign\\n\\n    :Creator:  Dr. William H. Wolberg, W. Nick Street, Olvi L. Mangasarian\\n\\n    :Donor: Nick Street\\n\\n    :Date: November, 1995\\n\\nThis is a copy of UCI ML Breast Cancer Wisconsin (Diagnostic) datasets.\\nhttps://goo.gl/U2Uwz2\\n\\nFeatures are computed from a digitized image of a fine needle\\naspirate (FNA) of a breast mass.  They describe\\ncharacteristics of the cell nuclei present in the image.\\n\\nSeparating plane described above was obtained using\\nMultisurface Method-Tree (MSM-T) [K. P. Bennett, \"Decision Tree\\nConstruction Via Linear Programming.\" Proceedings of the 4th\\nMidwest Artificial Intelligence and Cognitive Science Society,\\npp. 97-101, 1992], a classification method which uses linear\\nprogramming to construct a decision tree.  Relevant features\\nwere selected using an exhaustive search in the space of 1-4\\nfeatures and 1-3 separating planes.\\n\\nThe actual linear program used to obtain the separating plane\\nin the 3-dimensional space is that described in:\\n[K. P. Bennett and O. L. Mangasarian: \"Robust Linear\\nProgramming Discrimination of Two Linearly Inseparable Sets\",\\nOptimization Methods and Software 1, 1992, 23-34].\\n\\nThis database is also available through the UW CS ftp server:\\n\\nftp ftp.cs.wisc.edu\\ncd math-prog/cpo-dataset/machine-learn/WDBC/\\n\\n.. topic:: References\\n\\n   - W.N. Street, W.H. Wolberg and O.L. Mangasarian. Nuclear feature extraction \\n     for breast tumor diagnosis. IS&T/SPIE 1993 International Symposium on \\n     Electronic Imaging: Science and Technology, volume 1905, pages 861-870,\\n     San Jose, CA, 1993.\\n   - O.L. Mangasarian, W.N. Street and W.H. Wolberg. Breast cancer diagnosis and \\n     prognosis via linear programming. Operations Research, 43(4), pages 570-577, \\n     July-August 1995.\\n   - W.H. Wolberg, W.N. Street, and O.L. Mangasarian. Machine learning techniques\\n     to diagnose breast cancer from fine-needle aspirates. Cancer Letters 77 (1994) \\n     163-171.',\n",
+              " 'data': array([[1.799e+01, 1.038e+01, 1.228e+02, ..., 2.654e-01, 4.601e-01,\n",
+              "         1.189e-01],\n",
+              "        [2.057e+01, 1.777e+01, 1.329e+02, ..., 1.860e-01, 2.750e-01,\n",
+              "         8.902e-02],\n",
+              "        [1.969e+01, 2.125e+01, 1.300e+02, ..., 2.430e-01, 3.613e-01,\n",
+              "         8.758e-02],\n",
+              "        ...,\n",
+              "        [1.660e+01, 2.808e+01, 1.083e+02, ..., 1.418e-01, 2.218e-01,\n",
+              "         7.820e-02],\n",
+              "        [2.060e+01, 2.933e+01, 1.401e+02, ..., 2.650e-01, 4.087e-01,\n",
+              "         1.240e-01],\n",
+              "        [7.760e+00, 2.454e+01, 4.792e+01, ..., 0.000e+00, 2.871e-01,\n",
+              "         7.039e-02]]),\n",
+              " 'data_module': 'sklearn.datasets.data',\n",
+              " 'feature_names': array(['mean radius', 'mean texture', 'mean perimeter', 'mean area',\n",
+              "        'mean smoothness', 'mean compactness', 'mean concavity',\n",
+              "        'mean concave points', 'mean symmetry', 'mean fractal dimension',\n",
+              "        'radius error', 'texture error', 'perimeter error', 'area error',\n",
+              "        'smoothness error', 'compactness error', 'concavity error',\n",
+              "        'concave points error', 'symmetry error',\n",
+              "        'fractal dimension error', 'worst radius', 'worst texture',\n",
+              "        'worst perimeter', 'worst area', 'worst smoothness',\n",
+              "        'worst compactness', 'worst concavity', 'worst concave points',\n",
+              "        'worst symmetry', 'worst fractal dimension'], dtype='<U23'),\n",
+              " 'filename': 'breast_cancer.csv',\n",
+              " 'frame': None,\n",
+              " 'target': array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,\n",
+              "        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\n",
+              "        0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0,\n",
+              "        1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0,\n",
+              "        1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n",
+              "        1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0,\n",
+              "        0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n",
+              "        1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1,\n",
+              "        1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,\n",
+              "        0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0,\n",
+              "        1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,\n",
+              "        1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+              "        0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1,\n",
+              "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n",
+              "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n",
+              "        0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,\n",
+              "        0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0,\n",
+              "        1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1,\n",
+              "        1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n",
+              "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1,\n",
+              "        1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n",
+              "        1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n",
+              "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1,\n",
+              "        1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n",
+              "        1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+              "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1]),\n",
+              " 'target_names': array(['malignant', 'benign'], dtype='<U9')}"
+            ]
+          },
+          "execution_count": 65,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "cancer\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "collapsed_sections": [],
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3.9.7 ('base')",
+      "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.7"
+    },
+    "vscode": {
+      "interpreter": {
+        "hash": "6393ee2ab78c765736cc1aef8f8d0135189184293c81195bcc4bde5dd24e1759"
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

From c8482e7f2a51315da8a8027944039b18b9b3d3e5 Mon Sep 17 00:00:00 2001
From: Srishti Chauhan <104318680+Srishtichauhan5359@users.noreply.github.com>
Date: Thu, 20 Oct 2022 00:18:10 +0530
Subject: [PATCH 2/2] Random_forest_Rprog

---
 ML Algorithms/Random_Forest/RF_model | 52 ++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 ML Algorithms/Random_Forest/RF_model

diff --git a/ML Algorithms/Random_Forest/RF_model b/ML Algorithms/Random_Forest/RF_model
new file mode 100644
index 00000000..1bfc0ec9
--- /dev/null
+++ b/ML Algorithms/Random_Forest/RF_model	
@@ -0,0 +1,52 @@
+require(caret)
+require(randomForest)
+data <- read.csv(file="data_1.csv", header=T)
+str(data)
+data$ admit <- as.factor(data$admit)
+str(data)
+set.seed(123)
+ind <- sample(1:nrow(data), round(0.70*nrow(data)))
+train <- as.data.frame(data[ind, ])
+str(train)
+var_names <- names(data)
+var_names
+formula = as.formula(paste("admit ~", paste(var_names[!var_names %in% "admit"], collapse = " + 
+")))
+rf_train_model <- randomForest(formula, data = train, ntree = 500, mtry = 2, nodesize = 5, 
+importance=T)
+print(rf_train_model)
+jpeg('var_importance.jpg')
+impVar <- round(randomForest::importance(rf_train_model), 2)
+impVar[order(impVar[,3], decreasing=TRUE),]
+varImpPlot <- varImpPlot(rf_train_model, sort = TRUE, main = "Var Impoirance", n.var=4)
+rf_train_model
+tRF<- tuneRF(x = train[,2:4], y = as.factor(train$admit), mtryStart = 1, ntreeTry = 500, stepFactor = 
+0.5, improve = 0.001, trace = TRUE, plot = TRUE, doBest = TRUE, nodesize = 5, importance = TRUE 
+)
+train$predict.class <- predict(tRF, train, type = "class", na.action = na.omit)
+train$predict.score <- predict(tRF, train, type = "prob")
+head(train)
+class(train$predict.score)
+require(ROCR)
+jpeg('RF_training_AUC.jpg')
+pred <- prediction(train$predict.score[,2], train$admit)
+perf <- performance(pred, "tpr", "fpr")
+plot( perf, colorize=TRUE, lwd=1, main="RF ROC Curve for training", print.cutoffs.at=seq(0, 1, 
+by=0.05), text.adj=c(-0.5, 0.5), text.cex=0.5)
+dev.off()
+KS <- max(attr(perf, 'y.values')[[1]]-attr(perf, 'x.values')[[1]])
+auc <- performance(pred,"auc");
+auc <- as.numeric(auc@y.values)
+require(e1071)
+conf_matrix_rf_train <- confusionMatrix(data = train$predict.class, reference=train$admit)
+conf_matrix_rf_train
+test$predict.class <- predict(tRF, test, type="class")
+test$predict.score <- predict(tRF, test, type="prob")
+conf_matrix_rf_test <- confusionMatrix(data = test$predict.class, reference=test$admit)
+conf_matrix_rf_test
+jpeg('RF_internal_test_AUC.jpg')
+pred1 <- prediction(test$predict.score[,2], test$admit)
+perf1 <- performance(pred1, "tpr", "fpr")
+plot( perf1, colorize=TRUE, lwd=1, main="RF ROC Curve for internal test", print.cutoffs.at=seq(0, 1, 
+by=0.05), text.adj=c(-0.5, 0.5), text.cex=0.5)
+dev.off()
\ No newline at end of file