02.3.LinearRegression-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python version:  sys.version_info(major=3, minor=7, micro=2, releaselevel='final', serial=0)\n",
      "numpy 1.17.0\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "import sys\n",
    "from collections.abc import Iterable\n",
    "from functools import reduce\n",
    "\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.datasets import load_boston\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "print(\"python version: \", sys.version_info)\n",
    "print(np.__name__, np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Numpy实现Linear Regressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$w=\\left(X^{\\top} X\\right)^{-1} X^{\\top} Y$  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 NumpyBaseEstimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyBaseEstimator:\n",
    "    \"\"\"Numpy estimator base class for all numpy estimator.\"\"\"\n",
    "\n",
    "    def _fit_validation(self, X, y):\n",
    "        \"\"\"valid fit method's params\n",
    "\n",
    "        Args:\n",
    "            X: feature data for training. A np.ndarray matrix of (n_samples,\n",
    "                n_features) shape, data type must be continuous value type.\n",
    "            y: label data for training. A np.ndarray array of (n_samples, ) shape.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray type data of X and y.\n",
    "\n",
    "        Raises:\n",
    "            AssertionError: Error type of X or y, or mismatched shape for X or y.\n",
    "        \"\"\"\n",
    "        assert isinstance(X, Iterable) and isinstance(y, Iterable)\n",
    "        assert len(X) == len(y)\n",
    "        X = X if isinstance(X, np.ndarray) else np.array(X)\n",
    "        y = y if isinstance(y, np.ndarray) else np.array(y)\n",
    "        if X.ndim != 2:\n",
    "            raise ValueError(f\"X dim must be 2, got {X.ndim} dim of X! \")\n",
    "        return X, y\n",
    "\n",
    "    def _predict_validation(self, X_test):\n",
    "        \"\"\"valid predict method's params\n",
    "\n",
    "        Args:\n",
    "            X_test: feature data for predicting. A np.ndarray matrix of (n_samples,\n",
    "                n_features) shape, data type must be continuous value type.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray type data of X_test.\n",
    "\n",
    "        Raises:\n",
    "            AssertionError: Error type of X_test.\n",
    "            ValueError: Mismatched shape for X_test.\n",
    "        \"\"\"\n",
    "        assert isinstance(X_test, Iterable)\n",
    "        X_test = X_test if isinstance(X_test, np.ndarray) else np.array(X_test)\n",
    "        error_text = f\"Mismatched shape for X_test! Get {X_test.shape}, only\" \\\n",
    "                     f\" ({self._X_train.shape[1]}, ) or (_, {self._X_train.shape[1]}) \" \\\n",
    "                     f\"X_test can be.\"\n",
    "        if X_test.ndim == 1:\n",
    "            if X_test.shape[0] != self._X_train.shape[1]:\n",
    "                raise ValueError(error_text)\n",
    "        elif X_test.ndim == 2:\n",
    "            if X_test.shape[1] != self._X_train.shape[1]:\n",
    "                raise ValueError(error_text)\n",
    "        else:\n",
    "            raise ValueError(f\"X_test with the {X_test.ndim} dim! Only 1 or 2 dim X_test can be.\")\n",
    "        return X_test\n",
    "\n",
    "    def _score_validation(self, X_test, y_test):\n",
    "        \"\"\"valid score method's params\n",
    "\n",
    "        Args:\n",
    "            X_test: feature data for training. A np.ndarray matrix of (n_samples,\n",
    "                n_features) shape, data type must be continuous value type.\n",
    "            y_test: label data for training. A np.ndarray array of (n_samples, ) shape.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray type data of X_test and y_test.\n",
    "\n",
    "        Raises:\n",
    "            AssertionError: Error type of X_test or y_test.\n",
    "            ValueError: Mismatched shape for X_test or y_test.\n",
    "        \"\"\"\n",
    "        X_test = self._predict_validation(X_test)\n",
    "        is_valid = True\n",
    "        if isinstance(y_test, Iterable):\n",
    "            if X_test.shape[0] != len(y_test):\n",
    "                is_valid = False\n",
    "            elif X_test.ndim == 1:\n",
    "                is_valid = False\n",
    "        else:\n",
    "            assert isinstance(y_test, int) or isinstance(y_test, float)\n",
    "            if X_test.ndim != 1:\n",
    "                is_valid = False\n",
    "        y_test = np.array(y_test)\n",
    "        if not is_valid:\n",
    "            raise ValueError(f\"Mismatched shape for y_test! X_test with {X_test.shape} shape, but \"\n",
    "                             f\"y_test's shape is {y_test.shape}\")\n",
    "        return X_test, y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 NumpyRegressorMixin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyRegressorMixin:\n",
    "    \"\"\"Regressor Mixin with numpy. Mainly realized the score method.\"\"\"\n",
    "\n",
    "    def score(self, X_test, y_test):\n",
    "        \"\"\"Use test dataset to evaluate the trained model.\n",
    "\n",
    "        Args:\n",
    "            X_test: A np.ndarray matrix of (n_samples, n_features) shape.\n",
    "            y_test: A np.ndarray array of (n_samples, ) shape. data type must be\n",
    "                discrete value.\n",
    "        Returns:\n",
    "            return R^2, R^2 = 1 - u / v. u = sum((y_pred - y_true)^2), v = sum((y_true - y_true_mean)^2)\n",
    "        \"\"\"\n",
    "        X_test, y_test = self._score_validation(X_test, y_test)\n",
    "        y_pred = self.predict(X_test, _miss_valid=True)\n",
    "        y_true_mean = np.mean(y_test, axis=0)\n",
    "        u = np.sum(np.square(y_pred - y_test))\n",
    "        v = np.sum(np.square(y_test - y_true_mean))\n",
    "        r_squared = 1 - u / v\n",
    "        return r_squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 NumpyBaseLinearRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyBaseLinearRegressor(NumpyBaseEstimator, NumpyRegressorMixin):\n",
    "    \"\"\"Linear regressor base class with numpy, explicitly inherits from NumpyBaseEstimator\n",
    "        and NumpyRegressorMixin already.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train:feature data for training. A np.ndarray matrix of (n_samples, \n",
    "            n_features) shape, data type must be continuous value type. \n",
    "        _y_train:label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        coef_: coef of linear regressor. A np.ndarray array of (n_features, ) shape.\n",
    "        intercept_: intercept of regressor. A np.ndarray integer.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, fit_intercept=True, random_state=None):\n",
    "        \"\"\"linear regressor init method.\n",
    "        \n",
    "        Args:\n",
    "            fit_intercept: Bool value. If use intercept in the linear regressor model.\n",
    "        \"\"\"\n",
    "        fit_intercept, random_state = self._init_validation(fit_intercept, random_state)\n",
    "        self._X_train = None\n",
    "        self._y_train = None\n",
    "        self.coef_ = None\n",
    "        if random_state is not None:\n",
    "            np.random.seed(random_state)\n",
    "        self.intercept_ = np.random.randn() if fit_intercept else None\n",
    "\n",
    "    def fit(self, X_train, y_train):\n",
    "        \"\"\"method for training model. \n",
    "        \n",
    "        Args:\n",
    "            X_train: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                data type must be continuous value type. \n",
    "            y_train: A np.ndarray array of (n_samples, ) shape.\n",
    "        \n",
    "        Returns:\n",
    "            self object.\n",
    "        \"\"\"\n",
    "        self._X_train, self._y_train = self._fit_validation(X_train, y_train)\n",
    "        if self.intercept_ is not None:\n",
    "            self._X_train = np.c_[self._X_train, np.ones((self._X_train.shape[0], 1))]\n",
    "        self._calculate_coef()\n",
    "        if self.intercept_ is not None:\n",
    "            self.intercept_ = self.coef_[-1]\n",
    "            self.coef_ = np.delete(self.coef_, -1)\n",
    "            self._X_train = np.delete(self._X_train, -1, axis=1)\n",
    "        return self\n",
    "\n",
    "    def predict(self, X_test, _miss_valid=False):\n",
    "        \"\"\"predict test data.\n",
    "        \n",
    "        Args:\n",
    "            X_test: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                or a np.ndarray array of (n_features, ) shape.\n",
    "        \"\"\"\n",
    "        if not _miss_valid:\n",
    "            X_test = self._predict_validation(X_test)\n",
    "        product = X_test @ self.coef_\n",
    "        return product if self.intercept_ is None else product + self.intercept_\n",
    "    \n",
    "    def _init_validation(self, fit_intercept, random_state):\n",
    "        assert isinstance(fit_intercept, bool)\n",
    "        assert isinstance(random_state, (int, type(None)))\n",
    "        return fit_intercept, random_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 NumpyLinearRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyLinearRegressor(NumpyBaseLinearRegressor):\n",
    "    \"\"\"Linear regressor class with numpy, explicitly inherits from NumpyBaseLinearRegressor already.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train:feature data for training. A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "            data type must be continuous value type. \n",
    "        _y_train:label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        coef_: coef of linear regressor. A np.ndarray array of (n_features, ) shape.\n",
    "        intercept_: intercept of regressor. A np.ndarray integer.\n",
    "    \"\"\"\n",
    "\n",
    "    def _calculate_coef(self):\n",
    "        xtx = self._X_train.T @ self._X_train\n",
    "        try:\n",
    "            xtx_inv = np.linalg.inv(xtx)\n",
    "        except np.linalg.LinAlgError as ex:\n",
    "            raise ex\n",
    "        self.coef_ = xtx_inv @ self._X_train.T @ self._y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 生成数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_linear_data(point_count=100, min_=0., max_=10., w=0.5493, b=1.1973, random_state=None, scale=1.0, loc=0.0):\n",
    "    \"\"\"load linear data\n",
    "\n",
    "    Args:\n",
    "        point_count: a integer number, default = 100.\n",
    "        min_: bottom range of x data, a float number, default = 0.0.\n",
    "        max_: top range of x data, a float number, default = 10.0.\n",
    "        w: the coef of linear, a float number, default = 0.5493.\n",
    "        b: the intercept of linear, a float number, default = 1.1973.\n",
    "        random_state: random seed, a int number, default = None.\n",
    "        scale: noise's scale. A float number, default = 1.0.\n",
    "        loc: noise's loc. A float number, default = 0.0\n",
    "\n",
    "    Returns:\n",
    "        A tuple. (x, y). the shape of x is (point_count, 1), the shape\n",
    "            of y is (point_count, ).\n",
    "\n",
    "    Raises:\n",
    "        AssertionError: random_state is not a integer.\n",
    "    \"\"\"\n",
    "    if random_state is not None:\n",
    "        assert isinstance(random_state, int)\n",
    "        np.random.seed(random_state)\n",
    "\n",
    "    x = np.random.uniform(min_, max_, point_count)\n",
    "    noise = np.random.normal(scale=scale, loc=loc, size=[point_count])\n",
    "    y = w * x + b + noise\n",
    "    return x.reshape([-1, 1]), y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = load_linear_data(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=[10, 5])\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.scatter(x, y, s=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.56199546]), 1.1418439527206572)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyLinearRegressor(fit_intercept=True)\n",
    "rgs.fit(x, y)\n",
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6 绘制回归拟合直线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_regressor_linear(X_data, y_data, pred_coef, pred_intercept=0):\n",
    "    \"\"\"show the regression linear and data point.\n",
    "    \n",
    "    Args:\n",
    "        X_data: A np.ndarray matrix of (point_count, 1) shape, \n",
    "            data type must be continuous value type. \n",
    "        y_data: A np.ndarray array of (point_count, ) shape.\n",
    "        pred_coef: prediction coef. A np.ndarray matrix of (1, ) shape.\n",
    "        pred_intercept: prediction coef. A np.ndarray integer or interge, default = 0.\n",
    "    \"\"\"\n",
    "    if pred_intercept is None:\n",
    "        pred_intercept = 0\n",
    "    plt.figure(figsize=[10, 5])\n",
    "    plt.xlabel(\"x\")\n",
    "    plt.ylabel(\"y\")\n",
    "    plt.scatter(X_data, y_data, label=\"true\", s=12)\n",
    "    pred_y = pred_coef * X_data + pred_intercept\n",
    "    plt.plot(X_data, pred_y, label=\"pred\", color=\"darkorange\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_regressor_linear(\n",
    "    X_data=x, y_data=y, pred_coef=rgs.coef_, pred_intercept=rgs.intercept_\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Numpy实现Ridge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\hat{w}=\\arg \\min _{w} J(w)=\\left(X^{\\top} x+\\lambda I\\right)^{-1} x^{\\top} Y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyRidge(NumpyBaseLinearRegressor):\n",
    "    \"\"\"Ridge class with numpy. explicitly inherits from NumpyBaseLinearRegressor already.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train:feature data for training. A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "            data type must be continuous value type. \n",
    "        _y_train:label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        coef_: coef of linear regressor. A np.ndarray array of (n_features, ) shape.\n",
    "        intercept_: intercept of regressor. A np.ndarray integer.\n",
    "        alpha: the regularize rate. A positive float number, default = 1.0.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, fit_intercept=True, alpha=1.0, random_state=None):\n",
    "        \"\"\"ridge object init method.\n",
    "        \n",
    "        Args:\n",
    "            fit_intercept: Bool value. If use intercept in the ridge model.\n",
    "            alpha: the regularize rate. A positive float number, default = 1.0.\n",
    "        \n",
    "        Raises:\n",
    "            AssertionError: Alpha value must be a number.\n",
    "            ValueError: Alpha value must be greater than 0.\n",
    "        \"\"\"\n",
    "        super().__init__(fit_intercept=fit_intercept, random_state=random_state)\n",
    "        assert isinstance(alpha, int) or isinstance(alpha, float)\n",
    "        if 0 < alpha:\n",
    "            self.alpha = alpha\n",
    "        else:\n",
    "            raise ValueError(\"Alpha value must be greater than 0! \")\n",
    "\n",
    "    def _calculate_coef(self):\n",
    "        xtx = self._X_train.T @ self._X_train\n",
    "        self.coef_ = (\n",
    "            np.linalg.inv(xtx + self.alpha * np.identity(self._X_train.shape[1])) \\\n",
    "            @ self._X_train.T \\\n",
    "            @ self._y_train\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.5622924]), 1.1397567567796922)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyRidge(fit_intercept=True, alpha=0.5, random_state=12)\n",
    "rgs.fit(x, y)\n",
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_regressor_linear(\n",
    "    X_data=x, y_data=y, pred_coef=rgs.coef_, pred_intercept=rgs.intercept_\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Numpy实现SGD Regressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\frac{\\partial \\mathcal{L}}{\\partial w}= \\frac{2}{n} \\sum_{i=1}^{n}\\left(w x^{(i)}+b-y^{(i)}\\right) \\cdot x^{(i)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\frac{\\partial \\mathcal{L}}{\\partial b} =\\frac{2}{n} \\sum_{i=1}^{n}\\left(w x^{(i)}+b-y^{(i)}\\right)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 NumpySGDBaseEstimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpySGDBaseEstimator:\n",
    "    \"\"\"SGD Estimator Base class with numpy.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train:feature data for training. A np.ndarray matrix of (n_samples,\n",
    "            n_features) shape, data type must be continuous value type. \n",
    "        _y_train:label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        coef_: coef of linear regressor. A np.ndarray matrix of (n_features, ) shape.\n",
    "        intercept_: intercept of regressor. A np.ndarray integer if intercept_ is \n",
    "            not None else None.\n",
    "        alpha: the regularize rate. A float number and must be greater than 0, \n",
    "            default = 0.001.\n",
    "        save_param_list: if save param of the train process. A bool value, default = True.\n",
    "        coef_list: list of coef param from the train process,\n",
    "            every coef is a np.ndarray of (n_features, ) shape.\n",
    "        intercept_list: list of intercept param from the train process, \n",
    "            every intercept is a np.ndarray float number.\n",
    "        learning_rate: learning rate. A positive float number, default = 0.001.\n",
    "        epochs: epochs. A positive int number, default = 10.\n",
    "        batch_size: batch size. A positive int number, default = 32.\n",
    "        early_stopping: if early stopping when loss don't reduce again. A bool value,\n",
    "            default = True.\n",
    "        patient: Number of epochs that do not reduce loss continuously, \n",
    "            patient only takes effect when early_stopping is True. \n",
    "            A positive int number, default = 5.\n",
    "        toc: The threshold that symbolizes loss no longer decreases, \n",
    "            toc only takes effect when early_stopping is True. \n",
    "            A float number, default = 0.001\n",
    "        random_state: random seed. A positive int number if random_state \n",
    "            is not None else None, default = None.\n",
    "        regularize: regularize. A str value in {\"l1\", \"l2\"} if regularize \n",
    "            is not None else None, default = None.\n",
    "        best_loss: best loss of the train process. A np.ndarray float number.\n",
    "        best_coef: best coef of the train process. A np.ndarray array of \n",
    "            (n_features, 1) shape.\n",
    "        best_intercept_: best intercept of the train process. A np.ndarray number.\n",
    "        train_loss: list of train loss from the train process. \n",
    "            every loss is a np.ndarray float number.\n",
    "        valid_loss: list of valid loss from the train process.\n",
    "            every loss is a np.ndarray float number.\n",
    "        n_iter: the actual iteration of train process. A int number, initial = 0.\n",
    "        save_best_model: if save the best model params as the final model.\n",
    "                A bool value, defalut = True.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        loss=\"mse\",\n",
    "        alpha=0.0001,\n",
    "        fit_intercept=True,\n",
    "        save_param_list=True,\n",
    "        learning_rate=0.0001,\n",
    "        epochs=10,\n",
    "        batch_size=32,\n",
    "        print_step=1,\n",
    "        early_stopping=True,\n",
    "        patient=5,\n",
    "        toc=0.0001,\n",
    "        random_state=None,\n",
    "        regularize=None,\n",
    "        shuffle=True,\n",
    "        save_best_model=True\n",
    "    ):\n",
    "        \"\"\"NumpySGDBaseEstimator initial method.\n",
    "        \n",
    "        Args:\n",
    "            loss: A str in {\"mse\"}, default = \"mse\"\n",
    "            alpha: the regularize rate. A float number and must be greater\n",
    "                than 0, default = 0.001.\n",
    "            fit_intercept: if fit intercept. A bool value, default = True. \n",
    "            save_param_list: if save param of the train process. A bool value,\n",
    "                default = True.\n",
    "            learning_rate: learning rate. A positive float number, default = 0.001.\n",
    "            epochs: epochs. A positive int number, default = 10.\n",
    "            batch_size: batch size. A positive int number, default = 32.\n",
    "            early_stopping: if early stopping when loss don't reduce again. \n",
    "                A bool value, default = True\n",
    "            patient: Number of epochs that do not reduce loss continuously, \n",
    "                patient only takes effect when early_stopping is True. \n",
    "                A positive int number, default = 5.\n",
    "            toc: The threshold that symbolizes loss no longer decreases, \n",
    "                toc only takes effect when early_stopping is True. \n",
    "                A float number, default = 0.001\n",
    "            random_state: random seed. A positive int number if random_state \n",
    "                is not None else None, default = None.\n",
    "            regularize: regularize. A str value in {\"l2\"} if regularize \n",
    "                is not None else None, default = None.\n",
    "            shuffle: if shuffle the train data. A bool value, default = True.\n",
    "            save_best_model: if save the best model params as the final model.\n",
    "                A bool value, defalut = True.\n",
    "        \n",
    "        Raises:\n",
    "            AssertionError: Some parameters do not match.\n",
    "        \"\"\"\n",
    "        \n",
    "        (\n",
    "            loss,\n",
    "            alpha,\n",
    "            fit_intercept,\n",
    "            save_param_list,\n",
    "            learning_rate,\n",
    "            epochs,\n",
    "            batch_size,\n",
    "            print_step,\n",
    "            early_stopping,\n",
    "            patient,\n",
    "            toc,\n",
    "            random_state,\n",
    "            regularize,\n",
    "            shuffle,\n",
    "            save_best_model\n",
    "        ) = self._init_validation(\n",
    "            loss,\n",
    "            alpha,\n",
    "            fit_intercept,\n",
    "            save_param_list,\n",
    "            learning_rate,\n",
    "            epochs,\n",
    "            batch_size,\n",
    "            print_step,\n",
    "            early_stopping,\n",
    "            patient,\n",
    "            toc,\n",
    "            random_state,\n",
    "            regularize,\n",
    "            shuffle,\n",
    "            save_best_model\n",
    "        )\n",
    "        self.random_state = None\n",
    "        if random_state:\n",
    "            self.random_state = random_state\n",
    "            np.random.seed(self.random_state)\n",
    "        loss_func_dict = {\"mse\": self._mse}\n",
    "        loss_gradient_func_dict = {\"mse\": self._mse_gradient}\n",
    "        self._loss_func = loss_func_dict[loss]\n",
    "        self._gradient_func = loss_gradient_func_dict[loss]\n",
    "        self.alpha = alpha\n",
    "        self.intercept_ = None\n",
    "        if fit_intercept:\n",
    "            self.intercept_ = np.random.randn()\n",
    "        self.save_param_list = save_param_list\n",
    "        self.learning_rate = learning_rate\n",
    "        self.epochs = epochs\n",
    "        self.batch_size = batch_size\n",
    "        self._print_step = print_step\n",
    "        self.early_stopping = early_stopping\n",
    "        self.patient = patient\n",
    "        self.toc = toc\n",
    "        self.regularize = regularize\n",
    "        self.shuffle = shuffle\n",
    "        self.save_best_model = save_best_model\n",
    "        \n",
    "        self._X_train = None\n",
    "        self._y_train = None\n",
    "        self.n_iter_ = 0\n",
    "        self.coef_ = None\n",
    "        self.best_loss = float(\"inf\")\n",
    "        self.best_coef_ = None\n",
    "        self.best_intercept_ = None\n",
    "        self.best_epoch = 1\n",
    "        self.coef_list = []\n",
    "        self.intercept_list = []\n",
    "        self.valid_loss = []\n",
    "        self.train_loss = []\n",
    "\n",
    "    def fit(self, X_train, y_train, validation_data=None):\n",
    "        \"\"\"train model methed.\n",
    "        \n",
    "        Args:\n",
    "            X_train: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                data type must be continuous value type. \n",
    "            y_train: A np.ndarray array of (n_samples, ) shape, data type \n",
    "                must be continuous value type.\n",
    "            validation: the validation data for validate the model. A tuple\n",
    "                like (X_valid, y_valid) , the shape of X_valid and y_valid is \n",
    "                like X_train and y_train. Default = None.\n",
    "        \"\"\"\n",
    "        self._X_train, self._y_train = self._fit_validation(X_train, y_train)\n",
    "        X_valid, y_valid = self._validation_data_valid(validation_data)\n",
    "        if self.coef_ is None:\n",
    "            self.coef_ = np.random.randn(self._X_train.shape[1])\n",
    "        current_patient = 0\n",
    "        last_valid_loss = None\n",
    "        self.coef_list.append(copy.deepcopy(self.coef_))\n",
    "        self.intercept_list.append(self.intercept_)\n",
    "        for epoch in range(self.epochs):\n",
    "            # train model\n",
    "            self._fit_train()\n",
    "\n",
    "            # validate model\n",
    "            valid_mean_loss = self._fit_valid(X_valid, y_valid, epoch)\n",
    "\n",
    "            self.n_iter_ += 1\n",
    "\n",
    "            # early stopping\n",
    "            if self.early_stopping and epoch != 0:\n",
    "                if last_valid_loss - valid_mean_loss < self.toc:\n",
    "                    current_patient += 1\n",
    "                else:\n",
    "                    current_patient = 0\n",
    "                if current_patient >= self.patient:\n",
    "                    break\n",
    "            last_valid_loss = valid_mean_loss\n",
    "        if self.save_best_model:\n",
    "            self.coef_ = self.best_coef_\n",
    "            self.intercept_ = self.best_intercept_\n",
    "        self._final_print()\n",
    "        return self\n",
    "\n",
    "    def _final_print(self):\n",
    "        print(\n",
    "            f\"Actual iter epoch: {self.n_iter_}, best epoch: {self.best_epoch}, \"\n",
    "            f\"best loss: {self.best_loss}, best coef: {self.best_coef_}, \"\n",
    "            f\"best intercept: {self.best_intercept_}\"\n",
    "        )\n",
    "    \n",
    "    def _fit_train(self):\n",
    "        train_data = self._batch_generator(self._X_train, self._y_train, self.shuffle)\n",
    "        for X_batch, y_batch in train_data:\n",
    "            y_pred = self.predict(X_batch, _miss_valid=True)\n",
    "            coef_gradient, intercept_gradient = self._gradient_func(\n",
    "                y_batch, y_pred, X_batch\n",
    "            )\n",
    "            self.coef_ -= self.learning_rate * coef_gradient\n",
    "            if self.intercept_:\n",
    "                self.intercept_ -= self.learning_rate * intercept_gradient\n",
    "        train_loss_last_batch = self._loss_func(y_batch, y_pred)\n",
    "        self.train_loss.append(train_loss_last_batch)\n",
    "\n",
    "    def _fit_valid(self, X_valid, y_valid, epoch):\n",
    "        valid_data = self._batch_generator(X_valid, y_valid, self.shuffle)\n",
    "        valid_sum_loss = 0\n",
    "        for X_valid_batch, y_valid_batch in valid_data:\n",
    "            valid_batch_pred = self.predict(X_valid_batch)\n",
    "            loss = self._loss_func(y_valid_batch, valid_batch_pred)\n",
    "            valid_sum_loss += loss\n",
    "        valid_mean_loss = valid_sum_loss / (X_valid.shape[0] // self.batch_size)\n",
    "        if valid_mean_loss < self.best_loss:\n",
    "            self.best_loss = valid_mean_loss\n",
    "            self.best_coef_ = self.coef_\n",
    "            self.best_intercept_ = self.intercept_\n",
    "            self.best_epoch = epoch + 1\n",
    "        if self.save_param_list:\n",
    "            self.coef_list.append(copy.deepcopy(self.coef_))\n",
    "            self.intercept_list.append(self.intercept_)\n",
    "        if (epoch + 1) % self._print_step == 0:\n",
    "            print(f\"Epoch {epoch + 1}: valid_data loss: {valid_mean_loss}\")\n",
    "        self.valid_loss.append(valid_mean_loss)\n",
    "        return valid_mean_loss\n",
    "\n",
    "    def _validation_data_valid(self, validation_data):\n",
    "        if validation_data:\n",
    "            assert isinstance(validation_data, tuple) and len(validation_data) == 2\n",
    "            X_valid, y_valid = validation_data\n",
    "            X_valid, y_valid = self._fit_validation(X_valid, y_valid)\n",
    "        else:\n",
    "            X_train_len = int(self._X_train.shape[0] * 0.25)\n",
    "            X_valid = self._X_train[X_train_len:]\n",
    "            y_valid = self._y_train[X_train_len:]\n",
    "            self._X_train = self._X_train[:X_train_len]\n",
    "            self._y_train = self._y_train[:X_train_len]\n",
    "        return X_valid, y_valid\n",
    "\n",
    "    def _batch_generator(self, X_data, y_data, shuffle=True):\n",
    "        step = 0\n",
    "        steps_per_epoch = X_data.shape[0] // self.batch_size\n",
    "        while steps_per_epoch > step:\n",
    "            if shuffle:\n",
    "                index = np.random.choice(X_data.shape[0], self.batch_size)\n",
    "            else:\n",
    "                index = np.arange(self.batch_size * step, self.batch_size * (step + 1))\n",
    "            yield X_data[index], y_data[index]\n",
    "            step += 1\n",
    "            \n",
    "    def _regularize_gradient(self, coef_gradient):\n",
    "        if self.regularize is None:\n",
    "            return coef_gradient\n",
    "        elif self.regularize == \"l2\":\n",
    "            return coef_gradient + 2 * self.alpha * self.coef_\n",
    "\n",
    "    def _init_validation(\n",
    "        self,\n",
    "        loss,\n",
    "        alpha,\n",
    "        fit_intercept,\n",
    "        save_param_list,\n",
    "        learning_rate,\n",
    "        epochs,\n",
    "        batch_size,\n",
    "        print_step,\n",
    "        early_stopping,\n",
    "        patient,\n",
    "        toc,\n",
    "        random_state,\n",
    "        regularize,\n",
    "        shuffle,\n",
    "        save_best_model\n",
    "    ):\n",
    "        loss_key_set = {\"mse\", \"cross_entropy\"}\n",
    "        assert loss in loss_key_set\n",
    "        assert isinstance(alpha, (int, float))\n",
    "        assert 0 < alpha\n",
    "        assert isinstance(fit_intercept, bool)\n",
    "        assert isinstance(save_param_list, bool)\n",
    "        assert isinstance(learning_rate, (int, float))\n",
    "        assert 0 < learning_rate\n",
    "        assert isinstance(epochs, int) and epochs >= 1\n",
    "        assert isinstance(batch_size, int) and batch_size >= 1\n",
    "        assert isinstance(print_step, int) and print_step >= 1\n",
    "        assert isinstance(early_stopping, bool)\n",
    "        assert isinstance(patient, int) and patient >= 2\n",
    "        assert isinstance(toc, (int, float)) and toc > 0.0\n",
    "        assert (random_state is None) or isinstance(random_state, int)\n",
    "        regularize_key_set = {None, \"l2\"}\n",
    "        assert regularize in regularize_key_set\n",
    "        assert isinstance(shuffle, bool)\n",
    "        assert isinstance(save_best_model, bool)\n",
    "        return (\n",
    "            loss,\n",
    "            alpha,\n",
    "            fit_intercept,\n",
    "            save_param_list,\n",
    "            learning_rate,\n",
    "            epochs,\n",
    "            batch_size,\n",
    "            print_step,\n",
    "            early_stopping,\n",
    "            patient,\n",
    "            toc,\n",
    "            random_state,\n",
    "            regularize,\n",
    "            shuffle,\n",
    "            save_best_model\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 NumpySGDRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpySGDRegressor(NumpySGDBaseEstimator, NumpyBaseLinearRegressor):\n",
    "    \"\"\"SGD Regressor model with numpy, explicitly inherits \n",
    "        from NumpyBaseLinearRegression and NumpySGDBaseEstimator already.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train:feature data for training. A np.ndarray matrix of (n_samples,\n",
    "            n_features) shape, data type must be continuous value type. \n",
    "        _y_train:label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        coef_: coef of linear regressor. A np.ndarray matrix of (n_features, ) shape.\n",
    "        intercept_: intercept of regressor. A np.ndarray integer if intercept_ is \n",
    "            not None else None.\n",
    "        alpha: the regularize rate. A float number and must be greater than 0, \n",
    "            default = 0.001.\n",
    "        save_param_list: if save param of the train process. A bool value, default = True.\n",
    "        coef_list: list of coef param from the train process,\n",
    "            every coef is a np.ndarray of (n_features, ) shape.\n",
    "        intercept_list: list of intercept param from the train process, \n",
    "            every intercept is a np.ndarray float number.\n",
    "        learning_rate: learning rate. A positive float number, default = 0.001.\n",
    "        epochs: epochs. A positive int number, default = 10.\n",
    "        batch_size: batch size. A positive int number, default = 32.\n",
    "        early_stopping: if early stopping when loss don't reduce again. A bool value,\n",
    "            default = True.\n",
    "        patient: Number of epochs that do not reduce loss continuously, \n",
    "            patient only takes effect when early_stopping is True. \n",
    "            A positive int number, default = 5.\n",
    "        toc: The threshold that symbolizes loss no longer decreases, \n",
    "            toc only takes effect when early_stopping is True. \n",
    "            A float number, default = 0.001\n",
    "        random_state: random seed. A positive int number if random_state \n",
    "            is not None else None, default = None.\n",
    "        regularize: regularize. A str value in {\"l1\", \"l2\"} if regularize \n",
    "            is not None else None, default = None.\n",
    "        best_loss: best loss of the train process. A np.ndarray float number.\n",
    "        best_coef: best coef of the train process. A np.ndarray array of \n",
    "            (n_features, 1) shape.\n",
    "        best_intercept_: best intercept of the train process. A np.ndarray number.\n",
    "        train_loss: list of train loss from the train process. \n",
    "            every loss is a np.ndarray float number.\n",
    "        valid_loss: list of valid loss from the train process.\n",
    "            every loss is a np.ndarray float number.\n",
    "        n_iter: the actual iteration of train process. A int number, initial = 0.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        loss=\"mse\",\n",
    "        alpha=0.0001,\n",
    "        fit_intercept=True,\n",
    "        save_param_list=True,\n",
    "        learning_rate=0.0001,\n",
    "        epochs=10,\n",
    "        batch_size=32,\n",
    "        print_step=1,\n",
    "        early_stopping=True,\n",
    "        patient=5,\n",
    "        toc=0.0001,\n",
    "        random_state=None,\n",
    "        regularize=None,\n",
    "        shuffle=True\n",
    "    ):\n",
    "        \"\"\"NumpySGDRegressor initial method.\n",
    "        \n",
    "        Args:\n",
    "            loss: A str in {\"mse\"}, default = \"mse\"\n",
    "            alpha: the regularize rate. A float number and must be greater\n",
    "                than 0, default = 0.001.\n",
    "            fit_intercept: if fit intercept. A bool value, default = True. \n",
    "            save_param_list: if save param of the train process. A bool value,\n",
    "                default = True.\n",
    "            learning_rate: learning rate. A positive float number, default = 0.001.\n",
    "            epochs: epochs. A positive int number, default = 10.\n",
    "            batch_size: batch size. A positive int number, default = 32.\n",
    "            early_stopping: if early stopping when loss don't reduce again. \n",
    "                A bool value, default = True\n",
    "            patient: Number of epochs that do not reduce loss continuously, \n",
    "                patient only takes effect when early_stopping is True. \n",
    "                A positive int number, default = 5.\n",
    "            toc: The threshold that symbolizes loss no longer decreases, \n",
    "                toc only takes effect when early_stopping is True. \n",
    "                A float number, default = 0.001\n",
    "            random_state: random seed. A positive int number if random_state \n",
    "                is not None else None, default = None.\n",
    "            regularize: regularize. A str value in {\"l2\"} if regularize \n",
    "                is not None else None, default = None.\n",
    "            shuffle: if shuffle the train data. A bool value, default = True.\n",
    "            save_best_model: if save the best model params as the final model.\n",
    "                A bool value, defalut = True\n",
    "        \n",
    "        Raises:\n",
    "            AssertionError: Some parameters do not match.\n",
    "        \"\"\"\n",
    "        super().__init__(\n",
    "            loss=loss,\n",
    "            alpha=alpha,\n",
    "            fit_intercept=fit_intercept,\n",
    "            save_param_list=save_param_list,\n",
    "            learning_rate=learning_rate,\n",
    "            epochs=epochs,\n",
    "            batch_size=batch_size,\n",
    "            print_step=print_step,\n",
    "            early_stopping=early_stopping,\n",
    "            patient=patient,\n",
    "            toc=toc,\n",
    "            random_state=random_state,\n",
    "            regularize=regularize,\n",
    "            shuffle=shuffle\n",
    "        )\n",
    "\n",
    "    def _mse_gradient(self, y_true, y_pred, x):\n",
    "        difference_y = y_pred - y_true\n",
    "        intercept_gradient = None\n",
    "        if self.intercept_:\n",
    "            intercept_gradient = np.sum(difference_y) * 2 / self.batch_size\n",
    "        coef_gradient = (\n",
    "            np.sum(difference_y.reshape([-1, 1]) * x, axis=0) * 2 / self.batch_size\n",
    "        )\n",
    "        coef_gradient = self._regularize_gradient(coef_gradient)\n",
    "        return coef_gradient, intercept_gradient\n",
    "\n",
    "    def _mse(self, y, pred):\n",
    "        return np.sum(np.square(y - pred)) / y.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = load_linear_data(1000, w=-9.753, b=10.927)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "rgs = NumpySGDRegressor(\n",
    "    learning_rate=0.0001,\n",
    "    fit_intercept=True,\n",
    "    early_stopping=False,\n",
    "    epochs=10000,\n",
    "    print_step=1000,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1000: valid_data loss: 15.050865787807764\n",
      "Epoch 2000: valid_data loss: 8.517291952159212\n",
      "Epoch 3000: valid_data loss: 4.881540187056461\n",
      "Epoch 4000: valid_data loss: 2.6245360296196414\n",
      "Epoch 5000: valid_data loss: 1.5896360683947095\n",
      "Epoch 6000: valid_data loss: 1.3056168296976929\n",
      "Epoch 7000: valid_data loss: 1.11776256577783\n",
      "Epoch 8000: valid_data loss: 0.9089626870802631\n",
      "Epoch 9000: valid_data loss: 0.9065325141271627\n",
      "Epoch 10000: valid_data loss: 0.9743970635866697\n",
      "Actual iter epoch: 10000, best epoch: 9710, best loss: 0.7603488972220416, best coef: [-9.75995812], best intercept: 10.869592657702968\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.NumpySGDRegressor at 0x12333a278>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.fit(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 绘制训练过程参数变化图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_regressor_linear_sgd(X_data, y_data, coef_list, best_coef, intercept_list=None, best_intercept=None,\n",
    "                              pause_second=0.001, step=1, max_iter=50):\n",
    "    \"\"\"show the params' change of the train process.\n",
    "\n",
    "    Args:\n",
    "        X_data: A np.ndarray matrix of (point_count, 1) shape,\n",
    "            data type must be continuous value type.\n",
    "        y_data: A np.ndarray array of (point_count, ) shape.\n",
    "        coef_list: list with coef param( A np.ndarray array of (n_features, ) shape)\n",
    "            for every epochs.\n",
    "        best_coef: the best coef param. A np.ndarray array of (n_features, ) shape.\n",
    "        intercept_list: list with intercept param(A np.ndarray float number)\n",
    "            for every epochs. default = None.\n",
    "        best_intercept: the best intercept param. A np.ndarray float number.\n",
    "            default = None.\n",
    "        pause_second: pause second. A positive float number, default = 0.001.\n",
    "        step: epoch params update step.A positive int number.default = 1.\n",
    "        max_iter: max epoch iter. A positive int number. default = 50.\n",
    "    \"\"\"\n",
    "    from IPython import display\n",
    "\n",
    "    y_bottom = np.min(y_data) - 1\n",
    "    y_top = np.max(y_data) + 1\n",
    "    x_bottom = np.min(X_data) - 1\n",
    "    x_top = np.max(X_data) + 1\n",
    "\n",
    "    if not intercept_list or intercept_list == [None] * len(intercept_list):\n",
    "        intercept_list = [0] * len(coef_list)\n",
    "    if not best_intercept:\n",
    "        best_intercept = 0\n",
    "\n",
    "    max_iter = max_iter * step\n",
    "    if max_iter > len(coef_list):\n",
    "        max_iter = len(coef_list)\n",
    "\n",
    "    first_coef = None\n",
    "    first_intercept = None\n",
    "    for idx in range(0, max_iter, step):\n",
    "        plt.figure(figsize=[20, 10])\n",
    "        plt.ylim(y_bottom, y_top)\n",
    "        plt.xlim(x_bottom, x_top)\n",
    "        plt.xlabel(\"x\")\n",
    "        plt.ylabel(\"y\")\n",
    "        plt.scatter(X_data, y_data, label=\"true\", s=12)\n",
    "\n",
    "        if idx == 0:\n",
    "            first_coef = coef_list[idx]\n",
    "            first_intercept = intercept_list[idx]\n",
    "        else:\n",
    "            first_pred_y = first_coef * X_data + first_intercept\n",
    "            plt.plot(\n",
    "                X_data,\n",
    "                first_pred_y,\n",
    "                linewidth=1,\n",
    "                linestyle=\"-\",\n",
    "                label=\"first_pred\",\n",
    "                color=\"yellowgreen\",\n",
    "            )\n",
    "\n",
    "        if idx == (len(coef_list) - 1) or idx + step >= max_iter:\n",
    "            best_pred_y = best_coef * X_data + best_intercept\n",
    "            plt.plot(X_data, best_pred_y, label=\"best_pred\", color=\"firebrick\")\n",
    "\n",
    "        pred_y = coef_list[idx] * X_data + intercept_list[idx]\n",
    "        plt.plot(X_data, pred_y, label=\"pred\", color=\"darkorange\")\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "        plt.pause(pause_second)\n",
    "        display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-9.75995812]), 10.869592657702968)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-9.75995812]), 10.869592657702968)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.best_coef_, rgs.best_intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9710"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0.09607744]), array([-0.25766583])]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.coef_list[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_regressor_linear_sgd(\n",
    "    x,\n",
    "    y,\n",
    "    rgs.coef_list,\n",
    "    rgs.best_coef_,\n",
    "    rgs.intercept_list,\n",
    "    rgs.best_intercept_,\n",
    "    pause_second=0.001,\n",
    "    step=10,\n",
    "    max_iter=20\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1 深拷贝和浅拷贝"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可变类型和不可变类型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'b', 'c']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = ['a', 'b', 'c']\n",
    "ls[0] = 1\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-a3a6fd9b9bfc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstring\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"abc\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "string = \"abc\"\n",
    "string[0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-8373947047e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtup\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tup = (1, 2, 3,)\n",
    "tup[0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可变类型：list, dict, set  \n",
    "不可变类型：tuple, str, number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[[2], [2]]\n",
      "[[3], [3], [3]]\n",
      "[[4], [4], [4], [4]]\n",
      "[[5], [5], [5], [5], [5]]\n",
      "[[6], [6], [6], [6], [6], [6]]\n",
      "[[7], [7], [7], [7], [7], [7], [7]]\n",
      "[[8], [8], [8], [8], [8], [8], [8], [8]]\n",
      "[[9], [9], [9], [9], [9], [9], [9], [9], [9]]\n",
      "[[10], [10], [10], [10], [10], [10], [10], [10], [10], [10]]\n"
     ]
    }
   ],
   "source": [
    "a = [0]\n",
    "b = []\n",
    "for i in range(10):\n",
    "    a[0] += 1\n",
    "    b.append(a)\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[[1], [2]]\n",
      "[[1], [2], [3]]\n",
      "[[1], [2], [3], [4]]\n",
      "[[1], [2], [3], [4], [5]]\n",
      "[[1], [2], [3], [4], [5], [6]]\n",
      "[[1], [2], [3], [4], [5], [6], [7]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8], [9]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "a = [0]\n",
    "b = []\n",
    "for i in range(10):\n",
    "    a[0] += 1\n",
    "    b.append(copy.deepcopy(a))\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[[1], [2]]\n",
      "[[1], [2], [3]]\n",
      "[[1], [2], [3], [4]]\n",
      "[[1], [2], [3], [4], [5]]\n",
      "[[1], [2], [3], [4], [5], [6]]\n",
      "[[1], [2], [3], [4], [5], [6], [7]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8], [9]]\n",
      "[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "a = [0]\n",
    "b = []\n",
    "for i in range(10):\n",
    "    a[0] += 1\n",
    "    b.append(a[:])\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.2 波士顿房价"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_data, y_data = load_boston(return_X_y=True)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, random_state=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1000: valid_data loss: 36.98657526514078\n",
      "Actual iter epoch: 1614, best epoch: 1586, best loss: 17.056591788295442, best coef: [ -1.52813598   1.52584018   1.79505171   2.49387562  -3.80666039\n",
      "  17.22614771   5.43289587   0.33234538   0.87898424  -2.0866713\n",
      "  -4.64548923   4.14296111 -15.36128939], best intercept: 14.3372027976651\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.NumpySGDRegressor at 0x12623ab70>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "rgs = NumpySGDRegressor(\n",
    "    epochs=10000,\n",
    "    print_step=1000,\n",
    "    early_stopping=True,\n",
    "    toc=0.001,\n",
    "    patient=6,\n",
    "    learning_rate=0.008,\n",
    "    random_state=11384,\n",
    "    regularize='l2',\n",
    "    alpha=0.001\n",
    ")\n",
    "rgs.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.3 绘制训练过程损失变化图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_regressor_loss(train_loss, valid_loss, x_magnification=1, y_magnification=1):\n",
    "    \"\"\"show regressor loss of the train process.\n",
    "\n",
    "    Args:\n",
    "        train_loss: list of train loss. train loss's type is np.ndarray float number.\n",
    "        valid_loss: list of valid loss. valid loss's type is np.ndarray float number.\n",
    "        x_magnification: magnification for x axis, a positive number, default = 1.\n",
    "        y_magnification: magnification for y axis, a positive number, default = 1.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=[10 * x_magnification, 5 * y_magnification])\n",
    "    x = range(len(train_loss))\n",
    "    plt.xlabel(\"epochs\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.plot(x, train_loss, color=\"darkorange\", label=\"train_loss\")\n",
    "    plt.plot(x, valid_loss, label=\"valid_loss\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_regressor_loss(rgs.train_loss[:], rgs.valid_loss[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6209019823629415"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7487680397194808"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyLinearRegressor()\n",
    "rgs.fit(X_train, y_train)\n",
    "rgs.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Numpy实现多项式回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,1,2,3]\n",
    "a.pop(0)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1',\n",
       " 'x0',\n",
       " 'x1',\n",
       " 'x2',\n",
       " 'x3',\n",
       " 'x4',\n",
       " 'x5',\n",
       " 'x6',\n",
       " 'x7',\n",
       " 'x8',\n",
       " 'x9',\n",
       " 'x10',\n",
       " 'x11',\n",
       " 'x12',\n",
       " 'x0^2',\n",
       " 'x0 x1',\n",
       " 'x0 x2',\n",
       " 'x0 x3',\n",
       " 'x0 x4',\n",
       " 'x0 x5',\n",
       " 'x0 x6',\n",
       " 'x0 x7',\n",
       " 'x0 x8',\n",
       " 'x0 x9',\n",
       " 'x0 x10',\n",
       " 'x0 x11',\n",
       " 'x0 x12',\n",
       " 'x1^2',\n",
       " 'x1 x2',\n",
       " 'x1 x3',\n",
       " 'x1 x4',\n",
       " 'x1 x5',\n",
       " 'x1 x6',\n",
       " 'x1 x7',\n",
       " 'x1 x8',\n",
       " 'x1 x9',\n",
       " 'x1 x10',\n",
       " 'x1 x11',\n",
       " 'x1 x12',\n",
       " 'x2^2',\n",
       " 'x2 x3',\n",
       " 'x2 x4',\n",
       " 'x2 x5',\n",
       " 'x2 x6',\n",
       " 'x2 x7',\n",
       " 'x2 x8',\n",
       " 'x2 x9',\n",
       " 'x2 x10',\n",
       " 'x2 x11',\n",
       " 'x2 x12',\n",
       " 'x3^2',\n",
       " 'x3 x4',\n",
       " 'x3 x5',\n",
       " 'x3 x6',\n",
       " 'x3 x7',\n",
       " 'x3 x8',\n",
       " 'x3 x9',\n",
       " 'x3 x10',\n",
       " 'x3 x11',\n",
       " 'x3 x12',\n",
       " 'x4^2',\n",
       " 'x4 x5',\n",
       " 'x4 x6',\n",
       " 'x4 x7',\n",
       " 'x4 x8',\n",
       " 'x4 x9',\n",
       " 'x4 x10',\n",
       " 'x4 x11',\n",
       " 'x4 x12',\n",
       " 'x5^2',\n",
       " 'x5 x6',\n",
       " 'x5 x7',\n",
       " 'x5 x8',\n",
       " 'x5 x9',\n",
       " 'x5 x10',\n",
       " 'x5 x11',\n",
       " 'x5 x12',\n",
       " 'x6^2',\n",
       " 'x6 x7',\n",
       " 'x6 x8',\n",
       " 'x6 x9',\n",
       " 'x6 x10',\n",
       " 'x6 x11',\n",
       " 'x6 x12',\n",
       " 'x7^2',\n",
       " 'x7 x8',\n",
       " 'x7 x9',\n",
       " 'x7 x10',\n",
       " 'x7 x11',\n",
       " 'x7 x12',\n",
       " 'x8^2',\n",
       " 'x8 x9',\n",
       " 'x8 x10',\n",
       " 'x8 x11',\n",
       " 'x8 x12',\n",
       " 'x9^2',\n",
       " 'x9 x10',\n",
       " 'x9 x11',\n",
       " 'x9 x12',\n",
       " 'x10^2',\n",
       " 'x10 x11',\n",
       " 'x10 x12',\n",
       " 'x11^2',\n",
       " 'x11 x12',\n",
       " 'x12^2']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "poly = PolynomialFeatures(degree=2, interaction_only=False)\n",
    "poly.fit(X_train)\n",
    "poly.get_feature_names()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 NumpyPolynomialFeatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyPolynomialFeatures:\n",
    "    \"\"\"Polynomial Features transformor with Numpy.\n",
    "    \n",
    "    Attributes:\n",
    "        degree: degree of power. A positive int number and \n",
    "            must be greater than 1, default = 2.\n",
    "        interaction_only: if only transform to the interaction. \n",
    "            A bool value, default = False.\n",
    "        include_bias: if include bias(intercept). A bool value,\n",
    "            default = true.\n",
    "    \"\"\"\n",
    "    def __init__(self, degree=2, interaction_only=False, include_bias=True):\n",
    "        \"\"\"NumpyPolynomialFeatures initial method.\n",
    "        \n",
    "        Args:\n",
    "            degree: degree of power. A positive int number and \n",
    "                must be greater than 1, default = 2.\n",
    "            interaction_only: if only transform to the interaction. \n",
    "                A bool value, default = False.\n",
    "            include_bias: if include bias(intercept). A bool value,\n",
    "                default = true.\n",
    "        \"\"\"\n",
    "        self.degree, self.interaction_only, self.include_bias = self._init_validation(degree, interaction_only, include_bias)\n",
    "        self._feature_func_dict = {}\n",
    "        self._is_fitted = False\n",
    "    \n",
    "    def fit(self, X_train):\n",
    "        \"\"\"fit method.\n",
    "        \n",
    "        Args:\n",
    "            X_train: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                data type must be continuous value type. \n",
    "        Returns:\n",
    "            return self object.\n",
    "        \"\"\"\n",
    "        X_train = self._X_validation(X_train)\n",
    "        if self._is_fitted:\n",
    "            self.__init__(self.degree, self.interaction_only, self.include_bias)\n",
    "        for i in range(X_train.shape[1]):\n",
    "            self._feature_func_dict[(i, )] = lambda X: X[:, i].reshape([-1, 1])\n",
    "        last_end = 0\n",
    "        for loop in range(self.degree - 1):\n",
    "            for j in range(last_end, len(self._feature_func_dict)):\n",
    "                for k in range(0, X_train.shape[1]):\n",
    "                    key_list = [*self._feature_func_dict]\n",
    "                    if not (key_list[k][0] in key_list[j] and self.interaction_only):\n",
    "                        new_key = self._sorted_insert_tuple(key_list[k][0], key_list[j])\n",
    "                        if new_key not in self._feature_func_dict:\n",
    "                            self._feature_func_dict[new_key] = lambda X: reduce(lambda x, y: (X_train[:, x] if isinstance(x, int) else x) * X_train[:, y], new_key).reshape([-1, 1]) \n",
    "                last_end += 1\n",
    "        if self.include_bias:\n",
    "            self._feature_func_dict[\"bias\"] = lambda X: np.ones([X.shape[0], 1])\n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "        \n",
    "    def transform(self, X, _miss_valid=False):\n",
    "        \"\"\"transform the data.\n",
    "        \n",
    "        Args:\n",
    "            X: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                data type must be continuous value type. \n",
    "        Returns:\n",
    "            return a new X, a np.ndarray matrix of (n_samples, \n",
    "                new_n_features) shape.\n",
    "        \"\"\"\n",
    "        if not _miss_valid:\n",
    "            X = self._X_validation(X)\n",
    "        new_X = np.array([[] for _ in range(X.shape[0])])\n",
    "        for key in self._feature_func_dict:\n",
    "            new_X = np.c_[new_X, self._feature_func_dict[key](X)]\n",
    "        return new_X         \n",
    "    \n",
    "    def fit_transform(self, X_train):\n",
    "        \"\"\"fit transformer and transform data.\n",
    "        \n",
    "        Args:\n",
    "            X_train: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                data type must be continuous value type. \n",
    "        Returns:\n",
    "            return a new X, a np.ndarray matrix of (n_samples, \n",
    "                new_n_features) shape.\n",
    "        \"\"\"\n",
    "        self.fit(X_train)\n",
    "        return self.transform(X_train, _miss_valid=True)\n",
    "        \n",
    "    def get_feature_names(self):\n",
    "        \"\"\"get the new features' name\n",
    "        \n",
    "        Returns:\n",
    "            return a list with the tuples of old feature's num. \n",
    "                e.g: [(0,), (0, 0)], [(0,), (1,), (0, 0), (0, 1), (1, 1)].\n",
    "        \"\"\"\n",
    "        return [*self._feature_func_dict]\n",
    "    \n",
    "    def _init_validation(self, degree, interaction_only, include_bias):\n",
    "        assert isinstance(degree, int) and degree >= 1\n",
    "        assert isinstance(interaction_only, bool)\n",
    "        assert isinstance(include_bias, bool)\n",
    "        return degree, interaction_only, include_bias\n",
    "    \n",
    "    def _X_validation(self, X):\n",
    "        assert isinstance(X, Iterable)\n",
    "        if not isinstance(X, np.ndarray):\n",
    "            X = np.array(X)\n",
    "        assert X.ndim == 2\n",
    "        return X\n",
    "    \n",
    "    def _sorted_insert_tuple(self, item, tuple_):\n",
    "        idx = len(tuple_)\n",
    "        for i in range(len(tuple_)):\n",
    "            if tuple_[i] < item:\n",
    "                i += 1\n",
    "            else:\n",
    "                idx = i\n",
    "                break\n",
    "        tuple_ = tuple_[:idx] + (item,) + tuple_[idx:]\n",
    "        return tuple_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.1 reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "sum_ = lambda lst: reduce(lambda x, y: x + y, lst)\n",
    "sum_([1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 从公式加载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((500, 1), (500,))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def load_data_from_func(func=lambda X_data: 2.1084 * np.square(X_data) - 0.1932 * X_data + 10.813,\n",
    "                        x_min=0, x_max=10, n_samples=500, loc=0, scale=1, random_state=None):\n",
    "    \"\"\"load point data from a function\n",
    "\n",
    "    Args:\n",
    "        func: Function for creating data.A Function object, default = lambda X_data:\n",
    "            2.1084 *  np.square(X_data) - 0.1932 * X_data + 10.813.\n",
    "        x_min: min value of x. A number, x_min must be less ther x_max, default = 0.\n",
    "        x_max: max value of x. A number, x_max must be greater ther x_min, default = 0.\n",
    "        n_samples: sample count. A int number, default = 500.\n",
    "        loc: loc of noise's destribution. A float number, default = 0.\n",
    "        scale: scale of noise's destribution. A float number, default = 1.\n",
    "        random_state: random seed. A positive int number, default = None.\n",
    "    \n",
    "    Returns:\n",
    "        A tuple of x and y. x's shape is (n_samples, 1), y's shape is (n_samples, ).\n",
    "    \"\"\"\n",
    "    if random_state is not None and isinstance(random_state, int):\n",
    "        np.random.seed(random_state)\n",
    "    x = np.random.uniform(x_min, x_max, n_samples)\n",
    "    y = func(x)\n",
    "    noise = np.random.normal(loc=loc, scale=scale, size=n_samples)\n",
    "    y += noise\n",
    "    return x.reshape([-1, 1]), y\n",
    "x, y = load_data_from_func(x_max=100, scale=1)\n",
    "x.shape, y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_linear_point(X_data, y_data, s=12):\n",
    "    \"\"\"Plot linear point\n",
    "\n",
    "    Args:\n",
    "         X_data: X_data with (sample_count, 1) shape.\n",
    "         y_data: y_data with (sample_count, 1) shape.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=[10, 5])\n",
    "    plt.xlabel(\"x\")\n",
    "    plt.ylabel(\"y\")\n",
    "    plt.scatter(X_data, y_data, s=s)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_linear_point(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "np_poly = NumpyPolynomialFeatures(include_bias=False)\n",
    "x_poly_numpy = np_poly.fit_transform(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0,), (0, 0)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_poly.get_feature_names()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "poly = PolynomialFeatures(include_bias=False)\n",
    "x_poly = poly.fit_transform(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x0', 'x0^2']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.get_feature_names()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.49601864e+01, 2.02141837e+03],\n",
       "       [6.22596794e+01, 3.87626768e+03],\n",
       "       [3.04498278e+01, 9.27192015e+02],\n",
       "       [3.54289356e+01, 1.25520948e+03],\n",
       "       [6.56513314e+01, 4.31009732e+03],\n",
       "       [1.41186557e+01, 1.99336439e+02],\n",
       "       [5.03662236e+01, 2.53675648e+03],\n",
       "       [3.43300964e+01, 1.17855552e+03],\n",
       "       [7.52583689e+01, 5.66382210e+03],\n",
       "       [1.69168757e+01, 2.86180683e+02],\n",
       "       [9.28814316e+00, 8.62696033e+01],\n",
       "       [9.49787993e+01, 9.02097232e+03],\n",
       "       [9.31843900e+01, 8.68333054e+03],\n",
       "       [7.58852847e+01, 5.75857643e+03],\n",
       "       [2.59316245e+01, 6.72449151e+02],\n",
       "       [3.77060456e+01, 1.42174587e+03],\n",
       "       [6.28644172e+00, 3.95193496e+01],\n",
       "       [6.04959832e+00, 3.65976399e+01],\n",
       "       [1.22024755e+00, 1.48900409e+00],\n",
       "       [4.40397703e+01, 1.93950137e+03]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_poly_numpy[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.49601864e+01, 2.02141837e+03],\n",
       "       [6.22596794e+01, 3.87626768e+03],\n",
       "       [3.04498278e+01, 9.27192015e+02],\n",
       "       [3.54289356e+01, 1.25520948e+03],\n",
       "       [6.56513314e+01, 4.31009732e+03],\n",
       "       [1.41186557e+01, 1.99336439e+02],\n",
       "       [5.03662236e+01, 2.53675648e+03],\n",
       "       [3.43300964e+01, 1.17855552e+03],\n",
       "       [7.52583689e+01, 5.66382210e+03],\n",
       "       [1.69168757e+01, 2.86180683e+02],\n",
       "       [9.28814316e+00, 8.62696033e+01],\n",
       "       [9.49787993e+01, 9.02097232e+03],\n",
       "       [9.31843900e+01, 8.68333054e+03],\n",
       "       [7.58852847e+01, 5.75857643e+03],\n",
       "       [2.59316245e+01, 6.72449151e+02],\n",
       "       [3.77060456e+01, 1.42174587e+03],\n",
       "       [6.28644172e+00, 3.95193496e+01],\n",
       "       [6.04959832e+00, 3.65976399e+01],\n",
       "       [1.22024755e+00, 1.48900409e+00],\n",
       "       [4.40397703e+01, 1.93950137e+03]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_poly[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_poly == x_poly_numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-0.18914699,  2.10838344]), 10.778435171768251)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression, Ridge\n",
    "rgs = LinearRegression().fit(x_poly_numpy, y)\n",
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-0.18914699,  2.10838344]), 10.778435171720943)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyLinearRegressor().fit(x_poly_numpy, y)\n",
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-0.18914699,  2.10838344]), 10.778435171720943)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyLinearRegressor().fit(x_poly, y)\n",
    "rgs.coef_, rgs.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Numpy实现LWLR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\begin{align}\n",
    "w(i, i)=\\exp \\left(\\frac{||x^{(i)}-x||_{2} ^ 2}{-2 k^{2}}\\right)\n",
    "\\end{align}$\n",
    "\n",
    "$\n",
    "\\begin{align}\n",
    "J(a, b)= \\sum_{i=1}^{N} w_{i}\\left(y_{i}-a x_{i}-b\\right)^{2}\n",
    "\\end{align}\n",
    "$  \n",
    "\n",
    "$\\begin{align}\n",
    "\\hat{a}^*=\\left( X ^{ T } W X \\right)^{-1} X ^{ T } W y\n",
    "\\end{align}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 LWLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumpyLWLR(NumpyBaseLinearRegressor):\n",
    "    \"\"\"Locally Weighted Linear Regression model with Numpy, explicitly inherits \n",
    "        from NumpyBaseLinearRegressor already.\n",
    "    \n",
    "    Attributes:\n",
    "        _X_train: feature data for training. A np.ndarray matrix of (n_samples, n_features)\n",
    "            shape, data type must be continuous value type. \n",
    "        _y_train: label data for training. A np.ndarray array of (n_samples, ) shape, \n",
    "            data type must be continuous value.\n",
    "        k: the k of gaussian kernal. A float number not 0, default = 1.0\n",
    "    \"\"\"\n",
    "    def __init__(self, k=1.0, fit_intercept=True, random_state=None):\n",
    "        \"\"\"NumpyLWLR initial method\n",
    "        \n",
    "        Args:\n",
    "            k: the k of gaussian kernal. A float number, default = 1.0\n",
    "            fit_intercept: if fit intercept. A bool value, default = True.\n",
    "            random_state: random seed. A int number if random_state is \n",
    "                not None else None, default = None.\n",
    "        \"\"\"\n",
    "        super().__init__(fit_intercept=fit_intercept, random_state=random_state)\n",
    "        self.k = self._init_validation_self(k)\n",
    "    \n",
    "    def fit(self, X_train, y_train):\n",
    "        \"\"\"method for training model. \n",
    "        \n",
    "        Args:\n",
    "            X_train: A np.ndarray matrix of (n_samples, n_features) shape, data type \n",
    "                must be continuous value type. \n",
    "            y_train: A np.ndarray array of (n_samples, ) shape.\n",
    "            \n",
    "        Returns:\n",
    "            self object.\n",
    "        \"\"\"\n",
    "        self._X_train, self._y_train = self._fit_validation(X_train, y_train)\n",
    "        return self\n",
    "    \n",
    "    def predict(self, X_test, _miss_valid=False):\n",
    "        \"\"\"predict test data.\n",
    "        \n",
    "        Args:\n",
    "            X_test: A np.ndarray matrix of (n_samples, n_features) shape, \n",
    "                or a np.ndarray array of (n_features, ) shape.\n",
    "        \n",
    "        Returns:\n",
    "            result of predict. A np.ndarray array of (n_samples, ) shape,\n",
    "                or a float number.\n",
    "        \"\"\"\n",
    "        if not _miss_valid:\n",
    "            X_test = self._predict_validation(X_test)\n",
    "        if self.intercept_ is not None:\n",
    "            self._X_train = np.c_[self._X_train, np.ones(shape=(self._X_train.shape[0], 1), dtype=np.float32)]\n",
    "            X_test = np.c_[X_test, np.ones((X_test.shape[0], 1))]\n",
    "        if X_test.ndim == 1:\n",
    "            result = self._predict_one(X_test)\n",
    "            if self.intercept_ is not None:\n",
    "                self._X_train = np.delete(self._X_train, -1, axis=1)\n",
    "            return result\n",
    "        else:\n",
    "            results = []\n",
    "            for x_test in X_test:\n",
    "                results.append(self._predict_one(x_test))\n",
    "            if self.intercept_ is not None:\n",
    "                self._X_train = np.delete(self._X_train, -1, axis=1)\n",
    "            return np.array(results)\n",
    "    \n",
    "    def _predict_one(self, x_test):\n",
    "        w = self._calculate_weight(x_test)\n",
    "        xtx = self._X_train.T @ (w @ self._X_train)\n",
    "        try:\n",
    "            xtx_inv = np.linalg.inv(xtx)\n",
    "        except np.linalg.LinAlgError as ex:\n",
    "            raise ex\n",
    "        self.coef_ = xtx_inv @ self._X_train.T @ w @ self._y_train\n",
    "        return x_test @ self.coef_\n",
    "    \n",
    "    def _init_validation_self(self, k):\n",
    "        assert isinstance(k, (int, float))\n",
    "        return k\n",
    "    \n",
    "    def _calculate_weight(self, x_test):\n",
    "        w = np.eye(self._X_train.shape[0])\n",
    "        for i in range(self._X_train.shape[0]):\n",
    "            diff = self._X_train[i] - x_test\n",
    "            w[i, i] = np.exp(diff @ diff.T / (-2 * self.k ** 2))\n",
    "        return w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-57-51edcfc4170d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mage\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mB\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Alice'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m14\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-57-51edcfc4170d>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name, age)\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcall_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-57-51edcfc4170d>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mA\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcall_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-57-51edcfc4170d>\u001b[0m in \u001b[0;36mcall_name\u001b[0;34m(self, age)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcall_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mage\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Alice'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m14\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self, name):\n",
    "        self.call_name(name)\n",
    "    \n",
    "    def call_name(self, name):\n",
    "        print(name)\n",
    "        \n",
    "class B(A):\n",
    "    def __init__(self, name, age):\n",
    "        self.call_name(age)\n",
    "        super().__init__(name)\n",
    "        \n",
    "    def call_name(self, age):\n",
    "        print(age + 1)\n",
    "\n",
    "B('Alice', 14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = load_data_from_func(func=lambda x: 10 * np.sin(x) - 0.134 * x**2 + 4.0872 * x, scale=1, random_state=1091)\n",
    "X_train, X_test, y_train, y_test = train_test_split(x, y, random_state=1832)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9897665708601325"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgs = NumpyLWLR(k=0.1)\n",
    "rgs.fit(X_train, y_train)\n",
    "rgs.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 绘制回归曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_regression_line(X_data, y_data, y_pred):\n",
    "    \"\"\"show regression line no only linear regression.\n",
    "\n",
    "    Args:\n",
    "        X_data: A np.ndarray matrix of (point_count, 1) shape,\n",
    "            data type must be continuous value type.\n",
    "        y_data: A np.ndarray array of (point_count, ) shape.\n",
    "        y_pred: A np.ndarray array of (point_count, ) shape.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=[10, 5])\n",
    "    if X_data.ndim == 2:\n",
    "        X_data = X_data.reshape(-1)\n",
    "    plt.scatter(X_data, y_data)\n",
    "    idx = np.argsort(X_data)\n",
    "    X_data = X_data[idx]\n",
    "    y_pred = y_pred[idx]\n",
    "    plt.plot(X_data, y_pred, color=\"darkorange\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = rgs.predict(X_test)\n",
    "show_regression_line(X_test, y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. API  \n",
    "    > * 1.1 np.linalg.inv(a)  \n",
    "        >> * 求矩阵的逆矩阵  \n",
    "        >> * 如果矩阵是奇异矩阵不可逆  \n",
    "    > * 1.2 np.random.seed(seed)\n",
    "        >> * 设置随机数种子，保证多次执行代码，得到的随机结果一致\n",
    "    > * 1.3 np.random.randn(d0, d1, ... , dn)\n",
    "        >> * 用标准正态分布随机生成数据\n",
    "    > * 1.4 np.random.uniform(low=0.0, high=1.0, size=None)\n",
    "        >> * 均匀分布生成数据\n",
    "    > * 1.5 np.random.choice(a, size=None)\n",
    "        >> * 从a中随机选择size大小的数据\n",
    "    > * 1.6 np.c_[]\n",
    "        >> * 按列合并多个矩阵\n",
    "        >> * 是**方括号**，不是**圆括号**  \n",
    "    > * 1.7 np.delete(arr, obj, axis=None)\n",
    "        >> * 按axis删除数据\n",
    "    > * 1.8 np.identity(n)\n",
    "        >> * 生成单位矩阵(方阵)\n",
    "    > * 1.9 np.eye(N, M=None, k=0)  \n",
    "        >> * 生成对角矩阵  \n",
    "        >> * 不一定是方阵，默认M = N为方阵  \n",
    "        >> * k是对角线向右的偏移量\n",
    "\n",
    "2. 抽象类  \n",
    "    > * 2.1 NumpyBaseEstimator  \n",
    "        >> * 抽象出各种方法的参数验证方法，_fit_validation(X, y), _predict_validation(X_test), _score_validation(X_test, y_test)  \n",
    "    > * 2.2 NumpyRegressorMixin\n",
    "        >> * Regressor实现的score方法都一样，调用predict方法得到预测值，然后计算R^2指标  \n",
    "        >> * 可将score方法抽象成Regressor的Mixin类，每个Regressor继承该类即可继承score方法。  \n",
    "        >> * Mixin设计模式：只将方法抽象出来，Mixin类不可被实例化，且没有属性。  \n",
    "    > * 2.3 NumpyBaseLinearRegressor  \n",
    "        >> * LinearRegressor 和 Ridge只是计算coef_闭式解的公式不同  \n",
    "        >> * 抽象出NumpyBaseLinearRegressor类，LinearRegressor和Ridge只需单独修改计算coef闭式解的方法即可  \n",
    "    > * 2.4 NumpySGDBaseEstimator  \n",
    "        >> * SGD无论是分类还是回归，大部分代码都类似，抽象出NumpySGDBaseEstimator，减少写回归SGD时的代码量  \n",
    "\n",
    "3. SGD流程\n",
    "    >```python\n",
    "    \"\"\"\n",
    "    for epoch in arange(epoch):\n",
    "        for batch in batch_ganerator(X_train, y_train):\n",
    "            1. 计算预测值y_pred_batch\n",
    "            2. 计算loss\n",
    "            3. 计算导数\n",
    "            4. 计算累计平均损失，并输出\n",
    "            5. 更新参数\n",
    "        for batch in batch_ganerator(X_valid, y_valid, shuffle=False):\n",
    "            1. 计算valid累计平均损失\n",
    "        1. 输出valid的累计平均损失  \n",
    "        2. 保存最优参数  \n",
    "        3. 判断early stopping  \n",
    "    \"\"\"\n",
    "    > ```\n",
    "    \n",
    "4. Python指南\n",
    "    > * 4.1 深拷贝\n",
    "        >> import copy\n",
    "        >> copy.deepcopy(x)\n",
    "    > * 4.2 reduce\n",
    "        >> from functools import reduce\n",
    "        >> sum_ = lambda lst: reduce(lambda x, y: x + y, lst)\n",
    "    > * 4.3 继承\n",
    "        >> * 子类重写父类的某个方法，若父类的另一个方法也调用了他，调用的也会变成重写的方法。  \n",
    "        >> * 多继承中，先继承的类 方法优先。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作业"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 惯例，敲两遍以上  \n",
    "2. 熟悉各个API的输入输出  \n",
    "3. 查找Lasso的numpy实现  \n",
    "4. numpy实现StandardScaler  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 相关链接   \n",
    "\n",
    "<a href=\"./02.1.LinearRegression.ipynb\" style=\"\"> 2.1 线性回归、岭回归、Lasso、SGD、局部加权线性回归原理</a>    \n",
    "<a href=\"./02.2.LinearRegression-sklearn.ipynb\" style=\"\"> 2.2 sklearn中使用线性回归、岭回归、Lasso、SGD、多项式回归  </a>  \n",
    "   \n",
    "<a href=\"./02.4.LinearRegression-tf2.ipynb\"> 2.4 TensorFlow2实现线性回归、岭回归、SGD回归、LWLR </a>  \n",
    "<a href=\"./02.5.LinearRegression-torch1.ipynb\"> 2.5 PyTorch1实现线性回归、岭回归、SGD回归 、LWLR</a>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 项目源码  \n",
    "\n",
    "https://github.com/LossJ     \n",
    "进入后点击Statistic-Machine-Learning"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}