added regression models

app.py

@@ -16,6 +16,10 @@ from routes.ML_LogisticRegression_ChurnPredictor import router as logistic_regre
 from routes.ML_DecisionTree_IrisClassifier import router as iris_router
 from routes.ML_RandomForest_TaxiPredictor import router as random_forest_router
 from routes.ML_RidgeRegression_HousePricePredictor import router as ridge_regression_router
+from routes.ML_PolynomialRegression_CarPricePredictor import router as polynomial_regression_router
+from routes.ML_LassoRegression_SalesPredictor import router as lasso_regression_router
+from routes.ML_DecisionTreeRegressor_BikeRentalPredictor import router as decision_tree_regressor_router
+from routes.ML_GradientBoosting_HousePricePredictor import router as gradient_boosting_router
 
 from routes.DL_RNN_StockPricePredictor import router as rnn_stock_router
 from routes.DL_CNN_NumberRecognition import router as cnn_router
@@ -52,6 +56,10 @@ app.include_router(linear_regression_router, dependencies=_auth)
 app.include_router(logistic_regression_router, dependencies=_auth)
 app.include_router(random_forest_router, dependencies=_auth)
 app.include_router(ridge_regression_router, dependencies=_auth)
+app.include_router(polynomial_regression_router, dependencies=_auth)
+app.include_router(lasso_regression_router, dependencies=_auth)
+app.include_router(decision_tree_regressor_router, dependencies=_auth)
+app.include_router(gradient_boosting_router, dependencies=_auth)
 app.include_router(cnn_router, dependencies=_auth)
 app.include_router(iris_router, dependencies=_auth)
 app.include_router(nlp_collaborative_filter_router, dependencies=_auth)

ml/ML_DecisionTreeRegressor_BikeRentalPredictor.ipynb

@@ -0,0 +1,260 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   temperature_c  humidity_pct  hour_of_day  rentals\n",
+      "0           17.4            92            1       71\n",
+      "1           36.4            46           20        1\n",
+      "2           29.2            62            8      111\n",
+      "3           24.8            58            8      166\n",
+      "4           10.1            42            7       58\n",
+      "\n",
+      "Rentals range: 1 – 207\n",
+      "\n",
+      "R² score : 0.8386\n",
+      "RMSE     : 19.9 rentals\n",
+      "\n",
+      "Sample (22°C, 55% humidity, 8am): 132 rentals\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "n = 500\n",
+    "\n",
+    "temperature_c = np.round(np.random.uniform(5, 38, n), 1)\n",
+    "humidity_pct  = np.random.randint(30, 95, n)\n",
+    "hour_of_day   = np.random.randint(0, 24, n)\n",
+    "\n",
+    "# Peak rentals at comfortable temp (~22C) and rush hours (8, 17-19)\n",
+    "temp_comfort  = -0.8 * (temperature_c - 22) ** 2 + 100\n",
+    "hour_bonus    = np.where((hour_of_day >= 7) & (hour_of_day <= 9), 80,\n",
+    "               np.where((hour_of_day >= 16) & (hour_of_day <= 19), 100, 0))\n",
+    "\n",
+    "rentals = (\n",
+    "    temp_comfort\n",
+    "    - 0.4 * humidity_pct\n",
+    "    + hour_bonus\n",
+    "    + np.random.normal(0, 15, n)\n",
+    ").round().astype(int)\n",
+    "rentals = np.clip(rentals, 1, None)\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'temperature_c': temperature_c,\n",
+    "    'humidity_pct': humidity_pct,\n",
+    "    'hour_of_day': hour_of_day,\n",
+    "    'rentals': rentals\n",
+    "})\n",
+    "\n",
+    "print(df.head())\n",
+    "print(f'\\nRentals range: {df.rentals.min()} \\u2013 {df.rentals.max()}')\n",
+    "\n",
+    "X = df[['temperature_c', 'humidity_pct', 'hour_of_day']]\n",
+    "y = df['rentals']\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "model = DecisionTreeRegressor(max_depth=6, random_state=42)\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred = model.predict(X_test)\n",
+    "r2   = r2_score(y_test, y_pred)\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "\n",
+    "print(f'\\nR\\u00b2 score : {r2:.4f}')\n",
+    "print(f'RMSE     : {rmse:.1f} rentals')\n",
+    "\n",
+    "sample = pd.DataFrame([[22.0, 55, 8]], columns=['temperature_c', 'humidity_pct', 'hour_of_day'])\n",
+    "pred = model.predict(sample)[0]\n",
+    "print(f'\\nSample (22\\u00b0C, 55% humidity, 8am): {int(round(pred))} rentals')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:122: UserWarning: \n",
+      "Error while fetching `HF_TOKEN` secret value from your vault: 'Requesting secret HF_TOKEN timed out. Secrets can only be fetched when running from the Colab UI.'.\n",
+      "You are not authenticated with the Hugging Face Hub in this notebook.\n",
+      "If the error persists, please let us know by opening an issue on GitHub (https://github.com/huggingface/huggingface_hub/issues/new).\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved locally: /content/ML_DecisionTreeRegressor_BikeRentalPredictor.joblib\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "56fe82ebb24640ada519e1ecd5333d24",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Processing Files (0 / 0)      : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9c752ac1bf664927a49955a85f15b7a9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "New Data Upload               : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b9b16a31aac545e68185f055730913d2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  ...ikeRentalPredictor.joblib: 100%|##########| 7.87kB / 7.87kB            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uploaded model to https://huggingface.co/looh2/model\n"
+     ]
+    }
+   ],
+   "source": [
+    "import joblib\n",
+    "from pathlib import Path\n",
+    "from huggingface_hub import HfApi\n",
+    "\n",
+    "repo_id = \"looh2/model\"\n",
+    "model_path = Path(\"ML_DecisionTreeRegressor_BikeRentalPredictor.joblib\")\n",
+    "\n",
+    "joblib.dump(model, model_path)\n",
+    "print(f\"Model saved locally: {model_path.resolve()}\")\n",
+    "\n",
+    "api = HfApi()\n",
+    "api.create_repo(repo_id=repo_id, repo_type=\"model\", exist_ok=True)\n",
+    "api.upload_file(\n",
+    "    path_or_fileobj=str(model_path),\n",
+    "    path_in_repo=model_path.name,\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=\"model\",\n",
+    ")\n",
+    "print(f\"Uploaded model to https://huggingface.co/{repo_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1d98edb556df4ccdb76838f4a23713df",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "ML_DecisionTreeRegressor_BikeRentalPredi(…):   0%|          | 0.00/7.87k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# FastAPI integration reference\n",
+    "from fastapi import FastAPI\n",
+    "from pydantic import BaseModel\n",
+    "import joblib, pandas as pd\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "model_path = hf_hub_download(repo_id='looh2/model',\n",
+    "                              filename='ML_DecisionTreeRegressor_BikeRentalPredictor.joblib',\n",
+    "                              repo_type='model')\n",
+    "model = joblib.load(model_path)\n",
+    "app = FastAPI()\n",
+    "\n",
+    "class BikeFeatures(BaseModel):\n",
+    "    temperature_c: float\n",
+    "    humidity_pct: int\n",
+    "    hour_of_day: int\n",
+    "\n",
+    "@app.post('/predict')\n",
+    "def predict_rentals(features: BikeFeatures):\n",
+    "    df = pd.DataFrame([[features.temperature_c, features.humidity_pct, features.hour_of_day]],\n",
+    "                      columns=['temperature_c', 'humidity_pct', 'hour_of_day'])\n",
+    "    pred = max(int(round(float(model.predict(df)[0]))), 0)\n",
+    "    return {'predicted_rentals': pred}"
+   ]
+  }
+ ],
+ "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.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ml/ML_GradientBoosting_HousePricePredictor.ipynb

@@ -0,0 +1,267 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   lot_size_sqm  floors  rooms  crime_rate  school_rating  price_thousands\n",
+      "0           182       1      7         5.9              7           292.46\n",
+      "1           515       3      6         7.8              2           334.81\n",
+      "2           350       2      7         9.2              6           322.05\n",
+      "3           186       3      7         9.0              7           377.70\n",
+      "4           151       3      8         1.8             10           515.72\n",
+      "\n",
+      "Price range: $72.2k – $618.6k\n",
+      "\n",
+      "R² score : 0.8868\n",
+      "RMSE     : $35.93k\n",
+      "\n",
+      "Sample (200m² lot, 2 floors, 5 rooms, crime=3, school=8): $370.7k\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.ensemble import GradientBoostingRegressor\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "n = 400\n",
+    "\n",
+    "lot_size_sqm   = np.random.randint(80, 600, n)\n",
+    "floors         = np.random.randint(1, 4, n)\n",
+    "rooms          = np.random.randint(2, 9, n)\n",
+    "crime_rate     = np.round(np.random.uniform(0.5, 9.5, n), 1)  # index 0-10, lower is safer\n",
+    "school_rating  = np.random.randint(1, 11, n)                   # 1-10\n",
+    "\n",
+    "price_thousands = (\n",
+    "    0.35 * lot_size_sqm\n",
+    "    + 30  * floors\n",
+    "    + 20  * rooms\n",
+    "    - 15  * crime_rate\n",
+    "    + 18  * school_rating\n",
+    "    + np.random.normal(0, 20, n)\n",
+    "    + 50\n",
+    ").round(2)\n",
+    "price_thousands = np.clip(price_thousands, 50.0, None)\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'lot_size_sqm':  lot_size_sqm,\n",
+    "    'floors':        floors,\n",
+    "    'rooms':         rooms,\n",
+    "    'crime_rate':    crime_rate,\n",
+    "    'school_rating': school_rating,\n",
+    "    'price_thousands': price_thousands\n",
+    "})\n",
+    "\n",
+    "print(df.head())\n",
+    "print(f'\\nPrice range: ${df.price_thousands.min():.1f}k \\u2013 ${df.price_thousands.max():.1f}k')\n",
+    "\n",
+    "X = df[['lot_size_sqm', 'floors', 'rooms', 'crime_rate', 'school_rating']]\n",
+    "y = df['price_thousands']\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "model = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1, max_depth=4, random_state=42)\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred = model.predict(X_test)\n",
+    "r2   = r2_score(y_test, y_pred)\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "\n",
+    "print(f'\\nR\\u00b2 score : {r2:.4f}')\n",
+    "print(f'RMSE     : ${rmse:.2f}k')\n",
+    "\n",
+    "sample = pd.DataFrame([[200, 2, 5, 3.0, 8]], columns=['lot_size_sqm', 'floors', 'rooms', 'crime_rate', 'school_rating'])\n",
+    "pred = model.predict(sample)[0]\n",
+    "print(f'\\nSample (200m\\u00b2 lot, 2 floors, 5 rooms, crime=3, school=8): ${pred:.1f}k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:122: UserWarning: \n",
+      "Error while fetching `HF_TOKEN` secret value from your vault: 'Requesting secret HF_TOKEN timed out. Secrets can only be fetched when running from the Colab UI.'.\n",
+      "You are not authenticated with the Hugging Face Hub in this notebook.\n",
+      "If the error persists, please let us know by opening an issue on GitHub (https://github.com/huggingface/huggingface_hub/issues/new).\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved locally: /content/ML_GradientBoosting_HousePricePredictor.joblib\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ba48ab6b85c34c90a902aa4545924c0f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Processing Files (0 / 0)      : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4bc019c7879e43049cca1caa952b0c87",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "New Data Upload               : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a4c5c7f729ba4b2db31b6473d890d6bd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  ...ousePricePredictor.joblib: 100%|##########|  461kB /  461kB            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uploaded model to https://huggingface.co/looh2/model\n"
+     ]
+    }
+   ],
+   "source": [
+    "import joblib\n",
+    "from pathlib import Path\n",
+    "from huggingface_hub import HfApi\n",
+    "\n",
+    "repo_id = \"looh2/model\"\n",
+    "model_path = Path(\"ML_GradientBoosting_HousePricePredictor.joblib\")\n",
+    "\n",
+    "joblib.dump(model, model_path)\n",
+    "print(f\"Model saved locally: {model_path.resolve()}\")\n",
+    "\n",
+    "api = HfApi()\n",
+    "api.create_repo(repo_id=repo_id, repo_type=\"model\", exist_ok=True)\n",
+    "api.upload_file(\n",
+    "    path_or_fileobj=str(model_path),\n",
+    "    path_in_repo=model_path.name,\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=\"model\",\n",
+    ")\n",
+    "print(f\"Uploaded model to https://huggingface.co/{repo_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c1a443dc4ed64a82b6f8596b3c585130",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "ML_GradientBoosting_HousePricePredictor.(…):   0%|          | 0.00/461k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# FastAPI integration reference\n",
+    "from fastapi import FastAPI\n",
+    "from pydantic import BaseModel\n",
+    "import joblib, pandas as pd\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "model_path = hf_hub_download(repo_id='looh2/model',\n",
+    "                              filename='ML_GradientBoosting_HousePricePredictor.joblib',\n",
+    "                              repo_type='model')\n",
+    "model = joblib.load(model_path)\n",
+    "app = FastAPI()\n",
+    "\n",
+    "class HouseFeatures(BaseModel):\n",
+    "    lot_size_sqm: int\n",
+    "    floors: int\n",
+    "    rooms: int\n",
+    "    crime_rate: float\n",
+    "    school_rating: int\n",
+    "\n",
+    "@app.post('/predict')\n",
+    "def predict_house_price(features: HouseFeatures):\n",
+    "    df = pd.DataFrame(\n",
+    "        [[features.lot_size_sqm, features.floors, features.rooms,\n",
+    "          features.crime_rate, features.school_rating]],\n",
+    "        columns=['lot_size_sqm', 'floors', 'rooms', 'crime_rate', 'school_rating']\n",
+    "    )\n",
+    "    pred = max(round(float(model.predict(df)[0]), 2), 0.0)\n",
+    "    return {'predicted_price_thousands': pred, 'predicted_price_formatted': f'${pred:.1f}k'}"
+   ]
+  }
+ ],
+ "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.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ml/ML_LassoRegression_SalesPredictor.ipynb

@@ -0,0 +1,264 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   tv_budget  radio_budget  social_budget  sales_k\n",
+      "0      102.0          33.0           89.0    12.40\n",
+      "1      270.0          30.0           45.0    20.14\n",
+      "2      106.0           9.0           33.0    12.19\n",
+      "3       71.0          18.0           48.0     7.97\n",
+      "4      188.0          31.0           77.0    19.15\n",
+      "\n",
+      "Sales range: $2.0k – $23.2k\n",
+      "\n",
+      "Coefficients (after L1): TV=3.6672, Radio=0.0426, Social=0.5363\n",
+      "R² score : 0.8566\n",
+      "RMSE     : $1.73k\n",
+      "\n",
+      "Sample (TV=$150k, Radio=$20k, Social=$60k): $13.4k sales\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.linear_model import Lasso\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "n = 400\n",
+    "\n",
+    "tv_budget     = np.random.randint(0, 300, n).astype(float)   # $k spent on TV ads\n",
+    "radio_budget  = np.random.randint(0, 50,  n).astype(float)   # $k spent on radio\n",
+    "social_budget = np.random.randint(0, 100, n).astype(float)   # $k spent on social media\n",
+    "\n",
+    "# TV and social drive sales; radio has minimal effect (Lasso will shrink it)\n",
+    "sales_k = (\n",
+    "    0.045 * tv_budget\n",
+    "    + 0.004 * radio_budget\n",
+    "    + 0.025 * social_budget\n",
+    "    + np.random.normal(0, 1.5, n)\n",
+    "    + 5.0\n",
+    ").round(2)\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'tv_budget': tv_budget,\n",
+    "    'radio_budget': radio_budget,\n",
+    "    'social_budget': social_budget,\n",
+    "    'sales_k': sales_k\n",
+    "})\n",
+    "\n",
+    "print(df.head())\n",
+    "print(f'\\nSales range: ${df.sales_k.min():.1f}k \\u2013 ${df.sales_k.max():.1f}k')\n",
+    "\n",
+    "X = df[['tv_budget', 'radio_budget', 'social_budget']]\n",
+    "y = df['sales_k']\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "pipeline = Pipeline([\n",
+    "    ('scaler', StandardScaler()),\n",
+    "    ('lasso', Lasso(alpha=0.1))\n",
+    "])\n",
+    "pipeline.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred = pipeline.predict(X_test)\n",
+    "r2   = r2_score(y_test, y_pred)\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "\n",
+    "coefs = pipeline.named_steps['lasso'].coef_\n",
+    "print(f'\\nCoefficients (after L1): TV={coefs[0]:.4f}, Radio={coefs[1]:.4f}, Social={coefs[2]:.4f}')\n",
+    "print(f'R\\u00b2 score : {r2:.4f}')\n",
+    "print(f'RMSE     : ${rmse:.2f}k')\n",
+    "\n",
+    "sample = pd.DataFrame([[150, 20, 60]], columns=['tv_budget', 'radio_budget', 'social_budget'])\n",
+    "pred = pipeline.predict(sample)[0]\n",
+    "print(f'\\nSample (TV=$150k, Radio=$20k, Social=$60k): ${pred:.1f}k sales')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:122: UserWarning: \n",
+      "Error while fetching `HF_TOKEN` secret value from your vault: 'Requesting secret HF_TOKEN timed out. Secrets can only be fetched when running from the Colab UI.'.\n",
+      "You are not authenticated with the Hugging Face Hub in this notebook.\n",
+      "If the error persists, please let us know by opening an issue on GitHub (https://github.com/huggingface/huggingface_hub/issues/new).\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved locally: /content/ML_LassoRegression_SalesPredictor.joblib\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e185633c1dc6461cbc712459e56b0615",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Processing Files (0 / 0)      : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ef2629a70be14cd4b80a0606cf05e0d3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "New Data Upload               : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "46f7c2f0e80845a999440dfb222ace44",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  ...ion_SalesPredictor.joblib: 100%|##########| 1.48kB / 1.48kB            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uploaded model to https://huggingface.co/looh2/model\n"
+     ]
+    }
+   ],
+   "source": [
+    "import joblib\n",
+    "from pathlib import Path\n",
+    "from huggingface_hub import HfApi\n",
+    "\n",
+    "repo_id = \"looh2/model\"\n",
+    "model_path = Path(\"ML_LassoRegression_SalesPredictor.joblib\")\n",
+    "\n",
+    "joblib.dump(pipeline, model_path)\n",
+    "print(f\"Model saved locally: {model_path.resolve()}\")\n",
+    "\n",
+    "api = HfApi()\n",
+    "api.create_repo(repo_id=repo_id, repo_type=\"model\", exist_ok=True)\n",
+    "api.upload_file(\n",
+    "    path_or_fileobj=str(model_path),\n",
+    "    path_in_repo=model_path.name,\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=\"model\",\n",
+    ")\n",
+    "print(f\"Uploaded model to https://huggingface.co/{repo_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e0624f5ead574de89d675af44671b57a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "ML_LassoRegression_SalesPredictor.joblib:   0%|          | 0.00/1.48k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# FastAPI integration reference\n",
+    "from fastapi import FastAPI\n",
+    "from pydantic import BaseModel\n",
+    "import joblib, pandas as pd\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "model_path = hf_hub_download(repo_id='looh2/model',\n",
+    "                              filename='ML_LassoRegression_SalesPredictor.joblib',\n",
+    "                              repo_type='model')\n",
+    "pipeline = joblib.load(model_path)\n",
+    "app = FastAPI()\n",
+    "\n",
+    "class AdBudget(BaseModel):\n",
+    "    tv_budget: float\n",
+    "    radio_budget: float\n",
+    "    social_budget: float\n",
+    "\n",
+    "@app.post('/predict')\n",
+    "def predict_sales(features: AdBudget):\n",
+    "    df = pd.DataFrame([[features.tv_budget, features.radio_budget, features.social_budget]],\n",
+    "                      columns=['tv_budget', 'radio_budget', 'social_budget'])\n",
+    "    pred = max(round(float(pipeline.predict(df)[0]), 2), 0.0)\n",
+    "    return {'predicted_sales_k': pred, 'predicted_sales_formatted': f'${pred:.1f}k'}"
+   ]
+  }
+ ],
+ "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.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ml/ML_PolynomialRegression_CarPricePredictor.ipynb

@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   mileage_km  age_years  engine_cc  price_thousands\n",
+      "0      126958          4       1800            27.26\n",
+      "1      151867          6       3000            20.48\n",
+      "2      136932          8       2000            14.58\n",
+      "3      108694          3       1800            20.43\n",
+      "4      124879         16       1400             8.26\n",
+      "\n",
+      "Price range: $1.0k – $50.0k\n",
+      "\n",
+      "R² score : 0.9452\n",
+      "RMSE     : $2.73k\n",
+      "\n",
+      "Sample car (80k km, 5 yrs, 1600cc): $27.1k\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "n = 300\n",
+    "\n",
+    "mileage_km = np.random.randint(5000, 200000, n)\n",
+    "age_years = np.random.randint(1, 20, n)\n",
+    "engine_cc = np.random.choice([1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000], n)\n",
+    "\n",
+    "# Non-linear price: mileage has diminishing negative effect (quadratic), engine_cc positive\n",
+    "price_thousands = (\n",
+    "    35\n",
+    "    - 0.00012 * mileage_km\n",
+    "    - 0.0000000003 * mileage_km ** 2\n",
+    "    - 1.1 * age_years\n",
+    "    + 0.006 * engine_cc\n",
+    "    + np.random.normal(0, 2.5, n)\n",
+    ").round(2)\n",
+    "price_thousands = np.clip(price_thousands, 1.0, None)  # no negative prices\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'mileage_km': mileage_km,\n",
+    "    'age_years': age_years,\n",
+    "    'engine_cc': engine_cc,\n",
+    "    'price_thousands': price_thousands\n",
+    "})\n",
+    "\n",
+    "print(df.head())\n",
+    "print(f'\\nPrice range: ${df.price_thousands.min():.1f}k \\u2013 ${df.price_thousands.max():.1f}k')\n",
+    "\n",
+    "X = df[['mileage_km', 'age_years', 'engine_cc']]\n",
+    "y = df['price_thousands']\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Polynomial Regression (degree=2) with StandardScaler\n",
+    "pipeline = Pipeline([\n",
+    "    ('poly', PolynomialFeatures(degree=2, include_bias=False)),\n",
+    "    ('scaler', StandardScaler()),\n",
+    "    ('lr', LinearRegression())\n",
+    "])\n",
+    "pipeline.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred = pipeline.predict(X_test)\n",
+    "r2   = r2_score(y_test, y_pred)\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "\n",
+    "print(f'\\nR\\u00b2 score : {r2:.4f}')\n",
+    "print(f'RMSE     : ${rmse:.2f}k')\n",
+    "\n",
+    "# Sample prediction\n",
+    "sample = pd.DataFrame(\n",
+    "    [[80000, 5, 1600]],\n",
+    "    columns=['mileage_km', 'age_years', 'engine_cc']\n",
+    ")\n",
+    "pred = pipeline.predict(sample)[0]\n",
+    "print(f'\\nSample car (80k km, 5 yrs, 1600cc): ${pred:.1f}k')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:122: UserWarning: \n",
+      "Error while fetching `HF_TOKEN` secret value from your vault: 'Requesting secret HF_TOKEN timed out. Secrets can only be fetched when running from the Colab UI.'.\n",
+      "You are not authenticated with the Hugging Face Hub in this notebook.\n",
+      "If the error persists, please let us know by opening an issue on GitHub (https://github.com/huggingface/huggingface_hub/issues/new).\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved locally: /content/ML_PolynomialRegression_CarPricePredictor.joblib\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c806666d58f8434b938a24c9fa9a5698",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Processing Files (0 / 0)      : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3faea3a1772e411ca53659ddf3ea3016",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "New Data Upload               : |          |  0.00B /  0.00B            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "df2803f17067419ba6987004025a6666",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  ..._CarPricePredictor.joblib: 100%|##########| 1.85kB / 1.85kB            "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Uploaded model to https://huggingface.co/looh2/model\n"
+     ]
+    }
+   ],
+   "source": [
+    "import joblib\n",
+    "from pathlib import Path\n",
+    "from huggingface_hub import HfApi\n",
+    "\n",
+    "repo_id = \"looh2/model\"\n",
+    "model_path = Path(\"ML_PolynomialRegression_CarPricePredictor.joblib\")\n",
+    "\n",
+    "joblib.dump(pipeline, model_path)\n",
+    "print(f\"Model saved locally: {model_path.resolve()}\")\n",
+    "\n",
+    "api = HfApi()\n",
+    "api.create_repo(repo_id=repo_id, repo_type=\"model\", exist_ok=True)\n",
+    "api.upload_file(\n",
+    "    path_or_fileobj=str(model_path),\n",
+    "    path_in_repo=model_path.name,\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=\"model\",\n",
+    ")\n",
+    "print(f\"Uploaded model to https://huggingface.co/{repo_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c7d51668e9e849bbabd0797b05d2de83",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "ML_PolynomialRegression_CarPricePredicto(…):   0%|          | 0.00/1.85k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# FastAPI integration reference\n",
+    "from fastapi import FastAPI\n",
+    "from pydantic import BaseModel\n",
+    "import joblib\n",
+    "import pandas as pd\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "model_path = hf_hub_download(\n",
+    "    repo_id=\"looh2/model\",\n",
+    "    filename=\"ML_PolynomialRegression_CarPricePredictor.joblib\",\n",
+    "    repo_type=\"model\"\n",
+    ")\n",
+    "pipeline = joblib.load(model_path)\n",
+    "\n",
+    "app = FastAPI()\n",
+    "\n",
+    "class CarFeatures(BaseModel):\n",
+    "    mileage_km: int\n",
+    "    age_years: int\n",
+    "    engine_cc: int\n",
+    "\n",
+    "@app.post(\"/predict\")\n",
+    "def predict_car_price(features: CarFeatures):\n",
+    "    input_df = pd.DataFrame(\n",
+    "        [[features.mileage_km, features.age_years, features.engine_cc]],\n",
+    "        columns=['mileage_km', 'age_years', 'engine_cc']\n",
+    "    )\n",
+    "    pred = pipeline.predict(input_df)[0]\n",
+    "    price = max(round(float(pred), 2), 0.0)\n",
+    "    return {\n",
+    "        \"predicted_price_thousands\": price,\n",
+    "        \"predicted_price_formatted\": f\"${price:.1f}k\"\n",
+    "    }"
+   ]
+  }
+ ],
+ "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.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

routes/ML_DecisionTreeRegressor_BikeRentalPredictor.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import joblib
+import pandas as pd
+from typing import Optional, Any
+
+from .config_huggingface import build_model_url, download_artifact_if_needed
+
+router = APIRouter(tags=["Machine Learning"])
+
+
+class DecisionTreeRegressorRequest(BaseModel):
+    temperature_c: float = 22.0
+    humidity_pct: int = 55
+    hour_of_day: int = 8
+
+
+MODEL_STATE: dict[str, Optional[Any]] = {
+    "model": None,
+    "error": None,
+}
+
+MODEL_URL = build_model_url("ML_DecisionTreeRegressor_BikeRentalPredictor.joblib")
+
+
+def _ensure_model_loaded() -> None:
+    if MODEL_STATE["model"] is not None:
+        return
+    try:
+        model_path = download_artifact_if_needed(MODEL_URL)
+        MODEL_STATE["model"] = joblib.load(model_path)
+        MODEL_STATE["error"] = None
+    except Exception as e:
+        MODEL_STATE["error"] = str(e)
+        raise
+
+
+@router.post("/models/decision_tree_regressor", summary="Predict bike rentals with Decision Tree Regression")
+def predict_decision_tree_regressor(data: DecisionTreeRegressorRequest):
+    import traceback
+    try:
+        _ensure_model_loaded()
+    except Exception:
+        detail = "Model not loaded."
+        if MODEL_STATE["error"]:
+            detail = f"Model not loaded: {MODEL_STATE['error']}"
+        return {"error": detail, "traceback": traceback.format_exc(), "status": 500}
+
+    model = MODEL_STATE["model"]
+    if model is None:
+        return {"error": f"Model is None after loading. Error: {MODEL_STATE['error']}", "status": 500}
+
+    input_df = pd.DataFrame(
+        [[data.temperature_c, data.humidity_pct, data.hour_of_day]],
+        columns=["temperature_c", "humidity_pct", "hour_of_day"],
+    )
+
+    try:
+        pred = model.predict(input_df)[0]
+    except Exception as e:
+        return {"error": f"Prediction failed: {str(e)}", "traceback": traceback.format_exc(), "status": 500}
+
+    rentals = max(int(round(float(pred))), 0)
+    return {"predicted_rentals": rentals}

routes/ML_GradientBoosting_HousePricePredictor.py

@@ -0,0 +1,69 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import joblib
+import pandas as pd
+from typing import Optional, Any
+
+from .config_huggingface import build_model_url, download_artifact_if_needed
+
+router = APIRouter(tags=["Machine Learning"])
+
+
+class GradientBoostingRequest(BaseModel):
+    lot_size_sqm: int = 200
+    floors: int = 2
+    rooms: int = 5
+    crime_rate: float = 3.0
+    school_rating: int = 8
+
+
+MODEL_STATE: dict[str, Optional[Any]] = {
+    "model": None,
+    "error": None,
+}
+
+MODEL_URL = build_model_url("ML_GradientBoosting_HousePricePredictor.joblib")
+
+
+def _ensure_model_loaded() -> None:
+    if MODEL_STATE["model"] is not None:
+        return
+    try:
+        model_path = download_artifact_if_needed(MODEL_URL)
+        MODEL_STATE["model"] = joblib.load(model_path)
+        MODEL_STATE["error"] = None
+    except Exception as e:
+        MODEL_STATE["error"] = str(e)
+        raise
+
+
+@router.post("/models/gradient_boosting", summary="Predict house price with Gradient Boosting")
+def predict_gradient_boosting(data: GradientBoostingRequest):
+    import traceback
+    try:
+        _ensure_model_loaded()
+    except Exception:
+        detail = "Model not loaded."
+        if MODEL_STATE["error"]:
+            detail = f"Model not loaded: {MODEL_STATE['error']}"
+        return {"error": detail, "traceback": traceback.format_exc(), "status": 500}
+
+    model = MODEL_STATE["model"]
+    if model is None:
+        return {"error": f"Model is None after loading. Error: {MODEL_STATE['error']}", "status": 500}
+
+    input_df = pd.DataFrame(
+        [[data.lot_size_sqm, data.floors, data.rooms, data.crime_rate, data.school_rating]],
+        columns=["lot_size_sqm", "floors", "rooms", "crime_rate", "school_rating"],
+    )
+
+    try:
+        pred = model.predict(input_df)[0]
+    except Exception as e:
+        return {"error": f"Prediction failed: {str(e)}", "traceback": traceback.format_exc(), "status": 500}
+
+    price = max(round(float(pred), 2), 0.0)
+    return {
+        "predicted_price_thousands": price,
+        "predicted_price_formatted": f"${price:.1f}k",
+    }

routes/ML_LassoRegression_SalesPredictor.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import joblib
+import pandas as pd
+from typing import Optional, Any
+
+from .config_huggingface import build_model_url, download_artifact_if_needed
+
+router = APIRouter(tags=["Machine Learning"])
+
+
+class LassoRegressionRequest(BaseModel):
+    tv_budget: float = 150.0
+    radio_budget: float = 20.0
+    social_budget: float = 60.0
+
+
+MODEL_STATE: dict[str, Optional[Any]] = {
+    "model": None,
+    "error": None,
+}
+
+MODEL_URL = build_model_url("ML_LassoRegression_SalesPredictor.joblib")
+
+
+def _ensure_model_loaded() -> None:
+    if MODEL_STATE["model"] is not None:
+        return
+    try:
+        model_path = download_artifact_if_needed(MODEL_URL)
+        MODEL_STATE["model"] = joblib.load(model_path)
+        MODEL_STATE["error"] = None
+    except Exception as e:
+        MODEL_STATE["error"] = str(e)
+        raise
+
+
+@router.post("/models/lasso_regression", summary="Predict sales from ad budgets with Lasso Regression")
+def predict_lasso_regression(data: LassoRegressionRequest):
+    import traceback
+    try:
+        _ensure_model_loaded()
+    except Exception:
+        detail = "Model not loaded."
+        if MODEL_STATE["error"]:
+            detail = f"Model not loaded: {MODEL_STATE['error']}"
+        return {"error": detail, "traceback": traceback.format_exc(), "status": 500}
+
+    model = MODEL_STATE["model"]
+    if model is None:
+        return {"error": f"Model is None after loading. Error: {MODEL_STATE['error']}", "status": 500}
+
+    input_df = pd.DataFrame(
+        [[data.tv_budget, data.radio_budget, data.social_budget]],
+        columns=["tv_budget", "radio_budget", "social_budget"],
+    )
+
+    try:
+        pred = model.predict(input_df)[0]
+    except Exception as e:
+        return {"error": f"Prediction failed: {str(e)}", "traceback": traceback.format_exc(), "status": 500}
+
+    sales = max(round(float(pred), 2), 0.0)
+    return {
+        "predicted_sales_k": sales,
+        "predicted_sales_formatted": f"${sales:.1f}k",
+    }

routes/ML_PolynomialRegression_CarPricePredictor.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import joblib
+import pandas as pd
+from typing import Optional, Any
+
+from .config_huggingface import build_model_url, download_artifact_if_needed
+
+router = APIRouter(tags=["Machine Learning"])
+
+
+class PolynomialRegressionRequest(BaseModel):
+    mileage_km: int = 80000
+    age_years: int = 5
+    engine_cc: int = 1600
+
+
+MODEL_STATE: dict[str, Optional[Any]] = {
+    "model": None,
+    "error": None,
+}
+
+MODEL_URL = build_model_url("ML_PolynomialRegression_CarPricePredictor.joblib")
+
+
+def _ensure_model_loaded() -> None:
+    if MODEL_STATE["model"] is not None:
+        return
+    try:
+        model_path = download_artifact_if_needed(MODEL_URL)
+        MODEL_STATE["model"] = joblib.load(model_path)
+        MODEL_STATE["error"] = None
+    except Exception as e:
+        MODEL_STATE["error"] = str(e)
+        raise
+
+
+@router.post("/models/polynomial_regression", summary="Predict car resale price with Polynomial Regression")
+def predict_polynomial_regression(data: PolynomialRegressionRequest):
+    import traceback
+    try:
+        _ensure_model_loaded()
+    except Exception:
+        detail = "Model not loaded."
+        if MODEL_STATE["error"]:
+            detail = f"Model not loaded: {MODEL_STATE['error']}"
+        return {"error": detail, "traceback": traceback.format_exc(), "status": 500}
+
+    model = MODEL_STATE["model"]
+    if model is None:
+        return {"error": f"Model is None after loading. Error: {MODEL_STATE['error']}", "status": 500}
+
+    input_df = pd.DataFrame(
+        [[data.mileage_km, data.age_years, data.engine_cc]],
+        columns=["mileage_km", "age_years", "engine_cc"],
+    )
+
+    try:
+        pred = model.predict(input_df)[0]
+    except Exception as e:
+        return {"error": f"Prediction failed: {str(e)}", "traceback": traceback.format_exc(), "status": 500}
+
+    price = max(round(float(pred), 2), 0.0)
+    return {
+        "predicted_price_thousands": price,
+        "predicted_price_formatted": f"${price:.1f}k",
+    }