Was ist ein Tensor in TensorFlow? Form, Typ & Operatoren

Was ist ein Tensor?

Der Name TensorFlow TensorFlow leitet sich direkt von seinem Kernobjekt ab: dem Tensor. Jede Berechnung in TensorFlow beinhaltet Tensoren. Ein Tensor ist ein Vektor oder eine Matrix mit n Dimensionen, die alle Datentypen repräsentiert. Alle Werte in einem Tensor haben denselben Datentyp mit bekannter (oder teilweise bekannter) Form. Die Form der Daten entspricht der Dimensionalität der Matrix oder des Arrays.

Ein Tensor kann aus den Eingabedaten oder dem Ergebnis einer Berechnung entstehen. In TensorFlow werden alle Operationen innerhalb eines Graphen ausgeführt. Dieser Graph stellt eine Menge von Berechnungen dar, die nacheinander ablaufen. Jede Operation wird als „op-Knoten“ bezeichnet, und die Knoten sind miteinander verbunden.

Der Graph veranschaulicht die Operationen und die Verbindungen zwischen den Knoten. Die Werte werden jedoch nicht angezeigt. Die Kanten zwischen den Knoten stellen den Tensor dar, d. h. eine Möglichkeit, die Operation mit Daten zu füllen.

Im maschinellen Lernen werden Modelle mit einer Liste von Objekten, sogenannten Merkmalsvektoren, trainiert. Ein Merkmalsvektor kann beliebigen Datentyp haben und dient üblicherweise als primäre Eingabe zur Befüllung eines Tensors. Diese Werte fließen über den Tensor in einen Operationsknoten (op-Knoten), dessen Ergebnis einen neuen Tensor erzeugt, der wiederum in einer neuen Operation verwendet wird. Alle diese Operationen lassen sich im Graphen visualisieren.

Darstellung eines Tensors

In TensorFlow ist ein Tensor eine Sammlung von Merkmalsvektoren (d. h. ein Array) mit n Dimensionen. Wenn wir beispielsweise eine 2×3-Matrix mit Werten von 1 bis 6 haben, schreiben wir sie wie die unten gezeigte Matrix:

TensorFlow stellt diese Matrix dar als:

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

Wenn wir eine dreidimensionale Matrix mit Werten von 1 bis 8 erstellen, werden dieselben Daten als ein Kasten mit zwei übereinanderliegenden Flächen dargestellt:

TensorFlow stellt diese Matrix dar als:

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

Hinweis: Ein Tensor kann durch einen Skalar dargestellt werden oder eine Form mit mehr als drei Dimensionen haben. Es ist lediglich schwieriger, sich die höheren Dimensionen vorzustellen.

Arten von Tensoren

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

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

Jede Operation, die Sie mit TensorFlow durchführen, beinhaltet die Manipulation eines Tensors. Es gibt vier Haupttypen von Tensoren, die Sie erstellen können:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

In diesem Tutorial lernen Sie, wie Sie ein/e erstellen. tf.constant und einem tf.Variable.

Bevor Sie den Code ausführen, sollten Sie Folgendes beachten: Dieses Tutorial orientiert sich an der ursprünglichen TensorFlow 1.x API, bei der ein Graph zuerst erstellt und später innerhalb einer Sitzung ausgeführt wird. TensorFlow 2 wird standardmäßig sofort ausgeführt, daher wurden einige der unten aufgeführten Symbole verschoben oder entfernt. Sie sind aber weiterhin über die API erreichbar. tf.compat.v1 Namespace, und die Tabelle ordnet jedem Namespace sein modernes Gegenstück zu.

Bevor Sie mit dem Tutorial beginnen, stellen Sie sicher, dass Sie die Conda-Umgebung aktiviert haben, in der TensorFlow installiert ist. Diese Umgebung heißt hello-tf.

Für macOS Benutzer:

source activate hello-tf

Für Windows Benutzer:

activate hello-tf

Sobald Sie das erledigt haben, können Sie TensorFlow importieren.

# Import tf
import tensorflow as tf

Erstellen Sie einen Tensor der n-Dimension

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

Um einen Tensor zu erstellen, können Sie Folgendes verwenden: tf.constant() wie im folgenden TensorFlow-Tensorformbeispiel 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`

Um einen Tensor der Dimension 0 zu erstellen, führen Sie den folgenden Code aus.

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

Ausgang

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

Die drei Teile dieser Ausgabe werden den drei Tensor-Eigenschaften zugeordnet, wie die untenstehende kommentierte Version verdeutlicht.

Sie können dem Tensor auch einen eigenen Namen geben. name Argument.

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

Ausgang

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

Jeder Tensor wird durch seinen Tensornamen angezeigt. Jedes Tensorobjekt ist mit Attributen wie einer eindeutigen Bezeichnung (Name), einer Dimension (Form) und einem TensorFlow-Datentyp (dtype) definiert.

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

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

Ausgang

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

Ein Tensor der Dimension 1 kann wie folgt erzeugt werden:

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

Ausgang

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

Man kann erkennen, dass die TensorFlow-Form nur aus einer Spalte besteht.

Um ein Array mit zwei Tensordimensionen zu erstellen, müssen Sie nach jeder Zeile die Klammern schließen. Sehen Sie sich das untenstehende Beispiel für die Tensorform an.

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

Ausgang

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

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

Eine Matrix mit 3 Dimensionen wird durch Hinzufügen einer weiteren Klammerebene erstellt.

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

Ausgang

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

Das Ergebnis entspricht dem dreidimensionalen Kastendiagramm, das zuvor in diesem Tutorial gezeigt wurde.

Form des Tensors

Wenn Sie einen Tensor ausgeben, leitet TensorFlow dessen Form ab. Sie können die Form jedoch auch direkt mit TensorFlow auslesen. shape Eigentum.

Im Folgenden erstellen Sie eine Matrix, die mit den Zahlen von 10 bis 15 gefüllt ist, und überprüfen deren Form. m_shape.

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

Ausgang

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 Matrix, die mit 0 oder 1 gefüllt sind. Wenn Sie beispielsweise einen 1D-Tensor mit einer bestimmten Form von 10, gefüllt mit 0, erstellen möchten, können Sie den folgenden Code ausführen:

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

Ausgang

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

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

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

Ausgang

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

Man kann die Form einer gegebenen Matrix nutzen, um einen Vektor aus Einsen zu erzeugen. Die Matrix m_shape hat die Dimensionen 3×2, daher erzeugt der folgende Code einen Tensor mit 3 Zeilen, die mit Einsen gefüllt sind:

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

Ausgang

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

Wenn Sie den Wert 1 in die Klammer einsetzen, erzeugen Sie einen Vektor aus Einsen, dessen Anzahl der Anzahl der Spalten in der Matrix entspricht. m_shape.

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

Ausgang

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

Schließlich können Sie eine 3×2-Matrix erstellen, die vollständig mit Einsen gefüllt ist.

print(tf.ones(m_shape.shape))

Ausgang

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

Art der Daten

Die zweite Eigenschaft eines Tensors ist der Datentyp. Ein Tensor kann jeweils nur einen Datentyp speichern, und dieser Datentyp kann mit dem dtype Eigentum.

print(m_shape.dtype)

Ausgang

<dtype: &#x27;int32'>

Gelegentlich möchten Sie den Datentyp ändern. In TensorFlow ist dies mit der folgenden Methode möglich: tf.cast Methode.

Beispiel

Im Folgenden wird ein Gleitkomma-Tensor mit der folgenden Funktion in eine Ganzzahl umgewandelt: cast Methode.

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

Ausgang

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow wählt den Datentyp automatisch, wenn beim Erstellen des Tensors kein Argument angegeben wird. TensorFlow ermittelt den wahrscheinlichsten Datentyp: Wird beispielsweise Text übergeben, wird ein String angenommen.

Bessere OperaDo.

Einige nützliche TensorFlow-Beispiele Operatoren

Sie wissen, wie Sie mit TensorFlow einen Tensor erstellen. Jetzt ist es an der Zeit zu lernen, wie man mathematische Operationen durchführt.

TensorFlow enthält alle grundlegenden Operationen. Sie können mit einer einfachen Anwendung beginnen und eine TensorFlow-Methode verwenden, um die Quadratwurzel einer Zahl zu berechnen. Diese Operation ist unkompliziert, da nur ein Argument zum Erstellen des Tensors benötigt wird.

Die Quadratwurzel einer Zahl wird konstruiert mit tf.sqrt(x), wobei x eine Gleitkommazahl ist.

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

Ausgang

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

Hinweis: Die Ausgabe lieferte ein Tensorobjekt und nicht die Quadratwurzel aus 2. In diesem Beispiel wird die Definition des Tensors ausgegeben, nicht die eigentliche Auswertung der Operation. Im folgenden Abschnitt erfahren Sie, wie TensorFlow die Operationen ausführt.

Nachfolgend finden Sie eine Liste häufig verwendeter Operationen. Das Prinzip ist immer gleich: Jede Operation benötigt ein oder mehrere Argumente.

• tf.add(a, b)
• tf.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Beispiel

# Add
tensor_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)

Ausgang

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

Code Erläuterung

Erstellen Sie zwei Tensoren:

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

Man addiert beide Tensoren.

Beachten Sie, dass beide Tensoren die gleiche Form haben müssen. Sie können auch eine Multiplikation der beiden Tensoren durchführen.

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

Ausgang

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

Variablen

Bisher haben Sie nur konstante Tensoren erstellt, was allein nur begrenzt nützlich ist. Daten treffen stets mit unterschiedlichen Werten ein, und um diese zu erfassen, können Sie die Klasse „Variable“ verwenden. Eine Variable repräsentiert einen Knoten, dessen Werte sich im Laufe der Zeit ändern.

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

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. Optional
If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.

Der folgende Code erzeugt beispielsweise eine zweidimensionale Variable mit zwei Zufallswerten. Standardmäßig gibt TensorFlow einen Zufallswert zurück. Sie benennen die Variable „var“.

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

Ausgang

(1, 2)

In diesem Beispiel erstellen Sie eine Variable mit einer Zeile und zwei Spalten, daher übergeben Sie [1, 2] als Dimension der Variable.

Die Anfangswerte eines Tensors können auch null sein. Beim Trainieren eines Modells benötigt man beispielsweise Anfangswerte, bevor man die Gewichtung der Merkmale berechnet. Im Folgenden werden diese Anfangswerte auf null gesetzt.

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

Ausgang

(1, 2)

Sie können auch die Werte eines konstanten Tensors an eine Variable übergeben. Einen konstanten Tensor erstellen Sie mit der Methode tf.constant() und verwende diesen Tensor, um die Variable zu initialisieren.

Die ersten Werte der Variablen sind 10, 20, 30 und 40. Der neue Tensor hat die Form 2×2.

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

Ausgang

(2, 2)

Platzhalter

Ein Platzhalter dient dazu, den Tensor zu speisen. Er initialisiert die Daten, die in den Tensor fließen werden. Um einen Platzhalter bereitzustellen, verwendet man die feed_dict Das Argument und der Platzhalter werden nur innerhalb einer Sitzung übergeben.

Im nächsten Beispiel sehen Sie, wie Sie mit der Methode einen Platzhalter erstellen. tf.placeholderIm Abschnitt „Sitzung“ lernen Sie, wie Sie einen Platzhalter mit einem tatsächlichen Tensorwert 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. Optional			
data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")
print(data_placeholder_a)

Ausgang

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

Session

TensorFlow basiert auf drei Hauptkomponenten:

• Graph
• Tensor
• Session

Diagramme und Sitzungen sind unabhängig. Sie können eine Sitzung ausführen und die Werte für spätere Berechnungen speichern.

Im folgenden Beispiel werden Sie Folgendes tun:

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

Schritt 1) ​​Sie erstellen zwei Tensoren x und y.

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

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

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

Schritt 3) Sie öffnen eine Sitzung. Alle Berechnungen finden innerhalb der Sitzung statt, und wenn Sie fertig sind, müssen Sie sie schließen.

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

Ausgang

[8]

Code Erklärung

• tf.Session(): Öffnen Sie eine Sitzung. Alle Operationen laufen innerhalb der Sitzung ab.
• run(multiply)Führe die in Schritt 2 erstellte Operation aus
• print(result_1)Abschließend können Sie das Ergebnis ausdrucken.
• close()Sitzung schließen

Das Ergebnis zeigt 8, was der Multiplikation von x und y entspricht.

Eine weitere Möglichkeit, eine Sitzung zu erstellen, besteht darin, sie innerhalb eines Blocks zu erstellen. Der Vorteil ist, dass die Sitzung dadurch automatisch geschlossen wird.

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

Ausgang

[8]

Im Rahmen einer Sitzung können Sie die eval() Methode zur Ausführung der Operation. Sie ist äquivalent zu run() und macht den Code lesbarer.

Sie können eine Sitzung erstellen und die Werte in den Tensoren sehen, die Sie bisher erstellt haben.

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

Ausgang

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

Variablen sind standardmäßig leer, auch nachdem Sie den Tensor erstellt haben. Sie müssen eine Variable initialisieren, bevor Sie sie verwenden können. Das Objekt tf.global_variables_initializer() wird aufgerufen, um die Werte aller Variablen gleichzeitig zu initialisieren, was hilfreich ist, bevor man ein Modell trainiert.

Sie können die Werte der zuvor erstellten Variablen überprüfen. Beachten Sie, dass Sie den Befehl `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))

Ausgang

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

Sie können den zuvor erstellten Platzhalter verwenden und ihn mit einem tatsächlichen Wert befüllen. Sie müssen die Daten an die feed_dict Argument.

Beispielsweise nehmen Sie die Zweierpotenz des Platzhalters data_placeholder_a.

import numpy as np
power_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 Erläuterung

• import numpy as np: Importieren Sie die NumPy Bibliothek zum Erstellen der Daten
• tf.pow(data_placeholder_a, 2): Operationen erstellen
• np.random.rand(1, 10): Erstelle ein zufälliges Datenarray
• feed_dict={data_placeholder_a: data}: Füllen Sie den Platzhalter mit Daten

Ausgang

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

Graph

TensorFlow visualisiert jede Operation mithilfe eines Datenflussdiagramms. Dieses Diagramm dient dazu, die Datenabhängigkeiten zwischen einzelnen Operationen darzustellen. Eine mathematische Formel oder ein Algorithmus besteht aus einer Reihe aufeinanderfolgender Operationen, und ein Diagramm bietet eine anschauliche Möglichkeit, die Koordination dieser Berechnungen zu visualisieren.

Der Graph zeigt Knoten und Kanten. Ein Knoten repräsentiert eine Operation, d. h. die Recheneinheit. Eine Kante ist ein Tensor: Sie kann einen neuen Tensor erzeugen oder die Eingabedaten verarbeiten, abhängig von den Abhängigkeiten zwischen den einzelnen Operationen.

Die Struktur des Graphen verbindet die Operationen (d. h. die Knoten) miteinander und zeigt, wie jede einzelne Operation mit Daten versorgt wird. Der Graph stellt nicht die Ergebnisse der Operationen dar; er dient lediglich der Visualisierung der Verbindungen zwischen ihnen.

Betrachten wir ein Beispiel. Stellen Sie sich vor, Sie möchten die folgende Funktion auswerten:

TensorFlow erstellt einen Graphen zur Ausführung der Funktion. Der Graph sieht folgendermaßen aus:

Sie können leicht den Weg erkennen, den die Tensoren nehmen, um ihr endgültiges Ziel zu erreichen.

Zum Beispiel kann die add Der Knoten kann nicht ausgeführt werden, bevor beide Mul und Pow haben ihre Ergebnisse vorgelegt. Die Grafik zeigt, dass TensorFlow Folgendes leisten wird:

1. Berechne x·z in der Mul Knoten und x² im Pow Knoten
2. Addieren Sie diese beiden Ergebnisse in der add Knoten
3. Füge z zu dieser Summe hinzu. add_1 Knoten
4. Füge die Konstante 5 in die add_2 Knoten

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 Erläuterung

• 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 bleiben die Werte der Variablen konstant. Der konstante Tensor c ist der konstante Parameter der Funktion f und hat den festen Wert 5; im Diagramm ist dieser Parameter im als „Konstante“ bezeichneten Tensor dargestellt.

Für die Potenz im Operator wurde ebenfalls ein konstanter Tensor erstellt. tf.pow()Es ist nicht notwendig, aber es bedeutet, dass der Exponent im Graphen als Kreis, der als Quadrat bezeichnet wird, erscheint.

Anhand des Graphen kann man nachvollziehen, was mit den Tensoren passiert und warum die Funktion 66 zurückgibt: 5 × 6 plus 5² plus 6 plus 5 gleich 66.

Der unten stehende Code wertet die Funktion innerhalb einer Sitzung aus.

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

Ausgang

[66]

TensorFlow-Grundlagen – Kurzübersicht

In den vier folgenden Tabellen sind alle in diesem Tutorial verwendeten Befehle zusammengefasst, sodass Sie einen Befehl nachschlagen können, ohne durch die Beispiele zurückscrollen zu müssen.

Erstellen Sie einen konstanten Tensor

Erstellen eines Operators

Erstellen Sie einen variablen Tensor

Öffnen Sie eine Sitzung

Häufig gestellte Fragen