models_usedcars.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Price Prediction Using Linear Regression, Decision Trees, Random Forest, XGBoost, and Deep Neural Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Jupyter notebook utilizes a preprocessed Used Cars dataset to explore various regression models for predicting prices, including Linear Regression, Decision Trees, Random Forests, eXtreme Gradient Boosting (XGBoost), and Deep Neural Networks (DNN). Additionally, it employs GridSearchCV and Hyperband (Keras Tuner) to fine-tune model parameters for optimal performance. The performance of each model is evaluated based on Root Mean Squared Error (RMSE)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import xgboost as xgb\n",
    "from xgboost import XGBRegressor\n",
    "import tensorflow as tf\n",
    "import keras_tuner as kt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore', category=FutureWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Prep "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the preprocessed Used Cars dataset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('filtered_used_cars_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(977550, 11)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape # the dimensions of the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the features and target variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop('price', axis=1) # features\n",
    "y = df['price'] # target variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split the dataset into training and testing sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE (Linear Regression): 0.0039349203424231165\n"
     ]
    }
   ],
   "source": [
    "linear_model = LinearRegression()\n",
    "linear_model.fit(X_train, y_train)\n",
    "y_pred_linear = linear_model.predict(X_test)\n",
    "mse_linear = mean_squared_error(y_test, y_pred_linear)\n",
    "rmse_linear = np.sqrt(mse_linear)\n",
    "print(\"RMSE (Linear Regression):\", rmse_linear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Decision Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 36 candidates, totalling 180 fits\n",
      "Best Parameters: {'max_depth': 20, 'max_features': 'log2', 'min_samples_leaf': 5, 'min_samples_split': 2}\n",
      "RMSE (Decision Tree): 0.0028168047781605104\n"
     ]
    }
   ],
   "source": [
    "param_grid_tree = {\n",
    "    'max_depth': [10, 20, 30], # the maximum depth of the tree\n",
    "    'min_samples_split': [2, 10], # the minimum number of samples required to split an internal node\n",
    "    'min_samples_leaf': [1, 5], # the minimum number of samples required to be at a leaf node\n",
    "    'max_features': ['sqrt', 'log2', None]  # the number of features to consider when looking for the best split\n",
    "}\n",
    "\n",
    "model_dt = DecisionTreeRegressor()\n",
    "\n",
    "grid_search_dt = GridSearchCV(estimator=model_dt, param_grid=param_grid_tree, cv=5, scoring='neg_mean_squared_error', verbose=1)\n",
    "\n",
    "grid_search_dt.fit(X_train, y_train)\n",
    "\n",
    "print(\"Best Parameters:\", grid_search_dt.best_params_)\n",
    "best_model_tree = grid_search_dt.best_estimator_\n",
    "\n",
    "y_pred_dt = best_model_tree.predict(X_test)\n",
    "\n",
    "mse_dt = mean_squared_error(y_test, y_pred_dt)\n",
    "rmse_dt = np.sqrt(mse_dt)\n",
    "print(\"RMSE (Decision Tree):\", rmse_dt)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Random Forests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The implementation of a grid search for the Random Forest was omitted due to its time-consuming nature. Consequently, the optimal parameters identified from the Decision Tree model were utilized in configuring the Random Forest model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE (Random Forest): 0.0026457892283568373\n"
     ]
    }
   ],
   "source": [
    "best_params_dt = grid_search_dt.best_params_\n",
    "\n",
    "\n",
    "model_RF = RandomForestRegressor(\n",
    "    max_depth=best_params_dt['max_depth'], # the maximum depth of the tree.\n",
    "    min_samples_split=best_params_dt['min_samples_split'], # the minimum number of samples required to split an internal node\n",
    "    min_samples_leaf=best_params_dt['min_samples_leaf'],  # the minimum number of samples required to be at a leaf node\n",
    "    max_features=best_params_dt['max_features'], # the number of features to consider when looking for the best split:\n",
    "    n_estimators=100 # the number of trees (default setting)\n",
    ")\n",
    "\n",
    "model_RF.fit(X_train, y_train.ravel())\n",
    "y_pred_rf = model_RF.predict(X_test)\n",
    "mse_rf = mean_squared_error(y_test.ravel(), y_pred_rf)\n",
    "rmse_rf = np.sqrt(mse_rf)\n",
    "print(\"RMSE (Random Forest):\", rmse_rf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) XGBoost (eXtreme Gradient Boosting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 96 candidates, totalling 480 fits\n",
      "Best Parameters: {'colsample_bytree': 1.0, 'learning_rate': 0.1, 'max_depth': 7, 'reg_lambda': 10, 'subsample': 0.8}\n",
      "RMSE (XGBoost): 0.0027845734602668913\n"
     ]
    }
   ],
   "source": [
    "param_grid_xgb = {\n",
    "    'max_depth': [3, 5, 7], # the maximum tree depth for base learners\n",
    "    'learning_rate': [0.01, 0.1], # boosting learning rate\n",
    "    'subsample': [0.8, 1.0], # subsample ratio of the training instance\n",
    "    'colsample_bytree': [0.8, 1.0], # subsample ratio of columns when constructing each tree.\n",
    "    'reg_lambda': [0.01, 0.1, 1, 10] # L2 regularization term on weights. Increasing this value will make model more conservative.\n",
    "}\n",
    "\n",
    "model_xgb = XGBRegressor(n_estimators = 100)\n",
    "grid_search_xgb = GridSearchCV(estimator=model_xgb, param_grid=param_grid_xgb, scoring='neg_mean_squared_error', cv=5, verbose=1)\n",
    "\n",
    "grid_search_xgb.fit(X_train, y_train)\n",
    "\n",
    "print(\"Best Parameters:\", grid_search_xgb.best_params_)\n",
    "best_model_xgb = grid_search_xgb.best_estimator_\n",
    "\n",
    "y_pred_xgb = best_model_xgb.predict(X_test)\n",
    "\n",
    "mse_xgb = mean_squared_error(y_test, y_pred_xgb)\n",
    "rmse_xgb = np.sqrt(mse_xgb)\n",
    "print(\"RMSE (XGBoost):\", rmse_xgb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5) Deep Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model\n",
    "def build_nn(hp):\n",
    "    model_nn = tf.keras.Sequential()\n",
    "\n",
    "    model_nn.add(tf.keras.layers.InputLayer(input_shape = X_train.shape[1])) # input layer\n",
    "    model_nn.add(tf.keras.layers.Dense(units = hp.Int('units_1', min_value = 64, max_value = 256, step = 64), activation = 'relu')) #hidden layer 1\n",
    "    model_nn.add(tf.keras.layers.Dense(units = hp.Int('units_2', min_value = 32, max_value = 128, step = 32), activation = 'relu')) #hidden layer 2\n",
    "    model_nn.add(tf.keras.layers.Dense(units = hp.Int('units_3', min_value = 16, max_value = 64,  step = 16), activation = 'relu')) #hidden layer 3\n",
    "    model_nn.add(tf.keras.layers.Dropout(hp.Float('dropout', min_value=0.0, max_value=0.5, step=0.1)))\n",
    "    model_nn.add(tf.keras.layers.Dense(1)) # output layer\n",
    "\n",
    "    model_nn.compile(optimizer=tf.keras.optimizers.legacy.Adam(learning_rate=hp.Float('learning_rate',  min_value=1e-5, max_value=1e-2, sampling='LOG')),\n",
    "                     loss='mean_squared_error')\n",
    "\n",
    "    return model_nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I applied Hyperband for tuning the parameters of the Deep Neural Network (DNN) model due to its efficiency in optimizing hyperparameters. Unlike traditional grid search method, which evaluate all combinations exhaustively, Hyperband employs a more resource-efficient approach by leveraging adaptive resource allocation and early stopping. This means that it can quickly discard poorly performing configurations while allocating more resources to the promising ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 90 Complete [00h 04m 31s]\n",
      "val_loss: 2.8404980184859596e-05\n",
      "\n",
      "Best val_loss So Far: 7.011720754235284e-06\n",
      "Total elapsed time: 01h 27m 51s\n"
     ]
    }
   ],
   "source": [
    "# Hyperband\n",
    "tuner = kt.Hyperband(\n",
    "    build_nn,\n",
    "    objective='val_loss',  \n",
    "    max_epochs=30,        \n",
    "    factor=3,              \n",
    "    directory='my_dir',    \n",
    "    project_name='usedcars_nn'  \n",
    ")\n",
    "\n",
    "tuner.search(X_train, y_train, epochs=30, validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.iter\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.iter\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Detecting that an object or model or tf.train.Checkpoint is being deleted with unrestored values. See the following logs for the specific values in question. To silence these warnings, use `status.expect_partial()`. See https://www.tensorflow.org/api_docs/python/tf/train/Checkpoint#restorefor details about the status object returned by the restore function.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.iter\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.iter\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.beta_2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Value in checkpoint could not be found in the restored object: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model summary:\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 64)                704       \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 128)               8320      \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 64)                8256      \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 64)                0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 1)                 65        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 17,345\n",
      "Trainable params: 17,345\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "best_model_nn = tuner.get_best_models(num_models=1)[0]\n",
    "best_params_nn = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
    "\n",
    "print(\"Best model summary:\")\n",
    "best_model_nn.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Best Hyperparameters:\n",
      "units_1: 64\n",
      "units_2: 128\n",
      "units_3: 64\n",
      "dropout: 0.0\n",
      "learning_rate: 0.00021686067491772116\n",
      "tuner/epochs: 30\n",
      "tuner/initial_epoch: 10\n",
      "tuner/bracket: 2\n",
      "tuner/round: 2\n",
      "tuner/trial_id: 0068\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nBest Hyperparameters:\")\n",
    "for hp in best_params_nn.values.items():\n",
    "    name, value = hp\n",
    "    print(f\"{name}: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6110/6110 [==============================] - 1s 207us/step\n",
      "RMSE (Neural Network): 0.0028317311259897404\n"
     ]
    }
   ],
   "source": [
    "best_model_nn.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae'])\n",
    "y_pred = best_model_nn.predict(X_test)\n",
    "mse_nn = mean_squared_error(y_test, y_pred)\n",
    "rmse_nn = np.sqrt(mse_nn)\n",
    "print(\"RMSE (Neural Network):\", rmse_nn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_trials_nn = len(tuner.oracle.trials) # total number of trials\n",
    "params_nn = list(best_params_nn.values.items())[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Five ML algorithms were evaluated to predict prices using the cleaned used car dataset. Each model's performance was quantified using the Root Mean Square Error (RMSE), which measures the average magnitude of the errors between predicted and actual values—the lower the RMSE, the better the model's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = [\n",
    "    {\"Model\": \"Linear Regression\", \"# Models\": 1, \"Best Parameters\": \"-\", \"RMSE\": rmse_linear},\n",
    "    {\"Model\": \"Decision Tree\", \"# Models\": grid_search_dt.cv_results_['mean_test_score'].size, \"Best Parameters\": grid_search_dt.best_params_, \"RMSE\": rmse_dt},\n",
    "    {\"Model\": \"Random Forest\", \"# Models\": 1, \"Best Parameters\": best_params_dt, \"RMSE\": rmse_rf},\n",
    "    {\"Model\": \"XGBoost\", \"# Models\": grid_search_xgb.cv_results_['mean_test_score'].size, \"Best Parameters\": grid_search_xgb.best_params_, \"RMSE\": rmse_xgb},\n",
    "     {\"Model\": \"Deep Neural Network\", \"# Models\": num_trials_nn, \"Best Parameters\": params_nn, \"RMSE\": rmse_nn}\n",
    "]\n",
    "\n",
    "df_results = pd.DataFrame(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Table\n",
    "fig, ax = plt.subplots(figsize=(16, 5))  \n",
    "ax.axis('tight')\n",
    "ax.axis('off')\n",
    "fig.suptitle('Model Comparison', fontsize=16, fontweight='bold')\n",
    "colWidths = [0.12, 0.08, 0.65, 0.15]  \n",
    "the_table = ax.table(cellText=df_results.values,\n",
    "                     colLabels=df_results.columns,\n",
    "                     loc='center',\n",
    "                     cellLoc='center',\n",
    "                     colWidths=colWidths)  \n",
    "the_table.auto_set_font_size(False)\n",
    "the_table.set_fontsize(10)\n",
    "the_table.scale(1.2, 2.6) \n",
    "footnote_text = \"Note: For both the Random Forest and XGBoost models, the n_estimators parameter, specifying the number of trees, is set to 100. Parameters not explicitly \\n listed in the table are retained at their default settings as defined in the respective model implementations.\"\n",
    "ax.text(0.5, -0.05, footnote_text, transform=ax.transAxes, ha='center', va='center', fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Among the five models evaluated, Random Forest delivers the best performance with the lowest RMSE of 0.00265, closely followed by XGBoost with an RMSE of 0.00278. The Decision Tree model ranks third with an RMSE of 0.00282, showing a result very similar to XGBoost. The Deep Neural Network (DNN) comes in fourth with a slightly higher RMSE of 0.00283. While these four models perform similarly, Linear Regression lags behind significantly, with an RMSE of 0.00393, indicating a much lower predictive accuracy compared to the others."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}