linearRegression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "linearRegression.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNPTwe72jRueEMssXyeohmK",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/benject/deep_learning/blob/main/linearRegression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aLlrCQ0WjOMN"
      },
      "outputs": [],
      "source": [
        "#Linear Regression"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "Dzk-MQsfjRmk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def mse(m,predict,real):\n",
        "\n",
        "  result =  np.sum((predict - real)**2) / (2 * m)\n",
        "  return result\n"
      ],
      "metadata": {
        "id": "kim71XXHjteP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MyLinearRegression():\n",
        "\n",
        "  def __init__(self,w,b):\n",
        "\n",
        "    self.w = w\n",
        "    self.b = b\n",
        "    self.lr = 1\n",
        "    self.lr_w = 0\n",
        "    self.lr_b = 0\n",
        "    pass\n",
        "\n",
        "  def forward(self,X): \n",
        "    \"\"\"\n",
        "    n, 参数个数\n",
        "    m, 数据个数\n",
        "    \n",
        "    w : n 行 1 列\n",
        "    X ： n 行 m 列\n",
        "   \n",
        "    \"\"\"\n",
        "\n",
        "    return np.dot(self.w.T, X) + self.b\n",
        "\n",
        "  def backward(self,m,predict,real,X):\n",
        "\n",
        "    grad_w = 1/m* np.dot(X,(predict-real).T) # 损失函数对w的求偏导\n",
        "    grad_b = 1/m* np.sum(predict - real) #损失函数对b的求偏导\n",
        "    return grad_w,grad_b\n",
        "  \n",
        "  def optimization(self,dw,db):\n",
        "\n",
        "    self.lr_w = self.lr_w + np.power(dw,2) ##ada grad；自适应的学习率 可以极大提高学习效率\n",
        "    new_w = self.w - self.lr / np.sqrt(self.lr_w) * dw ##ada grad； 自适应的学习率 可以极大提高学习效率\n",
        "    #new_w = self.w - self.learning_rate * dw\n",
        "\n",
        "    self.lr_b = self.lr_b + db**2 ##ada grad；自适应的学习率 可以极大提高学习效率 \n",
        "    new_b = self.b - self.lr / np.sqrt(self.lr_b) * db ##ada grad；自适应的学习率 可以极大提高学习效率\n",
        "    #new_b = self.b - self.learning_rate * db\n",
        "    return new_w,new_b\n",
        "\n",
        "  def update(self,new_w,new_b):\n",
        "\n",
        "    self.w = new_w\n",
        "    self.b = new_b\n",
        "\n"
      ],
      "metadata": {
        "id": "02JiR7hBjUeo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "X0 = np.linspace(0,100,50)\n",
        "\n",
        "X1 = X0.reshape(1,50) \n",
        "Y = X1 * 2 + 103.556 + np.random.randn(1,50)*30\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.scatter(X1,Y)\n",
        "\n",
        "\n",
        "print(X1.shape)\n",
        "print(Y.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "zt_NxRvV0Xnt",
        "outputId": "bd3874cd-447d-4e12-ddc1-fe9d039f37dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 50)\n",
            "(1, 50)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "w = np.ones((1,1)) #只有1个特征值\n",
        "b = 0.\n",
        "\n",
        "linR = MyLinearRegression(w,b)\n",
        "\n",
        "for i in range(30000):\n",
        "\n",
        "  A = linR.forward(X1)\n",
        "  grad_w,grad_b = linR.backward(50,A,Y,X1)\n",
        "  new_w,new_b = linR.optimization(grad_w,grad_b)\n",
        "  linR.update(new_w,new_b)\n",
        "\n",
        "print(linR.w)\n",
        "print(linR.b)\n",
        "\n",
        "x = np.linspace(0, 100, 50)\n",
        "\n",
        "y1 = linR.w[0,0] * x + linR.b\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "plt.scatter(X1,Y)\n",
        "\n",
        "plt.plot(x, y1,color ='red')\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "id": "Ds_v6hIK2F9J",
        "outputId": "2e266b04-b251-4f67-a71b-11db14d57436"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1.92220312]]\n",
            "113.48623829492843\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "接下来使用pytorch实现"
      ],
      "metadata": {
        "id": "HB7bociezfqi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "class torchLR(torch.nn.Module): #继承Module类\n",
        "\n",
        "  def __init__(self):\n",
        "\n",
        "    super().__init__()\n",
        "\n",
        "    self.linear = torch.nn.Linear(1,1)  #一个线性层 代表为 y=xW.T + b 。 在这里 w是参数矩阵 维度为（1，n） ；x是数据 维度为（m，n） b是偏置项\n",
        "    self.crit = torch.nn.MSELoss() #损失函数\n",
        "    self.optim = torch.optim.Adam(self.parameters(),lr=1.) #优化器 \n",
        "\n",
        "  \n",
        "  def forward(self,x):\n",
        "    result = self.linear(x) #线性回归 直接用 y = xW.T + b 来做激活函数。\n",
        "    return result\n",
        "\n",
        "\n",
        "torLR = torchLR()\n",
        "\n",
        "X3 = X1.T\n",
        "\n",
        "x1 = torch.from_numpy(X3) #如果是从numpy 的ndarray 数据。一定要用torch.from_numpy做转换 \n",
        "y = torch.from_numpy(Y.T) #如果是从numpy 的ndarray 数据。一定要用torch.from_numpy做转换 \n",
        "\n",
        "#训练30000次\n",
        "for i in range(30000):\n",
        "\n",
        "  A = torLR.forward(x1.float()) \n",
        "  loss = torLR.crit(A.float(),y.float())\n",
        "  torLR.optim.zero_grad()\n",
        "  loss.backward()\n",
        "  torLR.optim.step()\n",
        "\n",
        "#打印参数值\n",
        "for name, param in torLR.named_parameters():\n",
        "    if param.requires_grad:\n",
        "        print( name, param.data)\n",
        "  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UsUQqn_gwcZo",
        "outputId": "c4e5f4bf-91c3-44d8-ade6-1581841df3c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "linear.weight tensor([[1.9215]])\n",
            "linear.bias tensor([113.5261])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n"
      ],
      "metadata": {
        "id": "qv-9pvflxCi8"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}