5.张量索引操作

（1）索引操作

• 行列索引
• 列表索引

print(data[[0, 2], [1, 2]]) #返回(0, 1)，(2, 2)两个位置的元素print(data[[[0], [1]], [1, 2]]) # 返回0，1行的1，2列共4个元素

• 范围索引

print(data[:3, :2]) # 前3行前2列数据print(data[2:, :2]) # 第2行到最后的前2列数据

• 布尔索引

tensor([[0, 7, 6, 5, 9],[6, 8, 3, 1, 0],[6, 3, 8, 7, 3],[4, 9, 5, 3, 1]])
print(data[data[:, 2] > 5])
print(data[:, data[1] > 5])

输出结果：
tensor([[0, 7, 6, 5, 9],[6, 3, 8, 7, 3]])tensor([[0, 7],[6, 8],[6, 3],[4, 9]])

• 多维索引

data = torch.randint(0, 10, [3, 4, 5])
print(data)
#获取0轴上的第一个数据
print(data[0, :, :])# 获取1轴上的第一个数据
print(data[:, 0, :])# 获取2轴上的第一个数据
print(data[:, :, 0])

6.张量形状操作

（1）reshape函数

import torchdata = torch.tensor([[10, 20, 30], [40, 50, 60]])# 1.使用shape属性或者size方法都可以获得张量的形状
print(data.shape, data.shape[0], data.shape[1])
print(data.size(), data.size(0), data.size(1))# 2.使用reshape函数修改张量形状
new_data = data.reshape(1, 6)
print(new_data.shape)

（2）squeeze()和unsqueeze()函数

• squeeze函数删除形状为1的维度（降维），unsqueeze函数添加形状为1的维度（升维）

import torchtorch.random.manual_seed(22)
data = torch.randint(0, 10, [3, 4, 5])# 添加维度
data1 = data.unsqueeze(dim = 1).unsqueeze(dim = -1)
print(data1.shape)# 降低维度
print(data1.squeeze().shape)

输出结果：
torch.Size([3, 1, 4, 5, 1])
torch.Size([3, 4, 5])

（3）transpose()和permute()函数

• transpose函数可以实现交换张量形状的指定维度；permute函数可以一次交换更多的维度

import torchtorch.random.manual_seed(22)
data = torch.randint(0, 10, [4, 2, 3, 5])
print(data.shape)# 转换成[3, 4, 5, 2]
data1 = torch.transpose(data, 0, 2)
data2 = torch.transpose(data1, 1, 2)
data3 = torch.transpose(data2, 2, 3)
print(data3.shape)data4 = torch.permute(data, [2, 0, 3, 1])
print(data4.shape)print(data.permute([2, 0, 3, 1]).shape)

输出结果：
torch.Size([4, 2, 3, 5])
torch.Size([3, 4, 5, 2])
torch.Size([3, 4, 5, 2])
torch.Size([3, 4, 5, 2])  

（4）view()和contiguous()函数

• view函数也可以用于修改张量的形状，只能用于存储在整块内存中的张量

• 一个张量经过了transpose或者permute函数的处理之后，就无法使用view函数进行形状操作，如果要使用view函数，需要使用contiguous()变得连续以后再使用view函数

import torchtorch.random.manual_seed(22)
data = torch.randint(0, 10, [2, 3])
print(data.shape)# 判断内存是否连续
print(data.is_contiguous())print(data.view(-1).shape)data1 = torch.transpose(data, 0, 1)
print(data1.is_contiguous()) # 内存不连续data2 = data1.contiguous()
print(data2.view(-1).shape)if data.is_contiguous():data.view(-1)
else:data.contiguous().view(-1)

输出结果：
torch.Size([2, 3])
True
torch.Size([6])
False
torch.Size([6])

7.张量拼接操作

• torch.cat()：可以将两个张量根据指定的维度拼接起来，不改变维度数

import torch
data1 = torch.randint(0, 10, [1, 2, 3])
data2 = torch.randint(0, 10, [1, 2, 3])
print(data1)
print(data2)# 1.按0维度拼接
new_data1 = torch.cat([data1, data2], dim = 0)
# print(new_data1)
print(new_data1.shape)# 2.按1维度拼接
new_data2 = torch.cat([data1, data2], dim = 1)
# print(new_data2)
print(new_data2.shape)# 3.按2维度拼接
new_data3 = torch.cat([data1, data2], dim = 2)
# print(new_data3)
print(new_data3.shape)

输出结果：
tensor([[[5, 1, 8],[8, 9, 5]]])
tensor([[[5, 2, 9],[0, 5, 6]]])
torch.Size([2, 2, 3])
torch.Size([1, 4, 3])
torch.Size([1, 2, 6])

8.自动微分模块

• 训练神经网络时，最常用的算法就是反向传播。在该算法中，参数（模型权重）会根据损失函数关于对应参数的梯度进行调整。为了计算这些梯度，pytorch内置了名为torch.autograd的微分引擎，它支持任意计算图的自动梯度计算

"""w = w - L(w.grad)"""
import torch# 数据  特征+目标
x = torch.tensor(5)
y = torch.tensor(0.)# 权重  偏置
w = torch.tensor(1, requires_grad=True,dtype = torch.float32)
b = torch.tensor(3, requires_grad=True, dtype = torch.float32)# 预测
z = w*x + b# 损失
loss = torch.nn.MSELoss()
loss = loss(z, y)# 微分
loss.backward()#梯度
print(w.grad)
print(b.grad)

输出结果：
tensor(80.)
tensor(16.)

import torchx = torch.ones(2, 5)
y = torch.zeros(2, 3)w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)z = torch.matmul(x, w) + bloss = torch.nn.MSELoss()
loss = loss(z, y)loss.backward()print(w.grad)
print(b.grad)

输出结果：
tensor([[0.2782, 1.4126, 0.4037],[0.2782, 1.4126, 0.4037],[0.2782, 1.4126, 0.4037],[0.2782, 1.4126, 0.4037],[0.2782, 1.4126, 0.4037]])
tensor([0.2782, 1.4126, 0.4037])