lesson 7 创建tensor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.  3.3] \n",
      " tensor([2.0000, 3.3000], dtype=torch.float64) \n",
      "\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]] \n",
      " tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.]], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "#将numpy数据转到tensor中\n",
    "import torch\n",
    "import numpy as np\n",
    "a=np.array([2,3.3])\n",
    "b=torch.from_numpy(a)\n",
    "print(a,\"\\n\",b,\"\\n\")\n",
    "\n",
    "c=np.ones([2,3])\n",
    "d=torch.from_numpy(c)\n",
    "print(c,\"\\n\",d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2.0000, 3.2000])\n",
      "tensor([2.0000, 3.2000])\n",
      "tensor([[0.0000e+00, 0.0000e+00, 1.8754e+28],\n",
      "        [1.6244e-07, 1.0256e-08, 1.2972e-11]])\n",
      "tensor([[2.0000, 3.2000],\n",
      "        [1.8000, 2.9000]])\n"
     ]
    }
   ],
   "source": [
    "#tensor 与Tensor \n",
    "import torch\n",
    "a=torch.tensor([2,3.2])\n",
    "print(a)\n",
    "\n",
    "b=torch.FloatTensor([2,3.2])\n",
    "print(b)\n",
    "\n",
    "c=torch.FloatTensor(2,3)#生成两行三列的tensor\n",
    "print(c)\n",
    "\n",
    "d=torch.tensor([[2.0,3.2],\n",
    "                 [1.8,2.9]])\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([nan]) \n",
      " tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.]])\n",
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.]])\n",
      "tensor([[         0,          0, 1852990827],\n",
      "        [ 875457637,  842019889,  761541986]], dtype=torch.int32)\n",
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.],\n",
      "        [0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "#利用Tensor生成未初始化的数据\n",
    "import torch\n",
    "a=torch.empty(1)\n",
    "b=torch.empty(2,3)\n",
    "print(a,\"\\n\",b)\n",
    "\n",
    "c=torch.Tensor(2,3)\n",
    "d=torch.IntTensor(2,3)\n",
    "e=torch.FloatTensor(3,3)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.FloatTensor\n",
      "torch.DoubleTensor\n"
     ]
    }
   ],
   "source": [
    "#调整数据类型的默认设置\n",
    "import torch\n",
    "a=torch.tensor([1.2,2,3]).type()\n",
    "print(a)\n",
    "torch.set_default_tensor_type(torch.DoubleTensor)\n",
    "b=torch.tensor([1.2,2,3]).type()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.6076, 0.2094, 0.5947],\n",
      "        [0.4974, 0.5528, 0.1686],\n",
      "        [0.9392, 0.6372, 0.6871]])\n",
      "tensor([[0.1318, 0.4471, 0.7802],\n",
      "        [0.7070, 0.5640, 0.9221],\n",
      "        [0.9406, 0.9927, 0.0893]])\n",
      "tensor([[3, 8, 3],\n",
      "        [5, 8, 2],\n",
      "        [8, 7, 4]])\n"
     ]
    }
   ],
   "source": [
    "#rand rand_like randint 应用\n",
    "import torch\n",
    "a=torch.rand(3,3)\n",
    "print(a)\n",
    "b=torch.rand_like(a)\n",
    "print(b)\n",
    "c=torch.randint(1,10,[3,3]) #【1,10） 3*3的tensor\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[8, 8, 8],\n",
      "        [8, 8, 8]])\n",
      "torch.LongTensor\n",
      "tensor([7])\n"
     ]
    }
   ],
   "source": [
    "#full\n",
    "import torch\n",
    "a=torch.full([2,3],8)\n",
    "print(a)\n",
    "\n",
    "b=torch.full([],7)\n",
    "c=torch.full([1],7)\n",
    "\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
      "tensor([0, 2, 4, 6, 8])\n"
     ]
    }
   ],
   "source": [
    "#arange\n",
    "import torch\n",
    "print(torch.arange(0,10)) #[0,10) 默认以1递增\n",
    "print(torch.arange(0,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])\n",
      "tensor([ 0.0000,  1.1111,  2.2222,  3.3333,  4.4444,  5.5556,  6.6667,  7.7778,\n",
      "         8.8889, 10.0000])\n",
      "tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])\n",
      "tensor([1.0000, 0.7743, 0.5995, 0.4642, 0.3594, 0.2783, 0.2154, 0.1668, 0.1292,\n",
      "        0.1000])\n",
      "tensor([ 1.0000,  1.2915,  1.6681,  2.1544,  2.7826,  3.5938,  4.6416,  5.9948,\n",
      "         7.7426, 10.0000])\n"
     ]
    }
   ],
   "source": [
    "#linspace\n",
    "import torch\n",
    "print(torch.linspace(0,10,steps=5)) #（末-初）/（step-1）\n",
    "print(torch.linspace(0,10,steps=10)) #（末-初）/（step-1）\n",
    "print(torch.linspace(0,10,steps=11)) #（末-初）/（step-1）\n",
    "#logspace\n",
    "\n",
    "print(torch.logspace(0,-1,steps=10))\n",
    "\n",
    "print(torch.logspace(0,1,steps=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.],\n",
      "        [1., 1., 1.]])\n",
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.],\n",
      "        [0., 0., 0.]])\n",
      "tensor([[1., 0., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 0., 1.]])\n",
      "tensor([[1., 0., 0., 0.],\n",
      "        [0., 1., 0., 0.],\n",
      "        [0., 0., 1., 0.]])\n",
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.],\n",
      "        [1., 1., 1.]])\n"
     ]
    }
   ],
   "source": [
    "#ones zeros eye\n",
    "import torch\n",
    "print(torch.ones(3,3))\n",
    "a=torch.zeros(3,3)\n",
    "print(a)\n",
    "print(torch.eye(3,3))\n",
    "print(torch.eye(3,4))\n",
    "\n",
    "#like\n",
    "\n",
    "print(torch.ones_like(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([4, 9, 5, 3, 1, 2, 6, 8, 0, 7])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#randperm\n",
    "import torch\n",
    "torch.randperm(10)#0-9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.2352, 0.4276, 0.6322],\n",
      "        [0.3318, 0.7633, 0.5072]])\n",
      "tensor([[0.1767, 0.7503],\n",
      "        [0.8307, 0.9706]])\n",
      "tensor([1, 0])\n",
      "tensor([[0.3318, 0.7633, 0.5072],\n",
      "        [0.2352, 0.4276, 0.6322]])\n",
      "tensor([[0.8307, 0.9706],\n",
      "        [0.1767, 0.7503]])\n"
     ]
    }
   ],
   "source": [
    "#randperm 应用\n",
    "import torch\n",
    "a=torch.rand(2,3)\n",
    "b=torch.rand(2,2)\n",
    "idx=torch.randperm(2)\n",
    "print(a)\n",
    "print(b)\n",
    "print(idx)\n",
    "print(a[idx])\n",
    "print(b[idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}