linear-regression-polynom.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import numpy as np\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"] = (10,8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Lineare Regression für nicht-lineare Daten?\n",
    "\n",
    "Was aber tun, wenn die Daten **nicht** durch ein lineares Modell abbildbar sind?\n",
    "\n",
    "Ein Trick, mit dem Sie die lineare Regression an nicht-lineare Beziehungen zwischen\n",
    "Variablen anpassen können, besteht darin, die Daten mit sogenannten **Basisfunktionen**\n",
    "zu transformieren.\n",
    "\n",
    "Die Idee besteht darin, unser mehrdimensionales lineares Modell zu nehmen\n",
    "\n",
    "$y=a_0+a_1x_1+a_2x_2+a_3x_3+\\dots$\n",
    "\n",
    "und mittels Basisfunktionen zu transformieren: Dazu lassen wir\n",
    "\n",
    "$x_i = f_i(x)$ für i=1...k\n",
    "\n",
    "sein, wobei $f_i$ eine Funktion ist, die unsere Daten transformiert.\n",
    "\n",
    "Wenn zum Beispiel $f_i(x) = x^i$ ist, wird unser Modell zu einer Polynom-Regression:\n",
    "\n",
    "$y=a_0+a_1x+a_2x^2+a_3x^3+\\dots$\n",
    "\n",
    "Beachten Sie, dass es sich nach wie vor um ein lineares Modell handelt - die\n",
    "Linearität bezieht sich auf die Tatsache, dass die Koeffizienten $a_i$ sich niemals\n",
    "miteinander multiplizieren oder dividieren. Was wir effektiv getan haben, ist,\n",
    "unsere $x$-Werte in eine höhere Dimension zu projizieren, so\n",
    "dass eine lineare Anpassung kompliziertere Beziehungen zwischen $x$ und $y$\n",
    "einpassen kann.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polynomische Basisfunktionen\n",
    "\n",
    "Diese Polynomprojektion ist so nützlich, dass sie mit Hilfe des\n",
    "`PolynomialFeatures-Transformators` in Scikit-Learn eingebaut ist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "x = np.array([2, 3, 4])\n",
    "poly = PolynomialFeatures(3, include_bias=False)\n",
    "poly.fit_transform(x[:, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Wir sehen hier, dass der Transformator unseren skalaren Wert in ein\n",
    "Array mit drei Elementen umgewandelt hat, indem er Quadrat und dritte Potenz unseres Wertes\n",
    "als \"Feature\" erzeugt hat.\n",
    "\n",
    "Diese neue, höherdimensionale Input-Darstellung kann dann in eine lineare Regression\n",
    "gesteckt werden. Der sauberste Weg, dies zu erreichen, ist die Verwendung einer sogenannten `Pipeline`.\n",
    "\n",
    "Erstellen wir auf diese Weise ein Polynom-Modell 7. Grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.pipeline import make_pipeline\n",
    "poly_model = make_pipeline(PolynomialFeatures(7), LinearRegression())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Mit dieser Transformation können wir das lineare Modell verwenden, um viel\n",
    "kompliziertere Beziehungen zwischen $x$ und $y$ anzupassen. Hier ist zum Beispiel\n",
    "eine polynomiale Regression einer verrauschte Sinuswelle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "rng = np.random.default_rng(1)\n",
    "x = 10 * rng.random(50)\n",
    "y = np.sin(x) + 0.1 * rng.standard_normal(50)\n",
    "\n",
    "\n",
    "poly_model.fit(x[:, np.newaxis], y)\n",
    "\n",
    "xfit = np.linspace(0, 10, 1000)\n",
    "yfit = poly_model.predict(xfit[:, np.newaxis])\n",
    "\n",
    "sns.scatterplot(x, y)\n",
    "sns.lineplot(xfit, yfit);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Gaußsche Basisfunktionen\n",
    "\n",
    "Natürlich sind auch andere Basisfunktionen möglich. Ein nützliches Muster ist zum\n",
    "Beispiel die Anpassung eines Modells, das nicht eine Summe von Polynom-Basen,\n",
    "sondern eine Summe von Gaußschen Basen ist.\n",
    "Eine Gaußsche Basis sieht folgendermaßen aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "x_all = np.arange(-10, 10, 0.001)\n",
    "y2 = norm.pdf(x_all,0,1)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(9,6))\n",
    "\n",
    "sns.lineplot(x_all,y2, ax=ax)\n",
    "ax.set_xlim([-4,4])\n",
    "ax.set_yticklabels([])\n",
    "ax.set_title('Gauß- / Normal-Verteilung');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    " Diese Gaußschen Basisfunktionen sind nicht in Scikit-Learn eingebaut, aber wir\n",
    " können einen benutzerdefinierten Transformator schreiben, der sie erzeugt.\n",
    "\n",
    " Hier ermöglichen wir also einen Fit der Daten mithilfe eine Summe von (im Beispiel 20) Gauß-Verteilungen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import Gauss\n",
    "\n",
    "gauss_model = make_pipeline(Gauss.GaussianFeatures(20),\n",
    "                            LinearRegression())\n",
    "gauss_model.fit(x[:, np.newaxis], y)\n",
    "yfit = gauss_model.predict(xfit[:, np.newaxis])\n",
    "\n",
    "sns.scatterplot(x, y)\n",
    "sns.lineplot(xfit, yfit);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Wir führen dieses Beispiel hier nur an, um deutlich zu machen, dass polynome\n",
    "Basisfunktionen nichts Magisches an sich haben: Wenn Sie eine Art Intuition in den\n",
    "Generierungsprozess Ihrer Daten haben, die Sie glauben lässt, dass die eine oder\n",
    "andere Basis angemessen sein könnte, können Sie sie ebenfalls verwenden.\n"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}