Python76-Pytorch教程 Tensor操作.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.00000e-04 *\n",
      "       [[ 0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  5.2658,  0.0000]])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "# exp1 :construct a 5x3 matrix, uninitialized:\n",
    "x=torch.empty(5,3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.1889,  0.7574,  0.5933],\n",
      "        [ 0.6637,  0.3017,  0.6300],\n",
      "        [ 0.5849,  0.9983,  0.2892],\n",
      "        [ 0.8989,  0.5606,  0.2526],\n",
      "        [ 0.4713,  0.3371,  0.0223]])\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# exp2:construct a randomly initialized matrix:\n",
    "x=torch.rand(5,3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0]])\n"
     ]
    }
   ],
   "source": [
    "# exp3:construct a matrix filled zeros and of dtype long\n",
    "x=torch.zeros(5,3,dtype=torch.long)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 5.5000,  3.0000])\n"
     ]
    }
   ],
   "source": [
    "# exp4:construct a tensor directly from data:\n",
    "x=torch.tensor([5.5,3])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.]], dtype=torch.float64)\n",
      "tensor([[ 0.1537,  0.1490,  0.7924],\n",
      "        [ 0.5670,  0.0083,  0.7103],\n",
      "        [ 0.6024,  0.6682,  0.4202],\n",
      "        [ 0.3626,  0.1101,  0.3646],\n",
      "        [ 0.5865,  0.7689,  0.1638]])\n"
     ]
    }
   ],
   "source": [
    "# exp5：or create a tensor based on an existing tensor.\n",
    "# These methods will reuse properties of the input tensor, e.g. dtype,\n",
    "# unless new values are provided by user\n",
    "x=x.new_ones(5,3,dtype=torch.double)    # new_* methods take in sizes\n",
    "print(x)\n",
    "\n",
    "x=torch.rand_like(x,dtype=torch.float)   # new_* methods take in sizes\n",
    "print(x)    # new_* methods take in sizes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([5, 3])\n"
     ]
    }
   ],
   "source": [
    "# get its size:\n",
    "print(x.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Addition: syntax 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2149,  0.3175,  1.2217],\n",
      "        [ 0.6788,  0.8254,  0.9440],\n",
      "        [ 1.0197,  1.0750,  1.3813],\n",
      "        [ 0.5985,  1.0242,  0.4603],\n",
      "        [ 1.4570,  1.6293,  0.3178]])\n"
     ]
    }
   ],
   "source": [
    "y=torch.rand(5,3)\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Addition: syntax 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2149,  0.3175,  1.2217],\n",
      "        [ 0.6788,  0.8254,  0.9440],\n",
      "        [ 1.0197,  1.0750,  1.3813],\n",
      "        [ 0.5985,  1.0242,  0.4603],\n",
      "        [ 1.4570,  1.6293,  0.3178]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.add(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Addition: providing an output tensor as argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2149,  0.3175,  1.2217],\n",
      "        [ 0.6788,  0.8254,  0.9440],\n",
      "        [ 1.0197,  1.0750,  1.3813],\n",
      "        [ 0.5985,  1.0242,  0.4603],\n",
      "        [ 1.4570,  1.6293,  0.3178]])\n"
     ]
    }
   ],
   "source": [
    "result=torch.empty(5,3)\n",
    "torch.add(x,y,out=result)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Addition: in-place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.2149,  0.3175,  1.2217],\n",
       "        [ 0.6788,  0.8254,  0.9440],\n",
       "        [ 1.0197,  1.0750,  1.3813],\n",
       "        [ 0.5985,  1.0242,  0.4603],\n",
       "        [ 1.4570,  1.6293,  0.3178]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add x to y\n",
    "y.add_(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.1537,  0.1490,  0.7924],\n",
       "        [ 0.5670,  0.0083,  0.7103],\n",
       "        [ 0.6024,  0.6682,  0.4202],\n",
       "        [ 0.3626,  0.1101,  0.3646],\n",
       "        [ 0.5865,  0.7689,  0.1638]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0.1490,  0.0083,  0.6682,  0.1101,  0.7689])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:,1] # 选取第二列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Resizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7407,  1.8183,  0.9411, -0.0961],\n",
       "        [-1.7284, -1.2689, -0.0478, -0.3334],\n",
       "        [ 0.3571,  0.1362, -1.3795,  1.3553],\n",
       "        [-0.7430,  0.4966,  0.5907,  1.0943]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=torch.randn(4,4)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-2.3152, -1.0368, -0.0738,  0.9901, -0.4519, -0.1859,  1.2947,\n",
       "        -1.2782,  0.2498, -2.3731, -0.3418, -0.3598,  2.2147, -0.7491,\n",
       "         1.0235, -0.5832])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=x.view(16)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7407,  1.8183,  0.9411, -0.0961, -1.7284, -1.2689, -0.0478,\n",
       "         -0.3334],\n",
       "        [ 0.3571,  0.1362, -1.3795,  1.3553, -0.7430,  0.4966,  0.5907,\n",
       "          1.0943]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=x.view(-1,8) # the size -1 is inferred from other dimensions\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7407,  1.8183],\n",
       "        [ 0.9411, -0.0961],\n",
       "        [-1.7284, -1.2689],\n",
       "        [-0.0478, -0.3334],\n",
       "        [ 0.3571,  0.1362],\n",
       "        [-1.3795,  1.3553],\n",
       "        [-0.7430,  0.4966],\n",
       "        [ 0.5907,  1.0943]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=x.view(8,-1) # the size -1 is inferred from other dimensions\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.3050])\n",
      "-0.30500277876853943\n"
     ]
    }
   ],
   "source": [
    "# If you have a one element tensor, use .item() to get the value as a Python number\n",
    "x=torch.randn(1)\n",
    "print(x)\n",
    "print(x.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 NumPy Bridge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Converting a Torch Tensor to a NumPy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1.,  1.,  1.,  1.,  1.])\n"
     ]
    }
   ],
   "source": [
    "a=torch.ones(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "b=a.numpy()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 2.,  2.,  2.,  2.,  2.])\n",
      "[2. 2. 2. 2. 2.]\n"
     ]
    }
   ],
   "source": [
    "# See how the numpy array changed in value.\n",
    "a.add_(1)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 2. 2. 2. 2.]\n",
      "tensor([ 2.,  2.,  2.,  2.,  2.], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "## 3.2 Converting NumPy Array to Torch Tensor\n",
    "import numpy as np\n",
    "a=np.ones(5)\n",
    "b=torch.from_numpy(a)\n",
    "np.add(a,1,out=a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}