predict_personality.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "big5_showcase.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KGDKHqThEeKp"
      },
      "source": [
        "## Install socialreaper version 0.3.0\r\n",
        "Most of the dependencies needed are already available in colab, when running the script locally, make sure to run \r\n",
        "```\r\n",
        "pip install -r requirements.txt\r\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H0ReyKVIEV5T",
        "outputId": "705f948f-380c-4bf1-ac02-9f90c9ce4d7b"
      },
      "source": [
        "!pip3 install socialreaper==0.3.0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting socialreaper==0.3.0\n",
            "  Downloading https://files.pythonhosted.org/packages/db/b4/c2999e4d21c3ed9112f87ef2838b7e4e338f0da28bf76fd704fffe4fefea/socialreaper-0.3.0-py3-none-any.whl\n",
            "Requirement already satisfied: requests>=2.11.1 in /usr/local/lib/python3.6/dist-packages (from socialreaper==0.3.0) (2.23.0)\n",
            "Requirement already satisfied: oauthlib>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from socialreaper==0.3.0) (3.1.0)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from socialreaper==0.3.0) (1.3.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests>=2.11.1->socialreaper==0.3.0) (3.0.4)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests>=2.11.1->socialreaper==0.3.0) (1.24.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests>=2.11.1->socialreaper==0.3.0) (2.10)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests>=2.11.1->socialreaper==0.3.0) (2020.12.5)\n",
            "Installing collected packages: socialreaper\n",
            "Successfully installed socialreaper-0.3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHKGxZlTEWow"
      },
      "source": [
        "import optparse\r\n",
        "import pickle\r\n",
        "from sklearn.feature_extraction.text import CountVectorizer\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import pandas as pd\r\n",
        "import re\r\n",
        "import numpy as np\r\n",
        "import pickle\r\n",
        "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\r\n",
        "#from data_prep import DataPrep\r\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\r\n",
        "\r\n",
        "from socialreaper import Twitter\r\n",
        "from socialreaper.tools import to_csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MFy6RTnvGS1H"
      },
      "source": [
        "## Train Classifier:\r\n",
        "Run the following cell to begin training. It requires approximately 5 minutes.\r\n",
        "\r\n",
        "In case you dont want to train, you can access pretrained models from this [Google drive link](https://drive.google.com/drive/folders/1oG_EZlshqx3leaMN41mQsZLKeYZdKocD?usp=sharing). Add the folder as shortcut to your drive and run the following code in a new cell\r\n",
        "```\r\n",
        "from google.colab import drive\r\n",
        "drive.mount('/content/drive')\r\n",
        "```\r\n",
        "Now you'll get access to google drive folders from colab.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GS2GnRBX3NIV",
        "outputId": "591b71fb-eaaa-4c23-cf45-9816aabbb489"
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "class DataPrep():\n",
        "    def __init__(self):\n",
        "        self.trait_cat_dict = {\n",
        "            'O': 'cOPN',\n",
        "            'C': 'cCON',\n",
        "            'E': 'cEXT',\n",
        "            'A': 'cAGR',\n",
        "            'N': 'cNEU',\n",
        "            'OPN': 'cOPN',\n",
        "            'CON': 'cCON',\n",
        "            'EXT': 'cEXT',\n",
        "            'AGR': 'cAGR',\n",
        "            'NEU': 'cNEU',\n",
        "            'Openness': 'cOPN',\n",
        "            'Conscientiousness': 'cCON',\n",
        "            'Extraversion': 'cEXT',\n",
        "            'Agreeableness': 'cAGR',\n",
        "            'Neuroticism': 'cNEU'\n",
        "            }\n",
        "        self.trait_score_dict = {\n",
        "            'O': 'sOPN',\n",
        "            'C': 'sCON',\n",
        "            'E': 'sEXT',\n",
        "            'A': 'sAGR',\n",
        "            'N': 'sNEU',\n",
        "            'OPN': 'sOPN',\n",
        "            'CON': 'sCON',\n",
        "            'EXT': 'sEXT',\n",
        "            'AGR': 'sAGR',\n",
        "            'NEU': 'sNEU',\n",
        "            'Openness': 'sOPN',\n",
        "            'Conscientiousness': 'sCON',\n",
        "            'Extraversion': 'sEXT',\n",
        "            'Agreeableness': 'sAGR',\n",
        "            'Neuroticism': 'sNEU'\n",
        "            }\n",
        "        self.LIWC_features = [\n",
        "            'WPS', 'Unique', 'Dic', 'Sixltr', 'Negate', 'Assent', 'Article', 'Preps', 'Number',\n",
        "            'Pronoun', 'I', 'We', 'Self', 'You', 'Other',\n",
        "            'Affect', 'Posemo', 'Posfeel', 'Optim', 'Negemo', 'Anx', 'Anger', 'Sad',\n",
        "            'Cogmech', 'Cause', 'Insight', 'Discrep', 'Inhib', 'Tentat', 'Certain',\n",
        "            'Senses', 'See', 'Hear', 'Feel',\n",
        "            'Social', 'Comm', 'Othref', 'Friends', 'Family', 'Humans',\n",
        "            'Time', 'Past', 'Present', 'Future',\n",
        "            'Space', 'Up', 'Down', 'Incl', 'Excl', 'Motion',\n",
        "            'Occup', 'School', 'Job', 'Achieve',\n",
        "            'Leisure', 'Home', 'Sports', 'TV', 'Music',\n",
        "            'Money',\n",
        "            'Metaph', 'Relig', 'Death', 'Physcal', 'Body', 'Sexual', 'Eating', 'Sleep', 'Groom',\n",
        "            'Allpct', 'Period', 'Comma', 'Colon', 'Semic', 'Qmark', 'Exclam', 'Dash', 'Quote', 'Apostro', 'Parenth', 'Otherp',\n",
        "            'Swear', 'Nonfl', 'Fillers',\n",
        "        ]\n",
        "\n",
        "    def prep_data(self, type, trait, regression=False, model_comparison=False):\n",
        "        df_status = self.prep_status_data()\n",
        "        tfidf = TfidfVectorizer(stop_words='english', strip_accents='ascii')\n",
        "        if type == 'essay':\n",
        "            if model_comparison:\n",
        "                X = tfidf.fit_transform(df_essay['TEXT'])\n",
        "            else:\n",
        "                X = df_essay['TEXT']\n",
        "\n",
        "            y_column = self.trait_cat_dict[trait]\n",
        "            y = df_essay[y_column]\n",
        "\n",
        "        elif type == 'status':\n",
        "            other_features_columns = [\n",
        "                'NETWORKSIZE',\n",
        "                'BETWEENNESS',\n",
        "                'NBETWEENNESS',\n",
        "                'DENSITY',\n",
        "                'BROKERAGE',\n",
        "                'NBROKERAGE',\n",
        "                'TRANSITIVITY'\n",
        "            ]\n",
        "            if model_comparison:\n",
        "                X = tfidf.fit_transform(df_status['STATUS'])\n",
        "                # X = np.nan_to_num(np.column_stack((result, df_status[other_features_columns])))\n",
        "            # Data to fit production model\n",
        "            else:\n",
        "                X = df_status['STATUS']\n",
        "            if regression:\n",
        "                y_column = self.trait_score_dict[trait]\n",
        "            else:\n",
        "                y_column = self.trait_cat_dict[trait]\n",
        "            y = df_status[y_column]\n",
        "        return X, y\n",
        "\n",
        "    def prep_status_data(self):\n",
        "        df = pd.read_csv('/content/e_summit/data/mypersonality_final.csv', encoding=\"ISO-8859-1\")\n",
        "        df = self.convert_traits_to_boolean(df)\n",
        "        return df\n",
        "\n",
        "    def prep_essay_data(self):\n",
        "        df_essays = pd.read_csv('data/personality-detection-my-copy/essays.csv', encoding=\"ISO-8859-1\")\n",
        "        df_mairesse = pd.read_csv('data/personality-detection-my-copy/mairesse.csv', encoding=\"ISO-8859-1\", header=None)\n",
        "        df_mairesse.columns = ['#AUTHID'] + self.LIWC_features\n",
        "        df = df_essays.merge(df_mairesse, how = 'inner', on = ['#AUTHID'])\n",
        "        # add word count (WC) column\n",
        "        df['WC'] = df['TEXT'].str.split().str.len()\n",
        "        df = self.convert_traits_to_boolean(df)\n",
        "        return df\n",
        "\n",
        "    def convert_traits_to_boolean(self, df):\n",
        "        trait_columns = ['cOPN', 'cCON', 'cEXT', 'cAGR', 'cNEU']\n",
        "        d = {'y': True, 'n': False}\n",
        "\n",
        "        for trait in trait_columns:\n",
        "            df[trait] = df[trait].map(d)\n",
        "        return df\n",
        "\n",
        "    def load_data(self, filepath):\n",
        "        return pd.read_csv(filepath, encoding=\"ISO-8859-1\")\n",
        "        \n",
        "class Model():\n",
        "    def __init__(self):\n",
        "        self.rfr = RandomForestRegressor(bootstrap=True,\n",
        "         max_features='sqrt',\n",
        "         min_samples_leaf=1,\n",
        "         min_samples_split=2,\n",
        "         n_estimators= 200)\n",
        "        self.rfc = RandomForestClassifier(max_features='sqrt', n_estimators=110)\n",
        "        self.tfidf = TfidfVectorizer(stop_words='english', strip_accents='ascii')\n",
        "\n",
        "    def fit(self, X, y, regression=True):\n",
        "        X = self.tfidf.fit_transform(X)\n",
        "        if regression:\n",
        "            self.rfr = self.rfr.fit(X, y)\n",
        "        else:\n",
        "            self.rfc = self.rfc.fit(X, y)\n",
        "\n",
        "    def predict(self, X, regression=True):\n",
        "        X = self.tfidf.transform(X)\n",
        "        if regression:\n",
        "            return self.rfr.predict(X)\n",
        "        else:\n",
        "            return self.rfc.predict(X)\n",
        "\n",
        "    def predict_proba(self, X, regression=False):\n",
        "        X = self.tfidf.transform(X)\n",
        "        if regression:\n",
        "            raise ValueError('Cannot predict probabilites of a regression!')\n",
        "        else:\n",
        "            return self.rfc.predict_proba(X)\n",
        "\n",
        "traits = ['OPN', 'CON', 'EXT', 'AGR', 'NEU']\n",
        "model = Model()\n",
        "\n",
        "for trait in traits:\n",
        "    dp = DataPrep()\n",
        "    X_regression, y_regression = dp.prep_data('status', trait, regression=True, model_comparison=False)\n",
        "    X_categorical, y_categorical = dp.prep_data('status', trait, regression=False, model_comparison=False)\n",
        "    print('Fitting trait ' + trait + ' regression model...')\n",
        "    model.fit(X_regression, y_regression, regression=True)\n",
        "    print('Done!')\n",
        "    print('Fitting trait ' + trait + ' categorical model...')\n",
        "    model.fit(X_categorical, y_categorical, regression=False)\n",
        "    print('Done!')\n",
        "    with open('/content/' + trait + '_model.pkl', 'wb') as f:\n",
        "        # Write the model to a file.\n",
        "        pickle.dump(model, f)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fitting trait OPN regression model...\n",
            "Done!\n",
            "Fitting trait OPN categorical model...\n",
            "Done!\n",
            "Fitting trait CON regression model...\n",
            "Done!\n",
            "Fitting trait CON categorical model...\n",
            "Done!\n",
            "Fitting trait EXT regression model...\n",
            "Done!\n",
            "Fitting trait EXT categorical model...\n",
            "Done!\n",
            "Fitting trait AGR regression model...\n",
            "Done!\n",
            "Fitting trait AGR categorical model...\n",
            "Done!\n",
            "Fitting trait NEU regression model...\n",
            "Done!\n",
            "Fitting trait NEU categorical model...\n",
            "Done!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZU2XkIYs-ycm"
      },
      "source": [
        "## Load the classifiers:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5x3gEshyylN"
      },
      "source": [
        "import pickle\r\n",
        "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\r\n",
        "#from data_prep import DataPrep\r\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\r\n",
        "\r\n",
        "class Model():\r\n",
        "    def __init__(self):\r\n",
        "        self.rfr = RandomForestRegressor(bootstrap=True,\r\n",
        "         max_features='sqrt',\r\n",
        "         min_samples_leaf=1,\r\n",
        "         min_samples_split=2,\r\n",
        "         n_estimators= 200)\r\n",
        "        self.rfc = RandomForestClassifier(max_features='sqrt', n_estimators=110)\r\n",
        "        self.tfidf = TfidfVectorizer(stop_words='english', strip_accents='ascii')\r\n",
        "\r\n",
        "    def fit(self, X, y, regression=True):\r\n",
        "        X = self.tfidf.fit_transform(X)\r\n",
        "        if regression:\r\n",
        "            self.rfr = self.rfr.fit(X, y)\r\n",
        "        else:\r\n",
        "            self.rfc = self.rfc.fit(X, y)\r\n",
        "\r\n",
        "    def predict(self, X, regression=True):\r\n",
        "        X = self.tfidf.transform(X)\r\n",
        "        if regression:\r\n",
        "            return self.rfr.predict(X)\r\n",
        "        else:\r\n",
        "            return self.rfc.predict(X)\r\n",
        "\r\n",
        "    def predict_proba(self, X, regression=False):\r\n",
        "        X = self.tfidf.transform(X)\r\n",
        "        if regression:\r\n",
        "            raise ValueError('Cannot predict probabilites of a regression!')\r\n",
        "        else:\r\n",
        "            return self.rfc.predict_proba(X)\r\n",
        "\r\n",
        "M = Model()\r\n",
        "models={}\r\n",
        "traits = ['OPN', 'CON', 'EXT', 'AGR', 'NEU']\r\n",
        "for trait in traits:\r\n",
        "    with open('/content/' + trait + '_model.pkl', 'rb') as f:\r\n",
        "        models[trait] = pickle.load(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WApCmIZh-5a8"
      },
      "source": [
        "## Define get_profile( ):\r\n",
        "the get_profile( ) function takes keywords/names as input and returns corresponding social media id's as a dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kr03RPrZzMBD"
      },
      "source": [
        "from googlesearch import search\r\n",
        "import re\r\n",
        "\r\n",
        "def get_profile(keyword):\r\n",
        "  print(\"getting profiles from google..\")\r\n",
        "  results = list(search(keyword, num=10))\r\n",
        "  profiles = {\r\n",
        "      'twitter': ''\r\n",
        "  }\r\n",
        "  for r in results:\r\n",
        "    if r.find('twitter') != -1 and profiles['twitter'] == '':\r\n",
        "      r = re.search(r'https://twitter.com/([^/?]+)', r).group(1)\r\n",
        "      profiles['twitter'] = r\r\n",
        "\r\n",
        "  return profiles"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kx6kpvn8_SoV"
      },
      "source": [
        "## Define get_text_from_tweets( ) :\r\n",
        "this function below takes the twitter username (string) as input, then gets rid of special characters using regex, and returns tweets corresponding to that user in form of a string. \r\n",
        "\r\n",
        "In the main script, we have saved the scraped tweets as information.txt to adhere with the problem statement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_-aHRJDzz5n"
      },
      "source": [
        "twt = Twitter(app_key=\"\", \r\n",
        "              app_secret=\"\", \r\n",
        "              oauth_token=\"\", \r\n",
        "              oauth_token_secret=\"\")\r\n",
        "    \r\n",
        "def get_text_from_tweets(user_name):\r\n",
        "    print(\"processing text from tweets..\")\r\n",
        "    tweets = twt.user(user_name, \r\n",
        "                    count=1000, \r\n",
        "                    exclude_replies=False, \r\n",
        "                    include_retweets=True)\r\n",
        "        \r\n",
        "    to_csv(list(tweets), filename=user_name+'_tweets.csv')\r\n",
        "\r\n",
        "    tweets_df = pd.read_csv(user_name+\"_tweets.csv\")\r\n",
        "    just_tweets=tweets_df[[\"text\"]]\r\n",
        "    ##remove urls \r\n",
        "    no_urls = just_tweets['text'].apply(lambda x: re.split('https:\\/\\/.*', str(x))[0])\r\n",
        "    #just_text_from_tweets.head(50)\r\n",
        "    no_urls=no_urls.to_frame()\r\n",
        "\r\n",
        "    # convert rows to a string\r\n",
        "    tweets_string = \"\"\r\n",
        "    for idx,row in no_urls.iterrows():\r\n",
        "        tweets_string += (row['text'] + '. ')\r\n",
        "\r\n",
        "    clean_text = re.sub(\"[^A-Za-z0-9. ]\",\" \",tweets_string)\r\n",
        "    clean_text = clean_text.strip()\r\n",
        "    return(clean_text)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w6IFNlQUAEF2"
      },
      "source": [
        "## Define predict_personality( )\r\n",
        "This function accepts a string as input and returns an array of floats, each corresponding to one of 5 personality traits."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NuFhpYU8z9v7"
      },
      "source": [
        "def predict(X):\r\n",
        "        X=[X]\r\n",
        "        predictions = {}\r\n",
        "        traits = ['OPN', 'CON', 'EXT', 'AGR', 'NEU']\r\n",
        "        for trait in traits:\r\n",
        "            pkl_model = models[trait]\r\n",
        "            trait_scores = pkl_model.predict(X, regression=True).reshape(1, -1)\r\n",
        "            # scaler = MinMaxScaler(feature_range=(0, 50))\r\n",
        "            # print(scaler.fit_transform(trait_scores))\r\n",
        "            # scaled_trait_scores = scaler.fit_transform(trait_scores)\r\n",
        "            predictions['pred_s'+trait] = trait_scores.flatten()[0]\r\n",
        "            # predictions['pred_s'+trait] = scaled_trait_scores.flatten()\r\n",
        "\r\n",
        "            trait_categories = pkl_model.predict(X, regression=False)\r\n",
        "            predictions['pred_c'+trait] = str(trait_categories[0])\r\n",
        "            # predictions['pred_c'+trait] = trait_categories\r\n",
        "\r\n",
        "            trait_categories_probs = pkl_model.predict_proba(X)\r\n",
        "            predictions['pred_prob_c'+trait] = trait_categories_probs[:, 1][0]\r\n",
        "            # predictions['pred_prob_c'+trait] = trait_categories_probs[:, 1]\r\n",
        "        return predictions"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0vMmBUvjAoLp"
      },
      "source": [
        "## Define display_results( ):\r\n",
        "This function plots a bar chart, representing each of the 5 OCEAN tendencies of the user."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PmU7sLWf2VzD"
      },
      "source": [
        "def display_results(predictions, user_name):\r\n",
        "    attrs = [predictions['pred_prob_cOPN'],\r\n",
        "             predictions['pred_prob_cCON'],\r\n",
        "             predictions['pred_prob_cEXT'],\r\n",
        "             predictions['pred_prob_cAGR'],\r\n",
        "             predictions['pred_prob_cNEU']]\r\n",
        "\r\n",
        "    plt.rcParams[\"figure.figsize\"] = (12, 6)\r\n",
        "    #plt.style.use('ggplot')\r\n",
        "    plt.ylim([0.0,1.0])\r\n",
        "    plt.bar(['Openness','Conscientiousness','Extraverison','Agreeableness','Neuroticism'],attrs, color =('green', 'black', 'pink', 'orange', 'yellow'), alpha=0.5)\r\n",
        "    plt.xticks(fontsize=15)\r\n",
        "    plt.xlabel(\"Attribute\", fontsize=17, labelpad=17)\r\n",
        "    plt.ylabel(\"Tendency\", fontsize=17)\r\n",
        "    plt.title(user_name+\"'s Personality Report\", fontsize=17)\r\n",
        "    plt.grid()\r\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RVE5llsPBHMF"
      },
      "source": [
        "##Moment of truth:\r\n",
        "Feel free to replace Elon Musk with Chetan Bhagat, Ratan Tata etc.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gnrzc3rO1KWk",
        "outputId": "b1a745d1-e0b9-45ff-9670-e090a8bc0f69"
      },
      "source": [
        "user_name = get_profile(\"Elon Musk tesla spacex\")['twitter']\r\n",
        "text = get_text_from_tweets(user_name)\r\n",
        "predictions = predict(text)\r\n",
        "#display_results(predictions=predictions, user_name=user_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "getting profiles from google..\n",
            "processing text from tweets..\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mj_krQsXVxTt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "outputId": "4e22e551-44f7-4bcc-fcf5-243dd5b30449"
      },
      "source": [
        "display_results(predictions=predictions, user_name=user_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNEKndMGgFF1"
      },
      "source": [
        "## In the website, we've used plotly instead of matplotlib."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jAIfRVHg0Wsx"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}