COMPARISION_1ST AND 2ND ORDER.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "83144928",
   "metadata": {},
   "source": [
    "# Importing Liabraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2d2095f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from scipy.optimize import minimize\n",
    "import numpy as np\n",
    "from sklearn.linear_model import SGDRegressor\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from sklearn.linear_model import Ridge\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "700be15f",
   "metadata": {},
   "source": [
    "# Loading Dataset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "657ae0b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       area  bedrooms   price\n",
      "0    1056.0         2   39.07\n",
      "1    2600.0         5  120.00\n",
      "2    1440.0         2   62.00\n",
      "3    1521.0         3   95.00\n",
      "4    1200.0         2   51.00\n",
      "..      ...       ...     ...\n",
      "294  1425.0         2   70.00\n",
      "295  1450.0         3  100.00\n",
      "296  1847.0         3  105.00\n",
      "297  1100.0         2   45.00\n",
      "298   525.0         1   26.00\n",
      "\n",
      "[299 rows x 3 columns]\n"
     ]
    }
   ],
   "source": [
    "# Load your dataset\n",
    "df = pd.read_csv('Bengaluru_House_Data.csv')\n",
    "print(df)\n",
    "# Preprocess the dataset as needed (e.g., handle missing values, encode categorical variables, etc.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "c70c69cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming 'Price' is the target variable and the rest are features\n",
    "X = df.drop('price', axis=1)\n",
    "y = df['price']\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68691856",
   "metadata": {},
   "source": [
    "# Applying the Ridge Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "70f9a236",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ridge MSE: 9262.194038432413\n",
      "Ridge R²: 0.4031962375976498\n"
     ]
    }
   ],
   "source": [
    "ridge = Ridge(alpha=1.0)\n",
    "ridge.fit(X_train, y_train)\n",
    "ridge_predictions = ridge.predict(X_test)\n",
    "ridge_mse = mean_squared_error(y_test, ridge_predictions)\n",
    "ridge_r2 = r2_score(y_test, ridge_predictions)\n",
    "\n",
    "print(f'Ridge MSE: {ridge_mse}')\n",
    "print(f'Ridge R²: {ridge_r2}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791aa0bd",
   "metadata": {},
   "source": [
    "# First Order (SGD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "7cc7e48a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD Score: -4.793943337942618e+26\n"
     ]
    }
   ],
   "source": [
    "# Initialize and train the model\n",
    "sgd = SGDRegressor(max_iter=10000, tol=1e-3)\n",
    "sgd.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the model\n",
    "sgd_score = sgd.score(X_test, y_test)\n",
    "print(f'SGD Score: {sgd_score}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dccf8ee",
   "metadata": {},
   "source": [
    "# Advance Algorithm (Adam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8fbf43fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam Optimizer Score: 0.32684297870899504\n"
     ]
    }
   ],
   "source": [
    "# Initialize and train the model\n",
    "adam_model = MLPRegressor(solver='adam', max_iter=1000)\n",
    "adam_model.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the model\n",
    "adam_score = adam_model.score(X_test, y_test)\n",
    "print(f'Adam Optimizer Score: {adam_score}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "6795e703",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization successful. Optimized parameters: [0.06216347 3.54875051]\n"
     ]
    }
   ],
   "source": [
    "'''Price=Intercept+(Slope Coefficient×Feature)'''\n",
    "\n",
    "# Define the objective function\n",
    "def objective_function(params):\n",
    "    # Ensure params is a 1D array\n",
    "    params = params.flatten()\n",
    "    # Make predictions using the linear model\n",
    "    predictions = X_train.dot(params)\n",
    "    # Calculate the loss (mean squared error)\n",
    "    loss = np.mean((y_train - predictions) ** 2)\n",
    "    return loss\n",
    "\n",
    "# Define a function to compute the gradient numerically\n",
    "def numerical_gradient(params):\n",
    "    epsilon = 1e-8\n",
    "    params = params.flatten()  # Ensure params is 1D\n",
    "    grad = np.zeros_like(params)\n",
    "    for i in range(len(params)):\n",
    "        params_plus = np.copy(params)\n",
    "        params_plus[i] += epsilon\n",
    "        grad[i] = (objective_function(params_plus) - objective_function(params)) / epsilon\n",
    "    return grad\n",
    "\n",
    "# Convert training data to numpy arrays if not already\n",
    "X_train = np.array(X_train)\n",
    "y_train = np.array(y_train)\n",
    "\n",
    "# Initial parameter guess\n",
    "initial_params = np.zeros(X_train.shape[1])\n",
    "\n",
    "# Perform optimization\n",
    "result = minimize(objective_function, initial_params, method='L-BFGS-B', jac=numerical_gradient)\n",
    "\n",
    "# Check if optimization was successful\n",
    "if result.success:\n",
    "    optimized_params = result.x\n",
    "    print(f'Optimization successful. Optimized parameters: {optimized_params}')\n",
    "else:\n",
    "    print(f'Optimization failed. Message: {result.message}')\n",
    "\n",
    "# Apply the optimized parameters to the model and evaluate\n",
    "# Here you would typically use the optimized parameters to make predictions and evaluate the model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb9b08cc",
   "metadata": {},
   "source": [
    "# Calculate Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "776912eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "L-BFGS MSE: 10063.43790543349\n",
      "L-BFGS R²: 0.3515685830220844\n",
      "\n",
      "Adam Optimizer MSE: 10447.170983696056\n",
      "Adam Optimizer R²: 0.32684297870899504\n",
      "\n",
      "SGD MSE: 7.440039122162888e+30\n",
      "SGD R²: -4.793943337942618e+26\n"
     ]
    }
   ],
   "source": [
    "# Compute predictions for L-BFGS\n",
    "l_bfgs_predictions = X_test.dot(optimized_params)\n",
    "l_bfgs_mse = mean_squared_error(y_test, l_bfgs_predictions)\n",
    "l_bfgs_r2 = r2_score(y_test, l_bfgs_predictions)\n",
    "\n",
    "print(f'\\nL-BFGS MSE: {l_bfgs_mse}')\n",
    "print(f'L-BFGS R²: {l_bfgs_r2}')\n",
    "\n",
    "\n",
    "# Predictions and evaluations for Adam\n",
    "adam_predictions = adam_model.predict(X_test)\n",
    "adam_mse = mean_squared_error(y_test, adam_predictions)\n",
    "adam_r2 = r2_score(y_test, adam_predictions)\n",
    "\n",
    "print(f'\\nAdam Optimizer MSE: {adam_mse}')\n",
    "print(f'Adam Optimizer R²: {adam_r2}')\n",
    "\n",
    "\n",
    "# Predictions and evaluations for SGD\n",
    "sgd_predictions = sgd.predict(X_test)\n",
    "sgd_mse = mean_squared_error(y_test, sgd_predictions)\n",
    "sgd_r2 = r2_score(y_test, sgd_predictions)\n",
    "\n",
    "print(f'\\nSGD MSE: {sgd_mse}')\n",
    "print(f'SGD R²: {sgd_r2}')\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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}