0基础动手学深度学习-李沐-ML-数据操作

访问张量数组中的元素：

​ 例：创建一个张量

x = torch.Tensor([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])

---

访问单个元素：例：

print(x[1, 1])
#############输出为#################
# tensor(5.)

切片操作符：使用该操作符可以从一个序列中 (列表，字符串或数组)提取子序列。

语法格式为start: stop: step

​ ‘start’:起始索引(包含在切片内)

​ ‘stop’:终止索引(不包含在切片内)

​ ‘step’：步长(可选参数，默认为1)(一阶张量默认是从左向右步长为1)

​ 逆序打印：

sequence = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 提取倒数第三个元素到第一个元素的所有元素，逆序输出
print(sequence[-3::-1])  # 输出: [7, 6, 5, 4, 3, 2, 1]
#‘-’表示从右往左

访问一行：

print(x[1,:])
###########输出为###############
# tensor([4., 5., 6.])

访问一列：

print(x[:,1])
###########输出为###############
# tensor([2., 5., 8.])

访问子区域：

print(x[1:, 1:])
#############输出为##########
# tensor([[5., 6.],
#         [8., 9.]])

访问子区域：

print(x[::2, ::2])
#########输出为#########
#tensor([[1., 3.],
#        [7., 9.]])

torch.cat()函数

​ 功能：用于将多个张量沿着指定的维度进行拼接(张量的维度任意)

​ dim参数：dim参数指定拼接的维度，默认为0

​ 注意：除了指定拼接的维度外，其余的维度以及张量的维度大小必须相同，否则会抛出异常

​ 例：

# 创建两个张量
x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
# 将两个张量按行拼接
z = torch.cat((x, y), dim=0)
print(z)
###########输出为#############
# tensor([1, 2, 3, 4, 5, 6])

广播机制(当操作的张量中有一阶张量时需要注意)：

​ 简介：不同形状的张量之间进行逐元素的操作，当两个张量在某个维度上的形状不匹配时，广播机制会自动调整其中一个或两个张量的形状，使他们具有相同的形状，以便进行逐元素的操作。

​ 广播机制遵循的规则：

​ 1.如果两个张量的维度数不同，那么在较小的维度上添加1，直到两个张量的维度数相同。

​ 2.如果两个张量在某个维度上的形状不同，但其中一个张量的形状在该维度上为1，那么可以将该张量在该维度上进行复制，使得两个张量在该维度上的形状相同。

​ 3.如果两个张量在某个维度上的形状既不相同，也不为1，则广播操作会引发错误。

​ 例：

x = torch.arange(12).reshape((2, 6))
y = torch.Tensor([10, 10, 10, 10, 10, 10])
print(x.shape)
print(y.shape)
print(x + y)
##########输出为###############
# torch.Size([2, 6])
# torch.Size([6])
# tensor([[10., 11., 12., 13., 14., 15.],
#         [16., 17., 18., 19., 20., 21.]])

Python中y = y+x和y += x操作的区别：

​ y = y+x：该操作会在y与x相加的基础上，新开辟一个内存空间存储求和结果，并将该空间与新的对象y进行绑定

​ y += x：(1)对于不可变对象(数字、字符串、元组)，使用该操作会创建一个新的内存空间存储求和的结果，并将该空间与新的对象y进行绑定

​ (2)对于可变对象(列表、字典、集合)，该操作是原地操作，不会创建新的对象

注意：对于张量来说，在求和前，必须要保证两个待求和张量具有相同的形状，在任意维度大小必须均相同

torch.zeros_like(x)函数：

​ **功能：**创建一个与x具有相同维度的张量，且其中的每一个元素均初始化为0

内存分配：

​ 如何执行原地操作：(1)在对张量进行操作的时候可以使用前文中的y += x运算或者使用切片运算符 x[:] = x + y来减少内存开销

​ (2)同时可以通过一个新申请的空间进行该操作：

​ (2)的例子：

x = torch.arange(12).reshape((3, 4))
y = torch.Tensor([[1, 3, 5, 7],
                  [2, 4, 8, 10],
                  [3, 6, 9, 12]])
z = torch.zeros_like(y)
print(z)
print(id(z))
z[:] = y + x#！！！！注意要使用切片运算符进行依次的计算与赋值操作，此时是原地操作，不加[:]就不是
#切片运算符可以保证求和运算是在原空间上进行的，而直接z = y + x操作就变成了上面y = y + x的情况
print(z)
print(id(z))
#############输出为#################
# tensor([[0., 0., 0., 0.],
#        [0., 0., 0., 0.],
#         [0., 0., 0., 0.]])
# 1835814506080
# tensor([[ 1.,  5.,  9., 13.],
#         [10., 14., 20., 24.],
#         [19., 24., 29., 34.]])
# 1835814506080  

注意：

x = torch.Tensor([[1, 2, 3], [4, 5, 6]])
y = x
print(id(x) == id(y))
#########输出为#############
# True

# 这意味着x和y对象虽是两个不同的对象，但指向的是同一个内存空间，如果改变其中一个，另一个会随之发生改变

y = x.clone()
##########输出为########
# False

#开辟了一个新的内存空间，并将其赋值为x，之后用y这个对象来指向，两个内存空间就互不影响了