pytorch_内置实现线性回归.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input\n",
    "inputs = np.array([[73,67,43],\n",
    "                  [91,88,64],\n",
    "                  [87,134,58],\n",
    "                  [102,43,37],\n",
    "                  [69,96,70]],dtype='float32')\n",
    "# Targets\n",
    "targets = np.array([[56,70],\n",
    "                   [81,101],\n",
    "                   [119,133],\n",
    "                   [22,37],\n",
    "                   [103,119]],dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = torch.from_numpy(inputs)\n",
    "targets = torch.from_numpy(targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建一个tensorDataset和一个DataLoader\n",
    "from torch.utils.data import TensorDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 73.,  67.,  43.],\n",
       "         [ 91.,  88.,  64.],\n",
       "         [ 87., 134.,  58.]]), tensor([[ 56.,  70.],\n",
       "         [ 81., 101.],\n",
       "         [119., 133.]]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_ds = TensorDataset(inputs,targets)\n",
    "train_ds[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义数据加载器\n",
    "batch_size = 5\n",
    "train_dl = DataLoader(train_ds,batch_size,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 73.,  67.,  43.],\n",
      "        [102.,  43.,  37.],\n",
      "        [ 69.,  96.,  70.],\n",
      "        [ 87., 134.,  58.],\n",
      "        [ 91.,  88.,  64.]])\n",
      "tensor([[ 56.,  70.],\n",
      "        [ 22.,  37.],\n",
      "        [103., 119.],\n",
      "        [119., 133.],\n",
      "        [ 81., 101.]])\n"
     ]
    }
   ],
   "source": [
    "for xb,yb in train_dl:\n",
    "    print(xb)\n",
    "    print(yb)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[-0.5400, -0.5225, -0.4104],\n",
      "        [ 0.2868, -0.3981, -0.0993]], requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([-0.0196,  0.0652], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "# 用nn.Linear自动初始化\n",
    "#定义模型\n",
    "model = nn.Linear(3,2)\n",
    "print(model.weight)\n",
    "print(model.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([[-0.5400, -0.5225, -0.4104],\n",
       "         [ 0.2868, -0.3981, -0.0993]], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([-0.0196,  0.0652], requires_grad=True)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(26107.8652, grad_fn=<MseLossBackward>)\n"
     ]
    }
   ],
   "source": [
    "# 内置损失函数mse_loss\n",
    "import torch.nn.functional as F\n",
    "loss_fn = F.mse_loss\n",
    "loss = loss_fn(model(inputs),targets)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义优化器\n",
    "opt = torch.optim.SGD(model.parameters(),lr=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(num_epochs,model,loss_fn,opt):\n",
    "    for epoch in range(num_epochs):\n",
    "        for xb,yb in train_dl:\n",
    "            preds = model(xb)\n",
    "            loss = loss_fn(preds,yb)\n",
    "            loss.backward()\n",
    "            # 用梯度更新参数\n",
    "            opt.step()\n",
    "            # 重置参数为0\n",
    "            opt.zero_grad()\n",
    "        if (epoch + 1) % 10 == 0:\n",
    "            print('Epoch[{}/{}],Loss:{:.4f}'.format(epoch + 1,num_epochs,loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[10/100],Loss:1447.9030\n",
      "Epoch[20/100],Loss:653.4196\n",
      "Epoch[30/100],Loss:566.2062\n",
      "Epoch[40/100],Loss:501.1792\n",
      "Epoch[50/100],Loss:444.0906\n",
      "Epoch[60/100],Loss:393.7699\n",
      "Epoch[70/100],Loss:349.4059\n",
      "Epoch[80/100],Loss:310.2888\n",
      "Epoch[90/100],Loss:275.7930\n",
      "Epoch[100/100],Loss:245.3682\n"
     ]
    }
   ],
   "source": [
    "fit(100,model,loss_fn,opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:root] *",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}