Predicting_PewDiePie's_daily_subscribers_using_Machine_Learning_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Predicting PewDiePie's daily subscribers using Machine Learning..ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Tanu-N-Prabhu/Python/blob/master/Predicting_PewDiePie's_daily_subscribers_using_Machine_Learning_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKiTLCkv3QAL",
        "colab_type": "text"
      },
      "source": [
        "# Predicting PewDiePie's daily subscribers using Machine Learning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hk9wZqcdcBU3",
        "colab_type": "text"
      },
      "source": [
        "## Let us understand how to predict PewDiePie's daily subscribers using Linear Regression."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDcs-uzN4ARg",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://o.aolcdn.com/images/dims?quality=85&image_uri=https%3A%2F%2Fo.aolcdn.com%2Fimages%2Fdims%3Fcrop%3D2999%252C2041%252C0%252C63%26quality%3D85%26format%3Djpg%26resize%3D1600%252C1089%26image_uri%3Dhttp%253A%252F%252Fo.aolcdn.com%252Fhss%252Fstorage%252Fmidas%252Fad4588edcab1d7fb3fcba1779e920b12%252F205651508%252Fauthormedia-personality-pewdiepie-poses-for-a-photo-at-an-book-for-picture-id494847828%26client%3Da1acac3e1b3290917d92%26signature%3D9f9196520c3836b1499e32e6aefbec05a47d1a0e&client=amp-blogside-v2&signature=cd9b8f96b7ccbf8b8546edf04924e2f3d7f95f7a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fgBXadKwcEH-",
        "colab_type": "text"
      },
      "source": [
        "[PewDiePie](https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw) is a Swedish YouTuber and has 100 million subscribers on YouTube (He is my favorite). He gains thousands of subscribers every day, so I thought of writing a tutorial about his gain in subscribers. So I wanted to show you guys a practical implementation of Machine Learning's Linear Regression Algorithm. Here we can apply linear regression to predict his daily YouTube subscribers. I will guide you guys throughout this tutorial how to do so. I will not explain the theory behind linear regression algorithms, because according to me the theory is not so important only the implementation is very important, because you need to know how and where to apply the algorithm. However, I will encourage you to go through some theory online, one of the best articles is shown below:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dn8YhN-scLMa",
        "colab_type": "text"
      },
      "source": [
        "[Linear Regression](https://towardsdatascience.com/linear-regression-using-python-b136c91bf0a2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "we8BcmN4cT4K",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "06TB7JClcRDd",
        "colab_type": "text"
      },
      "source": [
        "# Let's get started:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UXsle1AO4g9D",
        "colab_type": "text"
      },
      "source": [
        "## The Steps that we are going to follow to complete this implementation is as follows:\n",
        "\n",
        "\n",
        "1. Importing the necessary libraries.\n",
        "2. Reading the dataset from the CSV file.\n",
        "3. Splitting the dataset into independent (x) and dependent (y) variables.\n",
        "4. Dividing the complete dataset into training and testing dataset.\n",
        "5. Implement our classifier based on simple linear regression.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5QIKnypQ4yf6",
        "colab_type": "text"
      },
      "source": [
        "## 1: Importing the necessary libraries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kHO2ONivcdr7",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "1. numpy\n",
        "2. pandas \n",
        "3. sklearn.linear\n",
        "4. sklearn.model_selection"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6qIOcrutcisM",
        "colab_type": "text"
      },
      "source": [
        "**Numpy:** The reason I am using the numpy library is that in the tutorial's ending I'm rounding off some values to get more accurate results. To invoke the round method, I need to import numpy library. To read the official documentation of numpy library visit the link below:\n",
        "\n",
        "[Numpy](https://numpy.org/devdocs/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EB0sFhJMco77",
        "colab_type": "text"
      },
      "source": [
        "**Pandas:** As you know that I am using the PewDiePie's data from YouTube, I need to store them in some form of a data frame, to store the data in a data frame I am using pandas data frame, it's very easy and interesting to use pandas data frame. To read the official documentation of pandas library visit the link below:\n",
        "\n",
        "[Pandas:](https://pandas.pydata.org/pandas-docs/stable/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XRHDyYO0c0PB",
        "colab_type": "text"
      },
      "source": [
        "**Sklearn.linear:** As you know that by now I'm using Linear Regression algorithm to predict the data, I need to import the linear regression library, but you cannot directly import linear regression library, although you need to import sci-kit learn with the help of that you can access linear regression library. That is the reason I'm using sklearn.linear. To read the official documentation of the library visit the link below:\n",
        "\n",
        "[Sklearn.Linear:](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YOQieT2_c7J3",
        "colab_type": "text"
      },
      "source": [
        "**sklearn.model_selection:** If you are implementing linear regression to predict the data, it is often a good practice to divide the data into training and testing data, only then your predicted data would be a lot more accurate. To do this, you need to import model_selection library from scikit learn. To read the official documentation visit the link below:\n",
        "\n",
        "[Sklearn.model_selection:](https://scikit-learn.org/stable/tutorial/statistical_inference/model_selection.html) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yLSPsRXCdDsf",
        "colab_type": "text"
      },
      "source": [
        "A quick note to import any library in python all you have to do is just say \"import keyword\" the keyword can be any name of the library such as pandas, numpy and many more."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H7EyNMHgdFlR",
        "colab_type": "text"
      },
      "source": [
        "**Importing the required libraries for this tutorial is as shown below:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cXxoA2qYodHf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmmPmnXYdJgQ",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "isr5LvvD5CBt",
        "colab_type": "text"
      },
      "source": [
        "## 2. Reading the dataset from the CSV file.\n",
        "\n",
        "I have stored the PewDiePie's subscriber data in a CSV format in Kaggle. Kaggle is a place where people all around the world publish and store the data set. Here I have stored the data in a CSV (Comma Separated Value) format. To download the data set check the link below:\n",
        "\n",
        "[Data-set: ](https://www.kaggle.com/tanuprabhu/pewdiepies-subscribers)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t448SXOPdXiE",
        "colab_type": "text"
      },
      "source": [
        "You can download the data set by clicking the download option. To get the data into a format in python,  you have to use pandas data frame. Now before that you have to load the data into your notebook (I'm using [Google Colab](https://colab.research.google.com/notebooks/welcome.ipynb) to type all my python code), there are multiple ways to load the data into the notebook available online, but the easiest way is in [Google Colab](https://colab.research.google.com/notebooks/welcome.ipynb) at the left-hand side of the notebook, you will find a \">\"(greater than symbol). When you click that you will find a tab with three options, you just have to select Files. Then you c an easily upload your file with the help of the Upload option. No need to mount to the google drive or use any specific libraries just upload the data set and your job is done. One thing to remember in this step is that uploaded files will get deleted when this runtime is recycled. This is how I got the data set into the notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2xFG4Qu0oYcg",
        "colab_type": "code",
        "outputId": "f4e73088-6d01-4cb5-e60c-5f8ba6bebf35",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        }
      },
      "source": [
        "# Storing the data in a pandas data frame.\n",
        "\n",
        "df = pd.read_csv(\"PewDiePie.csv\")\n",
        "df.head(10)"
      ],
      "execution_count": 3,
      "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>Date</th>\n",
              "      <th>Subscribers</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>71915</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2</td>\n",
              "      <td>48270</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3</td>\n",
              "      <td>47746</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "      <td>42276</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5</td>\n",
              "      <td>36867</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>6</td>\n",
              "      <td>28722</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>7</td>\n",
              "      <td>29794</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>8</td>\n",
              "      <td>33125</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>9</td>\n",
              "      <td>27877</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>10</td>\n",
              "      <td>30675</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Date  Subscribers\n",
              "0     1        71915\n",
              "1     2        48270\n",
              "2     3        47746\n",
              "3     4        42276\n",
              "4     5        36867\n",
              "5     6        28722\n",
              "6     7        29794\n",
              "7     8        33125\n",
              "8     9        27877\n",
              "9    10        30675"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HoKlXL8fdpLG",
        "colab_type": "text"
      },
      "source": [
        "As you can see the above data set contains two columns, data, and subscribers. I know the date column seems confusing don't worry and think more about it, it's just stored the first day of the May 2019 (like May 1, May 2, and more). And the subscriber's column contains all the subscribers of PewDiePie."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8mf4WrSsdyds",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FfzJVXEg6GcA",
        "colab_type": "text"
      },
      "source": [
        "## 3. Splitting the dataset into independent (x) and dependent (y) variables.\n",
        "\n",
        "Before dividing the data set into the train and test data, you need to tell what are dependent and independent variables only then you can divide later. This can be done as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J58qvQgHohTO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = df.iloc[:, :-1]\n",
        "y = df.iloc[:, 1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2egu9Tzdu5b",
        "colab_type": "text"
      },
      "source": [
        "Here the 'x' value comprises the data and the 'y' value comprises the subscribers, and iloc is used to get the values from a data frame. The reason I have used [:,: -1] is because I needed the second last column from the data frame, and the [:1] gives me the last column of the data frame. You can print the value for confirmation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2RXVy_6edwu0",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wqXZivtF5eqI",
        "colab_type": "text"
      },
      "source": [
        "## 4. Dividing the complete dataset into training and testing dataset.\n",
        "\n",
        "To get a good prediction, divide the data into training and testing data, it is because as the name suggests you will train few data points and test few data points, and keep on doing that unless you get good results."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EqWDNBdoonpq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KV04urq5d4CM",
        "colab_type": "text"
      },
      "source": [
        "Here both the 'x' and the 'y' variables are divided into training and testing data, as seen in the above code snippet the size of the test data is 0.3 or 30% and the rest is 70% (training data), random_state is the seed used by the random number generator."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x8s8rSDod5Sv",
        "colab_type": "text"
      },
      "source": [
        "Note: Try printing the training values of both x and y, then you will understand what I'm talking about. **HINT: print(x_test)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNbahSRkd9gu",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jHlXMd-b6a-x",
        "colab_type": "text"
      },
      "source": [
        "## 5. Implement our classifier based on simple linear regression.\n",
        "\n",
        "\n",
        "This is one of the most important because this is where we apply the linear regression algorithm, to do this we have to feed the trained the tested values to the actual algorithm, by doing so we can predict the subscribers. To do this follow the below code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FEmJPJgJo__u",
        "colab_type": "code",
        "outputId": "3c26e919-d1c0-4341-cf20-376b8f7f7679",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "simplelinearRegression = LinearRegression()\n",
        "simplelinearRegression.fit(x_train, y_train)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0rktK1ceCUO",
        "colab_type": "text"
      },
      "source": [
        "Here in the above code, we are calling the Linear Regression function and then we are trying to fit the model by-passing the trained values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCg27hf7pBq4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_predict = simplelinearRegression.predict(x_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-xnQ33ZBpDK8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "predict = pd.DataFrame(y_predict)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oA0Y0xKkAPu9",
        "colab_type": "code",
        "outputId": "45981b44-58ce-4007-e10e-5db524c1ee0f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 233
        }
      },
      "source": [
        "predict.apply(np.round)"
      ],
      "execution_count": 11,
      "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>0</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>31042.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>47086.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>30098.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>40480.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>38592.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>31985.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "         0\n",
              "0  31042.0\n",
              "1  47086.0\n",
              "2  30098.0\n",
              "3  40480.0\n",
              "4  38592.0\n",
              "5  31985.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X1NAJb61eFzV",
        "colab_type": "text"
      },
      "source": [
        "And then we need to predict those values using then predict method, for this we need to pass the tested value of the 'x' variable, by doing so we get the predicted values (subscribers). And the next line of code is just conversion, this is because the y_predict is of type numpy array, so we need to convert this into a data frame only then we can apply the round function. Now the variable predict contains all the predicted subscribers as seen above:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8oRdwUnZeKpu",
        "colab_type": "text"
      },
      "source": [
        "Later I will put the data in a while loop to get it in an actual format, don't worry its just a print statement with the predicted values you will get it once you trace it back down:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mLj2mNxIeMcm",
        "colab_type": "text"
      },
      "source": [
        "This is how the predict function can predict the subscribers, the subscribers returned by the predict function is accurate. Below given is the social blade statistics, you can compare the rest."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uPDWN4J9pEn-",
        "colab_type": "code",
        "outputId": "77cdf801-bcc6-4587-d4cc-c972cbf2514b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        }
      },
      "source": [
        "i = 21\n",
        "while i <= 28:\n",
        "  print(\"Total number of increase in subscribers on May %d ==>\" %(i) , int(simplelinearRegression.predict([[i]])))\n",
        "  i= i+1\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total number of increase in subscribers on May 21 ==> 29154\n",
            "Total number of increase in subscribers on May 22 ==> 28210\n",
            "Total number of increase in subscribers on May 23 ==> 27266\n",
            "Total number of increase in subscribers on May 24 ==> 26322\n",
            "Total number of increase in subscribers on May 25 ==> 25378\n",
            "Total number of increase in subscribers on May 26 ==> 24434\n",
            "Total number of increase in subscribers on May 27 ==> 23491\n",
            "Total number of increase in subscribers on May 28 ==> 22547\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jnc5EQIQgHYf",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"http://www.freeimagehosting.net/commercial-photography/\"><img src=\"https://i.imgur.com/gGMEf5i.png\" alt=\"Commercial Photography\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wX-sCmEMeQDV",
        "colab_type": "text"
      },
      "source": [
        "As seen below when you compare the results of the predicted values with the actual subscriber from the above got by Social Blade, the results are almost same except here and there a few more or less subscriber can be found, but that's OK the machine learning cannot predict 100% accurately. Hence this is how you can use Machine Learning Algorithms to predict the daily subscribers of PewDiePie. If you have any doubt about the code, the comment section is all yours. Contact me for doubts only. Thank you guys for reading my article. Bye, start practicing the code and see you next time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PcBDl5lbeS5j",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    }
  ]
}