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 Anna,\n",
    "- Łaźna Patrycja,\n",
    "- Bregier Damian"
   ]
  },
  {
   "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)\n",
    "\n",
    "Dokładne informacje na temat tego zbioru, jego zawartości i samych danych można znaleźć pod adresem: https://www.kaggle.com/mustafaali96/weight-height."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Wczytywanie i preprocessing danych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stopień wielomianu\n",
    "degree = 4\n",
    "X_plot = np.linspace(0, 100, 1000)\n",
    "initial_theta = np.matrix([0] * (degree + 1)).reshape(degree + 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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 regresji wielomianowej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_theta(theta):\n",
    "    print(\"f(x) = \", end=\"\")\n",
    "    for i,x in enumerate(theta.tolist()[:-1]):\n",
    "        x = x[0]\n",
    "        print(f\"{x}x^{i}\", end=\" + \")\n",
    "    print(f\"{theta.tolist()[-1][0]}^{len(theta) - 1}\")\n",
    "\n",
    "# Implementacja wzrosu na regresję wielomianową\n",
    "def polynomial_regression(theta, x):\n",
    "    x = x/data[\"Height\"].max()\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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Wybrane rodzaje gradientów"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda gradientu prostego to algorytm numeryczny mający na celu znalezienie minimum lokalnego dla zadanej funkcji celu. Jak sama nazwa wskazuje jest to jedna z prostszych metod, która opiera się na iteracyjnym poszukiwaniu minimum. Proces ten (dla pierwszych czterech kroków), został pokazany na poniższym rysunku.\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wzór na gradient prosty\n",
    "def gradient(theta, X, Y):\n",
    "    return 1.0 / len(Y) * (X.T * (X * theta - Y)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Batch gradient descent (BGD)\n",
    "def BGD(X, Y, theta, cost_function = mean_squared_error, learning_rate=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 - learning_rate * 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",
    "# BGD z momentum\n",
    "def momentum(X, Y, theta, cost_function = mean_squared_error, learning_rate=0.1, momentum = 0.9, epochs=30):\n",
    "    cost = cost_function(theta, X, Y)\n",
    "    logs = [[cost, theta]]\n",
    "    delta_history = [np.matrix([0]*(degree+1)).T]\n",
    "    for i in range(epochs):\n",
    "        delta_history.append(momentum * delta_history[-1] + learning_rate * gradient(theta, X, Y))\n",
    "        theta = theta - delta_history[-1]\n",
    "        next_cost = cost_function(theta, X, Y)\n",
    "        logs.append([next_cost, theta])\n",
    "        cost = next_cost\n",
    "    return theta, logs\n",
    "\n",
    "# Mini-batch gradient descent (MBGD)\n",
    "def MBGD(X, Y, theta, cost_function = mean_squared_error, learning_rate=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 - learning_rate * 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, cost_function = mean_squared_error, learning_rate=0.1, epochs=5):\n",
    "    return MBGD(X, Y, theta, cost_function, learning_rate, epochs, 1)\n",
    "\n",
    "# Steepest descent\n",
    "def steepest_descent(X, Y, theta, cost_function = mean_squared_error, single_step=0.01, epochs=30):\n",
    "    cost = cost_function(theta, X, Y)\n",
    "    logs = [[cost, theta]]\n",
    "    for i in range(epochs):\n",
    "        direction = gradient(theta, X, Y)\n",
    "        j = 0\n",
    "        while(True):\n",
    "            j+=1\n",
    "            next_theta = theta - single_step * direction\n",
    "            next_cost = cost_function(next_theta, X, Y)\n",
    "            if(next_cost >= cost or type(next_cost) != float):\n",
    "                break\n",
    "            cost = next_cost\n",
    "            theta = next_theta\n",
    "        logs.append([next_cost, theta])\n",
    "    return theta, logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Zestawienie wyników"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BGD:\n",
      "f(x) = -65.64506277392503x^0 + 68.77648241255996x^1 + 114.75349304333463x^2 + 102.20675310280693x^3 + 52.80014652046723^4\n",
      "82705 updates\n",
      "\n",
      "MBGD:\n",
      "f(x) = -20.49538398624665x^0 + 43.83203531549893x^1 + 74.9580517022499x^2 + 83.08157339221718x^3 + 75.75845309811228^4\n",
      "37501 updates\n",
      "\n",
      "SGD:\n",
      "f(x) = 38.980419583838696x^0 + 42.24440889357842x^1 + 43.5350614491982x^2 + 43.437875831269686x^3 + 42.39005292817251^4\n",
      "600001 updates\n",
      "\n",
      "momentum:\n",
      "f(x) = 8.015549563834483x^0 + 38.129978604712036x^1 + 58.338707783566186x^2 + 71.220198958028x^3 + 78.7251186900262^4\n",
      "61 updates\n",
      "\n",
      "steepest descent:\n",
      "f(x) = 13.638648831593645x^0 + 39.092493619820296x^1 + 55.99541645170152x^2 + 66.58927282539155x^3 + 72.5680972400324^4\n",
      "61 updates\n",
      "\n"
     ]
    }
   ],
   "source": [
    "final_theta_BGD, logs_1 = BGD(X, Y, initial_theta)\n",
    "print(\"BGD:\")\n",
    "print_theta(final_theta_BGD)\n",
    "print(f\"{len(logs_1)} updates\\n\")\n",
    "\n",
    "final_theta_MBGD, logs_2 = MBGD(X, Y, initial_theta, epochs = 60)\n",
    "print(\"MBGD:\")\n",
    "print_theta(final_theta_MBGD)\n",
    "print(f\"{len(logs_2)} updates\\n\")\n",
    "\n",
    "final_theta_SGD, logs_3 = SGD(X, Y, initial_theta, epochs = 60)\n",
    "print(\"SGD:\")\n",
    "print_theta(final_theta_SGD)\n",
    "print(f\"{len(logs_3)} updates\\n\")\n",
    "\n",
    "final_theta_momentum, logs_4 = momentum(X, Y, initial_theta, epochs = 60)\n",
    "print(\"momentum:\")\n",
    "print_theta(final_theta_momentum)\n",
    "print(f\"{len(logs_4)} updates\\n\")\n",
    "\n",
    "final_steepest_descent, logs_5 = steepest_descent(X, Y, initial_theta, epochs = 60)\n",
    "print(\"steepest descent:\")\n",
    "print_theta(final_steepest_descent)\n",
    "print(f\"{len(logs_5)} updates\\n\")"
   ]
  },
  {
   "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": [
    "## 4. Reprezentacja graficzna regresji wielomianowej i funkcji kosztu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BGD:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAEzCAYAAADzdE1rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAxRElEQVR4nO3deXxcVf3/8dcnadImDU1pylK7JEWKLBZBApStLCkUKqWAIkvQimhkUVsBEYiCVSIIgoWfVoyyFBlBvlqWQssWQEWWkrKYstnaJqFQu0K6pEuW8/vjTtpJO1nn3pnJzPv5ePSRmzv3nnN4XJp8es7nfo455xARERGR2GUkegAiIiIiqUKBlYiIiIhPFFiJiIiI+ESBlYiIiIhPFFiJiIiI+ESBlYiIiIhPugyszGykmb1gZu+Z2TtmNi18/qdm9pGZvRX+MyninmvNbImZfWBmE4P8DxARERFJFtZVHSszGwYMc869YWa7AQuBM4GvAhudc7/a6foDgQeBI4DPAM8B+znnWvwfvoiIiEjy6HLGyjm3wjn3Rvh4A/AeMLyTW6YADznntjrnlgFL8IIsERERkZTWoxwrMysCDgVeC5/6rpn928zuMbPdw+eGAx9G3LaczgMxERERkZTQr7sXmlke8DdgunNuvZn9Dvg54MJfbwO+CViU23dZbzSzMqAMYODAgYftv//+PR+9iIikvYUfL+zR9XtvhOEbYH02LC7Y6UOD0YNHMyRniH8DlJSzcOHCNc65PaJ91q3Aysyy8IKqkHNuDoBzbmXE538Angh/uxwYGXH7CODjndt0zlUClQDFxcWuurq6O0MRERFpp2hmEXUNdd26duBWqJkJQ4ETz4fFo9t/bhhLb1jq+xgltZhZh//DdeetQAPuBt5zzt0ecX5YxGVnAYvCx48D55lZfzMbDYwBFvRm4CIiIl2pKKkgNyu3W9d++w0YuhleHgEvFu36+aj8UduPQzUhimYWkTEjg6KZRYRqQj6NWFJZd2asjgG+BtSY2Vvhc9cB55vZIXjLfLXAdwCcc++Y2cPAu0AzcLneCBQRkaCUji0FYNr8aazdvHaXzwdmDWRT0yaym+Gql71zvziOXRJXcrNyqSipALygqmxuGY1NjQDUNdRRNresXX8i0XRZbiEetBQoIiJ+CNWEKK8qp76hnlH5o6goqaB0bClFM4uYWFXH75+At/eCQy6hXWBVmF+4/VroeHmxML+Q2um18fmPkaRlZgudc8XRPut28rqIiEiyKx1bGnVG6RfH/4xxM6Z6xzvNVhXkFOwSLNU31Edtv6PzIm20pY2IiPQ5Pc1/uuCdDPb5FD4ogL8e2P6zDVs37NJWZK5VpI7Oi7TRUqCIiPQpO+c/RSrIKeCO0+4AduRcWSu8c5dxwCrHRVPgvkM7bz83K5epX5jK7Ldnt+sjNyuXysmVyrGSTpcCNWMlIiJ9SnlVedSgCmDt5rVcOOdCLpxz4fZE9ikfwAGrHPWDIDS26/YbmxqZt3gelZMrKcwvxDAK8wsVVEm3KMdKRET6lB7lOTko/4d3eMsx0NTN33r1DfUd5muJdEYzViIi0qf0JM/ptMVQvAJWDoS7vxhMHyKRFFiJiEifsu+Qfbt3oYMb/u4d3nIMbMnq3m2R9axEekqBlYiI9BmhmhDPL3u+W9ee8l848iNYlQt3RU0z3lVBToFyqSQmyrESEZE+o7yqHEc33mZ3cMOL3uGvjobG7M4vz8vO467T71JAJTHTjJWIiPQZ3U1cL1kKRy+H1bkw6/Cur++f2V9BlfhCgZWIiPQZ3Uoqj8ituu0o2NS/61ui7TEo0hsKrEREpE8I1YS6FQCduAyOq4e1OfDbI7rffneruIt0RjlWIiKS9EI1Ib752DfZ1rKty2uvD89W3X4UbOzGbFUbh6OuoY6yuWUAWhqUXtGMlYiIJKVQTYihtwzFZhgXzrmwW0HV+Fo4oQ4+GQC/6cFsVaTGpkbKq8p7d7OkPc1YiYhIwoVqQpRXlVPfUM+QnCFsad7CpqZNPW6nbbbq1+Ng/YDej6dH1d1FIiiwEhGRhLrsycu4q/qu7WUUeptIfkwdlCyDT/vDnUfGNiZVXpfe0lKgiIgkTKgm1C6oikXbm4B3jIOGnN63o8rrEgsFViIikjDdLvjZhaPq4eSl0NAfZo7rfTuZlknl5EoAimYW6U1B6TEtBYqISFxF5lP5EVTBjtyqO4+ET2OYrWp1rQCUzS2jsakRQG8KSo+Yc/78Tx2L4uJiV11dnehhiIhIgEI1IabNn+Z7Mc5xH8Ird8OGbCiaDutye99WYX4h4AVT0T6rnV7b+8YlZZjZQudc1B0otRQoIiKBC9WEKJtbFkiF85+H92SeOS62oKott6qjNwL1pqB0hwIrEREJXHlV+falNT+Nr4UJ4TcBbz+q9+205VaVji3t8I1AvSko3aHASkREAhfIbI/bMVt1+1G9z63Kzsxm9lmzt+dPVZRUkJvVfupLbwpKdymwEhGRwA3JGeJ7mxOWwvjwnoC9fROwIKeAe6bc0y4pvXRsKZWTKynML8QwCvMLt89miXRFbwWKiEigQjUh1m9d72+jEbNVtx4NG3pYZT3TMmm+vrnDz0vHliqQkl5RYCUiIoEJ1YSY+shUWlyLr+1OWgzjPoJVub3bE7DssDJfxyPSRoGViIgEYsL9E6haVuV/ww5+9oJ3ePOxsKl/z24vGV3CrC/N8n9cIijHSkREAnDZk5cFE1QBZ74Ph62Aj/Pgd4f37N6S0SUsWbdEFdUlMJqxEhER31UurAykXWvdMVv1i+NgS1bP7o8M9lRRXYKgGSsREfGd3zlVbc55F8augvpB8IfDYm+vsamR8qry2BsSCVNgJSIivsu0TN/bzGiFn77oHd84Hrb5tOaiiuriJwVWIiLiuyDeurugBg5YA0sHw72H+teuKqqLnxRYiYiIr0I1IeYtnudrm/1a4IYXveOfHQ/NPk6ITRozyb/GJO0peV1ERHzTttmy3/sCfuMt2PcT+M8QeOBgX5v2PQiU9KYZKxER8U0Qmy0PaNqRW/WTk6DF5/StuoY6fxuUtKbASkREfBNEIvjlC2D4Bnhjb/i/A31vHsNUz0p8o8BKRER84/dmy4O2wLUvecfXlYAL4LeWw6nkgvhGgZWIiHQpVBOiaGZRlxXLtzRv8bXfq16Ggs3w90J4el9fm25HJRfEL0peFxGRTu2ckB5ZsRy8vKog8pT23Ag/eMU7vrYEsNjay83KJadfDms3r93lM5VcEL8osBIRkU5FS0hvbGpk2vxpbG7e7Huyepvr/gl5TfD4fvBKjHFPQU4Bd5x2B8Auby3mZuVSUVIRWwciYVoKFBGRTnW0TLZ289rAgqrCT+DS16EVKC+Jvb3NzZsBb0/AysmVFOYXYhiF+YVUTq7UXoHiG3POJXoMFBcXu+rq6kQPQ0REoiiaWRT3kgT3PgLfeBv+dDB8/Wx/2izML6R2eq0/jUlaM7OFzrniaJ9pxkpERDpVUVJBblZuu3O5WbkU5BQE0t+Bq+Br/4amDLjhBP/aVYK6xIMCKxER6VTk8hl4dZ8amxqjJoH74cbnIdNB5WGwzMfqDUpQl3hQYCUiIlFFllgorypn0phJ9MvohyO4FJIjlsNZ70NjP7hxvH/tKkFd4kWBlYiI7KKtxEJdQx0OR11DHXdV30Vza3NwnTq46TnvcOY4+N9usTVXkFOgBHWJuy7LLZjZSOB+YG+8FzQqnXN3mNkQ4C9AEVALfNU590n4nmuBi4EW4PvOuacDGb2IiAQiWomFIGeqAE7+L5xUC58MgFuPib29vOw81ly9JvaGRHqgOzNWzcCVzrkDgHHA5WZ2IHANUOWcGwNUhb8n/Nl5wEHAqcAsM/N5y0wREQlSvBO9M1rhlme945uPhU9zYm9TyeqSCF0GVs65Fc65N8LHG4D3gOHAFGB2+LLZwJnh4ynAQ865rc65ZcAS4Aifxy0iIgGKd6J36b/hkJVQPwjuPNKfNpWsLonQoxwrMysCDgVeA/Zyzq0AL/gC9gxfNhz4MOK25eFzO7dVZmbVZla9evXqXgxdRES
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MBGD:\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD:\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Momentum:\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metoda najszybszego spadku:\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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(data[\"Height\"], Y ,\"go\")\n",
    "    chart.plot(X_plot, Y_plot, color=\"red\", lw=2, label=f\"degree {len(theta)}\")\n",
    "    plt.ylim([0,250])\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "def plot_cost_function(logs):\n",
    "    no_iter = no_iter = [x for x in range(1, len(logs) + 1)]\n",
    "    all_cost = [row[0] for row in logs]\n",
    "    \n",
    "    fig = plt.figure(figsize=(10,5))  \n",
    "    plt.plot(no_iter, all_cost)\n",
    "    plt.xlabel('No. of iterations')\n",
    "    plt.ylabel('Cost')\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "print(\"BGD:\")\n",
    "plot_polynomial_regression(final_theta_BGD)\n",
    "plot_cost_function(logs_1)\n",
    "print(\"MBGD:\")\n",
    "plot_polynomial_regression(final_theta_MBGD)\n",
    "plot_cost_function(logs_2)\n",
    "print(\"SGD:\")\n",
    "plot_polynomial_regression(final_theta_SGD)\n",
    "plot_cost_function(logs_3)\n",
    "print(\"Momentum:\")\n",
    "plot_polynomial_regression(final_theta_momentum)\n",
    "plot_cost_function(logs_4)\n",
    "print(\"Metoda najszybszego spadku:\")\n",
    "plot_polynomial_regression(final_steepest_descent)\n",
    "plot_cost_function(logs_5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Regresja wielomianowa z wykorzystaniem gotowych bibliotek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('polynomialfeatures', PolynomialFeatures(degree=4)),\n",
       "                ('linearregression', LinearRegression())])"
      ]
     },
     "execution_count": 9,
     "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": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "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": [
    "Y_plot_2 = model.predict([[x] for x in X_plot])\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, Y_plot_2, color=\"red\", lw=2, label=f\"degree {degree}\")\n",
    "plt.ylim([0,250])\n",
    "plt.xlim([0,100])\n",
    "degree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "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": [
    "polyfit_theta = np.polyfit(data[\"Height\"]/data[\"Height\"].max(), Y, degree)\n",
    "plot_polynomial_regression(polyfit_theta)"
   ]
  }
 ],
 "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
}