underfitting-overfitting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Underfitting und Overfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "np.random.seed(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir definieren uns unsere \"Ground Truth\" Funktion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def true_fun(X):\n",
    "    return np.cos(1.5 * np.pi * X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "und plotten dagegen Modelle mit Polynom Regression mit unterschiedlichen Graden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples = 20\n",
    "degrees = [1, 3, 5]\n",
    "\n",
    "X = np.sort(np.random.rand(n_samples))\n",
    "y = true_fun(X) + np.random.randn(n_samples) * 0.1\n",
    "\n",
    "fig, axs = plt.subplots(1, 3, figsize=(30, 10))\n",
    "\n",
    "def setup(ax):\n",
    "    ax.set_xticks(())\n",
    "    ax.set_yticks(())\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y\")\n",
    "    ax.set_xlim((0, 1))\n",
    "    ax.set_ylim((-2, 2))\n",
    "    ax.legend(loc=\"best\", fontsize=18)\n",
    "\n",
    "def plot_comparison(X, y):\n",
    "    for i in range(len(degrees)):\n",
    "\n",
    "        polynomial_features = PolynomialFeatures(degree=degrees[i],\n",
    "                                                 include_bias=True)\n",
    "        linear_regression = LinearRegression()\n",
    "        pipeline = Pipeline([(\"polynomial_features\", polynomial_features),\n",
    "                             (\"linear_regression\", linear_regression)])\n",
    "        pipeline.fit(X[:, np.newaxis], y)\n",
    "\n",
    "        # Evaluate the models using crossvalidation\n",
    "        scores = cross_val_score(pipeline, X[:, np.newaxis], y,\n",
    "                                 scoring=\"neg_mean_squared_error\", cv=10)\n",
    "\n",
    "        X_test = np.linspace(0, 1, 100)\n",
    "        axs[i].plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label=\"Modell\")\n",
    "        axs[i].plot(X_test, true_fun(X_test), label=\"Wahre Funktion\")\n",
    "        axs[i].scatter(X, y, edgecolor='b', s=20, label=\"Samples\")\n",
    "\n",
    "        setup(axs[i])\n",
    "        axs[i].set_title(f\"Grad {degrees[i]}\\nMSE = {-scores.mean():.2e}(+/- {scores.std():.2e})\", fontsize=18)\n",
    "\n",
    "plot_comparison(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... und jetzt mit 5-mal so vielen Trainingsdaten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples = 100\n",
    "\n",
    "X = np.sort(np.random.rand(n_samples))\n",
    "y = true_fun(X) + np.random.randn(n_samples) * 0.1\n",
    "\n",
    "fig, axs = plt.subplots(1, 3, figsize=(30, 10))\n",
    "\n",
    "plot_comparison(X, y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "param_range = np.arange(1,16)\n",
    "\n",
    "fig, axs = plt.subplots(1,3, figsize=(30,10), sharey=True)\n",
    "\n",
    "n_samples = 100\n",
    "\n",
    "X = np.sort(np.random.rand(n_samples))\n",
    "y = true_fun(X) + np.random.randn(n_samples) * 0.1\n",
    "\n",
    "for i, degree in enumerate(degrees):\n",
    "    polynomial_features = PolynomialFeatures(degree=degree, include_bias=True)\n",
    "    linear_regression = LinearRegression()\n",
    "    pipeline = Pipeline([(\"polynomial_features\", polynomial_features), (\"linear_regression\", linear_regression)])\n",
    "\n",
    "    # print(pipeline.get_params().keys())\n",
    "    train_sizes, train_scores, validation_scores = learning_curve(pipeline, X[:, np.newaxis], y, train_sizes=np.linspace(.3,1,10), cv = 5, scoring='neg_mean_squared_error', shuffle=True)\n",
    "\n",
    "    train_scores_mean = -np.mean(train_scores, axis=1)\n",
    "    validation_scores_mean = -np.mean(validation_scores, axis=1)\n",
    "\n",
    "    axs[i].set_ylim([0, 1])\n",
    "    axs[i].plot(train_sizes, train_scores_mean, label = 'Training error')\n",
    "    axs[i].plot(train_sizes, validation_scores_mean, label = 'Validation error')\n",
    "    axs[i].set_ylabel('MSE', fontsize = 14)\n",
    "    axs[i].set_xlabel('Training set size', fontsize = 14)\n",
    "    axs[i].set_title(f'Learning curves: Degree {degree}', fontsize = 24, y = 1.03)\n",
    "    axs[i].legend();\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.6 64-bit ('dhbw20': conda)",
   "language": "python",
   "name": "python37664bitdhbw20conda4e9f90a409f24fc4a1b2fdf8774acce3"
  },
  "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": 4
}