From c1950e54471114c21ba0bb4e49209947bea1a79e Mon Sep 17 00:00:00 2001 From: Nour <103857470+Nourahmed31@users.noreply.github.com> Date: Thu, 8 Sep 2022 16:21:34 +0200 Subject: [PATCH] new versionn --- BigMart Mini Project (Ver2) (1).ipynb | 2344 +++++++++++++++++++++++++ 1 file changed, 2344 insertions(+) create mode 100644 BigMart Mini Project (Ver2) (1).ipynb diff --git a/BigMart Mini Project (Ver2) (1).ipynb b/BigMart Mini Project (Ver2) (1).ipynb new file mode 100644 index 0000000..f83d554 --- /dev/null +++ b/BigMart Mini Project (Ver2) (1).ipynb @@ -0,0 +1,2344 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "0b76993e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from xgboost import XGBRegressor\n", + "from sklearn import metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9ca5284a", + "metadata": {}, + "outputs": [], + "source": [ + "train_data=pd.read_csv(\"Train.csv\")\n", + "test_data=pd.read_csv('Test.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "278ccd00", + "metadata": {}, + "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", + "
Item_IdentifierItem_WeightItem_Fat_ContentItem_VisibilityItem_TypeItem_MRPOutlet_IdentifierOutlet_Establishment_YearOutlet_SizeOutlet_Location_TypeOutlet_TypeItem_Outlet_Sales
0FDA159.30Low Fat0.016047Dairy249.8092OUT0491999MediumTier 1Supermarket Type13735.1380
1DRC015.92Regular0.019278Soft Drinks48.2692OUT0182009MediumTier 3Supermarket Type2443.4228
2FDN1517.50Low Fat0.016760Meat141.6180OUT0491999MediumTier 1Supermarket Type12097.2700
3FDX0719.20Regular0.000000Fruits and Vegetables182.0950OUT0101998NaNTier 3Grocery Store732.3800
4NCD198.93Low Fat0.000000Household53.8614OUT0131987HighTier 3Supermarket Type1994.7052
\n", + "
" + ], + "text/plain": [ + " Item_Identifier Item_Weight Item_Fat_Content Item_Visibility \\\n", + "0 FDA15 9.30 Low Fat 0.016047 \n", + "1 DRC01 5.92 Regular 0.019278 \n", + "2 FDN15 17.50 Low Fat 0.016760 \n", + "3 FDX07 19.20 Regular 0.000000 \n", + "4 NCD19 8.93 Low Fat 0.000000 \n", + "\n", + " Item_Type Item_MRP Outlet_Identifier \\\n", + "0 Dairy 249.8092 OUT049 \n", + "1 Soft Drinks 48.2692 OUT018 \n", + "2 Meat 141.6180 OUT049 \n", + "3 Fruits and Vegetables 182.0950 OUT010 \n", + "4 Household 53.8614 OUT013 \n", + "\n", + " Outlet_Establishment_Year Outlet_Size Outlet_Location_Type \\\n", + "0 1999 Medium Tier 1 \n", + "1 2009 Medium Tier 3 \n", + "2 1999 Medium Tier 1 \n", + "3 1998 NaN Tier 3 \n", + "4 1987 High Tier 3 \n", + "\n", + " Outlet_Type Item_Outlet_Sales \n", + "0 Supermarket Type1 3735.1380 \n", + "1 Supermarket Type2 443.4228 \n", + "2 Supermarket Type1 2097.2700 \n", + "3 Grocery Store 732.3800 \n", + "4 Supermarket Type1 994.7052 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3b0d872f", + "metadata": {}, + "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", + "
Item_IdentifierItem_WeightItem_Fat_ContentItem_VisibilityItem_TypeItem_MRPOutlet_IdentifierOutlet_Establishment_YearOutlet_SizeOutlet_Location_TypeOutlet_Type
0FDW5820.750Low Fat0.007565Snack Foods107.8622OUT0491999MediumTier 1Supermarket Type1
1FDW148.300reg0.038428Dairy87.3198OUT0172007NaNTier 2Supermarket Type1
2NCN5514.600Low Fat0.099575Others241.7538OUT0101998NaNTier 3Grocery Store
3FDQ587.315Low Fat0.015388Snack Foods155.0340OUT0172007NaNTier 2Supermarket Type1
4FDY38NaNRegular0.118599Dairy234.2300OUT0271985MediumTier 3Supermarket Type3
\n", + "
" + ], + "text/plain": [ + " Item_Identifier Item_Weight Item_Fat_Content Item_Visibility Item_Type \\\n", + "0 FDW58 20.750 Low Fat 0.007565 Snack Foods \n", + "1 FDW14 8.300 reg 0.038428 Dairy \n", + "2 NCN55 14.600 Low Fat 0.099575 Others \n", + "3 FDQ58 7.315 Low Fat 0.015388 Snack Foods \n", + "4 FDY38 NaN Regular 0.118599 Dairy \n", + "\n", + " Item_MRP Outlet_Identifier Outlet_Establishment_Year Outlet_Size \\\n", + "0 107.8622 OUT049 1999 Medium \n", + "1 87.3198 OUT017 2007 NaN \n", + "2 241.7538 OUT010 1998 NaN \n", + "3 155.0340 OUT017 2007 NaN \n", + "4 234.2300 OUT027 1985 Medium \n", + "\n", + " Outlet_Location_Type Outlet_Type \n", + "0 Tier 1 Supermarket Type1 \n", + "1 Tier 2 Supermarket Type1 \n", + "2 Tier 3 Grocery Store \n", + "3 Tier 2 Supermarket Type1 \n", + "4 Tier 3 Supermarket Type3 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "983f35de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train_data: (8523, 12)\n", + "Test_data: (5681, 11)\n" + ] + } + ], + "source": [ + "print('Train_data:',train_data.shape)\n", + "print('Test_data:',test_data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5a0df194", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Item_Identifier 0\n", + "Item_Weight 1463\n", + "Item_Fat_Content 0\n", + "Item_Visibility 0\n", + "Item_Type 0\n", + "Item_MRP 0\n", + "Outlet_Identifier 0\n", + "Outlet_Establishment_Year 0\n", + "Outlet_Size 2410\n", + "Outlet_Location_Type 0\n", + "Outlet_Type 0\n", + "Item_Outlet_Sales 0\n", + "dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0dffc05b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Item_Identifier 0\n", + "Item_Weight 976\n", + "Item_Fat_Content 0\n", + "Item_Visibility 0\n", + "Item_Type 0\n", + "Item_MRP 0\n", + "Outlet_Identifier 0\n", + "Outlet_Establishment_Year 0\n", + "Outlet_Size 1606\n", + "Outlet_Location_Type 0\n", + "Outlet_Type 0\n", + "dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9d03881b", + "metadata": {}, + "outputs": [], + "source": [ + "train_data['source'] = 'train'\n", + "test_data['source'] = 'test'\n", + "df=pd.concat([train_data,test_data], ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b55dbc8a", + "metadata": {}, + "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", + "
Item_IdentifierItem_WeightItem_Fat_ContentItem_VisibilityItem_TypeItem_MRPOutlet_IdentifierOutlet_Establishment_YearOutlet_SizeOutlet_Location_TypeOutlet_TypeItem_Outlet_Salessource
0FDA159.30Low Fat0.016047Dairy249.8092OUT0491999MediumTier 1Supermarket Type13735.1380train
1DRC015.92Regular0.019278Soft Drinks48.2692OUT0182009MediumTier 3Supermarket Type2443.4228train
2FDN1517.50Low Fat0.016760Meat141.6180OUT0491999MediumTier 1Supermarket Type12097.2700train
3FDX0719.20Regular0.000000Fruits and Vegetables182.0950OUT0101998NaNTier 3Grocery Store732.3800train
4NCD198.93Low Fat0.000000Household53.8614OUT0131987HighTier 3Supermarket Type1994.7052train
\n", + "
" + ], + "text/plain": [ + " Item_Identifier Item_Weight Item_Fat_Content Item_Visibility \\\n", + "0 FDA15 9.30 Low Fat 0.016047 \n", + "1 DRC01 5.92 Regular 0.019278 \n", + "2 FDN15 17.50 Low Fat 0.016760 \n", + "3 FDX07 19.20 Regular 0.000000 \n", + "4 NCD19 8.93 Low Fat 0.000000 \n", + "\n", + " Item_Type Item_MRP Outlet_Identifier \\\n", + "0 Dairy 249.8092 OUT049 \n", + "1 Soft Drinks 48.2692 OUT018 \n", + "2 Meat 141.6180 OUT049 \n", + "3 Fruits and Vegetables 182.0950 OUT010 \n", + "4 Household 53.8614 OUT013 \n", + "\n", + " Outlet_Establishment_Year Outlet_Size Outlet_Location_Type \\\n", + "0 1999 Medium Tier 1 \n", + "1 2009 Medium Tier 3 \n", + "2 1999 Medium Tier 1 \n", + "3 1998 NaN Tier 3 \n", + "4 1987 High Tier 3 \n", + "\n", + " Outlet_Type Item_Outlet_Sales source \n", + "0 Supermarket Type1 3735.1380 train \n", + "1 Supermarket Type2 443.4228 train \n", + "2 Supermarket Type1 2097.2700 train \n", + "3 Grocery Store 732.3800 train \n", + "4 Supermarket Type1 994.7052 train " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0ec3cc52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Item_Identifier 0\n", + "Item_Weight 2439\n", + "Item_Fat_Content 0\n", + "Item_Visibility 0\n", + "Item_Type 0\n", + "Item_MRP 0\n", + "Outlet_Identifier 0\n", + "Outlet_Establishment_Year 0\n", + "Outlet_Size 4016\n", + "Outlet_Location_Type 0\n", + "Outlet_Type 0\n", + "Item_Outlet_Sales 5681\n", + "source 0\n", + "dtype: int64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cf7000db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(14204, 13)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "63940676", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]),\n", + " [Text(0, 0, 'Dairy'),\n", + " Text(1, 0, 'Soft Drinks'),\n", + " Text(2, 0, 'Meat'),\n", + " Text(3, 0, 'Fruits and Vegetables'),\n", + " Text(4, 0, 'Household'),\n", + " Text(5, 0, 'Baking Goods'),\n", + " Text(6, 0, 'Snack Foods'),\n", + " Text(7, 0, 'Frozen Foods'),\n", + " Text(8, 0, 'Breakfast'),\n", + " Text(9, 0, 'Health and Hygiene'),\n", + " Text(10, 0, 'Hard Drinks'),\n", + " Text(11, 0, 'Canned'),\n", + " Text(12, 0, 'Breads'),\n", + " Text(13, 0, 'Starchy Foods'),\n", + " Text(14, 0, 'Others'),\n", + " Text(15, 0, 'Seafood')])" + ] + }, + "execution_count": 13, + "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,10))\n", + "sns.countplot(train_data.Item_Type)\n", + "plt.xticks(rotation=90)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e4e67b4b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Fruits and Vegetables 1232\n", + "Snack Foods 1200\n", + "Household 910\n", + "Frozen Foods 856\n", + "Dairy 682\n", + "Canned 649\n", + "Baking Goods 648\n", + "Health and Hygiene 520\n", + "Soft Drinks 445\n", + "Meat 425\n", + "Breads 251\n", + "Hard Drinks 214\n", + "Others 169\n", + "Starchy Foods 148\n", + "Breakfast 110\n", + "Seafood 64\n", + "Name: Item_Type, dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.Item_Type.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2cf96212", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "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=(10,8))\n", + "sns.countplot(train_data.Outlet_Size)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "97e220de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Medium 2793\n", + "Small 2388\n", + "High 932\n", + "Name: Outlet_Size, dtype: int64" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.Outlet_Size.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9c922ea0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "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=(10,8))\n", + "sns.countplot(train_data.Outlet_Location_Type)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "78d0a6e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Tier 3 3350\n", + "Tier 2 2785\n", + "Tier 1 2388\n", + "Name: Outlet_Location_Type, dtype: int64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.Outlet_Location_Type.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2019d1e7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\seaborn\\_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([0, 1, 2, 3]),\n", + " [Text(0, 0, 'Supermarket Type1'),\n", + " Text(1, 0, 'Supermarket Type2'),\n", + " Text(2, 0, 'Grocery Store'),\n", + " Text(3, 0, 'Supermarket Type3')])" + ] + }, + "execution_count": 19, + "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=(10,8))\n", + "sns.countplot(train_data.Outlet_Type)\n", + "plt.xticks(rotation=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "2ea5d8bc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Supermarket Type1 5577\n", + "Grocery Store 1083\n", + "Supermarket Type3 935\n", + "Supermarket Type2 928\n", + "Name: Outlet_Type, dtype: int64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.Outlet_Type.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "6b63a08a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Low Fat 8485\n", + "Regular 4824\n", + "LF 522\n", + "reg 195\n", + "low fat 178\n", + "Name: Item_Fat_Content, dtype: int64" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Item_Fat_Content'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "275e786f", + "metadata": {}, + "outputs": [], + "source": [ + "df['Item_Fat_Content'] = df['Item_Fat_Content'].replace({'LF':'Low Fat','reg':'Regular','low fat':'Low Fat',})" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "53122524", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Low Fat 9185\n", + "Regular 5019\n", + "Name: Item_Fat_Content, dtype: int64" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Item_Fat_Content'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d3b276c3", + "metadata": {}, + "outputs": [], + "source": [ + "train_data['Item_Fat_Content'] = train_data['Item_Fat_Content'].replace({'LF':'Low Fat','reg':'Regular','low fat':'Low Fat',})" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "4b480736", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Item_Fat_Content_pivot =\\\n", + "train_data.pivot_table(index='Item_Fat_Content',values='Item_Outlet_Sales',aggfunc=np.median)\n", + "\n", + "Item_Fat_Content_pivot.plot(kind='bar',color='blue',figsize=(12,7))\n", + "plt.xlabel('Item_Fat_Content')\n", + "plt.ylabel(\"Item_Outlet_Sales\")\n", + "plt.title(\"Impact of Item_Fat_Content on Item_Outlet_Sales\")\n", + "plt.xticks(rotation=0)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cbca0f0d", + "metadata": {}, + "outputs": [], + "source": [ + "df['Item_Weight'].fillna(df['Item_Weight'].mean(), inplace=True)\n", + "#missing values have been replaced with the mean using the fillna function." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d5ba4ee9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 Medium\n", + "Name: Outlet_Size, dtype: object" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# getting Mode \"what occurs most number of times\" for outlet size\n", + "df['Outlet_Size'].mode()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "55a826d4", + "metadata": {}, + "outputs": [], + "source": [ + "# fillinf missing values in outlet_size by Mode\n", + "df['Outlet_Size'].fillna(df['Outlet_Size'].mode()[0],inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c4fb9c1d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#cheking\n", + "df['Outlet_Size'].isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5d4e5d4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Item_Identifier 0\n", + "Item_Weight 0\n", + "Item_Fat_Content 0\n", + "Item_Visibility 0\n", + "Item_Type 0\n", + "Item_MRP 0\n", + "Outlet_Identifier 0\n", + "Outlet_Establishment_Year 0\n", + "Outlet_Size 0\n", + "Outlet_Location_Type 0\n", + "Outlet_Type 0\n", + "Item_Outlet_Sales 5681\n", + "source 0\n", + "dtype: int64" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum() #now we do not have any null values in Outlet_Size" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "6e41ed00", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(8523, 13)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "48e444a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5681, 12)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "dd78db5e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(14204, 13)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "8acc3f85", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "879" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['Item_Visibility']==0]['Item_Visibility'].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "9e319538", + "metadata": {}, + "outputs": [], + "source": [ + "df['Item_Visibility'].fillna(df['Item_Visibility'].median(), inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "ddf4f3d0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1985 2439\n", + "1987 1553\n", + "1999 1550\n", + "1997 1550\n", + "2004 1550\n", + "2002 1548\n", + "2009 1546\n", + "2007 1543\n", + "1998 925\n", + "Name: Outlet_Establishment_Year, dtype: int64" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Outlet_Establishment_Year'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "2916aa89", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 14204.000000\n", + "mean 15.169319\n", + "std 8.371664\n", + "min 4.000000\n", + "25% 9.000000\n", + "50% 14.000000\n", + "75% 26.000000\n", + "max 28.000000\n", + "Name: Outlet_Years, dtype: float64" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Outlet_Years'] = 2013-df['Outlet_Establishment_Year']\n", + "df['Outlet_Years'].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "adee4d7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Fruits and Vegetables 2013\n", + "Snack Foods 1989\n", + "Household 1548\n", + "Frozen Foods 1426\n", + "Dairy 1136\n", + "Baking Goods 1086\n", + "Canned 1084\n", + "Health and Hygiene 858\n", + "Meat 736\n", + "Soft Drinks 726\n", + "Breads 416\n", + "Hard Drinks 362\n", + "Others 280\n", + "Starchy Foods 269\n", + "Breakfast 186\n", + "Seafood 89\n", + "Name: Item_Type, dtype: int64" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Item_Type'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "5e064363", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FDU15 10\n", + "FDS25 10\n", + "FDA38 10\n", + "FDW03 10\n", + "FDJ10 10\n", + " ..\n", + "FDR51 7\n", + "FDM52 7\n", + "DRN11 7\n", + "FDH58 7\n", + "NCW54 7\n", + "Name: Item_Identifier, Length: 1559, dtype: int64" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['Item_Identifier'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "465af876", + "metadata": {}, + "outputs": [], + "source": [ + "#Changing only the first 2 characters (i.e. the category ID)\n", + "\n", + "df['New_Item_type'] = df['Item_Identifier'].apply(lambda x: x[0:2])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "a257c078", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Food 10201\n", + "Non-Consumable 2686\n", + "Drinks 1317\n", + "Name: New_Item_type, dtype: int64" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Rename them to more intuitive categories:\n", + "\n", + "df['New_Item_type'] = df['New_Item_type'].map({'FD':'Food','NC':'Non-Consumable','DR':'Drinks'})\n", + "df['New_Item_type'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "15c28047", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Low Fat 6499\n", + "Regular 5019\n", + "Non-Edible 2686\n", + "Name: Item_Fat_Content, dtype: int64" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df['New_Item_type']=='Non-Consumable','Item_Fat_Content']= \"Non-Edible\"\n", + "df['Item_Fat_Content'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "32790678", + "metadata": {}, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Item_IdentifierItem_WeightItem_Fat_ContentItem_VisibilityItem_TypeItem_MRPOutlet_IdentifierOutlet_Establishment_YearOutlet_SizeOutlet_Location_TypeOutlet_TypeItem_Outlet_SalessourceOutlet_YearsNew_Item_type
0FDA159.300000Low Fat0.016047Dairy249.8092OUT0491999MediumTier 1Supermarket Type13735.1380train14Food
1DRC015.920000Regular0.019278Soft Drinks48.2692OUT0182009MediumTier 3Supermarket Type2443.4228train4Drinks
2FDN1517.500000Low Fat0.016760Meat141.6180OUT0491999MediumTier 1Supermarket Type12097.2700train14Food
3FDX0719.200000Regular0.000000Fruits and Vegetables182.0950OUT0101998MediumTier 3Grocery Store732.3800train15Food
4NCD198.930000Non-Edible0.000000Household53.8614OUT0131987HighTier 3Supermarket Type1994.7052train26Non-Consumable
5FDP3610.395000Regular0.000000Baking Goods51.4008OUT0182009MediumTier 3Supermarket Type2556.6088train4Food
6FDO1013.650000Regular0.012741Snack Foods57.6588OUT0131987HighTier 3Supermarket Type1343.5528train26Food
7FDP1012.792854Low Fat0.127470Snack Foods107.7622OUT0271985MediumTier 3Supermarket Type34022.7636train28Food
8FDH1716.200000Regular0.016687Frozen Foods96.9726OUT0452002MediumTier 2Supermarket Type11076.5986train11Food
9FDU2819.200000Regular0.094450Frozen Foods187.8214OUT0172007MediumTier 2Supermarket Type14710.5350train6Food
\n", + "
" + ], + "text/plain": [ + " Item_Identifier Item_Weight Item_Fat_Content Item_Visibility \\\n", + "0 FDA15 9.300000 Low Fat 0.016047 \n", + "1 DRC01 5.920000 Regular 0.019278 \n", + "2 FDN15 17.500000 Low Fat 0.016760 \n", + "3 FDX07 19.200000 Regular 0.000000 \n", + "4 NCD19 8.930000 Non-Edible 0.000000 \n", + "5 FDP36 10.395000 Regular 0.000000 \n", + "6 FDO10 13.650000 Regular 0.012741 \n", + "7 FDP10 12.792854 Low Fat 0.127470 \n", + "8 FDH17 16.200000 Regular 0.016687 \n", + "9 FDU28 19.200000 Regular 0.094450 \n", + "\n", + " Item_Type Item_MRP Outlet_Identifier \\\n", + "0 Dairy 249.8092 OUT049 \n", + "1 Soft Drinks 48.2692 OUT018 \n", + "2 Meat 141.6180 OUT049 \n", + "3 Fruits and Vegetables 182.0950 OUT010 \n", + "4 Household 53.8614 OUT013 \n", + "5 Baking Goods 51.4008 OUT018 \n", + "6 Snack Foods 57.6588 OUT013 \n", + "7 Snack Foods 107.7622 OUT027 \n", + "8 Frozen Foods 96.9726 OUT045 \n", + "9 Frozen Foods 187.8214 OUT017 \n", + "\n", + " Outlet_Establishment_Year Outlet_Size Outlet_Location_Type \\\n", + "0 1999 Medium Tier 1 \n", + "1 2009 Medium Tier 3 \n", + "2 1999 Medium Tier 1 \n", + "3 1998 Medium Tier 3 \n", + "4 1987 High Tier 3 \n", + "5 2009 Medium Tier 3 \n", + "6 1987 High Tier 3 \n", + "7 1985 Medium Tier 3 \n", + "8 2002 Medium Tier 2 \n", + "9 2007 Medium Tier 2 \n", + "\n", + " Outlet_Type Item_Outlet_Sales source Outlet_Years New_Item_type \n", + "0 Supermarket Type1 3735.1380 train 14 Food \n", + "1 Supermarket Type2 443.4228 train 4 Drinks \n", + "2 Supermarket Type1 2097.2700 train 14 Food \n", + "3 Grocery Store 732.3800 train 15 Food \n", + "4 Supermarket Type1 994.7052 train 26 Non-Consumable \n", + "5 Supermarket Type2 556.6088 train 4 Food \n", + "6 Supermarket Type1 343.5528 train 26 Food \n", + "7 Supermarket Type3 4022.7636 train 28 Food \n", + "8 Supermarket Type1 1076.5986 train 11 Food \n", + "9 Supermarket Type1 4710.5350 train 6 Food " + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(n=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "cdf4d551", + "metadata": {}, + "outputs": [], + "source": [ + "#label encoder \n", + "encoder=LabelEncoder()\n", + "\n", + "df['Item_Identifier'] = encoder.fit_transform(df['Item_Identifier'])\n", + "\n", + "df['Item_Fat_Content'] = encoder.fit_transform(df['Item_Fat_Content'])\n", + "\n", + "df['Item_Type'] = encoder.fit_transform(df['Item_Type'])\n", + "\n", + "df['Outlet_Identifier'] = encoder.fit_transform(df['Outlet_Identifier'])\n", + "\n", + "df['Outlet_Size'] = encoder.fit_transform(df['Outlet_Size'])\n", + "\n", + "df['Outlet_Location_Type'] = encoder.fit_transform(df['Outlet_Location_Type'])\n", + "\n", + "df['Outlet_Type'] = encoder.fit_transform(df['Outlet_Type'])" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "46e2aa0b", + "metadata": { + "scrolled": true + }, + "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", + "
Item_IdentifierItem_WeightItem_Fat_ContentItem_VisibilityItem_TypeItem_MRPOutlet_IdentifierOutlet_Establishment_YearOutlet_SizeOutlet_Location_TypeOutlet_TypeItem_Outlet_SalessourceOutlet_YearsNew_Item_type
01569.3000.0160474249.8092919991013735.1380train14Food
185.9220.0192781448.269232009122443.4228train4Drinks
266217.5000.01676010141.6180919991012097.2700train14Food
3112119.2020.0000006182.095001998120732.3800train15Food
412978.9310.000000953.861411987021994.7052train26Non-Consumable
\n", + "
" + ], + "text/plain": [ + " Item_Identifier Item_Weight Item_Fat_Content Item_Visibility Item_Type \\\n", + "0 156 9.30 0 0.016047 4 \n", + "1 8 5.92 2 0.019278 14 \n", + "2 662 17.50 0 0.016760 10 \n", + "3 1121 19.20 2 0.000000 6 \n", + "4 1297 8.93 1 0.000000 9 \n", + "\n", + " Item_MRP Outlet_Identifier Outlet_Establishment_Year Outlet_Size \\\n", + "0 249.8092 9 1999 1 \n", + "1 48.2692 3 2009 1 \n", + "2 141.6180 9 1999 1 \n", + "3 182.0950 0 1998 1 \n", + "4 53.8614 1 1987 0 \n", + "\n", + " Outlet_Location_Type Outlet_Type Item_Outlet_Sales source Outlet_Years \\\n", + "0 0 1 3735.1380 train 14 \n", + "1 2 2 443.4228 train 4 \n", + "2 0 1 2097.2700 train 14 \n", + "3 2 0 732.3800 train 15 \n", + "4 2 1 994.7052 train 26 \n", + "\n", + " New_Item_type \n", + "0 Food \n", + "1 Drinks \n", + "2 Food \n", + "3 Food \n", + "4 Non-Consumable " + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "8528d12d", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "label = LabelEncoder()\n", + "\n", + "#New variable for outlet\n", + "df['Outlet'] = label.fit_transform(df['Outlet_Identifier'])\n", + "varib = ['Item_Fat_Content','Outlet_Location_Type','Outlet_Size','New_Item_type','Outlet_Type','Outlet']\n", + "for i in varib:\n", + " df[i] = label.fit_transform(df[i])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "1eaeab0e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Item_Identifier int32\n", + "Item_Weight float64\n", + "Item_Visibility float64\n", + "Item_Type int32\n", + "Item_MRP float64\n", + "Outlet_Identifier int32\n", + "Outlet_Establishment_Year int64\n", + "Item_Outlet_Sales float64\n", + "source object\n", + "Outlet_Years int64\n", + "Item_Fat_Content_0 uint8\n", + "Item_Fat_Content_1 uint8\n", + "Item_Fat_Content_2 uint8\n", + "Outlet_Location_Type_0 uint8\n", + "Outlet_Location_Type_1 uint8\n", + "Outlet_Location_Type_2 uint8\n", + "Outlet_Size_0 uint8\n", + "Outlet_Size_1 uint8\n", + "Outlet_Size_2 uint8\n", + "New_Item_type_0 uint8\n", + "New_Item_type_1 uint8\n", + "New_Item_type_2 uint8\n", + "Outlet_Type_0 uint8\n", + "Outlet_Type_1 uint8\n", + "Outlet_Type_2 uint8\n", + "Outlet_Type_3 uint8\n", + "Outlet_0 uint8\n", + "Outlet_1 uint8\n", + "Outlet_2 uint8\n", + "Outlet_3 uint8\n", + "Outlet_4 uint8\n", + "Outlet_5 uint8\n", + "Outlet_6 uint8\n", + "Outlet_7 uint8\n", + "Outlet_8 uint8\n", + "Outlet_9 uint8\n", + "dtype: object" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Dummy Variables:\n", + "\n", + "df = pd.get_dummies(df, columns =['Item_Fat_Content','Outlet_Location_Type','Outlet_Size','New_Item_type','Outlet_Type','Outlet'])\n", + "df.dtypes " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "f676d011", + "metadata": {}, + "outputs": [], + "source": [ + "train = df.loc[df['source'] == 'train']\n", + "test = df.loc[df['source'] == 'test']" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "c1ccbf26", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\AppData\\Local\\Temp\\ipykernel_18076\\3189634342.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " train.drop(['source'],axis=1,inplace=True)\n" + ] + } + ], + "source": [ + "train.drop(['source'],axis=1,inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "9d58bc51", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\AppData\\Local\\Temp\\ipykernel_18076\\698445876.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " test.drop(['Item_Outlet_Sales','source'],axis=1,inplace=True)\n" + ] + } + ], + "source": [ + "test.drop(['Item_Outlet_Sales','source'],axis=1,inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "df58b8e0", + "metadata": {}, + "outputs": [], + "source": [ + "X_train = train.drop(['Item_Outlet_Sales','Item_Identifier','Outlet_Identifier'],axis=1)\n", + "y_train = train['Item_Outlet_Sales']\n", + "X_test = test.drop(['Item_Identifier','Outlet_Identifier'],axis=1).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "177ee4df", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\sklearn\\linear_model\\_base.py:141: FutureWarning: 'normalize' was deprecated in version 1.0 and will be removed in 1.2.\n", + "If you wish to scale the data, use Pipeline with a StandardScaler in a preprocessing stage. To reproduce the previous behavior:\n", + "\n", + "from sklearn.pipeline import make_pipeline\n", + "\n", + "model = make_pipeline(StandardScaler(with_mean=False), LinearRegression())\n", + "\n", + "If you wish to pass a sample_weight parameter, you need to pass it as a fit parameter to each step of the pipeline as follows:\n", + "\n", + "kwargs = {s[0] + '__sample_weight': sample_weight for s in model.steps}\n", + "model.fit(X, y, **kwargs)\n", + "\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
LinearRegression(normalize=True)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression(normalize=True)" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "\n", + "model = LinearRegression(normalize=True)\n", + "\n", + "model.fit(X_train,y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "e55331bd", + "metadata": {}, + "outputs": [], + "source": [ + "model_pred = model.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "f6a5773d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1846.5 , 1574.25, 1874. , ..., 1809.5 , 3562.75, 1265. ])" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_pred\n" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "3cc604ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "56" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_accuracy = round(model.score(X_train,y_train)*100)\n", + "model_accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "9f5847fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "61" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "rf = RandomForestRegressor(n_estimators=400,max_depth=6,min_samples_leaf=100,n_jobs=4)\n", + "\n", + "rf.fit(X_train,y_train)\n", + "\n", + "rf_accuracy = round(rf.score(X_train,y_train)*100)\n", + "\n", + "rf_accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "9a0693f8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\nour\\anaconda3\\envs\\pythontut\\lib\\site-packages\\xgboost\\data.py:250: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", + " elif isinstance(data.columns, (pd.Int64Index, pd.RangeIndex)):\n" + ] + }, + { + "data": { + "text/html": [ + "
XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
+       "             colsample_bynode=1, colsample_bytree=1, enable_categorical=False,\n",
+       "             gamma=0, gpu_id=-1, importance_type=None,\n",
+       "             interaction_constraints='', learning_rate=0.5, max_delta_step=0,\n",
+       "             max_depth=6, min_child_weight=1, missing=nan,\n",
+       "             monotone_constraints='()', n_estimators=100, n_jobs=8,\n",
+       "             num_parallel_tree=1, predictor='auto', random_state=0, reg_alpha=0,\n",
+       "             reg_lambda=1, scale_pos_weight=1, subsample=1, tree_method='exact',\n",
+       "             validate_parameters=1, verbosity=None)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bynode=1, colsample_bytree=1, enable_categorical=False,\n", + " gamma=0, gpu_id=-1, importance_type=None,\n", + " interaction_constraints='', learning_rate=0.5, max_delta_step=0,\n", + " max_depth=6, min_child_weight=1, missing=nan,\n", + " monotone_constraints='()', n_estimators=100, n_jobs=8,\n", + " num_parallel_tree=1, predictor='auto', random_state=0, reg_alpha=0,\n", + " reg_lambda=1, scale_pos_weight=1, subsample=1, tree_method='exact',\n", + " validate_parameters=1, verbosity=None)" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from xgboost import XGBRegressor\n", + "\n", + "model = XGBRegressor(n_estimators = 100, learning_rate=0.50)\n", + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "af048a36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1630.2034, 1768.5997, 1018.8656, ..., 1626.949 , 4828.1304,\n", + " 1449.6985], dtype=float32)" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pred = model.predict(X_test)\n", + "y_pred" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "0916aeb0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "88.49840398440305" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.score(X_train, y_train)*100" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "415174b0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}