FakeNewsClassification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FakeNewsClassification.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ih9hQSPC6MhE",
        "outputId": "95e5cec3-0b68-461b-da83-377625c66b2b"
      },
      "source": [
        "# code by Jinshun Lin\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n_4zs1FO9s54"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv('/content/drive/MyDrive/Datasets/kaggle_fake_train.csv')"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iWAydG_1-CMt"
      },
      "source": [
        "# Exploring the dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FmZ90S_e-Hgm",
        "outputId": "638d175c-65d1-45e9-853c-02c077971992"
      },
      "source": [
        "df.shape"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(20800, 5)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1-_BAe9-MkA",
        "outputId": "11fa68f3-2407-4662-a763-c5003af3a4a1"
      },
      "source": [
        "df.columns"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['id', 'title', 'author', 'text', 'label'], dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "M45h_zGl-T2v",
        "outputId": "a478c4b2-9eac-4f66-9a82-97acac31924c"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>id</th>\n",
              "      <th>title</th>\n",
              "      <th>author</th>\n",
              "      <th>text</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>House Dem Aide: We Didn’t Even See Comey’s Let...</td>\n",
              "      <td>Darrell Lucus</td>\n",
              "      <td>House Dem Aide: We Didn’t Even See Comey’s Let...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>FLYNN: Hillary Clinton, Big Woman on Campus - ...</td>\n",
              "      <td>Daniel J. Flynn</td>\n",
              "      <td>Ever get the feeling your life circles the rou...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2</td>\n",
              "      <td>Why the Truth Might Get You Fired</td>\n",
              "      <td>Consortiumnews.com</td>\n",
              "      <td>Why the Truth Might Get You Fired October 29, ...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3</td>\n",
              "      <td>15 Civilians Killed In Single US Airstrike Hav...</td>\n",
              "      <td>Jessica Purkiss</td>\n",
              "      <td>Videos 15 Civilians Killed In Single US Airstr...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>Iranian woman jailed for fictional unpublished...</td>\n",
              "      <td>Howard Portnoy</td>\n",
              "      <td>Print \\nAn Iranian woman has been sentenced to...</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   id  ... label\n",
              "0   0  ...     1\n",
              "1   1  ...     0\n",
              "2   2  ...     1\n",
              "3   3  ...     1\n",
              "4   4  ...     1\n",
              "\n",
              "[5 rows x 5 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P4HQZoAD-b12"
      },
      "source": [
        "# Dropping the 'id' column\n",
        "df.drop('id', axis=1, inplace=True)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4bmJo5cc-p0h",
        "outputId": "63079e92-de92-4e60-81d8-6af5ad2b2449"
      },
      "source": [
        "df.columns"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['title', 'author', 'text', 'label'], dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ezXeXOWn-wi6"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "%matplotlib inline"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "id": "5U9aTrdk-9OC",
        "outputId": "2926e285-6e10-487a-c2b0-d34dd0f1c290"
      },
      "source": [
        "# Visualizing the count of 'fake news' in the dataset\n",
        "plt.figure(figsize=(10,7))\n",
        "sns.countplot(x='label', data=df)\n",
        "plt.xlabel('News Classification')\n",
        "plt.ylabel('Count')"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Count')"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Ap0r2on_krE"
      },
      "source": [
        "# Data cleaning and preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NNMDwKvC_qE6",
        "outputId": "9ac369db-d264-46eb-d716-b500fdf2bcec"
      },
      "source": [
        "print(df.shape)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(20800, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qaj2HLVS_t_r",
        "outputId": "b7ebffc9-1fe4-4717-c9e5-9ceafb7431b1"
      },
      "source": [
        "# Finding any NaN values\n",
        "df.isna().any()"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "title      True\n",
              "author     True\n",
              "text       True\n",
              "label     False\n",
              "dtype: bool"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DhFFenAh_4GX",
        "outputId": "05ede2c4-6f46-4881-9d6b-21bbba796686"
      },
      "source": [
        "# dropping NaN values\n",
        "df.dropna(inplace=True)\n",
        "print(df.shape)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(18285, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yR9ah146AIjp"
      },
      "source": [
        "news = df.copy()"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y5-OJiG5ANTj"
      },
      "source": [
        "news.reset_index(inplace=True)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uiHmN4ZRAVW-",
        "outputId": "b7592cd7-72fa-4d3d-8b98-840a885b437e"
      },
      "source": [
        "import nltk\n",
        "import re\n",
        "nltk.download('stopwords')\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.stem import PorterStemmer"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/stopwords.zip.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DZNLaUz7AplV"
      },
      "source": [
        "# cleaning the news\n",
        "corpus = []\n",
        "ps = PorterStemmer()\n",
        "for i in range(0,news.shape[0]):\n",
        "    # cleaninggg special character from the news title\n",
        "    title = re.sub(pattern='[^a-zA-Z]',repl=' ', string=news.title[i])\n",
        "\n",
        "    # converting the entire news title to lower case\n",
        "    title = title.lower()\n",
        "\n",
        "    #tokenizinggg the news title by words\n",
        "    words = title.split()\n",
        "\n",
        "    #removing the stopwords\n",
        "    words = [word for word in words if word not in set(stopwords.words('english'))]\n",
        "\n",
        "    # stemming the words\n",
        "    words = [ps.stem(word) for word in words]\n",
        "\n",
        "    # joining the stemmed words\n",
        "    title = ' '.join(words)\n",
        "\n",
        "    # building a corpus of news title\n",
        "    corpus.append(title)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_5MOwP8CNRS",
        "outputId": "390ef6db-d8ed-4e18-851b-b3a6bffd43a9"
      },
      "source": [
        "corpus[:10]"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['hous dem aid even see comey letter jason chaffetz tweet',\n",
              " 'flynn hillari clinton big woman campu breitbart',\n",
              " 'truth might get fire',\n",
              " 'civilian kill singl us airstrik identifi',\n",
              " 'iranian woman jail fiction unpublish stori woman stone death adulteri',\n",
              " 'jacki mason hollywood would love trump bomb north korea lack tran bathroom exclus video breitbart',\n",
              " 'beno hamon win french socialist parti presidenti nomin new york time',\n",
              " 'back channel plan ukrain russia courtesi trump associ new york time',\n",
              " 'obama organ action partner soro link indivis disrupt trump agenda',\n",
              " 'bbc comedi sketch real housew isi caus outrag']"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "orKT1fVFDN-N"
      },
      "source": [
        "# creatin the bag of words model\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "cv = CountVectorizer(max_features=5000,ngram_range=(1,3))\n",
        "X = cv.fit_transform(corpus).toarray()"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PEX0yFbiEdG5",
        "outputId": "1a18e4c2-a386-4c95-abc0-d19a36dc103a"
      },
      "source": [
        "X.shape\n",
        "X[0:10]"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0, ..., 0, 0, 0],\n",
              "       [0, 0, 0, ..., 0, 0, 0],\n",
              "       [0, 0, 0, ..., 0, 0, 0],\n",
              "       ...,\n",
              "       [0, 0, 0, ..., 0, 0, 0],\n",
              "       [0, 0, 0, ..., 0, 0, 0],\n",
              "       [0, 0, 0, ..., 0, 0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CFbxnzo2EnWE"
      },
      "source": [
        "# extracting dependent variable from the dataset\n",
        "y = news['label']\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=0)\n",
        "\n"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-t02eTUmFM98",
        "outputId": "6c84ad62-4e64-4195-ab08-0b705eb2dd70"
      },
      "source": [
        "from sklearn.naive_bayes import MultinomialNB\n",
        "nb_classifier = MultinomialNB()\n",
        "nb_classifier.fit(X_train, y_train)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB()"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mHjamqpaFjo7"
      },
      "source": [
        "nb_y_pred = nb_classifier.predict(X_test)"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2PTK_MDHFpOj",
        "outputId": "9459b08a-c014-455f-a900-76f7f58b3f7b"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
        "score1 = accuracy_score(y_test, nb_y_pred)\n",
        "score2 = precision_score(y_test,nb_y_pred)\n",
        "score3 = recall_score(y_test,nb_y_pred)\n",
        "print('====scores====')\n",
        "print('accuracy score is: {}%'.format(round(score1*100,2)))\n",
        "print('precision score is: {}'.format(round(score2,2)))\n",
        "print('recall score is: {}'.format(round(score3,2)))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "====scores====\n",
            "accuracy score is: 90.16%\n",
            "precision score is: 0.87\n",
            "recall score is: 0.91\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HCtQq_ifG0EY"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "nb_cm = confusion_matrix(y_test, nb_y_pred)"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6747NGNhHAb5",
        "outputId": "38d8cbba-6356-4579-fd0d-5b2e880b1804"
      },
      "source": [
        "nb_cm"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1823,  217],\n",
              "       [ 143, 1474]])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 458
        },
        "id": "adX6lhnfHESv",
        "outputId": "051e9ba5-72ee-44a7-d441-ddd6b9ee22f3"
      },
      "source": [
        "plt.figure(figsize=(10,7))\n",
        "sns.heatmap(data=nb_cm, annot=True, cmap='Blues', xticklabels=['Real','Fake'], yticklabels=['Real', 'Fake'])\n",
        "plt.xlabel('Predicted values')\n",
        "plt.ylabel('Actual values')\n",
        "plt.title('confusion matrix for multinomial naive bayes algorithm')\n",
        "plt.show()"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAG5CAYAAACHhJ4rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5wdVfn48c+ThBYgCSGhJSAdRESaFAF/9I5BlCZI1XxBrIgiiHQFRUUQQQNEqnQMAZEOImioIlIl9FRKCkgoSXh+f8xsuAm7m81m72Zz5/POa16ZOTN3zplbn33OmZnITCRJkhpRt3ndAEmSpHox0JEkSQ3LQEeSJDUsAx1JktSwDHQkSVLDMtCRJEkNy0CngUThjxExMSIenIv9bBERz3Zk2+aViFghIv4XEd3b8dilI+LeiHg7In5Vj/bNjYjIiFi1lfVPRsSWndikOa53dscwF234fUT8pA77fSkitu3o/XaGiDgxIi6r075b/c6IiBXL17pHPeqXWuObrrFsDmwHDMzMd9q7k8z8O7BGh7WqTiLiJeBrmXlHS9tk5ivAYu2sYjDwBtAru/gFpyLiImBUZh7XVJaZn5oXbZlX9c7ShsPmdRuqZNbvjLZ8NqXOYkansXwCeGlugpxG0gF/PX4CeKo9QY5/uaoqfK+ry8tMp3kwAcsD1wOvA28C55Tl3YDjgJeB14BLgN7luhWBBA4EXqHINvy4XHco8B4wHfgfcBJwEHDfLPUmsGo5vzPwFPA2MBo4qizfkiI70PSYTwL3AJOAJ4Ev1Ky7CPgd8JdyPw8Aq7RwzE3tPxh4FZgIHAZ8Fni83P85NduvAtxVPj9vAJcDfcp1lwIfAu+Wx/vDmv0fWj4/99aU9QD6AqOA3cp9LAaMBA5opq0XAVOBD8r9bwssBPwGGFNOvwEWqn3OgKOBccClzezzIOB+4MzyWF8APleWv1q+3gfWbH8PxV/FtY+/b9bXkiLzVNvWG8v1LwHblvMnAldTvJ/eLl/HDefgNT4X+Gu5//uBZcrjnwg8A6xXs31tvRsB/yz3OxY4B1iwufdjM8/XPcApZX1vA7cB/WrWX1M+15PL1/pTs7T51HL+aWDXmnU9KD5365fLmwD/KNv4b2DLVj63LwHHUHxuJgJ/BBYu1y0B3FTue2I5P7BctyfwyCz7OhK4oZxfCPglxft2PPB7YJFyXb9yX5OACcDfgW4ttO8sivfSW8AjwBY1604ELqtZPoDie+ZN4CezvG5z9F6n5juD1j+bH/vuqmnbNcBl5Wv9H2D18rl+rTym7ef197bT/DnN8wZUcQK6l1+oZwKLAgsDm5frDqH48V2Z4of4esofzZovi/OBRYDPAO8DnyzXH8TMP4QzLZdltYHO2KYvwvJLuumLv/ZLa4GyPccCCwJbl19Ea5TrLyq/KDei+AG5HLiyheNuav/vy2PeniI4GwYsBQwov9T+X7n9qhRdcQsB/Sl+zH5Ts78ZX8yz7P+S8nldpKasR7nN9uWX81Ll83htK6/TRZQ/luXyycCI8rH9KX4cT6l5zqYBPy/bu0gz+zuo3Obg8j1wKsWX/u/Kx2xfPreLldvfQxsCnebaOuvzQ/FD8h5FcNsdOA0YMQev8RvABuXrdhfwIsUPZdNx3N1CvRtQBBI9ytfiaeC7zR1DM8/XPcDzFD94i5TLp9esPwRYnI9+lB9r7rUDjgcur1m3C/B0OT+A4v27M8UfGduVy/1baNNLwBMUf6j0pQjCmupZEvgS0LNs1zXAsHLdQhRByidr9vUv4Evl/JnA8HKfiwM3AqeV606j+MwsUE5bANFC+/Yv29ED+D7Fe70pEDuRMtAB1qIIQjYvX/NfUgTLTa/bHL3X+fgfRzPeA2387jqR4v25Q9n2SyjeYz8uj/nrwIvz+rvbaf6c5nkDqjgBm1L81dejmXV3At+oWV6j/ALqUfNlMbBm/YPAPuX8QcxZoPMK8H8UY1Bqt5nxpVV+qY6j5i9I4ArgxHL+IuCCmnU7A8+0cNxN7R9QU/YmsHfN8nXU/BDO8vjdgX/VLLf0ZbpyM2U9asp+S/EX42hgyVZep4uYOdB5Hti5ZnkHiq7CpufsA8oflRb2dxDwXM3yp8u2LT3L87FuOX8PHRvo3FGzbi3g3Tl4jc+vWfctykCh5jgmtfS6zNKm7wJ/bu4Ymtn2HuC4muVvALe0sG2fcl+9a9rcFICsShG49SyXLweOL+ePZpbsG3ArNZm1Zp7Tw2Z5vz/fwrbrAhNrls8DflrOf4oi67MQEMA71GRCKb4jXiznTwZuaOl5am0q6/hMzXugKdA5HriiZrueFO/fpvfLHL3XaXug09J314nA7TXrdqMIxLqXy4uXj+8zp8+Bk5NjdOaN5YGXM3NaM+uWo0gnN3mZIshZuqZsXM38FNo/2PZLFF/UL0fE3yJi0xba82pmfjhLmwbMRXvG18y/28zyYjDjrKcrI2J0RLxFkdbuN5t9Q5Hmbs0QYG3gosx8sw37a9Lca7NczfLrmfnebPYx67GSmc0efx3M+jotXI6vaMtr3KbXbFYRsXpE3BQR48rX8Ge07TVsqc1N743uEXF6RDxf7velcpuP7TszR1JkknaLiJ7AF4A/las/AewZEZOaJoosx7KttKn2/TXjPRARPSPiDxHxctmme4E+NWf8XQx8JSIC+CpwdWa+T5Ex6Qk8UtOGW8pygDMoMm63RcQLEfGjlhoWEUdFxNMRMbncT+/mnpOyzTOOIzOnUATZtevn9r3enNa+K2Z9T72RmdNrlqF+nw01MAOdeeNVYIUWBvGNofjybbICRZp4fDPbzs47FF+gAETEMrUrM/OhzBxEkZ4eRjGGo7n2LB8Rte+VFSiyIfX2M4q/4j6dmb0o0vJRsz5beFxL5ZQ/OkMoUuPfmMNTm5t7bca0pd52mun1oxgX05K5qbuer/F5FGN4Vitfw2OZ+TVsr68AgyjGTvWmyBjQyr6vAPYtH/NUGfxA8Vm8NDP71EyLZubprdS9fM187Xvg+xQZ2I3LY/18bZsycwRFJmSLsv2XluvfoPgh/1RNG3pn5mLl497OzO9n5soUQdqREbHNrI2KiC0oxsPsBSyRmX0oxi8195yMBQbWPHYRii6vJnP7Xu/oz4LUbgY688aDFF80p0fEohGxcERsVq67AvheRKwUEYtR/Nhf1UL2Z3b+DXwqItaNiIUp0sMARMSCEbFfRPTOzKkUgxc/bGYfD1D85fXDiFigvD7KbsCV7WjPnFqcIn09OSIGAD+YZf14irFMc+JYii/hQyj+Ur5kDq6xcwVwXET0j4h+FOn/ulyXpPQYsEeZKViVYpB1S9rzXDSp52u8OMV7638RsSZweAfss2m/71NkIXpSfE5acyXFGKjD+SibA8Xrt1tE7FBmiRaOiC0jYmCzeykcEREDI6IvxRiSq2ra9C4wqVx3QjOPvYRiQPbUzLwPoMyknQ+cGRFLAUTEgIjYoZzfNSJWLTNBkylOOGjus7o4xR9FrwM9IuJ4oFcLx3Btedyfi4gFKb4bagOiuX2vz837UepQBjrzQJmO3Y1i7MArFGcw7F2uHkrxl969FIPx3qMYE9Geev5L0b9/B/AccN8sm3wVeKlMsx8G7NfMPj4o27oTxV+e51KcpfRMe9o0h04C1qf4cv8LxcDsWqdRfBlPioijZreziNiA4kyXA8rX4OcUQU+LXQGzOBV4mOIMsf8Aj5Zl9XImRQZgPEW3x+WtbHshsFb5XAybk0rq/BofRZG9eJvix/yq1jdvs0soulNGU5wBNaK1jTNzLMXZX5+rbUNmvkqR5TmWIkB4lSKgbu278U8UZ4C9QDGWpek98BuKgbZvlO25pZnHXkrRbTpr0HA0RffUiPLzeAcfXZdmtXL5f+UxnJuZdzez71vLOv9L8dy8RwvduJn5JMX3ypUUf3T9j+JEgPfLTeb2vT5Hn02pniLTDKMkdYayi+g1ijMcn5vX7WlSZo8nUXQxvjiv2yN1JDM6ktR5Dgce6gpBTkTsVnaLLkpxevl/+GhQt9QwvKKlJHWC8rYIQXGZhK5gEEVXWlB0U+2TpvjVgOy6kiRJDcuuK0mS1LC6bNfVIut901STNA+Muf+sed0EqbKW6Nm9I64z1WYd+Vv77r/O6dS2t5UZHUmS1LAMdCRJqqro1nHT7KqKGBoRr0XEEzVl60bEiIh4LCIejoiNyvKIiLMjYmREPB4R69c85sCIeK6cDpxdvQY6kiSpM1wE7DhL2S+AkzJzXYorcP+iLN+J4mKZqwGDKW4nQ81VxzcGNgJOiIglWqvUQEeSpKqK6LhpNjLzXmDCrMV8dKuS3nx0T7VBwCVZGEFxg9xlgR0o7nQ/ITMnArfz8eBpJl12MLIkSaqzNnQ5tXlXEYMpsi9NhmTmkNk87LvArRHxS4rky+fK8gHMfAuTUWVZS+UtMtCRJElzrQxqZhfYzOpw4HuZeV1E7EVx375tO7Jddl1JklRVndh11YID+eiGzddQjLuB4oa9y9dsN7Asa6m8RQY6kiRVVSeeddWCMcD/K+e3BpruAzccOKA8+2oTYHJmjgVuBbaPiCXKQcjbl2UtsutKkiTVXURcAWwJ9IuIURRnT30dOCsiegDv8dEYn5uBnYGRwBTgYIDMnBARpwAPldudnJmzDnCeiYGOJElV1f4upzmWmfu2sGqDZrZN4IgW9jMUGNrWeg10JEmqqg4866qravwjlCRJlWVGR5KkqurErqt5xUBHkqSqsutKkiRp/mVGR5KkqrLrSpIkNSy7riRJkuZfZnQkSaoqu64kSVLDsutKkiRp/mVGR5KkqqpARsdAR5KkqurW+GN0Gj+UkyRJlWVGR5KkqrLrSpIkNawKnF7e+KGcJEmqLDM6kiRVlV1XkiSpYdl1JUmSNP8yoyNJUlXZdSVJkhpWBbquDHQkSaqqCmR0Gv8IJUlSZZnRkSSpquy6kiRJDcuuK0mSpPmXGR1JkqrKritJktSw7LqSJEmaf5nRkSSpqiqQ0THQkSSpqiowRqfxQzlJklRZZnQkSaoqu64kSVLDsutKkiRp/mVGR5KkqqpA11XjH6EkSWpeRMdNs60qhkbEaxHxxCzl34qIZyLiyYj4RU35MRExMiKejYgdasp3LMtGRsSPZlevGR1JktQZLgLOAS5pKoiIrYBBwGcy8/2IWKosXwvYB/gUsBxwR0SsXj7sd8B2wCjgoYgYnplPtVSpgY4kSRUVnTgYOTPvjYgVZyk+HDg9M98vt3mtLB8EXFmWvxgRI4GNynUjM/MFgIi4sty2xUDHritJkioqIjpyGhwRD9dMg9vQhNWBLSLigYj4W0R8tiwfALxas92osqyl8haZ0ZEkSXMtM4cAQ+bwYT2AvsAmwGeBqyNi5Y5sl4GOJElVNe8vozMKuD4zE3gwIj4E+gGjgeVrthtYltFKebPsupIkqaI6suuqnYYBW5VtWR1YEHgDGA7sExELRcRKwGrAg8BDwGoRsVJELEgxYHl4axWY0ZEkSXUXEVcAWwL9ImIUcAIwFBhannL+AXBgmd15MiKuphhkPA04IjOnl/v5JnAr0B0YmplPtlavgY4kSRXVyWdd7dvCqv1b2P6nwE+bKb8ZuLmt9RroSJJUUZ0Z6MwrjtGRJEkNy4yOJEkVVYWMjoGOJElV1fhxjl1XkiSpcZnRkSSpouy6kiRJDasKgY5dV5IkqWGZ0ZEkqaKqkNEx0JEkqaKqEOjYdSVJkhqWGR1Jkqqq8RM6BjqSJFWVXVeSJEnzMTM6kiRVVBUyOgY6kiRVVBUCHbuuJElSwzKjI0lSVTV+QsdAR5KkqrLrSpIkaT5mRkeSpIqqQkbHQEeSpIqqQqBj15UkSWpYZnQkSaqoKmR0DHQkSaqqxo9z7LqSJEmNy4yOJEkVZdeVJElqWFUIdOy6kiRJDcuMjiRJFVWFjI6BjiRJVdX4cU59Ap2I+C2QLa3PzG/Xo15JktR2ZnTa7+E67VeSJKnN6hLoZObF9divJEnqOGZ05lJE9AeOBtYCFm4qz8yt61mv5szvT9iPnT6/Nq9PeJsN9/zZx9b3Wmxhhp56IMsvuwQ9unfnN5fcyaXDR8xVnUv06smlPz+ETyzXl5fHTGD/H17IpLffZdctP83xh+/Kh5lMm/4hPzzjWv7x2AtzVZfUVY0fN5aTfnIME958g4hg9y/txd5f+epM29xy841cetGFkEnPnovyw2OPZ7U11pyrej/44ANO+smPePbpJ+nVuw+n/vzXLLfcAB4Y8Q/OPfvXTJs6lR4LLMC3vnsUG260yVzVpa6tCoFOvU8vvxx4GlgJOAl4CXioznVqDl164wgGHfG7Ftf/316f55kXxrHx3qezw9fP4vQjv8gCPbq3ad9bbLAaQ07a/2PlRx28Hfc8+CyfHnQy9zz4LEcdvD0Adz/wLBvtfRqb7HM6h514Gece/5X2HZQ0H+jevQffPvKHXHn9TVxwyZVce9WfePH5kTNts9xyAznvgou5/JobOPjrh3HaqSe0ef9jxozm8K8d+LHy4cOuo9fivbh2+K3su9+B/O6sXwHQp08ffvmbc7n8mhs4/uTTOOm4H83dAUpdQL0DnSUz80Jgamb+LTMPAczmdDH3P/o8EyZPaXF9AostuhAAiy6yEBMnT2Ha9A8B+N4B23DfZT/gwauO4bjDdm5znbtuuQ6X3fgAAJfd+AC7bbUOAO+8+8GMbRZdZCGyxSHt0vyvX//+rPnJtQBYdNFFWXGllXnt9ddm2madddejV6/eAKy9zmd4ffz4Gev++pfhHLL/3nx17y9y+qknMH369DbV+/d77mLn3XYHYKttt+fhB0eQmayx5lr0X2opAFZeZVXef/89Pvjgg9Z2pflcRHTY1Ia6hkbEaxHxRDPrvh8RGRH9yuWIiLMjYmREPB4R69dse2BEPFdOH4/kZ1HvQGdq+f/YiNglItYD+ta5TnWw31/5N9ZcaRleuO2nPHzNsRx1xrVkJttssiarrLAUm+9/BhvvczrrfXIFNlt/lTbtc6klF2fcG28BMO6Nt1hqycVnrPvCVuvw2PXHcf3Zh3HYSZfX5ZikrmbMmNH899mnWXvtdVrc5sZh17HJZlsA8OILz3PHbbcw5I+XcelVf6Zbt+7cevNNbarr9dfGs/QyywDQo0cPFltscSZPmjTTNnffcRurr7kWCy64YDuPSPOF6MBp9i4CdvxYEyKWB7YHXqkp3glYrZwGA+eV2/YFTgA2BjYCToiIJVqrtN7X0Tk1InoD3wd+C/QCvtfSxhExmOKA6DFwS3r0+1Sdm6e22O5zn+TxZ0ex4+CzWXn5fvzlvG9y/97Ps+2mn2TbTddkxJVFenuxRRZi1RWW4v5Hn+feS45iwQV7sNgiC7FE754ztjnurBu4459Pf6yO2szN8LsfZ/jdj7PZ+qtw/Dd2YZfDzumU45TmlSlT3uGYo77Dd486hkUXW6zZbR556AGGD7ueIUMvA+DhB0fw7FNPcvD+ewHw/vvvs0Tf4u/Io4/8FmNGj2Lq1KmMHzeWr+79RQD2/spX2XXQHrNtzwvPP8fvzv41Z517fkccngRAZt4bESs2s+pM4IfADTVlg4BLMjOBERHRJyKWBbYEbs/MCQARcTtF8HRFS/XWNdDJzKY/LyYDW7Vh+yHAEIBF1vumnRZdxFe/sAm/+uPtALzw6hu8NPpN1lhxaSLgjKG3ceF193/sMZ8/4JdAMUbnq1/YmMEnXDbT+tfefJtl+vVi3BtvsUy/Xrw+4e2P7eP+R59npQH9WLLPorw56Z06HJk0702bOpVjjvouO+y0K1tts12z2zz332f52cnHc+Y5f6B3nz4AZCY77zaIb3z7yI9t//Nf/xYoskSnHH8s510w84mw/ZdamvHjxrHU0sswbdo0/ve/t2fs97Xx4zj6yG9z/CmnMXD5FTryUNUFdeRg5NpkRWlI+bve2mMGAaMz89+ztGUA8GrN8qiyrKXyFtW16yoiVo+IO5v64yJinYg4rp51quO9Om4iW260BgBL9V2c1VdcmhdHv8Ht/3iaAwdtyqKLFKnt5fr3pv8Szf81Oqu//O0/7L/bxgDsv9vG3HTP4wCsvHy/Gdusu+ZAFlqwh0GOGlZm8tOTfsKKK63MV756ULPbjBs7hmOO+jYnnHI6K3xixRnln91oE+664zYmTHgTgMmTJzF2zOg21bvF/9uKm28cBhRdVBt+dmMigrfffosjv3U43/j2kXxm3fVnsxc1go4co5OZQzJzw5ppdkFOT+BY4Ph6HmO9u67OB34A/AEgMx+PiD8Bp9a5Xs2Bi087iC02WI1+fRZj5C2ncMrvb55xVtUF197H6effwpCT9uehq48lAn581g28Oekd7hzxDGuutAz3XHwUAO+8+z4H//hiXp/4v9nW+cs/3s5lPz+EA3fflFfGTmD/Hw4F4IvbrMtXdt2YqdOm8977U/nq0UPrd+DSPPbvxx7lr38ZziqrrT6je+nwb36XcePGArDHnvtw4ZDzmDxpMmecdjJQnKl10Z+uYaVVVuX/jvgO3zn8a3yYSY8ePfjBj37Cssu1+sctALvt/iVOOu5ovvyFHejVqw+nnF5kYK+58k+MevUVhg45l6FDzgXgrPMuoG/fJetx+NIqFGdlN2VzBgKPRsRGwGhg+ZptB5Zloym6r2rL72mtksg6ntYSEQ9l5mcj4l+ZuV5Z9lhmrju7x9p1Jc0bY+4/a143QaqsJXp279QL26x61F877Ld25C93mm3byzE6N2Xm2s2sewnYMDPfiIhdgG8CO1MMPD47MzcqByM/AjSlHB8FNmgas9Ocemd03oiIVSjvexURXwbG1rlOSZLUBp15wcCIuIIiG9MvIkYBJ5SXoGnOzRRBzkhgCnAwQGZOiIhT+OiafCe3FuRA/QOdIygGF68ZEaOBF4H96lynJEnqYjJz39msX7FmPiliiOa2Gwq0eVxDvc+6egHYNiIWpRj4PAXYB3i5nvVKkqTZq8AdIOpz1lVE9IqIYyLinIjYjiLAOZAiBbVXPeqUJElzpjOvjDyv1CujcykwEfgn8HXgxxTXTfxiZj5WpzolSZJmUq9AZ+XM/DRARFxAMQB5hcx8r071SZKkOdSFEzEdpl6BTtM9rsjM6RExyiBHkqSupVu3xo906hXofCYi3irnA1ikXA6KwdS96lSvJEnSDHUJdDKzez32K0mSOo5dV5IkqWF15bOlOkpdb+opSZI0L5nRkSSpoiqQ0DHQkSSpquy6kiRJmo+Z0ZEkqaKqkNEx0JEkqaIqEOfYdSVJkhqXGR1JkirKritJktSwKhDn2HUlSZIalxkdSZIqyq4rSZLUsCoQ59h1JUmSGpcZHUmSKsquK0mS1LAqEOfYdSVJkhqXGR1JkirKritJktSwKhDn2HUlSZIalxkdSZIqyq4rSZLUsCoQ59h1JUmSGpcZHUmSKsquK0mS1LAqEOfYdSVJkhqXGR1JkirKritJktSwqhDo2HUlSZIaloGOJEkVFdFx0+zriqER8VpEPFFTdkZEPBMRj0fEnyOiT826YyJiZEQ8GxE71JTvWJaNjIgfza5eAx1JkioqIjpsaoOLgB1nKbsdWDsz1wH+CxxTtmstYB/gU+Vjzo2I7hHRHfgdsBOwFrBvuW2LDHQkSVLdZea9wIRZym7LzGnl4ghgYDk/CLgyM9/PzBeBkcBG5TQyM1/IzA+AK8ttW2SgI0lSRXVk11VEDI6Ih2umwXPYnEOAv5bzA4BXa9aNKstaKm+RZ11JklRRHXnWVWYOAYa0sx0/BqYBl3dYg0oGOpIkVVRXOLs8Ig4CdgW2ycwsi0cDy9dsNrAso5XyZtl1JUmS5omI2BH4IfCFzJxSs2o4sE9ELBQRKwGrAQ8CDwGrRcRKEbEgxYDl4a3VYUZHkqSK6taJKZ2IuALYEugXEaOAEyjOsloIuL3sRhuRmYdl5pMRcTXwFEWX1hGZOb3czzeBW4HuwNDMfLK1eg10JEmqqM7susrMfZspvrCV7X8K/LSZ8puBm9tar11XkiSpYZnRkSSpoqpwrysDHUmSKqpb48c5dl1JkqTGZUZHkqSKsutKkiQ1rArEOXZdSZKkxmVGR5KkigoaP6VjoCNJUkV51pUkSdJ8zIyOJEkV5VlXkiSpYVUgzpl911VE7BkRi5fzx0XE9RGxfv2bJkmSNHfaMkbnJ5n5dkRsDmxLcafR8+rbLEmSVG/dIjps6qraEuhML//fBRiSmX8BFqxfkyRJUmeI6Lipq2pLoDM6Iv4A7A3cHBELtfFxkiRJ81RbApa9gFuBHTJzEtAX+EFdWyVJkuouIjps6qpmG+hk5hTgNWDzsmga8Fw9GyVJkurPrisgIk4AjgaOKYsWAC6rZ6MkSZI6Qluuo/NFYD3gUYDMHNN0urkkSZp/deWzpTpKWwKdDzIzIyIBImLROrdJkiR1gsYPc9o2GPnq8qyrPhHxdeAO4Pz6NkuSJGnuzTajk5m/jIjtgLeANYDjM/P2urdMkiTVVVc+W6qjtOleV2VgY3AjSVID6db4cc7sA52IeBvIcnFBirOu3snMXvVsmCRJ0txqS9fVjDOsoshxDQI2qWejJElS/VWh62qObuWQhWHADnVqjyRJ6iRVuGBgW7qu9qhZ7AZsCLxXtxZJkiR1kLYMRt6tZn4a8BJF95UkSZqPVaHrqi1jdA7ujIZIkqTOVemzriLit3x0ttXHZOa369IiSZKkDtJaRufhTmuFJEnqdJXuusrMizuzIZIkqXM1fpjTtrOu+gNHA2sBCzeVZ+bWdWyXJEnSXGvLdXQuB54GVgJOojjr6qE6tkmSJHWCbhEdNnVVbQl0lszMC4Gpmfm3zDwEMJsjSdJ8zgsGFqaW/4+NiF2AMUDf+jVJkiSpY7Qlo3NqRPQGvg8cBVwAfK+urZIkSXUXER02taGuoRHxWkQ8UVPWNyJuj4jnyv+XKMsjIs6OiJER8XhErF/zmAPL7Z+LiANnV29bAp0HMnNyZj6RmVtl5gaZObwNj5MkSV1YJ3ddXQTsOEvZj4A7M3M14M5yGWAnYLVyGgycV7Q3+gInABsDGwEnNAVHLWlLoHN/RNwWEYfObmeSJL2bI0MAABrUSURBVEnNycx7gQmzFA8Cmi5nczGwe035JeXNxEcAfSJiWYqbit+emRMycyJwOx8PnmYy20AnM1cHjgM+BTwSETdFxP5tPC5JktRFdeRZVxExOCIerpkGt6EJS2fm2HJ+HLB0OT8AeLVmu1FlWUvlLWrLYGQy80HgwYj4GfBriqjrsrY8VpIkdU0debZUZg4BhszF4zMiWrz1VHvNNqMTEb3KgT9/Bf4BjKXoF5MkSZob48suKcr/XyvLRwPL12w3sCxrqbxFbcno/BsYBpycmf9sW7vn3sSHzumsqiTVWPmI6+d1E6TKGvOHPTq1vi5wr6vhwIHA6eX/N9SUfzMirqQYeDw5M8dGxK3Az2rGDG8PHNNaBW0JdFbOzA5PJUmSpHmrLWckdZSIuALYEugXEaMozp46Hbg6Ig4FXgb2Kje/GdgZGAlMAQ4GyMwJEXEKH92h4eTMnHWA80xmG+gY5EiSpLmVmfu2sGqbZrZN4IgW9jMUGNrWets0GFmSJDWeLtB1VXcGOpIkVVS3xo9zWg50IuK3QIvdVpn57bq0SJIkdYpKBzrAw53WCkmSpDpoMdDJzItbWidJkuZ/jtEBIqI/cDSwFrBwU3lmbl3HdkmSpDqrQtdVW06hvxx4GlgJOAl4iY/OX5ckSeqy2hLoLJmZFwJTM/NvmXkIYDZHkqT5XETHTV1VW04vn1r+PzYidgHGAH3r1yRJktQZunXlCKWDtCXQOTUiegPfB34L9AK+V9dWSZIkdYC23ALipnJ2MrBVfZsjSZI6S2fe62peactZV3+kmQsHlmN1JEnSfKoCPVdt6rq6qWZ+YeCLFON0JEmSurS2dF1dV7tc3mb9vrq1SJIkdQoHIzdvNWCpjm6IJEnqXBWIc9o0RudtZh6jM47iSsmSJEldWlu6rhbvjIZIkqTO5S0ggIi4sy1lkiRp/tItosOmrqrFjE5ELAz0BPpFxBJA01H0AgZ0QtskSZLmSmtdV/8HfBdYDniEjwKdt4Bz6twuSZJUZ104EdNhWgx0MvMs4KyI+FZm/rYT2yRJkjqBY3QKH0ZEn6aFiFgiIr5RxzZJkiR1iLYEOl/PzElNC5k5Efh6/ZokSZI6Q3Tgv66qLRcM7B4RkZkJEBHdgQXr2yxJklRvVei6akugcwtwVUT8oVz+v7JMkiSpS2tLoHM0MBg4vFy+HTi/bi2SJEmdogoZndmO0cnMDzPz95n55cz8MvAU4FlYkiTN5yKiw6auqk039YyI9YB9gb2AF4Hr69koSZKkjtDalZFXpwhu9gXeAK4CIjO36qS2SZKkOqpC11VrGZ1ngL8Du2bmSICI+F6ntEqSJNVdF+5x6jCtjdHZAxgL3B0R50fENtCFT5SXJEmaRWu3gBgGDIuIRYFBFPe9WioizgP+nJm3dVIbJUlSHXTlu453lLacdfVOZv4pM3cDBgL/ojjlXJIkzce6RcdNXVVbbgExQ2ZOzMwhmblNvRokSZLUUdp0erkkSWo8Fei5MtCRJKmqulXgHKM56rqSJElqj4j4XkQ8GRFPRMQVEbFwRKwUEQ9ExMiIuCoiFiy3XahcHlmuX7G99RroSJJUUREdN7VeTwwAvg1smJlrA92BfYCfA2dm5qrARODQ8iGHAhPL8jPL7drFQEeSpIrq5LOuegCLREQPoCfFtfq2Bq4t118M7F7ODyqXKddvE+28oZaBjiRJmmsRMTgiHq6ZBjety8zRwC+BVygCnMnAI8CkzJxWbjYKGFDODwBeLR87rdx+yfa0y8HIkiRVVEdeMDAzhwBDmlsXEUtQZGlWAiYB1wA7dljlrTDQkSSpojrx9PJtgRcz8/Wi3rge2AzoExE9yqzNQGB0uf1oYHlgVNnV1Rt4sz0V23UlSZLq7RVgk4joWY612QZ4Crgb+HK5zYHADeX88HKZcv1dmZntqdiMjiRJFdVZ97rKzAci4lrgUWAaxe2khgB/Aa6MiFPLsgvLh1wIXBoRI4EJFGdotYuBjiRJFdWZV0bOzBOAE2YpfgHYqJlt3wP27Ih67bqSJEkNy4yOJEkVVYVsh4GOJEkV1c5r8M1XqhDMSZKkijKjI0lSRTV+PsdAR5Kkyuqs08vnJbuuJElSwzKjI0lSRTV+PsdAR5KkyqpAz5VdV5IkqXGZ0ZEkqaKqcB0dAx1JkiqqCt06BjqSJFVUFTI6VQjmJElSRZnRkSSpoho/n2OgI0lSZdl1JUmSNB8zoyNJUkVVIdthoCNJUkXZdSVJkjQfM6MjSVJFNX4+x0BHkqTKqkDPlV1XkiSpcZnRkSSporpVoPPKQEeSpIqy60qSJGk+ZkZHkqSKCruuJElSo7LrSpIkaT5mRkeSpIryrCtJktSw7LqSJEmaj5nRkSSpoqqQ0THQkSSpoqpwerldV5IkqWGZ0ZEkqaK6NX5Cx4yOJElVFR34b7Z1RfSJiGsj4pmIeDoiNo2IvhFxe0Q8V/6/RLltRMTZETEyIh6PiPXbe4wGOpIkqTOcBdySmWsCnwGeBn4E3JmZqwF3lssAOwGrldNg4Lz2VmqgI0lSRUV03NR6PdEb+DxwIUBmfpCZk4BBwMXlZhcDu5fzg4BLsjAC6BMRy7bnGA10JEmqqI7suoqIwRHxcM00uKaqlYDXgT9GxL8i4oKIWBRYOjPHltuMA5Yu5wcAr9Y8flRZNsfqGuhExOoRcWdEPFEurxMRx9WzTkmS1Pkyc0hmblgzDalZ3QNYHzgvM9cD3uGjbqqmxyeQHd2uemd0zgeOAaYCZObjwD51rlOSJLVBt+i4aTZGAaMy84Fy+VqKwGd8U5dU+f9r5frRwPI1jx9Yls35MbbnQXOgZ2Y+OEvZtDrXKUmS2qCzzrrKzHHAqxGxRlm0DfAUMBw4sCw7ELihnB8OHFCefbUJMLmmi2uO1Ps6Om9ExCqUqaiI+DLQroZKkqT52reAyyNiQeAF4GCKhMvVEXEo8DKwV7ntzcDOwEhgSrltu9Q70DkCGAKsGRGjgReB/epcp+bQ8ccdw71/u4e+fZfk+htuanG7J/7zOAfstw8/P+PXbLfDjnNV5+RJk/jhUd9jzOjRLDdgAGf86jf06t2bv9w0nD9eeD6ZsOiii/Ljn5zIGmuuOVd1SV3Zrw9Yn20/vQxvvP0+W59858fWb7p6P/74jU159Y13ALj5X2M48y/PzFWdC/boxtkHb8inV+jDxHc+4LDzH2TUm1NYd8UlOGP/9WZs96ubnuGWx8bMVV3q2jrzXleZ+RiwYTOrtmlm26SIIeZavbuulsjMbYH+wJqZuTnw6TrXqTk0aPc9OO8PF7S6zfTp0/nNr3/Jpp/bbI72/dCDD/CTY3/0sfKhFwxho4035ca/3sZGG2/KhRcUY9YGDBjI0Isu47phNzL4sMM5+cSfzFF90vzmqn++zH5n/6PVbR547g22O/Uutjv1rjkKcgYu2ZNrj9ziY+X7brYik975gM1+chvn3zGS4/ZYG4BnR7/Fjj+7m+1OvYv9zv4Hv9hvXbpX4dK5FRYdOHVVdR+MHBFrZ+Y7mfl2ROwD+MvVxWyw4Wfp1bt3q9tccfmlbLvdDvTtu+RM5RcNvYCv7PUlvvzF3Tj3nLPbXOfdd9/JF3YvLpfwhd135+677gBg3fXWn9GWddZZl/Hjx83JoUjznQeee5OJUz5o12P32Hh5/vKjLbn9uK35+X7rtfly/jt8ZlmuGfEKADc9OprN1+wPwLtTpzP9w+Kkl4UW6Nbxp79I80C9A50vA5dExJoR8XWKNNT2da5THWz8+PHcdecd7LXPvjOV/+P++3jl5Ze5/Kprufq6G3jqqSd55OGH2rTPCW++Sf/+SwHQr19/Jrz55se2+fP117L5Fp+f+wOQ5nMbrNyX24/bmsu+9TlWX3ZxAFZdZnEGbTiQQb/4G9udehfTP0z22HiFNu1vmT4LM2bCuwBM/zB5692p9F10QQDWW3EJ7j5hW+46fluOvvyxGYGPGlO3iA6buqq6jtHJzBfKLM4w4BVg+8x8t6Xty4sLDQY459w/cOjXB7e0qTrRGaf/lO8eeRTdus0cF//zH/fzz3/cz95fKjIzU6ZM4eWXX2KDDT/LfvvsydQPPmDKlClMnjyZvfYYBMB3jjyKzTafOZUezVxW88EHRvDn66/lokv/VMcjk7q+/7wyiY2OvYUp709n67WXZujhm7L58bexxZr9+fQKffjrsVsBsPAC3Xnz7fcBuPCwTVihX08W6N6NAX17cvtxWwNwwV3Pc9U/Xm61vn+9NJGtTrqDVZdZnLMO2oC7nxjH+9M+rO9Bap7puuFJx6lLoBMR/2Hmi/70BboDD0QEmblOc48rLy40BOC9aWZNu4onn3yCo486EoCJEyfy97//je49epCZHPL1wey518cvjXT5ldcAxRid4cP+zCk/O32m9X2XXJLXX3+N/v2X4vXXX6Nv374z1v332Wc46YTj+N3vz6dPnyXqeGRS1/e/9z66IsddT4zntH2DvosuSARc889XOG3Ykx97zKG/HwEUY3R+c+AGfPnXf59p/bhJ77Fc30UYO+lduncLei2yABPembn7bOS4t3nn/WmsMaAXj788qQ5HJnWOenVd7QrsVjNtTNFl1bSs+chfb7uLv95eTNttvwM/Pu4Ett5mWz632eYMu/46prxTnA0yfvx43mymC6o5W261NcOHDQNg+LBhbLVVMeh+7JgxHPmdb/HT037BiiuuVJ8DkuYj/XstNGN+3RWXoFu3YMI7H/D3Z15nl/UHsOTixfo+PRdgQN9F2rTP2x4fy56bFN1cu64/gPueeR2A5ZfsOWPw8YC+i7DqMosz6o0pHXk46moqMBq5LhmdzJwpNxoRSwEL16Muzb2jjzqShx96kEmTJrLd1p/n8CO+xbRpxV+Re+29b4uP+9xmm/PiC8/z1f2KjE7Pnj352elnsOSSS7b4mCaHfG0wPzjyuwy7/lqWXW45zvjVbwD4w+9/x6TJk/jZKScB0L1Hd664+vq5PUSpyzr30M+y6Rr96bvYgjx8+k786san6NG9+Bv00ntfZNf1B3DA/1uZadM/5L2pH3L4+cU1WJ8b+za/GP4kV35nMyKCadM/5NgrHmP0hBZHB8xwxX0vcfYhG3L/Kdsz6Z0POPyCYp8brbok39xxDaZN/5APE47902Mfy/SosczuQn+NIIpT1eu084gvAL8ClqO4rPMngKcz81Oze6xdV9K8sfIRBpbSvDLmD3t0auTxwPOTO+y3duNVenfJqKneZ12dAmwC/DczV6K4KNCIOtcpSZLaoOlckI6Yuqp6BzpTM/NNoFtEdMvMu2n+qoiSJKmTVWCITt1vATEpIhYD7qW4v8VrFLdmlyRJqru6ZHQioumqVYMobsb1PeAW4Hk860qSpK6hAimdemV0hgHrZ+Y7EXFdZn4JuLhOdUmSpHaowllX9RqjU/vMrVynOiRJklpVr4xOtjAvSZK6iK58tlRHqVeg85mIeIsis7NIOU+5nJnZq071SpKkNqpAnFO3KyN3r8d+JUmS5kS9Ty+XJEldVQVSOgY6kiRVlGddSZIkzcfM6EiSVFGedSVJkhpWBeIcAx1JkiqrApGOY3QkSVLDMqMjSVJFVeGsKwMdSZIqqgqDke26kiRJDcuMjiRJFVWBhI6BjiRJlVWBSMeuK0mS1LDM6EiSVFGedSVJkhqWZ11JkiTNx8zoSJJUURVI6BjoSJJUWRWIdOy6kiRJDcuMjiRJFVWFs67M6EiSVFERHTe1rb7oHhH/ioibyuWVIuKBiBgZEVdFxIJl+ULl8shy/YrtPUYDHUmS1Fm+Azxds/xz4MzMXBWYCBxalh8KTCzLzyy3axcDHUmSKio6cJptXREDgV2AC8rlALYGri03uRjYvZwfVC5Trt+m3H6OGehIklRVHRjpRMTgiHi4Zho8S22/AX4IfFguLwlMysxp5fIoYEA5PwB4FaBcP7ncfo45GFmSJM21zBwCDGluXUTsCryWmY9ExJad2S4DHUmSKqoTz7raDPhCROwMLAz0As4C+kREjzJrMxAYXW4/GlgeGBURPYDewJvtqdiuK0mSKqqzzrrKzGMyc2BmrgjsA9yVmfsBdwNfLjc7ELihnB9eLlOuvyszsz3HaKAjSZLmlaOBIyNiJMUYnAvL8guBJcvyI4EftbcCu64kSaqoeXG5wMy8B7innH8B2KiZbd4D9uyI+gx0JEmqqsa/MLJdV5IkqXGZ0ZEkqaKqcK8rAx1Jkiqqfdcanr/YdSVJkhqWGR1JkiqqAgkdAx1JkiqrApGOXVeSJKlhmdGRJKmiPOtKkiQ1LM+6kiRJmo+Z0ZEkqaIqkNAx0JEkqarsupIkSZqPmdGRJKmyGj+lY6AjSVJF2XUlSZI0HzOjI0lSRVUgoWOgI0lSVdl1JUmSNB8zoyNJUkV5rytJktS4Gj/OsetKkiQ1LjM6kiRVVAUSOgY6kiRVlWddSZIkzcfM6EiSVFGedSVJkhpX48c5dl1JkqTGZUZHkqSKqkBCx0BHkqSqqsJZVwY6kiRVVBUGIztGR5IkNSwzOpIkVVQVuq7M6EiSpIZloCNJkhqWgY4kSRUV0XFT6/XE8hFxd0Q8FRFPRsR3yvK+EXF7RDxX/r9EWR4RcXZEjIyIxyNi/fYeo4GOJEkVFR34bzamAd/PzLWATYAjImIt4EfAnZm5GnBnuQywE7BaOQ0GzmvvMRroSJKkusrMsZn5aDn/NvA0MAAYBFxcbnYxsHs5Pwi4JAsjgD4RsWx76jbQkSSpojqy6yoiBkfEwzXT4ObrjBWB9YAHgKUzc2y5ahywdDk/AHi15mGjyrI55unlkiRVVEeeXZ6ZQ4AhrdYXsRhwHfDdzHwragb3ZGZGRHZgkwAzOpIkqRNExAIUQc7lmXl9WTy+qUuq/P+1snw0sHzNwweWZXPMQEeSpKqKDpxaq6ZI3VwIPJ2Zv65ZNRw4sJw/ELihpvyA8uyrTYDJNV1cc8SuK0mSKqoT73W1GfBV4D8R8VhZdixwOnB1RBwKvAzsVa67GdgZGAlMAQ5ub8UGOpIkqa4y8z5azvts08z2CRzREXUb6EiSVFFVuNeVgY4kSRVVgTjHwciSJKlxmdGRJKmqKpDSMdCRJKmiOvGsq3nGritJktSwzOhIklRRVTjrKopT1aWOFRGDy/ueSOpEfvakmdl1pXpp9q61kurOz55Uw0BHkiQ1LAMdSZLUsAx0VC+OEZDmDT97Ug0HI0uSpIZlRkeSJDUsAx1JktSwDHQ0RyJiekQ8FhFPRMSNEdGnnfs5KCLO6ej2SY2q5rPXNK3YwnYrRsQTnds6qesy0NGcejcz183MtYEJwBHzukFSRTR99pqml+Z1g6T5gYGO5sY/gQEAEbFKRNwSEY9ExN8jYs2yfLeIeCAi/hURd0TE0vO0xVKDiIjFIuLOiHg0Iv4TEYOa2Wbl8rP32ZY+o1Kj815XapeI6A5sA1xYFg0BDsvM5yJiY+BcYGvgPmCTzMyI+BrwQ+D786LN0nxukYh4rJx/EdgT+GJmvhUR/YARETG8aeOIWAO4EjgoM/8dEXfS/GdUamgGOppTTV+2A4CngdsjYjHgc8A18dEd4hYq/x8IXBURywILUnxBS5pz72bmuk0LEbEA8LOI+DzwIcVnsilj2h+4AdgjM5+azWdUamgGOppT72bmuhHRE7iVYozORcCk2i/hGr8Ffp2ZwyNiS+DEzmqo1OD2owhoNsjMqRHxErBwuW4y8AqwOfAUxTCFlj6jUkNzjI7aJTOnAN+m6IaaArwYEXsCROEz5aa9gdHl/IGd3lCpcfUGXiuDnK2AT9Ss+wD4InBARHwlM9+i5c+o1NAMdNRumfkv4HFgX4q/Lg+NiH8DTwJNAyNPpEiXPwK8MS/aKTWoy4ENI+I/wAHAM7UrM/MdYFfgexHxBVr+jEoNzVtASJKkhmVGR5IkNSwDHUmS1LAMdCRJUsMy0JEkSQ3LQEeSJDUsAx2pk81yB/hryosvtndfF0XEl8v5CyJirVa23TIiPteOOl4qbzEwVzpqP5I0Jwx0pM5Xewf4D4DDaldGRLuuWJ6ZX8vMp1rZZEuK2wBIUmUY6Ejz1t+BVctsy9/LmzI+FRHdI+KMiHgoIh6PiP+DGVe0PScino2IO4ClmnYUEfdExIbl/I7lXa3/Xd7hekWKgOp7ZTZpi4joHxHXlXU8FBGblY9dMiJui4gnI+ICIJhFRBwWEWfULB8UEeeU88PKO2Q/GRGDm3nsihHxRM3yURFxYjnf7B22I2LPMgP274i4dy6fc0kV4r2upHmkzNzsBNxSFq0PrJ2ZL5YBwuTM/GxELATcHxG3AesBawBrUdzA8Slg6Cz77Q+cD3y+3FffzJwQEb8H/peZvyy3+xNwZmbeFxErUNy77JPACcB9mXlyROwCHNpM868D/gn8oFzeG/hpOX9IWd8iwEMRcV1mvtnGp2UIzd9h+3hgh8wcHRF92rgvSTLQkeaBpjvAQ5HRuZCiS+nBzGy6u/v2wDpN428o7mu0GvB54IrMnA6MiYi7mtn/JsC9TfvKzAkttGNbYK2au1n3Ku9y/Xlgj/Kxf4mIibM+MDNfj4gXImIT4DlgTeD+cvW3I+KL5fzyZbtnG+jM5g7b9wMXRcTVwPWz25ckNTHQkTrfu7PeRbr8YX+ntgj4VmbeOst2O3dgO7oBm2Tme820pS2uBPaiuMfSnzMzyzvUbwtsmplTIuIePrqjdpNpzNxt3rS+xTtsZ+ZhZYZnF+CRiNhgDrJEkirMMTpS13QrcHhELAAQEatHxKLAvcDe5RieZYGtmnnsCODzEbFS+di+ZfnbwOI1290GfKtpISKaAox7ga+UZTsBS7TQxj9T3BhyX4qgB4rM08QyyFmTIrs0q/HAUuVYoIUobjxJa3fYjohVMvOBzDweeJ0iUyRJs2WgI3VNF1CMv3m0HLj7B4oM7J8puoqeAi6hGCczk8x8HRgMXF/eqfqqctWNwBebBiMD36a4+/XjEfEUH539dRJFoPQkRRfWK801MDMnAk8Dn8jMB8viW4AeEfE0cDpF0DXr46YCJwMPArcz8123W7rD9hkR8Z/yufgH8O/mnzZJmpl3L5ckSQ3LjI4kSWpYBjqSJKlhGehIkqSGZaAjSZIaloGOJElqWAY6kiSpYRnoSJKkhvX/Aexu5QUlsI4DAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P1iqCPRThVtD",
        "outputId": "b5a9aa47-5ca3-4cef-af05-9a0d27532e2a"
      },
      "source": [
        "# Hyperparameter tuning the Naive Bayes Classifier\n",
        "best_accuracy = 0.0\n",
        "alpha_val = 0.0\n",
        "for i in np.arange(0.1, 1.1,0.1):\n",
        "    temp_classifier = MultinomialNB(alpha=i)\n",
        "    temp_classifier.fit(X_train, y_train)\n",
        "    temp_y_pred = temp_classifier.predict(X_test)\n",
        "    score = accuracy_score(y_test, temp_y_pred)\n",
        "    print(\"Accuracy score for alpha={} is: {}%\".format(round(i,1), round(score*100,2)))\n",
        "    if score > best_accuracy:\n",
        "        best_accuracy = score\n",
        "        alpha_val = i\n",
        "print(\"===========================\")\n",
        "print(\"The best accuracy is {}% with alpha value as {}\".format(round(best_accuracy*100,2),round(alpha_val,1)))"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy score for alpha=0.1 is: 90.51%\n",
            "Accuracy score for alpha=0.2 is: 90.51%\n",
            "Accuracy score for alpha=0.3 is: 90.59%\n",
            "Accuracy score for alpha=0.4 is: 90.51%\n",
            "Accuracy score for alpha=0.5 is: 90.43%\n",
            "Accuracy score for alpha=0.6 is: 90.37%\n",
            "Accuracy score for alpha=0.7 is: 90.27%\n",
            "Accuracy score for alpha=0.8 is: 90.21%\n",
            "Accuracy score for alpha=0.9 is: 90.16%\n",
            "Accuracy score for alpha=1.0 is: 90.16%\n",
            "===========================\n",
            "The best accuracy is 90.59% with alpha value as 0.3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "In1sp4VLjcSB"
      },
      "source": [
        "# Logistic Regression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4EX2R4N1jiqb",
        "outputId": "a39e613f-d2dd-415f-b8dc-8d6ee549b71b"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "lr_classifier = LogisticRegression(random_state=0)\n",
        "lr_classifier.fit(X_train, y_train)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LogisticRegression(random_state=0)"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y7DJ0k3ej6db"
      },
      "source": [
        "# Predicting the Test set results\n",
        "lr_y_pred = lr_classifier.predict(X_test)"
      ],
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b_J-aLDzkEx0",
        "outputId": "00c2e042-a13a-43f7-eede-2f10d39a7c86"
      },
      "source": [
        "# Accuracy, Precision and Recall\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
        "score1 = accuracy_score(y_test, lr_y_pred)\n",
        "score2 = precision_score(y_test, lr_y_pred)\n",
        "score3 = recall_score(y_test, lr_y_pred)\n",
        "print(\"=============================scores========================\")\n",
        "print(\"Accuracy score is: {}%\".format(round(score1*100,2)))\n",
        "print(\"Precision score is: {}\".format(round(score2,2)))\n",
        "print(\"Recall score is: {}\".format(round(score3,2)))"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=============================scores========================\n",
            "Accuracy score is: 93.52%\n",
            "Precision score is: 0.89\n",
            "Recall score is: 0.97\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vci7VckclDbz"
      },
      "source": [
        "# Making the Confusion Matrix\n",
        "from sklearn.metrics import confusion_matrix\n",
        "lr_cm = confusion_matrix(y_test, lr_y_pred)"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rPD68WkclVhD",
        "outputId": "692234b8-3914-4cc6-cb86-223a2032eae0"
      },
      "source": [
        "lr_cm"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1850,  190],\n",
              "       [  47, 1570]])"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 475
        },
        "id": "2bUmrl5OlY6o",
        "outputId": "9b1a3a4f-1c96-4832-b987-c4b5c5d2bb0a"
      },
      "source": [
        "# Plotting the confusion matrix\n",
        "plt.figure(figsize=(10, 7))\n",
        "sns.heatmap(data=nb_cm,annot=True, cmap=\"Blues\", xticklabels=['Real','Fake'],yticklabels=['Real','Fake'])\n",
        "plt.xlabel('Predicted values')\n",
        "plt.ylabel('Actual values')\n",
        "plt.title('Confusion Matrix for Logistic Regression Algorithm')"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Confusion Matrix for Logistic Regression Algorithm')"
            ]
          },
          "metadata": {},
          "execution_count": 46
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T4lNP31pmSdo",
        "outputId": "f7d0c9f5-6035-4e4b-c2b0-316bde77f646"
      },
      "source": [
        "# Hyperparameter tuning the Logistic Regression Classifier\n",
        "best_accuracy = 0.0\n",
        "c_val = 0.0\n",
        "for i in np.arange(0.1,1.1,0.1):\n",
        "    temp_classifier = LogisticRegression(C=i,random_state=0)\n",
        "    temp_classifier.fit(X_train,y_train)\n",
        "    temp_y_pred = temp_classifier.predict(X_test)\n",
        "    score = accuracy_score(y_test, temp_y_pred)\n",
        "    print(\"Accuracy score for C={} is: {}%\".format(round(i,1),round(score*100,2)))\n",
        "    if score > best_accuracy:\n",
        "        best_accuracy = score\n",
        "        c_val = i\n",
        "print(\"===============================================\")\n",
        "print('The best accuracy is {}% with C value as {}'.format(round(best_accuracy*100,2),round(c_val,1)))"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy score for C=0.1 is: 92.02%\n",
            "Accuracy score for C=0.2 is: 92.86%\n",
            "Accuracy score for C=0.3 is: 93.22%\n",
            "Accuracy score for C=0.4 is: 93.38%\n",
            "Accuracy score for C=0.5 is: 93.49%\n",
            "Accuracy score for C=0.6 is: 93.49%\n",
            "Accuracy score for C=0.7 is: 93.55%\n",
            "Accuracy score for C=0.8 is: 93.63%\n",
            "Accuracy score for C=0.9 is: 93.57%\n",
            "Accuracy score for C=1.0 is: 93.52%\n",
            "===============================================\n",
            "The best accuracy is 93.63% with C value as 0.8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HHVPre7on8Hp",
        "outputId": "641d5482-2076-41f1-a1c6-ff7cebae54ed"
      },
      "source": [
        "classifier = LogisticRegression(C=0.8,random_state=0)\n",
        "classifier.fit(X_train, y_train)"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LogisticRegression(C=0.8, random_state=0)"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y8t6zTGJoMo7"
      },
      "source": [
        "# Predictions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "idLSnag6oQ9s"
      },
      "source": [
        "def fake_news(sample_news):\n",
        "    sample_news = re.sub(pattern='[^a-zA-Z]',repl=' ', string=sample_news)\n",
        "    sample_news = sample_news.lower()\n",
        "    sample_news_words = sample_news.split()\n",
        "    sample_news_words = [w for w in sample_news_words if not w in set(stopwords.words('english'))]\n",
        "    ps = PorterStemmer()\n",
        "    final_news = [ps.stem(w) for w in sample_news_words]\n",
        "    final_news = ' '.join(final_news)\n",
        "\n",
        "    temp = cv.transform([final_news]).toarray()\n",
        "    return classifier.predict(temp)"
      ],
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyLMjwsRpPVF"
      },
      "source": [
        "df_test = pd.read_csv('/content/drive/MyDrive/Datasets/kaggle_fake_test.csv')"
      ],
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zFYSuCKnphGG",
        "outputId": "f018443f-80b6-4e63-b28e-af60e465e003"
      },
      "source": [
        "df_test.columns"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['id', 'title', 'author', 'text'], dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OJz7pesjpmw5",
        "outputId": "9142ddd2-0719-40ea-be29-1805fb802eb9"
      },
      "source": [
        "news_title = df_test['title']\n",
        "news_title.shape"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5200,)"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FKnVDqP9pvDG"
      },
      "source": [
        "from random import randint"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liEfRBiWpzPd",
        "outputId": "9336e7d7-d55f-4c1d-c7c1-8db4b13d5b99"
      },
      "source": [
        "row = randint(0,news_title.shape[0]-1)\n",
        "sample_news = news_title[row]\n",
        "print('News: {}'.format(sample_news))\n",
        "if fake_news(sample_news):\n",
        "    print('Prediction: This is a FAKE news!')\n",
        "else:\n",
        "    print('Prediction: This is a REAL news.')\n"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "News: Halt-HALT (Halt Hillary-Above-the-Law-Treatment)\n",
            "Prediction: This is a FAKE news!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5KtTGN8hqhhN",
        "outputId": "b9cf0cd5-1a68-4fd9-ce49-d8efa6e30bf4"
      },
      "source": [
        "row = randint(0, news_title.shape[0]-1)\n",
        "sample_news = news_title[row]\n",
        "print('News: {}'.format(sample_news))\n",
        "if fake_news(sample_news):\n",
        "    print('Prediction: This is a FAKE news!')\n",
        "else:\n",
        "    print('Prediction: This is a REAL news.')"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "News: If You Like the Arts, Save the N.E.A., Advocates Tell Lawmakers - The New York Times\n",
            "Prediction: This is a REAL news.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wwjOZ-yTrS3I",
        "outputId": "6f61be9c-f8aa-48f9-f6ce-79d5674e44e6"
      },
      "source": [
        "row = randint(0,news_title.shape[0]-1)\n",
        "smaple_news = news_title[row]\n",
        "print('News: {}'.format(sample_news))\n",
        "if fake_news(sample_news):\n",
        "    print('Prediction: This is a FAKE news!')\n",
        "else:\n",
        "    print('Prediction: This is a REAL news.')"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "News: If You Like the Arts, Save the N.E.A., Advocates Tell Lawmakers - The New York Times\n",
            "Prediction: This is a REAL news.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TfcIgq2rr6A_",
        "outputId": "6790c8e7-b182-4339-8628-d7b65375e2ef"
      },
      "source": [
        "row = randint(0,news_title.shape[0]-1)\n",
        "smaple_news = news_title[row]\n",
        "print('News: {}'.format(sample_news))\n",
        "if fake_news(sample_news):\n",
        "    print('Prediction: This is a FAKE news!')\n",
        "else:\n",
        "    print('Prediction: This is a REAL news.')"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "News: If You Like the Arts, Save the N.E.A., Advocates Tell Lawmakers - The New York Times\n",
            "Prediction: This is a REAL news.\n"
          ]
        }
      ]
    }
  ]
}