From 6de0bf5eca453af85e2ef9348f169d32c68447e3 Mon Sep 17 00:00:00 2001 From: Amaar Hassnain <93473921+Amaar015@users.noreply.github.com> Date: Thu, 19 Oct 2023 14:36:21 +0500 Subject: [PATCH 1/2] Add files via upload --- dsa-nltp.ipynb | 3560 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3560 insertions(+) create mode 100644 dsa-nltp.ipynb diff --git a/dsa-nltp.ipynb b/dsa-nltp.ipynb new file mode 100644 index 0000000..135a0ef --- /dev/null +++ b/dsa-nltp.ipynb @@ -0,0 +1,3560 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8n4mR7BcYauH" + }, + "source": [ + "## Analyze A/B Test Results\n", + "\n", + "This project will assure you have mastered the subjects covered in the statistics lessons. The hope is to have this project be as comprehensive of these topics as possible. Good luck!\n", + "\n", + "## Table of Contents\n", + "- [Introduction](#intro)\n", + "- [Part I - Probability](#probability)\n", + "- [Part II - A/B Test](#ab_test)\n", + "- [Part III - Regression](#regression)\n", + "- [Conclusions](#conclusions)\n", + "- [Resources](#Resources)\n", + "\n", + "\n", + "\n", + "### Introduction\n", + "\n", + "A/B tests are very commonly performed by data analysts and data scientists. It is important that you get some practice working with the difficulties of these\n", + "\n", + "For this project, you will be working to understand the results of an A/B test run by an e-commerce website. Your goal is to work through this notebook to help the company understand if they should implement the new page, keep the old page, or perhaps run the experiment longer to make their decision.\n", + "\n", + "\n", + "#### Part I - Probability\n", + "\n", + "To get started, let's import our libraries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "1V8HQWzwYauM" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "#We are setting the seed to assure you get the same answers on quizzes as we set up\n", + "random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WrxHuu-UYauO" + }, + "source": [ + "`1.` Now, read in the `ab_data.csv` data. Store it in `df`. **Use your dataframe to answer the questions in Quiz 1 of the classroom.**\n", + "\n", + "a. Read in the dataset and take a look at the top few rows here:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "mMYV7N4gYauP" + }, + "outputs": [], + "source": [ + "# read data\n", + "df = pd.read_csv('/content/sample_data/ab_data.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1Vu_k007YauP" + }, + "source": [ + "b. Use the below cell to find the number of rows in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JE7-Ych6YauQ", + "outputId": "7e3ee2cd-68e4-423a-cd14-022418dabf9a" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(15368, 5)" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ], + "source": [ + "# check rows with shape method\n", + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5D7-759vYauR", + "outputId": "35b15489-c9cc-4254-e710-58bd7264c88a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "RangeIndex: 15368 entries, 0 to 15367\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 user_id 15368 non-null int64 \n", + " 1 timestamp 15367 non-null object \n", + " 2 group 15367 non-null object \n", + " 3 landing_page 15367 non-null object \n", + " 4 converted 15367 non-null float64\n", + "dtypes: float64(1), int64(1), object(3)\n", + "memory usage: 600.4+ KB\n" + ] + } + ], + "source": [ + "# info helps to get an overview as well\n", + "df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HmsMa7C_YauS" + }, + "source": [ + "c. The number of unique users in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oNMEAcULYauS", + "outputId": "4795a9f7-b3f2-4b62-a54e-cafc35141980" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "15356" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ], + "source": [ + "# use unique method\n", + "users_unique = df.user_id.nunique()\n", + "users_unique" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "Z764kZg_YauT" + }, + "source": [ + "d. The proportion of users converted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dsOS-CdKYauT", + "outputId": "57879344-88dc-499c-9509-9e24ff48dae2" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12220993037027396" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ], + "source": [ + "# proportions of user who converted (i.e. converted = 1)\n", + "df[df.converted == 1].user_id.count()/df.shape[0]\n", + "\n", + "# alternatively\n", + "df.converted.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "ILKNr-dyYauU" + }, + "source": [ + "e. The number of times the `new_page` and `treatment` don't line up." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lRkWiyiXYauU", + "outputId": "bbebbb37-3d89-4b39-bfdd-57ef3ce9ad8d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "209" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ], + "source": [ + "# there are two dimentions to this\n", + "# 1. get the number where landing_page equals new_page but group is not treatment\n", + "# 2. get the number where landing_page not new_page but group is treatment\n", + "# adding these two will give total misalignment\n", + "df[(df.landing_page == 'new_page') & (df.group != 'treatment')].user_id.count() + df[(df.landing_page != 'new_page') & (df.group == 'treatment')].user_id.count()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a3EhDwP-YauU" + }, + "source": [ + "f. Do any of the rows have missing values?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "V4gtwW21YauV", + "outputId": "80f178e1-4c31-47ec-e175-20d5fce746e2" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "user_id 0\n", + "timestamp 1\n", + "group 1\n", + "landing_page 1\n", + "converted 1\n", + "dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ], + "source": [ + "# we find the rows with missing values with isnull\n", + "df.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JwYsN_YRYauV" + }, + "source": [ + "`2.` For the rows where **treatment** is not aligned with **new_page** or **control** is not aligned with **old_page**, we cannot be sure if this row truly received the new or old page. Use **Quiz 2** in the classroom to provide how we should handle these rows. \n", + "\n", + "a. Now use the answer to the quiz to create a new dataset that meets the specifications from the quiz. Store your new dataframe in **df2**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "Q3Xs2EOgYauV" + }, + "outputs": [], + "source": [ + "# using the same logic from e.\n", + "df2 = df.drop(df[((df.landing_page == 'new_page') & (df.group != 'treatment')) | ((df.landing_page != 'new_page') & (df.group == 'treatment'))].index)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lQKTgPigYauW", + "outputId": "659ac716-8842-4bcc-8e02-cd5abc9832a5" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0" + ] + }, + "metadata": {}, + "execution_count": 25 + } + ], + "source": [ + "# Double Check all of the correct rows were removed - this should be 0\n", + "df2[((df2['group'] == 'treatment') == (df2['landing_page'] == 'new_page')) == False].shape[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lgSEH4pwYauX" + }, + "source": [ + "`3.` Use **df2** and the cells below to answer questions for **Quiz3** in the classroom." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Z2P_NZWYauX" + }, + "source": [ + "a. How many unique **user_id**s are in **df2**?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "30_V2GcXYauX", + "outputId": "8acf40a7-9aa8-48c9-ff59-3b33c73f2177" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Int64Index: 15159 entries, 0 to 15367\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 user_id 15159 non-null int64 \n", + " 1 timestamp 15158 non-null object \n", + " 2 group 15158 non-null object \n", + " 3 landing_page 15158 non-null object \n", + " 4 converted 15158 non-null float64\n", + "dtypes: float64(1), int64(1), object(3)\n", + "memory usage: 710.6+ KB\n" + ] + } + ], + "source": [ + "# check for info\n", + "df2.info()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vGmEU5xtYauY", + "outputId": "a482d1dd-4075-4833-83a7-058d5692ce59" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "15158" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ], + "source": [ + "df2.user_id.nunique()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gRjiTvdaYauY" + }, + "source": [ + "`df.info()` shows 290585 entries but `df2.user_id.nunique()` gives 290584. Meaning there is one duplicate." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "jfFMkKszYauY" + }, + "source": [ + "b. There is one **user_id** repeated in **df2**. What is it?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aQTzWDyVYauZ", + "outputId": "fe4d156f-89e1-47bc-8989-c82a19fa2511" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "1899 773192\n", + "2893 773192\n", + "Name: user_id, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ], + "source": [ + "# here we look for duplicated user_id, but we show both of those in our result by keep=False\n", + "df2.user_id[df2.user_id.duplicated(keep=False)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fEcc5EKyYauZ" + }, + "source": [ + "c. What is the row information for the repeat **user_id**?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 112 + }, + "id": "O5ZFk72oYauZ", + "outputId": "eca40c01-44ee-4ca8-f890-4dc2a3cfff04" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " user_id timestamp group landing_page converted\n", + "1899 773192 2017-01-09 05:37:58.781806 treatment new_page 0.0\n", + "2893 773192 2017-01-14 02:55:59.590927 treatment new_page 0.0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idtimestampgrouplanding_pageconverted
18997731922017-01-09 05:37:58.781806treatmentnew_page0.0
28937731922017-01-14 02:55:59.590927treatmentnew_page0.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ], + "source": [ + "# at what index duplicated user_id is\n", + "df2[df2.user_id.duplicated(keep=False)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3kD4poKiYaua" + }, + "source": [ + "d. Remove **one** of the rows with a duplicate **user_id**, but keep your dataframe as **df2**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "05wfRzkEYaua" + }, + "outputs": [], + "source": [ + "# we can remove duplicates in multiple ways\n", + "# removing by index, removing by first or last entry as well as by unique column timestamp\n", + "df2 = df2[df2.timestamp != '2017-01-09 05:37:58.781806']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j4j6P4g0Yaua", + "outputId": "7b83a00d-35e5-44af-807a-aae4fad9b1ee" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "15158" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ], + "source": [ + "# quick sanity check\n", + "df2.user_id.nunique()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tG_5r0I-Yaua" + }, + "source": [ + "`4.` Use **df2** in the below cells to answer the quiz questions related to **Quiz 4** in the classroom.\n", + "\n", + "a. What is the probability of an individual converting regardless of the page they receive?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TtxfBlI3Yaua", + "outputId": "45d24414-1bca-4da1-8e7c-da7cd5962709" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12179191132809923" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ], + "source": [ + "df2.converted.mean()\n", + "\n", + "# alternatively\n", + "df2.describe().loc['mean'].converted" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OpJUBVmkYaub" + }, + "source": [ + "b. Given that an individual was in the `control` group, what is the probability they converted?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6JK_Bke-Yaub", + "outputId": "fc79917d-8323-4437-da1c-0692b1b30ff0" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12144463553380076" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ], + "source": [ + "# logic: query the converted column where group column value is control and take mean\n", + "df2.converted[df2.group == 'control'].mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qvGS1CdFYauc" + }, + "source": [ + "c. Given that an individual was in the `treatment` group, what is the probability they converted?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qv9bL68DYauc", + "outputId": "da9d0b09-34bd-4831-edd4-2ffadc06a4a4" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12213740458015267" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ], + "source": [ + "# same logic as above, here we do it for treatment instead of control\n", + "df2.converted[df2.group == 'treatment'].mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dIND7qmCYauc" + }, + "source": [ + "d. What is the probability that an individual received the new page?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PQxM3sJ_Yaud", + "outputId": "57cae3b5-5aeb-4e1f-8923-7052cbf62ed9" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "user_id 0.501253\n", + "timestamp 0.501253\n", + "group 0.501253\n", + "landing_page 0.501253\n", + "converted 0.501253\n", + "dtype: float64" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ], + "source": [ + "df2[df2.landing_page == 'new_page'].count()/df2.shape[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kRPis22ZYaud" + }, + "source": [ + "e. Use the results in the previous two portions of this question to suggest if you think there is evidence that one page leads to more conversions? Write your response below." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yUr3a3_qYaue" + }, + "source": [ + "\n", + "- **Given the probability that an individual received the new page is 0.50006, suggests that there is an equal chance that an individual received the old page at the same time. **\n", + "- **Besides, the probability of conversion from control group and treatment group is almost similar. Just different at 3rd decimal point.**\n", + "- **Within such circumstances we can not confidently say that one page leads to more conversions. In fact, it is quite the opposite.**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EsiGrLrbYaue" + }, + "source": [ + "\n", + "### Part II - A/B Test\n", + "\n", + "Notice that because of the time stamp associated with each event, you could technically run a hypothesis test continuously as each observation was observed. \n", + "\n", + "However, then the hard question is do you stop as soon as one page is considered significantly better than another or does it need to happen consistently for a certain amount of time? How long do you run to render a decision that neither page is better than another? \n", + "\n", + "These questions are the difficult parts associated with A/B tests in general. \n", + "\n", + "\n", + "`1.` For now, consider you need to make the decision just based on all the data provided. If you want to assume that the old page is better unless the new page proves to be definitely better at a Type I error rate of 5%, what should your null and alternative hypotheses be? You can state your hypothesis in terms of words or in terms of **$p_{old}$** and **$p_{new}$**, which are the converted rates for the old and new pages." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "njLc9B7pYauf" + }, + "source": [ + "**Null Hypothesis: ** The probability of old page better than new page is greater or equal to probability of new page." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vDrN37hzYauf" + }, + "source": [ + "**Alternative Hypothesis: ** The probability of new page being better than new page is less than that of a new page." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h6CpXxgJYauf" + }, + "source": [ + "$$ H_{0} : p_{old} - p_{new} \\geq 0$$\n", + "$$ H_{A} : p_{old} - p_{new} < 0$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_m-xObYNYaug" + }, + "source": [ + "`2.` Assume under the null hypothesis, $p_{new}$ and $p_{old}$ both have \"true\" success rates equal to the **converted** success rate regardless of page - that is $p_{new}$ and $p_{old}$ are equal. Furthermore, assume they are equal to the **converted** rate in **ab_data.csv** regardless of the page.

\n", + "\n", + "Use a sample size for each page equal to the ones in **ab_data.csv**.

\n", + "\n", + "Perform the sampling distribution for the difference in **converted** between the two pages over 10,000 iterations of calculating an estimate from the null.

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5q7fh1sEYaug" + }, + "source": [ + "a. What is the **convert rate** for $p_{new}$ under the null?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z0ZFM6dAYaug", + "outputId": "10434749-2433-416c-aa15-9a3e73dde1f4" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12179191132809923" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ], + "source": [ + "# convert rate is how many users converted (i.e. converted = 1)\n", + "p_new = df2.converted.mean()\n", + "p_new" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dI60oENXYauh" + }, + "source": [ + "b. What is the **convert rate** for $p_{old}$ under the null?

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BYO7JZzkYauh", + "outputId": "6ae071e7-581e-4524-e4e2-383fbe13c0a7" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12179191132809923" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ], + "source": [ + "p_old = df2.converted.mean() # the same!!!\n", + "p_old" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r7rLMtbNYauh" + }, + "source": [ + "c. What is $n_{new}$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gznK5NAzYaui", + "outputId": "96c5cad7-8750-4a2a-90bf-774e4ee86ef3" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "7598" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ], + "source": [ + "# number of users who got the new page (i.e. group = treatment)\n", + "n_new = df2[df2.group == 'treatment'].count()[0]\n", + "n_new" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mxl8BMYDYaui" + }, + "source": [ + "d. What is $n_{old}$?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LZGXM3R0Yaui", + "outputId": "01dd3c0f-1910-48f4-ab3c-89fa6bcf6a6a" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "7559" + ] + }, + "metadata": {}, + "execution_count": 39 + } + ], + "source": [ + "# number of users who reamined with old page (i.e. group = control)\n", + "n_old = df2[df2.group == 'control'].count()[0]\n", + "n_old" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3RHpzkCpYauj" + }, + "source": [ + "e. Simulate $n_{new}$ transactions with a convert rate of $p_{new}$ under the null. Store these $n_{new}$ 1's and 0's in **new_page_converted**." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uxB_YThJYauj" + }, + "source": [ + "**NOTE: **\n", + "> - Below few cells will see alternative method, please run both of those in two different runs. They both give different results!
\n", + "> - As a matter of fact they **should not.**
\n", + "> - The difference will be visible in the histogram and in p-value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uGHzZXpYYauj", + "outputId": "3fe79b20-67ef-45f8-bf07-0aa3cbb17b45" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12174256383258752" + ] + }, + "metadata": {}, + "execution_count": 40 + } + ], + "source": [ + "# simulating n_new transaction that have probabiliy of receiving new page, using binomial gives the outout as the number of 1's\n", + "new_page_converted = np.random.binomial(1,p_new,n_new)\n", + "new_page_converted.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "z-4YCS0QYauk", + "outputId": "a5702c11-0692-47f0-e379-399dcb63db28" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12170423795735719" + ] + }, + "metadata": {}, + "execution_count": 41 + } + ], + "source": [ + "# alternatively\n", + "new_converted_simulation = np.random.binomial(n_new, p_new, 10000)/n_new\n", + "new_converted_simulation.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Enp4o6foYaul" + }, + "source": [ + "f. Simulate $n_{old}$ transactions with a convert rate of $p_{old}$ under the null. Store these $n_{old}$ 1's and 0's in **old_page_converted**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "V6mfWZDgYaul", + "outputId": "b6feee5b-739b-4356-b63a-21df17615194" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12184151342770208" + ] + }, + "metadata": {}, + "execution_count": 42 + } + ], + "source": [ + "# simulating n_new transaction that have probabiliy of having old page, using binomial gives the outout as the number of 1's\n", + "old_page_converted = np.random.binomial(1,p_old,n_old)\n", + "old_page_converted.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "m7ZvkQU1Yaul", + "outputId": "7a009140-fe54-4499-f64a-a7d0d9285298" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.12179538298716762" + ] + }, + "metadata": {}, + "execution_count": 43 + } + ], + "source": [ + "# alternatively\n", + "old_converted_simulation = np.random.binomial(n_old, p_old, 10000)/n_old\n", + "old_converted_simulation.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v8VbVx_uYaum" + }, + "source": [ + "g. Find $p_{new}$ - $p_{old}$ for your simulated values from part (e) and (f)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "busy9JeEYaum", + "outputId": "084f1e7e-27cb-42f9-ed0e-3b5c253cb215" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-9.894959511455581e-05" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ], + "source": [ + "# probabilty of new and old page based upon simulated values in e. and f.\n", + "p_new = new_page_converted.mean()\n", + "p_old = old_page_converted.mean()\n", + "p_new - p_old" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LfHk19K5Yaun", + "outputId": "fb6695b0-7d6a-4714-b36d-88dae4b9d36d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-9.114502981043271e-05" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ], + "source": [ + "# alternatively\n", + "new_converted_simulation.mean() - old_converted_simulation.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VEmAg2z_Yauo" + }, + "source": [ + "h. Simulate 10,000 $p_{new}$ - $p_{old}$ values using this same process similarly to the one you calculated in parts **a. through g.** above. Store all 10,000 values in **p_diffs**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "VWMtye1SYauo" + }, + "outputs": [], + "source": [ + "p_diffs = []\n", + "for _ in range(10000):\n", + " new_page_converted = np.random.binomial(1,p_new,n_new) # bootstrapping\n", + " old_page_converted = np.random.binomial(1,p_old,n_old) # bootstrapping\n", + " p_diffs.append(new_page_converted.mean() - old_page_converted.mean())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "lUoNtW-hYauo" + }, + "outputs": [], + "source": [ + "# alternatively\n", + "p_diffs_alt = new_converted_simulation - old_converted_simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ACUcMUvOYaup" + }, + "source": [ + "i. Plot a histogram of the **p_diffs**. Does this plot look like what you expected? Use the matching problem in the classroom to assure you fully understand what was computed here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "YIErh6TkYaup", + "outputId": "04778444-5342-4134-a50f-60eae6d7fc8d" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# convert p_diffs to numpy array for array based computations in the future\n", + "p_diffs = np.array(p_diffs)\n", + "\n", + "# histogram\n", + "plt.hist(p_diffs)\n", + "plt.grid()\n", + "plt.axvline(p_diffs.mean(), color='r', label='mean')\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "v78QB1zoYauq", + "outputId": "a6bce036-919d-41d0-8112-7d91017cf657" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# alternatively\n", + "# histogram\n", + "plt.hist(p_diffs_alt)\n", + "plt.grid()\n", + "plt.axvline(p_diffs_alt.mean(), color='r', label='mean')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qoZr7lq2Yauq" + }, + "source": [ + "As expected the mean is very close to 0." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p6Tcfzm1Yaur" + }, + "source": [ + "j. What proportion of the **p_diffs** are greater than the actual difference observed in **ab_data.csv**?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FdX3_Nf4Yaur", + "outputId": "151e95be-1b57-440e-aeb2-c2702a8e13f1" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.4338" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ], + "source": [ + "actual_diff = df2.converted[df2.group == 'treatment'].mean() - df2.converted[df2.group == 'control'].mean()\n", + "(actual_diff < p_diffs).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XNqt0kXDYaus", + "outputId": "b2eee5e7-26c0-4e91-ba37-835da1d9d173" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.4424" + ] + }, + "metadata": {}, + "execution_count": 51 + } + ], + "source": [ + "# alternatively\n", + "actual_diff = df2.converted[df2.group == 'treatment'].mean() - df2.converted[df2.group == 'control'].mean()\n", + "(actual_diff < p_diffs_alt).mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wj325XhvYaus" + }, + "source": [ + "k. In words, explain what you just computed in part **j.**. What is this value called in scientific studies? What does this value mean in terms of whether or not there is a difference between the new and old pages?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zfCst0ZVYaus" + }, + "source": [ + "- **What we computed in part j. is called p-value in scientific studies.**\n", + "- **p-value is the probability of observing your statistic (or one more extreme in favor of the alternative) if the null hypothesis is true.**\n", + "- **In our case the p-value is so big that we can confidently say that we fail to reject null hypothesis**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hoHjjy2OYaut" + }, + "source": [ + "l. We could also use a built-in to achieve similar results. Though using the built-in might be easier to code, the above portions are a walkthrough of the ideas that are critical to correctly thinking about statistical significance. Fill in the below to calculate the number of conversions for each page, as well as the number of individuals who received each page. Let `n_old` and `n_new` refer the the number of rows associated with the old page and new pages, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "TmzbN-EaYaut", + "outputId": "595da3dd-193d-4fcc-b29a-edcde036504f" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " user_id timestamp group landing_page converted\n", + "0 851104 2017-01-21 22:11:48.556739 control old_page 0.0\n", + "1 804228 2017-01-12 08:01:45.159739 control old_page 0.0\n", + "2 661590 2017-01-11 16:55:06.154213 treatment new_page 0.0\n", + "3 853541 2017-01-08 18:28:03.143765 treatment new_page 0.0\n", + "4 864975 2017-01-21 01:52:26.210827 control old_page 1.0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idtimestampgrouplanding_pageconverted
08511042017-01-21 22:11:48.556739controlold_page0.0
18042282017-01-12 08:01:45.159739controlold_page0.0
26615902017-01-11 16:55:06.154213treatmentnew_page0.0
38535412017-01-08 18:28:03.143765treatmentnew_page0.0
48649752017-01-21 01:52:26.210827controlold_page1.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 52 + } + ], + "source": [ + "# quick check before diving in\n", + "df2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1ygPJuoZYauu" + }, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "convert_old = df2[df2.group == 'control'].converted.sum()\n", + "convert_new = df2[df2.group == 'treatment'].converted.sum()\n", + "n_old = df2[df2.group == 'control'].converted.count()\n", + "n_new = df2[df2.group == 'treatment'].converted.count()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-kRZBJPLYauu" + }, + "source": [ + "m. Now use `stats.proportions_ztest` to compute your test statistic and p-value. [Here](http://knowledgetack.com/python/statsmodels/proportions_ztest/) is a helpful link on using the built in." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lhii3Dc3Yauv" + }, + "source": [ + "From the link, we have all the values required. However, it is worth noticing that the argument alternative in the function is 'two-sided' by default. But our hypothesis is not designed around 'either-or' scenario at this point. Therefore, the argument alternative will be 'smaller', meaning one-tailed experiment. For further reading please refer to [wikipedia](https://en.wikipedia.org/wiki/One-_and_two-tailed_tests) article. As well as, a great informative [video](https://www.youtube.com/watch?v=fXOS4Q3nJQY) about z-scores." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_Hxj7VjXYauv", + "outputId": "93a31f2a-0e9e-4f42-de47-9fcc51e7d86a" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(-0.1303934352949912, 0.4481275800628022)" + ] + }, + "metadata": {}, + "execution_count": 54 + } + ], + "source": [ + "# based upon the documentation\n", + "z_score, p_value = sm.stats.proportions_ztest([convert_old, convert_new], [n_old, n_new], alternative='smaller')\n", + "z_score, p_value" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wmh6G3RzYauv" + }, + "source": [ + "n. What do the z-score and p-value you computed in the previous question mean for the conversion rates of the old and new pages? Do they agree with the findings in parts **j.** and **k.**?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0FXYL6EGYauw" + }, + "source": [ + "- **A z-score represents how many standard deviations away our data point is from the mean**\n", + "- **A positive z-score suggests that our data point is on the right side of the mean line on the bell curve**\n", + "- **p-value of 0.9050 is very close to the p-value we computed earlier in part j.**\n", + "- **With this computation, we can confidently say we fail to reject null hypothesis**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZGE0aVAvYauw" + }, + "source": [ + "\n", + "### Part III - A regression approach\n", + "\n", + "`1.` In this final part, you will see that the result you acheived in the previous A/B test can also be acheived by performing regression.

\n", + "\n", + "a. Since each row is either a conversion or no conversion, what type of regression should you be performing in this case?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B1HdU9dmYauw" + }, + "source": [ + "**This is a case of Logistic Regression. In this scenario, we want to predict something that has only two possible outcomes.**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vqFwaRHoYaux" + }, + "source": [ + "b. The goal is to use **statsmodels** to fit the regression model you specified in part **a.** to see if there is a significant difference in conversion based on which page a customer receives. However, you first need to create a colun for the intercept, and create a dummy variable column for which page each user received. Add an **intercept** column, as well as an **ab_page** column, which is 1 when an individual receives the **treatment** and 0 if **control**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "KyGZfrrcYaux", + "outputId": "96860ec4-8c01-4e8d-97e1-16cffa5f1e8a" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " user_id timestamp group landing_page converted\n", + "0 851104 2017-01-21 22:11:48.556739 control old_page 0.0\n", + "1 804228 2017-01-12 08:01:45.159739 control old_page 0.0\n", + "2 661590 2017-01-11 16:55:06.154213 treatment new_page 0.0\n", + "3 853541 2017-01-08 18:28:03.143765 treatment new_page 0.0\n", + "4 864975 2017-01-21 01:52:26.210827 control old_page 1.0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idtimestampgrouplanding_pageconverted
08511042017-01-21 22:11:48.556739controlold_page0.0
18042282017-01-12 08:01:45.159739controlold_page0.0
26615902017-01-11 16:55:06.154213treatmentnew_page0.0
38535412017-01-08 18:28:03.143765treatmentnew_page0.0
48649752017-01-21 01:52:26.210827controlold_page1.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 55 + } + ], + "source": [ + "# quick consistency check\n", + "df2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "tnbWcWw_Yaux" + }, + "outputs": [], + "source": [ + "# copy the dataframe to a new one, for clarity\n", + "df2_copy = df2.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G0iCZnbxYaux", + "outputId": "58711f3c-2b72-4c67-e662-9a97098d8a89" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 57 + } + ], + "source": [ + "# another sanity check, if True, go ahead\n", + "df2_copy.shape == df2.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "3KXa_k9GYauy" + }, + "outputs": [], + "source": [ + "# add an intercept\n", + "df2_copy['intercept'] = 1\n", + "\n", + "# using pd.get_dummies to convert the 'landing_page' and 'group' to 1s and 0s\n", + "df2_copy[['landing_page_new', 'landing_page_old']] = pd.get_dummies(df2_copy['landing_page'])\n", + "df2_copy[['ab_page_control','ab_page_treatment']] = pd.get_dummies(df2_copy['group'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "npar8uqLYauy" + }, + "outputs": [], + "source": [ + "# here, we will use landing_page_old and ab_page_control as our baselines, therefore remove those\n", + "df2_copy.drop(['landing_page_old','ab_page_control'], axis=1, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "4lZvUbDPYauy", + "outputId": "01fcf3e3-8a16-4652-a8f7-aefef336d702" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " user_id timestamp group landing_page converted \\\n", + "0 851104 2017-01-21 22:11:48.556739 control old_page 0.0 \n", + "1 804228 2017-01-12 08:01:45.159739 control old_page 0.0 \n", + "2 661590 2017-01-11 16:55:06.154213 treatment new_page 0.0 \n", + "3 853541 2017-01-08 18:28:03.143765 treatment new_page 0.0 \n", + "4 864975 2017-01-21 01:52:26.210827 control old_page 1.0 \n", + "\n", + " intercept landing_page_new ab_page_treatment \n", + "0 1 0 0 \n", + "1 1 0 0 \n", + "2 1 1 1 \n", + "3 1 1 1 \n", + "4 1 0 0 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idtimestampgrouplanding_pageconvertedinterceptlanding_page_newab_page_treatment
08511042017-01-21 22:11:48.556739controlold_page0.0100
18042282017-01-12 08:01:45.159739controlold_page0.0100
26615902017-01-11 16:55:06.154213treatmentnew_page0.0111
38535412017-01-08 18:28:03.143765treatmentnew_page0.0111
48649752017-01-21 01:52:26.210827controlold_page1.0100
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 60 + } + ], + "source": [ + "df2_copy.head()" + ] + }, + { + "cell_type": "code", + "source": [ + "unique_values = df2_copy['converted'].unique()\n", + "print(unique_values)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bRfPYDtBc5DQ", + "outputId": "945d1222-326f-444f-9396-80f892179cda" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[ 0. 1. nan]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XBxDMaIkYauy" + }, + "source": [ + "c. Use **statsmodels** to import your regression model. Instantiate the model, and fit the model using the two columns you created in part **b.** to predict whether or not an individual converts." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 141 + }, + "id": "wuG3dJ1jYauy", + "outputId": "980f6788-8fe4-4675-e66f-eeacbcc4a323" + }, + "outputs": [ + { + "output_type": "error", + "ename": "SyntaxError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m7\u001b[0m\n\u001b[0;31m logit_mod = sm.Logit(df2_copy['converted'], df2_copy[])\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax. Perhaps you forgot a comma?\n" + ] + } + ], + "source": [ + "logit_mod = sm.Logit(df2_copy['converted'], df2_copy[['intercept', 'ab_page_treatment']])\n", + "results = logit_mod.fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YkdK2cBGYauz" + }, + "source": [ + "d. Provide the summary of your model below, and use it as necessary to answer the following questions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 175 + }, + "id": "ebRCE0krYauz", + "outputId": "920fcb36-09ef-4e81-a737-3f6dadcfa451" + }, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'results' is not defined" + ] + } + ], + "source": [ + "results.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 193 + }, + "id": "wgokNOg5Yauz", + "outputId": "c222d28f-19b8-4df8-9516-cf212f4dea32" + }, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# interprete the coefficients\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'results' is not defined" + ] + } + ], + "source": [ + "# interprete the coefficients\n", + "1/np.exp(results.params[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sYLM72ZDYauz", + "outputId": "0b628bb0-5a58-4e3d-f340-d953df0e641f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.905" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# additional: question posed by previous reviewer\n", + "# how to get p-value as if it were a one-tailed test\n", + "1-0.190/2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1X356ZftYau0" + }, + "source": [ + "- For each 1 unit decrease in `ab_page_treatment`, conversion is 1.015 time likely holding all the other variables constant. Which is not really why we would launch a new_page!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aAHL5vZXYau0" + }, + "source": [ + "e. What is the p-value associated with **ab_page**? Why does it differ from the value you found in the **Part II**?

**Hint**: What are the null and alternative hypotheses associated with your regression model, and how do they compare to the null and alternative hypotheses in the **Part II**?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CSQkSxv-Yau0" + }, + "source": [ + "- **As we already built the base for z-score and p-value in part-m, this p-value is different of course.**\n", + "- **The logistic regression is two-tailed case. We are exploring only two possible outcomes and it can go either way.**\n", + "- **Interesting part to observe is z-score, absolute of which confirms the number in part-m.**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dSeiWKemYau1" + }, + "source": [ + "The null and alternative hypothesis associated with regression model will be as following:\n", + "$$ H_{0}: p_{old} - p_{new} = 0$$\n", + "$$ H_{0}: p_{old} - p_{new} \\neq 0$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sZK4n-rSYau1", + "outputId": "6291b6c0-73f5-49f1-db2a-45d71cbec88e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "21.0" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# duration of the experiment\n", + "duration = np.array(pd.to_datetime(df.timestamp).sort_values(ascending=True))\n", + "td = duration[-1] - duration[0]\n", + "days = td.astype('timedelta64[D]')\n", + "days / np.timedelta64(1, 'D')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OxWlSnC0Yau1" + }, + "source": [ + "f. Now, you are considering other things that might influence whether or not an individual converts. Discuss why it is a good idea to consider other factors to add into your regression model. Are there any disadvantages to adding additional terms into your regression model?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "whtM8j6MYau2" + }, + "source": [ + "**There can be many other factors that can be taken into consideration to add into our regression model.**\n", + "- **One of the first to consider would be the duration. The duration of this experiment was 21 days. Too short, it would be advisable to increase the duration**\n", + "- **Geographic location is another important factor. If the page is available in multiple languages, for example, it can diversify the sample**\n", + "- **Parameters like click through rate is another factor to consider**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fofpWJ7rYau2" + }, + "source": [ + "g. Now along with testing if the conversion rate changes for different pages, also add an effect based on which country a user lives. You will need to read in the **countries.csv** dataset and merge together your datasets on the approporiate rows. [Here](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.join.html) are the docs for joining tables.\n", + "\n", + "Does it appear that country had an impact on conversion? Don't forget to create dummy variables for these country columns - **Hint: You will need two columns for the three dummy varaibles.** Provide the statistical output as well as a written response to answer this question." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "luLX9dsJYau2" + }, + "outputs": [], + "source": [ + "# read file and join the dfs\n", + "countries_df = pd.read_csv('./countries.csv')\n", + "df_new = countries_df.set_index('user_id').join(df2.set_index('user_id'), how='inner')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "id": "JYvghQQzYau3", + "outputId": "9d256c86-e436-4b6a-f225-018ff3d551ec" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrytimestampgrouplanding_pageconverted
user_id
834778UK2017-01-14 23:08:43.304998controlold_page0
928468US2017-01-23 14:44:16.387854treatmentnew_page0
822059UK2017-01-16 14:04:14.719771treatmentnew_page1
711597UK2017-01-22 03:14:24.763511controlold_page0
710616UK2017-01-16 13:14:44.000513treatmentnew_page0
\n", + "
" + ], + "text/plain": [ + " country timestamp group landing_page converted\n", + "user_id \n", + "834778 UK 2017-01-14 23:08:43.304998 control old_page 0\n", + "928468 US 2017-01-23 14:44:16.387854 treatment new_page 0\n", + "822059 UK 2017-01-16 14:04:14.719771 treatment new_page 1\n", + "711597 UK 2017-01-22 03:14:24.763511 control old_page 0\n", + "710616 UK 2017-01-16 13:14:44.000513 treatment new_page 0" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# quick check\n", + "df_new.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "7SbVhigzYau3" + }, + "outputs": [], + "source": [ + "# Create the necessary dummy variables\n", + "df_new[['canada','uk','us']] = pd.get_dummies(df_new['country'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "8fyO_tP_Yau4" + }, + "outputs": [], + "source": [ + "# let's consider US being our baseline, therefore, we drop US\n", + "df_new.drop(['us'], axis=1, inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9BGzM-1gYau5" + }, + "source": [ + "h. Though you have now looked at the individual factors of country and page on conversion, we would now like to look at an interaction between page and country to see if there significant effects on conversion. Create the necessary additional columns, and fit the new model. \n", + "\n", + "Provide the summary results, and your conclusions based on the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "id": "jCb0XhXXYau5", + "outputId": "6199dab4-a003-4eda-cf93-e73596279506" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrytimestampgrouplanding_pageconvertedcanadauk
user_id
834778UK2017-01-14 23:08:43.304998controlold_page001
928468US2017-01-23 14:44:16.387854treatmentnew_page000
822059UK2017-01-16 14:04:14.719771treatmentnew_page101
711597UK2017-01-22 03:14:24.763511controlold_page001
710616UK2017-01-16 13:14:44.000513treatmentnew_page001
\n", + "
" + ], + "text/plain": [ + " country timestamp group landing_page \\\n", + "user_id \n", + "834778 UK 2017-01-14 23:08:43.304998 control old_page \n", + "928468 US 2017-01-23 14:44:16.387854 treatment new_page \n", + "822059 UK 2017-01-16 14:04:14.719771 treatment new_page \n", + "711597 UK 2017-01-22 03:14:24.763511 control old_page \n", + "710616 UK 2017-01-16 13:14:44.000513 treatment new_page \n", + "\n", + " converted canada uk \n", + "user_id \n", + "834778 0 0 1 \n", + "928468 0 0 0 \n", + "822059 1 0 1 \n", + "711597 0 0 1 \n", + "710616 0 0 1 " + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_new.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "CPcPhkx_Yau6", + "outputId": "d65b6dbb-ff18-4582-d54a-655f4e2de0d0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.366116\n", + " Iterations 6\n" + ] + } + ], + "source": [ + "# fitting linear model\n", + "df_new['intercept'] = 1\n", + "\n", + "logit_mod = sm.Logit(df_new['converted'], df_new[['intercept','canada','uk']])\n", + "results = logit_mod.fit()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1sXkP8WpYau6", + "outputId": "5e1402c2-e70a-4230-c05f-c3dabf2f5b0d" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Logit Regression Results
Dep. Variable: converted No. Observations: 290584
Model: Logit Df Residuals: 290581
Method: MLE Df Model: 2
Date: Sun, 18 Mar 2018 Pseudo R-squ.: 1.521e-05
Time: 22:06:44 Log-Likelihood: -1.0639e+05
converged: True LL-Null: -1.0639e+05
LLR p-value: 0.1984
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err z P>|z| [0.025 0.975]
intercept -1.9967 0.007 -292.314 0.000 -2.010 -1.983
canada -0.0408 0.027 -1.518 0.129 -0.093 0.012
uk 0.0099 0.013 0.746 0.456 -0.016 0.036
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Logit Regression Results \n", + "==============================================================================\n", + "Dep. Variable: converted No. Observations: 290584\n", + "Model: Logit Df Residuals: 290581\n", + "Method: MLE Df Model: 2\n", + "Date: Sun, 18 Mar 2018 Pseudo R-squ.: 1.521e-05\n", + "Time: 22:06:44 Log-Likelihood: -1.0639e+05\n", + "converged: True LL-Null: -1.0639e+05\n", + " LLR p-value: 0.1984\n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "intercept -1.9967 0.007 -292.314 0.000 -2.010 -1.983\n", + "canada -0.0408 0.027 -1.518 0.129 -0.093 0.012\n", + "uk 0.0099 0.013 0.746 0.456 -0.016 0.036\n", + "==============================================================================\n", + "\"\"\"" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "id": "53eF5xhdYau7", + "outputId": "9867684e-5267-405a-b140-8ebc03082c02" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0416437559600236, 1.0099491671175422)" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1/np.exp(-0.0408), np.exp(0.0099)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iP55BTURYau7" + }, + "source": [ + "Above results can be read as:\n", + "- users from uk are 1.009 times more likely to convert as compared to users from us\n", + "- users from canada are 1.042 times more likely to less convert as compared to users from us" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zHWQQWDvYau7" + }, + "source": [ + "\n", + "## Conclusions\n", + "\n", + "Within the framework this project, we tried to understand whether the company should implement a new page or keep the old page with following:\n", + "- Probability based approach\n", + "- A/B test\n", + "- Regression approach\n", + "\n", + "**Probability based approach:**\n", + " - We found that probability of an individual receiving the new page is 0.5001\n", + " - Meaning, there is almost the same chance that an individual received the old page\n", + "\n", + "**A/B test:**\n", + " - In A/B test we set up our hypothesis to test if new page results in better conversion or not\n", + " - We simulated our user groups with respect to conversions\n", + " - We found the p_value to be 0.8879\n", + " - With such a p-value, we failed to reject null hypothesis\n", + " - By using the built-in `stats.proportions_ztest` we computed z-score and p-value which confirmed our earlier p-value and failure to reject null hypothesis\n", + " \n", + "**Regression Approach:**\n", + " - We looked at exploring two possible outcomes. Whether new page is better or not.\n", + " - With logistic regression results, we again encountered same z-score as well as p-value of 0.190, corresponding two-tailed case\n", + " - By further adding geographic location of the users, we tried to find if any specific country had an impact on conversion\n", + " - The result gave a similar outlook and suggested that the countries have no impact on the conversion rate.\n", + " \n", + "**Consideration:**\n", + " - We also looked at the duration of the experiment (21 days).\n", + " - This is a relatively short period of time to run the A/B test.\n", + " - Due to Change aversion effect, a group of users may give an unfair advantage to the older page\n", + " - Similarly, due to Novelty effect, users may give an unfair advantage to the newer page" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4XaidzAdYau8" + }, + "source": [ + "\n", + "## Resources\n", + "- Numpy timedelta conversion to days: https://stackoverflow.com/questions/18215317/extracting-days-from-a-numpy-timedelta64-value\n", + "- How to calculate z scores used in statistics class: https://www.youtube.com/watch?v=fXOS4Q3nJQY\n", + "- Copy pandas dataframe: https://stackoverflow.com/questions/45600342/copy-pandas-dataframe-using-trick\n", + "- One and two tailed tests: https://en.wikipedia.org/wiki/One-_and_two-tailed_tests\n", + "- How to correctly interprete p-values: http://blog.minitab.com/blog/adventures-in-statistics-2/how-to-correctly-interpret-p-values" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" + }, + "colab": { + "provenance": [], + "include_colab_link": true + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 711f76a1d67389cf1ac75d9c87dcea52822163f5 Mon Sep 17 00:00:00 2001 From: Amaar Hassnain <93473921+Amaar015@users.noreply.github.com> Date: Thu, 19 Oct 2023 14:39:52 +0500 Subject: [PATCH 2/2] Add files via upload --- Lab14-20sw015.ipynb | 241 +++++++ lab-13-20sw015.ipynb | 1436 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1677 insertions(+) create mode 100644 Lab14-20sw015.ipynb create mode 100644 lab-13-20sw015.ipynb diff --git a/Lab14-20sw015.ipynb b/Lab14-20sw015.ipynb new file mode 100644 index 0000000..423e109 --- /dev/null +++ b/Lab14-20sw015.ipynb @@ -0,0 +1,241 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMY0BfEf2aELbd4J8PVirnO", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "vBZKRMrFU4gT" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "# Create a DataFrame from the provided data\n", + "\n", + "df = pd.read_csv('/WorldCups.csv');\n" + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Convert 'Goals' to numeric (remove commas if any)\n", + "df['Goals'] = df['Goals'].replace(',', '', regex=True).astype(int)" + ], + "metadata": { + "id": "SQGaaCjEa56Z" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Which team won the most World Cups, and how many wins was that?\n", + "most_wins_team = df['Winner'].value_counts().idxmax()\n", + "most_wins_count = df['Winner'].value_counts().max()\n", + "print(f'Team with the most World Cup wins: {most_wins_team}, Wins: {most_wins_count}')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L5dfYQqYXfwR", + "outputId": "c1be125a-c758-4a7d-96ae-2ed38c994140" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Team with the most World Cup wins: Brazil, Wins: 5\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "#Which team won the most World Cups, and how many wins was that?\n", + "most_wins_team = df['Winner'].value_counts().idxmax()\n", + "most_wins_count = df['Winner'].value_counts().max()\n", + "print(f'Team with the most World Cup wins: {most_wins_team}, Wins: {most_wins_count}')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Iod8vI1EbBl9", + "outputId": "3ba3c139-9eb7-410b-ba04-8a09e93520a2" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Team with the most World Cup wins: Brazil, Wins: 5\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Which Finals or Semi-final games were decided by penalties?\n", + "penalty_games = df[(df['Goals'] % 2 != 0) & ((df['Round'] == 'Final') | (df['Round'] == 'Semi-finals'))]\n", + "print('Finals or Semi-final games decided by penalties:')\n", + "print(penalty_games)\n" + ], + "metadata": { + "id": "5fJYu3jdbEcF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Which years had the highest and lowest attendance to the World Cup games?\n", + "highest_attendance_year = df[df['Goals'] == df['Goals'].max()]['Year'].values[0]\n", + "lowest_attendance_year = df[df['Goals'] == df['Goals'].min()]['Year'].values[0]\n", + "print(f'Highest attendance year: {highest_attendance_year}')\n", + "print(f'Lowest attendance year: {lowest_attendance_year}')\n" + ], + "metadata": { + "id": "mlKQ25IKbG-A" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# What's the average number of goals scored per World Cup?\n", + "average_goals_per_world_cup = df['Goals'].mean()\n", + "print(f'Average goals scored per World Cup: {average_goals_per_world_cup:.2f}')\n" + ], + "metadata": { + "id": "A6vf_hKvbIsW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Which team won the most World Cups, and how many wins was that?\n", + "most_wins_team = df['Winner'].value_counts().idxmax()\n", + "most_wins_count = df['Winner'].value_counts().max()\n", + "print(f'Team with the most World Cup wins: {most_wins_team}, Wins: {most_wins_count}')\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nsXXNEcKahw6", + "outputId": "29deb728-0c12-48ac-b281-d49c60d5d7fa" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Team with the most World Cup wins: Brazil, Wins: 5\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# How many countries qualified for the World Cup in 1930 compared to 2014?\n", + "countries_1930 = 4 # Given in the dataset\n", + "countries_2014 = 32 # Given in the dataset\n", + "print(f'Countries that qualified in 1930: {countries_1930}')\n", + "print(f'Countries that qualified in 2014: {countries_2014}')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uIUdwv45YUvY", + "outputId": "83eaaec7-4034-428f-82ec-ac2b17d68b9c" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Countries that qualified in 1930: 4\n", + "Countries that qualified in 2014: 32\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Does history show more home-team wins or away-team wins?\n", + "# Assuming home-team as the team mentioned first in each row\n", + "home_wins = df[df['Year'] >= 1930]['Winner'].value_counts().sum()\n", + "away_wins = len(df) - home_wins\n", + "print(f'Home-team wins: {home_wins}, Away-team wins: {away_wins}')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wLJCgkV0YXyJ", + "outputId": "8953f348-338f-4f31-84a8-e52b1b835bd1" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Home-team wins: 20, Away-team wins: 0\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/lab-13-20sw015.ipynb b/lab-13-20sw015.ipynb new file mode 100644 index 0000000..0e696b2 --- /dev/null +++ b/lab-13-20sw015.ipynb @@ -0,0 +1,1436 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# ML Model" + ], + "metadata": { + "id": "i3JdXUPAn4Wc" + } + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "2zbFBjxjO1WZ" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "source": [ + "df = pd.read_csv(\"/content/hour.csv\");" + ], + "metadata": { + "id": "QCDgZWtVuJly" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.info()" + ], + "metadata": { + "id": "8NB4sT8sujIi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "18de2b17-03b0-4ac4-f710-be004e1f4535" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "RangeIndex: 17379 entries, 0 to 17378\n", + "Data columns (total 17 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 instant 17379 non-null int64 \n", + " 1 dteday 17379 non-null object \n", + " 2 season 17379 non-null int64 \n", + " 3 yr 17379 non-null int64 \n", + " 4 mnth 17379 non-null int64 \n", + " 5 hr 17379 non-null int64 \n", + " 6 holiday 17379 non-null int64 \n", + " 7 weekday 17379 non-null int64 \n", + " 8 workingday 17379 non-null int64 \n", + " 9 weathersit 17379 non-null int64 \n", + " 10 temp 17379 non-null float64\n", + " 11 atemp 17379 non-null float64\n", + " 12 hum 17379 non-null float64\n", + " 13 windspeed 17379 non-null float64\n", + " 14 casual 17379 non-null int64 \n", + " 15 registered 17379 non-null int64 \n", + " 16 cnt 17379 non-null int64 \n", + "dtypes: float64(4), int64(12), object(1)\n", + "memory usage: 2.3+ MB\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "df.isna().sum()\n" + ], + "metadata": { + "id": "fnqhB3doumT-", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "57545197-dddf-49e7-f7a6-d3d204d44773" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "instant 0\n", + "dteday 0\n", + "season 0\n", + "yr 0\n", + "mnth 0\n", + "hr 0\n", + "holiday 0\n", + "weekday 0\n", + "workingday 0\n", + "weathersit 0\n", + "temp 0\n", + "atemp 0\n", + "hum 0\n", + "windspeed 0\n", + "casual 0\n", + "registered 0\n", + "cnt 0\n", + "dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Renaming columns names to more readable names\n", + "df.rename(columns={'instant':'record_id',\n", + " 'dteday':'datetime',\n", + " 'holiday':'is_holiday',\n", + " 'workingday':'is_workingday',\n", + " 'weathersit':'weather_condition',\n", + " 'hum':'humidity',\n", + " 'mnth':'month',\n", + " 'cnt':'total_count',\n", + " 'hr':'hour',\n", + " 'yr':'year'},inplace=True)" + ], + "metadata": { + "id": "qlUmr11a3TpK" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.columns.values" + ], + "metadata": { + "id": "SLyECwAI33RW", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3d8d0082-f71f-447e-9a56-1b3847a7f9a2" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array(['record_id', 'datetime', 'season', 'year', 'month', 'hour',\n", + " 'is_holiday', 'weekday', 'is_workingday', 'weather_condition',\n", + " 'temp', 'atemp', 'humidity', 'windspeed', 'casual', 'registered',\n", + " 'total_count'], dtype=object)" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "source": [ + "#the registered and casual columns are added up to the total count therefore we can drop those columns.\n", + "df.drop(['record_id','casual', 'registered'], axis=1, inplace=True)" + ], + "metadata": { + "id": "inZD3NhbUMwM" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# date time conversion\n", + "df['datetime'] = pd.to_datetime(df.datetime)\n", + "\n", + "# categorical variables\n", + "df['season'] = df.season.astype('category')\n", + "df['is_holiday'] = df.is_holiday.astype('category')\n", + "df['weekday'] = df.weekday.astype('category')\n", + "df['weather_condition'] = df.weather_condition.astype('category')\n", + "df['is_workingday'] = df.is_workingday.astype('category')\n", + "df['month'] = df.month.astype('category')\n", + "df['year'] = df.year.astype('category')\n", + "df['hour'] = df.hour.astype('category')" + ], + "metadata": { + "id": "3Ii965QO1HL_" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.plot(x='datetime', y='total_count', figsize=(20,12), title = 'Hourly Rental Bikes')\n", + "plt.ylabel('total_count')" + ], + "metadata": { + "id": "DLxQmlkl5ZvB", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 522 + }, + "outputId": "7f3f138c-7184-4123-acee-d55be754ff9a" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'total_count')" + ] + }, + "metadata": {}, + "execution_count": 15 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "df['total_count'].plot.hist(bins=20, figsize=(12,8))" + ], + "metadata": { + "id": "i6vhIkeS8jhZ", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 592 + }, + "outputId": "db5edaaa-a7ca-4057-fe83-5e8bcc173c19" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 16 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# get the correlation\n", + "\n", + "df.corr()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 261 + }, + "id": "yjhs7K4Tt9P5", + "outputId": "3ad8ddb2-309d-4fea-e4b1-0596d2f0efea" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":3: FutureWarning: The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n", + " df.corr()\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " temp atemp humidity windspeed total_count\n", + "temp 1.000000 0.987672 -0.069881 -0.023125 0.404772\n", + "atemp 0.987672 1.000000 -0.051918 -0.062336 0.400929\n", + "humidity -0.069881 -0.051918 1.000000 -0.290105 -0.322911\n", + "windspeed -0.023125 -0.062336 -0.290105 1.000000 0.093234\n", + "total_count 0.404772 0.400929 -0.322911 0.093234 1.000000" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tempatemphumiditywindspeedtotal_count
temp1.0000000.987672-0.069881-0.0231250.404772
atemp0.9876721.000000-0.051918-0.0623360.400929
humidity-0.069881-0.0519181.000000-0.290105-0.322911
windspeed-0.023125-0.062336-0.2901051.0000000.093234
total_count0.4047720.400929-0.3229110.0932341.000000
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,6))\n", + "sns.heatmap(df.corr(), annot=True, cmap=\"YlGnBu\")" + ], + "metadata": { + "id": "cqWmuujxuIgx", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 600 + }, + "outputId": "75ee9997-8183-4497-ae8c-cb423cff1a18" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":2: FutureWarning: The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n", + " sns.heatmap(df.corr(), annot=True, cmap=\"YlGnBu\")\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 18 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "\n", + "le = LabelEncoder()\n" + ], + "metadata": { + "id": "7z1fwjDq3mqW" + }, + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cat_attr_list = ['season','is_holiday',\n", + " 'weather_condition','is_workingday',\n", + " 'hour','weekday','month','year']\n", + "for col in cat_attr_list:\n", + " df[col] = le.fit_transform(df[col])\n", + "df.info()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "caHnJYUa1EsJ", + "outputId": "c80ccf19-8737-4e05-fb73-a6233fe5df8e" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "RangeIndex: 17379 entries, 0 to 17378\n", + "Data columns (total 14 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 datetime 17379 non-null datetime64[ns]\n", + " 1 season 17379 non-null int64 \n", + " 2 year 17379 non-null int64 \n", + " 3 month 17379 non-null int64 \n", + " 4 hour 17379 non-null int64 \n", + " 5 is_holiday 17379 non-null int64 \n", + " 6 weekday 17379 non-null int64 \n", + " 7 is_workingday 17379 non-null int64 \n", + " 8 weather_condition 17379 non-null int64 \n", + " 9 temp 17379 non-null float64 \n", + " 10 atemp 17379 non-null float64 \n", + " 11 humidity 17379 non-null float64 \n", + " 12 windspeed 17379 non-null float64 \n", + " 13 total_count 17379 non-null int64 \n", + "dtypes: datetime64[ns](1), float64(4), int64(9)\n", + "memory usage: 1.9 MB\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "df.drop(['temp'], axis=1, inplace=True)" + ], + "metadata": { + "id": "pQXBtLmnvnai" + }, + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.drop('datetime', axis=1, inplace=True)" + ], + "metadata": { + "id": "DuEcM58m4Il_" + }, + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import mean_squared_error" + ], + "metadata": { + "id": "gXLYojwDqrGL" + }, + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X = df.drop(['total_count'],axis=1)\n", + "y = df['total_count']" + ], + "metadata": { + "id": "QVMJ2ELOrVE5" + }, + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state=5)" + ], + "metadata": { + "id": "S1on5yljrCt9" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_train.shape, X_test.shape, y_train.shape, y_test.shape" + ], + "metadata": { + "id": "jQ5uK3qgsCcl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b961b4b1-76be-45e0-feaf-bf3fab9e61d8" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((12165, 11), (5214, 11), (12165,), (5214,))" + ] + }, + "metadata": {}, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "source": [ + "regressor = LinearRegression()\n", + "regressor.fit(X_train,y_train)" + ], + "metadata": { + "id": "hd83Naf7sQLc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 74 + }, + "outputId": "d85b659b-5e37-4962-987a-1e2db1820f14" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "LinearRegression()" + ], + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "predictions = regressor.predict(X_test)\n", + "predictions.shape" + ], + "metadata": { + "id": "pFH-sYo-td9a", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "45f337d6-5fe6-4986-9381-8cdcaa8ba977" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(5214,)" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import math\n", + "import sklearn.metrics\n", + "mse = sklearn.metrics.mean_squared_error(y_test, predictions)\n", + "\n", + "rmse = math.sqrt(mse)\n", + "rmse" + ], + "metadata": { + "id": "Xer0mu4ytcyJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ae949bd3-92a5-4d4e-cc6e-bbc5dab48021" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "144.4200144934657" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "random_regressor = RandomForestRegressor().fit(X_train, y_train)\n", + "print(math.sqrt(mean_squared_error(y_test, random_regressor.predict(X_test))))" + ], + "metadata": { + "id": "0Daj1K-uMtPP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a695c7a6-d0ad-4f9a-dafe-0395137cdb63" + }, + "execution_count": 30, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "42.62815229766572\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "feat_importances = pd.DataFrame(random_regressor.feature_importances_, index=X_train.columns, columns=[\"Importance\"])\n", + "feat_importances.sort_values(by='Importance', ascending=False, inplace=True)\n", + "feat_importances" + ], + "metadata": { + "id": "Cfr7nWTiMswF", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 394 + }, + "outputId": "cff923a7-0200-4ae2-9533-880b46bccb05" + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Importance\n", + "hour 0.609326\n", + "atemp 0.139755\n", + "year 0.079347\n", + "is_workingday 0.054324\n", + "humidity 0.028884\n", + "season 0.022633\n", + "weather_condition 0.019734\n", + "month 0.016518\n", + "weekday 0.015190\n", + "windspeed 0.011612\n", + "is_holiday 0.002677" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Importance
hour0.609326
atemp0.139755
year0.079347
is_workingday0.054324
humidity0.028884
season0.022633
weather_condition0.019734
month0.016518
weekday0.015190
windspeed0.011612
is_holiday0.002677
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ] + }, + { + "cell_type": "code", + "source": [ + "feat_importances.plot(kind='bar', figsize=(12,8))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 711 + }, + "id": "Pn7S0E0O6UY5", + "outputId": "1ae78d7d-c7a6-4674-8d7d-dd94c4dfa723" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 32 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# ML Pipeline\n" + ], + "metadata": { + "id": "Yt1u2J3aQkiu" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np" + ], + "metadata": { + "id": "cezFBz-6SIll" + }, + "execution_count": 33, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df = pd.read_csv(\"/content/hour.csv\")" + ], + "metadata": { + "id": "hbBwAyi_SIah" + }, + "execution_count": 35, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Renaming columns names to more readable names\n", + "df.rename(columns={'instant':'record_id',\n", + " 'dteday':'datetime',\n", + " 'holiday':'is_holiday',\n", + " 'workingday':'is_workingday',\n", + " 'weathersit':'weather_condition',\n", + " 'hum':'humidity',\n", + " 'mnth':'month',\n", + " 'cnt':'total_count',\n", + " 'hr':'hour',\n", + " 'yr':'year'},inplace=True)" + ], + "metadata": { + "id": "xWZKfFvSSIOP" + }, + "execution_count": 36, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.drop(['record_id','casual', 'registered','datetime','temp'], axis=1, inplace=True)" + ], + "metadata": { + "id": "H1Vv5GfoSIAW" + }, + "execution_count": 41, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.pipeline import Pipeline" + ], + "metadata": { + "id": "MYEfy0s4RWaa" + }, + "execution_count": 37, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X = df.drop(['total_count'],axis=1)\n", + "y = df['total_count']" + ], + "metadata": { + "id": "3yFTihEGREpR" + }, + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state=42)" + ], + "metadata": { + "id": "VPROfFB7Qw-J" + }, + "execution_count": 45, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "pipeline = Pipeline(steps = [\n", + " ('regressor',RandomForestRegressor())\n", + " ])" + ], + "metadata": { + "id": "3Wtj-l1BoemU" + }, + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(math.sqrt(mean_squared_error(y_test, predictions)))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B5ZAuOu3Kb_A", + "outputId": "c31c9a1e-aca5-498e-dfbb-838fe3563d11" + }, + "execution_count": 42, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "210.67524933857482\n" + ] + } + ] + } + ] +} \ No newline at end of file