Pytorch|Pytorch 零基础学习系列之创建张量 Pytorch|深度学习

Pytorch 零基础学习系列之创建张量在深度学习中，神经网路结构是基础；在Pytorch中，张量是构建神经网络的基础。从本质上讲，Pytorch就是一个处理张量的库。一个张量可以是一个数字、向量、矩阵或者任何n维数组。比较重要的一点是张量可以在GPU上进行计算。
例如，下图分别展示了1维张量，2维张量和3维张量：
如何创建一般张量？方法一

(1) 导入 pytorch 和 numpy

import torch import numpy as np

(2) 张量相关参数

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

【Pytorch|Pytorch 零基础学习系列之创建张量】其中，

data：数据，可以是列表list，numpy的 ndarray
dtype：数据类型，默认与data数据类型一致
device：所在设备，GPU/CPU
requires_grad：是否需要梯度，神经网路经常需要梯度
pin_memory：是否存在锁页内存

(3) 使用numpy创建张量

通过 numpy 创建 ndarray，然后转化为张量，数据类型默认与 data一致。

arr = np.ones((3, 3)) print("数据类型：", arr.dtype) t = torch.tensor(arr) print(t)

运行结果：
数据类型： float64 tensor([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]], dtype=torch.float64)
如果在已经搭建了GPU环境运行，可以通过下面的代码在GPU 上创建张量（创建过程需要几秒的等待时间）

arr = np.ones((3, 3)) print("数据类型：", arr.dtype) t = torch.tensor(arr, device = 'cuda') print(t)

运行结果：
数据类型： float64 tensor([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]], device='cuda:0', dtype=torch.float64)
方法二
通过numpy创建的另外一种方法是：

使用 torch.from_numpy(ndarray)

这种方法只需要接受一个 ndarray 即可

arr = np.array([[1, 2, 3], [4, 5, 6]]) t = torch.from_numpy(arr) print(arr) print(t)

运行结果：
[[1 2 3] [4 5 6]] tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.int32)
注意

从torch.from_numpy 创建的 tensor 和 ndarray 共享内存，当修改其中一个的数据，另外一个也会被修改。

例如，在修改 array 的内容：

arr = np.array([[1, 2, 3], [4, 5, 6]]) t = torch.from_numpy(arr)# 修改 array 的内容 arr[0,0] = 312 print(arr) print(t)

运行结果：
[[312 2 3] [ 4 5 6]] tensor([[312, 2, 3], [ 4, 5, 6]], dtype=torch.int32)
再比如说，修改张量的内容：

arr = np.array([[1, 2, 3], [4, 5, 6]]) t = torch.from_numpy(arr)# 修改 tensor 的内容 t[0,0] = -430 print(arr) print(t)

运行结果：
[[-430 2 3] [ 4 5 6]] tensor([[-430, 2, 3], [ 4, 5, 6]], dtype=torch.int32)
创建全0张量方法一

可以通过 torch.zeros() 创建全0张量

zeros(*size, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中，

size：为张量形状
out：输出的张量
dtype：数据类型
layout：内存中的布局形式，有strided，sparsed_coo等
device：所在设备，GPU/CPU
requires_grad：是否需要梯度，神经网路经常需要梯度

t1 = torch.tensor([1, 2, 3]) # 创建一个t1张量并赋初始值 t = torch.zeros((2,3), out = t1) print(t, '\n', t1) print(id(t), id(t1), id(t) == id(t1))

运行结果：
tensor([[0, 0, 0], [0, 0, 0]]) tensor([[0, 0, 0], [0, 0, 0]]) 2464000054400 2464000054400 True
通过上面显示的id发现，t和t1的id相同，所以t和t1在内存中指向的内存块相同。
方法二

可以通过torch.zeros_like() 创建全0张量：

torch.zeros(input, dtype = None, layout = None, device = None, requires_grad = False)

根据 input 形状创建全0张量
例如，创建一个 4*6 的全0张量

input = torch.empty(4, 6) t = torch.zeros_like(input) print(t)

运行结果：
tensor([[0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0.]])
创建全1张量全1张量的创建和全0张量的创建方式基本一致，使用如下方式创建：

torch.ones()

torch.ones_like()

根据数值创建张量方法一

torch.full()

torch.full(size, fill_value, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中新出现的参数：

fill_value：填充的值

例如，创建一个 2*2 的元素都是 8 的张量

t = torch.full((2, 2), 8 ) print(t)

运行结果：
tensor([[8, 8], [8, 8]])
方法二

torch.fuu_like()

torch.full_like(input, fill_value, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

例如，创建一个 4*3 的元素都为6的张量

input = torch.empty(4, 3) t = torch.full_like(input, 6) print(t)

运行结果：
tensor([[6., 6., 6.], [6., 6., 6.], [6., 6., 6.], [6., 6., 6.]])
创建等差的一维张量

可以通过 torch.arange() 创建等差的一维张量

arange(start = 0, end, step = 1, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中，

start：数列的起始值
end：数列的结束值，取不到的，只能取到 end - 1
step：公差（步长），默认为1

t = torch.arange(1, 9, 2) print(t)

运行结果：
tensor([1, 3, 5, 7])
创建等间距（均分）的一维张量

可以通过 torch.linspace() 来创建等间距均分张量

linspace(start, end, steps = 100, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中，

steps：创建出的一维张量中元素个数
end：结束位置可以取到

t = torch.linspace(1, 5, 4) print(t)

运行结果：
tensor([1.0000, 2.3333, 3.6667, 5.0000])
注：linspace的图解

文章图片

创建对数均分的一维张量

可以通过 torch.logspace() 来创建对数均分张量

logspace(start, end, steps = 100, base = 10.0, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中参数，

base：对数函数的底，默认为10.0

t = torch.logspace(start = -5, end = 10, steps = 4) print(t)

运行结果：
tensor([1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])

等间距均分 linspace 相当于等差数列，对数均分 logspace 相当于等比数列。对数均分相当于幂次的指数部分成等间距均分。

t = torch.logspace(start = -2, end = 2, steps = 5, base = 2.0) print(t)

tensor([0.2500, 0.5000, 1.0000, 2.0000, 4.0000])
注：logspace图解

文章图片

创建单位对角矩阵（二维向量）

可以通过 torch.eye() 来创建单位对角矩阵。

torch.eye(n, m = None, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

其中，参数

m：矩阵行数
n：矩阵列数（默认为方阵）

t = torch.eye(4) print(t)

运行结果：
tensor([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]])
创建正态分布（高斯分布）数据的张量

可以通过 torch.normal() 生成正态分布数据的张量

torch.noraml(mean, std, out = None)

其中，参数

mean：均值
std：标准差

这种正态分布的数据张量的创建方法可以分成4种方式：
(1) mean为张量，std为张量
(2) mean为标量，std为标量
(3) mean为标量，std为张量
(4) mean为张量，std为标量

（1）mean为张量，std为张量

# means为张量，std为张量 mean = torch.arange(1, 6, dtype = torch.float) std = torch.arange(1, 6, dtype = torch.float) t = torch.normal(mean, std) print("mean:{}, std:{}".format(mean, std)) print(t)

运行结果：
mean:tensor([1., 2., 3., 4., 5.]), std:tensor([1., 2., 3., 4., 5.]) tensor([-0.9937, -0.4433, 5.5810, 6.5006, 0.1337])
此时，mean和std都是张量，可以理解为：

-0.9937是 mean = 1， std = 1 的正态分布采样得到，其他位置也是相应的正态分布采样得到，只是从不同的正态分布中采样罢了。

（2）mean为标量，std为标量

# mean为标量，std为标量 t = torch.normal(0.2, 1.0, size = (5, )) print(t)

运行结果：
tensor([-0.6160, -0.6579, 0.5311, 0.2198, 0.4986])

这里生成的数据都是通过 mean = 0.2，std = 1.0 采样得到长度为5的一维张量。

（3） mean为标量，std为张量

# mean为标量，std为张量 mean = 2 std = torch.arange(1, 4, dtype = torch.float) t = torch.normal(mean, std) print("mean:{}, std:{}".format(mean, std)) print(t)

运行结果：
mean:2, std:tensor([1., 2., 3.]) tensor([ 1.2999, 2.6499, -3.2337])

1.2999是mean为2，std为1的正态分布采样得到，其他对应位置数据同理可得。只是从不同的正态分布中得到（均值相同，标准差不同）

（4）mean为张量，std为标量

# mean为张量，std为标量 mean = torch.arange(1, 4, dtype = torch.float) std = 2 t = torch.normal(mean, std) print("mean:{}, std:{}".format(mean, std)) print(t)

运行结果：
mean:tensor([1., 2., 3.]), std:2 tensor([-0.3166, 1.6594, 2.7413])

11.6594是mean为2，std为2的正态分布采样得到，其他对应位置数据同理可得。只是从不同的正态分布中得到（均值不同，标准差相同）

小结

(1) mean为张量，std为张量 —— 每次采样的正态分布均值不同，标准差也不同
(2) mean为标量，std为标量—— 每次采样的正态分布均值相同，标准差也相同
(3) mean为标量，std为张量—— 每次采样的正态分布均值相同，标准差不同
(4) mean为张量，std为标量—— 每次采样正态分布均值不同，标准差相同

创建标准正态分布数据的张量一维标准正态分布
标准正态分布X ～ N ( 0 , 1 ) X \sim N(0,1) X～N(0,1) 均值为0，标准差为1

torch.randn()

torch.randn(*size, out = None, dtype = None, layout = torch.strided, device = None, requires_grad = False)

size ：张量的形状
例如，创建一个长度为6的标准正态分布张量：

print(torch.randn(6))

运行结果：
tensor([-0.4437, 0.4294, 0.6771, -0.5297, -1.0764, -0.2395])
二维标准正态分布

print(torch.randn(3, 4))

运行结果：
tensor([[-0.2408, -0.3853, 0.8474, -1.4925], [ 0.4209, -0.2081, -0.7453, -0.4224], [ 0.0714, -0.6231, 0.2519, 1.3031]])
另一种办法

torch.randn_like() 可以根据张量的形状创建新的标准正态分布

randn_like(input, dtype = None, layout = None, device = None, requires_grad = False)

a = torch.ones((3,4)) t = torch.randn_like(a) print(t)

运行结果：
tensor([[ 0.5477, -0.4851, 0.4772, -0.5393], [ 1.0461, 0.1628, 0.0659, 0.3142], [ 0.2300, 1.2297, 1.1029, -0.3967]])
创建在 ( 0 , 1 ] (0,1] (0,1]上均匀分布的张量一维均匀分布