Im vorherigen Weblog haben wir mit der Numpy-Bibliothek von Grund auf ein einfaches neuronales Netzwerk aufgebaut. Obwohl Numpy eine leistungsstarke Bibliothek ist, kann der Aufbau komplexer neuronaler Netze mühsam und zeitaufwändig sein. Hier kommt TensorFlow ins Spiel – eine beliebte Deep-Studying-Bibliothek, mit der wir problemlos komplexe neuronale Netze aufbauen und trainieren können. In diesem Weblog werden wir untersuchen, wie man mit TensorFlow ein neuronales Netzwerk aufbaut, und seine Vorteile gegenüber dem Aufbau eines neuronalen Netzwerks von Grund auf verstehen. Wir werden auch einige Schlüsselkonzepte in TensorFlow wie Tensoren, Operationen und Variablen behandeln und sie verwenden, um ein mehrschichtiges Perzeptron (MLP) für ein binäres Klassifizierungsproblem zu erstellen.
Was ist TensorFlow?
TensorFlow ist eine Open-Supply-Deep-Studying-Bibliothek, die 2015 vom Google Mind-Staff entwickelt wurde. Sie wird häufig zum Erstellen und Trainieren von Deep-Studying-Modellen, einschließlich neuronaler Netze, für verschiedene Aufgaben wie Bildklassifizierung, Verarbeitung natürlicher Sprache und verstärkendes Lernen verwendet. Die Bibliothek bietet Excessive-Stage-APIs wie Keras zum schnellen Erstellen und Trainieren von Modellen sowie Low-Stage-APIs für fortgeschrittene Benutzer, die ihre Modelle anpassen und optimieren möchten. TensorFlow bietet außerdem Instruments für Visualisierung, Modellbereitstellung und Produktion und ist damit eine umfassende Plattform für die Deep-Studying-Entwicklung.
Insgesamt ist TensorFlow eine beliebte und leistungsstarke Bibliothek für Deep Studying, und ihre Flexibilität und Skalierbarkeit machen sie zur ersten Wahl für Forscher und Entwickler auf diesem Gebiet.
Warum es TensorFlow heißt:
TensorFlow bietet eine versatile Architektur, die es Benutzern ermöglicht, komplexe mathematische Berechnungen als Datenflussdiagramme zu definieren und anzupassen. In diesem Diagramm stellen die Knoten mathematische Operationen dar und die Kanten stellen die Daten dar, die zwischen diesen Operationen in Type von Tensoren fließen.
Stellen Sie sich vor, Sie bereiten ein Sandwich zu und möchten ein Flussdiagramm der Schritte zur Herstellung erstellen. Sie beginnen damit, die verschiedenen Zutaten zu definieren, die Sie benötigen, und die Schritte zu deren Zubereitung festzulegen, z. B. das Schneiden von Brot, das Schneiden von Tomaten und das Verteilen von Butter. In diesem Flussdiagramm werden die verschiedenen Schritte zur Herstellung des Sandwichs durch Knoten und die Verbindungen zwischen ihnen durch Pfeile dargestellt. Beispielsweise könnten Sie einen Knoten für „Brot in Scheiben schneiden“ und einen weiteren Knoten für „Butter verteilen“ und einen Pfeil haben, der diese verbindet, um anzuzeigen, dass Sie Butter auf das geschnittene Brot streichen müssen.
Nehmen wir nun an, Sie möchten TensorFlow verwenden, um ein neuronales Netzwerk zu erstellen, das verschiedene Arten von Sandwiches erkennen kann. Sie können die Eingaben in das neuronale Netzwerk, beispielsweise Bilder von Sandwiches, als Tensoren darstellen – bei denen es sich lediglich um mehrdimensionale Datenarrays handelt. Jeder Schritt bei der Verarbeitung der Eingabedaten im neuronalen Netzwerk kann als Knoten im Datenflussdiagramm dargestellt werden, und die Daten, die zwischen diesen Knoten fließen, werden durch Tensoren dargestellt. Beispielsweise könnten Sie einen Knoten für „Faltung“ und einen anderen Knoten für „Pooling“ haben und der Ausgabetensor vom Faltungsknoten fließt als Eingabe in den Pooling-Knoten.
Zusammenfassend lässt sich sagen, dass Sie mit TensorFlow ein Datenflussdiagramm erstellen können, das die verschiedenen Vorgänge darstellt, die bei der Verarbeitung von Eingabedaten in einem neuronalen Netzwerk erforderlich sind. Die Knoten im Diagramm stellen mathematische Operationen dar, und die Kanten stellen die Daten dar, die zwischen diesen Operationen in Type von Tensoren fließen.
Wie installiere ich TensorFlow?
Hier sind die Schritte zur Set up von TensorFlow:
- Überprüfen Sie Ihre Systemanforderungen: TensorFlow kann auf verschiedenen Betriebssystemen wie Linux, macOS und Home windows installiert werden. Überprüfen Sie, ob Ihr System die von TensorFlow festgelegten Mindestanforderungen erfüllt.
- Python installieren: TensorFlow erfordert Python 3.6 oder höher. Sie können Python von der offiziellen Web site herunterladen und installieren.
- pip installieren: pip ist ein Paketmanager für Python. Sie können überprüfen, ob pip bereits auf Ihrem System installiert ist, indem Sie den Befehl ausführen
pip --version. Wenn nicht, können Sie es installieren, indem Sie den Anweisungen auf der offiziellen Web site folgen. - TensorFlow installieren: Sobald Sie pip installiert haben, können Sie TensorFlow mit dem folgenden Befehl installieren:
pip set up tensorflow. - Set up überprüfen: Nachdem die Set up abgeschlossen ist, können Sie sie überprüfen, indem Sie einen Python-Interpreter öffnen und ausführen
import tensorflow as tf. Wenn keine Fehler vorliegen, wurde TensorFlow erfolgreich installiert.
Aufbau eines neuronalen Netzwerks in der TensorFlow-Bibliothek
Dieser Codeblock zeigt, wie ein beliebter Datensatz mit TensorFlow und Keras importiert und geladen wird. Dies ist ein entscheidender Schritt beim Erstellen und Trainieren von Deep-Studying-Modellen.
Die ersten beiden Zeilen des Codes importieren die TensorFlow- und Keras-Bibliotheken. TensorFlow ist eine beliebte Deep-Studying-Bibliothek, die Instruments zum Erstellen und Trainieren von Deep-Studying-Modellen bereitstellt, während Keras eine Excessive-Stage-API ist, die den Prozess des Aufbaus neuronaler Netze vereinfacht.
Die nächste Codezeile importiert den MNIST-Datensatz aus Keras. Der MNIST-Datensatz ist ein weit verbreiteter Benchmark-Datensatz für Bildklassifizierungsaufgaben und besteht aus 60.000 Trainingsbildern und 10.000 Testbildern handgeschriebener Ziffern.
Die letzte Codezeile lädt den MNIST-Datensatz in vier Variablen: x_train, l_train, x_testUnd l_test. x_train Und x_test enthalten die Eingabebilder, whereas l_train Und l_test enthalten die entsprechenden Beschriftungen für jedes Bild. Der Trainingsdatensatz wird zum Trainieren des neuronalen Netzwerks verwendet, während der Testdatensatz zur Bewertung seiner Leistung verwendet wird.
#Knowledge Import import tensorflow as tf
from tensorflow import keras
from keras.datasets import mnist
(x_train, l_train), (x_test, l_test) = mnist.load_data()
Dieser Codeblock demonstriert einen allgemeinen Schritt bei der Datenvorverarbeitung für Klassifizierungsaufgaben, insbesondere für den MNIST-Datensatz. Das Ziel dieses Codes besteht darin, die Klassenbezeichnungen von einem einzelnen ganzzahligen Wert in einen One-Scorching-codierten Vektor umzuwandeln.
Die erste Codezeile importiert die NumPy-Bibliothek, die Unterstützung für mehrdimensionale Arrays und Matrizen bietet.
Die nächste Codezeile lädt den MNIST-Datensatz in vier Variablen: x_train, l_train, x_testUnd l_test. x_train Und x_test enthalten die Eingabebilder, whereas l_train Und l_test enthalten die entsprechenden Beschriftungen für jedes Bild.
Die folgenden zwei Codezeilen erstellen mithilfe von NumPy One-Scorching-codierte Vektoren für die Trainings- und Testbezeichnungen np.zeros Funktion. Der dtype Der Parameter gibt den Datentyp des resultierenden Arrays an und ist in diesem Fall auf festgelegt np.float32.
Der np.arange Die Funktion wird verwendet, um ein Array von Indizes zu erstellen, die dann verwendet werden, um die entsprechenden Elemente der One-Scorching-codierten Vektoren auf 1 zu setzen l_train Und l_test Arrays enthalten die ganzzahligen Klassenbezeichnungen und l_train.max() Und l_test.max() Gibt den maximalen Wert der Klassenbezeichnung zurück, der zur Bestimmung der Größe der One-Scorching-codierten Vektoren verwendet wird.
#Knowledge Preprocessingimport numpy as np
(x_train, l_train), (x_test, l_test) = mnist.load_data()
y_train = np.zeros((l_train.form[0], l_train.max()+1), dtype=np.float32)
y_train[np.arange(l_train.shape[0]), l_train] = 1
y_test = np.zeros((l_test.form[0], l_test.max()+1), dtype=np.float32)
y_test[np.arange(l_test.shape[0]), l_test] = 1
Dieser Codeblock definiert und trainiert ein neuronales Netzwerkmodell mithilfe der Keras-API in TensorFlow. Die Modellarchitektur verfügt über eine verborgene Schicht mit 15 Neuronen, eine Eingabeschicht mit abgeflachten 28×28-Bildern und eine Ausgabeschicht mit 10 Neuronen unter Verwendung einer Softmax-Aktivierungsfunktion.
Der compile() Die Methode wird verwendet, um das Modell für das Coaching zu konfigurieren. Der SGD Der Optimierer wird mit einer Lernrate von 0,1 verwendet, um die mittlere quadratische Fehlerverlustfunktion zu minimieren. Der metrics Der Parameter ist auf „Genauigkeit“ eingestellt, sodass das Modell basierend auf seiner Genauigkeit im Validierungssatz während des Trainings bewertet wird.
Der match() Methode wird zum Trainieren des Modells verwendet. Der x_train Und y_train Variablen sind die Eingabedaten bzw. Zielbezeichnungen und die batch_size Der Parameter wird auf 16 gesetzt, um die während des Trainings verwendete Batchgröße zu definieren. Der epochs Der Parameter ist auf 30 festgelegt, was definiert, wie oft die Trainingsdaten zum Aktualisieren der Modellgewichte verwendet werden.
Nach dem Coaching wird die consider() Die Methode wird verwendet, um die Leistung des Modells anhand des Testdatensatzes zu bewerten x_test Und y_test. Die Testgenauigkeit wird mit dem auf der Konsole ausgedruckt print() Funktion.
#Mannequin 1 : Neurons = 15 , Studying Charge = 0.1 , Batch Measurement = 16 , Epochs = 30model_1 = keras.Sequential([
keras.layers.Flatten(input_shape=(28,28)),
keras.layers.Dense(15,activation=tf.nn.sigmoid),
keras.layers.Dense(10,activation=tf.nn.softmax)
])
model_1.compile(optimizer = tf.keras.optimizers.SGD(0.1),
loss = 'mean_squared_error',
metrics=['accuracy'])
model_1.match(x_train,y_train,epochs=30,batch_size =16)
test_loss , test_acc = model_1.consider(x_test,y_test)
print('test_accuracy:',test_acc)
6 verschiedene Modelle wurden verwendet, um neuronale Netze mit TensorFlow zu trainieren und zu bewerten. Jedes Modell wird durch eine einzigartige Kombination von Hyperparametern identifiziert: Anzahl der Neuronen, Lernrate, Stapelgröße und Anzahl der Epochen.
- Modell 1 verfügt über 15 Neuronen, eine Lernrate von 0,1, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
- Modell 2 verfügt über 30 Neuronen, eine Lernrate von 0,1, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
- Modell 3 verfügt über 100 Neuronen, eine Lernrate von 0,1, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
- Modell 4 verfügt über 15 Neuronen, eine Lernrate von 3, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
- Modell 5 verfügt über 30 Neuronen, eine Lernrate von 3, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
- Modell 6 verfügt über 100 Neuronen, eine Lernrate von 3, eine Stapelgröße von 16 und ist für 30 Epochen trainiert.
Jedes Modell verwendet dieselben Eingabedaten, bestehend aus 28×28 Bildern handgeschriebener Ziffern aus dem MNIST-Datensatz, und dieselben Ausgabedaten, bestehend aus One-Scorching-codierten Klassenbezeichnungen. Allerdings können die unterschiedlichen Hyperparameter, die in jedem Modell verwendet werden, die Leistung des trainierten Modells erheblich beeinflussen.
Diese Tabelle zeigt einen Vergleich zwischen der Leistung neuronaler Netze, die mit der Numpy-Bibliothek und der TensorFlow-Bibliothek erstellt wurden. Zum Vergleich wurden sechs verschiedene Modelle verwendet, und die verwendete Bewertungsmetrik ist die Genauigkeit.
Die Tabelle zeigt, dass die TensorFlow-Bibliothek die Numpy-Bibliothek in allen sechs Modellen übertrifft. Die mit der TensorFlow-Bibliothek erzielte Genauigkeit liegt zwischen 36,41 % und 94,30 %, während die mit der Numpy-Bibliothek erzielte Genauigkeit zwischen 5,34 % und 10,24 % liegt.
+------------+---------------------------+--------------------+
| Mannequin Title | Numpy Library | TensorFlow Library |
+------------+---------------------------+--------------------+
| Model1 | 1024*100/1000 = 10.24% | 88.27 % |
| Model2 | 595*100/10000 = 5.95 % | 90.78 % |
| Model3 | 739*100/10000 = 7.39 % | 94.30 % |
| Model4 | 534*100/10000 = 5.34 % | 36.41 % |
| Model5 | 739*100/10000 = 7.39 % | 65.85 % |
| Model6 | 901*100/10000 = 9.01 % | 55.26 % |
+------------+---------------------------+--------------------+Dieser Genauigkeitsunterschied kann auf die Tatsache zurückgeführt werden, dass TensorFlow über integrierte Optimierungstechniken verfügt, die den Trainingsprozess neuronaler Netze verbessern können, wie z. B. automatische Differenzierung, Gradientenabstiegsoptimierung und GPU-Beschleunigung. Im Gegensatz dazu verfügt die Numpy-Bibliothek nicht über diese integrierten Optimierungstechniken, was es schwieriger macht, die Leistung des neuronalen Netzwerks zu optimieren. Insgesamt zeigen die Ergebnisse, dass die TensorFlow-Bibliothek im Vergleich zur Numpy-Bibliothek ein effizienteres und leistungsfähigeres Werkzeug zum Aufbau neuronaler Netze ist.
Abschluss
Der Weblog beschreibt den Prozess des Aufbaus neuronaler Netze mithilfe der TensorFlow-Bibliothek und vergleicht seine Leistung mit den neuronalen Netzen, die mithilfe der Numpy-Bibliothek erstellt wurden.
Der Weblog zeigt, dass die TensorFlow-Bibliothek die Numpy-Bibliothek in puncto Genauigkeit übertrifft. Dies wird auf die in TensorFlow integrierten Optimierungstechniken zurückgeführt, die den Trainingsprozess effizienter und leistungsfähiger machen.
Darüber hinaus beleuchtet der Weblog den Einfluss von Hyperparametern wie der Anzahl der Neuronen, der Lernrate, der Batch-Größe und der Anzahl der Epochen auf die Leistung des neuronalen Netzwerks. Die Modelle mit einer höheren Anzahl von Neuronen, geeigneten Lernraten und Stapelgrößen sowie mehr Epochen erzielen tendenziell eine höhere Genauigkeit.
Insgesamt kommt der Weblog zu dem Schluss, dass TensorFlow ein leistungsstarkes und effizientes Werkzeug zum Aufbau neuronaler Netze ist und aufgrund seiner integrierten Optimierungstechniken für diesen Zweck leistungsfähiger ist als die Numpy-Bibliothek. Darüber hinaus kann die richtige Abstimmung der Hyperparameter zu einer besseren Leistung des neuronalen Netzwerks führen.
