added ml_ridge_regression

app.py

@@ -15,6 +15,7 @@ from routes.ML_LinearRegression_ChurnPredictor import router as linear_regressio
 from routes.ML_LogisticRegression_ChurnPredictor import router as logistic_regression_router
 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.DL_RNN_StockPricePredictor import router as rnn_stock_router
 from routes.DL_CNN_NumberRecognition import router as cnn_router
@@ -50,6 +51,7 @@ app.include_router(sentiment_router, dependencies=_auth)
 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(cnn_router, dependencies=_auth)
 app.include_router(iris_router, dependencies=_auth)
 app.include_router(nlp_collaborative_filter_router, dependencies=_auth)

ml/ML_RidgeRegression_HousePricePredictor.ipynb

@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   square_feet  bedrooms  bathrooms  age_years  distance_to_center_km  \\\n",
+      "0         3574         3          1         21                    5.4   \n",
+      "1         3907         2          3         20                    7.6   \n",
+      "2         1260         3          2          5                   25.1   \n",
+      "3         1694         3          3          0                   17.5   \n",
+      "4         1530         4          3          4                   26.5   \n",
+      "\n",
+      "   price_thousands  \n",
+      "0           736.19  \n",
+      "1           729.73  \n",
+      "2           169.12  \n",
+      "3           353.68  \n",
+      "4           297.71  \n",
+      "\n",
+      "Price range: $-40.7k – $854.1k\n",
+      "\n",
+      "R² score : 0.9870\n",
+      "RMSE     : $22.48k\n",
+      "\n",
+      "Sample house (1800 sqft, 3 bed, 2 bath, 15 yrs, 8 km): $419.2k\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.linear_model import Ridge\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 = 300\n",
+    "\n",
+    "square_feet = np.random.randint(400, 4000, n)\n",
+    "bedrooms = np.random.randint(1, 6, n)\n",
+    "bathrooms = np.random.randint(1, 4, n)\n",
+    "age_years = np.random.randint(0, 60, n)\n",
+    "distance_to_center_km = np.round(np.random.uniform(0.5, 35.0, n), 1)\n",
+    "\n",
+    "# Price formula: size and rooms drive price up, age and distance drive it down\n",
+    "price_thousands = (\n",
+    "    0.18 * square_feet\n",
+    "    + 18 * bedrooms\n",
+    "    + 12 * bathrooms\n",
+    "    - 1.2 * age_years\n",
+    "    - 6.5 * distance_to_center_km\n",
+    "    + np.random.normal(0, 25, n)\n",
+    "    + 80\n",
+    ").round(2)\n",
+    "\n",
+    "df = pd.DataFrame({\n",
+    "    'square_feet': square_feet,\n",
+    "    'bedrooms': bedrooms,\n",
+    "    'bathrooms': bathrooms,\n",
+    "    'age_years': age_years,\n",
+    "    'distance_to_center_km': distance_to_center_km,\n",
+    "    'price_thousands': price_thousands\n",
+    "})\n",
+    "\n",
+    "print(df.head())\n",
+    "print(f'\\nPrice range: ${df.price_thousands.min():.1f}k – ${df.price_thousands.max():.1f}k')\n",
+    "\n",
+    "X = df[['square_feet', 'bedrooms', 'bathrooms', 'age_years', 'distance_to_center_km']]\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",
+    "# Ridge Regression with StandardScaler in a Pipeline\n",
+    "pipeline = Pipeline([\n",
+    "    ('scaler', StandardScaler()),\n",
+    "    ('ridge', Ridge(alpha=1.0))\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",
+    "mse = mean_squared_error(y_test, y_pred)\n",
+    "rmse = np.sqrt(mse)\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",
+    "    [[1800, 3, 2, 15, 8.0]],\n",
+    "    columns=['square_feet', 'bedrooms', 'bathrooms', 'age_years', 'distance_to_center_km']\n",
+    ")\n",
+    "pred = pipeline.predict(sample)[0]\n",
+    "print(f'\\nSample house (1800 sqft, 3 bed, 2 bath, 15 yrs, 8 km): ${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"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f8b5064bfed74a1ea1fc53a6a3c93bcc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HTML(value='<center> <img\\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.sv…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved locally: /content/ML_RidgeRegression_HousePricePredictor.joblib\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a41c535e27f14258a2c9574e8bedde2b",
+       "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": "8b8a652bd8eb44ac8c78ac314c382a42",
+       "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": "359430ce0d1f45309838e54d501de33e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  ...ousePricePredictor.joblib: 100%|##########| 1.50kB / 1.50kB            "
+      ]
+     },
+     "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_RidgeRegression_HousePricePredictor.joblib\")\n",
+    "\n",
+    "# Save the pipeline (scaler + Ridge model)\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": null,
+   "metadata": {},
+   "outputs": [],
+   "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_RidgeRegression_HousePricePredictor.joblib\",\n",
+    "    repo_type=\"model\"\n",
+    ")\n",
+    "pipeline = joblib.load(model_path)\n",
+    "\n",
+    "app = FastAPI()\n",
+    "\n",
+    "class HouseFeatures(BaseModel):\n",
+    "    square_feet: int\n",
+    "    bedrooms: int\n",
+    "    bathrooms: int\n",
+    "    age_years: int\n",
+    "    distance_to_center_km: float\n",
+    "\n",
+    "@app.post(\"/predict\")\n",
+    "def predict_house_price(features: HouseFeatures):\n",
+    "    input_df = pd.DataFrame(\n",
+    "        [[features.square_feet, features.bedrooms, features.bathrooms,\n",
+    "          features.age_years, features.distance_to_center_km]],\n",
+    "        columns=['square_feet', 'bedrooms', 'bathrooms', 'age_years', 'distance_to_center_km']\n",
+    "    )\n",
+    "    pred = pipeline.predict(input_df)[0]\n",
+    "    return {\n",
+    "        \"predicted_price_thousands\": round(float(pred), 2),\n",
+    "        \"predicted_price_formatted\": f\"${round(float(pred), 1)}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_RidgeRegression_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 RidgeRegressionRequest(BaseModel):
+    square_feet: int = 1800
+    bedrooms: int = 3
+    bathrooms: int = 2
+    age_years: int = 15
+    distance_to_center_km: float = 8.0
+
+
+MODEL_STATE: dict[str, Optional[Any]] = {
+    "model": None,
+    "error": None,
+}
+
+MODEL_URL = build_model_url("ML_RidgeRegression_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/ridge_regression", summary="Predict house price with Ridge Regression")
+def predict_ridge_regression(data: RidgeRegressionRequest):
+    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.square_feet, data.bedrooms, data.bathrooms, data.age_years, data.distance_to_center_km]],
+        columns=["square_feet", "bedrooms", "bathrooms", "age_years", "distance_to_center_km"],
+    )
+
+    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 = round(float(pred), 2)
+    return {
+        "predicted_price_thousands": price,
+        "predicted_price_formatted": f"${price:.1f}k",
+    }