Datenwissenschaft

PyTorch-Tutorial mit linearer Regression

PyTorch-Tutorial mit linearer Regression
PyTorch ist ein Python-basiertes wissenschaftliches Paket, das einen Ersatz von NumPy-Ndarrays als Tensoren bietet, die die GPUs optimal nutzen. Ein weiterer positiver Punkt des PyTorch-Frameworks ist die Geschwindigkeit und Flexibilität, die es während der Berechnung bietet. PyTorch ist eine effiziente Alternative zur Arbeit mit Tensoren unter Verwendung von Tensorflow, das wir zuvor untersucht haben.

PyTorch hat als Berechnungspaket wenige große Vorteile, wie zum Beispiel:

PyTorch wird hauptsächlich von der Data Science-Community angenommen, da es in der Lage ist, neuronale Netze bequem zu definieren. Sehen wir uns dieses Rechenpaket in dieser Lektion in Aktion an.

PyTorch installieren

Nur eine Anmerkung vor Beginn, Sie können für diese Lektion eine virtuelle Umgebung verwenden, die wir mit dem folgenden Befehl erstellen können:

python -m virtualenv pytorch
Quellcode pytorch/bin/aktivieren

Sobald die virtuelle Umgebung aktiv ist, können Sie die PyTorch-Bibliothek in der virtuellen Umgebung installieren, damit Beispiele, die wir als nächstes erstellen, ausgeführt werden können:

pip installieren pytorch

Wir werden in dieser Lektion Anaconda und Jupyter verwenden. Wenn Sie es auf Ihrem Computer installieren möchten, sehen Sie sich die Lektion an, die beschreibt, wie man Anaconda Python unter Ubuntu 18 installiert.04 LTS“ und teilen Sie uns Ihr Feedback mit, wenn Sie auf Probleme stoßen. Um PyTorch mit Anaconda zu installieren, verwenden Sie den folgenden Befehl im Terminal von Anaconda:

conda install -c pytorch pytorch

Wir sehen so etwas, wenn wir den obigen Befehl ausführen:

Sobald alle benötigten Pakete installiert und fertig sind, können wir mit der Verwendung der PyTorch-Bibliothek mit der folgenden Importanweisung beginnen:

Taschenlampe importieren

Beginnen wir mit grundlegenden PyTorch-Beispielen, da wir die Voraussetzungspakete installiert haben.

Erste Schritte mit PyTorch

Da wir wissen, dass neuronale Netze grundsätzlich als Tensoren strukturiert werden können und PyTorch um Tensoren herum aufgebaut ist, gibt es tendenziell eine deutliche Leistungssteigerung. Wir beginnen mit PyTorch, indem wir zuerst die Art der Tensoren untersuchen, die es bietet. Um damit zu beginnen, importieren Sie die erforderlichen Pakete:

Taschenlampe importieren

Als nächstes können wir einen nicht initialisierten Tensor mit einer definierten Größe definieren:

x = Fackel.leer(4, 4)
print("Array-Typ: ".format(x.Typ)) # Typ
print("Array-Form: ".format(x.Form)) # Form
drucken (x)

Wir sehen so etwas, wenn wir das obige Skript ausführen:

Wir haben gerade einen nicht initialisierten Tensor mit einer definierten Größe im obigen Skript erstellt. Zur Wiederholung unserer Tensorflow-Lektion, Tensoren können als n-dimensionales Array bezeichnet werden was es uns ermöglicht, Daten in komplexen Dimensionen darzustellen.

Lassen Sie uns ein weiteres Beispiel ausführen, in dem wir einen Torched-Tensor mit zufälligen Werten initialisieren:

random_tensor = Fackel.Rand(5, 4)
print(random_tensor)

Wenn wir den obigen Code ausführen, sehen wir ein zufälliges Tensorobjekt gedruckt:

Bitte beachten Sie, dass die Ausgabe für den obigen zufälligen Tensor für Sie unterschiedlich sein kann, da sie zufällig ist !

Konvertierung zwischen NumPy und PyTorch

NumPy und PyTorch sind vollständig miteinander kompatibel. Aus diesem Grund ist es einfach, NumPy-Arrays in Tensoren umzuwandeln und umgekehrt. Abgesehen von der Einfachheit, die die API bietet, ist es wahrscheinlich einfacher, die Tensoren in Form von NumPy-Arrays anstelle von Tensoren zu visualisieren, oder nennen Sie es einfach meine Liebe zu NumPy!

Als Beispiel importieren wir NumPy in unser Skript und definieren ein einfaches zufälliges Array:

numpy als np importieren
Array = np.zufällig.Rand(4, 3)
transformierter_tensor = Fackel.from_numpy(array)
print("\n".format(transformierter_tensor))

Wenn wir den obigen Code ausführen, sehen wir das transformierte Tensorobjekt gedruckt:

Versuchen wir nun, diesen Tensor wieder in ein NumPy-Array zu konvertieren:

numpy_arr = transformierter_tensor.numpy()
print(" \n".format(type(numpy_arr), numpy_arr))

Wenn wir den obigen Code ausführen, sehen wir das transformierte NumPy-Array gedruckt:

Wenn wir genau hinschauen, wird sogar die Genauigkeit der Konvertierung beibehalten, während das Array in einen Tensor konvertiert und dann wieder in ein NumPy-Array konvertiert wird.

Tensor-Operationen

Bevor wir unsere Diskussion über neuronale Netze beginnen, sollten wir die Operationen kennen, die auf Tensoren ausgeführt werden können, während neuronale Netze trainiert werden. Wir werden auch das NumPy-Modul ausgiebig nutzen.

Schneiden eines Tensors

Wir haben uns bereits angesehen, wie man einen neuen Tensor herstellt, lasst uns jetzt einen machen und Scheibe es:

Vektor = Fackel.Tensor([1, 2, 3, 4, 5, 6])
drucken (Vektor[1:4])

Das obige Code-Snippet liefert uns die folgende Ausgabe:

Tensor([2, 3, 4])

Den letzten Index können wir ignorieren:

drucken(vektor[1:])

Und wir werden auch mit einer Python-Liste zurückbekommen, was erwartet wird:

Tensor([2, 3, 4, 5, 6])

Einen schwebenden Tensor herstellen

Lassen Sie uns nun einen schwebenden Tensor erstellen:

float_vector = Fackel.FloatTensor([1, 2, 3, 4, 5, 6])
print(float_vector)

Das obige Code-Snippet liefert uns die folgende Ausgabe:

Tensor ([1., 2., 3., 4., 5., 6.])

Typ dieses Tensors ist:

print(float_vector.dtyp)

Gibt zurück:

Fackel.float32

Arithmetische Operationen an Tensoren

Wir können zwei Tensoren wie alle mathematischen Elemente hinzufügen, wie zum Beispiel:

tensor_1 = Fackel.Tensor([2, 3, 4])
tensor_2 = Fackel.Tensor([3, 4, 5])
tensor_1 + tensor_2

Das obige Code-Snippet gibt uns:

Wir können multiplizieren ein Tensor mit einem Skalar:

tensor_1 * 5

Dies wird uns geben:

Wir können a Skalarprodukt auch zwischen zwei Tensoren:

d_product = Fackel.Punkt(tensor_1, tensor_2)
d_produkt

Das obige Code-Snippet liefert uns die folgende Ausgabe:

Im nächsten Abschnitt betrachten wir höhere Dimensionen von Tensoren und Matrizen.

Matrix-Multiplikation

In diesem Abschnitt werden wir sehen, wie wir Metriken als Tensoren definieren und multiplizieren können, genau wie wir es in der Highschool-Mathematik getan haben.

Wir werden eine Matrix definieren, mit der wir beginnen:

Matrix = Fackel.Tensor([1, 3, 5, 6, 8, 0]).Ansicht(2, 3)

Im obigen Code-Schnipsel haben wir eine Matrix mit der Tensorfunktion definiert und dann mit . angegeben Ansichtsfunktion dass er als 2-dimensionaler Tensor mit 2 Zeilen und 3 Spalten erstellt werden sollte. Wir können mehr Argumente für die Aussicht Funktion zum Angeben weiterer Dimensionen. Beachten Sie nur, dass:

Zeilenanzahl multipliziert mit Spaltenanzahl = Elementanzahl

Wenn wir den obigen 2-dimensionalen Tensor visualisieren, sehen wir die folgende Matrix:

Wir definieren eine weitere identische Matrix mit einer anderen Form:

matrix_b = Fackel.Tensor([1, 3, 5, 6, 8, 0]).Ansicht(3, 2)

Wir können nun endlich die Multiplikation durchführen:

Fackel.matmul(matrix, matrix_b)

Das obige Code-Snippet liefert uns die folgende Ausgabe:

Lineare Regression mit PyTorch

Lineare Regression ist ein maschineller Lernalgorithmus, der auf überwachten Lerntechniken basiert, um Regressionsanalysen an unabhängigen und abhängigen Variablen durchzuführen. Schon verwirrt? Lassen Sie uns die lineare Regression in einfachen Worten definieren.

Die lineare Regression ist eine Technik, um die Beziehung zwischen zwei Variablen herauszufinden und vorherzusagen, wie viel Veränderung der unabhängigen Variablen wie viel Veränderung der abhängigen Variablen verursacht. Zum Beispiel kann der lineare Regressionsalgorithmus angewendet werden, um herauszufinden, um wie viel sich der Preis für ein Haus erhöht, wenn seine Fläche um einen bestimmten Wert erhöht wird. Oder wie viel PS in einem Auto basierend auf seinem Motorgewicht vorhanden sind. Das zweite Beispiel mag seltsam klingen, aber Sie können immer seltsame Dinge ausprobieren und wer weiß, dass Sie mit Linear Regression eine Beziehung zwischen diesen Parametern herstellen können!

Die lineare Regressionstechnik verwendet normalerweise die Gleichung einer Linie, um die Beziehung zwischen der abhängigen Variablen (y) und der unabhängigen Variablen (x) darzustellen:

y = m * x + c

In der obigen Gleichung:

Da wir nun eine Gleichung haben, die die Beziehung unseres Anwendungsfalls darstellt, werden wir versuchen, einige Beispieldaten zusammen mit einer Diagrammvisualisierung einzurichten. Hier sind die Beispieldaten für Hauspreise und deren Größen:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.array(house_prices_array, dtype=np.Schwimmer32)
house_price_np = house_price_np.umformen(-1,1)
house_price_tensor = Variable(Fackel.from_numpy(house_price_np))
house_size = [ 7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.array(house_size, dtype=np.Schwimmer32)
house_size_np = house_size_np.umformen(-1, 1)
house_size_tensor = Variable(Fackel.from_numpy(house_size_np))
# lasst uns unsere Daten visualisieren
Matplotlib importieren.pyplot als plt
plt.Scatter(house_prices_array, house_size_np)
plt.xlabel("Hauspreis $")
plt.ylabel("Hausgrößen")
plt.title("Hauspreis $ VS Hausgröße")
plt

Beachten Sie, dass wir Matplotlib verwendet haben, eine hervorragende Visualisierungsbibliothek. Lesen Sie mehr darüber im Matplotlib-Tutorial. Wir sehen das folgende Diagramm, sobald wir das obige Code-Snippet ausführen:

Wenn wir eine Linie durch die Punkte ziehen, ist sie vielleicht nicht perfekt, aber es reicht immer noch für die Art der Beziehung, die die Variablen haben. Nachdem wir unsere Daten gesammelt und visualisiert haben, möchten wir eine Vorhersage darüber treffen, wie groß das Haus sein wird, wenn es für 650.000 US-Dollar verkauft würde.

Das Ziel der Anwendung der linearen Regression ist es, eine Linie zu finden, die mit minimalem Fehler zu unseren Daten passt. Hier sind die Schritte, die wir ausführen werden, um den linearen Regressionsalgorithmus anzuwenden zu unseren Daten:

  1. Konstruieren Sie eine Klasse für die lineare Regression
  2. Definieren Sie das Modell aus dieser linearen Regressionsklasse
  3. Berechnen Sie den MSE (mittlerer quadratischer Fehler)
  4. Führen Sie eine Optimierung durch, um den Fehler zu reduzieren (SGD i.e. stochastischer Gradientenabstieg)
  5. Backpropagation durchführen
  6. Machen Sie schließlich die Vorhersage

Beginnen wir mit der Anwendung der obigen Schritte mit korrekten Importen:

Taschenlampe importieren
von der Fackel.Autograd-Importvariable
Taschenlampe importieren.nn als nn

Als nächstes können wir unsere lineare Regressionsklasse definieren, die vom PyTorch neuronalen Netzwerkmodul erbt:

Klasse LinearRegression(nn.Modul):
def __init__(self,input_size,output_size):
# Superfunktion erbt von nn.Modul, damit wir von nn auf alles zugreifen können.Modul
super(lineareRegression,selbst).__drin__()
# Lineare Funktion
selbst.linear = nn.Linear(input_dim,output_dim)
def vorwärts(selbst,x):
kehre selbst zurück.linear(x)

Da wir nun mit der Klasse fertig sind, definieren wir unser Modell mit der Eingabe- und Ausgabegröße von 1:

input_dim = 1
output_dim = 1
model = LinearRegression(input_dim, output_dim)

Wir können den MSE definieren als:

mse = nn.MSELloss()

Wir sind bereit, die Optimierung zu definieren, die an der Modellvorhersage für die beste Leistung durchgeführt werden kann:

# Optimierung (Parameter finden, die Fehler minimieren)
Lernrate = 0.02
Optimierer = Taschenlampe.optim.SGD (Modell.parameter(), lr=learning_rate)

Wir können endlich eine Darstellung für die Verlustfunktion in unserem Modell erstellen:

verlustliste = []
Iterationsnummer = 1001
für Iteration im Bereich(iteration_number):
# Optimierung mit Nullgradient durchführen
Optimierer.null_grad()
Ergebnisse = Modell(house_price_tensor)
loss = mse(results, house_size_tensor)
# Berechnen Sie die Ableitung, indem Sie rückwärts gehen
Verlust.rückwärts()
# Parameter aktualisieren
Optimierer.Schritt()
# Ladenverlust
Verlustliste_.anhängen (Verlust.Daten)
# Druckverlust
if(Iteration % 50 == 0):
print('Epoche , Verlust '.Format (Iteration, Verlust.Daten))
plt.plot(range(iteration_number),loss_list)
plt.xlabel("Anzahl der Iterationen")
plt.ylabel("Verlust")
plt

Wir haben mehrfach Optimierungen an der Verlustfunktion durchgeführt und versuchen zu visualisieren, wie viel Verlust zu- oder abgenommen hat. Hier ist der Plot, der die Ausgabe ist:

Wir sehen, dass bei einer höheren Anzahl von Iterationen der Verlust gegen Null geht. Das bedeutet, dass wir bereit sind, unsere Vorhersage zu treffen und zu zeichnen:

# unseren Autopreis vorhersagen
vorhergesagt = model(house_price_tensor).Daten.numpy()
plt.Scatter(house_prices_array, house_size, label = "Originaldaten",color ="red")
plt.Scatter(house_prices_array, vorhergesagt, label = "vorhergesagte Daten", color ="blue")
plt.Legende()
plt.xlabel("Hauspreis $")
plt.ylabel("Hausgröße")
plt.title("Original vs. vorhergesagte Werte")
plt.Show()

Hier ist der Plot, der uns bei der Vorhersage helfen wird:

Fazit

In dieser Lektion haben wir uns ein hervorragendes Berechnungspaket angesehen, mit dem wir schnellere und effizientere Vorhersagen und vieles mehr machen können much. PyTorch ist beliebt, weil es uns ermöglicht, neuronale Netzwerke mit Tensoren auf grundlegende Weise zu verwalten manage.

Installieren Sie Ulauncher auf dem Ubuntu Linux Desktop Application Launcher
Ulauncher ist eine einfache Software, mit der Benutzer die installierten Anwendungen starten und die vorhandenen Dateien und Verzeichnisse mit der Be...
So installieren Sie PHP 8.0 unter Ubuntu 20.04 (LTS) und 20.10
PHP ist eine universelle, serverseitige Skriptsprache, die verwendet werden kann, um dynamische Webinhalte zu erstellen, Datenbankverwaltung durchzufü...
So installieren Sie KeePass 2.36 auf Ubuntu 17.04 und darunter
KeePass 2.36 wurde kürzlich veröffentlicht und ist eine sichere Passwortverwaltungsanwendung für Personen, die ihre persönlichen Daten schützen möchte...