TensorFlow-Grundlagen: Tensor, Form, Typ, Sitzungen & Betreiber

Was ist ein Tensor?

Der Name von Tensorflow leitet sich direkt von seinem Kerngerüst ab: Tensor. In Tensorflow beinhalten alle Berechnungen Tensoren. Ein Tensor ist ein Vektor oder eine Matrix mit n Dimensionen, die alle Arten von Daten darstellt. Alle Werte in einem Tensor enthalten den gleichen Datentyp mit einer bekannten (oder teilweise bekannten) Form. Die Form der Daten ist die Dimensionalität der Matrix oder des Arrays.

Ein Tensor kann aus den Eingabedaten oder dem Ergebnis einer Berechnung stammen. In TensorFlow werden alle Operationen in einem Diagramm ausgeführt. Das Diagramm ist eine Reihe von Berechnungen, die nacheinander durchgeführt werden. Jede Operation wird als Operationsknoten bezeichnet und ist miteinander verbunden.

Das Diagramm zeigt die Operationen und Verbindungen zwischen den Knoten. Die Werte werden jedoch nicht angezeigt. Die Kante der Knoten ist der Tensor, dh eine Möglichkeit, die Operation mit Daten zu füllen.

Beim maschinellen Lernen werden Modelle mit einer Liste von Objekten gespeist, die als Merkmalsvektoren bezeichnet werden. Ein Merkmalsvektor kann von einem beliebigen Datentyp sein. Der Merkmalsvektor ist normalerweise die primäre Eingabe zum Auffüllen eines Tensors. Diese Werte fließen durch den Tensor in einen Operationsknoten und das Ergebnis dieser Operation / Berechnung erzeugt einen neuen Tensor, der wiederum in einer neuen Operation verwendet wird. Alle diese Vorgänge können in der Grafik angezeigt werden.

In diesem Tutorial lernen Sie die Grundlagen von TensorFlow kennen.

• Was ist ein Tensor?
• Darstellung eines Tensors
• Arten von Tensoren
• Erstellen Sie einen Tensor mit n-Dimension
• Form des Tensors
• Art der Daten
• Operator erstellen
• Einige nützliche TensorFlow-Operatoren
• Variablen
• Platzhalter
• Session
• Graph

Darstellung eines Tensors

In TensorFlow ist ein Tensor eine Sammlung von Merkmalsvektoren (dh ein Array) mit n-Dimensionen. Wenn wir zum Beispiel eine 2x3-Matrix mit Werten von 1 bis 6 haben, schreiben wir:

Darstellung eines Tensors

TensorFlow repräsentiert diese Matrix als:

[[1, 2, 3],[4, 5, 6]] 

Wenn wir eine dreidimensionale Matrix mit Werten von 1 bis 8 erstellen, haben wir:

TensorFlow repräsentiert diese Matrix als:

[ [[1, 2],[[3, 4],[[5, 6],[[7,8] ] 

Hinweis: Ein Tensor kann mit einem Skalar dargestellt werden oder eine Form von mehr als drei Dimensionen haben. Es ist nur komplizierter, höhere Dimensionsebenen zu visualisieren.

Arten von Tensoren

In TensorFlow durchlaufen alle Berechnungen einen oder mehrere Tensoren. Ein tf.tensor ist ein Objekt mit drei Eigenschaften:

• Ein eindeutiges Etikett (Name)
• Eine Dimension (Form)
• Ein Datentyp (dtype)

Jede Operation, die Sie mit TensorFlow ausführen, beinhaltet die Manipulation eines Tensors. Es gibt vier Haupttensortypen, die Sie erstellen können:

• tf.Variable
• tf.konstant
• tf.placeholder
• tf.SparseTensor

In diesem Tutorial erfahren Sie, wie Sie eine tf.constant und eine tf.Variable erstellen.

Bevor wir das Tutorial durcharbeiten, stellen Sie sicher, dass Sie die Conda-Umgebung mit TensorFlow aktivieren. Wir haben diese Umgebung hallo-tf genannt.

Für MacOS-Benutzer:

source activate hello-tf 

Für Windows-Benutzer:

activate hello-tf 

Nachdem Sie dies getan haben, können Sie den Tensorflow importieren

# Import tfimport tensorflow as tf 

Erstellen Sie einen Tensor mit n-Dimension

Sie beginnen mit der Erstellung eines Tensors mit einer Dimension, nämlich einem Skalar.

Um einen Tensor zu erstellen, können Sie tf.constant () verwenden, wie im folgenden Beispiel für die TensorFlow-Tensorform gezeigt:

tf.constant(value, dtype, name = "")arguments- `value`: Value of n dimension to define the tensor. Optional- `dtype`: Define the type of data:- `tf.string`: String variable- `tf.float32`: Float variable- `tf.int16`: Integer variable- "name": Name of the tensor. Optional. By default, `Const_1:0` 

Führen Sie den folgenden Code aus, um einen Tensor der Dimension 0 zu erstellen

## rank 0# Default namer1 = tf.constant(1, tf.int16)print(r1)

Ausgabe

Tensor("Const:0", shape=(), dtype=int16) 

# Named my_scalarr2 = tf.constant(1, tf.int16, name = "my_scalar")print(r2) 

Ausgabe

Tensor("my_scalar:0", shape=(), dtype=int16) 

Jeder Tensor wird durch den Tensornamen angezeigt. Jedes Tensorobjekt wird mit Tensorattributen wie einer eindeutigen Bezeichnung (Name), einer Dimension (Form) und TensorFlow-Datentypen (dtype) definiert.

Sie können einen Tensor mit Dezimalwerten oder mit einer Zeichenfolge definieren, indem Sie den Datentyp ändern.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_string = tf.constant("Guru99", tf.string)print(r1_string) 

Ausgabe

Tensor("Const_1:0", shape=(), dtype=float32)Tensor("Const_2:0", shape=(), dtype=string) 

Ein Tensor der Dimension 1 kann wie folgt erstellt werden:

## Rank 1r1_vector = tf.constant([1,3,5], tf.int16)print(r1_vector)r2_boolean = tf.constant([True, True, False], tf.bool)print(r2_boolean) 

Ausgabe

Tensor("Const_3:0", shape=(3,), dtype=int16)Tensor("Const_4:0", shape=(3,), dtype=bool) 

Sie können feststellen, dass die TensorFlow-Form nur aus einer Spalte besteht.

Um ein Array mit 2 Tensordimensionen zu erstellen, müssen Sie die Klammern nach jeder Zeile schließen. Überprüfen Sie das folgende Beispiel für die Keras-Tensor-Form

## Rank 2r2_matrix = tf.constant([ [1, 2],[3, 4] ],tf.int16)print(r2_matrix) 

Ausgabe

Tensor("Const_5:0", shape=(2, 2), dtype=int16) 

Die Matrix besteht aus 2 Zeilen und 2 Spalten, die mit den Werten 1, 2, 3, 4 gefüllt sind.

Eine Matrix mit 3 Dimensionen wird erstellt, indem eine weitere Ebene mit den Klammern hinzugefügt wird.

## Rank 3r3_matrix = tf.constant([ [[1, 2],[3, 4],[5, 6]] ], tf.int16)print(r3_matrix) 

Ausgabe

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16) 

Die Matrix sieht aus wie auf Bild zwei.

Form des Tensors

Wenn Sie einen Tensor drucken, errät TensorFlow die Form. Sie können jedoch die Form des Tensors mit der TensorFlow-Form-Eigenschaft abrufen.

Im Folgenden erstellen Sie eine Matrix mit einer Zahl von 10 bis 15 und überprüfen die Form von m_shape

# Shape of tensorm_shape = tf.constant([ [10, 11],[12, 13],[14, 15] ])m_shape.shape 

Ausgabe

TensorShape([Dimension(3), Dimension(2)]) 

Die Matrix besteht aus 3 Zeilen und 2 Spalten.

TensorFlow verfügt über nützliche Befehle zum Erstellen eines Vektors oder einer mit 0 oder 1 gefüllten Matrix. Wenn Sie beispielsweise einen 1-D-Tensor mit einer bestimmten Form von 10 erstellen möchten, der mit 0 gefüllt ist, können Sie den folgenden Code ausführen:

# Create a vector of 0print(tf.zeros(10)) 

Ausgabe

Tensor("zeros:0", shape=(10,), dtype=float32) 

Die Eigenschaft funktioniert auch für Matrix. Hier erstellen Sie eine 10x10-Matrix, die mit 1 gefüllt ist

# Create a vector of 1print(tf.ones([10, 10])) 

Ausgabe

Tensor("ones:0", shape=(10, 10), dtype=float32) 

Sie können die Form einer bestimmten Matrix verwenden, um einen Vektor aus Einsen zu erstellen. Die Matrix m_shape ist eine 3x2-Dimension. Sie können einen Tensor mit 3 Zeilen erstellen, die mit dem folgenden Code gefüllt sind:

# Create a vector of ones with the same number of rows as m_shapeprint(tf.ones(m_shape.shape[0])) 

Ausgabe

Tensor("ones_1:0", shape=(3,), dtype=float32) 

Wenn Sie den Wert 1 in die Klammer übergeben, können Sie einen Vektor von Einsen erstellen, der der Anzahl der Spalten in der Matrix m_shape entspricht.

# Create a vector of ones with the same number of column as m_shapeprint(tf.ones(m_shape.shape[1])) 

Ausgabe

Tensor("ones_2:0", shape=(2,), dtype=float32) 

Schließlich können Sie eine Matrix 3x2 mit nur einer erstellen

print(tf.ones(m_shape.shape)) 

Ausgabe

Tensor("ones_3:0", shape=(3, 2), dtype=float32) 

Art der Daten

Die zweite Eigenschaft eines Tensors ist die Art der Daten. Ein Tensor kann jeweils nur einen Datentyp haben. Ein Tensor kann nur einen Datentyp haben. Sie können den Typ mit der Eigenschaft dtype zurückgeben.

print(m_shape.dtype) 

Ausgabe

In einigen Fällen möchten Sie den Datentyp ändern. In TensorFlow ist dies mit der Methode tf.cast möglich.

Beispiel

Im Folgenden wird ein Float-Tensor mithilfe der Methode cast in eine Ganzzahl konvertiert.

# Change type of datatype_float = tf.constant(3.123456789, tf.float32)type_int = tf.cast(type_float, dtype=tf.int32)print(type_float.dtype)print(type_int.dtype) 

Ausgabe

TensorFlow wählt den Datentyp automatisch aus, wenn das Argument bei der Erstellung des Tensors nicht angegeben wird. TensorFlow errät, welche Datentypen am wahrscheinlichsten sind. Wenn Sie beispielsweise einen Text übergeben, wird davon ausgegangen, dass es sich um eine Zeichenfolge handelt, und in eine Zeichenfolge konvertiert.

Operator erstellen

Einige nützliche TensorFlow-Operatoren

Sie wissen, wie Sie mit TensorFlow einen Tensor erstellen. Es ist Zeit zu lernen, wie man mathematische Operationen ausführt.

TensorFlow enthält alle grundlegenden Operationen. Sie können mit einem einfachen beginnen. Sie verwenden die TensorFlow-Methode, um das Quadrat einer Zahl zu berechnen. Diese Operation ist unkompliziert, da nur ein Argument erforderlich ist, um den Tensor zu konstruieren.

Das Quadrat einer Zahl wird mit tf.sqrt (x) mit x als schwebender Zahl konstruiert.

x = tf.constant([2.0], dtype = tf.float32)print(tf.sqrt(x)) 

Ausgabe

Tensor("Sqrt:0", shape=(1,), dtype=float32) 

Hinweis: Die Ausgabe gab ein Tensorobjekt zurück und nicht das Ergebnis des Quadrats von 2. Im Beispiel drucken Sie die Definition des Tensors und nicht die tatsächliche Auswertung der Operation. Im nächsten Abschnitt erfahren Sie, wie TensorFlow die Operationen ausführt.

Im Folgenden finden Sie eine Liste häufig verwendeter Vorgänge. Die Idee ist die gleiche. Jede Operation erfordert ein oder mehrere Argumente.

• tf.add (a, b)
• tf.substract (a, b)
• tf.multiply (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Beispiel

# Addtensor_a = tf.constant([[1,2]], dtype = tf.int32)tensor_b = tf.constant([[3, 4]], dtype = tf.int32)tensor_add = tf.add(tensor_a, tensor_b)print(tensor_add) 

Ausgabe

Tensor("Add:0", shape=(1, 2), dtype=int32) 

Code Erklärung

Erstellen Sie zwei Tensoren:

• ein Tensor mit 1 und 2
• ein Tensor mit 3 und 4

Sie addieren beide Tensoren.

Hinweis : Beide Tensoren müssen die gleiche Form haben. Sie können eine Multiplikation über die beiden Tensoren ausführen.

# Multiplytensor_multiply = tf.multiply(tensor_a, tensor_b)print(tensor_multiply) 

Ausgabe

Tensor("Mul:0", shape=(1, 2), dtype=int32) 

Variablen

Bisher haben Sie nur konstante Tensoren erstellt. Es ist nicht von großem Nutzen. Daten kommen immer mit unterschiedlichen Werten an. Um dies zu erfassen, können Sie die Variable-Klasse verwenden. Es stellt einen Knoten dar, an dem sich die Werte immer ändern.

Um eine Variable zu erstellen, können Sie die Methode tf.get_variable () verwenden

tf.get_variable(name = "", values, dtype, initializer)argument- `name = ""`: Name of the variable- `values`: Dimension of the tensor- `dtype`: Type of data. Optional- `initializer`: How to initialize the tensor. OptionalIf initializer is specified, there is no need to include the `values` as the shape of `initializer` is used. 

Mit dem folgenden Code wird beispielsweise eine zweidimensionale Variable mit zwei Zufallswerten erstellt. Standardmäßig gibt TensorFlow einen zufälligen Wert zurück. Sie benennen die Variable var

# Create a Variable## Create 2 Randomized valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

Ausgabe

(1, 2) 

Im zweiten Beispiel erstellen Sie eine Variable mit einer Zeile und zwei Spalten. Sie müssen [1,2] verwenden, um die Dimension der Variablen zu erstellen

Die Initialwerte dieses Tensors sind Null. Wenn Sie beispielsweise ein Modell trainieren, benötigen Sie Anfangswerte, um das Gewicht der Features zu berechnen. Unten setzen Sie diesen Anfangswert auf Null.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer)print(var_init_1.shape) 

Ausgabe

(1, 2) 

Sie können die Werte eines konstanten Tensors in einer Variablen übergeben. Mit der Methode tf.constant () erstellen Sie einen konstanten Tensor. Mit diesem Tensor initialisieren Sie die Variable.

Die ersten Werte der Variablen sind 10, 20, 30 und 40. Der neue Tensor hat eine Form von 2x2.

# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],[30, 40]])# Initialize the first value of the tensor equals to tensor_constvar_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const)print(var_init_2.shape) 

Ausgabe

(2, 2) 

Platzhalter

Ein Platzhalter hat den Zweck, den Tensor zu speisen. Der Platzhalter wird verwendet, um die Daten so zu initialisieren, dass sie innerhalb der Tensoren fließen. Um einen Platzhalter anzugeben, müssen Sie die Methode feed_dict verwenden. Der Platzhalter wird nur innerhalb einer Sitzung eingezogen.

Im nächsten Beispiel sehen Sie, wie Sie mit der Methode tf.placeholder einen Platzhalter erstellen. In der nächsten Sitzung lernen Sie, einen Platzhalter mit dem tatsächlichen Tensorwert zu füttern.

Die Syntax lautet:

tf.placeholder(dtype,shape=None,name=None )arguments:- `dtype`: Type of data- `shape`: dimension of the placeholder. Optional. By default, shape of the data- `name`: Name of the placeholder. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Ausgabe

Tensor("data_placeholder_a:0", dtype=float32) 

Session

TensorFlow arbeitet mit 3 Hauptkomponenten:

• Graph
• Tensor
• Session

Komponenten	Beschreibung
Graph	Das Diagramm ist in TensorFlow von grundlegender Bedeutung. Alle mathematischen Operationen (ops) werden in einem Diagramm ausgeführt. Sie können sich ein Diagramm als ein Projekt vorstellen, in dem alle Vorgänge ausgeführt werden. Die Knoten repräsentieren diese Operationen, sie können neue Tensoren absorbieren oder erzeugen.
Tensor	Ein Tensor repräsentiert die Daten, die zwischen Operationen fortschreiten. Sie haben zuvor gesehen, wie ein Tensor initialisiert wird. Der Unterschied zwischen einer Konstanten und einer Variablen besteht darin, dass sich die Anfangswerte einer Variablen im Laufe der Zeit ändern.
Session	Eine Sitzung führt die Operation aus dem Diagramm aus. Um das Diagramm mit den Werten eines Tensors zu versorgen, müssen Sie eine Sitzung öffnen. Innerhalb einer Sitzung müssen Sie einen Operator ausführen, um eine Ausgabe zu erstellen.

Grafiken und Sitzungen sind unabhängig. Sie können eine Sitzung ausführen und die Werte abrufen, die später für weitere Berechnungen verwendet werden sollen.

Im folgenden Beispiel werden Sie:

• Erstellen Sie zwei Tensoren
• Erstellen Sie eine Operation
• Öffnen Sie eine Sitzung
• Drucken Sie das Ergebnis

Schritt 1) Sie erstellen zwei Tensoren x und y

## Create, run and evaluate a sessionx = tf.constant([2])y = tf.constant([4]) 

Schritt 2) Sie erstellen den Operator, indem Sie x und y multiplizieren

## Create operatormultiply = tf.multiply(x, y) 

Schritt 3) Sie öffnen eine Sitzung. Alle Berechnungen werden innerhalb der Sitzung durchgeführt. Wenn Sie fertig sind, müssen Sie die Sitzung schließen.

## Create a session to run the codesess = tf.Session()result_1 = sess.run(multiply)print(result_1)sess.close() 

Ausgabe

[8] 

Code-Erklärung

• tf.Session (): Öffnen Sie eine Sitzung. Alle Vorgänge werden innerhalb der Sitzungen ausgeführt
• run (multiplizieren): Führen Sie die in Schritt 2 erstellte Operation aus.
• print (result_1): Schließlich können Sie das Ergebnis drucken
• close (): Schließen Sie die Sitzung

Das Ergebnis zeigt 8, was die Multiplikation von x und y ist.

Eine andere Möglichkeit, eine Sitzung zu erstellen, besteht in einem Block. Der Vorteil ist, dass die Sitzung automatisch geschlossen wird.

with tf.Session() as sess:result_2 = multiply.eval()print(result_2) 

Ausgabe

[8] 

In einem Kontext der Sitzung können Sie die eval () -Methode verwenden, um die Operation auszuführen. Es ist gleichbedeutend mit run (). Dadurch wird der Code besser lesbar.

Sie können eine Sitzung erstellen und die Werte in den bisher erstellten Tensoren anzeigen.

## Check the tensors created beforesess = tf.Session()print(sess.run(r1))print(sess.run(r2_matrix))print(sess.run(r3_matrix)) 

Ausgabe

1[[1 2][3 4]][[[1 2][3 4][5 6]]] 

Variablen sind standardmäßig leer, auch nachdem Sie einen Tensor erstellt haben. Sie müssen die Variable initialisieren, wenn Sie die Variable verwenden möchten. Das Objekt tf.global_variables_initializer () muss aufgerufen werden, um die Werte einer Variablen zu initialisieren. Dieses Objekt initialisiert explizit alle Variablen. Dies ist hilfreich, bevor Sie ein Modell trainieren.

Sie können die Werte der zuvor erstellten Variablen überprüfen. Beachten Sie, dass Sie run verwenden müssen, um den Tensor auszuwerten

sess.run(tf.global_variables_initializer())print(sess.run(var))print(sess.run(var_init_1))print(sess.run(var_init_2)) 

Ausgabe

[[-0.05356491 0.75867283]][[0 0]][[10 20][30 40]] 

Sie können den zuvor erstellten Platzhalter verwenden und ihn mit dem tatsächlichen Wert füttern. Sie müssen die Daten an die Methode feed_dict übergeben.

Zum Beispiel nehmen Sie die Potenz von 2 des Platzhalters data_placeholder_a.

import numpy as nppower_a = tf.pow(data_placeholder_a, 2)with tf.Session() as sess:data = np.random.rand(1, 10)print(sess.run(power_a, feed_dict={data_placeholder_a: data})) # Will succeed. 

Code Erklärung

• numpy als np importieren: Importiert die numpy-Bibliothek, um die Daten zu erstellen
• tf.pow (data_placeholder_a, 2): Erstellen Sie die Operationen
• np.random.rand (1, 10): Erstellen Sie ein zufälliges Datenarray
• feed_dict = {data_placeholder_a: data}: Füttere den Platzhalter mit Daten

Ausgabe

[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]] 

Graph

TensorFlow hängt von einem genialen Ansatz ab, um die Operation zu rendern. Alle Berechnungen werden mit einem Datenflussschema dargestellt. Das Datenflussdiagramm wurde entwickelt, um Datenabhängigkeiten zwischen einzelnen Vorgängen zu erkennen. Mathematische Formeln oder Algorithmen bestehen aus einer Reihe aufeinanderfolgender Operationen. Ein Diagramm ist eine bequeme Möglichkeit, um zu visualisieren, wie die Berechnungen koordiniert werden.

Die Grafik zeigt einen Knoten und eine Kante . Der Knoten ist die Darstellung einer Operation, dh der Berechnungseinheit. Die Kante ist der Tensor, sie kann einen neuen Tensor erzeugen oder die Eingabedaten verbrauchen. Dies hängt von den Abhängigkeiten zwischen den einzelnen Operationen ab.

Die Struktur des Diagramms verbindet die Operationen (dh die Knoten) miteinander und wie diese Operationen sind, werden eingespeist. Beachten Sie, dass das Diagramm nicht die Ausgabe der Operationen anzeigt, sondern nur die Verbindung zwischen einzelnen Operationen visualisiert.

Sehen wir uns ein Beispiel an.

Stellen Sie sich vor, Sie möchten die folgende Funktion bewerten:

TensorFlow erstellt ein Diagramm zur Ausführung der Funktion. Die Grafik sieht folgendermaßen aus:

Beispiel für ein TensorFlow-Diagramm

Sie können leicht den Weg sehen, den die Tensoren nehmen, um das endgültige Ziel zu erreichen.

Sie können beispielsweise sehen, dass die Operation add nicht vor und ausgeführt werden kann. Die Grafik erklärt, dass es:

1. berechnen und:
2. addiere 1) zusammen
3. addiere zu 2)
4. addiere 3) zu

x = tf.get_variable("x", dtype=tf.int32, initializer=tf.constant([5]))z = tf.get_variable("z", dtype=tf.int32, initializer=tf.constant([6]))c = tf.constant([5], name = "constant")square = tf.constant([2], name = "square")f = tf.multiply(x, z) + tf.pow(x, square) + z + c 

Code Erklärung

• x: Initialisieren Sie eine Variable namens x mit einem konstanten Wert von 5
• z: Initialisieren Sie eine Variable namens z mit einem konstanten Wert von 6
• c: Initialisieren Sie einen konstanten Tensor namens c mit einem konstanten Wert von 5
• Quadrat: Initialisieren Sie einen konstanten Tensor namens Quadrat mit einem konstanten Wert von 2
• f: Konstruieren Sie den Operator

In diesem Beispiel behalten wir die Werte der Variablen fest. Wir haben auch einen konstanten Tensor namens c erstellt, der der konstante Parameter in der Funktion f ist. Es nimmt einen festen Wert von 5 an. In der Grafik sehen Sie diesen Parameter im Tensor, der als Konstante bezeichnet wird.

Wir haben auch einen konstanten Tensor für die Leistung im Operator tf.pow () konstruiert. Es ist nicht notwendig. Wir haben es so gemacht, dass Sie den Namen des Tensors in der Grafik sehen können. Es ist der Kreis, der Quadrat genannt wird.

Aus dem Diagramm können Sie verstehen, was mit den Tensoren passieren wird und wie sie eine Ausgabe von 66 zurückgeben können.

Der folgende Code wertet die Funktion in einer Sitzung aus.

init = tf.global_variables_initializer() # prepare to initialize all variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

Ausgabe

[66] 

Zusammenfassung

TensorFlow arbeitet um:

• Grafik : Computerumgebung mit den Operationen und Tensoren
• Tensoren : Repräsentiert die Daten (oder Werte), die im Diagramm fließen. Es ist die Kante in der Grafik
• Sitzungen : Ermöglichen Sie die Ausführung der Operationen

Erstellen Sie einen konstanten Tensor

Konstante	Objekt
D0	tf.constant (1, tf.int16)
D1	tf.constant ([1,3,5], tf.int16)
D2	tf.constant ([[1, 2], [3, 4]], tf.int16)
D3	tf.constant ([[[1, 2], [3, 4], [5, 6]], tf.int16)

Erstellen Sie einen Operator

Erstellen Sie einen Operator	Objekt
a + b	tf.add (a, b)
a * b	tf.multiply (a, b)

Erstellen Sie einen variablen Tensor

Erstellen Sie eine Variable	Objekt
randomisierter Wert	tf.get_variable ("var", [1, 2])
initialisierter erster Wert	tf.get_variable ("var_init_2", dtype = tf.int32, initializer = [[1, 2], [3, 4]])

Öffnen Sie eine Sitzung

Session	Objekt
Erstellen Sie eine Sitzung	tf.Session ()
Führen Sie eine Sitzung aus	tf.Session.run ()
Bewerten Sie einen Tensor	Variablenname.eval ()
Schließen Sie eine Sitzung	sess.close ()
Sitzung nach Block	mit tf.Session () als sess: