Laptop Price Prediction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 452,
   "id": "1fa46c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import pickle\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LinearRegression, Lasso, Ridge\n",
    "from sklearn.metrics import r2_score, mean_absolute_error\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "id": "176b8c51",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"laptop_price.csv\", encoding=\"latin-1\")\n",
    "df = df[[\"Company\", \"TypeName\", \"Inches\", \"ScreenResolution\", \"Cpu\", \"Ram\", \"Memory\", \"Gpu\", \"OpSys\", \"Weight\", \"Price_euros\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "id": "309d6ab4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Company             0\n",
       "TypeName            0\n",
       "Inches              0\n",
       "ScreenResolution    0\n",
       "Cpu                 0\n",
       "Ram                 0\n",
       "Memory              0\n",
       "Gpu                 0\n",
       "OpSys               0\n",
       "Weight              0\n",
       "Price_euros         0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "c3c89ad1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8GB     619\n",
       "4GB     375\n",
       "16GB    200\n",
       "6GB      41\n",
       "12GB     25\n",
       "2GB      22\n",
       "32GB     17\n",
       "24GB      3\n",
       "64GB      1\n",
       "Name: Ram, dtype: int64"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Ram\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "id": "18cf0ccc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Windows 10      1072\n",
       "No OS             66\n",
       "Linux             62\n",
       "Windows 7         45\n",
       "Chrome OS         27\n",
       "macOS             13\n",
       "Mac OS X           8\n",
       "Windows 10 S       8\n",
       "Android            2\n",
       "Name: OpSys, dtype: int64"
      ]
     },
     "execution_count": 368,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"OpSys\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a8cbe43",
   "metadata": {},
   "source": [
    "# Preprocess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "id": "e8e662c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def RamParser(text):\n",
    "    text = text.replace(\"GB\", \"\")\n",
    "    return int(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "id": "da4da96e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Ram\"] = df[\"Ram\"].apply(RamParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "id": "4c4b70d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8     619\n",
       "4     375\n",
       "16    200\n",
       "6      41\n",
       "12     25\n",
       "2      22\n",
       "32     17\n",
       "24      3\n",
       "64      1\n",
       "Name: Ram, dtype: int64"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Ram\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "id": "da29b59d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def WeightParser(text):\n",
    "    text = text.replace(\"kg\", \"\")\n",
    "    return float(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "id": "f49e12bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Weight\"] = df[\"Weight\"].apply(WeightParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "id": "e661b731",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.20    126\n",
       "2.10     58\n",
       "2.00     45\n",
       "2.40     44\n",
       "2.30     41\n",
       "       ... \n",
       "4.50      1\n",
       "1.14      1\n",
       "3.80      1\n",
       "3.25      1\n",
       "2.34      1\n",
       "Name: Weight, Length: 171, dtype: int64"
      ]
     },
     "execution_count": 374,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Weight\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "id": "a8dce449",
   "metadata": {},
   "outputs": [],
   "source": [
    "def TouchscreenParser(text):\n",
    "    if \"Touchscreen\" in text:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "a5f9fb5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Touchscreen\"] = df[\"ScreenResolution\"].apply(TouchscreenParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "id": "679296b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1111\n",
       "1     192\n",
       "Name: Touchscreen, dtype: int64"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Touchscreen\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "id": "cfff710b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def IPSParser(text):\n",
    "    if \"IPS\" in text:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "id": "c2f9569d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"IPS\"] = df[\"ScreenResolution\"].apply(IPSParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "id": "34dcea31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    938\n",
       "1    365\n",
       "Name: IPS, dtype: int64"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"IPS\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "id": "0167039c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ScreenParser(text):\n",
    "    text = text[-9:]\n",
    "    if text[0] == \" \":\n",
    "        return text[-8:]\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e5f70b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"ScreenResolution\"] = df[\"ScreenResolution\"].apply(ScreenParser)\n",
    "resdf = df[\"ScreenResolution\"].str.split(\"x\", n=1, expand=True)\n",
    "df[\"Wide\"] = resdf[0]\n",
    "df[\"Tall\"] = resdf[1]\n",
    "df[\"Wide\"] = df[\"Wide\"].astype(\"int64\")\n",
    "df[\"Tall\"] = df[\"Tall\"].astype(\"int64\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "id": "2651c598",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1920    846\n",
       "1366    308\n",
       "3840     43\n",
       "2560     29\n",
       "3200     27\n",
       "1600     23\n",
       "2304      6\n",
       "2256      6\n",
       "1440      4\n",
       "2880      4\n",
       "2400      4\n",
       "2160      2\n",
       "2736      1\n",
       "Name: Wide, dtype: int64"
      ]
     },
     "execution_count": 383,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Wide\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "id": "cb7f8df1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1080    841\n",
       "768     308\n",
       "2160     43\n",
       "1800     31\n",
       "1440     31\n",
       "900      27\n",
       "1600     10\n",
       "1504      6\n",
       "1200      5\n",
       "1824      1\n",
       "Name: Tall, dtype: int64"
      ]
     },
     "execution_count": 384,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"Tall\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "id": "f449ea18",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"PPI\"] = pow(((pow(df[\"Wide\"], 2)) + (pow(df[\"Tall\"], 2))), 0.5) / (df[\"Inches\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "id": "f1820914",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Company              object\n",
       "TypeName             object\n",
       "Inches              float64\n",
       "ScreenResolution     object\n",
       "Cpu                  object\n",
       "Ram                   int64\n",
       "Memory               object\n",
       "Gpu                  object\n",
       "OpSys                object\n",
       "Weight              float64\n",
       "Price_euros         float64\n",
       "Touchscreen           int64\n",
       "IPS                   int64\n",
       "Wide                  int64\n",
       "Tall                  int64\n",
       "PPI                 float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 387,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "id": "f9a7fea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CPUParser(text):\n",
    "    text = \" \".join(text.split()[:3])\n",
    "    if text.split()[0] == \"Intel\":\n",
    "        if text == \"Intel Core i3\" or text == \"Intel Core i5\" or text == \"Intel Core i7\":\n",
    "            return text\n",
    "        else:\n",
    "            return \"Other Intel Processor\"\n",
    "    else:\n",
    "        return \"AMD Processor\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "id": "daff7352",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Cpu\"] = df[\"Cpu\"].apply(CPUParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "0b3cb31d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def GPUParser(text):\n",
    "    text = text.split()\n",
    "    return text[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "id": "857a85d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Gpu\"] = df[\"Gpu\"].apply(GPUParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "id": "e04a6a14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Windows 10      1072\n",
       "No OS             66\n",
       "Linux             62\n",
       "Windows 7         45\n",
       "Chrome OS         27\n",
       "macOS             13\n",
       "Mac OS X           8\n",
       "Windows 10 S       8\n",
       "Android            2\n",
       "Name: OpSys, dtype: int64"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"OpSys\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "id": "beb12ed0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def OSParser(text):\n",
    "    if text == \"Windows 7\" or text == \"Windows 10\" or text == \" Windows 10 S\":\n",
    "        return \"Windows\"\n",
    "    \n",
    "    elif text == \"macOS\" or text == \"Mac OS X\":\n",
    "        return \"macOS\"\n",
    "    \n",
    "    else:\n",
    "        return \"Freedos\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "id": "5bf099d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"OpSys\"] = df[\"OpSys\"].apply(OSParser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "961c5cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def MemoryParse1(text):\n",
    "    text = text.replace(\"GB\", \"\")\n",
    "    text = text.replace(\"TB\", \"000\")\n",
    "    text = re.sub(\"\\.0\", \"\", text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "id": "695c29f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Memory\"] = df[\"Memory\"].apply(MemoryParse1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "id": "faa8f084",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_memory(row):\n",
    "    pattern = r'\\+'\n",
    "    parts = re.split(pattern, row)\n",
    "    return parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9334fca9",
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = df[\"Memory\"].tolist()\n",
    "memory_ssd = np.zeros(1303).astype(int)\n",
    "memory_hdd = np.zeros(1303).astype(int)\n",
    "memory_hybrid = np.zeros(1303).astype(int)\n",
    "memory_flash_storage = np.zeros(1303).astype(int)\n",
    "\n",
    "for i in range(len(texts)):\n",
    "    text_arr = split_memory(texts[i])\n",
    "    print(\"Text Array: \", text_arr)\n",
    "    for j in range(len(text_arr)):\n",
    "        text = text_arr[j].strip(\" \")\n",
    "        print(\"Text:\", text)\n",
    "        if \"SSD\" in text:\n",
    "            print(i, \"SSD: \", text)\n",
    "            text = text.replace(\"SSD\", \"\")\n",
    "            memory_ssd[i] += int(text)\n",
    "            #memory_hdd.append(0)\n",
    "            #memory_hybrid.append(0)\n",
    "            #memory_flash_storage.append(0)\n",
    "        elif \"HDD\" in text:\n",
    "            print(i, \"HDD: \", text)\n",
    "            text = text.replace(\"HDD\", \"\")\n",
    "            #df[\"HDD\"] = text\n",
    "            #memory_ssd.append(0)\n",
    "            memory_hdd[i] += int(text)\n",
    "            #memory_hybrid.append(0)\n",
    "            #memory_flash_storage.append(0)\n",
    "        elif \"Hybrid\" in text:\n",
    "            print(i, \"Hybrid: \", text)\n",
    "            #df[\"Hybrid\"] = text\n",
    "            text = text.replace(\"Hybrid\", \"\")\n",
    "            #memory_ssd.append(0)\n",
    "            #memory_hdd.append(0)\n",
    "            memory_hybrid[i] += int(text)\n",
    "            #memory_flash_storage.append(0)\n",
    "        elif \"Flash Storage\" in text:\n",
    "            print(i, \"Flash Storage: \", text)\n",
    "            #df[\"Flash_Storage\"] = text\n",
    "            text = text.replace(\"Flash Storage\", \"\")\n",
    "            #memory_ssd.append(0)\n",
    "            #memory_hdd.append(0)\n",
    "            #memory_hybrid.append(0)\n",
    "            memory_flash_storage[i] += int(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "id": "676052ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1303\n",
      "1303\n",
      "1303\n",
      "1303\n"
     ]
    }
   ],
   "source": [
    "print(len(memory_ssd))\n",
    "print(len(memory_hdd))\n",
    "print(len(memory_hybrid))\n",
    "print(len(memory_flash_storage))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "id": "d4bdc982",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128"
      ]
     },
     "execution_count": 406,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memory_ssd[615]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "id": "0c598c2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1303"
      ]
     },
     "execution_count": 407,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df[\"Company\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "id": "22799525",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"SSD\"] = memory_ssd\n",
    "df[\"HDD\"] = memory_hdd\n",
    "df[\"Flash_Storage\"] = memory_flash_storage\n",
    "df[\"Hybrid\"] = memory_hybrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a89747c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ndf = df.drop([\"ScreenResolution\", \"Memory\", \"Hybrid\", \"Flash_Storage\", \"Inches\", \"Wide\", \"Tall\"], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "3e58a94a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ndf.to_csv(\"cleaned_data.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d785def",
   "metadata": {},
   "source": [
    "# Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "id": "6c1d876a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Company         object\n",
       "TypeName        object\n",
       "Cpu             object\n",
       "Ram              int64\n",
       "Gpu             object\n",
       "OpSys           object\n",
       "Weight         float64\n",
       "Price_euros    float64\n",
       "Touchscreen      int64\n",
       "IPS              int64\n",
       "PPI            float64\n",
       "SSD              int64\n",
       "HDD              int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 424,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ndf.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "id": "f9a7f15c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ndf[\"Company\"] = ndf[\"Company\"].astype(\"str\")\n",
    "ndf[\"TypeName\"] = ndf[\"TypeName\"].astype(\"str\")\n",
    "ndf[\"Cpu\"] = ndf[\"Cpu\"].astype(\"str\")\n",
    "#ndf[\"Ram\"] = ndf[\"Ram\"].astype(\"int\")\n",
    "ndf[\"Gpu\"] = ndf[\"Gpu\"].astype(\"str\")\n",
    "ndf[\"OpSys\"] = ndf[\"OpSys\"].astype(\"str\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "id": "556b3544",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = ndf.drop([\"Price_euros\"], axis=1)\n",
    "y = ndf[\"Price_euros\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "id": "069d0ee1",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=4242)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "id": "4572f21e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1107, 12), (196, 12))"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "id": "eb78c775",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Company        0\n",
       "TypeName       0\n",
       "Cpu            0\n",
       "Ram            0\n",
       "Gpu            0\n",
       "OpSys          0\n",
       "Weight         0\n",
       "Price_euros    0\n",
       "Touchscreen    0\n",
       "IPS            0\n",
       "PPI            0\n",
       "SSD            0\n",
       "HDD            0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ndf.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "id": "a0f6c7ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_scores(model, y_test, y_pred):\n",
    "    print(\"R2 Score:\", r2_score(y_test, y_pred))\n",
    "    print(\"MAE:\", mean_absolute_error(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "id": "9744680c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Regression:\n",
      "R2 Score: 0.7968869033616763\n",
      "MAE: 227.59817588259853\n"
     ]
    }
   ],
   "source": [
    "# 0 -> Company\n",
    "# 1 -> TypeName\n",
    "# 2 -> Cpu\n",
    "# 4 -> Gpu\n",
    "# 5 -> OpSys\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[\n",
    "    (\"ohe\", OneHotEncoder(sparse_output=False, drop=\"first\"), [0, 1, 2, 4, 5])\n",
    "], remainder=\"passthrough\")\n",
    "\n",
    "lin_reg = LinearRegression()\n",
    "\n",
    "pipe1 = Pipeline([\n",
    "    (\"1\", col_transformer),\n",
    "    (\"2\", lin_reg)\n",
    "])\n",
    "\n",
    "pipe1.fit(X_train, y_train)\n",
    "y_pred = pipe1.predict(X_test)\n",
    "\n",
    "print(\"Linear Regression:\")\n",
    "find_scores(pipe1, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "id": "a59a738d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lasso:\n",
      "R2 Score: 0.7968949767386566\n",
      "MAE: 227.59185469227245\n"
     ]
    }
   ],
   "source": [
    "# 0 -> Company\n",
    "# 1 -> TypeName\n",
    "# 2 -> Cpu\n",
    "# 4 -> Gpu\n",
    "# 5 -> OpSys\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[\n",
    "    (\"ohe\", OneHotEncoder(sparse_output=False, drop=\"first\"), [0, 1, 2, 4, 5])\n",
    "], remainder=\"passthrough\")\n",
    "\n",
    "lasso = Lasso(alpha=0.001)\n",
    "\n",
    "pipe2 = Pipeline([\n",
    "    (\"1\", col_transformer),\n",
    "    (\"2\", lasso)\n",
    "])\n",
    "\n",
    "pipe2.fit(X_train, y_train)\n",
    "y_pred = pipe2.predict(X_test)\n",
    "\n",
    "print(\"Lasso:\")\n",
    "find_scores(pipe2, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "id": "5a0c019d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ridge:\n",
      "R2 Score: 0.8034054672168616\n",
      "MAE: 224.5453126168333\n"
     ]
    }
   ],
   "source": [
    "# 0 -> Company\n",
    "# 1 -> TypeName\n",
    "# 2 -> Cpu\n",
    "# 4 -> Gpu\n",
    "# 5 -> OpSys\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[\n",
    "    (\"ohe\", OneHotEncoder(sparse_output=False, drop=\"first\"), [0, 1, 2, 4, 5])\n",
    "], remainder=\"passthrough\")\n",
    "\n",
    "ridge = Ridge(alpha=10)\n",
    "\n",
    "pipe3 = Pipeline([\n",
    "    (\"1\", col_transformer),\n",
    "    (\"2\", ridge)\n",
    "])\n",
    "\n",
    "pipe3.fit(X_train, y_train)\n",
    "y_pred = pipe3.predict(X_test)\n",
    "\n",
    "print(\"Ridge:\")\n",
    "find_scores(pipe3, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 450,
   "id": "ff1ba128",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeRegressor:\n",
      "R2 Score: 0.7469597532318639\n",
      "MAE: 235.72535061091375\n"
     ]
    }
   ],
   "source": [
    "# 0 -> Company\n",
    "# 1 -> TypeName\n",
    "# 2 -> Cpu\n",
    "# 4 -> Gpu\n",
    "# 5 -> OpSys\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[\n",
    "    (\"ohe\", OneHotEncoder(sparse_output=False, drop=\"first\"), [0, 1, 2, 4, 5])\n",
    "], remainder=\"passthrough\")\n",
    "\n",
    "dtr = DecisionTreeRegressor(max_depth=5)\n",
    "\n",
    "pipe4 = Pipeline([\n",
    "    (\"1\", col_transformer),\n",
    "    (\"2\", dtr)\n",
    "])\n",
    "\n",
    "pipe4.fit(X_train, y_train)\n",
    "y_pred = pipe4.predict(X_test)\n",
    "\n",
    "print(\"DecisionTreeRegressor:\")\n",
    "find_scores(pipe4, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 451,
   "id": "840e5f54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestRegressor:\n",
      "R2 Score: 0.8504089769515462\n",
      "MAE: 183.39291769613385\n"
     ]
    }
   ],
   "source": [
    "# 0 -> Company\n",
    "# 1 -> TypeName\n",
    "# 2 -> Cpu\n",
    "# 4 -> Gpu\n",
    "# 5 -> OpSys\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[\n",
    "    (\"ohe\", OneHotEncoder(sparse_output=False, drop=\"first\"), [0, 1, 2, 4, 5])\n",
    "], remainder=\"passthrough\")\n",
    "\n",
    "rfr = RandomForestRegressor(n_estimators=100, max_samples=0.5, max_features=0.75, max_depth=15, random_state=3)\n",
    "\n",
    "pipe5 = Pipeline([\n",
    "    (\"1\", col_transformer),\n",
    "    (\"2\", rfr)\n",
    "])\n",
    "\n",
    "pipe5.fit(X_train, y_train)\n",
    "y_pred = pipe5.predict(X_test)\n",
    "\n",
    "print(\"RandomForestRegressor:\")\n",
    "find_scores(pipe5, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "id": "7b45fb8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(pipe5, open(\"RandomForestRegressor.pkl\", \"wb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "id": "ea6211e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Intel     616\n",
       "Nvidia    338\n",
       "AMD       152\n",
       "ARM         1\n",
       "Name: Gpu, dtype: int64"
      ]
     },
     "execution_count": 461,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[\"Gpu\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "594932cc",
   "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}