pytorch 深度学习之数据操作

基础

张量表示由一个数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量（vector）；具有两个轴的张量对应数学上的矩阵（matrix）；具有两个轴以上的张量没有特殊的数学名称。
张量中的每个值都称为张量的元素（element）。

arange 创建一个行向量，可以指定数据类型，tensor 可以使用 python 列表的形式指定张量：

x1 = torch.arange(12) 
x2 = torch.arange(10,dtype=torch.float32)

print(x1)
print(x2)

x3 = torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(x3)

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

通过张量的 shape 属性来访问张量（沿每个轴的长度）的形状，numel 函数可以获取所有元素的个数：

x1 = torch.arange(5)
x2 = torch.tensor([[1,2,3],[4,5,6]])

print(x1.shape)
print(x2.shape)

print(x1.numel())
print(x2.numel())

torch.Size([5])
torch.Size([2, 3])
5
6

reshape 函数可以改变一个张量的形状而不改变元素数量和元素值，可以通过 -1 来自动计算出维度：

x1 = torch.arange(12).reshape(4,3)
x2 = torch.arange(12).reshape(-1,6)
x3 = torch.arange(12).reshape(2,3,-1)

print(x1)
print(x2)
print(x3)

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

        [[ 6,  7],
         [ 8,  9],
         [10, 11]]])

zeros 函数和 ones 函数可以分别用来生成全 0 和全 1 张量，randn 函数可以用来生成每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样：

x1 = torch.zeros((2, 3, 4))
print(x1)

x2 = torch.ones((1,2,3))
print(x2)

x3 = torch.randn((2,2,3))
print(x3)

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.]]])
tensor([[[1., 1., 1.],
         [1., 1., 1.]]])
tensor([[[ 0.3054, -0.2960,  0.1536],
         [-0.7202,  1.5987, -0.3821]],

        [[ 0.3733,  0.2818, -1.2353],
         [-0.7004,  0.6075,  0.5294]]])

运算符

常见的标准算术运算符（+、-、*、/ 和 **）都可以被升级为按元素运算，“按元素”方式可以应用更多的计算，包括像求幂这样的一元运算符，比如 exp，逻辑运算：

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])

print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)

print(torch.exp(x))

print(x == y)

tensor([ 3.,  4.,  6., 10.])
tensor([-1.,  0.,  2.,  6.])
tensor([ 2.,  4.,  8., 16.])
tensor([0.5000, 1.0000, 2.0000, 4.0000])
tensor([ 1.,  4., 16., 64.])
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
tensor([False,  True, False, False])

张量连结，也就是把张量端对端地叠起来形成一个更大的张量，需要指定按照哪个轴进行连结：

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
P = torch.cat((X, Y), dim=0)
Q = torch.cat((X, Y), dim=1)

print(P)
print(Q)

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

对所有的元素求和：

print(torch.sum(X))
print(torch.sum(Y))

tensor(66.)
tensor(30.)

广播机制

在某些情况下，即使形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：首先，通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状。其次，对生成的数组执行按元素操作:

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))

print(a)
print(b)
print(a + b)

tensor([[0],
        [1],
        [2]])
tensor([[0, 1]])
tensor([[0, 1],
        [1, 2],
        [2, 3]])

其过程为：

索引和切片

张量中的元素可以通过索引访问。与任何 Python 数组一样：第一个元素的索引是 0，最后一个元素索引是 -1；可以指定范围以包含第一个元素和最后一个之前的元素：

X = torch.arange(16).reshape(4,4)

print(X)
print(X[-1])
print(X[0:2])
print(X[3:])
print(X[-1][-1])
print(X[-1][1:3])

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]])
tensor([12, 13, 14, 15])
tensor([[0, 1, 2, 3],
        [4, 5, 6, 7]])
tensor([[12, 13, 14, 15]])
tensor(15)
tensor([13, 14])

利用切片和索引可以对元素赋值：

X[-1][-1] = 99
print(X)

X[-1][:] = 1099
print(X)

X[:2][:] = 10
print(X)

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

节省内存

运行一些操作可能会导致为新结果分配内存。例如，如果我们用 Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量：

Y = torch.arange(12)
before = id(Y)
print(before)

Y = Y + torch.ones(12)
after = id(Y)
print(after)

print(after == before)

1923522705264
1923522706464
False

可以使用切片表示法将操作的结果分配给先前分配的数组,也可以使用 X[:] = X + Y 或 X += Y 来减少操作的内存开销:

Z = torch.zeros_like(Y)  # 创建一个新的矩阵Z，其形状与另一个Y相同， 使用zeros_like来分配一个全的块
print('id(Z):', id(Z))
Z[:] = torch.ones(12) + Y
print('id(Z):', id(Z))


before = id(Y)
Y += torch.ones(12)
print(id(Y) == before)

id(Z): 1923522863488
id(Z): 1923522863488
True

转换为其他Python对象

torch 张量和 numpy 数组将共享它们的底层内存，就地操作更改一个张量也会同时更改另一个张量:

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

(numpy.ndarray, torch.Tensor)

要将大小为1的张量转换为 Python 标量，我们可以调用 item 函数或 Python 的内置函数：

a = torch.tensor([3.5])

print(a)
print(a.item())
print(float(a))
print(int(a))

tensor([3.5000])
3.5
3.5
3

__EOF__

本文作者：刘皇叔
本文链接：https://www.cnblogs.com/xiaojianliu/p/16149751.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！