2.1 数据操作

  • 获取数据

  • 将数据读入计算机后对其进行处理。

    2.1.1 入门

  • 创建一个向量 ```python x = torch.arange(12)

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

  2. - shape 访问张量的形状（在每个维度上的长度）
  3. ```python
  4. x.shape
  6. # torch.Size([12])
  • numel() 访问张量中元素的总数 ```python x.numel()

12


- reshape 改变张量的形状

reshape可以使用-1来自动计算某个方向上的维度
```python
x.reshape(2,3,2)

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

x.reshape(2,3,-1)
#当reshape中某个维度为-1时表示自动计算该维度的大小。
#tensor([[[ 0,  1],
#         [ 2,  3],
#         [ 4,  5]],
#
#        [[ 6,  7],
#         [ 8,  9],
#         [10, 11]]])
  • 创建全0张量 ```python torch.zeros(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.]]])


- 创建全1张量
```python
torch.ones(2,5)

#tensor([[1., 1., 1., 1., 1.],
#        [1., 1., 1., 1., 1.]])
  • randn（）创建标准正态分布的张量 ```python torch.randn(3,4)

tensor([[ 0.2507, -0.9476, 0.5208, -0.0058],

[ 0.3376, -1.8534, 0.4105, 0.4918],

[ 1.4540, -1.3196, 1.6268, 0.0667]])


- 通过list创建张量
```python
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

#tensor([[2, 1, 4, 3],
#        [1, 2, 3, 4],
#        [4, 3, 2, 1]])

2.1.2 运算符

  • 按元素运算 ```python x = torch.tensor([1.0, 2, 4, 8]) y = torch.tensor([2, 2, 2, 2]) 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.])


- cat（）多个张量连结
```python
X = torch.arange(12).reshape(3,4)
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X,Y),dim = 0)
#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.]])

torch.cat((X,Y),dim = 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.]])
  • 判断两个张量在每个元素上是否相等 ```python X == Y

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

    [False, False, False, False],

    [False, False, False, False]])

X ==5.0

tensor([[False, False, False, False],

[False, True, False, False],

[False, False, False, False]])


- 对所有元素进行求和
```python
X.sum()
#tensor(66)

2.1.3 广播机制

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

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

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

a+b
#将a矩阵复制列，b矩阵复制行，各自变为3x2矩阵后相加
#tensor([[0, 1],
#        [1, 2],
#        [2, 3]])