[Pytorch] Registro de aprendizaje (4) Uso de Pytorch para realizar regresión lineal

En las secciones anteriores, se involucraron modelos lineales simples. Este capítulo utilizará las herramientas proporcionadas por pytorch para implementar la regresión lineal. Introduciremos cosas como el módulo, la construcción de la función de pérdida, la construcción del optimizador de descenso de gradiente estocástico, etc. Estas cosas serán proporcionadas por pytorch, por lo que la función principal de este capítulo es cómo utilizar las herramientas proporcionadas por pytorch para ayudarnos a realizar la construcción de modelos lineales de manera más conveniente .

Primero que nada, revisemos lo que dijimos antes: el primer paso es determinar el modelo lineal y luego definir la función de pérdida para la optimización. Al optimizar en pytorch, se usa sgd (descenso de gradiente estocástico), y el paso principal del uso de sgd es solicitar gradiente) de cada función de pérdida con respecto al peso . Este es el paso de optimización. estar hecho. A continuación, comenzamos a utilizar las herramientas proporcionadas por pytorch para implementar el modelo lineal, aunque el siguiente código puede ser más problemático, tiene mejor escalabilidad, es decir, se puede usar para hacer muchas cosas.

Preparar conjunto de datos

Construya un modelo con clase (heredada de nn.Moudle) para calcular y_hat

Función de pérdida de construcción y optimizador (usando la API de pytorch)

Escriba el ciclo de entrenamiento (adelante, atrás, actualización; la retroalimentación calcula la pérdida, la retroalimentación calcula el gradiente, el descenso del gradiente estocástico actualiza los pesos)

El conjunto de datos de muestra que preparamos aquí es muy simple, como se muestra a continuación, tanto x como y son matrices de 3 × 1.

x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[2.0], [4.0], [6.0]])

Cuando entrenábamos en el frente, teníamos que buscar derivadas manualmente, en pytorch ya no buscamos derivadas manualmente. Nuestro enfoque debe centrarse en la construcción del gráfico de cálculo . Siempre que el gráfico de cálculo se pueda construir con éxito, el gradiente y similares se calcularán automáticamente y luego podremos optimizarlo. En la Figura 1 se muestra un gráfico computacional simple.

Después de ingresar x, se obtiene y_hat mediante una operación unitaria lineal y luego ingresa a la función de pérdida para obtener el valor de pérdida. Después de calcular el valor de la pérdida, puede invocar la pérdida hacia atrás y luego propagar hacia atrás todo el gráfico de cálculo. La siguiente es la parte del código de la construcción del modelo:

class LinearModel (torch.nn.Module) :        # 必须继承自 torch.nn.Module
    def __init__(self) :                     # 所有的模型至少都要实现 init 和 forward
        super(LinearModel, self).__init__()  # 这行不用管他为什么，直接写上就对了
        self.linear = torch.nn.Linear(1, 1)  # 构造对象，linear 中已经包含了 ω 和 b，两个参数分别为输入输出的 size
                                             # 用 module 构造出来的对象，会自动帮助实现 backward 的过程

    def forward (self, X) :                  # forward 是前馈的过程中所要进行的计算
        y_pred = self.linear (x)
        return y_pred

model = LinearModel()

# 优化器
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters()，lr=0.01)

El siguiente es el proceso de capacitación: este conjunto de procesos se lleva a cabo en el marco y el principio es exactamente el mismo que el de la capacitación manual mencionada anteriormente. Obviamente, usar un marco puede reducir en gran medida la cantidad de código.

for epoch in range(100) :
    y_pred = model(x_data)            # 先在前馈中算y_hat
    loss = criterion(y_pred, y_data)  # 计算损失
    print(epoch, loss)

    optimizer.zero_grad ()            # 一定注意--梯度清零--
    loss.backward()                   # 反向传播
    optimizer.step ()                 # 进行更新


# 训练情况的输出
print('W = '，model.linear.weight.item())
print('b = '，model.linear.bias.item())

# Test Model
x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred ='，y_test.data)

Lo anterior es una rutina completa de entrenamiento modelo.

El código reproducible completo es el siguiente:

import torch

x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[2.0], [4.0], [6.0]])


class LinearModel(torch.nn.Module):          # 必须继承自 torch.nn.Module
    def __init__(self):                      # 所有的模型至少都要实现 init 和 forward
        super(LinearModel, self).__init__()  # 这行不用管他为什么，直接写上就对了
        self.linear = torch.nn.Linear(1, 1)  # 构造对象，linear 中已经包含了 ω 和 b，两个参数分别为输入输出的 size
        # 用 module 构造出来的对象，会自动帮助实现 backward 的过程

    def forward(self, X):                    # forward 是前馈的过程中所要进行的计算
        y_pred = self.linear(x)
        return y_pred


model = LinearModel()

# 优化器
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

for epoch in range(100):
    y_pred = model(x_data)                   # 先在前馈中算y_hat
    loss = criterion(y_pred, y_data)         # 计算损失
    print(epoch, loss)

    optimizer.zero_grad()                    # 一定注意--梯度清零--
    loss.backward()                          # 反向传播
    optimizer.step()                         # 进行更新

# 训练情况的输出
print('W = ', model.linear.weight.item())
print('b = ', model.linear.bias.item())

# Test Model
x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred =', y_test.data)

[Pytorch] Registro de aprendizaje (4) Uso de Pytorch para realizar regresión lineal

Supongo que te gusta