PolynomialRegression/Polynomial Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorytm najszybszego spadku dla regresji wielomianowej. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skład grupy:\n",
    "- Nowak Ania,\n",
    "- Łaźna Patrycja,\n",
    "- Bregier Damian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Podstawowe informacje o zbiorze danych"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ze względu na specyfikę wytycznych projektu zakładającego wykorzystanie jedynie dwóch cech: x i y oraz modelowanie zależności y od x za pomocą funkcji wielomianowej dobrany został przez nas odpowiedni dataset. Obejmuje on jedynie trzy kolumny, czyli: płeć, wzrost w calach oraz wagę w funtach, z czego ze względu na specyfikę projektu wykorzystywane są jedynie wzrost oraz waga. Każdy z parametrów zawiera po 10 tysięcy unikalnych wartości.\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Wczytywanie i preprocessing danych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stopień wielomianu - zgodnie z wytycznymi domyślna wartość to dwa\n",
    "degree = 2\n",
    "X_plot = np.linspace(0, 1, 1000)\n",
    "initial_theta = np.matrix([0] * (degree + 1)).reshape(degree + 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wybór dwóch kolumn - dotyczących wzrostu i wagi\n",
    "data = pd.read_csv('weight-height.csv')[[\"Height\", \"Weight\"]]\n",
    "# Czyszczenie tabeli i wartości pustych\n",
    "data = data.dropna()\n",
    "data_matrix = np.matrix(data)\n",
    "\n",
    "m, n_plus_1 = data_matrix.shape\n",
    "n = n_plus_1 - 1\n",
    "X = (np.ones((m, 1)))\n",
    "\n",
    "for i in range(1, degree + 1):\n",
    "    Xn = np.power(data_matrix[:, 0:n], i)\n",
    "    Xn /= np.amax(Xn, axis=0)\n",
    "    X = np.concatenate((X, Xn), axis=1)\n",
    "\n",
    "X = np.matrix(X).reshape(m, degree * n + 1)\n",
    "Y = np.matrix(data_matrix[:, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Metody do regresji wielomianowej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Implementacja wzrosu na regresję wielomianową\n",
    "def polynomial_regression(theta, x):\n",
    "    return sum(theta * np.power(x, i) for i, theta in enumerate(theta.tolist()))\n",
    "\n",
    "# Implementacja wzoru na RMSE, czyli pierwiastek z błędu średniokwadratowego\n",
    "def mean_squared_error(theta, X, Y):\n",
    "    J = 1.0 / (2.0 * m) * ((X * theta - Y).T * (X * theta - Y))\n",
    "    return J.item()\n",
    "\n",
    "# Wzór na gradient prosty\n",
    "def classic_gradient(theta, X, Y):\n",
    "    return 1.0 / len(Y) * (X.T * (X * theta - Y)) \n",
    "\n",
    "# Batch gradient descent (BGD)\n",
    "def BGD(X, Y, theta, gradient = classic_gradient, cost_function = mean_squared_error, alpha=0.1, eps=10**-5, max_steps = 10000000000):\n",
    "    cost = cost_function(theta, X, Y)\n",
    "    logs = [[cost, theta]]\n",
    "    \n",
    "    for i in range(max_steps):\n",
    "        theta = theta - alpha * gradient(theta, X, Y)\n",
    "        next_cost = cost_function(theta, X, Y)\n",
    "        logs.append([next_cost, theta])\n",
    "        if abs(cost - next_cost) <= eps:\n",
    "            break\n",
    "        cost = next_cost\n",
    "    return theta, logs\n",
    "\n",
    "# Mini-batch gradient descent (MBGD)\n",
    "def MBGD(X, Y, theta, gradient = classic_gradient, cost_function = mean_squared_error, alpha=0.1, epochs=5, batch_size=16):\n",
    "    cost = cost_function(theta, X, Y)\n",
    "    logs = [[cost, theta]]\n",
    "    start, end = 0, batch_size\n",
    "    \n",
    "    steps = m / batch_size\n",
    "    for i in range(epochs):\n",
    "        zipped_XY = list(zip(X, Y))\n",
    "        random.shuffle(zipped_XY)\n",
    "        X_shuffled, Y_shuffled = zip(*zipped_XY)\n",
    "        X_shuffled = np.concatenate(X_shuffled, axis=0) \n",
    "        Y_shuffled = np.concatenate(Y_shuffled, axis=0) \n",
    "        for j in range(int(steps)):\n",
    "            batch =  X_shuffled[start:end,:], Y_shuffled[start:end,:]\n",
    "            theta = theta - alpha * gradient(theta, batch[0], batch[1])\n",
    "            cost = cost_function(theta, X, Y)\n",
    "            logs.append([cost, theta])\n",
    "\n",
    "            if start + batch_size < batch_size:\n",
    "                start += batch_size\n",
    "            else:\n",
    "                start = 0\n",
    "            end = min(start + batch_size, m)\n",
    "    return theta, logs\n",
    "\n",
    "# Stochastic gradient descent (SGD)\n",
    "def SGD(X, Y, theta, gradient = classic_gradient, cost_function = mean_squared_error, alpha=0.1, epochs=5, batch_size=16):\n",
    "    return MBGD(X, Y, theta, gradient, cost_function, alpha, epochs, 1)\n",
    "\n",
    "#print(mean_squared_error([1,2,1,1],[1,2,43,1]))\n",
    "#mean_squared_error(polynomial_regression(initial_theta, X), Y)\n",
    "#final_theta, logs_1 = BGD(X, Y, initial_theta)\n",
    "#final_theta, logs_2 = MBGD(X, Y, initial_theta, epochs = 30, batch_size = 16)\n",
    "final_theta, logs_2 = SGD(X, Y, initial_theta, epochs = 30)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda gradientu prostego\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Reprezentacja graficzna regresji wielomianowej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_polynomial_regression(theta):\n",
    "    fig = plt.figure(figsize=(10,5))\n",
    "    Y_plot = polynomial_regression(theta, X_plot).tolist()\n",
    "    chart = fig.add_subplot()\n",
    "    chart.plot(X[:,1], Y ,\"go\")\n",
    "    chart.plot(X_plot, Y_plot, color=\"red\", lw=2, label=f\"degree {len(theta)}\")\n",
    "    plt.show()\n",
    "    \n",
    "#plot_polynomial_regression(initial_theta)\n",
    "plot_polynomial_regression(final_theta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Regresja wielomianowa z wykorzystaniem gotowej biblioteki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.linear_model import Ridge, LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('polynomialfeatures', PolynomialFeatures()),\n",
       "                ('linearregression', LinearRegression())])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = make_pipeline(PolynomialFeatures(degree=degree, include_bias=True), \n",
    "                       LinearRegression())\n",
    "model.fit(data[[\"Height\"]],Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_plot_2 = np.linspace(-50, 100, 1000)\n",
    "Y_plot_2 = model.predict([[x] for x in X_plot_2])\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "chart = fig.add_subplot()\n",
    "chart.plot(data[\"Height\"], Y ,\"go\")\n",
    "chart.plot(X_plot_2, Y_plot_2, color=\"red\", lw=2, label=f\"degree {degree}\")\n",
    "plt.ylim([0,250])\n",
    "plt.xlim([40,80])\n",
    "degree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}