数据操作

• 数据操作
• • 创建数组
• 访问元素
• • 赋值
  • • 单数赋值
    • 按区域赋值

数据操作

在实现数据操作之前需要了解一些定义：
张量：张量表示一个由数值组成的数组，这个数组可能有多个维度。
0-d（0维数组）为标量
1-d（1维数组）为向量
2-d（2维数组）为矩阵
……

创建数组

要创建一个向量：

x = torch.arange(12) print(x) 

结果：

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

通过shape属性来访问张量的形状和其中元素的总数：

print(x.shape) print(x.numel()) 

结果：

torch.Size([12]) 12 

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数，可以看到他变成了一个三行四列的张量：

X = x.reshape(3, 4) print(X) 

结果：

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

使用全0、全1、其他常量，或者从特定分布中随机采样的数字：

print(torch.zeros(2, 3, 4)) print(torch.ones(2, 3, 4)) 

结果：

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., 1., 1.],          [1., 1., 1., 1.]],          [[1., 1., 1., 1.],          [1., 1., 1., 1.],          [1., 1., 1., 1.]]]) 

通过提供包含数值的Python列表（或嵌套列表），来为所需张量中的每个元素赋予确定值。

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

结果：

torch.Size([1, 3, 4]) 

常见的标准算术运算符（+、-、*、/和**）都可以被升级为按元素运算。

x = torch.tensor([1.0, 2, 4, 8]) y = torch.tensor([2, 2, 2, 2]) print(x + y, x - y, x * y, x / y, 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.]) 

我们也可以把多个张量连结（concatenate）在一起 dim=0代表按行合并，dim=1代表按列合并，以此类推：

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]]) print(torch.cat((X, Y), dim=0)) print(torch.cat((X, Y), dim=1)) 

结果：

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(X == Y) 

结果：

tensor([[False,  True, False,  True],         [False, False, False, False],         [False, False, False, False]]) 

可以计算所有的向量
print(X.sum())
结果：
tensor(66.)

访问元素

赋值

X[1, 2] = 9 print(X) X[0:2, :] = 12 print(X) 

结果：

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

在维度相同但形状不同的情况下，即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作，该机制通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状之后再对生成的数组执行按元素操作。

 a = torch.arange(3).reshape((3, 1)) b = torch.arange(2).reshape((1, 2)) print(a) print(b) # 由于a和b分别是3*1和1*2矩阵，如果让它们相加，它们的形状不匹配。 # 矩阵广播机制将会将其化为一个更大的3*2矩阵，如下所示：矩阵a将复制列，矩阵b将复制行，然后再按元素相加。 print(a + b) 

结果：

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

单数赋值

使X的第2行第3列变为9

X[1, 2] = 9 print(X) 

结果：

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

按区域赋值

让矩阵的前两行和所有列的值都改为12：

X[0:2, :] = 12 print(X) 

结果：

tensor([[12., 12., 12., 12.],         [12., 12., 12., 12.],         [ 8.,  9., 10., 11.]]) 

张量转换为NumPy张量

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

结果：

将大小为1的张量转换为标量

a = torch.tensor([3.5]) print(a,a.item,float(a),int(a)) 

结果：

tensor([3.5000]) 3.5 3.5 3