Tensor是深度学习的基本类型，我们常用的说法有，标量、向量、矩阵如下：

我们常用的表示

标量（Scalar）是只有大小，没有方向的量，如1，2，3等
向量（Vector）是有大小和方向的量，其实就是一串数字，如(1,2)
矩阵（Matrix）是好几个向量拍成一排合并而成的一堆数字，如[1,2;3,4]

其实标量，向量，矩阵它们三个也是张量，标量是零维的张量，向量是一维的张量，矩阵是二维的张量。张量可以扩展到多维。

tensor的创建方法大致分成四类

已经存在的数据构造使用 torch.tensor().
根据形状创建tensor,使用torch.* (见 Creation Ops).
根据已有形状创建tensor 使用 torch.*_like (见 Creation Ops).
T创建一个与现有形状不一样的tensor，使用tensor.new_* .

1 torch.tensor构造函数

torch.tensor(data, dtype=None, device=None, requires_grad=False)

data(数组) – 初始化的tensor数据，可以是list, tuple, NumPy ndarray, scalar, 或者其他类型.
dtype [torch.dtype]–tensor的数据类型.默认值: if None,
device torch.device类型，目前支持两种cpu和cuda，表示该变量存储位置，
requires_grad – 是否需要自动求导，默认是False.

1.2 torch支持的数据类型

Data type	dtype	Tensor types
32-bit 浮点	torch.float32 or torch.float	torch.*.FloatTensor
64-bit 浮点	torch.float64 or torch.double	torch.*.DoubleTensor
16-bit 浮点	torch.float16 or torch.half	torch.*.HalfTensor
8-bit 无符号整形	torch.uint8	torch.*.ByteTensor
8-bit 有符号整形	torch.int8	torch.*.CharTensor
16-bit 有符号整形	torch.int16 or torch.short	torch.*.ShortTensor
32-bit 有符号整形	torch.int32 or torch.int	torch.*.IntTensor
64-bit 有符号整形	torch.int64 or torch.long	torch.*.LongTensor

1.3 torch.device的构造方法

字符串

torch.device('cpu')
torch.device('cuda')
torch.tensor((2,3),device='cuda')

字符串和数字

torch.device('cuda:0')
torch.device('cuda', 0)
torch.device('cpu', 0)

直接使用数字

device=torch.device(0)
torch.randn((2,3), device=0)

1.4 例子

>>> torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])
tensor([[ 0.1000,  1.2000],
        [ 2.2000,  3.1000],
        [ 4.9000,  5.2000]])

>>> torch.tensor([0, 1])  # Type inference on data
tensor([ 0,  1])

>>> torch.tensor([[0.11111, 0.222222, 0.3333333]],
                 dtype=torch.float64,
                 device=torch.device('cuda:0'))  # creates a torch.cuda.DoubleTensor
tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64, device='cuda:0')

>>> torch.tensor(3.14159)  # Create a scalar (zero-dimensional tensor)
tensor(3.1416)

>>> torch.tensor([])  # Create an empty tensor (of size (0,))
tensor([])

2 根据形状创建tensor

目前有如下操作：

torch.rand()
torch.randn()
torch.randint()
torch.randperm()
torch.empty()
torch.bernoulli
torch.multinomial
torch.normal()
......

2.1 torch.rand

根据size创建[0,1]的随机数tensor

>>> torch.rand(4)
tensor([ 0.5204,  0.2503,  0.3525,  0.5673])
>>> torch.rand(2, 3)
tensor([[ 0.8237,  0.5781,  0.6879],
        [ 0.3816,  0.7249,  0.0998]])

import matplotlib.pyplot as plt
import matplotlib
import torch
%matplotlib inline
N = 4000
a = torch.rand(N)
b = range(N)
plt.figure(figsize=(10,8))
plt.scatter(b,a.numpy(), color='g')
plt.show()

torch.rand[0,1]

2.2 torch.randn

根据size创建标准正太分布的随机数tensor，均值0，方差1

import matplotlib.pyplot as plt
import matplotlib
import torch
%matplotlib inline
N = 4000
a = torch.randn(N)
b = range(N)
plt.figure(figsize=(10,8))
plt.scatter(b,a.numpy(), color='g')
plt.show()

torch.randn 均值0，方差1

2.3 torch.randint

自定义最大值和最小值，根据形状创建随机数

torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 
size需要一个元组，此处需要注意

例如获取[-150,100]之间的4000个随机数

import matplotlib.pyplot as plt
import matplotlib
import torch
%matplotlib inline
N = 4000
a = torch.randint(-150, 100, (N,))
b = range(N)
plt.figure(figsize=(10,8))
plt.scatter(b,a.numpy(), color='r')
plt.show()

torch.randint[-150, 100]

2.4 torch.randperm

随机获取0,1,...,n-1的组合

>>> torch.randperm(4)
tensor([ 2,  1,  0,  3])

3 根据已有数据形状创建tensor

torch.rand_like()
输入数据求尺寸input.size()，调用torch.rand_like
torch.randn_like()
输入数据求尺寸input.size()，调用torch.randn
torch.randint_like()
输入数据求尺寸input.size()，调用torch.randint

3 Tensor出生-庖丁解牛之pytorch