深度学习基础2

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 torch

data = 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 torch

torch.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 torch

torch.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 torch

torch.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 torch

x = 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) + b

loss = 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])