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

Was ist ein Tensor?

Der Name von Tensorflow leitet sich direkt von seinem Kern-Framework ab: Tensor. In Tensorflow beinhalten alle Berechnungen Tensoren. Ein Tensor ist ein Vektor oder eine Matrix mit n-Dimensionen, der alle Arten von Daten darstellt. Alle Werte in einem Tensor haben einen identischen 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 ausgeführt werden. Jede Operation wird als Operationsknoten bezeichnet und ist miteinander verbunden.

Der Graph stellt die Operationen und Verbindungen zwischen den Knoten dar. Die Werte werden jedoch nicht angezeigt. Der Rand der Knoten ist der Tensor, also eine Möglichkeit, die Operation mit Daten zu füllen.

Beim maschinellen Lernen werden Modelle mit einer Liste von Objekten gefüttert, die als Merkmalsvektoren bezeichnet werden. Ein Merkmalsvektor kann von jedem beliebigen Datentyp sein. Der Merkmalsvektor ist normalerweise der primäre Input zum Fü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 Operationen können im Diagramm angezeigt werden.

Darstellung eines Tensors

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

TensorFlow stellt diese Matrix dar als:

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

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

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 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 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 Haupttensortypen, die Sie erstellen können:

• tf.Variable
• tf.konstante
• tf.placeholder
• tf.SparseTensor

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

Bevor wir das Tutorial durchgehen, stellen Sie sicher, dass Sie die Conda-Umgebung mit TensorFlow aktivieren. Wir haben diese Umgebung hello-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 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 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`

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)

# 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 den Tensornamen angezeigt. Jedes Tensorobjekt wird mit Tensorattributen wie einem eindeutigen Label (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.

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

Ausgang

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. Sehen Sie sich das Beispiel für die Keras-Tensorform unten 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 besteht aus 2 Zeilen und 2 Spalten, die mit den Werten 1, 2, 3, 4 gefüllt sind.

Durch das Hinzufügen einer weiteren Ebene mit Klammern wird eine Matrix mit 3 Dimensionen konstruiert.

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

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-Shape-Eigenschaft ermitteln.

Unten erstellen Sie eine Matrix, die mit einer Zahl von 10 bis 15 gefüllt ist, und überprüfen die Form von 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 Matrix. Hier erstellen Sie eine 10×10-Matrix gefüllt mit 1

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

Ausgang

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

Sie können die Form einer gegebenen Matrix verwenden, um einen Vektor aus Einsen zu erstellen. Die Matrix m_shape hat eine Dimension von 3×2. Mit dem folgenden Code können Sie einen Tensor mit 3 Zeilen erstellen, 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 übergeben, können Sie einen Vektor aus Einsen konstruieren, der der Anzahl der Spalten in der Matrix m_shape entspricht.

# 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 mit nur Einsen erstellen

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 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)

Ausgang

<dtype: 'int32'>

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

Beispiel

Unten wird ein Float-Tensor mit der Methode cast in eine Ganzzahl konvertiert.

# 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: 'float32'>
<dtype: 'int32'>

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 umgewandelt.

Operator erstellen

Einige nützliche TensorFlow-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 beginnen. Sie verwenden die TensorFlow-Methode, um das Quadrat einer Zahl zu berechnen. Diese Operation ist unkompliziert, da zum Erstellen des Tensors nur ein Argument erforderlich ist.

Das Quadrat einer Zahl wird mit tf.sqrt(x) konstruiert, 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 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 zum Ausführen der Operationen funktioniert.

Nachfolgend finden Sie eine Liste häufig verwendeter Operationen. Die Idee ist dieselbe. Jede Operation erfordert ein oder mehrere Argumente.

• tf.add(a, b)
• tf.subtract(a, b)
• tf.multiply(a, b)
• tf.div(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 Erklärung

Erstellen Sie zwei Tensoren:

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

Man addiert beide Tensoren.

Hinweise: dass beide Tensoren die gleiche Form haben müssen. Sie können eine Multiplikation über die 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. Es ist nicht von großem Nutzen. Daten kommen immer mit unterschiedlichen Werten an. Um dies zu erfassen, können Sie die Klasse Variable verwenden. Es stellt einen Knoten dar, an dem sich die Werte ständig ä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. Optional
If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.

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

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

Ausgang

(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 Anfangswerte dieses Tensors sind Null. Wenn Sie beispielsweise ein Modell trainieren, benötigen Sie Anfangswerte, um die Gewichtung der Features zu berechnen. Nachfolgend 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)

Ausgang

(1, 2)

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

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

# Create a 2x2 matrixtensor_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 hat die Aufgabe, den Tensor zu versorgen. Platzhalter werden verwendet, um den Datenfluss innerhalb der Tensoren zu initialisieren. Um einen Platzhalter bereitzustellen, müssen Sie die Methode „feed_dict“ verwenden. Der Platzhalter wird nur innerhalb einer Sitzung gefüttert.

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. 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

Komponenten	descritption
Graph	Der Graph ist in TensorFlow grundlegend. Alle mathematischen Operationen (Ops) werden in einem Graphen ausgeführt. Sie können sich einen Graphen als ein Projekt vorstellen, in dem alle Operationen ausgeführt werden. Die Knoten stellen diese Operationen dar, sie können neue Tensoren aufnehmen oder erstellen.
Tensor	Ein Tensor stellt die Daten dar, die zwischen Operationen fortschreiten. Sie haben zuvor gesehen, wie ein Tensor initialisiert wird. Der Unterschied zwischen einer Konstante 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 füttern, müssen Sie eine Sitzung öffnen. Innerhalb einer Sitzung müssen Sie einen Operator ausführen, um eine Ausgabe zu erstellen.

Diagramme und Sitzungen sind unabhängig. Sie können eine Sitzung ausführen und die Werte abrufen, um sie später für weitere Berechnungen zu verwenden.

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) Den Operator erhält man durch die Multiplikation von x und y

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

Schritt 3) Sie erö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 code
sess = tf.Session()result_1 = sess.run(multiply)
print(result_1)
sess.close()

Ausgang

[8]

Codeerklärung

• tf.Session(): Öffnen Sie eine Sitzung. Alle Vorgänge werden innerhalb der Sitzungen ablaufen.
• run(multiply): Führen Sie die in Schritt 2 erstellte Operation aus.
• print(result_1): Abschließend können Sie das Ergebnis ausdrucken
• close(): Schließt die Sitzung

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

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

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

Ausgang

[8]

Im Kontext der Sitzung können Sie die Operation mit der Methode eval() ausführen. Sie ist gleichbedeutend mit run(). Sie 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 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))

Ausgang

[[-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 versorgen. Sie müssen die Daten an die Methode „feed_dict“ übergeben.

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 Erklärung

• numpy als np importieren: Importieren Numpy-Bibliothek um die Daten zu erstellen
• tf.pow(data_placeholder_a, 2): Erstellen Sie die Ops
• np.random.rand(1, 10): Erstellen Sie ein zufälliges Datenarray
• feed_dict={data_placeholder_a: data}: Füttere 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 setzt auf einen genialen Ansatz zur Darstellung der Operation. Alle Berechnungen werden mit einem Datenflussschema dargestellt. Das Datenflussdiagramm wurde entwickelt, um Datenabhängigkeiten zwischen einzelnen Operationen zu erkennen. Mathematische Formeln oder Algorithmen bestehen aus einer Reihe aufeinanderfolgender Operationen. Ein Diagramm ist eine praktische Möglichkeit, die Koordination der Berechnungen zu visualisieren.

Die Grafik zeigt a Knoten und ein Rand. Der Knoten ist die Darstellung einer Operation, also die Recheneinheit. Die Kante ist der Tensor, er kann einen neuen Tensor erzeugen oder die Eingabedaten verbrauchen. Dabei kommt es auf die Abhängigkeiten zwischen den einzelnen Operationen an.

Die Struktur des Graphen verbindet die Operationen (also die Knoten) miteinander und zeigt, wie diese Operationen gespeist werden. Beachten Sie, dass der Graph nicht die Ausgabe der Operationen anzeigt, sondern nur hilft, die Verbindung zwischen einzelnen Operationen zu visualisieren.

Sehen wir uns ein Beispiel an.

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

TensorFlow erstellt ein Diagramm, um die Funktion auszuführen. Die Grafik sieht so aus:

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

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

1. berechnen und:
2. Addiere 1) zusammen
3. zu 2 hinzufügen)
4. 3) hinzufügen

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 entscheiden wir uns dafür, die Werte der Variablen festzuhalten. Wir haben auch einen konstanten Tensor namens c erstellt, der der konstante Parameter in der Funktion f ist. Er nimmt einen festen Wert von 5 an. Im Diagramm können Sie diesen Parameter im Tensor namens Konstante sehen.

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

Aus der Grafik können Sie verstehen, was mit den Tensoren passiert 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 variables
with tf.Session() as sess:    
	init.run() # Initialize x and y    
    function_result = f.eval()
print(function_result)

Ausgang

[66]

Zusammenfassung

TensorFlow funktioniert um:

• Graph: Rechenumgebung mit den Operationen und Tensoren
• Tensoren: Stellt die Daten (oder den Wert) dar, die im Diagramm fließen. Es ist die Kante im Diagramm
• Sessions: Erlauben 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 eines Operators

Erstellen eines Operators	Betreff
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 durch	tf.Session.run()
Bewerten Sie einen Tensor	Variablenname.eval()
Schließen Sie eine Sitzung	sess.close()
Sitzung für Block	mit tf.Session() als sess: