3.4分钟入门torch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 3]) \n",
      " tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.]])\n"
     ]
    }
   ],
   "source": [
    "# Tensors\n",
    "x = torch.FloatTensor([[1,2,3],[4,5,6]])\n",
    "print(x.size(),'\\n',x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[3., 4., 5.],\n",
       "        [6., 7., 8.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add tensors\n",
    "x.add_(torch.ones([2,3]) + torch.ones([2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2., 3.],\n",
       "        [4., 5., 6.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 此时x已经改变\n",
    "# Subtract Tensor\n",
    "x.sub_(torch.ones([2,3]) * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2, 3],\n",
       "        [4, 5, 6]], dtype=torch.int16)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pytorch和Numpy转换\n",
    "import numpy as np\n",
    "y = np.matrix([[2,2],[2,2],[2,2]])\n",
    "z = np.matrix([[2,2],[2,2],[2,2]],dtype='int16')\n",
    "x.short()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2, 2],\n",
       "        [2, 2],\n",
       "        [2, 2]], dtype=torch.int16)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.from_numpy(z)\n",
    "# 将tensor张量转换为numpy矩阵 tensor.numpy()\n",
    "# 将numpy转换为Variable sub_va = Variable(torch.from_numpy(sub_img))\n",
    "# 将Variable张量转化为numpy sub_np2 = sub_va.data.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2., 3., 4., 5., 6.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape tensors(similar to np.reshape)\n",
    "x.view(1,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[3., 4., 5.],\n",
      "        [6., 7., 8.]], device='cuda:0')\n",
      "tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.]])\n"
     ]
    }
   ],
   "source": [
    "# CPU和GPUs\n",
    "x = torch.FloatTensor([[1,2,3],[4,5,6]])\n",
    "y = np.matrix([[2,2,2],[2,2,2]],dtype='float32')\n",
    "if (torch.cuda.is_available()):\n",
    "    x = x.cuda()\n",
    "    y = torch.from_numpy(y).cuda()\n",
    "    z = x + y\n",
    "print(z)\n",
    "print(x.cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4., 10., 18.], dtype=float32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pytorch Variables\n",
    "from torch.autograd import Variable\n",
    "v1 = Variable(torch.tensor([1.,2.,3.]),requires_grad = False)\n",
    "v2 = Variable(torch.tensor([4.,5.,6.]),requires_grad = True)\n",
    "v3 = v1 * v2\n",
    "v3.data.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MulBackward0 at 0x23c1e98c908>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Variables remember what created them\n",
    "v3.grad_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d(sin(x) / d(x) = cons(x))\n"
     ]
    }
   ],
   "source": [
    "# 反向传播\n",
    "# Backpropagation with example of sin(x)\n",
    "x = Variable(torch.Tensor(np.array([0.,1.,1.5,2.]) * np.pi),requires_grad = True)\n",
    "y = torch.sin(x)\n",
    "x.grad\n",
    "y.backward(torch.Tensor([1.,1.,1.,1]))\n",
    "# check gradient in indeed cos(x)\n",
    "if ((x.grad.data.int().numpy() == torch.cos(x).data.int().numpy()).all()):\n",
    "    print ('d(sin(x) / d(x) = cons(x))')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple Liner Regression\n",
    "#         Fit a line to the data. Y = w.x + b\n",
    "\n",
    "# Deterministic behavior\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "\n",
    "\n",
    "# Step 1: Dataset\n",
    "\n",
    "w = 2; b = 3\n",
    "x = np.linspace(0, 10, 100)\n",
    "y = w*x + b + np.random.randn(100)*2\n",
    "x = x.reshape(-1, 1)\n",
    "y = y.reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 2: Model\n",
    "\n",
    "class LinearRegressionModel(torch.nn.Module):\n",
    "    def __init__(self,in_dimn,out_dimn):\n",
    "        super(LinearRegressionModel,self).__init__()\n",
    "        self.model = torch.nn.Linear(in_dimn,out_dimn)\n",
    "    def forward(self,x):\n",
    "        y_pred = self.model(x)\n",
    "        return y_pred\n",
    "model = LinearRegressionModel(in_dimn=1,out_dimn=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 10,loss 33.951412200927734\n",
      "epoch 20,loss 8.786260604858398\n",
      "epoch 30,loss 17.577659606933594\n",
      "epoch 40,loss 11.382862091064453\n",
      "epoch 50,loss 5.572602272033691\n",
      "epoch 60,loss 4.080413818359375\n",
      "epoch 70,loss 4.094191074371338\n",
      "epoch 80,loss 4.1218461990356445\n",
      "epoch 90,loss 4.069921493530273\n",
      "epoch 100,loss 4.03877067565918\n"
     ]
    }
   ],
   "source": [
    "# Step 3: Training\n",
    "cost = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(),lr=0.01,momentum=0.9)\n",
    "inputs = Variable(torch.from_numpy(x.astype('float32')))\n",
    "outputs = Variable(torch.from_numpy(y.astype('float32')))\n",
    "for epoch in range(100):\n",
    "    # forward pass\n",
    "    y_pred = model(inputs)\n",
    "    # compute loss\n",
    "    loss = cost(y_pred,outputs)\n",
    "    # backward pass \n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    if ((epoch + 1) % 10 == 0):\n",
    "        print('epoch {},loss {}'.format(epoch + 1,loss.data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Step 4: Display model and confirm\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(4,4))\n",
    "plt.title('Model and Dataset')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid()\n",
    "plt.plot(x, y, 'ro', label='Dataset', marker='x', markersize=4)\n",
    "plt.plot(x, model.model.weight.item()*x+model.model.bias.item(), label='Regression Model')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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": 4
}