TensorFlow-Grundlagen: Tensor, Form, Typ, Sitzungen und 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 entstehen. In TensorFlow werden alle Operationen innerhalb eines Diagramms ausgeführt. Der Graph ist eine Reihe von Berechnungen, die nacheinander stattfinden. Jede Operation wird als Operationsknoten bezeichnet und ist miteinander verbunden.

Das Diagramm zeigt die Vorgänge und Verbindungen zwischen den Knoten. Allerdings werden die Werte 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 einen beliebigen Datentyp haben. Der Merkmalsvektor ist normalerweise die primäre Eingabe zum Füllen eines Tensors. Diese Werte fließen über den Tensor in einen Op-Knoten und das Ergebnis dieser Operation/Berechnung erstellt einen neuen Tensor, der wiederum in einer neuen Operation verwendet wird. Alle diese Vorgänge 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:

Darstellung eines Tensors
Darstellung eines Tensors

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:

Darstellung eines Tensors

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

Aussichten für MacOS Benutzer:

source activate hello-tf

Aussichten 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 Folgendes auswing Code

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

Output

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

Erstellen Sie einen Tensor der n-Dimension

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

Output

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

Jeder Tensor wird mit dem 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.

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

Output

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)

Output

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 zwei Tensor-Dimensionen zu erstellen, müssen Sie das schließen brackets nach jeder Reihe. Sehen Sie sich unten das Keras-Tensor-Formbeispiel an

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

Output

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 entsteht durch Hinzufügen einer weiteren Ebene mit brackets.

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

Output

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

Output

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

Output

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

Output

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

Sie können die Form einer bestimmten Matrix verwenden, um einen Einsenvektor zu erstellen. Die Matrix m_shape ist 3×2-dimensional. Mit folgendem Befehl können Sie einen Tensor mit 3 durch Einsen gefüllten Zeilen erstellenwing Code:

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

Output

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

Output

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

Output

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)

Output

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

Output

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

Betreiber erstellen

Einige nützliche TensorFlow-Operatoren

Sie wissen, wie Sie mit TensorFlow einen Tensor erstellen. Es ist Zeit zu lernen, wie man mathematische Operationen durchfü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 zur Konstruktion 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))

Output

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 Vorgänge ausführt.

Following ist eine Liste häufig verwendeter Operationen. Die Idee ist dieselbe. Für jede Operation sind ein oder mehrere Argumente erforderlich.

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

Output

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)

Output

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)

Output

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

Output

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

Output

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

Output

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

Session

TensorFlow basiert auf drei Hauptkomponenten:

  • Graph
  • Tensor
  • Session
Komponenten descritption
Graph Der Graph ist in TensorFlow von grundlegender Bedeutung. Alle mathematischen Operationen (Ops) werden innerhalb eines Diagramms ausgeführt. Sie können sich ein Diagramm 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 man einen Tensor initialisiert. 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.

Diagramme und Sitzungen sind unabhängig. Sie können eine Sitzung ausführen und die zu verwendenden Werte abrufen later für weitere Berechnungen.

Im folgenden Beispiel werden Sie Folgendes tun:

  • Erstellen Sie zwei Tensoren
  • Erstellen Sie einen Vorgang
  • Ö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 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()

Output

[8]

Codeerklärung

  • tf.Session(): Eine Sitzung öffnen. Alle Vorgänge werden innerhalb der Sitzungen ausgeführt
  • 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)

Output

[8]

Im Kontext der Sitzung können Sie die Methode eval() verwenden, um den Vorgang auszuführen. Es entspricht run(). Dadurch wird der Code besser lesbar.

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

Output

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

Output

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

Output

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

Graph

TensorFlow ist auf einen genialen Ansatz zum Rendern der Operation angewiesen. Alle Berechnungen werden mit einem Datenflussschema dargestellt. Der Datenflussgraph 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 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, sie kann einen neuen Tensor erzeugen oder die Eingabedaten verbrauchen. Es kommt auf die Abhängigkeiten zwischen einzelnen Vorgängen an.

Die Struktur des Diagramms verbindet die Operationen (dh die Knoten) und wie diese Operationen gespeist werden. Beachten Sie, dass das Diagramm nicht die Ausgabe der Vorgänge anzeigt, sondern nur dazu dient, den Zusammenhang zwischen einzelnen Vorgängen zu visualisieren.

Sehen wir uns ein Beispiel an.

Stellen Sie sich vor, Sie möchten Folgendes bewertenwing Funktion:

Graph

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

Beispiel für ein TensorFlow-Diagramm

Beispiel für ein TensorFlow-Diagramm

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

Beispielsweise können Sie sehen, dass der Vorgang „Hinzufügen“ nicht vor und ausgeführt werden kann. Die Grafik erklärt, dass Folgendes passieren wird:

  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. Es ist nicht erforderlich. Wir haben es so gemacht, dass Sie den Namen des Tensors im Diagramm sehen können. Es ist der Kreis, den man Quadrat nennt.

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)

Output

[66]

Zusammenfassung

TensorFlow funktioniert um:

  • Graph: Rechenumgebung, die die Operationen und Tensoren enthält
  • 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 Vorgänge

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