pytorch第02天 创建张量

除了可以像上节课一样，使用.tensor()，.FloatTensor()，.Tensor()等函数来初始化一个张量，还可以用.from_numpy()函数把numpy的数据类型转化为tensor（详见第一天笔记），还可以用很多方法生成。

1 rand，randn，randint，rand_like，rand_perm的使用

.rand(shape)生成服从[0, 1]均匀分布的张量。这里的shape既可以是元组，也可以是类似于“torch.Size([2, 3])”的形式，pytorch中的其他函数如果参数列表中有shape或者size，同样如此
.randn(shape)生成服从标准正态分布的张量
.randint(min,max,shape)生成一个指定形状的张量，该张量的元素从[min, max)中随机取整

上面的三个函数，和numpy中的用法完全一样

.rand_like(a)将a的shape拿出来，然后输入.rand()，其中a只能为浮点型，不能为整型，因为rand函数是0-1之间的均匀分布，可能的两个整数是0或者1，都在分布区间的边界。
.rand_like(a)相当于.rand(a.shape)，但是.rand(a.shape)中，a可以是整型
torch中，*_like(a)函数，都会提取a对象的size，但类型必须相似（即类型可以不一致，但必须是整型like整型，浮点型like浮点型）

rint('---------a----------')
a = torch.randint(1, 5, (3, 3))     # 在[1, 5)上随机取值，组成3x3矩阵
print(a)

print('----------b----------')
m = torch.FloatTensor(2, 3)
b = torch.rand_like(m)              # 让b与m维度相同
print(b)

print('---------c------------')
c = torch.rand(a.shape)
print(c)

输出

---------a----------
tensor([[2, 3, 3],
        [4, 4, 2],
        [4, 1, 2]])
----------b----------
tensor([[0.9532, 0.8631, 0.3422],
        [0.2206, 0.0818, 0.7083]])
---------c------------
tensor([[0.8685, 0.6719, 0.5644],
        [0.9357, 0.4897, 0.4805],
        [0.4164, 0.8479, 0.6756]])

在torch.rand_like()函数中，如果想要取某个整型张量的形状，必须设定新生成元素的类型为浮点型。假如a的类型是IntTensor，现在要取a的形状，可以这样写：

print('----------d-----------')
d = torch.rand_like(a,dtype=torch.double) # 取a的维度，并生成double型张量
print(d)
print(d.type())

如果上述程序的第二行改为：d = torch.rand_like(a, dtype=torch.int)则会报错
输出

----------d-----------
tensor([[0.1785, 0.5559, 0.5255],
        [0.8970, 0.0486, 0.6113],
        [0.2485, 0.5304, 0.8705]], dtype=torch.float64)
torch.DoubleTensor

.randperm(n)生成一个[0,n)的整型张量，并打乱

idx = torch.randperm(10)
print(idx)

输出

tensor([9, 4, 6, 1, 7, 2, 5, 8, 3, 0])

随机函数种子设置

torch.manual_seed(SEED)				# cpu
torch.cuda.manual_seed_all(SEED)	# gpu

2 张量类型与元素类型的关系

这里补充一下元素类型的概念，前面讲了张量类型，那是对整个张量而言的，但对张量中的具体某个元素，它的常用类型如下：

torch.short或torch.int16   # 16表示16位
torch.int或torch.int32   
torch.long或torch.int64   
torch.float或torch.float32   
torch.double或torch.float64   
torch.bool

张量类型与元素类型是一一对应的，比如，如果张量a的类型是torch.FloatTensor，那么这个张量的元素类型是torch.float，其他的组合也是类似。
可以用.dtype属性来获取张量中元素的类型，注意是属性，不是函数

import torch
a = torch.BoolTensor(2, 3)     # 生成一个2x3的Bool型张量，元素的默认值为False
print(a)
print(a.dtype)

输出

tensor([[False, False, False],
        [False, False, False]])
torch.bool

可以用a.short(),a.int(),a.long(),a.float(),a.double()来实现变量之间的转换，也可以用a.type(torch.float)，a.type(torch.douoble)等形式来线性类型转换，转换规则为：字节数多的字节数少的转换，则去掉高位字节，字节数少的向字节数多的转换，则补充字节。需要注意的是，这些函数都不是原地转换，他们返回一个转换后的函数，a的类型没有变

在numpy中，若k是numpy的数组，那么k.dtype是获得数组中的元素属性，k.astype(“int8”)是转换数据类型，这里的8表示8个字节，而非8位

3 填充函数

.full(size, fill_value) 填充函数，输出的张量，其每个元素都相同
比如，把7填充到一个2行3列的矩阵中，可以这样写

a = torch.full((2, 3), 7.)
print(a)
print(a.type())

注意，这里填充的时候，只能填浮点型，所以要用7. 而非7，输出

tensor([[7., 7., 7.],
        [7., 7., 7.]])
torch.FloatTensor

如果填充的时候填充的是整型7，那么必须特别指定元素类型，例如

b = torch.full((2, 3), 7, dtype=torch.int)
print(b)
print(b.type())

输出

tensor([[7, 7, 7],
        [7, 7, 7]], dtype=torch.int32)
torch.IntTensor

也可以用full函数获得一个向量

c = torch.full((5,), 7.)
print(c)
print(c.type())

输出

tensor([7., 7., 7., 7., 7.])
torch.FloatTensor

pytorch中的向量，相当于numpy中的一维数组，因为只有一个方括号括起来的
因为在pytorch中，size和shape是一样的，所以在指定尺寸的时候，既可以用元组，也可以用列表。因此，
如果要生成向量，可以用c = torch.full([5], 7.)
如果要生成矩阵，可以用c = torch.full([2, 3], 7.)

4 arange与range函数

arange(start,end,step)函数表示生成一个序列，不包括end，既能用于整数，也能用于小数，步长既能为正，也能为负。要么只写end，要么把stat，end，step三个同时写出来。

import torch
print(torch.arange(10))
print(torch.arange(0, 10, 2))

输出

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
tensor([0, 2, 4, 6, 8])

arrange的用法和numpy中的arrange完全一样

range(start,end,step)生成的序列包括end，但具体还得看步长，不推荐使用

print(torch.range(0, 5))	# 0不能省略
print(torch.range(0, 5, 2))

输出

tensor([0., 1., 2., 3., 4., 5.])
tensor([0., 2., 4.])

torch中的range和Python自带的range有区别，Python自带的range函数，起始数字可以省略，而且不包含end

5 指定均值和标准差的正态分布

.randn(shape) 生成标准正态分布，但如果想生成非标准的正态分布，该如何实现？
.normal(mean=tensor1, std=tensor2)，tensor1和tensor2的尺寸要相同，tensor1提供相应位置的均值，tensor2提供相应位置的标准差，标准差的平方才是方差。如

n= torch.normal(mean=torch.full([10],0.), std=torch.arange(10,0,-1))

生个一个含10个元素的张量，每个元素都来自正态分布。

6 linspace

torch.linspace(start,end,steps) 注意，这里的steps不是步长，而是生成的张量元素个数，这里生成的序列，包含end

print(torch.linspace(5, 10, 10))

输出

tensor([ 5.0000,  5.5556,  6.1111,  6.6667,  7.2222,  7.7778,  8.3333,  8.8889,  9.4444,  10.0000])

7 单位矩阵

.eye(n)生成nxn单位矩阵

print(torch.eye(5))

输出

tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1.]])

8 总结

1 torch.rand(2,3) torch.rand(5) torch.randint(2,8,(3,3)) torch.randperm(10)分别表示什么意思？如何设置随机函数的种子
2 张量类型与元素类型的对应关系，如何获取张量的元素类型，Bool型张量的默认值为？
数据类型之间该如何转换？
3 torch.full((2, 3), 7.)什么意思，能不能把7.改成7？如果需要用整数7来填充，需要怎么做？
4 torch.arange(0, 10, 1)什么意思？如果想简便，该怎么写？
5 如何生成一个标准正态分布的张量，如何生成一个非标准正态分布的张量？
6 torch.linspace(5, 10, 10)什么意思，最后生成的张量，是否包含10？
7 如何生成一个5x5的单位矩阵？
8 torch.rand_like(a)中，a能不能为整型？如果a是整型，需要怎么做？