Einführung in Tensor mit Tensorflow

Blog

Was ist Tensorflow und wie funktioniert es

TensorFlow ist eine Open-Source-Softwarebibliothek für die Datenflussprogrammierung für eine Reihe von Aufgaben. Es ist eine symbolische Mathematikbibliothek und wird auch für Anwendungen des maschinellen Lernens verwendet, wie z Neuronale Netze . TensorFlow wurde im November 2015 von Google als Open-Source-Software bereitgestellt. Seitdem hat sich TensorFlow zum beliebtesten Repository für maschinelles Lernen auf Github entwickelt. ( https://github.com/tensorflow/tensorflow )



Warum TensorFlow? Die Popularität von TensorFlow ist auf viele Dinge zurückzuführen, vor allem aber auf das rechnergestützte Graphenkonzept, die automatische Differenzierung und die Anpassungsfähigkeit der Tensorflow-Python-API-Struktur . Dies macht die Lösung echter Probleme mit TensorFlow für die meisten Programmierer zugänglich.

Die Tensorflow-Engine von Google bietet eine einzigartige Möglichkeit, Probleme zu lösen. Dieser einzigartige Weg ermöglicht es, Probleme des maschinellen Lernens sehr effizient zu lösen. Wir werden die grundlegenden Schritte behandeln, um die Funktionsweise von Tensorflow zu verstehen.



Was ist Tensor in Tensorflow?

TensorFlow , wie der Name schon sagt, ist ein Framework zum Definieren und Ausführen von Berechnungen mit Tensoren. Ein Tensor ist eine Verallgemeinerung von Vektoren und Matrizen auf potenziell höhere Dimensionen. Intern repräsentiert TensorFlow Tensoren als n-dimensionale Arrays von Basisdatentypen. Jedes Element im Tensor hat denselben Datentyp, und der Datentyp ist immer bekannt. Die Form (d. h. die Anzahl der Dimensionen und die Größe jeder Dimension) ist möglicherweise nur teilweise bekannt. Die meisten Operationen erzeugen Tensoren mit vollständig bekannten Formen, wenn auch die Formen ihrer Eingaben vollständig bekannt sind, aber in einigen Fällen ist es nur möglich, die Form eines Tensors zur Zeit der Graphausführung zu finden.



Allgemeine TensorFlow-Algorithmus-Umrisse

Hier stellen wir den allgemeinen Ablauf von . vor Tensorflow-Algorithmen .

  1. Daten importieren oder generieren

Alle unsere Algorithmen für maschinelles Lernen wird von den Daten abhängen. In der Praxis werden wir entweder Daten generieren oder eine externe Datenquelle verwenden. Manchmal ist es besser, sich auf generierte Daten zu verlassen, weil wir das erwartete Ergebnis wissen wollen. Und auch tensorflow ist mit bekannten Datensätzen wie MNIST, CIFAR-10 usw. vorinstalliert.

  1. Daten transformieren und normalisieren

Die Daten haben normalerweise nicht die richtige Dimension oder den richtigen Typ, den unsere Tensorflow-Algorithmen erwarten. Wir müssen unsere Daten transformieren, bevor wir sie verwenden können. Die meisten Algorithmen erwarten auch normalisierte Daten. Tensorflow verfügt über integrierte Funktionen, die die Daten für Sie normalisieren können.

data = tf.nn.batch_norm_with_global_normalization(...)
  1. Algorithmusparameter einstellen

Unsere Algorithmen haben normalerweise eine Reihe von Parametern, die wir während des gesamten Verfahrens konstant halten. Dies können beispielsweise die Anzahl der Iterationen, die Lernrate oder andere feste Parameter unserer Wahl sein. Es wird als sinnvoll erachtet, diese gemeinsam zu initialisieren, damit der Leser oder Benutzer sie leicht finden kann.

learning_rate = 0.001 iterations = 1000
  1. Variablen und Platzhalter initialisieren

Tensorflow hängt davon ab, dass wir ihm sagen, was es ändern kann und was nicht. Tensorflow modifiziert die Variablen während der Optimierung, um eine Verlustfunktion zu minimieren. Dazu speisen wir Daten über Platzhalter ein. Wir müssen beide, Variablen und Platzhalter, mit Größe und Typ initialisieren, damit Tensorflow weiß, was zu erwarten ist.

a_var = tf.constant(42) x_input = tf.placeholder(tf.float32, [None, input_size]) y_input = tf.placeholder(tf.fload32, [None, num_classes])
  1. Definieren Sie die Modellstruktur

Nachdem wir die Daten haben und unsere Variablen und Platzhalter initialisiert haben, müssen wir das Modell definieren. Dies geschieht durch den Aufbau eines Rechengraphen. Wir teilen Tensorflow mit, welche Operationen an den Variablen und Platzhaltern durchgeführt werden müssen, um zu unseren Modellvorhersagen zu gelangen.

y_pred = tf.add(tf.mul(x_input, weight_matrix), b_matrix)
  1. Deklarieren Sie die Verlustfunktionen

Nach der Definition des Modells müssen wir in der Lage sein, die Ausgabe auszuwerten. Hier deklarieren wir die Verlustfunktion. Die Verlustfunktion ist sehr wichtig, da sie uns sagt, wie weit unsere Vorhersagen von den tatsächlichen Werten abweichen.

loss = tf.reduce_mean(tf.square(y_actual – y_pred))
  1. Modell initialisieren und trainieren

Nachdem wir nun alles eingerichtet haben, erstellen wir eine Instanz oder unser Diagramm und speisen die Daten durch die Platzhalter ein und lassen Tensorflow die Variablen ändern, um unsere Trainingsdaten besser vorherzusagen. Hier ist eine Möglichkeit, den Berechnungsgraphen zu initialisieren.

with tf.Session(graph=graph) as session: ... session.run(...) ...

Beachten Sie, dass wir unseren Graphen auch mit initiieren können

session = tf.Session(graph=graph) session.run(…)
  1. Bewerten Sie das Modell (optional)

Nachdem wir das Modell erstellt und trainiert haben, sollten wir das Modell evaluieren, indem wir uns ansehen, wie gut es mit neuen Daten anhand bestimmter Kriterien abschneidet.

  1. Neue Ergebnisse vorhersagen (optional)

Es ist auch wichtig zu wissen, wie man Vorhersagen zu neuen, ungesehenen Daten macht. Das können wir mit all unseren Modellen machen, wenn wir sie erst einmal trainiert haben.

Zusammenfassung

In Tensorflow müssen wir die Daten, Variablen, Platzhalter und das Modell einrichten, bevor wir das Programm anweisen, die Variablen zu trainieren und zu ändern, um die Vorhersagen zu verbessern. Tensorflow erreicht dies durch den Rechengraphen. Wir weisen es an, eine Verlustfunktion zu minimieren, und Tensorflow tut dies, indem es die Variablen im Modell modifiziert. Tensorflow weiß, wie man die Variablen ändert, da es die Berechnungen im Modell verfolgt und automatisch die Gradienten für jede Variable berechnet. Aus diesem Grund können wir sehen, wie einfach es sein kann, Änderungen vorzunehmen und verschiedene Datenquellen auszuprobieren.

Insgesamt sind Algorithmen in TensorFlow so konzipiert, dass sie zyklisch sind. Wir richten diesen Zyklus als Rechendiagramm ein und (1) speisen Daten durch die Platzhalter ein, (2) berechnen die Ausgabe des Rechendiagramms, (3) vergleichen die Ausgabe mit der gewünschten Ausgabe mit einer Verlustfunktion, (4) modifizieren die Modellvariablen gemäß der automatischen Backpropagation, und schließlich (5) den Vorgang wiederholen, bis ein Stoppkriterium erfüllt ist.

Einführung in Tensor mit Tensorflow
Nun beginnt die praktische Sitzung mit tensorflow und der Implementierung von Tensoren damit.

Zuerst müssen wir die erforderlichen Bibliotheken importieren.

import tensorflow as tf from tensorflow.python.framework import ops ops.reset_default_graph()

Dann um die Grafiksitzung zu starten

sess = tf.Session()

Jetzt kommt der Hauptteil, nämlich Tensoren zu erzeugen.

TensorFlow verfügt über eine integrierte Funktion zum Erstellen von Tensoren zur Verwendung in Variablen. Beispielsweise können wir mit der Funktion tf.zeros() wie folgt einen mit Nullen gefüllten Tensor einer vordefinierten Form erstellen.

my_tensor = tf.zeros([1,20])

Wir können Tensoren auswerten, indem wir eine run()-Methode in unserer Sitzung aufrufen.

sess.run(my_tensor)

TensorFlow-Algorithmen müssen wissen, welche Objekte Variablen und welche Konstanten sind. Also erstellen wir eine Variable mit der TensorFlow-Funktion tf.Variable(). Beachten Sie, dass Sie sess.run(my_var) nicht ausführen können, da dies zu einem Fehler führen würde. Da TensorFlow mit Berechnungsgraphen arbeitet, müssen wir eine Variableninitialisierungsoperation erstellen, um Variablen auszuwerten. Für dieses Skript können wir jeweils eine Variable initialisieren, indem wir die Variablenmethode my_var.initializer aufrufen.

my_var = tf.Variable(tf.zeros([1,20])) sess.run(my_var.initializer) sess.run(my_var)

Ausgabe:

array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)

Lassen Sie uns nun unsere Variable erstellen, um Dimensionen mit einer bestimmten Form zu verarbeiten und dann die Variablen mit allen „1“ oder „0“ zu initialisieren.

row_dim = 2 col_dim = 3 zero_var = tf.Variable(tf.zeros([row_dim, col_dim])) ones_var = tf.Variable(tf.ones([row_dim, col_dim]))

Jetzt können wir die Werte von ihnen auswerten und wir können die Initialisierungsmethoden erneut für unsere Variablen ausführen.

sess.run(zero_var.initializer) sess.run(ones_var.initializer) print(sess.run(zero_var)) print(sess.run(ones_var))

Ausgabe:

[[ 0. 0. 0.] [ 0. 0. 0.]] [[ 1. 1. 1.] [ 1. 1. 1.]]

Und diese Liste wird weitergehen. Der Rest wird für Sie zum Lernen sein, folgen Sie diesem Jupyter-Notizbuch von mir, um mehr Informationen über die Tensoren von zu erhalten Hier .

Visualisierung der Variablenerstellung in TensorBoard

Um die Erstellung von Variablen in Tensorboard zu visualisieren, werden wir den Berechnungsgraphen zurücksetzen und eine globale Initialisierungsoperation erstellen.

# Reset graph ops.reset_default_graph() # Start a graph session sess = tf.Session() # Create variable my_var = tf.Variable(tf.zeros([1,20])) # Add summaries to tensorboard merged = tf.summary.merge_all() # Initialize graph writer: writer = tf.summary.FileWriter('/tmp/variable_logs', graph=sess.graph) # Initialize operation initialize_op = tf.global_variables_initializer() # Run initialization of variable sess.run(initialize_op)

Führen Sie nun den folgenden Befehl in cmd aus.

tensorboard --logdir=/tmp

Und es wird uns die URL mitteilen, zu der wir in unserem Browser navigieren können, um Tensorboard anzuzeigen, um Ihre Verlustdiagramme zu erhalten.

Code, um alle Arten von Tensoren zu erstellen und auszuwerten.

Empfohlen: Bitte versuchen Sie Ihren Ansatz auf {HIER} zuerst, bevor Sie mit der Lösung fortfahren.

import tensorflow as tf from tensorflow.python.framework import ops ops.reset_default_graph() # Introduce tensors in tf # Get graph handle sess = tf.Session() my_tensor = tf.zeros([1,20]) # Declare a variable my_var = tf.Variable(tf.zeros([1,20])) # Different kinds of variables row_dim = 2 col_dim = 3 # Zero initialized variable zero_var = tf.Variable(tf.zeros([row_dim, col_dim])) # One initialized variable ones_var = tf.Variable(tf.ones([row_dim, col_dim])) # shaped like other variable sess.run(zero_var.initializer) sess.run(ones_var.initializer) zero_similar = tf.Variable(tf.zeros_like(zero_var)) ones_similar = tf.Variable(tf.ones_like(ones_var)) sess.run(ones_similar.initializer) sess.run(zero_similar.initializer) # Fill shape with a constant fill_var = tf.Variable(tf.fill([row_dim, col_dim], -1)) # Create a variable from a constant const_var = tf.Variable(tf.constant([8, 6, 7, 5, 3, 0, 9])) # This can also be used to fill an array: const_fill_var = tf.Variable(tf.constant(-1, shape=[row_dim, col_dim])) # Sequence generation linear_var = tf.Variable(tf.linspace(start=0.0, stop=1.0, num=3)) # Generates [0.0, 0.5, 1.0] includes the end sequence_var = tf.Variable(tf.range(start=6, limit=15, delta=3)) # Generates [6, 9, 12] doesn't include the end # Random Numbers # Random Normal rnorm_var = tf.random_normal([row_dim, col_dim], mean=0.0, stddev=1.0) # Add summaries to tensorboard merged = tf.summary.merge_all() # Initialize graph writer: writer = tf.summary.FileWriter('/tmp/variable_logs', graph=sess.graph) # Initialize operation initialize_op = tf.global_variables_initializer() # Run initialization of variable sess.run(initialize_op)

Ausgabe:

Einführung in Tensor mit Tensorflow

Referenzlink:

1) Tensorflow-Dokumentation

Roadrunner E-Mail-Login tampa

#tensorflow #maschinenlernen #deep-learning #data-science #python

www.geeksforgeeks.org

Einführung in Tensor mit Tensorflow

Einführung in Tensorflow und Tensor sowie Implementierung von Tensoren in Tensorflow.