[PYTHON] Essayez d'implémenter la régression linéaire à l'aide de Pytorch avec Google Colaboratory

Pour les débutants! On suppose que vous avez une connaissance de base de l'apprentissage profond. Implémentons la régression linéaire à l'aide de Pytorch, une bibliothèque d'apprentissage automatique. C'est facile, c'est donc une excellente introduction à l'apprentissage automatique.

Qu'est-ce que Pytorch?

Une bibliothèque d'apprentissage automatique open source pour Python qui a été initialement développée par le groupe de recherche sur l'intelligence artificielle de Facebook. La lecture est une torche à tarte.

Il est devenu populaire ces dernières années parmi les bibliothèques de Deep Learning. Il est recommandé car il est très facile à décrire.

Qu'est-ce que Google Colaboratory?

C'est un environnement d'exécution python qui peut être utilisé gratuitement fourni par Google.

Le GPU peut également être utilisé et les bibliothèques requises pour l'apprentissage automatique sont préinstallées. Il est difficile de créer un environnement d'apprentissage automatique localement, donc cette fois j'utiliserai Google Colaboratory.

Voir ci-dessous pour savoir comment l'utiliser. Vous pourrez l'utiliser en 1 minute environ. https://qiita.com/shoji9x9/items/0ff0f6f603df18d631ab

Essayez de mettre en œuvre une régression linéaire

Installez les bibliothèques requises.

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

Créons un modèle de distribution aléatoire et tracons-le. Régression linéaire sur cette figure.

x = torch.randn(100, 1) * 10
y = x + torch.randn(100, 1) * 3
plt.plot(x.numpy(), y.numpy(), "o")
plt.ylabel("y")
plt.xlabel("x")

Lorsque je l'exécute, je pense que la figure suivante est sortie.

Définit un modèle de régression linéaire. Il hérite de nn.Module et définit un modèle dans init qui spécifie la taille des entrées et des sorties.

class LR(nn.Module):
  def __init__(self, input_size, output_size):
    super().__init__()
    self.linear = nn.Linear(input_size, output_size)
  def forward(self, x):
    pred = self.linear(x)
    return pred

Fixez la graine du nombre aléatoire. Créez une instance du modèle de régression linéaire.

torch.manual_seed(1)
model = LR(1, 1)

Définissez une fonction qui récupère les paramètres du modèle.

[w, b] = model.parameters()
def get_params():
  return (w[0][0].item(), b[0].item())

Définissez la fonction à tracer. L'extraction des paramètres du modèle définit y1.

def plot_fit(title):
  plt_title = title
  w1, b1 = get_params()
  x1 = np.array([-30, 30])
  y1 = w1*x1 + b1
  plt.plot(x1, y1, "r")
  plt.scatter(x, y)
  plt.show()

Tracons le chiffre avant d'apprendre. Vous pouvez voir que la ligne rouge est éteinte car c'est avant l'apprentissage.

plot_fit("initial Model")

Il est maintenant temps de se préparer à apprendre. La fonction de perte est définie comme l'erreur quadratique moyenne, et la méthode d'apprentissage est définie comme la méthode de descente de gradient stochastique. Le taux d'apprentissage est de 0,01.

criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

Apprenons! L'époque est fixée à 100. Enregistrez la perte.

epochs = 100
losses = []
for i in range(epochs):
  y_pred = model.forward(x)
  loss = criterion(y_pred, y)
  print("epoch:", i, "loss:", loss.item())
  
  losses.append(loss)
  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

Jetons un coup d'œil au processus d'apprentissage.

plt.plot(range(epochs), losses)
plt.ylabel("Loss")
plt.xlabel("epoch")

Vous pouvez voir que vous apprenez. Tracons le chiffre après l'entraînement.

plot_fit("Trained Model")

Vous pouvez voir que vous apprenez correctement.

c'est tout. Je vous remercie pour votre travail acharné!

J'ai essayé d'apprendre la régression linéaire en utilisant pytorch. Pytorch et Google Colaboratory facilitent l'expérience de l'apprentissage automatique, alors essayez-le! !!