Pytorch Tutorial

Pytorch ist eine Open-Source-Bibliothek mit maschinellem Lernen, die für Python verwendet wird. Das Forschungsteam von Facebooks künstlichem Intelligenz hat es ursprünglich erstellt und als Grundlage für die Pyro -Software von Uber für probabilistische Programmierung dient. Es handelt sich um ein mathematisches Toolkit.

Da es unkompliziert und anpassungsfähig ist, ist die Pytorch -API bei Akademikern und Forschern beliebt und schafft neue Deep -Learning -Modelle und Anwendungen. Aufgrund der weit verbreiteten Verwendung gibt es bereits zahlreiche Erweiterungen für Nischenanwendungen wie Text, Computer Vision und Audio-Daten sowie potenziell zu verwendende vorgebrachte Modelle.

Merkmale

Die wichtigsten Eigenschaften von Pytorch sind:

Einfach zu verwenden

Da Pytorch eine intuitive API hat und auf Python angewiesen ist, gilt sie als relativ einfach zu bedienen. Die Codeausführung wird durch dieses Framework einfach gemacht.

Python -Verwendung

Dieses Modul interagiert nahtlos mit dem Python Data Science STAC und gilt als pythonisch. Infolgedessen kann es alle Funktionen und Dienste nutzen, die die Python -Umgebung bietet.

Rechendiagramme

Pytorch bietet eine effektive Umgebung für dynamische Rechendiagramme. Dies ermöglicht die Änderung der Laufzeit durch den Benutzer.

Tools und Bibliotheken

Eine lebendige Gemeinschaft von Forschern und Schöpfer hat ein umfassendes Netzwerk von Tools und Bibliotheken für die Verbreitung von Pytorch und die Förderung des Fortschritts in Bereichen wie Computer Vision und Verstärkungslernen eingerichtet.

Vorteile von Pytorch

• Es ist leicht zu verstehen und einfach zu codieren, da es auf Python basiert
• Ermöglicht ein einfaches Debuggen mit beliebten Python-Tools
• Pytorch ist einfach zu skalieren und bietet hervorragende Unterstützung für die beliebtesten Cloud -Plattformen
• Konzentriert seine kleine Gemeinschaft auf Open-Source
• Hat die Möglichkeit, Lernmodelle im Open Neural Network Exchange (ONNX) Common Format zu exportieren

Unterschied zwischen Fackel und Pytorch

Torch (Torch7) ist eine Freeware -Bibliothek für maschinelles Lernen und ein wissenschaftliches Computer -Framework, das auf der Programmiersprache basiert und in der Regel über die LUA -Schnittstelle zugegriffen wird. Es wird nicht mehr aktiv entwickelt.

Pytorch ist die Bibliothek, die auf einer Fackel basiert, da sie unkompliziert und anpassungsfähig ist. In Pytorch zeigt „PY“ den Python an, in dem die "Fackel" seine frühere Taschenbibliothek widerspiegelt.

So installieren Sie Pytorch

Denken Sie daran, dass Python installiert ist, insbesondere Version 3.7 oder höher, bevor Sie Pytorch konfigurieren. Python kann mit Anaconda installiert werden. Nachdem wir unsere Python -Umgebung eingerichtet haben, werden wir zu unserem nächsten Schritt zur Installation von Pytorch fortfahren.

Zunächst müssen wir eine virtuelle Umgebung für Conda schaffen, in der wir alle unsere Pakete installieren und die Umgebung festlegen möchten.

$ conda create -n pytorch python = 3.7

Conda ist ein Umgebungsmanager, mit dem Sie das Paket für maschinelles Lernprogramm installieren können. Wenn Sie mit einer anderen Version von Python arbeiten müssen, müssen Sie nicht darauf wechseln. Conda verwaltet es automatisch. Sie müssen nur einige Befehle verwenden, um Ihre Umgebung entsprechend Ihrer Wahl zu erstellen.

Wo Create ein Schlüsselwort ist, um dem Compiler eine neue Umgebung für Pytorch zu erstellen, die das „Python 3) verwendet.7 ”Version. Wenn unsere Pakete erfolgreich heruntergeladen werden, werden Ihre Erlaubnis zur Installation aufgefordert oder nicht.

Wenn Ihre Umgebung erfolgreich erstellt wird, wird die Ausgabe angezeigt, wie im folgenden Snippet gezeigt:

Lassen Sie uns mit der Pytorch -Installation beginnen:

Öffnen Sie den folgenden Link und gehen Sie zur Pytorch -Website. Gehen Sie zur Registerkarte "Erste Schritte" und klicken Sie lokal auf Starten.

https: // pytorch.org/starten/lokal/

Eine Zone wie die in der folgenden Figur wird zu sehen. Der erste Selektor ist Pytorch -Build und wählen stabil (1.12.1) Aus den angegebenen Optionen. Jetzt ist das Feld der zweiten Auswahl Ihre Wahl und Sie können das Betriebssystem gemäß Ihren Anforderungen auswählen. Wir werden Windows -Betriebssystem aus den angegebenen Optionen auswählen, da wir Windows verwenden, um unsere Aufgaben auszuführen. Die dritte Registerkarte ist ein Paket. Wir werden Conda aus den angegebenen Optionen auswählen. Wenn wir ein anderes Paket verwenden, werden wir dieses Paket auswählen.

Wählen Sie in der zweiten letzten Option den Namen der Sprache aus, die Sie verwenden, und in unserem Fall wird dies Python sein, damit wir sie aus den angegebenen Optionen auswählen. Endlich werden wir die CPU aus den angegebenen Optionen auswählen, da wir die CPU als unsere Computerplattform verwenden. Wenn wir eine andere Plattform wie CUDA verwenden, wählen Sie CUDA aus.

Nach Auswahl aller Optionen aus den oben angegebenen Selektoren wird im Feld unten ein Befehl angezeigt. Kopieren Sie diesen Befehl und führen Sie diesen Befehl in Ihrer Conda -Eingabeaufforderung aus.

Im vorherigen Befehl wird Conda angewiesen, den Pytorch und andere Bibliotheken, Torchvision und Torchaudio, zu installieren, wo Torchvision die Bibliothek von Python ist. Es wurde entwickelt, um Tests und Studien im Bereich Computer Vision einfacher zu machen. Es verfügt über Modellarchitekturen, gemeinsame Bildtransformationen und andere beliebte Datensätze für Computer Vision.

Torchaudio ist auch ein Paket von Pytorch und wurde für die Audio- und Signalverarbeitung von Computern erstellt. Es verfügt auch über beliebte Datensätze, I/O und allgemeine Audio -Transformationen.

Wenn alle unsere Pakete heruntergeladen werden, werden Sie um Erlaubnis gebeten, ob Sie damit fortfahren möchten oder nicht.

Aktivieren Sie nun zu unserem nächsten Schritt, um unsere Pytorch -Pakete zu aktivieren. Dabei werden wir den folgenden Befehl in der Anaconda -Eingabeaufforderung ausführen:

$ conda aktivieren pytorch

Das Aktivieren unserer Pytorch -Pakete mit dem zuvor in diesem Aktivität erwähnten Befehl ist nun das Schlüsselwort, mit dem Conda die bereits installierte Pytorch -Bibliothek aktiviert.

Wir können überprüfen, indem wir Python starten, dass die folgende Ausgabe angezeigt wird, wenn es ausgeführt wird:

Danach müssen wir die Taschenlampe darin importieren; Wenn ein Modul nicht gefunden wird, bedeutet dies, dass Ihre Installation nicht korrekt war. In diesem Fall war die Installation korrekt, so dass kein Fehler angezeigt wurde.

Jetzt können wir einen Torch -Tensor erstellen, um zu prüfen, ob es richtig funktioniert. sagen wir:

$ x = Fackel.Rand (3)
$ print (x)

Im vorherigen Befehl haben wir eine Variable „x“ erstellt und der Wertbereichen zugewiesen.Rand, wobei Rand einen zufälligen Wert angibt. Anschließend zeigten wir die Fackelausgabe für ihn mit der Druckfunktion und übergeben sie unsere Variable „x“. Der folgende Screenshot zeigt, wie Tensorwerte angezeigt werden:

Überprüfen Sie nun die Fackelversion, importieren wir die Taschenlampe und verwenden die Druckfunktion den Wert „Torch__version__“, um sie zu überprüfen.

$ Import Taschenlampe
$ print (Taschenlampe.__Ausführung__)

Hier ist die Ausgabe für den folgenden Befehl, wie in der vorherigen Abbildung gezeigt. Und jetzt ist unsere Pytorch -Umgebung erfolgreich für unsere Verwendung installiert.

Pytorch Deep Learning Model Lebenszyklus

Projekte mit maschinellem Lernen sind nicht einfach. Sie beinhalten einen laufenden Zyklus zur Verbesserung der Daten, des Modells und der Bewertung. Dieser Zyklus ist wichtig für die Erstellung eines maschinellen Lernmodells, da er die Verwendung von Simulation und Ergebnissen zur Verbesserung Ihres Datensatzes betont.

Seit mehr als zehn Jahren ist Deep Learning ein wichtiges Thema und hat zum verstärkten Fokus des Marktes auf ML beigetragen. Die Entwicklung vieler Tools, die bei der Herstellung von ML -Modellen helfen, hat die ML -Branche dazu veranlasst, Erfahrung zu erleben.

5 Hauptschritte für das Lebenszyklus des Deep Learning Model sind:

1. Daten vorbereiten
2. Modal Definition
3. Training des Modal
4. Modale Bewertung
5. Vorhersage

Beispiel 1

In diesem Beispiel werden wir die Torchvision-Bibliothek mit einem vorinstallierten „FashionMnist“ -Datensatz mit der Torchvision-Bibliothek von Pytorch verwenden, die über reale Objekte verfügt.

Wenn es um die Arbeit mit Daten geht, verwendet Pytorch seine beiden Hauptelemente, die Taschenlampe sind.Utils.Daten.Dataloader und Taschenlampe.Utils.Daten.Datensatz, sodass wir Ihre Daten oder vorinstallierten Datensätze verwenden können. Der Datenlader wickelt ein iterable um den Datensatz, damit die Proben erfasst werden können.

TOTENSOR wird für die Bildverbesserung und -veränderung verwendet, während das NN -Paket eine Sammlung praktischer Verlustfunktionen spezifiziert, die normalerweise verwendet werden. FashionMnist-Datensatz funktioniert für Bilder mit Elementen im Bereich von 0-255. Sie können auch angepasste Transformationen entsprechend Ihren Anforderungen schreiben. Schauen wir uns den Code dieses Szenarios im folgenden Bild an:

Im oberen Code haben wir unserem Training_Data einen Datensatz von FashionMnist zugewiesen. Dieser Datensatz, der dem Training_Data zugewiesen ist. In diesem Fall werden wir den FashionMnist -Datensatz einsetzen. Für alle Tackvision -Datensätze sind zwei Parameter erforderlich. Einer wird transformiert und der andere ist target_transform. Diese beiden Parameter ändern die Beschriftungen und Proben.

Die in der begleitenden Figur gezeigten Ergebnisse erscheinen nach dem Ausführen des Codes. Es wird den Datensatz aus der Bibliothek herunterladen.

Jetzt wird der Datensatz nach der Ausführung unseres Codes heruntergeladen. Wir werden den Datensatz als Parameter an Dataloader übergeben. Dies hilft uns bei der Probenahme, Mischung, Datenladung von Multiprozess und automatisch Batching. In unserem Fall weisen wir unserem Batch_Size 64 zu. Infolgedessen definieren wir 64 Chargengrößen. Jedes Element von Dataloader Iterable kann eine Ausgabe einer Stapel von 64 Beschriftungen und Funktionen zurückgeben.

Wir haben den Zug für wahr gesetzt, weil er das Modul festlegt. Der Download ist auch auf den True -Modus gesetzt, da wir den Datensatz herunterladen müssen, um unser Modul mit Hilfe dieses Datensatzes zu trainieren. Wir haben Daten an unseren Stammparameter weitergeleitet, da wir die Informationen in Form von Daten übergeben werden.

Nachdem wir unseren Code ausgeführt haben. Es wird die Bilder herunterladen.

Wenn wir uns nun in Richtung Modalerstellung bewegen, werden wir eine Klasse namens Neural Network erstellen, die NN erben wird. Das Modul ist ein Parameter. Wir werden eine Funktion namens Init erstellen. In dieser Funktion werden wir die Schichten des Netzwerks definieren. Als nächstes erstellen wir eine Funktion mit dem Namen vorwärts, während der Name seinen Zweck verdeutlicht. Wir werden angeben, wie die Daten in der Vorwärtsfunktion über das Netzwerk übertragen werden.

Linear ist eine Klasse von NN -Bibliothek, die eine lineare Transformation zu den Daten anwendet, die wir an sie übergeben. Wir bestehen 28*28 als Anzahl der Dimensionen an die lineare Klasse. Relu ist eine Funktion auf NN -Paketen, die die negativen Elemente behandelt, indem sie sie durch 0 ersetzt. Um den gesamten Prozess für das neuronale Netzwerk zu beschleunigen, verwenden wir die Ressourcen unserer Grafikkarte, wenn sie für die Nutzung verfügbar sind. Schauen wir uns den Code dieses Szenarios im folgenden festgelegten Bild an:

Die Init -Funktion ist die Initialisierungsmethode in Pytorch. Es ist erforderlich, dass Pytorch die Verzeichnisse mit Bibliotheken erhalten. Darin bestanden wir es selbstfunktion. Während wir in der Vorwärtsfunktion Eingangstensoren als Parameter übergeben, und die Vorwärtsfunktion die Ausgangstensoren zurückgibt, indem Sie Ihre Eingangszensoren berechnen. Darin übergeben wir zwei Parameter, „Selbst“ und „X“ an die Vorwärtsfunktion. Die Vorwärtsfunktion definiert auch, wie Ihr Modul von der Eingabe bis zur Ausgabe funktioniert.

Anschließend wird die Ausgabe des vorherigen Code im folgenden Screenshot angezeigt:

Nach dem Prozess, den wir in den vorherigen Schritten durchgeführt haben, werden wir unser Modell trainieren. Wir müssen einen Optimierer und eine Verlustfunktion verwenden, um dies zu erreichen. Ein Verlustfunktionsverfahren bestimmt die Diskrepanz zwischen dem aktuellen Ausgang eines Algorithmus und der erwarteten Ausgabe. Optimierer hilft dem System, die beste Wahl aus einer Reihe möglicher Optionen auszuwählen, die einfach sind und keine Einschränkungen ausnutzen. Schauen wir uns den Code dieses Szenarios im unten angegebenen Bild an:

Epoche ist ein Parameter, der angibt, wie oft ein Lernalgorithmus durch den Datensatz ausgeführt wird, den wir für das Training bereitgestellt haben. In unserem Fall haben wir es auf 5 gesetzt, was bedeutet.

Nach der Initialisierung von Epochen werden wir eine für die Schleife verwenden, die die Häufigkeit von „T“ ausführen wird, die wir in Epochen deklariert haben. In dieser Schleife wird die geschulte Funktion 5 Mal ausgeführt und werden sie ausgeführt. Nachdem die Ausführung "für die Schleife" durchgeführt wurde, wird der Text "Fertig" gedruckt, der den Text "Fertig" druckt.

Der folgende Ausschnitt zeigt die Ausgabe der von Epochen geschulten Funktion an:

Beispiel 2

In diesem Fall reicht die Lösung des Problems der Anpassung y = sin (x) mit einem Polynom dritter Ordnung aus.

Methode 1

Das von Pytorch bereitgestellte Optim-Paket wird in dieser Technik verwendet. "Fackel.Optim “ist ein Pytorch -Paket, das für die Implementierung verschiedener Optimierungstechniken verantwortlich ist. Die Mehrheit der häufig verwendeten Techniken ist bereits implementiert, und die Schnittstelle ist ausreichend offen, dass die zukünftige einfache Integration komplexerer Integration ebenfalls möglich ist. Durch manuelles Ändern der Tensoren, die lernbare Parameter mit Taschenlampe enthalten.Kein Abschluss, die Gewichte unserer Modelle () werden aktualisiert.

Wir werden auch das NN -Paket verwenden, um unser Modal zu deklarieren, aber wir werden RMSPOP verwenden, um das Modell zu optimieren.

Gehen wir zu unserem Code, um einen Tensor zu erstellen. In unserem Fall haben wir zwei Variablen erstellt, "A" und "B". Als Nächst.

Danach werden wir Modal- und Verlustfunktionen mit dem NN -Paket deklarieren. Erstellen Sie einen Optimierer mithilfe des Optim -Pakets, um die Gewichte des Modells in unserem Namen zu ändern. RMSProp wird in diesem Fall verwendet. Das Optim -Paket enthält zahlreiche andere Optimierungstechniken. Der erste Eingang des RMSProp -Konstruktors weist den Optimierer an, für welche Tensoren er geändert werden sollte. Erstellen Sie einen Optimierer mithilfe des Optim -Pakets, um die Gewichte des Modells in unserem Namen zu ändern. RMSProp wird in diesem Fall verwendet. Das Optim -Paket enthält zahlreiche andere Optimierungstechniken. Der Code für die vorherige Erklärung finden Sie im folgenden Spyder -Bildschirm:

Im folgenden Schritt werden wir dann das vorhergesagte Y berechnen, indem wir es myvar übergeben:

$ y_pred = modal (myvar)

Darin ist Y_Predicat die Variable, an die wir die modale Funktion zuweisen, an die der Wert "myvar" übergeben wird. Der Verlust wird dann berechnet und angezeigt. Dies wird durch die Tatsache verursacht, dass Gradienten wann immer dynamisch in Puffer gesammelt werden.rückwärts () wird aufgerufen.

Verlust.rückwärts () bestimmt den Verlustgradienten unter Berücksichtigung des Modals. Wenn die Schrittfunktion eines Optimierers aufgerufen wird, werden die Parameter aktualisiert. Die Eingangsmerkmale der linearen Ebenen werden mit der Gewichtsmatrix multipliziert, um die Ausgangsfunktionen zu erzeugen. Die Eingangsmerkmale werden als eindimensionaler Tensor, der abgerissen wurde, an eine lineare Schicht übergeben und mit der Gewichtsmatrix multipliziert. Am Ende des Codes wird die Ausgabe als Ergebnis der Form der Gleichung angezeigt.

Methode 2

Nach der folgenden Methode verwenden wir Tensor- und Autograd -Pakete. Importieren Sie zuerst unsere Fackel- und Mathematikbibliotheken für dieses Programm und definieren Sie dann unsere Variablen "DTYPE". Hier haben wir die Wertbrenner zugewiesen.Float wie im vorherigen Beispiel durchgeführt und definiert die Variable „Gerät“. Wir weisen erneut die Wertbereichen zu.Geräte („CPU“), mit dem die zu verwendende Plattform definiert wird.

Um Eingänge und Ausgänge zu halten, erstellen Sie Tensoren. Angenommen. Machen Sie Gewichte mit zufälligen Tensoren. Wir benötigen vier Gewichte für ein Polynom der dritten Ordnung: y = a + b x + c x^2 + d x^3 Einstellungsanforderungen. Wir möchten Gradienten bezüglich dieser Tensoren während des Rückwärtspasses berechnen, was durch den Wert _grad = true angezeigt wird.

Berechnen und anzeigen Sie den Verlust unter Verwendung von Tensorfunktionen. Verlust wird zum Tensor mit dem Formular (1,) Verlust. Der skalare Wert des Verlusts wird durch item () zurückgegeben (). Der Code für die vorherige Erklärung finden Sie im folgenden Spyder -Bildschirm:

In diesem Fall muss der Rückwärtspass unseres neuronalen Netzwerks manuell verwaltet werden. Es ist nicht physisch schwer für das unkomplizierte Zweischicht-Netzwerk, dies zu tun. Es kann jedoch für große komplexe Netzwerke schnell kompliziert werden. Glücklicherweise können wir die automatische Differenzierung nutzen, um den Prozess eines Rückwärtspasses in neuronalen Netzwerken zu mechanisieren. Die Autograd -Bibliothek in Pytorch verleiht dieser Funktionalität sehr genau; Während der Verwendung von autodrad charakterisiert der Vorwärtspass eines Netzwerks ein Rechendiagramm. Die Grafik hat Knoten und Kanten; Die Tensoren werden unter Verwendung von Knoten dargestellt, und die Kanten repräsentieren die Methoden, die Ausgangstensoren zurückgeben, indem sie Eingangstensoren als Argumente aufnehmen.

Das Lesen dieses Diagramms hilft dabei, Gradienten leicht zu berechnen. Dies scheint eine schwierige Aufgabe zu sein, aber in Wirklichkeit ist diese Praxis sehr einfach und unkompliziert. Wenn „X“ ein Tensor ist und das Attribut „erfordert Grad“ ist auf wahr eingestellt. Daher ist X ein Tensor, der einen Knoten in einem Rechendiagramm adressiert. X.Grad ist ein weiterer Tensor, der eine Steigung von „X“ für einen Skalarwert hält. Hier zeigen wir eine Sinuswelle mit einem Polynom dritter Ordnung unter Verwendung von Pytorch-Tensoren und Autograd. Jetzt müssen wir die rückwärts gerichtete Pause nicht durch das Netzwerk manuell ausführen.

Methode 3

In diesem Beispiel werden wir das Numpy -Modul verwenden. Numpy ist eine Python-Bibliothek für die Programmiersprache, die erhebliche, mehrdimensionale Arrays und Matrizen unterstützt. Darüber hinaus eine erhebliche Menge an mathematischen Operationen auf hoher Ebene, um diese Arrays zu betreiben. Numpy ist eine generische Plattform für die Berechnung wissenschaftlicher Vorgänge. Es beinhaltet kein tiefes Lernen oder Computerdiagramme.

Mit Numpy Operations können wir leicht ein Polynom dritter Ordnung in eine „Sin“ -Funktion einfügen. Dafür werden wir zuerst Bibliotheken Numpy und Math importieren. Mathematik ist das Paket, das zum Importieren mathematischer Operationen verwendet wird. Schauen wir uns den Code dieses Szenarios im folgenden Bild an:

Wir haben zuerst zwei Variablen mit dem Namen "Var1" und "var2" initialisiert und ihre Funktionen zugewiesen. Hier, NP.Die Linspace -Funktion ist eine Python -Methode, mit der wir numerische Sequenzen erstellen können. Es hilft uns bei der Erzeugung linearer Vektoren. Es ist das gleiche wie das Dickdarmzeichen, aber der einzige Unterschied zwischen dem Dickdarmzeichen und es gibt uns die direkte Kontrolle über die Anzahl der Punkte. Zu dieser Funktion haben wir drei Parameter übergeben, die „-math“ sind.pi ”,„ Mathematik.pi ”und„ 200 “, in denen 200 der Bereich der Berechnung erfolgen wird. Und die zweite Funktion, die wir an var2 übergeben haben.sin (var1) “, mit dem die Sinus der Werte berechnet wird, die in" var1 "gespeichert werden, werden gespeichert.

Als nächstes haben wir vier Variablen mit dem Namen "A", "B", "C" und "D" in diese Variablen initialisiert. Als Nächst.

Definieren Sie anschließend eine andere Variable, "var2_pred", der wir den mathematischen Operation zum Berechnen des Aggregats zuweisen und an die Variable mit dem Namen "Verlust" weitergeben werden. Der Verlust wird für die Berechnung des VAR -Verlusts "var2_pred" verantwortlich sein.

Umzug zum nächsten Schritt, wo wir die IF -Anweisung verwendet haben, die für die Berechnung der Berechnung von „t%10 == 9“ verantwortlich ist, dauert der Modus von „T“ mit dem Wert 10 und erhöht sie um 9 um 9. Es druckt den Verlust dieser Werte aus der vorherigen If -Anweisung.

Nach all diesen Berechnungen, bei denen die für die Schleife endet, fasst er die gesamten Werte zusammen, und der letzte Druckvorgang wird am Ende der für die für die Schleife angezeigte und dadurch angezeigt, wie im Snippet unten gezeigt:

Methode 4

In diesem Code werden wir das Tensor -Paket verwenden. Ein numpy Array und ein Pytorch-Tensor sind theoretisch gleichwertig, da ein Tensor ein mehrdimensionales Array ist, und Pytorch bietet eine Vielzahl von Methoden für die Arbeit mit ihnen. Tensoren sind ein allgemeines wissenschaftliches Computing-Tool, das Gradienten und Rechendiagramme im Hintergrund überwachen kann. Pytorch -Tensoren können mit GPUs ihre numerischen Operationen beschleunigen, im Gegensatz zu Numpy. Ein Pytorch -Tensor kann in wenigen einfachen Schritten auf einer GPU ausgeführt werden.

In diesem Code importierten wir zwei Bibliotheken, Taschenlampe und Mathematik. Da wir in diesem Code und in mathematischen Funktionen eine Taschenlampe verwenden werden, haben wir eine Variable mit dem Namen "DTYPE" definiert. Wir haben DataTypes -Fackel zugewiesen.Float, weil wir mathematische Operationen ausführen, die die Werte in Punkten zurückgeben. Um Dezimalwerte zu speichern, verwenden wir Datatype Float.

Dann haben wir eine weitere Variable mit dem Namen "Gerät" mit Zuweisung von Wert Torch deklariert.Gerät („CPU“), da wir CPU als unsere Plattform in der Pytorch -Installation ausgewählt haben. Wenn wir uns weiterentwickeln, haben wir zwei Variablen namens var1 "und" var2 "initialisiert und ihnen dieselbe Funktion zugewiesen, die wir im vorherigen Beispiel zugewiesen haben. Dann werden vier Variablen erstellen, die "A", "B", "C" und "D" sind, um zufällige Tensoren zu erstellen. Jeder hat seine einzigartige Form; Wir haben auch das Datentyp -Gerät und das DTYPE übergeben, das zu Beginn unseres Codes initialisiert wird. Daher wird es die Ressourcen unserer CPU verwenden und Werte in Form von Dezimalstellen aufnehmen. Es wird angedeutet, dass wir während des Rückwärtspasses Gradienten über solche Tensoren berechnen möchten, indem wir feststellen, dass es Grad = True erfordert. Schauen wir uns den Code dieses Szenarios im folgenden festgelegten Bild an:

Dann haben wir ein Learning_rate = 1E-6 deklariert. Die Lernrate ist auch ein Hyperparameter, der für die Ausbildung neuronaler Netze verwendet wird. Es hat einen sehr geringen Wert, der größer als 0 sein muss.0 und weniger als 1.0, was bedeutet, dass es ein positiver Wert sein muss. Das Lerntempo nimmt mit der zunehmenden Lernrate zu.

Danach werden wir eine Schleife öffnen, die 200 Mal ausgeführt wird und mathematische Operationen in unseren Variablen ausführt. Wo immer t%100 gleich 99 wird, druckt die Schleife die Häufigkeit, mit der sie ausgeführt und gestoppt wird. Danach wird das Ergebnis so veröffentlicht, dass unsere Iteration endet, wie im folgenden Screenshot angezeigt:

Methode 5

Bei dieser Methode erstellen wir unsere Autograd -Funktion mit Pytorch -Unterklassen. Jedes primäre Autograd ist zwei Methoden, die mit Tensoren arbeiten. Die Vorwärtsfunktion nimmt Eingangstensoren an und berechnet die Ausgangstensoren daraus. In Pytorch können wir unseren Autograd -Operator zweifellos charakterisieren, indem wir eine Unterklasse beschreiben.Autograd.Funktion und Ausführung der Vorwärts- und Rückwärtsansätze.

Jetzt werden die Ausgangstensoren als Parameter für die Rückwärtsfunktionen mit einigen Skalarwerten beschafft. Pytorch erleichtert uns, unseren Autograd -Operator zu definieren, indem wir eine Unterklasse erstellen können, die den Gradienten der Eingangstensoren analysiert. Jetzt können wir unseren Autograd -Operator verwenden, indem wir einen Konstruktor initialisieren und eine Methode nennen. Dann werden wir den Tensor mit Eingabedaten als Parameter an diesen Konstruktor übergeben.

Im folgenden Beispiel geben wir unser Modal As an:

$ y = a+b p_3 (c+dx)
y = a+bp3 (c+dx)
anstatt
y = a+bx+cx^2+dx^3
y = a+bx+cx2+dx3

Wir komponieren unsere benutzerdefinierte Autograd -Methode, indem wir die Vorwärts- und Rückwärts von P3 verarbeiten und sie verwenden, um unser Modell auszuführen. Der Code für die folgende Erklärung finden Sie auf dem Spyder -Bildschirm.

Durch die Unterklasse der Fackel können wir unsere einzigartigen Autograd -Funktionen implementieren.Autograd. So funktionieren und in die Praxis um die Vorwärts- und Rückwärtspässe, die Tensoren verwenden. Wir erhalten einen Tensor, der den Eingang während des Vorwärtspasses hält und einen Tensor liefern, der den Ausgang zurückhält. Ein Kontextobjekt namens CTX kann verwendet werden, um Daten zur Verwendung in der Rückwärtsberechnung zu speichern.

Tensoren können erstellt werden, um Eingänge und Ausgabe zu speichern. Angenommen.

Machen Sie Gewichte mit zufälligen Tensoren. Um die Konvergenz zu gewährleisten, sollten die Gewichte für dieses Beispiel einigermaßen nahe dem genauen Ergebnis eingeführt werden: y = a + b * p3 (c + d * x). Es wird angedeutet, dass wir beabsichtigen, einen Gradienten über diese Zuordnungen während eines Rückwärtspass zu generieren, der Grad = True erfordert.

Das folgende Bild zeigt die Ausgabe, die der vorherige Code generiert hat:

Methode 6

Hier werden wir das Modul verwenden, um dieses Problem zu lösen. Nach dem Importieren unserer gewünschten Bibliotheken werden wir Tensoren für die Zuweisung von Eingaben und Ausgängen erklären. Dieses Beispiel kann als lineares neuronales Netzwerk angesehen werden, da die resultierende Ausgabe eine lineare Funktion von (x, x2, x3) ist. Schauen wir uns den Code dieses Szenarios an, das das folgende angebotene Bild ist:

Lassen Sie uns den Tensor (x, x2, x3) bereit machen. Da hat P Form (3) und x.Die Struktur (–1) hat Struktur (200, 1), Streaming-Semantik wird verwendet, um in dieser Situation einen Formsor der Form zu erzeugen (200, 3). Verwenden Sie das NN -Paket, um unser Modell als eine Reihe von Ebenen zu konstruieren. NN ist ein Modul, das andere Module nacheinander anwendet, um seinen Ausgang zu erhalten, der als sequentielles Modul bezeichnet wird. Das lineare Modul behält interne Tensoren für seine Verzerrung und sein Gewicht bei und verwendet eine lineare Funktion, um den Ausgang aus der Eingabe zu berechnen. Verwenden Sie zur Berechnung des Rückspanns Autograd.

A.Grad, b.Grad wird diesem Anruf folgen. Tensoren, die den Gradienten eines Verlusts über die Buchstaben A, B, C und D halten, werden als C bezeichnet.Grad und d.bzw. abschließen. Wir haben den mittleren Quadratfehler (MSE) als unsere Verlustfunktion verwendet, die im NN -Paket zusammen mit anderen prominenten Verlustfunktionen definiert ist.

Vorwärtspass: Berechnen Sie das erwartete y, indem Sie das Modell X geben. Der __call__ -Operator wird von Modulobjekten erweitert, sodass Sie sie genau wie Funktionen aufrufen können. Auf diese Weise stellen Sie dem Modul einen Tensor mit Eingabedaten zur Verfügung, und es gibt einen Tensor der erwarteten Ausgabe zurück. Duplikat- und Druckverlust Die Verlustfunktion liefert einen Tensor, der den Verlust enthält, nachdem sie Tensoren von uns erhalten haben und die wahren und erwarteten Werte von Y enthalten.

Berechnen Sie den Gradienten eines Verlust. Aufgrund der internen Speicherung der Eigenschaften jedes Moduls in Tensoren, für die ein Grad auf True gesetzt werden muss. Sie können auf die Anfangsebene des Modells zugreifen, indem Sie das erste Element aus einer Liste auswählen.

Endlich wird das Ergebnis unter Verwendung der Druckfunktion angezeigt, wenn die gesamte Iteration erfolgreich ausgeführt wird.

Methode 7

Fackel.Das NN -Modul ist im Allgemeinen Pytorchs Hauptbaustein. Definieren Sie zuerst ein NN.Modulobjekt und rufen Sie dann seine Vorwärtsfunktion auf, um sie auszuführen. Diese Betriebsmethode ist objektorientiert. Ein vollständig verbundenes Relu -Netz.

In diesem Fall wird das Modell als spezifische Modul -Unterklasse definiert. Sie müssen Ihr Modell auf diese Weise definieren, wenn Sie möchten, dass es komplexer ist als eine einfache Auflistung aller aktuell vorhandenen Module. Der Code für die vorherige Erklärung finden Sie im folgenden Spyder -Bildschirm:

Berechnen Sie dann den Rückwärts -Durchgang mit autodrad. Die Methode würde den Verlustgradienten für alle Tensoren mit dem erforderlichen Grad = true bestimmen. A.Grad, b.Grad wird diesem Anruf folgen. Tensoren, die den Gradienten des Verlusts über die Buchstaben A, B, C und D halten, werden als C bezeichnet.Grad und d.bzw. abschließen. Wir können auch eine benutzerdefinierte Funktion in Pytorch definieren.

Nach dem Erstellen von Klassenpolynom 3 deklarieren wir Tensoren für das Halten von Eingaben und Ausgaben. In der Funktion werden vier Argumente erstellt und als Mitgliedsparameter zugewiesen. Bei Verwendung mit Modulen hat die als Parameter bekannte Unterklasse von Tensoren eine sehr einzigartige Eigenschaft. Wenn der Parameter als Modulattribute zugewiesen wird, wird er automatisch in der Liste der Parameter des Moduls enthalten und wird in der Liste der Parameter des Moduls angezeigt, e.G., in Parametern () Iterator. Die Parameter () -Methode in jedem NN.Modul ruft die trainierbaren Variablen des Moduls ab. Diese Variablen müssen explizit definiert werden.

Die Vorwärtsfunktion erfordert einen Tensor der Eingabedaten und einen Tensor der Ausgangsdaten. Wir können beliebige Betreiber auf die im Konstruktor definierten Tensoren und Module anwenden. Erstellen Sie einen Optimierer und unsere Verlustfunktion. Die trainierbaren Parameter, die Modellelemente sind und mit der Taschenlampe angegeben sind.nn.Der Parameter im SGD -Konstruktor würde in den Aufruf zum Modell aufgenommen.Parameter (). Berechnen Sie dann im Vorwärtspass das vorhergesagte y (y_pred) und übergeben Sie die Variable "var".Am Ende führen die Null -Gradienten automatisch den Rückwärtspass durch und führen die Gewichte aus.

Stochastischer Gradientenabstieg (SGD) ist ein Optimierer, der zur Familie der Gradientenabstiegsfamilie gehört und eine bekannte Optimierungstechnik für Deep Learning und maschinelles Lernen ist. Der Begriff „stochastisch“ bezieht.

Letztendlich werden wir den Verlust berechnen und ihn drucken, indem wir ihm die für die Berechnung des Verlusts verantwortliche Kriterienfunktion zuweisen. Wir haben das vorhergesagte y und das Modal, das wir trainiert haben. Dann deklarieren Sie, ob Anweisung, die den Modus um 10 von Variablen -T -Werten berechnet, berechnet. Als nächstes wird es um 9 erhöht, und der resultierende Wert von t wird an die Druckfunktion übergeben, zu der der Verlust berechnet wird.

Am Ende des Code wird das Ergebnis erfolgreich ausgeführt, wie in der folgenden Abbildung gezeigt:

Abschluss

Die Anwendung der Pytorch -API für typische Aktivitäten für Deep Learning Model Creation ist das zentrale Ziel des Tutorials. Die Informationen, die Sie in diesem Artikel untersucht haben. Wir haben auch die verschiedenen Möglichkeiten zur Implementierung eines einzelnen Beispiels unter Verwendung verschiedener Module, Numpy, Tensor, Torch und Autograd, diskutiert, indem wir eine neue Autograd -Funktion, Optim -Funktion, NN -Module und auch das benutzerdefinierte NN -Modul erstellen. Die Plattform, mit der unser Code ausgeführt wird, ist Spyder. Sie können andere Plattformen wie Conda, Jupiter und Linux verwenden.