Aprendizaje de Pytorch: el primer modelo (modelo lineal)

Objetivo

Queremos inicializar aleatoriamente los parámetros $ay\_\_b$ puede hacer que el valor predicho y el valor objetivo se acerquen infinitamente a
$$y=\omega x+b$$

definir datos

x = torch.rand([60, 1])*10
y = x*2 + torch.randn(60,1)

modelo de construcción

Cuando use nn.Module en pytorch
para construir un modelo, simplemente herede esta clase
Algunas precauciones al reescribir la clase nn.Module
(1) Generalmente, las capas con parámetros que se pueden aprender en la red (como capas completamente conectadas, convoluciones, etc.) capas, etc.) en el constructor __init__();
(2) Por lo general, las capas que no tienen parámetros de aprendizaje (como ReLU, dropout, BatchNormanation) se pueden colocar en el constructor, o no en el constructor, si no se coloca en el constructor __init__, puede usar nn.funcional en su lugar en el método de avance
(3) El método de avance debe reescribirse , es para realizar la función del modelo y realizar la relación de conexión entre cada núcleo de capa.

from torch import nn
class Lr(nn.Module):
    def __init__(self):
        super(Lr, self).__init__()  #继承父类init的参数
        self.linear = nn.Linear(1, 1) #只有线性层（全链接层）
 
    def forward(self, x):
        out = self.linear(x)#输出
        return out

El número de salidas nn.Linear(in_features, out_features);nn.Linear(1, 1) Los parámetros aquí son fáciles de saber que lo que obtenemos a través de la ecuación es finalmente una lista de números

# 实例化模型
model = Lr()
# 传入数据，计算结果
predict = model(x)

optimizador

1. El optimizador es principalmente para actualizar los parámetros de aprendizaje del modelo durante la fase de entrenamiento del modelo. Los optimizadores de uso común incluyen SGD, RMSprop, Adam, etc. 2. Se pasan los parámetros de aprendizaje del modelo entrante y otros hiperparámetros como
lr cuando se inicializa el optimizador, impulso, etc.
3. Durante el proceso de entrenamiento, primero llame aOptimizer.zero_grad() para borrar el gradiente, luego llame a loss.backward() para retropropagar y finalmente llame aOptimizer.step() para actualizar los parámetros del modelo
4. Los parámetros se pueden usar model.parameters() Para obtener, obtenga todos los parámetros de require_grad=True en el modelo

optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化，1e-3也可以写成0.001
optimizer.zero_grad() #2. 梯度置为0
loss.backward() #3. 计算梯度
optimizer.step()  #4. 更新参数的值

función de pérdida

Hay muchas funciones de pérdida en la antorcha.

1. Error cuadrático medio: nn.MSELoss(), a menudo utilizado para problemas de regresión

2. Pérdida de entropía cruzada: nn.CrossEntropyLoss(), comúnmente utilizada en problemas de clasificación

criterion = nn.MSELoss() # 实例化损失函数

modelo de entrenamiento

1. Defina una época, lo que significa que todos los datos deben ser entrenados para rondas de época
2. Pase los datos al modelo para obtener el valor predicho
3. Pase el valor predicho y el valor objetivo a la función de pérdida para calcular la pérdida 4.
Devolver a cero el gradiente del optimizador, este paso se debe realizar cada vez que se actualicen los parámetros, de lo contrario siempre se acumulará el gradiente
5. Calcular el gradiente, este paso se realiza después del 4.
6. Actualizar el gradiente, y los parámetros se actualizarán en consecuencia
7. (Opcional) a intervalos durante el proceso de entrenamiento Imprimir la pérdida y observar la velocidad de convergencia

#训练模型
for i in range(30000):
    out = model(x)  # 3.1 获取预测值
    loss = criterion(y, out)  # 3.2 计算损失
    optimizer.zero_grad()  # 3.3 梯度归零
    loss.backward()  # 3.4 计算梯度
    optimizer.step()  # 3.5 更新梯度
    if i % 300 == 0:
        print('Epoch[{}/{}], loss: {:.6f}'.format(i, 30000, loss.data))

prueba modelo

En la prueba del modelo, generalmente usamos el conjunto de prueba para evaluar el modelo entrenado. En este momento, no necesitamos operaciones relacionadas con gradientes . Solo necesitamos pasar los datos a través del modelo para obtener pérdida, precisión, etc. En la prueba se debe tener en cuenta lo siguiente:

model.eval()  # 设置模型为评估模式，即预测模式
predict = model(x)

dibujo

predict = predict.data.numpy()
plt.scatter(x.data.numpy(), y.data.numpy(), c="r")
plt.plot(x.data.numpy(), predict)
plt.show()

ejecutar en GPU

Determinar si la GPU está disponible torch.cuda.is_available()

1, antorcha.dispositivo(“cuda:0” si antorcha.cuda.is_disponible() de lo contrario “cpu”)

dispositivo(tipo='cuda', índice=0) #usar gpu
dispositivo(tipo='cpu') #usar cpu

2. Convierta los parámetros del modelo y los datos de entrada en tipos de soporte cuda

modelo.a(dispositivo)
x_true.a(dispositivo)

3. El resultado del cálculo en la GPU también es el tipo de datos de cuda, que debe convertirse al tipo de tensor de la CPU de numpy o torch

predict = predict.cpu().detach().numpy()
El efecto de detach() es similar al de los datos, pero detach() es una copia profunda y los datos son un valor, que es una copia superficial

código completo

import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt

# 1. 定义数据
x = torch.rand([60, 1])*10
y = x*2 + torch.randn(60,1)


# 2 .定义模型
class Lr(nn.Module):
    def __init__(self):
        super(Lr, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out


# 2. 实例化模型，loss，和优化器
model = Lr()
# 损失函数
criterion = nn.MSELoss()
# 优化器
optimizer = optim.SGD(model.parameters(), lr=1e-3)
# 3. 训练模型
for i in range(30000):
    out = model(x)  # 3.1 获取预测值
    loss = criterion(y, out)  # 3.2 计算损失
    optimizer.zero_grad()  # 3.3 梯度归零
    loss.backward()  # 3.4 计算梯度
    optimizer.step()  # 3.5 更新梯度
    if i % 300 == 0:
        print('Epoch[{}/{}], loss: {:.6f}'.format(i, 30000, loss.data))

# 4. 模型评估
model.eval()  # 设置模型为评估模式，即预测模式
predict = model(x)
predict = predict.data.numpy()
plt.scatter(x.data.numpy(), y.data.numpy(), c="r")
plt.plot(x.data.numpy(), predict)
plt.show()