Python Deep Learning - Kurzanleitung

Tiefes strukturiertes Lernen oder hierarchisches Lernen oder kurz gesagt tiefes Lernen gehört zur Familie der Methoden des maschinellen Lernens, die selbst eine Teilmenge des breiteren Feldes der künstlichen Intelligenz sind.

Deep Learning ist eine Klasse von Algorithmen für maschinelles Lernen, die mehrere Schichten nichtlinearer Verarbeitungseinheiten zur Merkmalsextraktion und -transformation verwenden. Jede aufeinanderfolgende Ebene verwendet die Ausgabe der vorherigen Ebene als Eingabe.

Tiefe neuronale Netze, tiefe Glaubensnetzwerke und wiederkehrende neuronale Netze wurden auf Bereiche wie Computer Vision, Spracherkennung, Verarbeitung natürlicher Sprache, Audioerkennung, Filterung sozialer Netzwerke, maschinelle Übersetzung und Bioinformatik angewendet, wo sie Ergebnisse erzielten, die mit und in einigen Fällen vergleichbar waren besser als menschliche Experten.

Deep Learning-Algorithmen und -Netzwerke -

• basieren auf dem unbeaufsichtigten Lernen mehrerer Ebenen von Merkmalen oder Darstellungen der Daten. Features auf höherer Ebene werden von Features auf niedrigerer Ebene abgeleitet, um eine hierarchische Darstellung zu bilden.

• Verwenden Sie für das Training eine Form des Gefälles.

In diesem Kapitel lernen wir die Umgebung kennen, die für Python Deep Learning eingerichtet wurde. Wir müssen die folgende Software installieren, um Deep-Learning-Algorithmen zu erstellen.

• Python 2.7+
• Scipy mit Numpy
• Matplotlib
• Theano
• Keras
• TensorFlow

Es wird dringend empfohlen, Python, NumPy, SciPy und Matplotlib über die Anaconda-Distribution zu installieren. Es kommt mit all diesen Paketen.

Wir müssen sicherstellen, dass die verschiedenen Softwaretypen ordnungsgemäß installiert sind.

Gehen wir zu unserem Befehlszeilenprogramm und geben den folgenden Befehl ein:

$ python
Python 3.6.3 |Anaconda custom (32-bit)| (default, Oct 13 2017, 14:21:34)
[GCC 7.2.0] on linux

Als nächstes können wir die erforderlichen Bibliotheken importieren und ihre Versionen drucken -

import numpy
print numpy.__version__

Ausgabe

1.14.2

Installation von Theano, TensorFlow und Keras

Bevor wir mit der Installation der Pakete beginnen - Theano, TensorFlow und Keras - müssen wir bestätigen, ob die pipist installiert. Das Paketverwaltungssystem in Anaconda heißt pip.

Geben Sie Folgendes in die Befehlszeile ein, um die Installation von pip zu bestätigen:

$ pip

Sobald die Installation von pip bestätigt ist, können wir TensorFlow und Keras installieren, indem wir den folgenden Befehl ausführen:

$pip install theano $pip install tensorflow
$pip install keras

Bestätigen Sie die Installation von Theano, indem Sie die folgende Codezeile ausführen:

$python –c “import theano: print (theano.__version__)”

Ausgabe

1.0.1

Bestätigen Sie die Installation von Tensorflow, indem Sie die folgende Codezeile ausführen:

$python –c “import tensorflow: print tensorflow.__version__”

Ausgabe

1.7.0

Bestätigen Sie die Installation von Keras, indem Sie die folgende Codezeile ausführen:

$python –c “import keras: print keras.__version__”
Using TensorFlow backend

Ausgabe

2.1.5

Künstliche Intelligenz (KI) ist ein Code, Algorithmus oder eine Technik, mit der ein Computer das kognitive Verhalten oder die Intelligenz des Menschen nachahmen kann. Maschinelles Lernen (ML) ist eine Teilmenge der KI, die statistische Methoden verwendet, um Maschinen das Lernen und Verbessern mit Erfahrung zu ermöglichen. Deep Learning ist eine Teilmenge des maschinellen Lernens, die die Berechnung mehrschichtiger neuronaler Netze ermöglicht. Maschinelles Lernen wird als flaches Lernen angesehen, während tiefes Lernen als hierarchisches Lernen mit Abstraktion angesehen wird.

Maschinelles Lernen befasst sich mit einer Vielzahl von Konzepten. Die Konzepte sind unten aufgeführt -

• supervised
• unsupervised
• Verstärkungslernen
• lineare Regression
• Kostenfunktionen
• overfitting
• under-fitting
• Hyperparameter usw.

Beim überwachten Lernen lernen wir, Werte aus beschrifteten Daten vorherzusagen. Eine ML-Technik, die hier hilft, ist die Klassifizierung, bei der Zielwerte diskrete Werte sind. Zum Beispiel Katzen und Hunde. Eine andere Technik des maschinellen Lernens, die hilfreich sein könnte, ist die Regression. Die Regression arbeitet mit den Zielwerten. Die Zielwerte sind kontinuierliche Werte; Beispielsweise können die Börsendaten mithilfe der Regression analysiert werden.

Beim unbeaufsichtigten Lernen ziehen wir Schlussfolgerungen aus den Eingabedaten, die nicht beschriftet oder strukturiert sind. Wenn wir über eine Million Krankenakten verfügen und diese verstehen, die zugrunde liegende Struktur und Ausreißer finden oder Anomalien erkennen müssen, verwenden wir die Clustering-Technik, um Daten in breite Cluster zu unterteilen.

Datensätze sind in Trainingssätze, Testsätze, Validierungssätze usw. unterteilt.

Ein Durchbruch im Jahr 2012 brachte das Konzept des Deep Learning in den Vordergrund. Ein Algorithmus klassifizierte 1 Million Bilder erfolgreich in 1000 Kategorien unter Verwendung von 2 GPUs und neuesten Technologien wie Big Data.

Deep Learning und traditionelles maschinelles Lernen in Beziehung setzen

Eine der größten Herausforderungen bei herkömmlichen Modellen für maschinelles Lernen ist ein Prozess, der als Merkmalsextraktion bezeichnet wird. Der Programmierer muss spezifisch sein und dem Computer mitteilen, auf welche Funktionen er achten muss. Diese Funktionen helfen bei der Entscheidungsfindung.

Die Eingabe von Rohdaten in den Algorithmus funktioniert selten. Daher ist die Merkmalsextraktion ein wichtiger Bestandteil des herkömmlichen Workflows für maschinelles Lernen.

Dies stellt eine große Verantwortung für den Programmierer dar, und die Effizienz des Algorithmus hängt stark davon ab, wie erfinderisch der Programmierer ist. Bei komplexen Problemen wie der Objekterkennung oder der Handschrifterkennung ist dies ein großes Problem.

Deep Learning mit der Fähigkeit, mehrere Repräsentationsebenen zu lernen, ist eine der wenigen Methoden, die uns bei der automatischen Merkmalsextraktion geholfen haben. Es kann davon ausgegangen werden, dass die unteren Schichten eine automatische Merkmalsextraktion durchführen, die vom Programmierer nur wenig oder gar keine Anleitung benötigt.

Das künstliche neuronale Netzwerk, oder kurz neuronales Netzwerk, ist keine neue Idee. Es gibt es seit ungefähr 80 Jahren.

Erst 2011 wurde Deep Neural Networks durch den Einsatz neuer Techniken, die enorme Verfügbarkeit von Datensätzen und leistungsstarke Computer populär.

Ein neuronales Netzwerk ahmt ein Neuron nach, das Dendriten, einen Kern, ein Axon und ein terminales Axon aufweist.

Für ein Netzwerk benötigen wir zwei Neuronen. Diese Neuronen übertragen Informationen über eine Synapse zwischen den Dendriten des einen und dem terminalen Axon eines anderen.

Ein wahrscheinliches Modell eines künstlichen Neurons sieht so aus -

Ein neuronales Netzwerk sieht wie folgt aus:

Die Kreise sind Neuronen oder Knoten mit ihren Funktionen auf den Daten und die Linien / Kanten, die sie verbinden, sind die Gewichte / Informationen, die weitergegeben werden.

Jede Spalte ist eine Ebene. Die erste Ebene Ihrer Daten ist die Eingabeebene. Dann sind alle Ebenen zwischen der Eingabeebene und der Ausgabeebene die verborgenen Ebenen.

Wenn Sie eine oder mehrere versteckte Schichten haben, haben Sie ein flaches neuronales Netzwerk. Wenn Sie viele versteckte Schichten haben, haben Sie ein tiefes neuronales Netzwerk.

In diesem Modell haben Sie Eingabedaten, gewichten sie und leiten sie durch die Funktion im Neuron, die als Schwellenwertfunktion oder Aktivierungsfunktion bezeichnet wird.

Grundsätzlich ist es die Summe aller Werte nach dem Vergleich mit einem bestimmten Wert. Wenn Sie ein Signal auslösen, ist das Ergebnis (1) oder nichts, dann (0). Das wird dann gewichtet und an das nächste Neuron weitergegeben, und die gleiche Art von Funktion wird ausgeführt.

Wir können eine Sigmoidfunktion (S-Form) als Aktivierungsfunktion haben.

Die Gewichte sind zu Beginn nur zufällig und pro Eingabe in den Knoten / das Neuron eindeutig.

In einem typischen "Feed Forward", dem grundlegendsten Typ eines neuronalen Netzwerks, werden Ihre Informationen direkt durch das von Ihnen erstellte Netzwerk geleitet, und Sie vergleichen die Ausgabe mit dem, was Sie gehofft hatten, dass die Ausgabe Ihre Beispieldaten verwendet hätte.

Von hier aus müssen Sie die Gewichte anpassen, damit Ihre Ausgabe der gewünschten Ausgabe entspricht.

Das Senden von Daten direkt durch ein neuronales Netzwerk wird als a bezeichnet feed forward neural network.

Unsere Daten gehen von der Eingabe über die Ebenen bis zur Ausgabe.

Wenn wir rückwärts gehen und anfangen, Gewichte anzupassen, um Verluste / Kosten zu minimieren, wird dies aufgerufen back propagation.

Das ist ein optimization problem. Mit dem neuronalen Netzwerk müssen wir in der Praxis mit Hunderttausenden von Variablen oder Millionen oder mehr umgehen.

Die erste Lösung bestand darin, den stochastischen Gradientenabstieg als Optimierungsmethode zu verwenden. Jetzt gibt es Optionen wie AdaGrad, Adam Optimizer und so weiter. In jedem Fall ist dies eine massive Rechenoperation. Aus diesem Grund wurden neuronale Netze meist über ein halbes Jahrhundert lang im Regal gelassen. Erst in jüngster Zeit hatten wir sogar die Leistung und Architektur unserer Maschinen, um diese Vorgänge in Betracht zu ziehen, und die passenden Datensätze mit der richtigen Größe.

Für einfache Klassifizierungsaufgaben ist die Leistung des neuronalen Netzwerks anderen einfachen Algorithmen wie K Nearest Neighbors relativ ähnlich. Der wahre Nutzen neuronaler Netze wird erkannt, wenn wir viel größere Daten und viel komplexere Fragen haben, die beide andere Modelle des maschinellen Lernens übertreffen.

Ein Deep Neural Network (DNN) ist ein ANN mit mehreren versteckten Schichten zwischen der Eingabe- und der Ausgabeschicht. Ähnlich wie flache ANNs können DNNs komplexe nichtlineare Beziehungen modellieren.

Der Hauptzweck eines neuronalen Netzwerks besteht darin, eine Reihe von Eingaben zu empfangen, zunehmend komplexe Berechnungen an ihnen durchzuführen und Ausgaben zu liefern, um Probleme der realen Welt wie die Klassifizierung zu lösen. Wir beschränken uns darauf, neuronale Netze weiterzuleiten.

Wir haben eine Eingabe, eine Ausgabe und einen Fluss von sequentiellen Daten in einem tiefen Netzwerk.

Neuronale Netze werden häufig bei überwachten Lern- und Verstärkungslernproblemen eingesetzt. Diese Netzwerke basieren auf einer Reihe von Schichten, die miteinander verbunden sind.

Beim tiefen Lernen kann die Anzahl der verborgenen Schichten, die meist nicht linear sind, groß sein. sagen wir über 1000 Schichten.

DL-Modelle liefern viel bessere Ergebnisse als normale ML-Netzwerke.

Wir verwenden meistens die Gradientenabstiegsmethode, um das Netzwerk zu optimieren und die Verlustfunktion zu minimieren.

Wir können die verwenden Imagenet, ein Repository mit Millionen digitaler Bilder, um einen Datensatz in Kategorien wie Katzen und Hunde zu klassifizieren. DL-Netze werden zunehmend für dynamische Bilder neben statischen sowie für Zeitreihen und Textanalysen verwendet.

Das Training der Datensätze ist ein wichtiger Bestandteil von Deep Learning-Modellen. Darüber hinaus ist Backpropagation der Hauptalgorithmus beim Trainieren von DL-Modellen.

DL befasst sich mit dem Training großer neuronaler Netze mit komplexen Input-Output-Transformationen.

Ein Beispiel für DL ist die Zuordnung eines Fotos zum Namen der Person (en) auf dem Foto, wie sie es in sozialen Netzwerken tut, und die Beschreibung eines Bildes mit einer Phrase ist eine weitere neuere Anwendung von DL.

Neuronale Netze sind Funktionen mit Eingängen wie x1, x2, x3…, die in zwei (flache Netze) oder mehrere Zwischenoperationen, auch Schichten genannt (tiefe Netze), in Ausgänge wie z1, z2, z3 usw. umgewandelt werden.

Die Gewichte und Vorspannungen ändern sich von Schicht zu Schicht. 'w' und 'v' sind die Gewichte oder Synapsen von Schichten der neuronalen Netze.

Der beste Anwendungsfall für Deep Learning ist das überwachte Lernproblem. Hier haben wir eine große Anzahl von Dateneingaben mit einer gewünschten Anzahl von Ausgaben.

Hier wenden wir einen Back-Propagation-Algorithmus an, um eine korrekte Ausgabevorhersage zu erhalten.

Der grundlegendste Datensatz für Deep Learning ist der MNIST, ein Datensatz handgeschriebener Ziffern.

Mit Keras können wir ein Faltungs-Neuronales Netzwerk tief trainieren, um Bilder handgeschriebener Ziffern aus diesem Datensatz zu klassifizieren.

Das Auslösen oder Aktivieren eines neuronalen Netzklassifikators erzeugt eine Punktzahl. Um beispielsweise Patienten als krank und gesund einzustufen, berücksichtigen wir Parameter wie Größe, Gewicht und Körpertemperatur, Blutdruck usw.

Eine hohe Punktzahl bedeutet, dass der Patient krank ist, und eine niedrige Punktzahl bedeutet, dass er gesund ist.

Jeder Knoten in Ausgabe- und ausgeblendeten Ebenen verfügt über eigene Klassifizierer. Die Eingabeebene nimmt Eingaben entgegen und gibt ihre Ergebnisse zur weiteren Aktivierung an die nächste verborgene Ebene weiter. Dies wird fortgesetzt, bis die Ausgabe erreicht ist.

Dieser Fortschritt von Eingabe zu Ausgabe von links nach rechts in Vorwärtsrichtung wird aufgerufen forward propagation.

Der Kreditzuweisungspfad (CAP) in einem neuronalen Netzwerk ist die Reihe von Transformationen, die von der Eingabe zur Ausgabe beginnen. CAPs erarbeiten wahrscheinliche kausale Zusammenhänge zwischen Input und Output.

Die CAP-Tiefe für ein bestimmtes neuronales Feed-Forward-Netzwerk oder die CAP-Tiefe ist die Anzahl der verborgenen Schichten plus eins, wenn die Ausgabeschicht enthalten ist. Bei wiederkehrenden neuronalen Netzen, bei denen sich ein Signal mehrmals durch eine Schicht ausbreiten kann, kann die CAP-Tiefe möglicherweise unbegrenzt sein.

Tiefe Netze und flache Netze

Es gibt keine klare Tiefenschwelle, die flaches Lernen von tiefem Lernen trennt. Es besteht jedoch größtenteils Einigkeit darüber, dass für tiefes Lernen mit mehreren nichtlinearen Schichten die GAP größer als zwei sein muss.

Der Grundknoten in einem neuronalen Netz ist eine Wahrnehmung, die ein Neuron in einem biologischen neuronalen Netzwerk nachahmt. Dann haben wir mehrschichtige Wahrnehmung oder MLP. Jeder Satz von Eingaben wird durch einen Satz von Gewichten und Verzerrungen modifiziert. Jede Kante hat ein eindeutiges Gewicht und jeder Knoten hat eine eindeutige Vorspannung.

Die Vorhersage accuracy eines neuronalen Netzes hängt von seiner weights and biases.

Der Prozess der Verbesserung der Genauigkeit des neuronalen Netzwerks wird aufgerufen training. Die Ausgabe eines Vorwärtsstützennetzes wird mit dem Wert verglichen, von dem bekannt ist, dass er korrekt ist.

Das cost function or the loss function ist die Differenz zwischen der generierten Ausgabe und der tatsächlichen Ausgabe.

Der Zweck des Trainings besteht darin, die Trainingskosten für Millionen von Trainingsbeispielen so gering wie möglich zu halten. Dazu optimiert das Netzwerk die Gewichte und Verzerrungen, bis die Vorhersage mit der richtigen Ausgabe übereinstimmt.

Einmal gut trainiert, kann ein neuronales Netz jedes Mal eine genaue Vorhersage treffen.

Wenn das Muster komplex wird und Sie möchten, dass Ihr Computer es erkennt, müssen Sie sich für neuronale Netzwerke entscheiden. In solchen komplexen Musterszenarien übertrifft das neuronale Netzwerk alle anderen konkurrierenden Algorithmen.

Es gibt jetzt GPUs, die sie schneller als je zuvor trainieren können. Tiefe neuronale Netze revolutionieren bereits das Gebiet der KI

Computer haben sich als gut darin erwiesen, sich wiederholende Berechnungen durchzuführen und detaillierte Anweisungen zu befolgen, waren jedoch nicht so gut darin, komplexe Muster zu erkennen.

Wenn es das Problem der Erkennung einfacher Muster gibt, kann eine Support Vector Machine (svm) oder ein logistischer Regressionsklassifizierer die Aufgabe gut erledigen, aber mit zunehmender Komplexität von Mustern gibt es keine andere Möglichkeit, als sich für tiefe neuronale Netze zu entscheiden.

Daher versagen bei komplexen Mustern wie einem menschlichen Gesicht flache neuronale Netze und haben keine andere Wahl, als sich für tiefe neuronale Netze mit mehr Schichten zu entscheiden. Die tiefen Netze können ihre Arbeit erledigen, indem sie die komplexen Muster in einfachere zerlegen. Zum Beispiel menschliches Gesicht; Adeep Net würde Kanten verwenden, um Teile wie Lippen, Nase, Augen, Ohren usw. zu erkennen und diese dann wieder zu einem menschlichen Gesicht zu kombinieren

Die Genauigkeit der korrekten Vorhersage ist so genau geworden, dass kürzlich bei einer Google Pattern Recognition Challenge ein tiefes Netz einen Menschen schlug.

Diese Idee eines Netzes geschichteter Perzeptrone gibt es schon seit einiger Zeit; In diesem Bereich ahmen tiefe Netze das menschliche Gehirn nach. Ein Nachteil dabei ist jedoch, dass das Trainieren lange dauert, was eine Hardwarebeschränkung darstellt

In jüngster Zeit konnten Hochleistungs-GPUs jedoch so tiefe Netze in weniger als einer Woche trainieren. während schneller cpus Wochen oder vielleicht Monate gebraucht haben könnte, um dasselbe zu tun.

Ein tiefes Netz wählen

Wie wählt man ein tiefes Netz? Wir müssen uns entscheiden, ob wir einen Klassifikator erstellen oder ob wir versuchen, Muster in den Daten zu finden, und ob wir unbeaufsichtigtes Lernen verwenden werden. Um Muster aus einem Satz unbeschrifteter Daten zu extrahieren, verwenden wir eine Restricted Boltzman-Maschine oder einen Auto-Encoder.

Berücksichtigen Sie bei der Auswahl eines tiefen Netzes die folgenden Punkte:

• Für die Textverarbeitung, Stimmungsanalyse, Analyse und Erkennung von Namensentitäten verwenden wir ein wiederkehrendes Netz oder ein rekursives neuronales Tensornetzwerk oder RNTN.

• Für jedes Sprachmodell, das auf Zeichenebene arbeitet, verwenden wir das wiederkehrende Netz.

• Für die Bilderkennung verwenden wir DBN oder Faltungsnetzwerk.

• Zur Objekterkennung verwenden wir ein RNTN oder ein Faltungsnetzwerk.

• Für die Spracherkennung verwenden wir wiederkehrende Netze.

Im Allgemeinen sind Deep-Believe-Netzwerke und mehrschichtige Perzeptrone mit gleichgerichteten linearen Einheiten oder RELU beide eine gute Wahl für die Klassifizierung.

Für die Zeitreihenanalyse wird immer empfohlen, ein wiederkehrendes Netz zu verwenden.

Neuronale Netze gibt es seit mehr als 50 Jahren; aber erst jetzt haben sie an Bedeutung gewonnen. Der Grund ist, dass sie schwer zu trainieren sind; Wenn wir versuchen, sie mit einer Methode zu trainieren, die als Rückausbreitung bezeichnet wird, stoßen wir auf ein Problem, das als Verschwinden oder Explodieren von Gradienten bezeichnet wird. In diesem Fall dauert das Training länger und die Genauigkeit tritt in den Hintergrund. Beim Trainieren eines Datensatzes berechnen wir ständig die Kostenfunktion, die die Differenz zwischen der vorhergesagten Ausgabe und der tatsächlichen Ausgabe aus einem Satz gekennzeichneter Trainingsdaten darstellt. Die Kostenfunktion wird dann minimiert, indem die Gewichte und Vorspannungswerte bis zum niedrigsten Wert angepasst werden erhalten wird. Der Trainingsprozess verwendet einen Gradienten, bei dem es sich um die Rate handelt, mit der sich die Kosten in Bezug auf Gewichtsänderungen oder Abweichungswerte ändern.

Eingeschränkte Boltzman-Netzwerke oder Autoencoder - RBNs

Im Jahr 2006 wurde ein Durchbruch bei der Bewältigung des Problems der verschwindenden Gradienten erzielt. Geoff Hinton entwickelte eine neuartige Strategie, die zur Entwicklung von führteRestricted Boltzman Machine - RBM, ein flaches zweischichtiges Netz.

Die erste Schicht ist die visible Schicht und die zweite Schicht ist die hiddenSchicht. Jeder Knoten in der sichtbaren Ebene ist mit jedem Knoten in der verborgenen Ebene verbunden. Das Netzwerk wird als eingeschränkt bezeichnet, da keine zwei Schichten innerhalb derselben Schicht eine Verbindung gemeinsam nutzen dürfen.

Autoencoder sind Netzwerke, die Eingabedaten als Vektoren codieren. Sie erstellen eine versteckte oder komprimierte Darstellung der Rohdaten. Die Vektoren sind nützlich bei der Dimensionsreduktion; Der Vektor komprimiert die Rohdaten in eine kleinere Anzahl wesentlicher Dimensionen. Autoencoder werden mit Decodern gepaart, was die Rekonstruktion von Eingabedaten basierend auf ihrer verborgenen Darstellung ermöglicht.

RBM ist das mathematische Äquivalent eines Zwei-Wege-Übersetzers. Ein Vorwärtsdurchlauf nimmt Eingaben entgegen und übersetzt sie in eine Reihe von Zahlen, die die Eingaben codieren. Ein Rückwärtsdurchlauf nimmt währenddessen diesen Satz von Zahlen und übersetzt sie zurück in rekonstruierte Eingaben. Ein gut trainiertes Netz führt die Rückenstütze mit einem hohen Maß an Genauigkeit aus.

In beiden Schritten spielen die Gewichte und die Vorspannungen eine entscheidende Rolle. Sie helfen dem RBM bei der Dekodierung der Wechselbeziehungen zwischen den Eingaben und bei der Entscheidung, welche Eingaben für die Erkennung von Mustern wesentlich sind. Durch Vorwärts- und Rückwärtsdurchläufe wird das RBM darauf trainiert, die Eingabe mit unterschiedlichen Gewichten und Vorspannungen zu rekonstruieren, bis die Eingabe und die Konstruktion so nah wie möglich sind. Ein interessanter Aspekt von RBM ist, dass Daten nicht gekennzeichnet werden müssen. Dies erweist sich als sehr wichtig für reale Datensätze wie Fotos, Videos, Stimmen und Sensordaten, die in der Regel unbeschriftet sind. Anstatt Daten manuell von Menschen zu kennzeichnen, sortiert RBM die Daten automatisch. Durch die richtige Anpassung der Gewichte und Vorspannungen kann ein RBM wichtige Merkmale extrahieren und die Eingabe rekonstruieren. RBM ist Teil der Familie der Merkmalsextraktor-Neuronalen Netze, die inhärente Muster in Daten erkennen sollen. Diese werden auch als Auto-Encoder bezeichnet, da sie ihre eigene Struktur codieren müssen.

Deep Belief Networks - DBNs

Deep Believe Networks (DBNs) werden durch die Kombination von RBMs und die Einführung einer cleveren Trainingsmethode gebildet. Wir haben ein neues Modell, das endlich das Problem des verschwindenden Gradienten löst. Geoff Hinton erfand die RBMs und auch Deep Belief Nets als Alternative zur Rückausbreitung.

Ein DBN hat eine ähnliche Struktur wie ein MLP (Multi-Layer Perceptron), unterscheidet sich jedoch beim Training erheblich. Es ist das Training, das es DBNs ermöglicht, ihre flachen Kollegen zu übertreffen

Ein DBN kann als Stapel von RBMs dargestellt werden, wobei die verborgene Schicht eines RBM die sichtbare Schicht des darüber liegenden RBM ist. Das erste RBM wird trainiert, um seine Eingabe so genau wie möglich zu rekonstruieren.

Die verborgene Schicht des ersten RBM wird als sichtbare Schicht des zweiten RBM genommen, und das zweite RBM wird unter Verwendung der Ausgänge des ersten RBM trainiert. Dieser Prozess wird wiederholt, bis jede Schicht im Netzwerk trainiert ist.

In einem DBN lernt jeder RBM die gesamte Eingabe. Ein DBN arbeitet global, indem die gesamte Eingabe nacheinander fein abgestimmt wird, da sich das Modell langsam verbessert wie ein Kameraobjektiv, das ein Bild langsam fokussiert. Ein Stapel von RBMs übertrifft ein einzelnes RBM, da ein mehrschichtiges Perzeptron MLP ein einzelnes Perzeptron übertrifft.

Zu diesem Zeitpunkt haben die RBMs inhärente Muster in den Daten erkannt, jedoch ohne Namen oder Bezeichnung. Um das Training des DBN zu beenden, müssen wir Beschriftungen in die Muster einführen und das Netz mit überwachtem Lernen fein abstimmen.

Wir benötigen einen sehr kleinen Satz beschrifteter Beispiele, damit die Merkmale und Muster einem Namen zugeordnet werden können. Dieser kleine Datensatz wird für das Training verwendet. Dieser Satz beschrifteter Daten kann im Vergleich zum Originaldatensatz sehr klein sein.

Die Gewichte und Vorspannungen werden geringfügig geändert, was zu einer geringfügigen Änderung der Wahrnehmung der Muster durch das Netz und häufig zu einer geringfügigen Erhöhung der Gesamtgenauigkeit führt.

Das Training kann auch in angemessener Zeit abgeschlossen werden, indem GPUs verwendet werden, die im Vergleich zu flachen Netzen sehr genaue Ergebnisse liefern, und wir sehen auch eine Lösung für das Problem des verschwindenden Gradienten.

Generative Adversarial Networks - GANs

Generative kontradiktorische Netzwerke sind tiefe neuronale Netze, die zwei gegeneinander angeordnete Netze umfassen, daher der Name „kontrovers“.

GANs wurden in einem Artikel vorgestellt, der 2014 von Forschern der Universität von Montreal veröffentlicht wurde. Der KI-Experte von Facebook, Yann LeCun, bezeichnete GANs als „die interessanteste Idee in den letzten 10 Jahren in ML“.

Das Potenzial von GANs ist enorm, da der Netzwerk-Scan lernt, jede Datenverteilung nachzuahmen. GANs können gelehrt werden, Parallelwelten zu erschaffen, die unseren in jedem Bereich auffallend ähnlich sind: Bilder, Musik, Sprache, Prosa. Sie sind in gewisser Weise Roboterkünstler, und ihre Leistung ist ziemlich beeindruckend.

In einem GAN generiert ein neuronales Netzwerk, das als Generator bezeichnet wird, neue Dateninstanzen, während das andere, der Diskriminator, diese auf Authentizität auswertet.

Nehmen wir an, wir versuchen, handgeschriebene Ziffern zu generieren, wie sie im MNIST-Datensatz enthalten sind, der aus der realen Welt stammt. Die Arbeit des Diskriminators besteht darin, eine Instanz aus dem wahren MNIST-Datensatz als authentisch zu erkennen, wenn sie angezeigt wird.

Betrachten Sie nun die folgenden Schritte der GAN -

• Das Generator-Netzwerk nimmt Eingaben in Form von Zufallszahlen entgegen und gibt ein Bild zurück.

• Dieses erzeugte Bild wird als Eingabe in das Diskriminatornetzwerk zusammen mit einem Strom von Bildern gegeben, die aus dem tatsächlichen Datensatz entnommen wurden.

• Der Diskriminator nimmt sowohl echte als auch gefälschte Bilder auf und gibt Wahrscheinlichkeiten zurück, eine Zahl zwischen 0 und 1, wobei 1 eine Vorhersage der Authentizität darstellt und 0 eine Fälschung darstellt.

• Sie haben also eine doppelte Rückkopplungsschleife -

  • Der Diskriminator befindet sich in einer Rückkopplungsschleife mit der Grundwahrheit der Bilder, die wir kennen.

  • Der Generator befindet sich in einer Rückkopplungsschleife mit dem Diskriminator.

Wiederkehrende neuronale Netze - RNNs

RNNSare neuronale Netze, in denen Daten in jede Richtung fließen können. Diese Netzwerke werden für Anwendungen wie Sprachmodellierung oder Natural Language Processing (NLP) verwendet.

Das Grundkonzept, das RNNs zugrunde liegt, besteht darin, sequentielle Informationen zu verwenden. In einem normalen neuronalen Netzwerk wird angenommen, dass alle Ein- und Ausgänge unabhängig voneinander sind. Wenn wir das nächste Wort in einem Satz vorhersagen wollen, müssen wir wissen, welche Wörter davor standen.

RNNs werden als wiederkehrend bezeichnet, da sie für jedes Element einer Sequenz dieselbe Aufgabe wiederholen, wobei die Ausgabe auf den vorherigen Berechnungen basiert. Man kann also sagen, dass RNNs einen "Speicher" haben, der Informationen über das erfasst, was zuvor berechnet wurde. Theoretisch können RNNs Informationen in sehr langen Sequenzen verwenden, in der Realität können sie jedoch nur wenige Schritte zurückblicken.

Long Short Term Memory Networks (LSTMs) sind die am häufigsten verwendeten RNNs.

Zusammen mit Faltungs-Neuronalen Netzen wurden RNNs als Teil eines Modells verwendet, um Beschreibungen für unbeschriftete Bilder zu generieren. Es ist ziemlich erstaunlich, wie gut dies zu funktionieren scheint.

Convolutional Deep Neural Networks - CNNs

Wenn wir die Anzahl der Schichten in einem neuronalen Netzwerk erhöhen, um es tiefer zu machen, erhöht dies die Komplexität des Netzwerks und ermöglicht es uns, kompliziertere Funktionen zu modellieren. Die Anzahl der Gewichte und Vorspannungen wird jedoch exponentiell zunehmen. Tatsächlich kann das Lernen derart schwieriger Probleme für normale neuronale Netze unmöglich werden. Dies führt zu einer Lösung, den Faltungs-Neuronalen Netzen.

CNNs werden häufig in der Bildverarbeitung verwendet. wurden auch in der akustischen Modellierung zur automatischen Spracherkennung angewendet.

Die Idee hinter Faltungs-Neuronalen Netzen ist die Idee eines „sich bewegenden Filters“, der durch das Bild geht. Dieser sich bewegende Filter oder diese Faltung gilt für eine bestimmte Nachbarschaft von Knoten, die beispielsweise Pixel sein können, wobei der angewendete Filter das 0,5-fache des Knotenwerts beträgt.

Der bekannte Forscher Yann LeCun war Pionier der Faltungs-Neuronalen Netze. Facebook als Gesichtserkennungssoftware verwendet diese Netze. CNN war die Lösung für Bildverarbeitungsprojekte. Ein Faltungsnetzwerk besteht aus vielen Schichten. Bei der Imagenet-Herausforderung konnte eine Maschine 2015 einen Menschen bei der Objekterkennung schlagen.

Kurz gesagt, Convolutional Neural Networks (CNNs) sind mehrschichtige neuronale Netze. Die Ebenen sind manchmal bis zu 17 oder mehr und nehmen an, dass die Eingabedaten Bilder sind.

CNNs reduzieren die Anzahl der Parameter, die eingestellt werden müssen, drastisch. CNNs bewältigen also effizient die hohe Dimensionalität von Rohbildern.

In diesem Kapitel werden wir uns mit den Grundlagen von Python Deep Learning befassen.

Deep Learning Modelle / Algorithmen

Lassen Sie uns nun die verschiedenen Deep-Learning-Modelle / -Algorithmen kennenlernen.

Einige der populären Modelle innerhalb des tiefen Lernens sind wie folgt:

• Faltungs-Neuronale Netze
• Wiederkehrende neuronale Netze
• Netzwerke des tiefen Glaubens
• Generative gegnerische Netzwerke
• Auto-Encoder und so weiter

Die Ein- und Ausgänge werden als Vektoren oder Tensoren dargestellt. Beispielsweise kann ein neuronales Netzwerk Eingaben haben, bei denen einzelne Pixel-RGB-Werte in einem Bild als Vektoren dargestellt werden.

Die Schichten von Neuronen, die zwischen der Eingangsschicht und der Ausgangsschicht liegen, werden als verborgene Schichten bezeichnet. Hier geschieht der größte Teil der Arbeit, wenn das neuronale Netz versucht, Probleme zu lösen. Ein genauerer Blick auf die verborgenen Ebenen kann viel über die Funktionen verraten, die das Netzwerk gelernt hat, aus den Daten zu extrahieren.

Unterschiedliche Architekturen neuronaler Netze werden gebildet, indem ausgewählt wird, welche Neuronen mit den anderen Neuronen in der nächsten Schicht verbunden werden sollen.

Pseudocode zur Berechnung der Ausgabe

Es folgt der Pseudocode zur Berechnung der Ausgabe von Forward-propagating Neural Network - -

• # node []: = Array topologisch sortierter Knoten
• # Eine Kante von a nach b bedeutet, dass a links von b steht
• # Wenn das Neuronale Netz R-Eingänge und S-Ausgänge hat,
• # dann sind die ersten R-Knoten Eingangsknoten und die letzten S-Knoten Ausgangsknoten.
• # eingehend [x]: = Knoten, die mit Knoten x verbunden sind
• # weight [x]: = Gewichtung der eingehenden Kanten zu x

Für jedes Neuron x von links nach rechts -

• Wenn x <= R: nichts tun, ist es ein Eingabeknoten
• Eingänge [x] = [Ausgang [i] für i bei eingehendem [x]]
• weighted_sum = dot_product (Gewichte [x], Eingaben [x])
• Ausgabe [x] = Aktivierungsfunktion (gewichtete Summe)

Wir werden nun lernen, wie man ein neuronales Netzwerk trainiert. Wir werden auch den Back-Propagation-Algorithmus und den Backward-Pass in Python Deep Learning lernen.

Wir müssen die optimalen Werte der Gewichte eines neuronalen Netzwerks finden, um die gewünschte Ausgabe zu erhalten. Um ein neuronales Netzwerk zu trainieren, verwenden wir die iterative Gradientenabstiegsmethode. Wir beginnen zunächst mit einer zufälligen Initialisierung der Gewichte. Nach der zufälligen Initialisierung machen wir Vorhersagen für eine Teilmenge der Daten mit Vorwärtsausbreitungsprozess, berechnen die entsprechende Kostenfunktion C und aktualisieren jedes Gewicht w um einen Betrag proportional zu dC / dw, dh die Ableitung der Kostenfunktionen für die Gewicht. Die Proportionalitätskonstante wird als Lernrate bezeichnet.

Die Gradienten können unter Verwendung des Back-Propagation-Algorithmus effizient berechnet werden. Die Schlüsselbeobachtung der Rückwärtsausbreitung oder der Rückwärtsstütze ist, dass aufgrund der Kettenregel der Differenzierung der Gradient an jedem Neuron im neuronalen Netzwerk unter Verwendung des Gradienten an den Neuronen berechnet werden kann, zu dem er ausgehende Kanten hat. Daher berechnen wir die Farbverläufe rückwärts, dh berechnen zuerst die Farbverläufe der Ausgabeebene, dann die oberste verborgene Ebene, gefolgt von der vorhergehenden verborgenen Ebene usw., die auf der Eingabeebene endet.

Der Back-Propagation-Algorithmus wird hauptsächlich unter Verwendung der Idee eines Berechnungsgraphen implementiert, bei dem jedes Neuron auf viele Knoten im Berechnungsgraphen erweitert wird und eine einfache mathematische Operation wie Addition und Multiplikation ausführt. Der Berechnungsgraph hat keine Gewichte an den Kanten. Alle Gewichte werden den Knoten zugewiesen, sodass die Gewichte zu ihren eigenen Knoten werden. Der Rückwärtsausbreitungsalgorithmus wird dann auf dem Berechnungsgraphen ausgeführt. Sobald die Berechnung abgeschlossen ist, werden nur die Gradienten der Gewichtsknoten zur Aktualisierung benötigt. Der Rest der Farbverläufe kann verworfen werden.

Technik zur Optimierung des Gradientenabfalls

Eine häufig verwendete Optimierungsfunktion, die die Gewichte an den von ihnen verursachten Fehler anpasst, wird als "Gradientenabstieg" bezeichnet.

Gradient ist ein anderer Name für Steigung, und Steigung in einem xy-Diagramm gibt an, wie zwei Variablen miteinander in Beziehung stehen: der Anstieg über den Lauf, die Änderung der Entfernung über die Änderung der Zeit usw. In diesem Fall ist die Steigung das Verhältnis zwischen dem Netzwerkfehler und einem einzelnen Gewicht; dh wie ändert sich der Fehler, wenn das Gewicht variiert wird.

Genauer gesagt wollen wir herausfinden, welches Gewicht den geringsten Fehler verursacht. Wir wollen das Gewicht finden, das die in den Eingabedaten enthaltenen Signale korrekt darstellt, und sie in eine korrekte Klassifizierung übersetzen.

Wie ein neuronales Netzwerk lernt, passt es langsam viele Gewichte an, damit sie das Signal der Bedeutung richtig zuordnen können. Das Verhältnis zwischen dem Netzwerkfehler und jedem dieser Gewichte ist eine Ableitung, dE / dw, die das Ausmaß berechnet, in dem eine geringfügige Änderung eines Gewichts eine geringfügige Änderung des Fehlers verursacht.

Jedes Gewicht ist nur ein Faktor in einem tiefen Netzwerk, das viele Transformationen umfasst. Das Signal des Gewichts durchläuft Aktivierungen und summiert sich über mehrere Schichten. Daher verwenden wir die Kettenregel des Kalküls, um die Netzwerkaktivierungen und -ausgaben durchzuarbeiten. Dies führt uns zu dem fraglichen Gewicht und seiner Beziehung zum Gesamtfehler.

Bei zwei Variablen, Fehler und Gewicht, wird eine dritte Variable vermittelt: activation, durch die das Gewicht geleitet wird. Wir können berechnen, wie sich eine Gewichtsänderung auf eine Fehleränderung auswirkt, indem wir zunächst berechnen, wie sich eine Änderung der Aktivierung auf eine Änderung des Fehlers auswirkt und wie sich eine Gewichtsänderung auf eine Änderung der Aktivierung auswirkt.

Die Grundidee beim Deep Learning ist nichts anderes als das: Anpassen der Gewichte eines Modells als Reaktion auf den Fehler, den es erzeugt, bis Sie den Fehler nicht mehr reduzieren können.

Das tiefe Netz trainiert langsam, wenn der Gradientenwert klein ist, und schnell, wenn der Wert hoch ist. Ungenauigkeiten im Training führen zu ungenauen Ergebnissen. Der Prozess des Trainings der Netze vom Ausgang zurück zum Eingang wird als Rückausbreitung oder Rückstütze bezeichnet. Wir wissen, dass die Vorwärtsausbreitung mit der Eingabe beginnt und vorwärts arbeitet. Back Prop macht das Gegenteil / Gegenteil und berechnet den Gradienten von rechts nach links.

Jedes Mal, wenn wir einen Gradienten berechnen, verwenden wir alle vorherigen Gradienten bis zu diesem Punkt.

Beginnen wir an einem Knoten in der Ausgabeschicht. Die Kante verwendet den Verlauf an diesem Knoten. Wenn wir in die verborgenen Ebenen zurückkehren, wird es komplexer. Das Produkt zweier Zahlen zwischen 0 und 1 ergibt eine kleinere Zahl. Der Gradientenwert wird immer kleiner und infolgedessen nimmt das Training der Rückstütze viel Zeit in Anspruch, und die Genauigkeit leidet.

Herausforderungen bei Deep-Learning-Algorithmen

Es gibt bestimmte Herausforderungen sowohl für flache neuronale Netze als auch für tiefe neuronale Netze, wie Überanpassung und Rechenzeit. DNNs sind von einer Überanpassung betroffen, da zusätzliche Abstraktionsebenen verwendet werden, mit denen sie seltene Abhängigkeiten in den Trainingsdaten modellieren können.

RegularizationWährend des Trainings werden Methoden wie Ausfall, frühes Stoppen, Datenerweiterung und Transferlernen angewendet, um Überanpassung zu bekämpfen. Durch die Drop-out-Regularisierung werden während des Trainings zufällig Einheiten aus den verborgenen Ebenen weggelassen, wodurch seltene Abhängigkeiten vermieden werden. DNNs berücksichtigen verschiedene Trainingsparameter wie die Größe, dh die Anzahl der Schichten und die Anzahl der Einheiten pro Schicht, die Lernrate und die Anfangsgewichte. Das Finden optimaler Parameter ist aufgrund des hohen Zeit- und Rechenaufwands nicht immer praktikabel. Mehrere Hacks wie Batching können die Berechnung beschleunigen. Die große Verarbeitungsleistung von GPUs hat den Trainingsprozess erheblich unterstützt, da die erforderlichen Matrix- und Vektorberechnungen auf den GPUs gut ausgeführt werden.

Aussteigen

Dropout ist eine beliebte Regularisierungstechnik für neuronale Netze. Tiefe neuronale Netze sind besonders anfällig für Überanpassungen.

Lassen Sie uns nun sehen, was Dropout ist und wie es funktioniert.

Mit den Worten von Geoffrey Hinton, einem der Pioniere des Deep Learning: "Wenn Sie ein tiefes neuronales Netz haben und es nicht überpasst, sollten Sie wahrscheinlich ein größeres verwenden und Dropout verwenden."

Dropout ist eine Technik, bei der bei jeder Iteration des Gradientenabfalls eine Reihe zufällig ausgewählter Knoten gelöscht wird. Dies bedeutet, dass wir einige Knoten zufällig ignorieren, als ob sie nicht existieren.

Jedes Neuron wird mit einer Wahrscheinlichkeit von q gehalten und mit der Wahrscheinlichkeit 1-q zufällig fallen gelassen. Der Wert q kann für jede Schicht im neuronalen Netzwerk unterschiedlich sein. Ein Wert von 0,5 für die ausgeblendeten Ebenen und 0 für die Eingabeebene eignet sich für eine Vielzahl von Aufgaben.

Während der Auswertung und Vorhersage wird kein Ausfall verwendet. Die Ausgabe jedes Neurons wird mit q multipliziert, so dass die Eingabe in die nächste Schicht den gleichen erwarteten Wert hat.

Die Idee hinter Dropout lautet wie folgt: In einem neuronalen Netzwerk ohne Dropout-Regularisierung entwickeln Neuronen eine gegenseitige Abhängigkeit, die zu einer Überanpassung führt.

Implementierungstrick

Dropout wird in Bibliotheken wie TensorFlow und Pytorch implementiert, indem die Ausgabe der zufällig ausgewählten Neuronen als 0 gehalten wird. Das heißt, obwohl das Neuron vorhanden ist, wird seine Ausgabe als 0 überschrieben.

Frühes Anhalten

Wir trainieren neuronale Netze mit einem iterativen Algorithmus, der als Gradientenabstieg bezeichnet wird.

Die Idee hinter dem frühen Stoppen ist intuitiv; Wir beenden das Training, wenn der Fehler zunimmt. Unter Fehler verstehen wir hier den an Validierungsdaten gemessenen Fehler, der Teil der Trainingsdaten ist, die zum Einstellen von Hyperparametern verwendet werden. In diesem Fall ist der Hyperparameter das Stoppkriterium.

Datenerweiterung

Der Prozess, bei dem wir das vorhandene Datenvolumen erhöhen oder erweitern, indem wir vorhandene Daten verwenden und einige Transformationen darauf anwenden. Die genauen verwendeten Transformationen hängen von der Aufgabe ab, die wir erreichen möchten. Darüber hinaus hängen die Transformationen, die dem neuronalen Netz helfen, von seiner Architektur ab.

Beispielsweise besteht eine effektive Datenerweiterungstechnik bei vielen Computer-Vision-Aufgaben wie der Objektklassifizierung darin, neue Datenpunkte hinzuzufügen, die beschnittene oder übersetzte Versionen von Originaldaten sind.

Wenn ein Computer ein Bild als Eingabe akzeptiert, nimmt er eine Reihe von Pixelwerten auf. Nehmen wir an, das gesamte Bild ist um 15 Pixel nach links verschoben. Wir wenden viele verschiedene Verschiebungen in verschiedene Richtungen an, was zu einem erweiterten Datensatz führt, der um ein Vielfaches größer ist als der ursprüngliche Datensatz.

Lernen übertragen

Der Prozess der Erstellung eines vorab trainierten Modells und der „Feinabstimmung“ des Modells mit unserem eigenen Datensatz wird als Transferlernen bezeichnet. Es gibt verschiedene Möglichkeiten, dies zu tun. Im Folgenden werden einige Möglichkeiten beschrieben:

• Wir trainieren das vorgefertigte Modell an einem großen Datensatz. Dann entfernen wir die letzte Schicht des Netzwerks und ersetzen sie durch eine neue Schicht mit zufälligen Gewichten.

• Wir frieren dann die Gewichte aller anderen Schichten ein und trainieren das Netzwerk normal. Hier ändert das Einfrieren der Schichten nicht die Gewichte während des Gradientenabfalls oder der Optimierung.

Das Konzept dahinter ist, dass das vorab trainierte Modell als Feature-Extraktor fungiert und nur die letzte Ebene für die aktuelle Aufgabe trainiert wird.

Backpropagation wird in Deep-Learning-Frameworks wie Tensorflow, Torch, Theano usw. mithilfe von Berechnungsgraphen implementiert. Noch wichtiger ist, dass das Verständnis der Rückausbreitung in Berechnungsgraphen verschiedene Algorithmen und ihre Variationen wie Backprop durch die Zeit und Backprop mit gemeinsamen Gewichten kombiniert. Sobald alles in einen Berechnungsgraphen konvertiert ist, handelt es sich immer noch um denselben Algorithmus - nur die Rückübertragung auf Berechnungsgraphen.

Was ist Computational Graph?

Ein Berechnungsgraph wird als gerichteter Graph definiert, bei dem die Knoten mathematischen Operationen entsprechen. Computergraphen sind eine Möglichkeit, einen mathematischen Ausdruck auszudrücken und auszuwerten.

Zum Beispiel ist hier eine einfache mathematische Gleichung -

$$p = x+y$$

Wir können einen Berechnungsgraphen der obigen Gleichung wie folgt zeichnen.

Der obige Berechnungsgraph hat einen Additionsknoten (Knoten mit "+" - Vorzeichen) mit zwei Eingangsvariablen x und y und einem Ausgang q.

Nehmen wir ein anderes Beispiel, das etwas komplexer ist. Wir haben die folgende Gleichung.

$$g = \left (x+y \right ) \ast z $$

Die obige Gleichung wird durch den folgenden Berechnungsgraphen dargestellt.

Computergraphen und Backpropagation

Computergraphen und Backpropagation sind wichtige Kernkonzepte des Deep Learning für das Training neuronaler Netze.

Vorwärtspass

Der Vorwärtsdurchlauf ist das Verfahren zum Bewerten des Werts des mathematischen Ausdrucks, der durch Berechnungsgraphen dargestellt wird. Vorwärtsdurchlauf bedeutet, dass wir den Wert von Variablen in Vorwärtsrichtung von links (Eingabe) nach rechts übergeben, wo sich die Ausgabe befindet.

Betrachten wir ein Beispiel, indem wir allen Eingaben einen Wert geben. Angenommen, die folgenden Werte werden für alle Eingaben angegeben.

$$x=1, y=3, z=−3$$

Indem wir diese Werte den Eingaben zuweisen, können wir einen Vorwärtsdurchlauf durchführen und die folgenden Werte für die Ausgaben auf jedem Knoten erhalten.

Zuerst verwenden wir den Wert von x = 1 und y = 3, um p = 4 zu erhalten.

Dann verwenden wir p = 4 und z = -3, um g = -12 zu erhalten. Wir gehen von links nach rechts vorwärts.

Ziele des Rückwärtspasses

Im Rückwärtsdurchlauf möchten wir die Gradienten für jede Eingabe in Bezug auf die endgültige Ausgabe berechnen. Diese Gradienten sind für das Training des neuronalen Netzwerks unter Verwendung eines Gradientenabfalls wesentlich.

Zum Beispiel wünschen wir uns die folgenden Farbverläufe.

Gewünschte Farbverläufe

$$\frac{\partial x}{\partial f}, \frac{\partial y}{\partial f}, \frac{\partial z}{\partial f}$$

Rückwärtspass (Backpropagation)

Wir beginnen den Rückwärtsdurchlauf, indem wir die Ableitung der endgültigen Ausgabe in Bezug auf die endgültige Ausgabe (selbst!) Finden. Somit führt dies zur Identitätsableitung und der Wert ist gleich eins.

$$\frac{\partial g}{\partial g} = 1$$

Unser Berechnungsdiagramm sieht nun wie folgt aus:

Als nächstes werden wir den Rückwärtsdurchlauf durch die "*" - Operation durchführen. Wir werden die Gradienten bei p und z berechnen. Da g = p * z ist, wissen wir, dass -

$$\frac{\partial g}{\partial z} = p$$

$$\frac{\partial g}{\partial p} = z$$

Wir kennen die Werte von z und p bereits aus dem Vorwärtsdurchlauf. Daher bekommen wir -

$$\frac{\partial g}{\partial z} = p = 4$$

und

$$\frac{\partial g}{\partial p} = z = -3$$

Wir wollen die Gradienten bei x und y berechnen -

$$\frac{\partial g}{\partial x}, \frac{\partial g}{\partial y}$$

Wir möchten dies jedoch effizient tun (obwohl x und g in diesem Diagramm nur zwei Sprünge entfernt sind, stellen Sie sich vor, dass sie wirklich weit voneinander entfernt sind). Um diese Werte effizient zu berechnen, verwenden wir die Kettenregel der Differenzierung. Aus der Kettenregel haben wir -

$$\frac{\partial g}{\partial x}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial x}$$

$$\frac{\partial g}{\partial y}=\frac{\partial g}{\partial p}\ast \frac{\partial p}{\partial y}$$

Wir wissen jedoch bereits, dass dg / dp = -3, dp / dx und dp / dy einfach sind, da p direkt von x und y abhängt. Wir haben -

$$p=x+y\Rightarrow \frac{\partial x}{\partial p} = 1, \frac{\partial y}{\partial p} = 1$$

Daher bekommen wir -

$$\frac{\partial g} {\partial f} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial x} = \left ( -3 \right ).1 = -3$$

Zusätzlich für die Eingabe y -

$$\frac{\partial g} {\partial y} = \frac{\partial g} {\partial p}\ast \frac{\partial p} {\partial y} = \left ( -3 \right ).1 = -3$$

Der Hauptgrund dafür ist, dass wir bei der Berechnung des Gradienten bei x nur bereits berechnete Werte und dq / dx (Ableitung der Knotenausgabe in Bezug auf die Eingabe desselben Knotens) verwendet haben. Wir haben lokale Informationen verwendet, um einen globalen Wert zu berechnen.

Schritte zum Trainieren eines neuronalen Netzwerks

Befolgen Sie diese Schritte, um ein neuronales Netzwerk zu trainieren -

• Für den Datenpunkt x im Datensatz leiten wir den Durchlauf mit x als Eingabe weiter und berechnen die Kosten c als Ausgabe.

• Wir machen einen Rückwärtsdurchlauf ab c und berechnen Gradienten für alle Knoten im Diagramm. Dies schließt Knoten ein, die die Gewichte des neuronalen Netzwerks darstellen.

• Wir aktualisieren dann die Gewichte, indem wir W = W - Lernrate * Gradienten machen.

• Wir wiederholen diesen Vorgang, bis die Stoppkriterien erfüllt sind.

Deep Learning hat zu guten Ergebnissen für einige Anwendungen wie Computer Vision, Sprachübersetzung, Bildunterschrift, Audiotranskription, Molekularbiologie, Spracherkennung, Verarbeitung natürlicher Sprache, selbstfahrende Autos, Erkennung von Hirntumoren, Sprachübersetzung in Echtzeit und Musik geführt Komposition, automatisches Spielen und so weiter.

Deep Learning ist der nächste große Sprung nach maschinellem Lernen mit einer fortgeschritteneren Implementierung. Derzeit ist es auf dem Weg, ein Industriestandard zu werden, der das Versprechen verspricht, beim Umgang mit unstrukturierten Rohdaten eine entscheidende Rolle zu spielen.

Deep Learning ist derzeit einer der besten Lösungsanbieter für eine Vielzahl realer Probleme. Entwickler erstellen KI-Programme, die anstelle zuvor festgelegter Regeln anhand von Beispielen lernen, um komplizierte Aufgaben zu lösen. Da Deep Data von vielen Datenwissenschaftlern verwendet wird, liefern tiefere neuronale Netze Ergebnisse, die immer genauer werden.

Die Idee ist, tiefe neuronale Netze zu entwickeln, indem die Anzahl der Trainingsschichten für jedes Netz erhöht wird. Die Maschine erfährt mehr über die Daten, bis sie so genau wie möglich sind. Entwickler können Deep-Learning-Techniken verwenden, um komplexe maschinelle Lernaufgaben zu implementieren, und KI-Netzwerke trainieren, um ein hohes Maß an Wahrnehmungserkennung zu erreichen.

Deep Learning findet seine Popularität in der Bildverarbeitung. Hier ist eine der erreichten Aufgaben die Bildklassifizierung, bei der bestimmte Eingabebilder als Katze, Hund usw. oder als Klasse oder Etikett klassifiziert werden, die das Bild am besten beschreiben. Wir als Menschen lernen sehr früh in unserem Leben, wie man diese Aufgabe erledigt, und haben die Fähigkeit, Muster schnell zu erkennen, aus dem Vorwissen zu verallgemeinern und uns an verschiedene Bildumgebungen anzupassen.

In diesem Kapitel werden wir Deep Learning mit den verschiedenen Bibliotheken und Frameworks in Verbindung bringen.

Deep Learning und Theano

Wenn wir mit der Codierung eines tiefen neuronalen Netzwerks beginnen möchten, ist es besser, eine Vorstellung davon zu haben, wie verschiedene Frameworks wie Theano, TensorFlow, Keras, PyTorch usw. funktionieren.

Theano ist eine Python-Bibliothek, die eine Reihe von Funktionen zum Aufbau tiefer Netze bietet, die schnell auf unserem Computer trainieren.

Theano wurde an der Universität von Montreal, Kanada, unter der Leitung von Yoshua Bengio, einem Deep-Net-Pionier, entwickelt.

Mit Theano können wir mathematische Ausdrücke mit Vektoren und Matrizen definieren und auswerten, die rechteckige Anordnungen von Zahlen sind.

Technisch gesehen können sowohl neuronale Netze als auch Eingabedaten als Matrizen dargestellt werden und alle Standardnetzoperationen können als Matrixoperationen neu definiert werden. Dies ist wichtig, da Computer Matrixoperationen sehr schnell ausführen können.

Wir können mehrere Matrixwerte parallel verarbeiten und wenn wir ein neuronales Netz mit dieser zugrunde liegenden Struktur aufbauen, können wir eine einzelne Maschine mit einer GPU verwenden, um enorme Netze in einem angemessenen Zeitfenster zu trainieren.

Wenn wir jedoch Theano verwenden, müssen wir das tiefe Netz von Grund auf aufbauen. Die Bibliothek bietet keine vollständige Funktionalität zum Erstellen eines bestimmten Deep-Net-Typs.

Stattdessen müssen wir jeden Aspekt des tiefen Netzes wie das Modell, die Ebenen, die Aktivierung, die Trainingsmethode und alle speziellen Methoden codieren, um eine Überanpassung zu verhindern.

Die gute Nachricht ist jedoch, dass Theano die Erstellung unserer Implementierung über vektorisierte Funktionen hinweg ermöglicht und uns eine hochoptimierte Lösung bietet.

Es gibt viele andere Bibliotheken, die die Funktionalität von Theano erweitern. TensorFlow und Keras können mit Theano als Backend verwendet werden.

Deep Learning mit TensorFlow

Googles TensorFlow ist eine Python-Bibliothek. Diese Bibliothek ist eine gute Wahl für die Erstellung kommerzieller Deep-Learning-Anwendungen.

TensorFlow ist aus einer anderen Bibliothek DistBelief V2 hervorgegangen, die Teil des Google Brain Project war. Diese Bibliothek zielt darauf ab, die Portabilität des maschinellen Lernens zu erweitern, damit Forschungsmodelle auf kommerzielle Anwendungen angewendet werden können.

Ähnlich wie die Theano-Bibliothek basiert TensorFlow auf Berechnungsgraphen, bei denen ein Knoten persistente Daten oder mathematische Operationen darstellt und Kanten den Datenfluss zwischen Knoten darstellen, bei denen es sich um ein mehrdimensionales Array oder einen Tensor handelt. daher der Name TensorFlow

Die Ausgabe einer Operation oder einer Reihe von Operationen wird als Eingabe in die nächste eingespeist.

Obwohl TensorFlow für neuronale Netze entwickelt wurde, funktioniert es gut für andere Netze, in denen die Berechnung als Datenflussdiagramm modelliert werden kann.

TensorFlow verwendet auch verschiedene Funktionen von Theano, wie z. B. Eliminierung gemeinsamer und Unterausdrücke, automatische Differenzierung, gemeinsame und symbolische Variablen.

Mit TensorFlow können verschiedene Arten von tiefen Netzen aufgebaut werden, z. B. Faltungsnetze, Autoencoder, RNTN, RNN, RBM, DBM / MLP usw.

Es gibt jedoch keine Unterstützung für die Hyperparameterkonfiguration in TensorFlow. Für diese Funktionalität können wir Keras verwenden.

Deep Learning und Keras

Keras ist eine leistungsstarke, benutzerfreundliche Python-Bibliothek zur Entwicklung und Bewertung von Deep-Learning-Modellen.

Es hat ein minimalistisches Design, das es uns ermöglicht, ein Netz Schicht für Schicht aufzubauen. trainiere es und lass es laufen.

Es umfasst die effizienten numerischen Berechnungsbibliotheken Theano und TensorFlow und ermöglicht es uns, neuronale Netzwerkmodelle in wenigen kurzen Codezeilen zu definieren und zu trainieren.

Es handelt sich um eine API für neuronale Netze auf hoher Ebene, mit deren Hilfe Deep Learning und künstliche Intelligenz umfassend genutzt werden können. Es läuft auf einer Reihe von Bibliotheken niedrigerer Ebene, darunter TensorFlow, Theano usw. Keras-Code ist portabel; Wir können ein neuronales Netzwerk in Keras implementieren, indem wir Theano oder TensorFlow als Back-End verwenden, ohne dass sich der Code ändert.

Bei dieser Implementierung von Deep Learning ist es unser Ziel, den Kundenabrieb oder die Abwanderung von Daten für eine bestimmte Bank vorherzusagen - welche Kunden diesen Bankdienst wahrscheinlich verlassen werden. Der verwendete Datensatz ist relativ klein und enthält 10000 Zeilen mit 14 Spalten. Wir verwenden die Anaconda-Distribution und Frameworks wie Theano, TensorFlow und Keras. Keras basiert auf Tensorflow und Theano, die als Backends fungieren.

# Artificial Neural Network
# Installing Theano
pip install --upgrade theano

# Installing Tensorflow
pip install –upgrade tensorflow

# Installing Keras
pip install --upgrade keras

Schritt 1: Datenvorverarbeitung

In[]:

# Importing the libraries
   import numpy as np
   import matplotlib.pyplot as plt
   import pandas as pd
 
# Importing the database
   dataset = pd.read_csv('Churn_Modelling.csv')

Schritt 2

Wir erstellen Matrizen der Merkmale des Datensatzes und der Zielvariablen in Spalte 14, die als "Beendet" gekennzeichnet ist.

Das anfängliche Aussehen der Daten ist wie folgt:

In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X

Ausgabe

Schritt 3

Y

Ausgabe

array([1, 0, 1, ..., 1, 1, 0], dtype = int64)

Schritt 4

Wir vereinfachen die Analyse, indem wir Zeichenfolgenvariablen codieren. Wir verwenden die ScikitLearn-Funktion 'LabelEncoder', um die verschiedenen Beschriftungen in den Spalten mit Werten zwischen 0 und n_classes-1 automatisch zu codieren.

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder() 
X[:,1] = labelencoder_X_1.fit_transform(X[:,1]) 
labelencoder_X_2 = LabelEncoder() 
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X

Ausgabe

In der obigen Ausgabe werden Ländernamen durch 0, 1 und 2 ersetzt. während männlich und weiblich durch 0 und 1 ersetzt werden.

Schritt 5

Labelling Encoded Data

Wir benutzen das gleiche ScikitLearn Bibliothek und eine andere Funktion namens OneHotEncoder um einfach die Spaltennummer zu übergeben und eine Dummy-Variable zu erstellen.

onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X

Jetzt repräsentieren die ersten beiden Spalten das Land und die vierte Spalte das Geschlecht.

Ausgabe

Wir teilen unsere Daten immer in Schulungs- und Testteile auf. Wir trainieren unser Modell anhand von Trainingsdaten und überprüfen dann die Genauigkeit eines Modells anhand von Testdaten, um die Effizienz des Modells zu bewerten.

Schritt 6

Wir verwenden ScikitLearns train_test_splitFunktion zum Aufteilen unserer Daten in Trainingssatz und Testsatz. Wir behalten das Split-Verhältnis von Zug zu Test bei 80:20.

#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)

Einige Variablen haben Werte in Tausend, während andere Werte in Zehnern oder Einsen haben. Wir skalieren die Daten so, dass sie repräsentativer sind.

Schritt 7

In diesem Code passen wir die Trainingsdaten mit dem an und transformieren sie StandardScalerFunktion. Wir standardisieren unsere Skalierung so, dass wir die gleiche angepasste Methode zum Transformieren / Skalieren von Testdaten verwenden.

# Feature Scaling

fromsklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Ausgabe

Die Daten sind jetzt richtig skaliert. Schließlich sind wir mit unserer Datenvorverarbeitung fertig. Jetzt beginnen wir mit unserem Modell.

Schritt 8

Wir importieren hier die benötigten Module. Wir benötigen das sequentielle Modul zum Initialisieren des neuronalen Netzwerks und das dichte Modul zum Hinzufügen der verborgenen Schichten.

# Importing the Keras libraries and packages 
import keras 
from keras.models import Sequential 
from keras.layers import Dense

Schritt 9

Wir werden das Modell als Klassifikator bezeichnen, da unser Ziel darin besteht, die Kundenabwanderung zu klassifizieren. Dann verwenden wir das sequentielle Modul zur Initialisierung.

#Initializing Neural Network 
classifier = Sequential()

Schritt 10

Wir fügen die verborgenen Ebenen einzeln mit der Dichtefunktion hinzu. Im folgenden Code sehen wir viele Argumente.

Unser erster Parameter ist output_dim. Dies ist die Anzahl der Knoten, die wir dieser Ebene hinzufügen.initist die Initialisierung des Stochastic Gradient Decent. In einem neuronalen Netzwerk weisen wir jedem Knoten Gewichte zu. Bei der Initialisierung sollten die Gewichte nahe Null sein, und wir initialisieren die Gewichte zufällig mit der einheitlichen Funktion. Dasinput_dimDer Parameter wird nur für die erste Ebene benötigt, da das Modell die Anzahl unserer Eingabevariablen nicht kennt. Hier beträgt die Gesamtzahl der Eingabevariablen 11. In der zweiten Ebene kennt das Modell automatisch die Anzahl der Eingabevariablen aus der ersten verborgenen Ebene.

Führen Sie die folgende Codezeile aus, um die Eingabeebene und die erste verborgene Ebene hinzuzufügen:

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu', input_dim = 11))

Führen Sie die folgende Codezeile aus, um die zweite verborgene Ebene hinzuzufügen:

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu'))

Führen Sie die folgende Codezeile aus, um die Ausgabeebene hinzuzufügen:

classifier.add(Dense(units = 1, kernel_initializer = 'uniform', 
activation = 'sigmoid'))

Schritt 11

Compiling the ANN

Wir haben unserem Klassifikator bisher mehrere Ebenen hinzugefügt. Wir werden sie jetzt mit dem kompilierencompileMethode. Argumente, die in der endgültigen Kompilierungssteuerung hinzugefügt wurden, vervollständigen das neuronale Netzwerk. Daher müssen wir in diesem Schritt vorsichtig sein.

Hier ist eine kurze Erklärung der Argumente.

Das erste Argument ist OptimizerDies ist ein Algorithmus, der verwendet wird, um den optimalen Satz von Gewichten zu finden. Dieser Algorithmus heißtStochastic Gradient Descent (SGD). Hier verwenden wir einen von mehreren Typen, den "Adam-Optimierer". Der SGD hängt vom Verlust ab, daher ist unser zweiter Parameter der Verlust. Wenn unsere abhängige Variable binär ist, verwenden wir die aufgerufene logarithmische Verlustfunktion‘binary_crossentropy’und wenn unsere abhängige Variable mehr als zwei Kategorien in der Ausgabe hat, verwenden wir ‘categorical_crossentropy’. Wir möchten die Leistung unseres neuronalen Netzwerks basierend auf verbessernaccuracy, so fügen wir hinzu metrics als Genauigkeit.

# Compiling Neural Network 
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Schritt 12

In diesem Schritt muss eine Reihe von Codes ausgeführt werden.

Anpassen des ANN an das Trainingsset

Wir trainieren jetzt unser Modell anhand der Trainingsdaten. Wir nehmen dasfitMethode für unser Modell. Wir optimieren auch die Gewichte, um die Modelleffizienz zu verbessern. Dazu müssen wir die Gewichte aktualisieren.Batch size ist die Anzahl der Beobachtungen, nach denen wir die Gewichte aktualisieren. Epochist die Gesamtzahl der Iterationen. Die Werte für Chargengröße und Epoche werden nach der Trial-and-Error-Methode ausgewählt.

classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)

Vorhersagen treffen und das Modell bewerten

# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)

Vorhersage einer einzelnen neuen Beobachtung

# Predicting a single new observation
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes

Schritt 13

Predicting the test set result

Das Vorhersageergebnis gibt Ihnen die Wahrscheinlichkeit, dass der Kunde das Unternehmen verlässt. Wir werden diese Wahrscheinlichkeit in binäre 0 und 1 umwandeln.

# Predicting the Test set results 
y_pred = classifier.predict(X_test) 
y_pred = (y_pred > 0.5)

new_prediction = classifier.predict(sc.transform
(np.array([[0.0, 0, 500, 1, 40, 3, 50000, 2, 1, 1, 40000]])))
new_prediction = (new_prediction > 0.5)

Schritt 14

Dies ist der letzte Schritt, in dem wir unsere Modellleistung bewerten. Wir haben bereits Originalergebnisse und können daher eine Verwirrungsmatrix erstellen, um die Genauigkeit unseres Modells zu überprüfen.

Making the Confusion Matrix

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)

Ausgabe

loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]

Aus der Verwirrungsmatrix kann die Genauigkeit unseres Modells berechnet werden als -

Accuracy = 1541+175/2000=0.858

We achieved 85.8% accuracy, was gut ist.

Der Vorwärtsausbreitungsalgorithmus

In diesem Abschnitt erfahren Sie, wie Sie Code schreiben, um die Vorwärtsausbreitung (Vorhersage) für ein einfaches neuronales Netzwerk durchzuführen.

Jeder Datenpunkt ist ein Kunde. Die erste Eingabe gibt an, wie viele Konten sie haben, und die zweite Eingabe gibt an, wie viele Kinder sie haben. Das Modell wird vorhersagen, wie viele Transaktionen der Benutzer im nächsten Jahr tätigt.

Die Eingabedaten sind als Eingabedaten vorinstalliert, und die Gewichte befinden sich in einem Wörterbuch, das als Gewichte bezeichnet wird. Das Array von Gewichten für den ersten Knoten in der verborgenen Schicht ist in Gewichten ['Knoten_0'] und für den zweiten Knoten in der verborgenen Schicht in Gewichten ['Knoten_1'] angegeben.

Die in den Ausgabeknoten eingespeisten Gewichte sind in Gewichten verfügbar.

Die gleichgerichtete lineare Aktivierungsfunktion

Eine "Aktivierungsfunktion" ist eine Funktion, die an jedem Knoten funktioniert. Es wandelt die Eingabe des Knotens in eine Ausgabe um.

Die gleichgerichtete lineare Aktivierungsfunktion ( ReLU genannt ) wird häufig in sehr leistungsstarken Netzwerken verwendet. Diese Funktion verwendet eine einzelne Zahl als Eingabe und gibt 0 zurück, wenn der Eingang negativ ist, und den Eingang als Ausgang, wenn der Eingang positiv ist.

Hier einige Beispiele -

• relu (4) = 4
• relu (-2) = 0

Wir füllen die Definition der Funktion relu () aus

• Wir verwenden die Funktion max (), um den Wert für die Ausgabe von relu () zu berechnen.
• Wir wenden die Funktion relu () auf node_0_input an, um node_0_output zu berechnen.
• Wir wenden die Funktion relu () auf node_1_input an, um node_1_output zu berechnen.

import numpy as np
input_data = np.array([-1, 2])
weights = {
   'node_0': np.array([3, 3]),
   'node_1': np.array([1, 5]),
   'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)

def relu(input):
   '''Define your relu activation function here'''
   # Calculate the value for the output of the relu function: output
   output = max(input,0)
      # Return the value just calculated
   return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)

# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)

# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])

# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output

Ausgabe

0.9950547536867305
-3

Anwenden des Netzwerks auf viele Beobachtungen / Datenzeilen

In diesem Abschnitt erfahren Sie, wie Sie eine Funktion namens Predict_with_network () definieren. Diese Funktion generiert Vorhersagen für mehrere Datenbeobachtungen, die aus dem oben genannten Netzwerk als Eingabedaten stammen. Die im obigen Netzwerk angegebenen Gewichte werden verwendet. Die Funktionsdefinition relu () wird ebenfalls verwendet.

Definieren wir eine Funktion namens Predict_with_network (), die zwei Argumente akzeptiert - input_data_row und weight - und eine Vorhersage aus dem Netzwerk als Ausgabe zurückgibt.

Wir berechnen die Eingabe- und Ausgabewerte für jeden Knoten und speichern sie als: node_0_input, node_0_output, node_1_input und node_1_output.

Um den Eingabewert eines Knotens zu berechnen, multiplizieren wir die relevanten Arrays miteinander und berechnen ihre Summe.

Um den Ausgabewert eines Knotens zu berechnen, wenden wir die Funktion relu () auf den Eingabewert des Knotens an. Wir verwenden eine 'for-Schleife', um über input_data zu iterieren -

Wir verwenden auch unser Predict_with_network (), um Vorhersagen für jede Zeile der input_data - input_data_row zu generieren. Wir hängen auch jede Vorhersage an die Ergebnisse an.

# Define predict_with_network()
def predict_with_network(input_data_row, weights):
   # Calculate node 0 value
   node_0_input = (input_data_row * weights['node_0']).sum()
   node_0_output = relu(node_0_input)
   
   # Calculate node 1 value
   node_1_input = (input_data_row * weights['node_1']).sum()
   node_1_output = relu(node_1_input)
   
   # Put node values into array: hidden_layer_outputs
   hidden_layer_outputs = np.array([node_0_output, node_1_output])
   
   # Calculate model output
   input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
   model_output = relu(input_to_final_layer)
# Return model output
   return(model_output)

# Create empty list to store prediction results
results = []
for input_data_row in input_data:
   # Append prediction to results
   results.append(predict_with_network(input_data_row, weights))
print(results)# Print results

Ausgabe

[0, 12]

Hier haben wir die Relu-Funktion verwendet, wobei Relu (26) = 26 und Relu (-13) = 0 und so weiter.

Tiefe mehrschichtige neuronale Netze

Hier schreiben wir Code für die Vorwärtsausbreitung eines neuronalen Netzwerks mit zwei verborgenen Schichten. Jede verborgene Schicht hat zwei Knoten. Die Eingabedaten wurden als vorinstalliertinput_data. Die Knoten in der ersten verborgenen Schicht heißen node_0_0 und node_0_1.

Ihre Gewichte sind als Gewichte ['node_0_0'] bzw. Gewichte ['node_0_1'] vorinstalliert.

Die Knoten in der zweiten verborgenen Schicht werden aufgerufen node_1_0 and node_1_1. Ihre Gewichte sind als vorinstalliertweights['node_1_0'] und weights['node_1_1'] beziehungsweise.

Anschließend erstellen wir eine Modellausgabe aus den ausgeblendeten Knoten mit den vorinstallierten Gewichten als weights['output'].

Wir berechnen node_0_0_input anhand seiner Gewichtungsgewichte ['node_0_0'] und der angegebenen input_data. Wenden Sie dann die Funktion relu () an, um node_0_0_output zu erhalten.

Wir machen dasselbe wie oben für node_0_1_input, um node_0_1_output zu erhalten.

Wir berechnen node_1_0_input anhand seiner Gewichtungsgewichte ['node_1_0'] und der Ausgaben der ersten verborgenen Ebene - hidden_0_outputs. Wir wenden dann die Funktion relu () an, um node_1_0_output zu erhalten.

Wir machen dasselbe wie oben für node_1_1_input, um node_1_1_output zu erhalten.

Wir berechnen model_output mit den Gewichten ['output'] und den Ausgaben des Arrays hidden_1_outputs der zweiten verborgenen Schicht. Wir wenden die Funktion relu () nicht auf diese Ausgabe an.

import numpy as np
input_data = np.array([3, 5])
weights = {
   'node_0_0': np.array([2, 4]),
   'node_0_1': np.array([4, -5]),
   'node_1_0': np.array([-1, 1]),
   'node_1_1': np.array([2, 2]),
   'output': np.array([2, 7])
}
def predict_with_network(input_data):
   # Calculate node 0 in the first hidden layer
   node_0_0_input = (input_data * weights['node_0_0']).sum()
   node_0_0_output = relu(node_0_0_input)
   
   # Calculate node 1 in the first hidden layer
   node_0_1_input = (input_data*weights['node_0_1']).sum()
   node_0_1_output = relu(node_0_1_input)
   
   # Put node values into array: hidden_0_outputs
   hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
   
   # Calculate node 0 in the second hidden layer
   node_1_0_input = (hidden_0_outputs*weights['node_1_0']).sum()
   node_1_0_output = relu(node_1_0_input)
   
   # Calculate node 1 in the second hidden layer
   node_1_1_input = (hidden_0_outputs*weights['node_1_1']).sum()
   node_1_1_output = relu(node_1_1_input)
   
   # Put node values into array: hidden_1_outputs
   hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
   
   # Calculate model output: model_output
   model_output = (hidden_1_outputs*weights['output']).sum()
      # Return model_output
   return(model_output)
output = predict_with_network(input_data)
print(output)

Ausgabe

364