Datenwissenschaft

Python Tensorflow-Tutorial

Python Tensorflow-Tutorial
In dieser Lektion betrachten wir TensorFlow, eine Open-Source-Bibliothek für maschinelles Lernen, die zum Entwerfen, Erstellen und Trainieren von Deep-Learning-Modellen verwendet wird. Es ist möglich, numerische Berechnungen mit der TensorFlow-Bibliothek durchzuführen, bei denen Datenflussgraphen, in denen mathematische Operationen als Knoten dargestellt werden, und Daten als Kanten zwischen diesen Knoten dargestellt werden.

Insgesamt werden wir in dieser Lektion drei Hauptthemen behandeln:

  1. Was sind Tensoren und TensorFlow
  2. Anwenden von ML-Algorithmen mit TensorFlow
  3. TensorFlow-Anwendungsfälle

TensorFlow ist ein hervorragendes Python-Paket von Google, das das Datenfluss-Programmierparadigma für hochoptimierte mathematische Berechnungen nutzt. Einige der Funktionen von TensorFlow sind:

Aufgrund all dieser Funktionen und der Bandbreite an Machine-Learning-Algorithmen, die TensorFlow implementiert, ist es eine Bibliothek im Produktionsmaßstab. Lassen Sie uns in Konzepte in TensorFlow eintauchen, damit wir uns gleich danach die Hände mit Code schmutzig machen können.

TensorFlow installieren

Da wir die Python-API für TensorFlow verwenden werden, ist es gut zu wissen, dass sie sowohl mit Python 2.7 und 3.3+ Versionen. Lassen Sie uns die TensorFlow-Bibliothek installieren, bevor wir zu den tatsächlichen Beispielen und Konzepten übergehen. Es gibt zwei Möglichkeiten, dieses Paket zu installieren. Die erste beinhaltet die Verwendung des Python-Paketmanagers pip:

pip installieren tensorflow

Der zweite Weg bezieht sich auf Anaconda, wir können das Paket installieren als:

conda install -c conda-forge tensorflow

Fühlen Sie sich frei, auf den offiziellen Installationsseiten von TensorFlow nach nächtlichen Builds und GPU-Versionen zu suchen.

Ich werde den Anaconda-Manager für alle Beispiele in dieser Lektion verwenden. Ich werde ein Jupyter Notebook dafür starten:

Nachdem wir nun mit allen Importanweisungen zum Schreiben von Code bereit sind, fangen wir an, mit einigen praktischen Beispielen in das SciPy-Paket einzutauchen.

Was sind Tensoren??

Tensoren sind die grundlegenden Datenstrukturen, die in Tensorflow verwendet werden. Ja, sie sind nur eine Möglichkeit, Daten in Deep Learning darzustellen. Lassen Sie uns sie hier visualisieren:

Wie im Bild beschrieben, Tensoren können als n-dimensionales Array bezeichnet werden was es uns ermöglicht, Daten in komplexen Dimensionen darzustellen. Wir können uns jede Dimension als ein anderes Merkmal von Daten im Deep Learning vorstellen. Dies bedeutet, dass Tensoren ziemlich komplex werden können, wenn es um komplexe Datensätze mit vielen Funktionen geht.

Sobald wir wissen, was Tensoren sind, ist es meiner Meinung nach ziemlich einfach abzuleiten, was in TensorFlow passiert. Dieser Begriff bedeutet, wie Tensoren oder Features in Datasets fließen können, um eine wertvolle Ausgabe zu erzeugen, während wir verschiedene Operationen darauf ausführen.

TensorFlow mit Konstanten verstehen

Genau wie wir oben gelesen haben, können wir mit TensorFlow maschinelle Lernalgorithmen auf Tensoren ausführen, um wertvolle Ergebnisse zu erzeugen. Mit TensorFlow ist das Entwerfen und Trainieren von Deep-Learning-Modellen einfach.

TensorFlow kommt mit Gebäude Berechnungsgrafiken. Berechnungsgraphen sind Datenflussgraphen, in denen mathematische Operationen als Knoten und Daten als Kanten zwischen diesen Knoten dargestellt werden. Lassen Sie uns einen sehr einfachen Code-Schnipsel schreiben, um eine konkrete Visualisierung zu ermöglichen:

Tensorflow als tf importieren
x = tf.Konstante(5)
y = tf.Konstante(6)
z = x * y
drucken(z)

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Warum ist die Multiplikation falsch? Das hatten wir nicht erwartet. Dies geschah, weil wir Operationen mit TensorFlow nicht so ausführen können. Zuerst müssen wir beginnen a Session um den Berechnungsgraphen zum Laufen zu bringen,

Mit Sessions können wir kapseln die Kontrolle der Operationen und des Zustands von Tensoren. Dies bedeutet, dass eine Sitzung auch das Ergebnis eines Berechnungsgraphen speichern kann, um dieses Ergebnis in der Reihenfolge der Ausführung der Pipelines an die nächste Operation weiterzugeben. Lassen Sie uns jetzt eine Sitzung erstellen, um das richtige Ergebnis zu erhalten:

# Beginnen Sie mit dem Sitzungsobjekt
Sitzung = tf.Session()
# Geben Sie die Berechnung für die Sitzung an und speichern Sie sie
Ergebnis = Sitzung.laufen(z)
# Berechnungsergebnis ausdrucken
drucken (Ergebnis)
# Sitzung schließen
Session.schließen()

Dieses Mal haben wir die Sitzung erhalten und ihr die Berechnungen zur Verfügung gestellt, die sie für die Ausführung auf den Knoten benötigt. Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Obwohl wir eine Warnung von TensorFlow erhalten haben, haben wir immer noch die korrekte Ausgabe der Berechnung erhalten.

Einzelelement-Tensor-Operationen

Genau wie wir im letzten Beispiel zwei konstante Tensoren multipliziert haben, haben wir in TensorFlow viele andere Operationen, die an einzelnen Elementen ausgeführt werden können:

Einzelelementoperationen bedeuten, dass die Operationen auch bei Bereitstellung eines Arrays für jedes Element dieses Arrays ausgeführt werden. Beispielsweise:

Tensorflow als tf importieren
numpy als np importieren
Tensor = np.Array([2, 5, 8])
Tensor = tf.convert_to_tensor(tensor, dtype=tf.Schwimmer64)
mit tf.Session() als Sitzung:
drucken (Sitzung.laufen (tf.cos(Tensor)))

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Wir haben hier zwei wichtige Konzepte verstanden:

  1. Jedes NumPy-Array kann mit Hilfe der convert_to_tensor-Funktion leicht in einen Tensor umgewandelt werden
  2. Die Operation wurde für jedes der NumPy-Array-Elemente ausgeführt

Platzhalter und Variablen

In einem der vorherigen Abschnitte haben wir uns angesehen, wie wir Tensorflow-Konstanten verwenden können, um Rechengraphen zu erstellen. Aber TensorFlow ermöglicht es uns auch, Eingaben während des Laufs zu nehmen, damit der Berechnungsgraph dynamisch sein kann. Dies ist mit Hilfe von Platzhaltern und Variablen möglich.

Tatsächlich enthalten Platzhalter keine Daten und müssen während der Laufzeit gültige Eingaben erhalten und wie erwartet erzeugen sie ohne Eingabe einen Fehler.

Ein Platzhalter kann als Vereinbarung in einem Graphen bezeichnet werden, dass eine Eingabe sicher zur Laufzeit bereitgestellt wird. Hier ist ein Beispiel für Platzhalter:

Tensorflow als tf importieren
# Zwei Platzhalter
x = tf. Platzhalter (tf.Schwimmer32)
y = tf. Platzhalter (tf.Schwimmer32)
# Multiplikationsoperation w . zuweisen.r.t. ein & b zum Knoten mul
z = x * y
# Erstellen Sie eine Sitzung
Sitzung = tf.Session()
# Werte für Platzhalter übergeben
Ergebnis = Sitzung.run(z, x: [2, 5], y: [3, 7])
print('x und y multiplizieren:', Ergebnis)

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Da wir nun über Platzhalter Bescheid wissen, wenden wir uns den Variablen zu. Wir wissen, dass sich die Ausgabe einer Gleichung für dieselbe Menge von Eingaben im Laufe der Zeit ändern kann. Wenn wir also unsere Modellvariable trainieren, kann sie ihr Verhalten im Laufe der Zeit ändern. In diesem Szenario ermöglicht uns eine Variable, diese trainierbaren Parameter zu unserem Berechnungsgraphen hinzuzufügen. Eine Variable kann wie folgt definiert werden:

x = tf.Variabel( [5.2], dtyp = tf.Schwimmer32 )

In der obigen Gleichung ist x eine Variable, deren Anfangswert und der Datentyp. Wenn wir den Datentyp nicht bereitstellen, wird er von TensorFlow mit seinem Anfangswert abgeleitet. Siehe TensorFlow-Datentypen hier.

Im Gegensatz zu einer Konstanten müssen wir eine Python-Funktion aufrufen, um alle Variablen eines Graphen zu initialisieren:

init = tf.global_variables_initializer()
Session.ausführen (initiieren)

Stellen Sie sicher, dass Sie die obige TensorFlow-Funktion ausführen, bevor wir unseren Graphen verwenden.

Lineare Regression mit TensorFlow

Lineare Regression ist einer der am häufigsten verwendeten Algorithmen, um eine Beziehung in gegebenen kontinuierlichen Daten herzustellen. Diese Beziehung zwischen den Koordinatenpunkten, sagen wir x und y, heißt a Hypothese. Wenn wir über lineare Regression sprechen, ist die Hypothese eine gerade Linie:

y = mx + c

Hier ist m die Steigung der Geraden und hier ist es ein Vektor, der darstellt Gewichte. c ist der konstante Koeffizient (y-Achsenabschnitt) und repräsentiert hier den Vorspannen. Das Gewicht und der Bias werden als bezeichnet Parameter des Modells.

Lineare Regressionen ermöglichen es uns, die Werte von Gewichtung und Verzerrung so zu schätzen, dass wir ein Minimum haben Kostenfunktion. Schließlich ist x die unabhängige Variable in der Gleichung und y ist die abhängige Variable. Beginnen wir nun mit dem Aufbau des linearen Modells in TensorFlow mit einem einfachen Code-Snippet, das wir erklären werden:

Tensorflow als tf importieren
# Variablen für Parametersteigung (W) mit Anfangswert als 1.1
W = tf.Variable([1.1], tf.Schwimmer32)
# Variable für Bias (b) mit Anfangswert als -1.1
b = tf.Variable([-1.1], tf.Schwimmer32)
# Platzhalter zum Bereitstellen von Eingaben oder unabhängigen Variablen, gekennzeichnet durch x
x = tf.Platzhalter (tf.Schwimmer32)
# Liniengleichung oder die lineare Regression
linear_model = W * x + b
# Initialisieren aller Variablen
Sitzung = tf.Session()
init = tf.global_variables_initializer()
Session.ausführen (initiieren)
# Regressionsmodell ausführen
drucken (Sitzung.run(linear_model x: [2, 5, 7, 9]))

Hier haben wir genau das getan, was wir zuvor erklärt haben, fassen wir hier zusammen:

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Der einfache Codeausschnitt liefert nur eine grundlegende Idee, wie wir ein Regressionsmodell erstellen können build. Aber wir müssen noch einige weitere Schritte ausführen, um das von uns erstellte Modell zu vervollständigen:

Verlustfunktion und Modellvalidierung

Um das Modell zu validieren, benötigen wir ein Maß dafür, wie stark die aktuelle Ausgabe von der erwarteten Ausgabe abweicht. Es gibt verschiedene Verlustfunktionen, die hier zur Validierung verwendet werden können, aber wir werden uns eine der gebräuchlichsten Methoden ansehen, Summe des quadrierten Fehlers oder SSE.

Die Gleichung für SSE lautet:

E = 1/2 * (t - y)2

Hier:

Lassen Sie uns nun ein Code-Snippet in Fortsetzung des letzten Snippets schreiben, um den Verlustwert widerzuspiegeln:

y = tf.Platzhalter (tf.Schwimmer32)
error = linear_model - y
squared_errors = tf.Quadrat (Fehler)
Verlust = tf.Reduce_sum(squared_errors)
drucken (Sitzung.run(Verlust, x:[2, 5, 7, 9], y:[2, 4, 6, 8]))

Wenn wir dieses Beispiel ausführen, sehen wir die folgende Ausgabe:

Offensichtlich ist der Verlustwert für das gegebene lineare Regressionsmodell sehr niedrig.

Fazit

In dieser Lektion haben wir uns eines der beliebtesten Deep-Learning- und Machine-Learning-Pakete angesehen, TensorFlow. Wir haben auch ein lineares Regressionsmodell mit sehr hoher Genauigkeit erstellt.

So installieren Sie das Google Cloud SDK unter Ubuntu 20.04?
Das Google Cloud SDK gibt uns die Möglichkeit, über ein Terminal auf Google Cloud zuzugreifen. Es ist ein Toolkit für die Erstellung, das viele Befehl...
MX Linux vs. Ubuntu
Linux ist keine begrenzte Plattform, da es mehrere Betriebssysteme für mehrere Werke hat und den Benutzern eine erstaunliche Unterstützung bietet. Wir...
Ubuntu Aktivieren und Deaktivieren der Netzwerkschnittstelle
Wenn Sie als Linux-Administrator arbeiten, ist das gesamte Netzwerkkonfigurationsmanagement des Systems auch in Ihrem Job enthalten. Bei Linux-Servern...