[PYTHON] Versuchen Sie, eine lineare Regression mit Pytorch mit Google Colaboratory zu implementieren

Für Anfänger! Es wird davon ausgegangen, dass Sie über Grundkenntnisse in Deep Learning verfügen. Implementieren wir die lineare Regression mit Pytorch, einer Bibliothek für maschinelles Lernen. Es ist einfach und daher eine großartige Einführung in das maschinelle Lernen.

Was ist Pytorch?

Eine Open-Source-Bibliothek für maschinelles Lernen für Python, die ursprünglich von der Facebook-Forschungsgruppe für künstliche Intelligenz entwickelt wurde. Die Lesung ist Kuchenfackel.

Es ist in den letzten Jahren unter den Deep Learning-Bibliotheken populär geworden. Es wird empfohlen, da es sehr einfach zu beschreiben ist.

Was ist Google Colaboratory?

Es handelt sich um eine Python-Ausführungsumgebung, die von Google kostenlos zur Verfügung gestellt werden kann.

Die GPU kann ebenfalls verwendet werden und die für das maschinelle Lernen erforderlichen Bibliotheken sind vorinstalliert. Es ist schwierig, eine maschinelle Lernumgebung lokal zu erstellen, daher werde ich dieses Mal Google Colaboratory verwenden.

Weiter unten finden Sie Informationen zur Verwendung. Sie können es in ca. 1 Minute verwenden. https://qiita.com/shoji9x9/items/0ff0f6f603df18d631ab

Versuchen Sie, eine lineare Regression zu implementieren

Installieren Sie die erforderlichen Bibliotheken.

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

Erstellen wir ein zufälliges Verteilungsmodell und zeichnen es auf. Lineare Regression auf dieser Figur.

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")

Wenn ich es starte, denke ich, dass die folgende Abbildung ausgegeben wird.

Definiert ein Modell für die lineare Regression. Es erbt von nn.Module und definiert in init ein Modell, das die Größe der Ein- und Ausgänge angibt.

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

Korrigieren Sie den Startwert der Zufallszahl. Erstellen Sie eine Instanz des linearen Regressionsmodells.

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

Definieren Sie eine Funktion, die Modellparameter abruft.

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

Definieren Sie die zu zeichnende Funktion. Das Extrahieren von Parametern aus dem Modell definiert 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()

Lassen Sie uns die Figur zeichnen, bevor wir lernen. Sie können sehen, dass die rote Linie ausgeschaltet ist, weil es vor dem Lernen ist.

plot_fit("initial Model")

Jetzt ist es Zeit, sich auf das Lernen vorzubereiten. Die Verlustfunktion ist als quadratischer mittlerer Fehler definiert, und die Lernmethode ist als stochastische Gradientenabstiegsmethode definiert. Die Lernrate beträgt 0,01.

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

Lass uns lernen! Die Epoche ist auf 100 eingestellt. Notieren Sie den Verlust.

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()

Werfen wir einen Blick auf den Lernprozess.

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

Sie können sehen, dass Sie lernen. Lassen Sie uns die Figur nach dem Training zeichnen.

plot_fit("Trained Model")

Sie können sehen, dass Sie richtig lernen.

das ist alles. Danke für deine harte Arbeit!

Ich habe versucht, lineare Regression mit Pytorch zu lernen. Pytorch und Google Colaboratory machen es ziemlich einfach, maschinelles Lernen zu erleben. Probieren Sie es aus! !!