[PYTHON] Remarques sur l'optimisation à l'aide de Pytorch

Comme tensorflow2, basé sur des fonctions, est difficile à utiliser, nous migrons vers Pytorch. Cet article s'adresse aux nostalgiques qui souhaitent créer des fonctions de perte et des méthodes d'optimisation par eux-mêmes, pas aux enfants modernes qui utilisent les packages tels quels. Les fossiles qui disent que "le gradient est calculé à la main" ne sont pas la cible.

Génération de données

Correctement généré

import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.autograd import Variable
import torch.optim as optim

N = 100
a_data =  - 1
b_data = 1
sigma_data = 0.1
x_data = 2 * np.random.rand(N)
y_data = a_data * x_data + b_data + sigma_data * np.random.randn(N)

Lors de l'utilisation d'un package optimisé

Pour les personnes tordues qui veulent créer leur propre fonction Loss.

#Définition variable
a = Variable(torch.randn(1), requires_grad=True)
b = Variable(torch.randn(1), requires_grad=True)

#Conversion de données
x_train = torch.tensor(x_data)
y_train = torch.tensor(y_data)

#Optimisation des paramètres de fonction
optimizer = optim.Adam([a, b])

#Nombre de répétitions
epoch = 4000

loss_epoch = np.zeros(epoch)

for i in range(epoch):
    #Initialisation du dégradé utilisée dans l'optimiseur
    optimizer.zero_grad()
    #Modèle linéaire
    y_hat = a * x_train + b
    #Calcul de la fonction de perte
    loss = (y_train - y_hat).norm()
    loss_epoch[i] = loss.item()
    #Réglage du dégradé
    loss.backward()
    #Effectuer l'optimisation
    optimizer.step()

Lors de l'utilisation uniquement du dégradé

Pour ceux qui ne veulent pas utiliser Optimizer et qui ont plus de rebondissements. Optimisé à l'aide de la méthode du gradient.

#Préparation des paramètres
a = torch.randn(1,requires_grad=True)
b = torch.randn(1,requires_grad=True)

#Conversion de données
x_train = torch.tensor(x_data)
y_train = torch.tensor(y_data)

#Taux d'apprentissage
eta = 0.001

#Nombre de répétitions
epoch = 4000
loss_epoch = np.zeros(epoch)
for i in range(epoch):
    #Commencer l'enregistrement du dégradé
    a.requires_grad_(True)
    b.requires_grad_(True)
    #Prédiction et calcul de la fonction de perte
    y_hat = a * x_train + b
    loss = (y_train - y_hat).norm()
    loss_epoch[i] = loss.item()
    #Réglage du dégradé
    loss.backward()
    #Arrêter d'enregistrer le dégradé
    a.requires_grad_(False)
    b.requires_grad_(False)

    #Mettre à jour avec dégradé
    a = a - eta * a.grad
    b = b - eta * b.grad

Résumé

Il semble facile à utiliser une fois que vous vous êtes habitué à l'enregistrement de la pente et à l'arrêt des parties.

Détails du code

https://github.com/yuji0001/2020Introduction_of_Pytorch

Reference Tutoriels Pytorch (ici).

Author Yuji Okamoto [email protected]