diff --git "a/Walmart_Sales_Prediction.ipynb" "b/Walmart_Sales_Prediction.ipynb" new file mode 100644--- /dev/null +++ "b/Walmart_Sales_Prediction.ipynb" @@ -0,0 +1,3687 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Loading" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Importing the necessary libraries, like pandas, numpy and some plotting libraries such as matplotlib and seaborn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "lI2v1okvKuij" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np \n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "%matplotlib inline " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the default font size, figure size and the grid in the plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "s8ezED7IHvPI" + }, + "outputs": [], + "source": [ + "sns.set_style('darkgrid')\n", + "matplotlib.rcParams['font.size'] = 14\n", + "matplotlib.rcParams['figure.figsize'] = (10, 6)\n", + "matplotlib.rcParams['figure.facecolor'] = '#00000000'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h0njd46PH47d" + }, + "source": [ + "Reading of data as a pandas dataframe and named as **df**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4WA1PYlpHxYX" + }, + "outputs": [], + "source": [ + "df = pd.read_csv('Walmart.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "iFsIgIxlH4S7", + "outputId": "76fdf6c5-df19-440a-8a7a-61c5478340f4" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StoreDateWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemployment
0105-02-20101643690.90042.312.572211.0963588.106
1112-02-20101641957.44138.512.548211.2421708.106
2119-02-20101611968.17039.932.514211.2891438.106
3126-02-20101409727.59046.632.561211.3196438.106
4105-03-20101554806.68046.502.625211.3501438.106
...........................
64304528-09-2012713173.95064.883.997192.0135588.684
64314505-10-2012733455.07064.893.985192.1704128.667
64324512-10-2012734464.36054.474.000192.3272658.667
64334519-10-2012718125.53056.473.969192.3308548.667
64344526-10-2012760281.43058.853.882192.3088998.667
\n", + "

6435 rows × 8 columns

\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Date Weekly_Sales Holiday_Flag Temperature Fuel_Price \\\n", + "0 1 05-02-2010 1643690.90 0 42.31 2.572 \n", + "1 1 12-02-2010 1641957.44 1 38.51 2.548 \n", + "2 1 19-02-2010 1611968.17 0 39.93 2.514 \n", + "3 1 26-02-2010 1409727.59 0 46.63 2.561 \n", + "4 1 05-03-2010 1554806.68 0 46.50 2.625 \n", + "... ... ... ... ... ... ... \n", + "6430 45 28-09-2012 713173.95 0 64.88 3.997 \n", + "6431 45 05-10-2012 733455.07 0 64.89 3.985 \n", + "6432 45 12-10-2012 734464.36 0 54.47 4.000 \n", + "6433 45 19-10-2012 718125.53 0 56.47 3.969 \n", + "6434 45 26-10-2012 760281.43 0 58.85 3.882 \n", + "\n", + " CPI Unemployment \n", + "0 211.096358 8.106 \n", + "1 211.242170 8.106 \n", + "2 211.289143 8.106 \n", + "3 211.319643 8.106 \n", + "4 211.350143 8.106 \n", + "... ... ... \n", + "6430 192.013558 8.684 \n", + "6431 192.170412 8.667 \n", + "6432 192.327265 8.667 \n", + "6433 192.330854 8.667 \n", + "6434 192.308899 8.667 \n", + "\n", + "[6435 rows x 8 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**About Data:**\n", + "* Store - the store number\n", + "* Date - the week of sales\n", + "* Weekly_Sales - sales for the given store\n", + "* Holiday_Flag - whether the week is a special holiday week 1 – Holiday week 0 – Non-holiday week\n", + "* Temperature - Temperature on the day of sale\n", + "* Fuel_Price - Cost of fuel in the region\n", + "* CPI – Prevailing consumer price index\n", + "* Unemployment - Prevailing unemployment rate" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "70sjXLXPPgms" + }, + "source": [ + "**Insights:**\n", + "\n", + "* Here the target columns is Weekly_Sales.\n", + "* The data is related to walmart store of united state of america. Where **Store**, **Holiday_Flag** are categorical in nature\n", + "* The data is collected over a 45 stores and weekly sales gives the sales of the crossponding store.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v4tOp36ePN1I" + }, + "source": [ + "## Data Exploration and Modification" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "z5gHyIQ8PKaX", + "outputId": "202db5ed-a412-44a0-8510-38c847086604" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 6435 entries, 0 to 6434\n", + "Data columns (total 8 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Store 6435 non-null int64 \n", + " 1 Date 6435 non-null object \n", + " 2 Weekly_Sales 6435 non-null float64\n", + " 3 Holiday_Flag 6435 non-null int64 \n", + " 4 Temperature 6435 non-null float64\n", + " 5 Fuel_Price 6435 non-null float64\n", + " 6 CPI 6435 non-null float64\n", + " 7 Unemployment 6435 non-null float64\n", + "dtypes: float64(5), int64(2), object(1)\n", + "memory usage: 402.3+ KB\n" + ] + } + ], + "source": [ + "df.info() # it gives the information (like count and data type) of the dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E71rOKGCSMdO" + }, + "source": [ + "Here Date columns is **object** and other remain columns are **interger or float** in nature. Now using the pandas I change the date column datatype(i.e. object) into a pandas-datetime. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.Date=pd.to_datetime(df.Date)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the date column i create three seperate columns of weekday, month and year and added to the existing dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Wah1iBNMRbOZ" + }, + "outputs": [], + "source": [ + "df['weekday'] = df.Date.dt.weekday\n", + "df['month'] = df.Date.dt.month\n", + "df['year'] = df.Date.dt.year" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now I drop the date columns because of no use of it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FVa_jWuuSeXw" + }, + "outputs": [], + "source": [ + "df.drop(['Date'], axis=1, inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hence the modified dataset is look like:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "_N5RjYZqijWo", + "outputId": "f8a19149-7e22-4fa8-fe22-42dfb58fcb10" + }, + "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", + "
StoreWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemploymentweekdaymonthyear
011643690.90042.312.572211.0963588.106652010
111641957.44138.512.548211.2421708.1063122010
211611968.17039.932.514211.2891438.106422010
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Weekly_Sales Holiday_Flag Temperature Fuel_Price CPI \\\n", + "0 1 1643690.90 0 42.31 2.572 211.096358 \n", + "1 1 1641957.44 1 38.51 2.548 211.242170 \n", + "2 1 1611968.17 0 39.93 2.514 211.289143 \n", + "\n", + " Unemployment weekday month year \n", + "0 8.106 6 5 2010 \n", + "1 8.106 3 12 2010 \n", + "2 8.106 4 2 2010 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Explored the unique values of the weekday, month and year columns as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vvUj_-NAimJu", + "outputId": "2d78f9c1-8f56-4ada-bb15-5433f62c2d33" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "years unique value [2010 2011 2012]\n", + "months unique value [ 5 12 2 3 9 4 7 11 6 8 10 1]\n", + "weekday unique value [6 3 4 0 5 1 2]\n" + ] + } + ], + "source": [ + "print('years unique value', df.year.unique())\n", + "print('months unique value', df.month.unique())\n", + "print('weekday unique value', df.weekday.unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lOswVgn6kIMe" + }, + "source": [ + "Months and weekday are as usual, but the data is taken from year 2010, 2011, 2012 only." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now to get the idea of distribution of the dataset, I used describe function which gives a table of various statistical values of all the columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 300 + }, + "id": "iXkWelyCkq-I", + "outputId": "1bc10ad1-6d6a-42c1-ee2d-2c471db9fd39" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StoreWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemploymentweekdaymonthyear
count6435.0000006.435000e+036435.0000006435.0000006435.0000006435.0000006435.0000006435.0000006435.0000006435.000000
mean23.0000001.046965e+060.06993060.6637823.358607171.5783947.9991513.5734276.4755242010.965035
std12.9881825.643666e+050.25504918.4449330.45902039.3567121.8758851.4265813.3217970.797019
min1.0000002.099862e+050.000000-2.0600002.472000126.0640003.8790000.0000001.0000002010.000000
25%12.0000005.533501e+050.00000047.4600002.933000131.7350006.8910004.0000004.0000002010.000000
50%23.0000009.607460e+050.00000062.6700003.445000182.6165217.8740004.0000006.0000002011.000000
75%34.0000001.420159e+060.00000074.9400003.735000212.7432938.6220004.0000009.0000002012.000000
max45.0000003.818686e+061.000000100.1400004.468000227.23280714.3130006.00000012.0000002012.000000
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Weekly_Sales Holiday_Flag Temperature Fuel_Price \\\n", + "count 6435.000000 6.435000e+03 6435.000000 6435.000000 6435.000000 \n", + "mean 23.000000 1.046965e+06 0.069930 60.663782 3.358607 \n", + "std 12.988182 5.643666e+05 0.255049 18.444933 0.459020 \n", + "min 1.000000 2.099862e+05 0.000000 -2.060000 2.472000 \n", + "25% 12.000000 5.533501e+05 0.000000 47.460000 2.933000 \n", + "50% 23.000000 9.607460e+05 0.000000 62.670000 3.445000 \n", + "75% 34.000000 1.420159e+06 0.000000 74.940000 3.735000 \n", + "max 45.000000 3.818686e+06 1.000000 100.140000 4.468000 \n", + "\n", + " CPI Unemployment weekday month year \n", + "count 6435.000000 6435.000000 6435.000000 6435.000000 6435.000000 \n", + "mean 171.578394 7.999151 3.573427 6.475524 2010.965035 \n", + "std 39.356712 1.875885 1.426581 3.321797 0.797019 \n", + "min 126.064000 3.879000 0.000000 1.000000 2010.000000 \n", + "25% 131.735000 6.891000 4.000000 4.000000 2010.000000 \n", + "50% 182.616521 7.874000 4.000000 6.000000 2011.000000 \n", + "75% 212.743293 8.622000 4.000000 9.000000 2012.000000 \n", + "max 227.232807 14.313000 6.000000 12.000000 2012.000000 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Insights:**\n", + "* Temperature - has values ranges from (-2, 100.1) Fahrenhite.\n", + "* CPI - is ranges from 126 to 227 with a standard deviation of 39.35\n", + "* Unemployment - is ranges from 3.87 to 14.31 with a standard deviation of 1.87" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "pAD-SpIjmIC6" + }, + "outputs": [], + "source": [ + "original_df = df.copy() # made the copy of dataframe to check the dublicates values in the dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Checking of dublicates values : " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "li2XZvesln26", + "outputId": "8b99e149-6d6d-4206-9afd-accc361799ff" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The dataset doesn't have any duplicates\n" + ] + } + ], + "source": [ + "counter = 0\n", + "rs,cs = original_df.shape\n", + "\n", + "df.drop_duplicates(inplace=True)\n", + "\n", + "if df.shape==(rs,cs):\n", + " print('The dataset doesn\\'t have any duplicates')\n", + "else:\n", + " print('Number of duplicates dropped/fixed ---> {rs-df.shape[0]}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Checking of missing values : " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UAQTtf7jmWhQ", + "outputId": "963c9cfd-b98e-44c9-8a55-85b78d714281" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Store 0\n", + "Weekly_Sales 0\n", + "Holiday_Flag 0\n", + "Temperature 0\n", + "Fuel_Price 0\n", + "CPI 0\n", + "Unemployment 0\n", + "weekday 0\n", + "month 0\n", + "year 0\n", + "dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ekTGNkWRma1k" + }, + "source": [ + "Dataset doesn't have null values" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BvM1LJc7kyq_" + }, + "source": [ + "## Data Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "4M5tqFzPlAB2", + "outputId": "25785689-f3c4-4be1-c30f-2acf6a1ff3a1" + }, + "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", + "
StoreWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemploymentweekdaymonthyear
011643690.90042.312.572211.0963588.106652010
111641957.44138.512.548211.2421708.1063122010
211611968.17039.932.514211.2891438.106422010
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Weekly_Sales Holiday_Flag Temperature Fuel_Price CPI \\\n", + "0 1 1643690.90 0 42.31 2.572 211.096358 \n", + "1 1 1641957.44 1 38.51 2.548 211.242170 \n", + "2 1 1611968.17 0 39.93 2.514 211.289143 \n", + "\n", + " Unemployment weekday month year \n", + "0 8.106 6 5 2010 \n", + "1 8.106 3 12 2010 \n", + "2 8.106 4 2 2010 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we have:\n", + "\n", + "**Numerical columns:** Weekly_sales, temperature, fuel_price, cpi, unemployment\n", + "\n", + "**Categorical columns:** Holiday_flag, Weekday, month, year\n", + "\n", + "Now plotted the count plot to get the distribution or frequency of the columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 505 + }, + "id": "eSyWAfAXlLNS", + "outputId": "4d131471-a565-4ec7-b5dc-b9c6e4b1ed2f" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(16, 8))\n", + "\n", + "#axes[0,0].set_title('Holiday Count plot')\n", + "sns.countplot(x='Holiday_Flag', data=df, ax= axes[0,0])\n", + "\n", + "#axes[0,1].set_title('Weekday Count plot')\n", + "sns.countplot(x='weekday', data=df, ax= axes[0,1]);\n", + "\n", + "#axes[1,0].set_title('month Count plot')\n", + "sns.countplot(x='month', data=df, ax= axes[1,0]);\n", + "\n", + "#axes[1,1].set_title('year Count plot')\n", + "sns.countplot(x='year', data=df, ax= axes[1,1]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Insights:**\n", + "\n", + "* In Holiday flag most of the time there is no holiday in that week.\n", + "* In weekdays columns observations are mostly related to the day 4\n", + "* Most of the observation in the data is from the month of april\n", + "* Most of the observation in the data is from year 2011" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the idea of how many observations are there in dataset crossponding to each store, I again plot a count plot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 505 + }, + "id": "_HphuyP76FHt", + "outputId": "90411b65-58e5-453a-8d19-d7b8e838c15e" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABC4AAAHoCAYAAACGpq6oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeZhkZ103/O9klixkmSCTBRBEkVv0gTcI+EgEDGhQ2QybIKs8KAIhgAiRRHwJKFtAQtCgCGhE2SQhSFgDKiKLeQGDkEhu9DVskgUIHRISkmGY549TM+mp9HRX16nTc1fy+VxXX919qvrb95zpX5/ub586tW779u0BAAAAaNFee3oBAAAAALujuAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmrVhTy9gLf3gBz/Yvm2bp38FAACAlmzcuP6bSbYsddtNqrjYtm17Fhau3tPLAAAAABbZsuWAL+/uNg8VAQAAAJqluAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmqW4AAAAAJqluAAAAACapbgAAAAAmqW4AAAAAJq1YU8vYE+4+UH7ZP2mjb1ztl23NZdf8b3Bc2eVvXTu3lm/aVOv3C77ulx+xbU73z/4oE3ZsGnv3rnfv+7afPuK63bZNovsoXKXyt580KZsnEHu1uuuzcIa5A6ZvXnzxmzcuE//3K3fy8LC1p3vH7R5YzbNIPe6rd/LFYtyh8weKvfAzZuy98b+/3fXbr0231nY9etiqOwDNm/KPjPI/d7Wa3PlLrl7Z5+N/b+/fW/rdbly4dpdtg2VfcDmfbLPxv7Hke9t3ZorF67/fj9U7pDZw+Xum3029v/x53tbv58rF67ZZdsssofKXSp7PvfFftln4/peuV32tly5cPXguUly4Ob9snfP7Gu3bst3xnIP2rxfNs1gzddt3ZYrFmUftPlm2bSx/982r9v6g1yx8N2d72/efLNsnEHu1q0/yMKi3CGzD958s2yYQe73t/4g316ce9DNsmHTDHKv+0G+fcWu+2Ko7JsftF/Wb+r/9bbtum25/Irrv96Gyh0ye7jcfbN+U//vyduu+34uv2LX751DZQ+55nE3yeJi/aaN+caf/W3vnC1PfWyS638YWr9pY77x56/rn/uU394ld0f2pX/28l65hz7195bI3ZSvn/bsXrlJcstjX5Xk+h++N2zaOxf9yTG9c2933LuS7PrL04ZNe+dzf/bgXrl3fuq7l8z95F88sFduktzjye/ZJXvjpr3zj294QO/c+/7me2+Q+943/krv3Ac86f0Z3xcbN+2dM/7ql3tnP/yJH9gle+PGffI3p/9S79zH/cYHk1z/y/qmjfvk9W/qn/tbj981d0f2a97cP/sZj7nhml/6tv65Jzxq19y9N+6d572j///dyx6x6//djuwnntU/+68esmv2Phv3zq/8/eN6577/V/8mV+6Suyn3f9dze+e+75hX5MrsWlzss3FT7n/WH/XPfsjzd8neZ+PGPOCdr+qd+96HPjtXLvp+3+W+dga5T9sld2f2mW/on/2w37zBmh94xpt6577n4Y8fy92QB57xthnkPipXjm3bZ+OGPOiMd/bKPfvhD10y98FnvKdXbpK8++EP3CV7n40bcswZH+6d+66H/+KSa37ImR/rlXvWw+65RO76PPzMz/TKTZIzHnbXsX2xPr92Zu2d+3cPKzdY894b1+cZZ321V+5rHvLDN9i2aeP6nHzWxb1yk+T4hxw+lrtX/vKdl/XO/T8PPWSX9zdu3CvvPOObvXMf+vBb3GDbxo175Zy39s++36/vmr1h4175+Ju+0Tv35x6/ZdfcTXvlvDf038d3+c1DbrBtw6a98sXTLu2dfYdjD93l/fWb1ufrr+j/9XbL5+769bZ+0/pc8sr/6p172HNuf4Nt6zetz6WnfK539qG/c+cb5p56bv/cZ/7vsdwNufQ1H+mf+4yjbrBt/aYNuexPP9A7+5Cn7/pz4PpNG3LZaWf1zz32ISvex0NFAAAAgGYpLgAAAIBmrelDRUop907ynCR3TXLLJE+stZ6+m/u+LsmTkzy31vrKRdv3TvLKJL+eZN8k/5DkabXWrw27egAAAGCtrfUZF/snOT/JM5Ps9uobpZSHJ/mZJF9f4uZXJ3lYuuLiXkkOTPKeUkr/K6QAAAAATVnTMy5qre9L8r4kKaWcvtR9Sim3TXJqkl9M8v6x2w5K8qR0Z2p8aLTtcUm+PLr/B4daOwAAALD2mrrGRSllQ5K3JvmjWusXlrjLXZNsTHLOjg211q8m+UKSI9dkkQAAAMCaae3pUF+Y5Ju11j/bze2HJdmWZPz5ji4d3bas9evXZfPm/fqtcMys8+Y1d8jsecsdMnvecofMnrfcIbPnLXfI7HnLHTJ73nKHzJY7fPa85Q6ZPW+5Q2bPW+6Q2fOWO2T2vOUOmT1vuUNmr5TbTHFRSjkqyW8kOWKoz7Ft2/YsLFydLVsOmFnmwsLVO98eKneW2UPljmfbF8Pvi3nYx+PZ85Y7ZPa85Q6ZPW+5Q2bPW+6Q2fOWO8vsed/Hs8y2L4bPHc+et9whs+ctd8jsecsdMnvecofMnnXucnktPVTkqCSHJ7m4lPL9Usr3k9w2yctLKTueMeSSJOuT3GLsYw8d3QYAAADciLRUXLw2yZ3TnXGx4+XrSU5J8guj+3wmydYkR+/4oFLKrZPcMckn1nKxAAAAwPDW9KEipZT9k9x+9O5eSW5TSjkiyeW11q8kuWzs/luTXFJrrUlSa72ilPLGJCeXUi5L8q0kr0ryuSQfXqN/BgAAALBG1vqMi7slOW/0sm+6i3Gel+RFq8h4VpKzkrw9yceTXJXkQbXWbbNdKgAAALCnrekZF7XWjyRZt4r7/8gS265NctzoBQAAALgRa+kaFwAAAAC7UFwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzdqwlp+slHLvJM9Jctckt0zyxFrr6aPbNib5oyS/kuTHknwnyT8leV6t9SuLMvZO8sokv55k3yT/kORptdavrd2/BAAAAFgLa33Gxf5Jzk/yzCTXjN22X5KfTvLi0etfTfLDST5QSllcsLw6ycPSFRf3SnJgkveUUtYPu3QAAABgra3pGRe11vcleV+SlFJOH7vtiiRHL95WSvntJBckuWOSz5dSDkrypHRnanxodJ/HJflykl9M8sGB/wkAAADAGmr9GhcHjl5/e/T6rkk2Jjlnxx1qrV9N8oUkR67t0gAAAIChrekZF6tRStmU5I+TnL3o+hWHJdmW5Jtjd790dNuy1q9fl82b95vpOmedN6+5Q2bPW+6Q2fOWO2T2vOUOmT1vuUNmz1vukNnzljtkttzhs+ctd8jsecsdMnvecofMnrfcIbPnLXfI7HnLHTJ7pdwmi4vRNS3+NsnmJA+eVe62bduzsHB1tmw5YFaRWVi4eufbQ+XOMnuo3PFs+2L4fTEP+3g8e95yh8yet9whs+ctd8jsecsdMnvecmeZPe/7eJbZ9sXwuePZ85Y7ZPa85Q6ZPW+5Q2bPW+6Q2bPOXS6vuYeKjEqLtya5c5JfqLV+a9HNlyRZn+QWYx926Og2AAAA4EakqeJi9JSob09XWtyn1jpeRnwmydYsuohnKeXW6S7e+Ym1WicAAACwNtb0oSKllP2T3H707l5JblNKOSLJ5Um+nuQdSe6e5EFJtpdSdly34opa6zW11itKKW9McnIp5bIk30ryqiSfS/LhNfynAAAAAGtgrc+4uFuS80Yv+yZ54ejtFyW5dZJfTXLLdGdWXLzo5ZGLMp6V5Kx0Z2Z8PMlVSR5Ua922Nv8EAAAAYK2s6RkXtdaPJFm3zF2Wu21HxrVJjhu9AAAAADdiTV3jAgAAAGAxxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQrA1r+clKKfdO8pwkd01yyyRPrLWevuj2dUlekOTJSQ5Ocm6SY2utFyy6z8FJXpPkwaNN705yXK11YS3+DQAAAMDaWeszLvZPcn6SZya5Zonbj0/yu0mOS3L3JJcl+VAp5YBF93lLkp9O8sujl59O8jcDrhkAAADYQ9b0jIta6/uSvC9JSimnL75tdLbFs5K8rNZ65mjbE9KVF49O8rpSyh3TlRX3rLV+cnSf307yL6WUUmuta/VvAQAAAIbX0jUubpfksCTn7NhQa70myUeTHDnadI8kVyX5xKKP+3iS7y66DwAAAHAjsaZnXKzgsNHrS8e2X5rkVovu841a6/YdN9Zat5dSLlv08bu1fv26bN683yzWutOs8+Y1d8jsecsdMnvecofMnrfcIbPnLXfI7HnLHTJ73nKHzJY7fPa85Q6ZPW+5Q2bPW+6Q2fOWO2T2vOUOmT1vuUNmr5TbUnExuG3btmdh4eps2XLAynee0MLC1TvfHip3ltlD5Y5n2xfD74t52Mfj2fOWO2T2vOUOmT1vuUNmz1vukNnzljvL7Hnfx7PMti+Gzx3PnrfcIbPnLXfI7HnLHTJ73nKHzJ517nJ5LT1U5JLR60PHth+66LZLkmwZXQ8jyc5rYxyy6D4AAADAjURLxcVF6cqHo3dsKKXsk+Reuf6aFp9M98wk91j0cfdIcrPset0LAAAA4EZgTR8qUkrZP8ntR+/uleQ2pZQjklxea/1KKeXVSU4spVyY5ItJnp/uYpxvSZJa6xdKKR9I9wwjTx7lvC7JezyjCAAAANz4rPUZF3dLct7oZd8kLxy9/aLR7ScnOSXJaUk+neTwJPertV65KOPRSf49yQdHL/+e5HFrsXgAAABgba3pGRe11o8kWbfM7duTnDR62d19vp3ksTNeGgAAANCglq5xAQAAALALxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQLMUFAAAA0CzFBQAAANAsxQUAAADQrA2T3rGUcpskX621bh/bvi7JD9dav9J3MaWU9UlOSvLYJIcnuTjJm5OcVGv9/qLP94IkT05ycJJzkxxba72g7+cHAAAA2rKaMy4uSrJlie03H902C7+X5Ngkz0jyE0meOXr/hEX3OT7J7yY5Lsndk1yW5EOllANmtAYAAACgEROfcZFkXZLtS2zfP8n3ZrOcHJnk7Frr2aP3v1RKeXeS/53sPNviWUleVms9c7TtCenKi0cned2M1gEAAAA0YMXiopTymtGb25O8tJRy9aKb1yf5mSSfndF6PpbkaaWUn6i1XlhK+ckk903y0tHtt0tyWJJzdnxArfWaUspH05UeigsAAAC4EZnkjIs7jV6vS3LHJNctuu26JP+W5JUzWs/LkxyQ5D9KKdtG63txrfW1o9sPG72+dOzjLk1yq5XC169fl82b95vRUjuzzpvX3CGz5y13yOx5yx0ye95yh8yet9whs+ctd8jsecsdMlvu8Nnzljtk9rzlDpk9b7lDZs9b7pDZ85Y7ZPa85Q6ZvVLuisVFrfU+SVJK+askz6y1fmc2S1vSI5M8Pt3DPi5IckSSU0spF9Va39g3fNu27VlYuDpbtszuchgLC9efgDJU7iyzh8odz7Yvht8X87CPx7PnLXfI7HnLHTJ73nKHzJ633CGz5y13ltnzvo9nmW1fDJ87nj1vuUNmz1vukNnzljtk9rzlDpk969zl8ia+xkWt9YkzWdHyXpHklbXWt43e/3wp5bbpLs75xiSXjLYfmmTxs5gcuug2AAAA4EZiNU+Huk+6Z/n4hSSHZOwZSWqtd57BevZLsm1s27ZFn+uidAXF0Uk+tWhd90ry3Bl8fgAAAKAhq3lWkdcmeUiSdyT5RJZ+hpG+zk7yvFLKRekeKnKXJM9O8qYkqbVuL6W8OsmJpZQLk3wxyfOTXJXkLQOsBwAAANiDVlNcHJPkEbXWDw+1mCTHJfnDdCXJIUkuTvL6JC9adJ+Tk+yb5LQkByc5N8n9aq1XDrguAAAAYA9YTXFxdZKvDrWQJBmVD88avezuPtuTnDR6AQAAAG7E9lr5LjudnOTZpZR1Qy0GAAAAYLHVnHFxdLqLYP5yKeU/kmxdfGOt9cGzXBgAAADAaoqLbyY5a6iFAAAAAIybuLiotT5xyIUAAAAAjFvNNS4AAAAA1tTEZ1yUUj6fZPvubq+13nkmKwIAAAAYWc01Ls4Ye39jkiOS/FyS02a2IgAAAICR1Vzj4oVLbS+lPDfJbWe2IgAAAICRWVzj4p1JHjODHAAAAIBdzKK4uHeSq2eQAwAAALCL1Vyc891jm9YlOTzJXZIs+TASAAAAgD5Wc3HOb429/4MkFyQ5sdZ6zuyWBAAAANBZzcU5nzjkQgAAAADGreaMiyRJKeVHk/xkku1JvlBr/e+ZrwoAAAAgq7vGxYFJ3pjkYekeJpIk60opZyZ5Uq31ygHWBwAAANyEreZZRU5Ncuck90my7+jlF0bbXj37pQEAAAA3dat5qMiDkxxTa/2XRds+Ukp5cpKzkjxppisDAAAAbvJWc8bFvrnhM4skyeVJ9pnNcgAAAACut5ri4uNJ/rCUst+ODaWUmyV5YZJPzHphAAAAAKt5qMizk3wgyf+UUj432nanJNckud+sFwYAAAAw8RkXtdbPJ/nxJMcn+fTo5fgkt6+1XjDM8gAAAICbstU8HeqLk3y11vrnY9ufUkq5Va31D2a+OgAAAOAmbTXXuHhckvOW2P5vSR4/m+UAAAAAXG81xcUhSb6xxPZvJjl0NssBAAAAuN5qiouvJLnXEtvvneRrs1kOAAAAwPVW86wir0tySillU5J/HG37hSQvTfLyWS8MAAAAYOLiotb6x6WUWyR5TZJNo83XJTm11nryEIsDAAAAbtpW81CR1FpPSHKLJD87etlSa33eEAsDAAAAWM1DRZIktdbvJvnUAGsBAAAA2MWqzrgAAAAAWEuKCwAAAKBZigsAAACgWYoLAAAAoFmKCwAAAKBZigsAAACgWYoLAAAAoFmKCwAAAKBZigsAAACgWYoLAAAAoFmKCwAAAKBZigsAAACgWYoLAAAAoFmKCwAAAKBZigsAAACgWYoLAAAAoFmKCwAAAKBZigsAAACgWRv29ALGlVIOT/KyJPdPckCS/07y1FrrP49uX5fkBUmenOTgJOcmObbWesGeWTEAAAAwlKbOuCilbE7y8STrkjwgyR2THJfkskV3Oz7J7462331024dKKQes7WoBAACAobV2xsXxSS6utT5+0baLdrwxOtviWUleVms9c7TtCenKi0cned0arhUAAAAYWFNnXCQ5Jsm5pZS3l1IuK6V8tpTy9FFhkSS3S3JYknN2fECt9ZokH01y5NovFwAAABhSa2dc/GiSpyU5Jd11Lo5I8iej2/40XWmRJJeOfdylSW61Uvj69euyefN+s1npyKzz5jV3yOx5yx0ye95yh8yet9whs+ctd8jsecsdMnvecofMljt89rzlDpk9b7lDZs9b7pDZ85Y7ZPa85Q6ZPW+5Q2avlNtacbFXkk/XWk8YvX9eKeXHkxybrrjoZdu27VlYuDpbtszuchgLC1fvfHuo3FlmD5U7nm1fDL8v5mEfj2fPW+6Q2fOWO2T2vOUOmT1vuUNmz1vuLLPnfR/PMtu+GD53PHvecofMnrfcIbPnLXfI7HnLHTJ71rnL5bX2UJGLk/zH2LYvJLnN6O1LRq8PHbvPoYtuAwAAAG4kWisuPp6kjG27Q5Ivj96+KF1BcfSOG0sp+yS5V5JPrMUCAQAAgLXT2kNFTknyiVLK7yd5e5K7JHlGkhOTpNa6vZTy6iQnllIuTPLFJM9PclWSt+yZJQMAAABDaeqMi1rrp9I9s8ivJTk/yYuT/EGS1y6628npCo7Tknw6yeFJ7ldrvXJtVwsAAAAMrbUzLlJrfW+S9y5z+/YkJ41eAAAAgBuxps64AAAAAFhMcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0S3EBAAAANEtxAQAAADRLcQEAAAA0a8OeXsBySiknJHlJktNqrU8fbVuX5AVJnpzk4CTnJjm21nrBHlsoAAAAMIhmz7gopfxsunLic2M3HZ/kd5Mcl+TuSS5L8qFSygFru0IAAABgaE0WF6WUg5K8Ocn/SfLtRdvXJXlWkpfVWs+stZ6f5AlJDkjy6D2xVgAAAGA4TRYXSf4iyRm11n8a2367JIclOWfHhlrrNUk+muTItVseAAAAsBaau8ZFKeW3ktw+yWOXuPmw0etLx7ZfmuRWK2WvX78umzfv12+BY2adN6+5Q2bPW+6Q2fOWO2T2vOUOmT1vuUNmz1vukNnzljtkttzhs+ctd8jsecsdMnvecofMnrfcIbPnLXfI7HnLHTJ7pdymiotSSkl3Mc571lq3zjp/27btWVi4Olu2zO5yGAsLV+98e6jcWWYPlTuebV8Mvy/mYR+PZ89b7pDZ85Y7ZPa85Q6ZPW+5Q2bPW+4ss+d9H88y274YPnc8e95yh8yet9whs+ctd8jsecsdMnvWucvlNVVcJLlHklskuaDrMJIk65Pcu5TylCQ/Ndp2aJKvLPq4Q5NcslaLBAAAANZGa9e4eFeSOyU5YtHLp5O8bfT2F9MVFEfv+IBSyj5J7pXkE2u9WAAAAGBYTZ1xUWtdSLKweFsp5btJLh89g0hKKa9OcmIp5cJ0Rcbzk1yV5C1rvFwAAABgYE0VFxM6Ocm+SU5LcnCSc5Pcr9Z65R5dFQAAADBzzRcXtdajxt7fnuSk0QsAAABwI9baNS4AAAAAdlJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM3asKcXsFgp5YQkD01Sklyb5F+TnFBrPX/RfdYleUGSJyc5OMm5SY6ttV6w9isGAAAAhtTaGRdHJXltkiOT3DfJ95N8uJRy80X3OT7J7yY5Lsndk1yW5EOllAPWdqkAAADA0Jo646LW+kuL3y+lPC7JFUl+LsnZo7MtnpXkZbXWM0f3eUK68uLRSV63tisGAAAAhtTaGRfjDki3xm+P3r9dksOSnLPjDrXWa5J8NN1ZGgAAAMCNSFNnXCzh1CSfTfLJ0fuHjV5fOna/S5PcaqWw9evXZfPm/Wa3umTmefOaO2T2vOUOmT1vuUNmz1vukNnzljtk9rzlDpk9b7lDZssdPnvecofMnrfcIbPnLVNC8SsAABfZSURBVHfI7HnLHTJ73nKHzJ633CGzV8pttrgopbwqyT2T3LPWum0Wmdu2bc/CwtXZsmV2l8NYWLh659tD5c4ye6jc8Wz7Yvh9MQ/7eDx73nKHzJ633CGz5y13yOx5yx0ye95yZ5k97/t4ltn2xfC549nzljtk9rzlDpk9b7lDZs9b7pDZs85dLq/Jh4qUUk5J8utJ7ltr/e9FN10yen3o2Iccuug2AAAA4EaiueKilHJqri8tLhy7+aJ0BcXRi+6/T5J7JfnEmi0SAAAAWBNNPVSklHJaksclOSbJt0spO65pcVWt9apa6/ZSyquTnFhKuTDJF5M8P8lVSd6yRxYNAAAADKap4iLJ00av/2Fs+wuTnDR6++Qk+yY5LcnBSc5Ncr9a65VrsUAAAABg7TRVXNRa101wn+3pSoyThl4PAAAAsGc1d40LAAAAgB0UFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzFBcAAABAsxQXAAAAQLMUFwAAAECzNuzpBUyrlPK0JM9NcniSC5I8q9b6L3t2VQAAAMAszeUZF6WURyY5NclLktwlySeSvL+Ucps9ujAAAABgpuayuEjy7CSn11pfX2v9Qq31uCQXJ3nqHl4XAAAAMENzV1yUUjYluWuSc8ZuOifJkWu/IgAAAGAo67Zv376n17AqpZRbJvmfJD9fa/3oou3/b5LH1FrLMh/+jSRfHniJAAAAwOrcNsmWpW6Y24tzTmnJnQAAAAC0ae4eKpLkm0m2JTl0bPuhSS5Z++UAAAAAQ5m74qLWel2SzyQ5euymo9M9uwgAAABwIzGvDxV5VZK/KaX8f0k+nuQpSW6Z5M/36KoAAACAmZq7i3PuUEp5WpLjkxye5Pwkv7P4Yp0AAADA/Jvb4gIAAAC48Zu7a1wAAAAANx3zeo2LQZRS7p3kOUnumu6aGU+stZ4+g9wTkjw0SUlybZJ/TXJCrfX8nrnHJvntJD8y2nRBkj+qtb63T+4Sn+eEJC9Jclqt9ek9s05K8oKxzZfWWg/rkzvKPjzJy5LcP8kBSf47yVNrrf/cI/NL6Z5PeNz7aq0PmDZ3lL0+yUlJHpvuIU8XJ3lzkpNqrd/vmX1Akj9M8pAkhyQ5L8kza62fWkXGsvNQSlmX7v/yyUkOTnJukmNrrRfMIPuh6b62fzrJLZLcp9b6kT65pZSNSf4oya8k+bEk30nyT0meV2v9Ss/1/mGSRyT54STXJfm3JH9Qa13xgsGr+b5TSnlduv393FrrK3uu+fQkTxj7sHNrrT/bd72llDukm8X7JtmU5MIkj6m1fqHnmnd3iuBra63H9sjdP8lL083LDyX5SpI/r7We0nO9hyZ5eZL7Jdmc5KNJjqu1/ucKuSseM6aZvwlzp529ZbOnnb8J17zq+VvtcXmVszfJmk/PKudv0jWvdv4mXO+0szdJ9qrnb8LcVc/fSj9X9TzurZQ97eztNrfncW+l9fY57k388+sqZ2+lNZ+e6Y57K653muPeBOudau4mzJ72uLdS7lTHvSU+zw1+9+gzfyvkTjV7K2X3mb8J1jz1/C2XO3b7xLM34ZpPzxTzt5gzLna1f7rrZTwzyTUzzD0qyWuTHJnuG9r3k3y4lHLznrlfS/J76Qbtbkn+Mcm7Sil37pm7UynlZ9N90X5uVplJarpf1He83KlvYCllc7oLta5L8oAkd0xyXJLLekbfPbuu9aeTbE/ydz1zk+7/7tgkz0jyE+m+7o5NcsIMst+Q5JfSfYO4U5Jz0n3N3WoVGSvNw/FJfjfdfr57un39oVFp0jf7ZumeJejZq1jvSrn7pfv/e/Ho9a+m+4b/gVLKSiXuSuut6f7v7pTknkkuGuWOP23zNNlJklLKw5P8TJKvT5A5ae6Hs+vX9/375pZSbpduFi9K9/3ufyV5fpKrZrDmw8deHjTavtI8rpT7qnTfNx6X7nvHi5O8rJTyuGlzRz9gvSvJjyc5Jsldknw53RzebIXco7LyMWOa+Zskd9rZWyl72vmbZM3TzN8kuUmmmr1Js1c7fyvmTjl/k6x32tmbJHua+Vs2t8f8rfRzVZ/j3krZ087ecrl9jnsrrbfPcW+in1+nmL1Jcqc57i2b2+O4t9J6p527SbKnPe7tNrfncW+nZX736DN/y+VOO3srZfeZv5XW3Gf+Vvz9borZmzR7mvnbyTUudqOUclWSp8/ijIslsvdPckWSY2qtZ884+/J0f3V43QyyDkrX4P1muobz/BmdcfHwWuv/6ru+sdyXJPn5WuvPzTJ3ic/z+0mem+TwWmuvcquU8p4k36q1PmHRtr9O8kO11gf2yN03yZVJHlZr/ftF2z+T5P211udPkbnLPIwOTl9P8qe11hcv+ryXJXnOar7+lpu1UsotknwjU7Tfk8xwKeUn0/214M611s/PMPfAdDP+y7XWD/ZdcynltukOqr+Y5P3p9vvE7fdSuaPm+xY9v9aWyn1Lku211sdMm7u77CXu8/ok9661lj65pZTzk5xZa33Bom3/nOTzk37PW2JG7pDuB4sjaq3/Ptq2V5JLkpxYa33DKta8yzFjVvO33LGoz+ytlL3oPtPM3yS5q56/3eX2nb3dZc9o/pbK7T1/E+7jVc/eMmuexfyNz8gs5+/ydH9Q+IvM6Lg3nr34Y/vO3u5yF9226rmbMHeq497usmcxe+O5s5i73eTO5Lg3nrvEbVPN3VLZs5i78dx0ZxP0mrvd/e7R97g3ye80087ean5fWs38rTJ34vlbKbfP7C2XPYv5c8bFnnFAun3/7VkFllLWl1Iele4vgBOfJrSCv0hyRq31n2aUt8OPllK+Xkq5qJTytlLKj84g85gk55ZS3l5KuayU8tlSyo5vdDMxynpSkr/tW1qMfCzJfUopPzHK/8l0Tf37euZuSLI+yffGtl+TrpWdhdslOSzdmRxJktE++Wi6v4DNiwNHr2c5i5vSNc3fSfLZGeRtSPLWdKdiLvtQiyncczQvXyylvL6UckifsNEPKA9K8h+llA+UUr5RSvlUKeWRs1nuLp9r/ySPSvL6GcR9LMmDSik/PMo+MskRST7QI3Pv0eudc1hr/UG609pXO4fjx4xZzd/Mj0WrzJ5m/pbN7TF/N8id4eztbs1952+X3BnO30r7uM/sLZU9i/kbz+09f0v8XDWz495AP7NNmrvquVspt89xb6nsWczeMmvuNXfjubOauwn28dRzt5vs3nO3RO4sjnu7+92j7/wN9TvNarNXM38T5U4xf7vNncHsrbTmXvPnGhd7xqnpvrA+2TeolHKnUc4+6U5Je8hqG/Td5P5Wktunu/7CLJ2b5DfSPfbvkHSn0n2ilPJTtdZv9cj90SRPS3JKuscYHpHkT0a3/WmP3MWOTveNcxa/KCXdYwAPSHew25ZuHl9ca31tn9Ba65WllE8mef6oUb8kya8nuUeS/+q55h12XJPk0rHtlyZZzcNR9pjRN/o/TnJ2rfVrM8h7YJK3pTs18OIkR9dax/fPNF6Y5Ju11j+bQdZiH0jyznSnF/5Iusdh/mMp5a611munzDwk3Q8wJyb5gyTPS1fGvbmUclWd7fV3Hp3uccR/PYOsZyR5XZKvlFJ2XF/muFrre3pkXpjuMcMvGX0/vSrJ7yS5dbrTI1dj/Jgxq/mb2bFotdk95m/J3BnM31K5s5q9pbJnMX/jubOav5W+LvrM3lLZs5i/8dyp5293P1eNfrFLeszdgD+zTZS72rlbKbfP3K2QPfXsrZA79dwt83VxWHrM3Sq+JlY9dytkTz13y+yLjelx3Fvhd4+pj3sD/k6zquzVzN8kudPM3wS5fWZvpezexz3FxRorpbwqXet4z1rrthlE1nS/pB+U5OFJ/rqUclTtceHPUkpJd0GVe9Zat85gjTvVWt8/9rn+Nd1FNJ+Q7vF209oryadrrTuuD3FeKeXH0z3+a1bFxW8l+dSO099m4JFJHp/uYHRBuv/HU0spF9Va39gz+3FJ/jLdYxG3pTtt663pLiJ4kzdqlP823YWjHjyj2H9K9394i3RfK39XSrlHrfXiaQNLKUelK/qOmMUCF6u1vm3Ru58v3UOJvpzuMa/vnDJ2x1l8f19r3THPny2l3C3J05PMsrj4rdHn+cYMso5L9xebB6fbB/dO8spSypdqrVOddVFr3Vq6C369Mcm30s3hh9OddjnxmWADHDMGzZ0ke9r5WyF36vlbKndWs7e7Nfedv93k9p6/Cb8uppq9ZbJ7zd9SuT3nb8mfqyb9d06T3edntklzp5y7lXL7HPd2t59vkX6zt9s195y73a338tHt087dpF8T08zdctl95m63udPO3VC/ewz5O81qslczf6vIXdX8rZTb57g3yZpn8XOn4mINlVJOSXea131qrf89i8xa63W5/q/onyml3D1du/mkHrH3SDcEF3Rfh0m6hx7cu5TylCQ36/EX2V3UWq8qpVyQ7kI+fVyc5D/Gtn0h3UXzehudyvSr6YqQWXlFklcuGuTPl+5xZSek+6Y/tVrr/5/k50t3MaQDa60Xl1Lenq4kmoVLRq8PTdeuZ9H7l9zw7u1YdBrcnZIc1fNMn51qrd9NN4v/leRfSyn/me4xfn/YI/aojJ5xZmwWX15KeVat9dY9sndRa/16KeVr6TeL30x3kbylZvFRPXJ3UUo5It1FwU6cQda+6a6s/oh6/eP5Pzf6HM9Jj4eL1Fo/k+SI0j3mc1Ot9RullHOTfHrCte3umNFr/oY4Fk2aPe38rZQ77fwtk3tUes7eavbzauZvmdxe8zfJeqedvd1l952/5dY87fwt83PVi0fbpj7uDfQz24q5087dSrl9jnvLZH81PWZvNft4NXO3TO5T02PuJlnvtHO3u+xSytPTY+6WW3OP495Kv3v81GjbaudvyN9pJsqeYv4myp1i/lbKfUWmn71V7+dpfu5UXKyRUsqp6f7Cfp9a64UDfqq9cv1jzKb1rtzwG8xfJfnPdG3adT3zdyql7JPuGTX6Pubs40nGL1Z0h3RN3iz8RrrH6L11RnlJd2rX+F+0tmWG154ZfVP7binl4HTPMnL8jKIvSnegODrJp5Kd/5f3Snfx0iaV7jTGt6W74vdRtdYhS5ZZzOJrk5wxtu2D6b4OZ/WQpSQ7L0p1q3Ql4FRqrdeVUj6VYWcx6R7LeVG6v+T0tXH0Mtgs1lqvSJLSnQV2t3SnEy9rhWPG1PM35LFopexp52/KNa84fyvk9pq91a550vlbLrfP/K1ivauevRWyp56/Sdc8zfyN2fG1NMRxbxbHiWVzZ3zcW2m9ff49Oz521se93a6p53FvryR7D3DcW2q9szrm7cie9XHvBmueYu5W+t3ji5lu/ob8nWbF7Cnnb9o1rzR/K+V+I8mbx26fdPZWveZp5k9xsUjpLnxz+9G7eyW5zah9vLyu4vl2l8g9Ld2p+8ck+XbpHg+XJFfVWid5isDd5b4s3SloX013rYRHp/sr0QOmzUySWutCkoWxz/XddPuh1+mMpZRXJjk7XVt6SLpvZDdL/8epn5LuWhm/n+Tt6Z6C6RmZzV9k16VrMN/W5/9rCWcneV4p5aJ0DxW5S7qnYnpT3+BSyi+l+xq+MN3X9CtGb//VKjKWnYdSyquTnFhKuTDdAWXHU3+9ZQbZN09ym3Sn1CXJ7UspC0kuWe6b/nK56a5G/Y50T6H1oCTbF83iFXWZC66ukLuQrhA6O9033y3pzsy5dSZ4yrIJvu9cNnb/raP9UKfNHb2clOTM0Zp/JN1fXy5LclbP9Z6c7nTFf0n3NGn3SfdXp2OWy50wO6WU/ZI8JsnJtdaJnhZrgq+3f073NHBXpftB8+fTPYxr2aJvgtxHpPsr+JfT/aXl1CTvqrWes2Tg9bnLHjNqrdunmb9JjkU9Zm/Z7NFfnFY9fxPkHpgp5m+CfXxZpp+9lda8f6aYvwl/llj1/E36M8qUs7fSfv7ONPM34dfyqudvuZ+rpp27SbJHt087e7vNnXbuJsidau4mye45e8uteaq5Wyl3dJepjnuT/Bw/zdytlD3t3E2y5mmPe5P87jHN/E2YO9XsrZQ97fxNkHtgKWXV8zfh73eXjt0+0exNsOb9S/fMkquev8U8q8iu7pbkvNHLvukuUHJekhf1zH1auuH+h3T/WTtentMz97B0j5eqo+y7J/mVOnYdicbcOl1zV9M9nunaJD9ba+3119ha66fSHSB+Lcn56U7p/IN0zX1fR6U7jWmmf+FO9/jCM9Kt8QvpLtjz+iS/P4Psg9Jd2+PCdEXIx5L8Ul3d4/tWmoeT0xVGp6VrWQ9Pcr9a65UzyH7w6P0dZ+K8fvT+U3rk3jrdw31umeQz2XUWV7r693K53093CuNZ6Zrls5P8ULqnLFvy+bFXkd3Hcrnb0v1A8ffpDv5/nW4m7zHB/9+y6621vivdX4eek+Tz6b7OH18nuzDgJPvikenKzolLuAlyH5XuLzhvTne67/PSff9Y6fo4K+Uenm7+LkzymiR/k+5CuSuZ5JgxzfxNkjvt7K2UPe38rZQ77fwNdVyeJHva+VtxzVPO36T7YprZmyR7mvmbJHea+Vvp56o+x72VsqedveVy+xz3lsvte9wb6ufX5XL7HPeWXW+P494k+2GauZske9rj3kq50x73JtFn/pYz7eytpM/8Lafv/O0JfeZvp3Xbt09c3gEAAACsKWdcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM1SXAAAAADNUlwAAAAAzVJcAAAAAM3asKcXAADc9JRStiR5YZL7Jzk8yUKS85O8rNb6oVLKl5L8aa31lXtskQBAE5xxAQDsCWcm+ZkkT0pyhyQPTPL+JD80y09SStk0yzwAYO2t2759+55eAwBwE1JK2Zzk20mOrrV+eInbP5Lk5xdvq7WuG9320HRnatwhyWVJ/jzJS2qt20e3fynJ6Uluk+ShST5Ua31EKeXIJC9NcvfR5353kt+rtX5n5v9AAGCmnHEBAKy1q0YvDy6l7LPE7Q9N8rUkL0r3MJLDk6SUctck70jyziR3SvK8JCckefrYxz87yYVJ7pbkxFLKnZKck66s+H9G+Uck+cuZ/qsAgEE44wIAWHOllIcleX2S/ZKcl+TjSd5Raz13dPuXMnaNi1LKm5McXmu976JtJyX5zVrrrRd93OdrrQ9adJ83Jdlaa33Som1HjD7vobXWywb5RwIAM+GMCwBgzdVaz0xyyyQPSndtiyOT/Gsp5cRlPuyO6QqOxT6W5FallAMXbfv02H3umuSxpZSrdrwsyvmxaf8NAMDa8KwiAMAeUWv9XpIPjV5eVEp5Q5KTSinTPJPI4lNIvzt2215J3pDklCU+7n+m+FwAwBpSXMD/be9uVa2IwjgO/8BiNwu2EbwEP+7AJOIlGA2C0SgabAYtJjl3YbAJwgEPfrBAm0U0eSyaDDPphJ22mxWeB6bMDPPOasOfWe8LwCw+tX6bnK/+VufOXP9cXT1z7lr1bYxxuuO5x9WVMcaXfb0oAHA4ggsA4KCWZbnQ2mTzZXVSnbY20nxQvR5j/Np6VVxfluVV9WeM8bN6Wr3b+loctU4IuV/t2l5S9aR1G8rz6sVW73J1c4xxd7+rAwD2TY8LAODQfldvq3vVm+pj9ag1jLiz3fOwulh9rX5UjTGOq9vVrepD9Xg7nu0qNsY4qW5Ul7Z671tHo37f35IAgP/FVBEAAABgWv64AAAAAKYluAAAAACmJbgAAAAApiW4AAAAAKYluAAAAACmJbgAAAAApiW4AAAAAKYluAAAAACmJbgAAAAApvUPVmO+ykVjQgUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize= (18,8))\n", + "sns.countplot(x= 'Store', data= df);\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4D0pl3sXZ6Bt" + }, + "source": [ + "All the store have equal number of data in the set " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 81 + }, + "id": "KSXkCVMiaQet", + "outputId": "4931b89f-f270-42e7-bbc1-35224ece8d77" + }, + "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", + "
StoreWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemploymentweekdaymonthyear
011643690.9042.312.572211.0963588.106652010
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Weekly_Sales Holiday_Flag Temperature Fuel_Price CPI \\\n", + "0 1 1643690.9 0 42.31 2.572 211.096358 \n", + "\n", + " Unemployment weekday month year \n", + "0 8.106 6 5 2010 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To analyze the distribution of the data, I plotted the histogram and boxplot for Temperature, Unemployment, Fuel_Price, CPI." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 940 + }, + "id": "tOLH3pvoZkbU", + "outputId": "0af62c08-add8-431d-d5e4-95ebc583c125" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(4, 2, figsize=(16, 16))\n", + "# axes[0,0].set_title('Temperature')\n", + "sns.histplot(x= 'Temperature', data= df, ax= axes[0,0])\n", + "\n", + "sns.boxplot(x= 'Temperature', data= df, ax= axes[0,1])\n", + "\n", + "# axes[1,0].set_title('Unemployment')\n", + "sns.histplot(x= 'Unemployment', data= df, ax= axes[1,0])\n", + "\n", + "sns.boxplot(x= 'Unemployment', data= df, ax= axes[1,1])\n", + "\n", + "# axes[2,0].set_title('Fuel_Price')\n", + "sns.histplot(x= 'Fuel_Price', data= df, ax= axes[2,0])\n", + "\n", + "sns.boxplot(x = 'Fuel_Price', data= df, ax= axes[2,1])\n", + "\n", + "# axes[3,0].set_title('CPI')\n", + "sns.histplot(x= 'CPI', data= df, ax= axes[3,0])\n", + "\n", + "sns.boxplot(x= 'CPI', data= df, ax= axes[3,1]);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y6eCaSOXekvp" + }, + "source": [ + "**Insights:**\n", + "\n", + "* Temperature: Crossponding to the lower temperature, there is a presence of outlier.\n", + "* Umemployment: The outlier is present in the dataset crossponding to higher and lower both values.\n", + "* CPI: It is either very low or very high." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-EmN6ZTra1Hr" + }, + "outputs": [], + "source": [ + "# Removing the outlier from Temperature column\n", + "\n", + "Q1 = df['Temperature'].quantile(0.25)\n", + "Q3 = df['Temperature'].quantile(0.75)\n", + "IQR = Q3 - Q1\n", + "df = df[df['Temperature'] <= (Q3+(1.5*IQR))]\n", + "df = df[df['Temperature'] >= (Q1-(1.5*IQR))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "U4R3Kqgn-_vB" + }, + "outputs": [], + "source": [ + "# Removing the outlier from Unemployment column\n", + "\n", + "Q1 = df['Unemployment'].quantile(0.25)\n", + "Q3 = df['Unemployment'].quantile(0.75)\n", + "IQR = Q3 - Q1\n", + "df = df[df['Unemployment'] <= (Q3+(1.5*IQR))]\n", + "df = df[df['Unemployment'] >= (Q1-(1.5*IQR))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yVemcM-M_Mxv", + "outputId": "4922b35f-827c-4c02-bd28-dd6ad6430ccb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(5951, 10)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cBBEn2FE_ZA-" + }, + "source": [ + "On the process of removing outlier, **484 data** points are removed from data-set" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rFMweINACZvn" + }, + "source": [ + "## Encoding" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Encoding is a process to convert the categorical columns into a numerical columns, as it is not a good preactice to train a model with categorical inputs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "pO1uOasqGBeF" + }, + "outputs": [], + "source": [ + "cat_cols = ['Store', 'Holiday_Flag', 'weekday', 'month', 'year'] # these are the categorical columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "x5k8sIgQF4dX", + "outputId": "9e9bd9cd-7a26-4c35-e2d9-371c04dbdbe0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Store 45\n", + "Holiday_Flag 2\n", + "weekday 7\n", + "month 12\n", + "year 3\n", + "dtype: int64" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[cat_cols].nunique() # Counting the unique value in each of the categorical columns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "glaMQs6fGJl4" + }, + "outputs": [], + "source": [ + "# Imported OneHotEncoder to perfrom the encoding\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "# Creating a object of the encoder function\n", + "encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n", + "# Fit the encoder object to the dataset which i want to convert into numerical form. \n", + "encoder.fit(df[cat_cols])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vv6dMsDNGZFT" + }, + "outputs": [], + "source": [ + "# Creating a list of the encoded columns \n", + "encoded_cols = list(encoder.get_feature_names(cat_cols))\n", + "print(encoded_cols)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ldtCeFZRGm7A" + }, + "outputs": [], + "source": [ + "# Now i added those encoded columns into the original dataset by transforming it into a categorical form.\n", + "df[encoded_cols] = encoder.transform(df[cat_cols])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YIJJkqjtD-j3", + "outputId": "ac67c455-7867-416a-fd82-b149257d8701" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(5951, 79)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LXQ5SY-r_-ak" + }, + "source": [ + "## Standardization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To scale all the column values to specific range of 0 - 1, I used standard scaler function. It is important to give the equal weights to all the columns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "exI_1mV__UxE" + }, + "outputs": [], + "source": [ + "# Importing a MinMaxScaler\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "# Creating Scaler Object\n", + "scaler = MinMaxScaler()\n", + "# Fitted the scaler to the dataset\n", + "scaler.fit(df)\n", + "# Transformed the dataset using the fitted scaler object \n", + "scaled_df = scaler.transform(df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V9uWoyqPA1BS" + }, + "outputs": [], + "source": [ + "# Converting the output scaled dataframe into a pandas dataframe\n", + "scaled_df = pd.DataFrame(data = scaled_df, columns = df.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 237 + }, + "id": "c3VW-LArA4mN", + "outputId": "741afdf9-2629-4e22-bafd-4a58678396de" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StoreWeekly_SalesHoliday_FlagTemperatureFuel_PriceCPIUnemploymentweekdaymonthyear...month_6month_7month_8month_9month_10month_11month_12year_2010year_2011year_2012
00.00.3972910.00.3760250.0501000.8405000.5738891.0000000.3636360.0...0.00.00.00.00.00.00.01.00.00.0
10.00.3968111.00.3350240.0380760.8419410.5738890.5000001.0000000.0...0.00.00.00.00.00.01.01.00.00.0
20.00.3885010.00.3503450.0210420.8424050.5738890.6666670.0909090.0...0.00.00.00.00.00.00.01.00.00.0
\n", + "

3 rows × 79 columns

\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Store Weekly_Sales Holiday_Flag Temperature Fuel_Price CPI \\\n", + "0 0.0 0.397291 0.0 0.376025 0.050100 0.840500 \n", + "1 0.0 0.396811 1.0 0.335024 0.038076 0.841941 \n", + "2 0.0 0.388501 0.0 0.350345 0.021042 0.842405 \n", + "\n", + " Unemployment weekday month year ... month_6 month_7 month_8 \\\n", + "0 0.573889 1.000000 0.363636 0.0 ... 0.0 0.0 0.0 \n", + "1 0.573889 0.500000 1.000000 0.0 ... 0.0 0.0 0.0 \n", + "2 0.573889 0.666667 0.090909 0.0 ... 0.0 0.0 0.0 \n", + "\n", + " month_9 month_10 month_11 month_12 year_2010 year_2011 year_2012 \n", + "0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 1.0 1.0 0.0 0.0 \n", + "2 0.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "\n", + "[3 rows x 79 columns]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Checking the output dataframe\n", + "scaled_df.head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QIAMnLaPA_LV" + }, + "source": [ + "## Train-Test-Split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Split the dataset into the two part: \n", + "1. Training dataset (used to train the model)\n", + "2. Testing dataset (used to test the model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gOh0w-0aA7vG" + }, + "outputs": [], + "source": [ + "# Drop the sales columns to get the input features\n", + "X = scaled_df.drop('Weekly_Sales', axis=1)\n", + "# Use the sales column as a target columns\n", + "y = scaled_df['Weekly_Sales']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eMBXWBsOBNzU" + }, + "outputs": [], + "source": [ + "# Importing train test split\n", + "from sklearn.model_selection import train_test_split\n", + "# dividing the dataset into the train and the test parts and each part has input feature and target features\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oX6elOYdBQS_", + "outputId": "9dfc3165-66b9-476f-9c50-b398d17963a4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((4760, 78), (1191, 78), (4760,), (1191,))" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Printin the shape of all the dataset\n", + "X_train.shape, X_test.shape, y_train.shape, y_test.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2JEIeQ5jHKpw" + }, + "source": [ + "## Feature Selection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Out of all the 78 features all are not important and we have to choose the important feature out of all the features" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kGByOHPPFS2F" + }, + "outputs": [], + "source": [ + "# import a linear regerssion model\n", + "from sklearn.linear_model import LinearRegression\n", + "# import a Random Forest Regressor model\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "# import a mean squared error for model evaluation\n", + "from sklearn.metrics import mean_squared_error\n", + "# import a r2 score for model evaluation\n", + "from sklearn.metrics import r2_score\n", + "# import a RFE model for feature selection\n", + "from sklearn.feature_selection import RFE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "APc3ReipKEUV" + }, + "outputs": [], + "source": [ + "# Creatint a list to store training and test error \n", + "Trr=[]; Tss=[]; n=3\n", + "order=['ord-'+str(i) for i in range(2,n)]\n", + "Trd = pd.DataFrame(np.zeros((10,n-2)), columns=order)\n", + "Tsd = pd.DataFrame(np.zeros((10,n-2)), columns=order)\n", + "\n", + "m=df.shape[1]-2\n", + "for i in range(m):\n", + " # creating a linear regression model object\n", + " lm = LinearRegression()\n", + " # creating a rfe model object with linear regression model and with a parameter of the number of features \n", + " rfe = RFE(lm, n_features_to_select=X_train.shape[1]-i)\n", + " # fitting the rfe model to the trainig dataset\n", + " rfe = rfe.fit(X_train, y_train)\n", + " # creating a linear regression model object for prediction\n", + " LR = LinearRegression()\n", + " # fitted the lr model using the selected features\n", + " LR.fit(X_train.loc[:,rfe.support_], y_train)\n", + " # Made the prediction using the linear regression model\n", + " pred1 = LR.predict(X_train.loc[:,rfe.support_]) # make the prediction on the trainig dataset\n", + " pred2 = LR.predict(X_test.loc[:,rfe.support_]) # make the prediction on the test dataset\n", + " # Insert the mse into the Trr and Tss for train and test respectively\n", + " Trr.append(np.sqrt(mean_squared_error(y_train, pred1)))\n", + " Tss.append(np.sqrt(mean_squared_error(y_test, pred2)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 378 + }, + "id": "NjmxXDHsqtjJ", + "outputId": "d367acd0-8c1c-4f4f-f737-5de31e50d296" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAFpCAYAAAA/eUS4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUxf7H8ffuJpveCL33Qy+CIIpKFQQEO7/rvV57QwQsYMHuRcVeEcSC/ap4VZBebCCCoEg/ICWgECBAetns7vn9kUAEUjaQTTbJ5/U8ebJ7zsyc744rfJkzZ8ZmWRYiIiIiUv7sFR2AiIiISHWlRExERESkgigRExEREakgSsREREREKogSMREREZEKokRMREREpIIEVXQAp8Lr9Voej/+X3XA4bJTHdQKd+qGA+qKA+qKA+iKP+qGA+qKA+gKCgx1JQK3CzlXKRMzjsUhOzvT7dWJjw8vlOoFO/VBAfVFAfVFAfZFH/VBAfVFAfQG1akUlFHVOtyZFREREKogSMREREZEKokRMREREpIIoERMRERGpIErERERERCpIpXxqsjiWZZGenkJWVjper+e02tq/34ZlVe9HbqHy9ENQkJO4uFo4HFXuay0iIlVUlfsb68iRg9hsNmrUqIPDEYTNZjvlthwOOx6Ptwyjq5wqQz9YlkVGRipHjhykZs16FR2OiIiIT6rcrUmXK5vY2HiCgoJPKwmTysVmsxEREY3b7aroUERERHxW5RIxsLDZquDHkhIp8RYRkcpGGYuIiIhIBVEiJiIiIlJBqtxkfSkwadKjpKQk88wzL1V0KCIiUl24s7BnH8GWdQR79mFsh50EZ4PlcGI5QsARguVwgiMYsAH5T+Uf93R+EU/qW4DlAa8bW/5vvB5sljvvtc0ONgeWzQH2vNd57+1gDwJ7/nt7UF5ZezCWM9K//VECJWIBoHfv7sWev/DCYUyc+Gip2x079p7TXnbi119XM2bMrcfeR0fH0LJlK2688VY6depy7Pjbb0/j3Xen063bmbz88hvHtfHllzN5/vmnadasOR988BkAHo+HTz75gHnzviExcR/BwU4aNGjI4MFDueKK/zuuzRPVqBHPrFkLTutziYhIKbgyCDVnYs86hC03o+DHlYEtNx2bKw171uG8xMuddVL12AoI2VdpfZ4mu/2/Kuz6SsQCwNdfzz/2+qefljF58n+OOxYSEnpcebfbTVBQyf/pIiPLLsv/4IPPiI6OJjk5mffee5sJE8bxySf/Iy6uxrEy8fHxrFu3ln379lKvXv1jx7/55mvq1Kl7XHvvvjudL7/8nDvvnEDbtu3Jzs5m69Yt7N+feFy5xo2b8Oqr0447Zrc7yuxziYhICXIzifnm3zj3rQTACgrFCo7ECo7I+3FG4g2vhSe+Dd7QGnhD47DC8n+HxhEZFU56cio2Tw54crB5XPm/cwuuYTvpBRTxAFbeaJcjbzTL5sgf6cof4bKsvBEzy5M/UuY99hrLkz+Klv/a6wbLwtWkv3/6zUdKxAJAfHzNY6+PJk9Hj+3bt5cRIwbzyCP/Yfbsr9iwYT233z6GAQMG8cILz7Bu3VpSUlKoX78B//jHvxg6dPixtk68NTl69M00bdqcqKgoZs36HzabncGDhzJq1Bjs9uKnC8bF1SA2Npb4+Jpcc80NLF26iI0bN9C793nHykRHx9C+fSfmzp3NDTfcAsAff2xj9+5dDB9+KatWrThWdtmyHxgx4jIGDBh07FiLFi1Puq7D4Tiuf0REpBzlZhEz51qCE38hdeBr5LQclpf0lIIVG05uVKafAqz8qkUiNmfjfmZtSCy54AlsthNuWZfC8A51Gdq+zqlVLsS0aa9z++1jue++hwgKCsLlcmEYbfjXv64hPDyC1atX8eyzT1KnTl26d+9RZDuLFs3jiiv+wRtvvMO2bVt5/PEHMYw2DBw42Kc4srOzmTt3NkCho3LDho3ghRcmc911N2G32/nmm6/p23cA4eHhx5WrUSOe335bw+HDh6hRI74UPSEiIuXCnU3MvBsI/msFaQNeIqf1xRUdUZVULRKxquCyy0bSt++A445dddW/j71u0KAhv/76C4sXLyg2EWvatDk33pg356tx4ybMnv0la9b8UmIidsUVFwF5iZhlWbRp067Q6/Ts2Qu3282aNavo3PkMFi6cx1NPPc/q1SuPK3fHHXfy0EP3MmLEYJo0aUaHDh3p1esczjuv73HrgSUk7GLgwHOPq3v22efy2GNPFhuviIicBk8O0fNuInjPj6T1e54c47KKjqjKqhaJ2ND2dU5pdCqQtvZp06btce89Hg8ffjiDpUsXcfDgQXJzXeTm5tK1a7di2znx9l/NmrU4cuRwidd/5ZWpREREsm2bydSprzNx4qOFjog5HA4uvHAY33wzi9TUVGJjY+ncuctJiVizZs15//1PMc3NrFu3lrVrf+Phh+/nzDN78swzLx27VVq/fkOee+7l4+qGhYWVGK+IiJwij4vo+bcSsvtb0vpMJqftlRUdUZXmcyJmGMYoYDxQD9gIjDNN88ciytYDngfOAFoBH5imeW0h5aKB/wCXA/HAHuAB0zQ/K93HqPpOTD4++eQD/vvfjxg79m5atGhJWFg406a9XmJSdWLyZLP5tqF3vXoNiI2NpXHjJrhcLiZOHM+MGZ/gdDpPKjtkyEVcc80/SEzcx5AhFxXZpt1up23b9rRt256RI//JggVzeeKJh1m79lfOOCPvSdLg4CAaNmxUYnwiIlIGPLlEL7ydkF2LSDtvEtnt/1nREVV5Pi3oahjGSOBl4EmgK/ATMM8wjMZFVAkBkoCngZWFFTAMIxhYRF6idiVgANcCO30Pv/pat+53zjnnXAYPHkqrVgYNGjRkz57d5XLtQYOG4Ha7+d//Cs+XGzVqTLt27dmyZRMXXjjM53abNm0OQFbWyY8+i4iIn1leopaMI2THPNJ7P0Z2x2sqOqJqwdcRsbuAGaZpHl3U6Q7DMAYDtwH3n1jYNM1dwBgAwzAuL6LN64BawLmmaR7dqXmXj/FUe40aNWbp0kX8/vtaYmNjmTnzU/bt+4tWrQy/X9tut3Pllf9gxoy3GTHiskJvFT733Cu4XC6io6MLbePBByfQsWNnOnToTHx8PHv3/sW0aa9To0Y8HTt2OlbO4/Fw6FDSSfX1JKWISNkK+3UKodu+Jr3X/WR1vqGiw6k2SkzEDMNwAt2A5044tRA4+zSufTGwHHjVMIwRwGHgM2CSaZq5xdYUrrnmBvbt28s994whJCSEIUOGMXDghezataNcrj906AjefvtNPv/8E/797+tPOh8aGkpoaGghNfP06NGLJUsW8eGH75GenkZcXA06duzEvfc+SHR0zLFyu3cnMGLEyQ8SfPfdzz6tpSYiIiUL/nM5ESufIbvVCLK6jqrocKoVW0nzgwzDqA/8BZxvmuYPfzv+MPBP0zSLHYIxDOMbIOnEOWKGYWwBmgIfA6/nv34d+NA0zXuKa9Pr9VoeT+Fxm+YW6tdvWuxnkqpr795dGEYbv7UfSA9wVDT1RQH1RR71Q4FK1Repewl6py+ExuK+fgmU8ZY/laov/CQ42LEGKHQbnYocUrADB4CbTNP0AGsMw4gHXjQMY7xpmkVmiB6PRXJy4YvDWZZVZv/B9eXJU5n6wbKK/m6UhdjYcL+2X5moLwqoL/KoHwpUmr7w5BL79XWQk8GR4Z/iybRDZtnGXWn6wo9q1Yoq8pwviVgS4AFOXP+hDlD6VVIL7ANy85OwozYD4UBN4OBptC0iIiIliFjxFMH78lbN99RoXdHhVEslPjWZP5F+DTDwhFMDyXt68lQtB1oahvH3GFoDmeQlfyIiIuInzu1zCP/9TbI6XqNV8yuQr7cmXwA+MAxjFXkJ1K1AfWAqgGEY7wOYpnlsqXfDMLrkv4wGvPnvXaZpbso//gYwGnjZMIzXyJsj9hgwpbjbkiIiInJ6HMk7iFpyN7m1u5B+zsMVHU615lMiZprmp/nztx4kb0HXDcAQ0zQT8osUtp7Ybye8vwhIIC/hwjTNPYZhXEBekreWvNuc75C3wKuIiIj4Q24m0fNuAkcwqYOngSOkoiOq1nyerG+a5hRgShHn+hRyzFZI0RPL/MzpLYEhIiIivrIsor6dgOPwVlIu+gBvVAOfqh3OdPH+qj/JcXtw2G047DaC8n878vcHdnks3F4vLreXXK+F2+PF5bFwBNnJznFjWeCxLCwLvPm/i1VYFmEd/WUd/ThHDx37fbThvzd/rJyVV/Poe7sNburVhB5N4nzqB3/QQkwiIiLVRPia1wjd9hUZPSeQ27iPT3W8lsUjc01+2X2EqNBgPF4r78eycOe/Bgh22HA67ATZbQQ77DgdNoIcdpxBDizLi91my/8Bu82GzVZ4rgXHJ1Ensp3w6u/t5OeEBWVsx5e22W1552x5v+02CHKUOG7kV0rEREREqgHn9rlErJxMdquLyex2h8/1Pv9tLz8nHOG+AS25rHP9k84fXY/UZis8odHyFcVTIiYiIlLFBR1cT/TiseTW6Upav+eOGykqzvakDF79cSe9m9fg0k71Ci1TVAImvvFp028RERGpnOwZ+4mecx3e0DhSLnwbgorefu7vXG4vD8/dQniwgwcvaK2Ey080IhYAevcudNeDYy68cBgTJz56Sm2//fY0vvtuCR988Fmx5ebOnc2TTz527H1cXA3atm3PrbeOplWrVseOT5r0KPPmfcPQocO5//7jH3meMuUVPv74fc4+uzfPPPMSANnZ2bz33tssXbqIgwcPEBYWRuPGTbj00isZOHDwcW2eqF27Drz55oxT+twiIgK4s4ieez32nFSOXPYVVkRtn6tO+2kXWw9m8PzF7YmPcPoxyOpNiVgA+Prr+cde//TTMiZP/s9xx0JCfPvXy+kKDQ3l00+/wrIgKekAU6a8woQJ4/jss6+w2x3HytWuXYelSxczbtx4wsLCAHC73SxYMIc6deoe1+azzz7J+vW/M3bsPTRv3oK0tFQ2btxAamrqceW6d+/BQw89ftyx4OBgP31SEZFqwLKIWnoPQQfWkXrhdDw12/lcdc2eZD745U8u7VSP81rE+zFIUSIWAOLjax57HRkZedKxZct+4J133mTXrh3Ex9dkwIBBXH/9zccSle+/X8o777zJnj17CAkJoUWLljz++FP8/PNPvPvudKBg1O2BBx5hyJCLCo3DZrMdu27NmjW58sqruO++u0hI2EWzZi2OlWvZshVJSQdZunQRQ4cOB2DFimU4nSF07tyV1NSUY2WXL/+B228fxznnnAtAvXr1ad365E25nU7ncZ9ZREROT/jqlwnd9jXpve7H1Xywz/XSst08Ms+kUVwY4/o092OEAtUkEQvZMpPQzf8tdT2bzXbsaZDSym77f+S0ufyU6v7dypUrePzxhxg79m66dDmD/fsTefbZJ8nNzWX06HEcOpTEI488wC23jKZPn35kZWWyceMGAPr3H8iOHdv56acfefXVaUBBoleStLQ0Fi3KG5ULCjr5azJ06AjmzJl1LBGbM2cWQ4ZcxN69fx1XrkaNeFau/Im+fQf4fG0RETk9zp2LiFj1HNnG5WR1HVWqupOXbCMpPYe3r+pKWLCj5ApyWqpFIlaZvf/+O1x11dXHEp4GDRpy221jeOKJh7j99rEkJSXhdrvp27c/devmPdHSvHnLY/XDwsJwOBw+jTZlZWUxcOC5WJZFdnY2AL17n0fTps3weLzHlR04cDCvv/4ye/bsJjw8nJUrVzBu3ATefnvqceUmTJjI448/xNCh/WnRoiUdOnTi3HPP58wzzzqu3MqVKxg48Nzjjl1yyRWMGjXGx54SEREAW+ZBor69h9ya7UnrO9nnJyQB5m8+wIItB7n1nCa0rxvlxyjlqGqRiOW0ufyURqccDvtJCUh5M83NbN68kY8+eu/YMa/XS05ODocOHaJly1Z0796Dq68eSY8ePenevSd9+vQnLq70qwSHhoby7rsf4/F4WLv2Vz755EPGj3+g0LLR0dGcd14f5syZRWRkJF27dqNu3bonlevS5Qw+++xrNm5cz7p1v/Prr79w552jGT78EiZMmHisXOfOXY97DxAZqT8ERERKxbKI+nY8Nlc6aSNeKdX2RX8mZzF5yTY61Y/mmh6F7Vwo/lAtErHKzOu1uO66m+jbd8BJ52JjY3E4HLz44uts3LieVat+5ptvvmbatNd49dU3adWqdamuZbPZaNiwEQBNmjTl0KEkHn10IlOmTC+0/NChw5k06VHCwsK48cZbi2w3KCiIzp270rlzV66++lpmzHiLt96aytVXX0e9enmLA4aGhh67toiInJrQTR8Rsmsx6b0fxRNv+Fwvx+3l/tmbsWHjiSFtCLJrqYryonXEApxhGCQk7KJhw0Yn/Rydu2Wz2ejQoRPXX38zb731PjVr1mLp0kVA3pOHXu+pjeqNHHkVW7du4bvvlhR6vnv3HgQHB5OSksK55/bxud1mzfImf2ZlaaVlEZGyYk/eSeSyx3A17E1Wp+tLVfel77az5UA6jww2qB9TPk/qSx6NiAW4a6+9iQkTxlG3bj369RuAwxHEjh1/sHnzRkaNGsuGDetZvXolPXv2Ii4unm3btrB//36aNm0GQN269UlM3IdpbqFOnbqEh4fjdPq2HkxERCTDhl3M9OnTOOec87Hbj8/bbTYb7733CZZlFdnm6NE3M2DAINq0aUdMTAy7du1g2rTXadKkKU2aNDtWzuVycehQ0nF17XbHKd1iFRGpdrxuohePwXI4Sev/Ath8H2dZuOUAM3/fx9XdG3J+Sy1VUd6UiAW4nj178eyzLzNjxlt88skHOBxBNGrUmCFDhgF5T0GuX7+OL774jPT0NGrXrsO1197AoEFDAOjTpx8//LCUsWNvIz09rdjlKwpzxRX/YObMT1m8eCEXXHDy48/h4RElxr9gwVymT59CVlYWNWrEc+aZPbn22htxOAqexlm9ehUjRhzffq1atfnyy7k+xyoiUl2Fr3mN4P2/kXrB63gjT94Psii7DmcyaeE2OtePZlTvpv4LUIpkO9XlGSpSbq7HKmoD0cTEBOrWbVIm1wmEyfqBoDL1Q1n+9y+MNq8toL4ooL7Io34oUJ59EbR/LbFfjCCn5UWkXfCaz/Wycz1c9/FakjJcfHj1GdSJ8n1if2noewG1akWtAQrdRkcjYiIiIpVVbiZRi8fgjahN+vmTSlX12aV/sD0pg5cu7eC3JExKpkRMRESkkor8aRJByTtIHvEpVkiMz/Vmb0hk1ob9XH9WY85uVsOPEUpJ9NSkiIhIJeRMWErYhvfI7HwzuQ3P8bneH0kZTF7yB90bxXBzL/9N5RDfKBETERGpZGxZh4lceg/uGgYZZ03wuV52rocHvtlMhNPBE0Pb4tB6YRWuSt6atCwLWym2dJCqoTI+eCIiUmqWRdR392LPTubIRR9CkO/rfr30/Q52Hsrktcs6UjPCt6WMxL+q3IiYwxFEbq6rosOQCuDxuLHbtUGtiFRtIeZMQnbMI6PneDw12/lc7/s/DvHF7/v4Z7eG9GyqNRoDRZVLxCIjY0lOPojLlaMRkmrEsrykpR0hLCyyokMREfEbe+puIn94CFf9nmR1udnnegfTc3higUnrWhFaLyzAVLlbk2FheQuMpqQk4fG4T6stm82mZI7K0g82nM5QIiN9f2pIRKRS8XqIWnwnAGn9XwYf7wB4LYtH55lku71MGtoWZ1CVG4Op1KpcIgZ5ydjRhOx0aBG6POoHEZGKF7Z2Gs59K0nt/xLe6IY+1/t4zV+s2p3M/QNb0TQ+3I8RyqlQWiwiIhLgHAc3ErHyWXJaDCXHuMzneub+dF7/cSd9WsZzSce6foxQTpUSMRERkUDmziZ68Ri8oTVI6/M0+LgqQFauh4lzNlMjPJiJF7TWagIBqkremhQREakqIn5+hqDDJskXfYgV6vvTji9+t53dR7J4/YqOxIYF+zFCOR0aERMREQlQwXtXEvb7dLI6XENu4z4+11tkHuTLdYlcfWYjzmyspSoCmRIxERGRQJSbSdSSu/BGNya91wM+V9t6IJ3H55t0rh/NredoC6NAp1uTIiIiAShyxSTsqbtJuWQmOH1bCSA5M5d7vt5IdGgQTw9vR7BD4y2BTv+FREREAkzwn8sJW/8eWZ1vILd+T5/quD1e7v9mE4cyXDw7or22MKoklIiJiIgEEJsrjaild+OObU5Gz3t9rvfS9ztYvSeFiRe0pl3dKD9GKGVJtyZFREQCSMTyJ7Cn7yX50i8hOMynOrM2JPLpb3u5qlsDhrSr4+cIpSxpRExERCRABO/+jrBNH5PV5Rbcdbv5VGfDvlSeXryNHo1jueO85n6OUMqaEjEREZEAYMtJIWrpPbjjWpPR426f6iSl5zBh1iZqR4YwaVhbguxatLWy0a1JERGRABC57FHsmQdJvvAtCAotsbzL7WXCrE2k57h556quWrS1klIiJiIiUo5sOak4kncU/KTsxHFkO8FJG8joNgZ3nS4ltmFZFk8t3sb6fWlMHt6OljV9W95CAo/PiZhhGKOA8UA9YCMwzjTNH4soWw94HjgDaAV8YJrmtcW0/Q/gY2COaZrDfI5eRESkkrBn7Cdm1lUEHTaPHbNsdrxRjfDENiOj+1gyu4/1qa2P1/zFNxv3c3OvJvRrVdNfIUs58CkRMwxjJPAyMApYlv97nmEY7UzT3F1IlRAgCXgauLmEtpsDzwKFJnUiIiKVnsdF9PxbcKTuJv2s+/DEtcQT2xxPTBNwhJSqqZ92HuaVH3bQv3VNbujV2E8BS3nxdUTsLmCGaZrT89/fYRjGYOA24P4TC5umuQsYA2AYxuVFNWoYRjDwCTAR6AsorRcRkSonctmjBCeuJvWCN8hpddEpt7PrcCYT52ymRc0IHhlsYLdpcn5lV+JTk4ZhOIFuwMITTi0Ezj7N608Cdpmm+d5ptiMiIhKQQjd9QtiG98nsettpJWFp2W7u/mojwXY7z1/cnrBgRxlGKRXFlxGxmoAD2H/C8f3AgFO9sGEYFwBXAiXPSjyBw2EjNjb8VC9diuvYy+U6gU79UEB9UUB9UUB9kUf9UOBoX9j+WoPjh4l4m/UhePDjxNpPLXlye7zc9fWv7EvN5v3retC2cVwZR+w/+l4Ur0KemjQMoxYwA/iHaZrJpa3v8VgkJ2eWeVwnio0NL5frBDr1QwH1RQH1RQH1RR71Q4HY2HBS9iYQ9/nVeMPrcKTfq1ipOafc3ovfbefHP5KYOLAVLWNCKlU/63sBtWoVveWUL4lYEuABTtwzoQ6QeIoxtSfv6cslhmEcPWYHMAzDDbQ3TdMsoq6IiEhg8+QSPf9W7DnJHLn0a6zQUx/Bmr0hkY/X/MXIrvW5uFO9MgxSAkGJc8RM03QBa4CBJ5waCPx0itf9BehI3m3Joz+zyHtysguw8xTbFRERqXD2xQ/i3LeStL7P4qnV/pTbWb07mScXbePMxrGM69OiDCOUQOHrrckXgA8Mw1gFLAduBeoDUwEMw3gfwDTNfx+tYBjG0blf0YA3/73LNM1NpmlmABv+fgHDMJKBINM0jzsuIiJSmYRu/BDH6ulkdr6ZnNaXnHI7uw5lMmHWJhrFhjH5onbavqiK8ikRM03zU8Mw4oEHybuluAEYYppmQn6RwhYy+e2E9xcBCUDTUwtVREQkgHk9RPz8NOG/vYG3eV8yzn7glJs6kuli7JcbCHbYePHS9kSFaiOcqsrn/7KmaU4BphRxrk8hx0qVuhe38r6IiEggs2UfIXrhaJx7vierwzUEDZsMae5Tais718PdX23iUIaLqVd2okFMWBlHK4FEKbaIiMhpcBzaTMzcG7Gn7yWt7zNkt7uKWIcTKH0i5rUsHptvsmFfKk9f1JYO9aLLPmAJKErERERETpFz+xyiF9+J1xlF8iUzcdftdlrtTVm2i8VbkxhzXjP6ta5VRlFKIFMiJiIiUlqWl/CVzxGx5hVy65xB6oVv4o2oe1pNfrVuH++t2sOlnerxr+4NyyhQCXRKxEREREopYvl/CP/9TbLa/h/p508q1cbdHq9FYlo2u49ksedIFruPZJFwJItfdidzVtM4xvdviU17SFYbSsRERERKIcScmZeEdbyW9HOfAB+TpqT0HB74ZjMbEtPI9VjHjocHO2gcF8aw9nUYd35zLVNRzSgRExER8VHQgd+J+vZeXA16kX7OIz4nYcmZuYyauZ7E1GxGdm1Ak7gwGtcIo3FsGPERTo2AVWNKxERERHxgyzxI9Lwb8YbXInXQVHAE+1QvLdvN6C/W81dyFi9d2oEzK9GG3eJ/SsRERERK4nERM/8W7NlH8vaODIv3qVqmy8PY/21ge1IGz41oryRMTqJETEREpASRPz5C8L5VpF7wus97R+YtzLqBjYmpPDWsLec0r+HnKKUyKnHTbxERkeosdOOHhG38gMyut5HTaoRPdVxuL/fN3syaPSk8MtjQmmBSJCViIiIiRQja9wuRPzyEq3EfMs66z6c6bq/FXZ//zvKdh7lvYCuGtKvj5yilMlMiJiIiUghbZhIx827GE9WA1IGvgd1RYh3Lsnhq0VYWbNrPnX2ac2mneuUQqVRmmiMmIiJyIssi6rt7seWkkDriY6zQWJ+qfb52H7M27Oe285tzVTetji8l04iYiIjICUK2fEbIzgVknHUvnvi2PtX57c8UXvhuO72b12Bcv1Z+jlCqCiViIiIif2NP3UPkj4/gqn8WWV1u8qnO/rQc7pu9iQYxoTwxpA12rY4vPtKtSRERkaMsL1FL7gQgrf+LYCt5vMLl9nLvrE1k53p548p2RIbor1bxnb4tIiIi+cJ+fwvn3p9J7fc83uhGJZa3LItnlvzBxsQ0Jg9vR/P4iHKIUqoS3ZoUEREBHIdMIn6eTE6zQeS0udKnOl+u28fXGxK5vmcj+rWq6ecIpSpSIiYiIuJxEbV4DJYzkrQ+k33azPv3v1J4dul2zmlWg5vPbur/GKVK0q1JERGp9sJ/eYngpI2kXPg2VnjJI1sH03O4d/Zm6kWH8MSQNjg0OV9OkUbERESkWgtKXEP4r6+R1WYkruaDSiyflQQPEZgAACAASURBVOvh7q82kuly88yI9kSFakxDTp2+PSIiUn25MohaPBZvZH0yzn20xOJey+LhuVswD6Tz/MXtaVlTk/Pl9CgRExGRaity+WM4UhJIuWQmljOqxPKv/7iT7/44xF19W9C7eXw5RChVnW5NiohIteTcuZCwTR+TdcZt5NbvWWL5r9bt4/1f/uTyzvX4v671yyFCqQ6UiImISLVjyzxI1Lfjya3Znowe95RYflXCEZ5e8ge9msZxd7+W2Hx4qlLEF0rERESkerEsor4dj82VTtqAV8DhLLb4rkOZ3Dd7M01rhPHksLYE6QlJKUNKxEREpFoJ3fQRIbsWk9HrATzxRrFlkzNzGfflBoIdNl68pIO2L5Iyp2+UiIhUG47kHUQuewxXo/PI6nRdsWVdbi/jZ20kKcPF1Cs7US86tJyilOpEI2IiIlI9eHKJWjQGy+Ekrd/zxW7ofXQPybV/pfLwoNZ0qBddjoFKdaIRMRERqRbC17xC8IG1pAyaijeyXrFlP1+7N28PybMac0Gb2uUUoVRHGhETEZEqL2jfasJXv0K2cRmulsOKLfvL7iO88O12zmsRzy1nNymnCKW6UiImIiJVmj11DzHzbsAb1ZD0c58otuyfyVncP3szjWuE89iFBnYtUyF+pkRMRESqLJsrjZg514LXTcqw97BCip7rlenycM/XG7GAFy5uryckpVzoWyYiIlWT1030gttwJG8nZdiHeOJaFl3Usnhk3hZ2Hsrklcs60jA2rBwDlepMI2IiIlIlRS57FOfu70g/bxK5jXoXW/atFQl898chxp7fnJ5N4sonQBGUiImISBUUuu5dwtbPILPLLWS3/2exZZduS2L6it0Ma1+Hf5zRoJwiFMmjRExERKqU4IRviVz2CDlNLyCj1wPFlv0rJYvH55u0rxvFfQNaaQ9JKXc+zxEzDGMUMB6oB2wExpmm+WMRZesBzwNnAK2AD0zTvPaEMjcB/wY6ADbgN+Ah0zSXlf5jiIiIgOPQFqIX3IY7vi2pA18Fu6PIsm6vxUNzTACeHNaWkCCNTUj58+lbZxjGSOBl4EmgK/ATMM8wjMZFVAkBkoCngZVFlOkDfAr0A3oCJrDAMIxWvgYvIiJylC0ziZg512IFR5A69F1wRhRb/q0VCazfl8oDA1tRP0bbF0nF8HVE7C5ghmma0/Pf32EYxmDgNuD+EwubprkLGANgGMblhTVomuZxN+0Nw7gNuBgYDGzzMS4RERHw5BAz/ybsmQdJvuQLvJH1iy3+65/JvLtyN0Pb19HK+VKhShwRMwzDCXQDFp5waiFwdhnG4gRCgSNl2KaIiFR1lkXUt/cSvO8X0vq/hLtOl2KLp2bn8vBckwYxoYzv16KcghQpnC8jYjUBB7D/hOP7gQFlGMt/gHRgVkkFHQ4bsbHhZXjpoq5jL5frBDr1QwH1RQH1RQH1RZ6K6gf7ildwmDPxnHsvYWeOpLgVwCzL4qH5JocyXHx601k0qO2fzbz1nSigviheQCzoahjGWOAWYIBpmqkllfd4LJKTM/0eV2xseLlcJ9CpHwqoLwqoLwqoL/JURD84dy4keuljZLccTlrH0VDC9b9ev4/5G/cz+txmNI4M9lu8+k4UUF9ArVpRRZ7zZbJ+EuAB6pxwvA6QeOph5TEMYxx5o2FDTNNcdbrtiYhI9eBI2kT0wtG4a3cirf/zUMLSE7sOZfLc0u10bxzL1Wc2LKcoRYpXYiJmmqYLWAMMPOHUQPKenjxlhmHcBTwBDNWyFSIi4itb5kFi5lyHNySK1CFvQ1DxWxK53F4enLuFkCA7jw3WZt4SOHy9NfkC8IFhGKuA5cCtQH1gKoBhGO8DmKb576MVDMM4OlsyGvDmv3eZprkp//x4YBLwL2CrYRh188tnmaaZclqfSkREqi5PDjHzbsKefYjkS/6HN6JuiVXeXJGAeSCd50a0o3ZUSDkEKeIbnxIx0zQ/NQwjHniQvAVdN5B3KzEhv0hh64n9dsL7i4AEoGn++9uBYPLWEvu794BrfYlLRESqn8gfHiY4cTUpg6birt2pxPIbE9P44Jc9DO9Qh/Nb1iyHCEV85/NkfdM0pwBTijjXp5BjxY77mqbZ1Ndri4iIAATtW03Ypo/I7HILrpbDSizvcnt5bL5JzQgn487XUhUSeLSfg4iIVA5eD5E/TMQTWY+MHnf7VOWtnxPYeSiTBwa2Jio0IBYKEDmOvpUiIlIphG78kOCkjaQMmgrBJa9LtXl/Gu+v2sOw9nU4p3mNcohQpPQ0IiYiIgHPlnWIiJXP4GpwDq4WQ0ssn+vJuyVZI8LJnX2al0OEIqdGiZiIiAS8iJ+fxpabQfp5/ylxvTCAt3/ezfakTB4Y2Iro0OByiFDk1CgRExGRgBa0/zdCN/2XrE434KnRqsTyW/anMWPlboa2q03v5vHlEKHIqVMiJiIigcvrIfKHB/GG1ybzzDtLLJ7r8fL4gq3EhTu5q6+ekpTAp0RMREQCVujm/xJ84HcyznkQyxlZYvl3V+5m28EM7tctSakklIiJiEhAsmUfIeLnp3HV70lOq4tLLL95fxrvrNzDhW1rc14L3ZKUykGJmIiIBKSIn5/BlpNK+rlPlDhBPzvXw0NzthAfHszduiUplYgSMRERCThB+9cSuvFDsjpeg6dmuxLLv/LDThKOZPHIYIOYMN2SlMpDiZiIiAQUW8YBouffhDeyLpk+rKC/fOdhPl+7l6u6NaBHk7hyiFCk7GhlfRERCRzuLGLmXo89O5nkS7/ECokptviRTBdPLNhKi5rhjOrdrJyCFCk7SsRERCQwWBZRS+8h+MBaUi58C3etDiUUt3hy0TZSs3N59bIOhATpJo9UPvrWiohIQAhf/TKh274m/az7cDUfXGL52Rv2890fhxjVuxmtapW8tIVIIFIiJiIiFS5k22wiVj1HtnE5WWfcXmL5P5OzeO7bP+jeKIarujUohwhF/EOJmIiIVKig/WuJWjKO3HpnktZ3colLVbi9Fg/PNXHYbTwy2MDuw96TIoFKiZiIiFQYe/peoufegDe8NimDp4MjpMQ6M1buZv2+VO4f0Iq60aHlEKWI/2iyvoiIVIzcLKLn3oAtN53k4V9jhdcsscqmxDTeWpHAoDa1uKBN7XIIUsS/lIiJiEj5syyivr2HoIMbSB36Lp74NiVWyc718Mi8LcRHOJnQv2U5BCnif7o1KSIi5S7s9+mEbvuazJ7jcTUd4FOd137cya7Deavna0NvqSqUiImISLkK3rOMiJ/+Q07zC8nsdodPdVbuOsKnv+3l/87Q6vlStSgRExGRcmNP3UP0wtvwxLYkrf+LJT4hCZCSlctjC0ya1Qjn9t5N/R+kSDnSHDERESkfuVlEz7sRvB5Sh7yF5fRtEdZnlvzB4cxcnr+4PaHBDj8HKVK+NCImIiL+d3RyftIm0i54DU9sc5+qLdh8gIXmQW7q1Zi2daL8HKRI+VMiJiIifhe29s38yfkTcDXp51Od/Wk5TF7yBx3rRXFNj8Z+jlCkYigRExERvwre8yMRKyaR02IImd1G+1THa1k8scAk1+PlsQvbEGTX6vlSNSkRExERv7FlHiR60Wg8ca1I7efb5HyAT3/by8qEZO7s05xGcWF+jlKk4miyvoiI+IdlEbX0bmyudFJHfAbOCJ+qbT2Qzqs/7KB38xpc0qmen4MUqVgaERMREb8I3fAeIQlLST/7QTzxhk91snM9TJyzmZjQYB4e1BqbNvSWKk4jYiIiUuYch0wilz9BTpN+ZHe81ud6L3y3nYTDWbx6eUfiwp3+C1AkQGhETEREypYnh+hFo7GckaT1e97neWFLtyXx5bpErj6zIT21er5UExoRExGRMhWxYjJBhzaTMvQ9rPBaPtVJTM1m0sKttK0Tya3nNPVvgCIBRCNiIiJSZoL3/Ej472+S1eEaXE37+1TH47V4eF7eUhWThrYl2KG/mqT60LddRETKRuZhohaPwx3XivSzH/S52oxVu/ntzxQm9G+ppSqk2tGtSREROX2WhWPuOGzZhzky7H0I9i2hWrc3lek/JTCoTS2Gtqvj5yBFAo9GxERE5LSFrXsHu/kNGWfdh6dWe5/qpGbn8tCczdSJCuG+Aa20VIVUSxoRExGR0xKy9Ssilj2Kt/UQsrrc5FMdr2XxyDyT/ekupo/sTGSI/jqS6snnb75hGKOA8UA9YCMwzjTNH4soWw94HjgDaAV8YJrmtYWUuwx4AmgBbAcmmqb5ZSk/g4iIVJDghG+JWjKO3Po9sF08HTIsn+q9t2oPy3Yc5p6+LehYP9rPUYoELp9uTRqGMRJ4GXgS6Ar8BMwzDKNxEVVCgCTgaWBlEW32Aj4FPgK65P/+3DCMnqX5ACIiUjGCEtcQM/9m3DUMUoe86/O8sJUJR5i6fBeD2tTiyq71/RylSGDzdUTsLmCGaZrT89/fYRjGYOA24P4TC5umuQsYA2AYxuVFtDkO+NY0zUn57ycZhtE3//g/fIxLREQqgOOQScw3/8YTUYeUiz7ECvFtVCsxNZsH52yhSY1wHhioLYxEShwRMwzDCXQDFp5waiFw9mlcu1chbS44zTZFRMTP7Kl7iJl9FZYjlJThH/u8aGuux8v932zG5fbyzPB2hDsdfo5UJPD5MiJWE3AA+084vh8YcBrXrltEm3VLquhw2IiNDT+NS/vG4bCXy3UCnfqhgPqigPqiQLXqi4yDBM35F3iycV89h+jabY6dKqkfHvtmExv2pfHKyC50aV6zPKKtMNXqO1EC9UXxKuVjKh6PRXJypt+vExsbXi7XCXTqhwLqiwLqiwLVpi9yM4n98nJI/Yvk4Z/gdjaFv33u4vph3ub9fLhyN//s1pBeDaOrfH9Vm++ED9QXUKtWVJHnfEnEkgAPcOJKe3WAxFMPi0Q/tCkiIv5gWUR9O4GggxtIHToDd70zfa76R1IGTy7cRtcG0Yw+t6n/YhSphEqcI2aapgtYAww84dRA8p6ePFUr/NCmiIj4Qej6dwnd9hWZPcf7vIckQHqOm3tnbSIiJIgnh7UlSPtIihzH11uTLwAfGIaxClgO3ArUB6YCGIbxPoBpmv8+WsEwjC75L6MBb/57l2mam/KPvwz8YBjGfcBXwCVAX6D3aX0iEREpU0H7VhO5/HFymg4ks9ton+tZlsVj803+Ss5iypWdqBkZ4scoRSonnxIx0zQ/NQwjHniQvAVdNwBDTNNMyC9S2Hpiv53w/iIgAWia3+ZPhmH8H/Af4HHyFnQdaZpmoeuOiYhI+bNlHiR6wS14IxuQNuAlsPk+ovXBL3/y3R+HGHd+c85oGOvHKEUqL58n65umOQWYUsS5PoUcK3FxGNM0ZwIzfY1BRETKkddN9MJR2LOTOXLZLKyQGJ+rrt6dzOvLdtK/dU2u6tbAj0GKVG6V8qlJERHxv4ifJ+P8awWp/V/0eSNvgANpOUycs5nGcWE8NEiLtooUR4mYiIicxLljHuG/vUFW+6vJaXOFz/VyPV7um72ZrFwPU6/sTIRTf82IFEePr4iIyHEcyTuIWnwnubW7kH7uo6Wq+/L3O1i/L5WHBhk0i9ciniIlUSImIiIF3NlEz78FHMGkDp4GDt+fdJy9bi+f/raXf5zRgIGGb9seiVR3GjMWEZFjIlY8RdChzaQMex9vlO+T7LcdTGfiVxvp0iCaMec182OEIlWLRsRERASA4IRvCV/3NpmdrsfVpJ/P9bYeSGfU5+uJDg3iKS3aKlIqGhETERFsmUlEL7kLdw2DjF4P+FzP3J/O7TPXERJk56MbehDj0BOSIqWhf7aIiFR3lkXUt/dgc6WSesFrEBTqU7VNiWnc9vk6woIdTBvZmSbxEX4OVKTqUSImIlLNhW54n5Bdi8no9QCe+LY+1dmwL5XbZ64jKjSIaSM70zA2zL9BilRRSsRERKoxxyGTyOWP42rch6xO1/tU5/e/Uhg9cz2xYcFMu7IT9WN8G0ETkZMpERMRqa48OUQvGo3ljCS1/4vgwwr4v/6ZzB1frCc+wsm0KztTN1pJmMjp0GR9EZFqKmLF03lLVQx9Dyu85HW/fvszhbFfbKBudAhvXNGJmpG+rzEmIoVTIiYiUg05d8wn/PfpZHW8FlfT/iWWX7c3lXH/y0vCpl7ZmfgIZzlEKVL16dakiEg1E2LOJHr+LeTW7kz62RNLLL8pMY0xX6wnPiKYKVd0UhImUoaUiImIVCNhv79F9OJx5NY/i5QRn0JQ8U87bj2Qzh1frCcmNIgpV3Silm5HipQp3ZoUEakOLIvwlc8SseYVcppfSOrAV0tcL2x7Uga3z1xPaJCdKVd20sR8ET9QIiYiUtV5PUT+MJGwjR+S1e4q0s9/CuyOYqskHM5k1OfrCLLbeOPKzjSI0TphIv6gRExEpCrz5BC9aAwh2+eQecZoMs66t8RlKv5MzmLU5+sAmHJFJxrHKQkT8RclYiIiVVVuFjFzr8P55zLSz3mYrC43l1glKT2H2z9fR47by9QrO9MsPrwcAhWpvpSIiYhURV430QtHEfznclL7v0hOmytKrJKe42bM/zZwJCuXqVd2pmUt7R0p4m9KxEREqhrLIvK7+wjZtYi08yb5lITluL3c8/VGdhzK5KVL2tOubpT/4xQRLV8hIlLVhK96jrDN/yWj2xiyO15TYnmP1+KReVtYsyeFRwa35qymNcohShEBJWIiIlVK6Ib3iVj9MlltR5LZc3yJ5S3L4vlvt7NkaxJjz2/OhW3rlEOUInKUEjERkSrCuX0ukd9PJKfpANL7TPZpE+93V+7h87V7+We3hvyre8NyiFJE/k6JmIhIFRC892eiF92Bu05XUi94A+wlTwH+ev0+3li+i8FtazPm/GblEKWInEiT9UVEKjPLIujgeqLnXI8nqiEpQ2dAcMnrfs3dtJ8nF23jrCZxPDyoNXYfRs9EpOwpERMRqSRsGQcIOmwSdHgrjsNbCTqS99uek4InvA4pF32EFVb8RPvsXA/Pf7udr9Yn0rVhDJOHtyPYoZsjIhVFiZiISCUQseJJwn+dcuy9NyQGTw2DnJYX4a7RGlezQXijGhTbRsLhTO7/ZjPbDmZwTY9G3HpOU4LsGgkTqUhKxEREAlzIls8J/3UK2cZlZBtX4K7RGiu8lk+T8Y9auOUAkxZuI9hh46VLOnBOcy1RIRIIlIiJiASwoMQ1RH17L66GvUnr97xPk/D/Lsft5cXvtvPF7/voWC+aJ4e1oW50qJ+iFZHSUiImIhKg7Ol7iZ53E97IeqQO8u1JyL9Lycpl9Mz1bDmQztXdGzKqd1OCNB9MJKAoERMRCUTuLKLn3ogtN4Pk4Z9ghcaVqrrHa/Hg3C1sP5TBcyPac37LeD8FKiKnQ/80EhEJNJZF1NLxBB1cT9rAV/HEG6Vu4s0VCfy86wj39GupJEwkgCkRExEJMGG/TSF021dk9pyAq9kFpa7//R9JvPPzbkZ0qMslHev6IUIRKStKxEREAohz1xIiVjxNdsvhZHYbXer6CYczeWSeSds6kYzv3xKbFmoVCWhKxEREAoQ9dTdRC2/HXbN93hOSpUyiMl0exs/aRLDDzjPD2xESpD/iRQKdJuuLiAQCyyLq2wkApF74lk/bFB1f3eKJBSYJhzN59bKOWqJCpJLwOREzDGMUMB6oB2wExpmm+WMx5c8HXgDaA3uBZ0zTnPq38w7gUeBf+W3uAz4CHjVN013qTyIiUomFbv4U55/LSDv/KbzRDUtd/8PVf7J4axJjzmtGjyale8JSRCqOT+PWhmGMBF4GngS6Aj8B8wzDaFxE+WbA3PxyXYGngFcNw7jsb8XuBW4HxgBtgLH57+8/pU8iIlJJ2TMSiVj+OK76Z5Hd/p+lqpvhcrN060Fe+3En/VvX5F/dS5/EiUjF8XVE7C5ghmma0/Pf32EYxmDgNgpPnG4F9pqmeUf++82GYfQE7gG+yD92NjDbNM3Z+e93GYYxC+hZ2g8hIlJpWRaR30/E5skhve8zYCv838fZuR6W7TjMnuQsdh/JYs+RLPYkZ3E4MxeAZjXCeWhQa03OF6lkSkzEDMNwAt2A5044tZC8ZKowvfLP/90C4BrDMIJN08wFlgGjDMNoY5rmFsMw2gH9yBs9ExGpFpzb5xCycwHpvSbiiW1eaBmP1+LurzayancyADUjnDSKC6N38xo0ig2jcVwYZzaOI8Kpab8ilY0v/9fWBBzA/hOO7wcGFFGnLrC4kPJB+e3tAyYDUcAmwzA8+ecmmaY5paSAHA4bsbHhPoR+ehwOe7lcJ9CpHwqoLwqoLwqccl9kHiZo2UN463YhpM9YQorYwuj5RVtZtTuZh4a25bKuDYgICcyES9+JAuqLAuqL4lXk/80jgX8DV5E3+b8L8LJhGDtN03y7uIoej0VycqbfA4yNDS+X6wQ69UMB9UUB9UWBU+2LqMX3EpR1hORhH+FJdQGuk8p8ty2JqT/s4OKOdRnepha5WS6Ss04uFwj0nSigviigvoBataKKPOdLIpYEeIA6JxyvAyQWUSexiPLu/PYAngWeM03zv/nv1xuG0YS8OWfFJmIiIpWdM2EpoeYXZHQfi6dmu0LL7DqcyaPzTdrVjWJ8v5blHKGIlIcSn5o0TdMFrAEGnnBqIHlPRRZmRRHlV+fPDwMIJy/B+zuPLzGJiFRmNlcakd/dhzuuFZndxxRaJtPlYUL+4qyTL2qLU4uzilRJvt6afAH4wDCMVcBy8p6KrA9MBTAM430A0zT/nV9+KjDaMIyXgGnAOcC1wD/+1uZs4D7DMHaSd2uyK3lPZ75/Gp9HRCTgRax4Cnv6PpIv+wocISed//virK9drsVZRaoyn/6JZZrmp8A44EFgLdAbGGKaZkJ+kcb5P0fL7wSGAOfll58IjDFN84u/NXsHMBOYAmwGngem55cVEamSnDvmE7bhfbI634i7brdCy3y05i8Wb03i9t7NOLOxFmcVqcpslmVVdAyllpvrsTRZv/yoHwqoLwqoLwr42hf21D+J+2wQnugmJF/2ZaGjYWv2JHP75+s4v2VNnr6obaVaF0zfiQLqiwLqC6hVK2oN0L2wc5p0ICJSHjy5RC+6HbweUgdNKTQJO5CWw/2zN9MoLoyHB2txVpHqIDAXoxERqWIiVj5DcOIaUi94A29M05POuz1e7v9mMzluL88Ob6/FWUWqCY2IiYj4mTNhKeG/vUFW+3+R0+qiQsu8+uNO1u1NZeIFrWgar8UvRaoLJWIiIn5kT99H1OJxuOPbkt77kULLLNl6kI/X/MXIrvW5oE3tco5QRCqSEjEREX/xuolaNBqbO5vUQW9AUNhJRRIOZ/LEgq10qBfF2PML32tSRKouTUIQEfGT8F9exLl3JakDXsITd/LK+Nm5Hu6bvZkgu42nhrUl2KF/G4tUN0rERET8wLlzIeGrXyGrzUhyjMtPOm9ZFk8v3sb2pAxevqyDFm0VqaaUiImIlCXLS/ia1whf+SzuWh1IP++JQot9tT6ROZsOcFOvxvRqWqOcgxSRQKFETESkjNhyUolacichOxeQ3epi0vo+C8Enzwvbsj+N55b+wVlN4rjhrCYVEKmIBAolYiIiZcBxaAvR827CkbaH9N6PkdXpeihkQdaUrFzunb2Z2LBgHh9i4LBr0VaR6kyJmIjIabJt+pK42XfgdUaSPOIz3PV7FFrOa1k8PG8LB9JyeHNkZ+LCneUcqYgEGiViIiK+8LiwudKw5aRiz/9tc6Xi/OsngtbPILdud1IHT8UbUbfIJqb/lMBPO49w34CWdKwfXY7Bi0igUiImIlIUy8K5fQ4RK58hKHlHkcU83W4k+cwHwFH0CNeP2w/x1s+7Gda+Dpd2quePaEWkElIiJiJSiKDENUQuf5zgxDW4axhk9LgHb0gMVkgUljMayxmF1xmNFR5PdIPmkJxZZFt7jmTx8LwttKkdyb39W2ozbxE5RomYiMjf2FMSiPj5aUL/mI0nvDZpfZ8hu81IsDtOqb2sXA8TZm3CYbMxeXg7QoNPrR0RqZqUiImIALacFMJXv0LYunfB7iDjzDvJ7HIrOCNOuU3Lspi0cCvbkzJ45bIO1I/Roq0icjwlYiJS7Tl3LCDy+/uxZx4ku+2VZPa4B2/k6c/j+vS3vSzYcpDbzmnKWVq0VUQKoURMRKotW9YhIn94iNA/ZuGOb0vy0Bm4a3cqk7Z/+zOFl77fwXkt4rm2Z6MyaVNEqh4lYiJS/VgWIX/MIvKHh7C50sjocQ+ZZ4wq9qnH0tiXms29szbRICaUxy40sGtyvogUQYmYiFQr9oxEIr+fSMjOBeTW7kxav+fxxLcps/YzXR7u/mojuV4vz1/cnsgQ/TErIkXTnxAiUm04dy0mavFYbO5s0s9+kKzON4K97P4Y9FoWj8432Z6UwUuXdqBpjfAya1tEqiYlYiJS9VkW4WteJXzls7hrdSDtgtfxxDYv88tM/ymBb7clMe785vTS5HwR8YESMRGp2lwZRC+9i5Dtc8hudTFpfZ+F4LAyv8xi8+CxlfOv6tagzNsXkapJiZiIVFn21N3EzL0Bx2Ez71Zkl1vADxPnN+5N5dH5Jp3qR3P/gFZaOV9EfKZETESqpOA/lxO94FawvKQMe5/cxn38cp1DGS5u+2QtsWHBPDO8Hc4gu1+uIyJVkxIxEalaPC7Cfn+biJ+fxhPbnNQhb5fZfDDLskjJcnMwI4cD6S6S0nP4cl0iyZm5TB/ZmfiIsln+QkSqDyViIlI1eP+/vXsPk6Mq9z3+rerumZ5bMklmciMJSQxZhBCIEkAwAsrV4FY3IIqPglvRzS1cvO0NgQe3AmYjm4sCJ+jZHrxwDviAikoQ0K2AhGsEcl+AJISYTDKTZDKXnr5V1/mjamY6k5lkkulJz9C/z/PU011Vq6tWvemeerNq1SqP8jd+TdXLtxNp2Uhq2pm0nnYnflnNgDabjVgy0wAAG6hJREFUzHj855/e4m+bdtHUliLt+butL4+63HbeUZhx1QPaj4iUJiViIjK8+T5lby+l6sXbiO58k0zdkbR9/Gekp3xkwP3B2lJZvvbrVbz2jxZOnVnPxJl11FWXM7a6jLqqMuqry6mrKmNsXTXNzYkCHZCIlBIlYiIyPPk+sY1/oerF7xNrXEF21Ax2nbmE9PsWgDPwflo7EmmufGQVf29q5+aPz+J0U1+ASouI7E6JmIgML75PbNOzVL18B7EtL+PVTKbl1DtIzTwH3EhBdtHQkuTyh1eytTXFf31qNidO05hgIjI4lIiJyPDg+8TefYaql28n1rAcr3oCrSfdTPKICwr2jEiAd3YkuPzhlbSlstx97hzmThpZsG2LiPSkRExEhjbfJ/bu01S9dDuxrX/Dq55I68nfIznrfIiUF3RXdmsbCx9ZCcB95x+tDvgiMuiUiInIkBXd/BLVy27KS8AWk5z16YInYADPb9jBdb9fS1VZlHvOm8Ohek6kiBwESsREZMhxW/9B1fO3EH/zUbyq8bSespjk4ecX9BJkp6b2NHf+5e88sa6RaWMq+cE5RzJ+RLzg+xER6Y0SMREZOjIdVL76v6h89V7wfdrnXU3iA5dBrPCtUznf5zcrtvDDZ9eTyua4+INT+OLxUyjXyPgichApEROR4vN9yt/6HVXLbiLStpnkjH+i/YRF5EZMGpTdvdnYxveeeouVW1o4ZvJI/v20w5iqS5EiUgRKxESkuLIdjFx6MWXvPk2mbjatp/+AzMQPDsquUtkcP1q2gQde2URNPMa3zzIsOGKsHtItIkXT70TMGHMZ8E1gArAauNpa++xeyp8M3A7MBjYDt1prl/QoMwFYDCwAaoC3gUuttU/v53GIyHDk56j54zXE3n2G1g9/h+SRFxVsLLCe1m9PsOixtbzZ2M4njxzPFSdNo7YiNij7EhHpr351hjDGfAa4C7gFeD+wDHjcGDOlj/LTgKVhufcD3wN+aIw5N69MLfAc4ABnA7OAhcC2Az0YERleql5YTPzvv6f9xEUkj/rSoCRhvu/z25UNXPiLv9HYlubOc47k+jNnKgkTkSGhvy1iXwPut9b+OJxfaIw5C7gUuLaX8pcAm621C8P5tcaY44FvAI+Ey74FbLHWXpj3ufX7VXsRGbbiqx+g8m/30jH7C3TM/ddB2UdbKsviP77JE+samTellu98zFBfXfihL0REDtQ+EzFjTBlwDHBbj1VPAif28bETwvX5ngAuMsbErLUZ4FPAH4wxDwEfIbh8+b+Be6y1fv8PQUSGm9jGv1D99HWkpnyEtpO+O+CHc/dmdUMri36/loaWJJd+aCoXHTeZiKu+YCIytPSnRawOiABbeyzfCpzWx2fGA3/spXw03N4WYDpwGXAHQT+xucAPw7J3761CkYhDbe3g3+EUibgHZT9DneLQTbHodsCx2Lqa6BOXQP0s3PPvp7a8pqD18n2f/7NsA99/8g3G1pTzwJeP55hDRxV0Hz3pexFQHLopFt0Ui70r5l2TLvCKtbbz0uarxpjDgMvZRyLmeT7NzYnBrh+1tZUHZT9DneLQTbHodiCxcNsbqH34fHKxKpo/9hNyHRHoKFw8OzIe333iDZ6yjZwyYwzXnzGTkRWxQf830/cioDh0Uyy6KRZQX9/3fzj7k4g1AR4wrsfycUBDH59p6KN8NtweBK1ia3qUWQtc1Y86ichwk25nxGP/gpNqofmff0WuemJBN7+puYNvPrqGvze1c8WHp3HhsZM0LIWIDHn7vGvSWpsGlgOn91h1OsFdkb15vo/yr4T9wyC4Y9L0KDMTeGdfdRKRYSaTYOTjXybatJrWM+7Fq59d0M2/sGEHFz3wKtvaUtx17pFcdNxkJWEiMiz099Lk7cDPjTEvESRQlwATgSUAxpifAeTdAbkEuMIYcydwH/Ah4IvABXnbvANYZoxZBDxEMMzFlcB1AzgeERlinFQLIx+7iGjDclpPvZ301FMLtm3f9/nZy5u496/rmT6miu9/8ggm1VYUbPsiIoOtX+OIWWsfAq4GrgdeA+YDC6y1na1XU8Kps/x6gkFaTwrLLwKutNY+klfmZYI7J88HVgE3AzcA9w7skERkqHCSOxn52wuIbn2VljPuJWXOK9i2E2mP636/lrufXc9HD6vnJ5+bqyRMRIYdx/eH30gRmYznq7P+waM4dFMsuu0rFk6ikdrfXkCkeT0tZ91HempfN1nvv+XvNnPTk2+weVeSy+dP4wtF7g+m70VAceimWHRTLKC+vmY5MK+3dXrWpIgUnNu2mZGPXkCkbTO7zr6fzOQPF2S77eksdz+znodf38IhI+Pc++mjOGZybUG2LSJSDErERKSg3JaN1D76WZyOHTT/0wNkJx5XkO2+uGEnNz/1Bg0tKS74wCFcOn8qFbHBeS6liMjBokRMRArGbd1M7a/Owcl2sOuTD5IdN3fA22xLZbnz6bd5dGUDU0ZV8OPPHs3Rh4wsQG1FRIpPiZiIFIafo+ZPV+GkW2k+59d4dUcMeJOrG1r51qOraWpPc+Gxk/jKCYcSVyuYiLyHKBETkYKoeO1HlP3jeVo/cltBkrDn1u/g33+7htGVMX5ywVxmTxhRgFqKiAwtSsREZMAiTWuoeuFWUtPOJDnrMwPe3u9WNXDzk28wo76aO885krqqsgLUUkRk6FEiJiIDk00y4qmF+OUjaf3IrTCAYSR83+f+l97l3r9u4LgptfznJ46gulx/pkTkvUt/4URkQKpeuJXoDsuus3+KXzHmgLfj5Xxu+5+3ePj1LZx5eD03nmWIRfo15rSIyLClRExEDlhs03NUvv4jOo68cECPLkplc9ywdB1/frOJz8+bxMKTpuHqWZEiUgKUiInIgelopuZPV5OtnU7biTcc8Gba01mu+fVqXt20i2tOmc7njplUwEqKiAxtSsRE5IBEnvgWTvs2ms99FGIH9ozH9nSWq3+1ipWbW7hpweGcOWtsgWspIjK0KRETkf1W/uajuKsfpv24rx/woK3t6SxXPbKKVVtauOnsWZxm6gtcSxGRoU+JmIj0m5NopHL5D6lY9Qtyh8wjcczCA9qOkjARkYASMRHZJye5k8pXl1Cx4ifgpUnOOp/o6TdCdv//hCgJExHppkRMRPrkpNuoWPHfVLx6H066ldRhnyBx3NfxaqdTW10JzYn92l57OsuVj6xi9ZYWbv74LE6dqSRMREqbEjERAcBJtxLZ9Q5uyztEdgVT+fo/4HZsJzX1DNqP/8aAHl2kJExEZE9KxERKjJNoJLp9HdHt64hsX0d0hyXS8g5ucudu5XLxUWTGvZ/EvKvJjv/AgPb5ZmMbix5bx8YdCSVhIiJ5lIiJDJZskooV/0187UM4OQ8A33GDRwA5LhAOWJrL4vg5yGXB98DP4eSy4ETw3Qi4UXw3Cm40XBYL3kfKguWRWLgsFsw7bjhFwHG79hlpeZfo9nW4HU1dVcxV1JEdbUhNX4A38lC8EVPIjZyKN2IKfvnAH7Lt+z6/fHUzP3jmbarLo9x1zhyOnzpqwNsVEXmvUCImUmi+T9nbS6ledjORlo2kD/kQuapx4OcAH3wf8IPkC8LkKQJuJEyaouBGgvK5bJCUhUmak8uEyzLgha/ZDhwv07UOPxds28+FiZ0Hvk+uegKpQ0/FG3M42XDyKwevZWpnIs13nniDv769g/nTR3PDmTMZXamHd4uI5FMiJlJA0cZVVP31Rso2v0h2zOE0f+JBMpPnF7taB90LG3bw7T+8QWsywzc/+j4+PXcijh5ZJCKyByViIgXgtm+l8sVbia/9JX58FK0nLyZ5xAVBy1YJyXo57n52Aw8s38T0MZXcfe4cZtRXFbtaIiJDlhIxEQguF2aTOJn2YMomcbwkTjYZLA/nXSdBZdNGIu1bcdsbcNsacBNbcVO78N0YHXO/SmLeVQXpXzXctCaz/Nvv1vDyxmbOO3oCV508nXistBJREZH9pURMhi23vYHothVEdr6Fk0ngZDtwvCRkwiQq04GTS0POAz8bdJjv7BCfywafySS6ky/8fu230omQqxpLrmo83qjpZCadiFc9gdT0BeRqpw3yUQ9NW1qSXPWrVby7s4Mbz5rJx2ePL3aVRESGBSViMvR5Kdz2RqLb1xDdtoJo40qijSuJJLbtVsyPxvEjcfxYBX4kDtEK/Ejn3YTh3YbRiuBORCeCH6sMp6pwCt9HK4Ny0XjXRDSOH62gpm4szZmqkrvkuDdrGlq55teryHg+Pzx3DvOm1Ba7SiIiw4YSMSk6J9EUJFlNa4i0vIvb0YibaMLpaMJNNOGmW7rK+o6LN+owMpNPoqN+DpmxR+ONMfix6mBYiMFWs/+jyb+XPf1WE4seW8eYyhhLzp/DtDGVxa6SiMiwokRsKAuHNwjGnNpLmWxq9/5Mfg4/WhG0DMWqILKfQwb4fnDpzgu2hxvD6fCCcasi5eDGek96fB86h1fw0l2fd/L6WJFN4nbsILp9LdHta4g0rd2tZStXXkuusp5cxRi8utn4FWPC+Tqyo2eSrZsNMZ3sh4L7n9/ALUvXccT4Gv7rU7MZU6WhKURE9pcSscGQSeAmtuG2bwteE43BlG4J+iKlW3HS7TiZNpx0G04mAbnucaAcLx0O8ul1bdLPG6ATJxhvyvHSQR+offDdKH40uAyHGyN/LKuwBPh+sL1sErxk1xhXnep6bjNSHiRlENY7E4x31U++GwtatqacTMeYI8jWBZMf12CfQ1ky4/H65hYeX7OVx9Zs45QZY/jugsPVKV9E5AApEetNJsHIxy8mmmpilJfbc73vh4NlBgNmOl3zHk6qBTfTtudHHBe/rAY/Vo1fFk7lI/CqD4FYBb5bBpFo16jpvlsWjJ4OXftyOgfnzOWAXNhCFcePlkOksz9TOTiRoON6V2f0BGTDTunhCO9Bi5aD3zm6u0OwjUh5d5+o8H1FVQUdbe1hK1c6SNS8NHip4LNuDD8S1tctC/tlRcO65fWxCuvql43Aq522/y11ctB5OZ83Gtt4ccNOXtrYzOv/2EXa84m4DhfPn8bFx04i4mp8MBGRA6VErDeOizdiCtHsCLxMH608TgTfiXQ/riZsrcqV1QSX0qrGBa+VY8lVjsWvGL33S4xDWLy2kqT6Rb2nZL0craksu5JZdnVk2JnIsCORZkciE05pdrSneXt7gl3J4Dcwo66K8+ZO5Lgpo3j/pJFMHFtDs74XIiIDokSsN9E4bacsJlpbSYtONDIA6WyOtVtbyeb6NzRGX/cb+Hkfz/k+yUyOZDZHR8YjmfHoyHS+z5H2cqSyHqlsbrepLZWlJZmlNZWlPe31viOgpjzK6MoYoytjnPS+MRx7aC3HThlFnfqAiYgUnBIxkUHwVlM7v13ZwNI1W7talA6G8qhLPOpSHnUpC1/LoxHKIw5ja8o5rL6KEfEYNfEoI+NRauJRRsRjjKmMMaqyjNGVMWKR4dlyKyIyHCkREymQ9nSWp9Y18uiqBlZtaSXqOpwyYwxnHD6WmvJ9/9T8vAFlfX/P1jEn7M/nOBCPusRjESpiESpiLhWxCGVRF1fPcxQRGVaUiInsJ9/3ae7IsKk5yT92JdnU3MGGHQme+ft2OjI5po2p5JpTpvOxWWMZVanLeSIi0jclYvKe4ft+V1+otpRHaypLKpsj5/vBEGf45PygnJeDbC7oO5XOdvarCl7T2aD/Vc8+VsmMR0vaY+P2BInM7n2s6qvLON3U88k5E5gzoQZHLVMiItIPSsRk2Ml4Oey2NlZsbmHF5hbebGynNeyE3t9O8XvjOnT3rerqZxX0vRo/Is7RE2o4pLaCSSPjHFIbZ+KIuMbREhGRA6JETIaUjJejPe3RkfFoT3sk0h6JdHC3X2fytaahlbQXJFwTR8aZNa6a2ooY1eVRqssi1MSjVJdFqY5HiYf9plwHnPC1cz4acSmPhJ3aw9eyiEPEdfps0aqtrdSQDSIiUjBKxKRomjsyrGloZU1DK6vD1x2JTJ/lo67DrHHVnDd3IkdPHMFRE0dQV11+EGssIiJSWP1OxIwxlwHfBCYAq4GrrbXP7qX8ycDtwGxgM3CrtXZJH2WvBW4B7rHWXtH/6g9Pvu/TnvbY3p5mZyJDa2r34Q3yG2Oc/JHvw5fO9b4fjCnV2e+p83VvF+f2aOfJ21ku55PzfbLhq5fz8XyIx2MkkxkiXa1JDq4LkfCzua56+ORy3e8znr9b36vO/ljNHRnWbG1j865kV52mjq7khKmjmDyqgsqyKFWxCJVlwVRVFqGqLMrkURWURzW0goiIvHf0KxEzxnwGuAu4DPhr+Pq4MeYIa+3GXspPA5YCPwE+D8wH7jXGNFprH+lR9oPAV4EVAzmQocL3fVqSWTa3JNmyK7irbktLii0tSba3ByOX70ykuy6tlYrOfldlEZfq8iiHj63m3KMmcMT4Gg4fV011P4Z3EBERea/p79nva8D91tofh/MLjTFnAZcC1/ZS/hJgs7V2YTi/1hhzPPANoCsRM8aMBB4AvgTceAD1HxTJjMf1j61jVzqLl93zWZOdLUBeLmiF8rre++xMZPYYtby6PMKEEXHqqsqYXlfF6IoYo6vKukYvr4nHulqqdkvPwuHU/bzZ7vd+V18n13VwcXDCFqs9m7162/ie41a5rkPUcXBdh0jY4uU6DrW1FTQ3d3S1vuUfe2cLXWcrmesEbXgR1yEWCTq5xyIuUT2PUEREZA/7TMSMMWXAMcBtPVY9CZzYx8dOCNfnewK4yBgTs9Z2dgT6EfCwtfbPxph+J2KRiENtbWV/i++3ZMZjVHU5uYSD7+/ZcuUQJCtRN0hUupIW16G2MsbkUZXBXXWjKphUW8GIitig1fVgiERcxtbEi12NISEScQf1uzecKBbdFIuA4tBNseimWOxdf1rE6oAIsLXH8q3AaX18Zjzwx17KR8PtbTHGfAWYQXDpcr94nj/od64tOm1GQe6Qy6UyNKf67oA+HOhOwW6KRTfFoptiEVAcuikW3RQLqK+v6XNdUTrmGGMMQef8+XmtYyIiIiIlpT+JWBPgAeN6LB8HNPTxmYY+ymfD7Z1J0DK2OsjJgKDV7SRjzCVAlbU21Y+6iYiIiAxb+xwLwFqbBpYDp/dYdTqwrI+PPd9H+VfCFrDfAHOAuXnTK8CD4ft0P+svIiIiMmz199Lk7cDPjTEvAc8R3BU5EVgCYIz5GYC19sKw/BLgCmPMncB9wIeALwIXhOWageb8HRhj2oEd1tpVAzgeERERkWGjX6NjWmsfAq4GrgdeIxgXbIG19p2wyJRw6iy/HlgAnBSWXwRc2XMMMREREZFS5vQ2PMNQl8l4/sG4A0N3egQUh26KRTfFoptiEVAcuikW3RQLqK+vWQ7M622dnhcjIiIiUiRKxERERESKRImYiIiISJEoERMREREpEiViIiIiIkWiRExERESkSJSIiYiIiBTJsBxHDGgE3tlnKREREZHiOxSo723FcE3ERERERIY9XZoUERERKRIlYiIiIiJFokRMREREpEiUiImIiIgUiRIxERERkSJRIiYiIiJSJNFiV2AoMsZcBnwTmACsBq621j5b3FoNLmPMScA3gGOAicC/WGvvz1vvADcCXwVGAS8Cl1trVx/82g4eY8y1wDmAAVLAC8C11tpVeWVKJRaXA/8KTA0XrQZustY+Fq4viTj0FH5HbgHusdZeES4rmVgYY75NcKz5tlprx4frSykWE4DFwAKgBngbuNRa+3S4viRiYYzZQDBOVk9LrbVnh2VK7rzaX2oR68EY8xngLoI/tO8HlgGPG2OmFLVig68aWAVcBXT0sv5bwNeBhcCxwDbgKWNMzUGr4cFxCnAvcCLwUSAL/NEYMzqvTKnEYhPwb8AHgHnA/wC/McYcFa4vlTh0McZ8kOCkuqLHqlKLhSU4oXZOc/LWlUQsjDG1wHOAA5wNzCI45m15xUoiFgTHlv99+ADgA7+Ekj6v9otaxPb0NeB+a+2Pw/mFxpizgEuBa4tXrcFlrV0KLAUwxtyfvy78X93VwGJr7SPhsosI/qh8DrjvoFZ2EFlrz8yfN8Z8AdgFfAj4XYnF4tEeixYZYy4FTjDGrKRE4tDJGDMSeAD4EnktQqX0nciTtdY29FxYYrH4FrDFWnth3rL1nW9KKRbW2sb8eWPMl4EWwkSMEj2v9pdaxPIYY8oILs092WPVkwQtJKVqGjCevLhYazuAZ3jvx6WG4HeyM5wvyVgYYyLGmM8StJwuozTj8CPgYWvtn3ssL8VYTDfGbDbGrDfGPGiMmR4uL6VYfAp40RjzkDFmmzHmNWPMFWECBqUViy7h8X8Z+IW1tkPn1X1TIra7OiACbO2xfCvBD6pUdR57KcblLuA14PlwvqRiYYyZY4xpI+gvtwT4Z2vtSkovDl8BZgDX97K6pGJB0M/pi8BZwFcIjnGZMWYMpRWL6cBlBP3CziT4W7EYuDxcX0qxyHc6QRLa2fql8+o+6NKkSB+MMbcD84H51lqv2PUpEgvMBUYC5wE/NcacUtQaHWTGGEPQt2W+tTZT7PoUm7X28fx5Y8wLBMnIRQQ3t5QKF3jFWtt5ae1VY8xhBInY3cWrVtF9BXjZWvt6sSsyXKhFbHdNgAeM67F8HLBHf4gS0nnsJRMXY8wdwAXAR621b+etKqlYWGvT1tq3rLXLwxPOa8A1lFYcTiD4X/1qY0zWGJMFTgYuC99vD8uVQiz2YK1tI7gL7jBK63uxBVjTY9laoLMDeinFAgBjzFjgk3S3hoHOq/ukRCyPtTYNLCdoWs13OkG/mFK1nuAH0xUXY0wc+DDvwbgYY+6iOwlb12N1ScWiFy5QTmnF4TcEdwXOzZteAR4M379B6cRiD+GxHk6QmJTS9+I5gmFu8s0E3gnfl1IsOn2RoBvD/+tcoPPqvunS5J5uB35ujHmJ4Id2CcG4WkuKWqtBZoypJugDA8HJdooxZi6ww1q70RhzJ3CdMWYdwYnneqAN+L9FqfAgMcbcA3yBoCPuTmNMZx+GNmttm7XWL6FYLAYeA94luGnhcwTDe5xdSnGw1jYDzfnLjDHtBL+NVeF8ScQCwBhzG/A7YCMwFrgBqAJ+WkrfC+AOgr5xi4CHCIZluBK4DqDEYtHZSf9i4MGwlTRfSZ5X+0uJWA/W2ofCTqfXE4yHsgpYYK19Z++fHPbmAfl3g/1HOP2U4H85twIVwD10D0x4hrW29eBWc9BdFr7+qcfy/wC+Hb4vlViMB34Rvu4iGDvrY9baJ8L1pRKH/iilWEwiaPGoAxoJ+oV9MO9vZEnEwlr7sjHmUwT9B28gSExvIBiHsFNJxCJ0CsHl6c/3XFHC59V+cXzfL3YdREREREqS+oiJiIiIFIkSMREREZEiUSImIiIiUiRKxERERESKRImYiIiISJEoERMREREpEiViIiIiIkWiRExERESkSJSIiYiIiBTJ/weedkWC8+6UxgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Trr, label= 'Train RMSE')\n", + "plt.plot(Tss, label= 'Test RMSE')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RSaCDr3kr1uk" + }, + "source": [ + "If we Recursively Eleminate at most **Ten** features then the score is maximum." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y-JxFYhZq5iy", + "outputId": "9f027b4c-21ec-4f9f-8ba6-00ea00312bd5" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'LinearRegression' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn [2], line 4\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# Eleminating 10 features and using Linear Regresion model the error printed as follows which is the best possible score.\u001b[39;00m\n\u001b[0;32m 2\u001b[0m \n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# creating a linear regression model object\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m lm \u001b[38;5;241m=\u001b[39m \u001b[43mLinearRegression\u001b[49m()\n\u001b[0;32m 5\u001b[0m \u001b[38;5;66;03m# creating a rfe model object with linear regression model and with number of features equal to 10.\u001b[39;00m\n\u001b[0;32m 6\u001b[0m rfe \u001b[38;5;241m=\u001b[39m RFE(lm,n_features_to_select\u001b[38;5;241m=\u001b[39mX_train\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m9\u001b[39m) \n", + "\u001b[1;31mNameError\u001b[0m: name 'LinearRegression' is not defined" + ] + } + ], + "source": [ + "# Eleminating 10 features and using Linear Regresion model the error printed as follows which is the best possible score.\n", + "\n", + "# creating a linear regression model object\n", + "lm = LinearRegression()\n", + "# creating a rfe model object with linear regression model and with number of features equal to 10.\n", + "rfe = RFE(lm,n_features_to_select=X_train.shape[1]-9) \n", + "# fitting the rfe model to the trainig dataset\n", + "rfe = rfe.fit(X_train, y_train)\n", + "# creating a linear regression model object for prediction\n", + "LR = LinearRegression()\n", + "# fitted the lr model using the selected features\n", + "LR.fit(X_train.loc[:,rfe.support_], y_train)\n", + "# Made the prediction using the linear regression model\n", + "pred1 = LR.predict(X_train.loc[:,rfe.support_])\n", + "pred2 = LR.predict(X_test.loc[:,rfe.support_])\n", + "# Printing the results as a MSE and r2_score.\n", + "print(\"MSE train\",np.sqrt(mean_squared_error(y_train, pred1)))\n", + "print(\"MSE test\",np.sqrt(mean_squared_error(y_test, pred2)))\n", + "print(\"r2_score train - {}\".format(r2_score(y_train, pred1)))\n", + "print(\"r2_score test - {}\".format(r2_score(y_test, pred2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now Removing the 10 features and create the New training and test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0uSp1k6cv3V9" + }, + "outputs": [], + "source": [ + "X_train = X_train.loc[:,rfe.support_]\n", + "X_test = X_test.loc[:,rfe.support_]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now onwards I am going to use various models " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AkQofSuyBdSD" + }, + "source": [ + "## Linear Regression" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sD6R7U2yv2jB", + "outputId": "0e604f7a-c7b7-4f6f-ec71-aa0c5dd88fd2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Root Mean Squared Error train 0.0016695395619648289\n", + "Root Mean Squared Error test 0.04569350618906344\n", + "r2_score train 0.9324387485162124\n", + "r2_score test 0.9223162582948724\n" + ] + } + ], + "source": [ + "lr =LinearRegression()\n", + "lr.fit(X_train, y_train)\n", + "pred1 = lr.predict(X_train)\n", + "pred2 = lr.predict(X_test)\n", + "\n", + "print(\"Root Mean Squared Error train {}\".format(np.mean(mean_squared_error(y_train, pred1))))\n", + "print(\"Root Mean Squared Error test {}\".format(np.sqrt(mean_squared_error(y_test, pred2))))\n", + "print(\"r2_score train {}\".format(r2_score(y_train, pred1)))\n", + "print(\"r2_score test {}\".format(r2_score(y_test, pred2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x6zJIryQclSZ" + }, + "source": [ + "**Ridge Regression**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r1DrhBkty16r", + "outputId": "6a9023a8-69df-4301-f3b5-ec9d736b5aea" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Root Mean Squared Error train 0.0016713833486400986\n", + "Root Mean Squared Error test 0.04580603645234492\n", + "r2_score train 0.9323641360074176\n", + "r2_score test 0.9219331606995953\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import Ridge\n", + "rr = Ridge()\n", + "rr.fit(X_train, y_train)\n", + "predrr1 = rr.predict(X_train)\n", + "predrr2 = rr.predict(X_test)\n", + "print(\"Root Mean Squared Error train {}\".format(np.mean(mean_squared_error(y_train, predrr1))))\n", + "print(\"Root Mean Squared Error test {}\".format(np.sqrt(mean_squared_error(y_test, predrr2))))\n", + "print(\"r2_score train {}\".format(r2_score(y_train, predrr1)))\n", + "print(\"r2_score test {}\".format(r2_score(y_test, predrr2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2Y0ahAqDu3XD" + }, + "source": [ + "**Lasso Regression**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uUlDM-7ruZDH", + "outputId": "8283d5d8-cd81-45dd-f9a5-0cf93a8c0d12" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Root Mean Squared Error train 0.024711495499242828\n", + "Root Mean Squared Error test 0.16395383804559885\n", + "r2_score train 0.0\n", + "r2_score test -0.00014816618161050954\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import Lasso\n", + "lr = Lasso()\n", + "lr.fit(X_train, y_train)\n", + "predlr1 = lr.predict(X_train)\n", + "predlr2 = lr.predict(X_test)\n", + "print(\"Root Mean Squared Error train {}\".format(np.mean(mean_squared_error(y_train, predlr1))))\n", + "print(\"Root Mean Squared Error test {}\".format(np.sqrt(mean_squared_error(y_test, predlr2))))\n", + "print(\"r2_score train {}\".format(r2_score(y_train, predlr1)))\n", + "print(\"r2_score test {}\".format(r2_score(y_test, predlr2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tLMigwXou6xO" + }, + "source": [ + "**ElasticNet Regression**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NOSOCAYQu_Nr", + "outputId": "d1dc41ce-23b8-4368-ddaa-7ff05985ee63" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Root Mean Squared Error train 0.024711495499242828\n", + "Root Mean Squared Error test 0.16395383804559885\n", + "r2_score train 0.0\n", + "r2_score test -0.00014816618161050954\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import ElasticNet\n", + "en = ElasticNet()\n", + "en.fit(X_train, y_train)\n", + "predlr1 = en.predict(X_train)\n", + "predlr2 = en.predict(X_test)\n", + "print(\"Root Mean Squared Error train {}\".format(np.mean(mean_squared_error(y_train, predlr1))))\n", + "print(\"Root Mean Squared Error test {}\".format(np.sqrt(mean_squared_error(y_test, predlr2))))\n", + "print(\"r2_score train {}\".format(r2_score(y_train, predlr1)))\n", + "print(\"r2_score test {}\".format(r2_score(y_test, predlr2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CETh_HMie4MC" + }, + "source": [ + "**Polynomial Regression**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zB8BwPRDfjH6" + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mQCHSdJ2hXwM" + }, + "outputs": [], + "source": [ + "Trr = []\n", + "Tss = []\n", + "for i in range(2,4):\n", + " poly_reg = PolynomialFeatures(degree = i)\n", + " pl_X_train = poly_reg.fit_transform(X_train)\n", + " pl_X_test = poly_reg.fit_transform(X_test)\n", + " lr = LinearRegression()\n", + " lr.fit(pl_X_train, y_train)\n", + " pred_poly_train = lr.predict(pl_X_train)\n", + " Trr.append(np.sqrt(mean_squared_error(y_train, pred_poly_train)))\n", + " pred_poly_test = lr.predict(pl_X_test)\n", + " Tss.append(np.sqrt(mean_squared_error(y_test, pred_poly_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "imp9hsFDlGZ8", + "outputId": "64eef10d-d211-428c-e41f-ff10d8de6c89" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[15,6])\n", + "plt.subplot(1,2,1)\n", + "plt.plot(range(2,4), Trr, label= 'Training')\n", + "plt.plot(range(2,4), Tss, label= 'Testing')\n", + "plt.title('Polynomial Feature on training data')\n", + "plt.xlabel('Degree')\n", + "plt.ylabel('RMSE')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gRYxfuQqpcvD" + }, + "source": [ + "It is clear that in between 2-4 degree polynomial regression 2 has Bais-variance tradeoff" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mHBnSFZzlTai", + "outputId": "afac8ffa-8b79-4b95-eae7-7d268bdf42c6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "r2_score train 0.9563932198334125\n", + "r2_score test -0.0005599911350040454\n", + "Root Mean Squared Error train 0.0010346077251656776\n", + "Root Mean Squared Error test 730742413.004261\n" + ] + } + ], + "source": [ + "poly_reg = PolynomialFeatures(degree = 2)\n", + "pl_X_train = poly_reg.fit_transform(X_train)\n", + "pl_X_test = poly_reg.fit_transform(X_test)\n", + "lr = LinearRegression()\n", + "lr.fit(pl_X_train, y_train)\n", + "pred_poly_train = lr.predict(pl_X_train)\n", + "print(\"r2_score train {}\".format(r2_score(pred_poly_train, y_train)))\n", + "pred_poly_test = lr.predict(pl_X_test)\n", + "print(\"r2_score test {}\".format(r2_score(pred_poly_test, y_test)))\n", + "print(\"Root Mean Squared Error train {}\".format(np.mean(mean_squared_error(y_train, pred_poly_train))))\n", + "print(\"Root Mean Squared Error test {}\".format(np.sqrt(mean_squared_error(y_test, pred_poly_test))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6HoezSNiqmss" + }, + "outputs": [], + "source": [ + "#creating a tabel \n", + "tabel = {\n", + " 'Train R2': [0.9324387485162124, 0.9323641360074176, 0.0, 0.0, 0.9563932198334125],\n", + " 'Test R2' : [0.9223162582948724, 0.9219331606995953, -0.00014816618161050954, -0.00014816618161050954, -0.0005599911350040454],\n", + " 'Train RMSE' : [0.0016695395619648289, 0.0016713833486400986, 0.024711495499242828, 0.024711495499242828, 0.0010346077251656776 ],\n", + " 'Test RMSE' : [0.04569350618906344, 0.04580603645234492, 0.16395383804559885, 0.16395383804559885, 730742413.004261 ]\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "15aJ93r7sZxk" + }, + "outputs": [], + "source": [ + "df_new = pd.DataFrame(tabel) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NRpZ7pq2t8iK" + }, + "outputs": [], + "source": [ + "df_new.index = ['Linear Regression', 'Ridge Regression', 'Lasso Regression', 'ElasticNet Regression', 'Polynomial Regression']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "h5ss0EGQuMEs", + "outputId": "55be9aa5-fb47-47a8-e36f-343e36072b68" + }, + "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", + "
Train R2Test R2Train RMSETest RMSE
Linear Regression0.9324390.9223160.0016704.569351e-02
Ridge Regression0.9323640.9219330.0016714.580604e-02
Lasso Regression0.000000-0.0001480.0247111.639538e-01
ElasticNet Regression0.000000-0.0001480.0247111.639538e-01
Polynomial Regression0.956393-0.0005600.0010357.307424e+08
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Train R2 Test R2 Train RMSE Test RMSE\n", + "Linear Regression 0.932439 0.922316 0.001670 4.569351e-02\n", + "Ridge Regression 0.932364 0.921933 0.001671 4.580604e-02\n", + "Lasso Regression 0.000000 -0.000148 0.024711 1.639538e-01\n", + "ElasticNet Regression 0.000000 -0.000148 0.024711 1.639538e-01\n", + "Polynomial Regression 0.956393 -0.000560 0.001035 7.307424e+08" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_new" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "U1dNQB1KvuP-" + }, + "source": [ + "It is clear that Linear Regression is the Best Model in the dataset, with test accuracy of 92%(approx). \n", + "\n", + "To improve the accuracy further we can apply other regressor i.e. Random Forest, G" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hC-CZ3klm8A9" + }, + "source": [ + "Now I am going to imporve the accuracy till 98% - 99%. For this I have to use Decision Tree or Random Forest etc." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a_LqH0uUt-7V" + }, + "source": [ + "**Decision Tree Regressor**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4zzf04E_ndeG", + "outputId": "bd692f88-5ff2-41ff-ff3b-70e074cf2ee8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "DecisionTreeRegressor()" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.tree import DecisionTreeRegressor\n", + "dt = DecisionTreeRegressor()\n", + "dt.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TLXmPbdkqyA2", + "outputId": "7bbacea4-67e3-43ec-b99a-d38438df1ff7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE for train 0.02816270639447925\n", + "RMSE for test 0.05659037012899937\n", + "Accuracy Score train: 0.9679040861170889\n", + "Accuracy Score test: 0.8808466556220073\n" + ] + } + ], + "source": [ + "pred_dt1 = dt.predict(X_train)\n", + "pred_dt2 = dt.predict(X_test)\n", + "print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_dt1))))\n", + "print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_dt2))))\n", + "print('Accuracy Score train: ', dt.score(X_train, y_train))\n", + "print('Accuracy Score test: ', dt.score(X_test, y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xPOkbi7Z6FkT" + }, + "outputs": [], + "source": [ + "max_depth_range = np.arange(1,40,1)\n", + "for x in max_depth_range:\n", + " dt = DecisionTreeRegressor(max_depth= x)\n", + " dt.fit(X_train, y_train)\n", + " pred_dt1 = dt.predict(X_train)\n", + " pred_dt2 = dt.predict(X_test)\n", + " print('for max_depth: ', x)\n", + " print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_dt1))))\n", + " print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_dt2))))\n", + " print('Accuracy Score train: ', dt.score(X_train, y_train))\n", + " print('Accuracy Score test: ', dt.score(X_test, y_test))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vPCmEkY3_aUL" + }, + "source": [ + "Decision Tree has maximum accuracy at **maximum depth 39** " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ynbvHfSzuDKV" + }, + "source": [ + "**Random Forest Regressor**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WyP5xkl_rkH5", + "outputId": "f24466ce-7712-40d3-a8bb-1e619269a489" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "RandomForestRegressor()" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "rfc = RandomForestRegressor()\n", + "rfc.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7-Wey9Dduy9x", + "outputId": "8ca5ab06-5482-40c9-e82a-b26f0712fccb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE for train 0.028304398176036298\n", + "RMSE for test 0.051356545554440226\n", + "Accuracy Score train: 0.9520754860405363\n", + "Accuracy Score test: 0.8969168840066629\n" + ] + } + ], + "source": [ + "pred_rfc1 = rfc.predict(X_train)\n", + "pred_rfc2 = rfc.predict(X_test)\n", + "print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_rfc1))))\n", + "print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_rfc2))))\n", + "print('Accuracy Score train: ', dt.score(X_train, y_train))\n", + "print('Accuracy Score test: ', dt.score(X_test, y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HGSiy0Bb2wc4" + }, + "outputs": [], + "source": [ + "max_depth_range = np.arange(1,40,1)\n", + "for x in max_depth_range:\n", + " dt = RandomForestRegressor(max_depth= x)\n", + " dt.fit(X_train, y_train)\n", + " pred_xg1 = dt.predict(X_train)\n", + " pred_xg2 = dt.predict(X_test)\n", + " print('for max_depth: ', x)\n", + " print('for max_depth: ', x)\n", + " print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_xg1))))\n", + " print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_xg2))))\n", + " print('Accuracy Score train: ', dt.score(X_train, y_train))\n", + " print('Accuracy Score test: ', dt.score(X_test, y_test))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AMjPAWZ-4aEY" + }, + "source": [ + "In the depth of **36** the** Random Forest Regressor** has its maximum value of accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D6Yv0koP5OFD", + "outputId": "a0f18f68-ea31-4f29-c81a-97f5fde388ec" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE for train 0.02992618589836856\n", + "RMSE for test 0.051110374979016944\n", + "Accuracy Score train: 0.9637587048322853\n", + "Accuracy Score test: 0.9028060343874318\n" + ] + } + ], + "source": [ + "rfc = RandomForestRegressor(max_depth = 36)\n", + "rfc.fit(X_train, y_train)\n", + "pred_rfc1 = rfc.predict(X_train)\n", + "pred_rfc2 = rfc.predict(X_test)\n", + "print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_rfc1))))\n", + "print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_rfc2))))\n", + "print('Accuracy Score train: ', rfc.score(X_train, y_train))\n", + "print('Accuracy Score test: ', rfc.score(X_test, y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eT3uhPIBvPpy" + }, + "source": [ + "**XG Boost Regressor**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1NHxJAtlvMK9" + }, + "outputs": [], + "source": [ + "from xgboost import XGBRegressor\n", + "xg = XGBRegressor()\n", + "xg.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6vNkacpIwbn_", + "outputId": "dc3a75a1-6668-4bb0-f2e9-4d6963be7fc6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE for train 0.06244578034875512\n", + "RMSE for test 0.0686852771272921\n" + ] + } + ], + "source": [ + "pred_xg1 = xg.predict(X_train)\n", + "pred_xg2 = xg.predict(X_test)\n", + "print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_xg1))))\n", + "print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_xg2))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "hTsFSkZPw-0I" + }, + "outputs": [], + "source": [ + "max_depth_range = np.arange(1,15,1)\n", + "for x in max_depth_range:\n", + " dt = XGBRegressor(max_depth= x)\n", + " dt.fit(X_train, y_train)\n", + " pred_xg1 = dt.predict(X_train)\n", + " pred_xg2 = dt.predict(X_test)\n", + " print('for max_depth: ', x)\n", + " print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_xg1))))\n", + " print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_xg2))))\n", + " print('Accuracy Score train: ', dt.score(X_train, y_train))\n", + " print('Accuracy Score test: ', dt.score(X_test, y_test))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vl_Nj4Z3ysbg" + }, + "source": [ + "It means **maximun depth 9** has best value of Accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lxz4Cgl9x380", + "outputId": "c6503f69-49a6-4eca-f918-41b5afddc31b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[19:57:14] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.\n", + "RMSE for train 0.03137907401148098\n", + "RMSE for test 0.04876553192516943\n", + "Accuracy Score train: 0.9601543222728802\n", + "Accuracy Score test: 0.9115195955339979\n" + ] + } + ], + "source": [ + "xg = XGBRegressor(max_depth = 9)\n", + "xg.fit(X_train, y_train)\n", + "pred_xg1 = xg.predict(X_train)\n", + "pred_xg2 = xg.predict(X_test)\n", + "print(\"RMSE for train {}\".format(np.sqrt(mean_squared_error(y_train, pred_xg1))))\n", + "print(\"RMSE for test {}\".format(np.sqrt(mean_squared_error(y_test, pred_xg2))))\n", + "print('Accuracy Score train: ', xg.score(X_train, y_train))\n", + "print('Accuracy Score test: ', xg.score(X_test, y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VBj4oaqs2JIA" + }, + "outputs": [], + "source": [ + "tabel1 = {\n", + " 'Train Score': [0.9679040861170889, 0.9637587048322853, 0.9601543222728802], \n", + " 'Test Score' : [0.8808466556220073, 0.9028060343874318, 0.9115195955339979],\n", + " 'Train RMSE' : [0.02816270639447925, 0.02992618589836856, 0.03137907401148098],\n", + " 'Test RMSE' : [0.05659037012899937, 0.051110374979016944, 0.04876553192516943]\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rVAtta7hAVMx" + }, + "outputs": [], + "source": [ + "df1 = pd.DataFrame(tabel1) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "k8crGwRUBf1q", + "outputId": "e59bd920-da99-4c42-ca10-2086255b7e79" + }, + "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", + "
Train ScoreTest ScoreTrain RMSETest RMSE
00.9679040.8808470.0281630.056590
10.9637590.9028060.0299260.051110
20.9601540.9115200.0313790.048766
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Train Score Test Score Train RMSE Test RMSE\n", + "0 0.967904 0.880847 0.028163 0.056590\n", + "1 0.963759 0.902806 0.029926 0.051110\n", + "2 0.960154 0.911520 0.031379 0.048766" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a9VZnwLWBhrw" + }, + "outputs": [], + "source": [ + "df1.index = ['Decision Tree', 'Random Forest', 'XGBoost']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "CHhpP5rXBqwS", + "outputId": "66a65c86-48d0-421f-ab92-21ff55154d45" + }, + "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", + "
Train ScoreTest ScoreTrain RMSETest RMSE
Decision Tree0.9679040.8808470.0281630.056590
Random Forest0.9637590.9028060.0299260.051110
XGBoost0.9601540.9115200.0313790.048766
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " Train Score Test Score Train RMSE Test RMSE\n", + "Decision Tree 0.967904 0.880847 0.028163 0.056590\n", + "Random Forest 0.963759 0.902806 0.029926 0.051110\n", + "XGBoost 0.960154 0.911520 0.031379 0.048766" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xKGedPiHEM-_" + }, + "source": [ + "Among the method XGBoost is the best method for the data set" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xXCWIMqCEhbu" + }, + "source": [ + "By Comparising the Linear and XGBoost we can conclude that linear Regression the best suited for the above data set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bagD1h3yH3p2" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Walmart_1.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}