1. Was sind Tensors?
Tensors sind die grundlegenden Bausteine in TensorFlow. Sie sind allgemeine Datenstrukturen, die verwendet werden, um Daten zu speichern und zu verarbeiten. Ein Tensor kann man sich als eine N-dimensionales Array oder eine Liste vorstellen. Dabei kann ein Tensor verschiedene Formen und Dimensionen haben, wie z.B. Skalare (0D), Vektoren (1D), Matrizen (2D) und höhere Dimensionen (3D, 4D, etc.).
- Skalar (0D Tensor): Ein einzelner Wert, z.B.
42oder3.14. - Vektor (1D Tensor): Eine Liste von Werten, z.B.
[1, 2, 3]. - Matrix (2D Tensor): Eine Tabelle von Werten, z.B.
[[1, 2], [3, 4]]. - Höherdimensionale Tensors: Z.B.
[[[1], [2]], [[3], [4]]](3D Tensor).
Tensor-Operationen
TensorFlow bietet eine Vielzahl von Operationen, die auf Tensors angewendet werden können. Diese Operationen sind die grundlegenden Werkzeuge, um Berechnungen und Datenmanipulationen durchzuführen.
Hier sind einige grundlegende Tensor-Operationen:
2. Erstellen von Tensors
import tensorflow as tf
# Erstellen eines Skalars
scalar = tf.constant(3)
print("Skalar:", scalar)
# Erstellen eines Vektors
vector = tf.constant([1, 2, 3])
print("Vektor:", vector)
# Erstellen einer Matrix
matrix = tf.constant([[1, 2], [3, 4]])
print("Matrix:", matrix)
# Erstellen eines höherdimensionalen Tensors
tensor_3d = tf.constant([[[1], [2]], [[3], [4]]])
print("3D Tensor:", tensor_3d)
Ausgabe:
Skalar: tf.Tensor(3, shape=(), dtype=int32)
Vektor: tf.Tensor([1 2 3], shape=(3,), dtype=int32)
Matrix: tf.Tensor(
[[1 2]
[3 4]], shape=(2, 2), dtype=int32)
3D Tensor: tf.Tensor(
[[[1]
[2]]
[[3]
[4]]], shape=(2, 2, 1), dtype=int32)
3. Grundlegende mathematische Operationen:
# Addition
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])
result = tf.add(a, b)
print("Addition:", result)
# Multiplikation
result = tf.multiply(a, b)
print("Multiplikation:", result)
# Matrixmultiplikation
matrix1 = tf.constant([[1, 2], [3, 4]])
matrix2 = tf.constant([[5, 6], [7, 8]])
result = tf.matmul(matrix1, matrix2)
print("Matrixmultiplikation:", result)
Ausgabe:
Addition: tf.Tensor([5 7 9], shape=(3,), dtype=int32)
Multiplikation: tf.Tensor([ 4 10 18], shape=(3,), dtype=int32)
Matrixmultiplikation: tf.Tensor(
[[19 22]
[43 50]], shape=(2, 2), dtype=int32)
4. Reshape und Slicing
# Reshape
tensor = tf.constant([[1, 2, 3], [4, 5, 6]])
reshaped_tensor = tf.reshape(tensor, [3, 2])
print("Reshape:", reshaped_tensor)
# Slicing
sliced_tensor = tensor[:, 1]
print("Slicing:", sliced_tensor)
Ausgabe:
Reshape: tf.Tensor(
[[1 2]
[3 4]
[5 6]], shape=(3, 2), dtype=int32)
Slicing: tf.Tensor([2 5], shape=(2,), dtype=int32)
5. TensorFlow-Variablen
Was sind TensorFlow-Variablen?
TensorFlow-Variablen sind spezielle Tensors, deren Werte während der Ausführung eines Programms geändert werden können. Sie werden häufig in maschinellen Lernmodellen verwendet, um die Parameter zu speichern, die während des Trainings aktualisiert werden.
Erstellen von Variablen
# Erstellen einer Variable
initial_value = tf.constant([1.0, 2.0, 3.0])
variable = tf.Variable(initial_value)
print("Variable:", variable)
Ausgabe:
Variable: <tf.Variable 'Variable:0' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>
Zugriff auf und Modifikation von Variablen
# Zugriff auf den Wert einer Variable
print("Wert der Variable:", variable.numpy())
# Modifikation des Wertes einer Variable
variable.assign([4.0, 5.0, 6.0])
print("Neuer Wert der Variable:", variable.numpy())
# Inkrementieren des Wertes einer Variable
variable.assign_add([1.0, 1.0, 1.0])
print("Inkrementierter Wert der Variable:", variable.numpy())
Ausgabe:
Wert der Variable: [1. 2. 3.]
Neuer Wert der Variable: [4. 5. 6.]
Inkrementierter Wert der Variable: [5. 6. 7.]
6. Platzhalter (TensorFlow 1.x)
Platzhalter sind spezielle Tensors, die verwendet werden, um Eingabedaten zu definieren, die zur Laufzeit übergeben werden. Sie sind besonders nützlich für das Training und die Vorhersage von Modellen.
Erstellen und Verwenden von Platzhaltern:
import tensorflow as tf
# Erstellen eines Platzhalters
placeholder = tf.compat.v1.placeholder(dtype=tf.float32, shape=None)
Beispiel:
import tensorflow as tf
# Deaktivieren von Eager Execution, um Platzhalter verwenden zu können
tf.compat.v1.disable_eager_execution()
# Erstellen eines Platzhalters
x = tf.compat.v1.placeholder(dtype=tf.float32, shape=None)
y = x * 2
# Ausführen der Berechnung
with tf.compat.v1.Session() as sess:
result = sess.run(y, feed_dict={x: 3})
print("Ergebnis:", result)
# Ausgabe:
# Ergebnis: 6.0
7. Computational Graph
Ein Computational Graph ist eine Darstellung von Berechnungen als gerichteter Graph. Die Knoten im Graph repräsentieren Operationen (Ops), während die Kanten die Datenflüsse (Tensors) darstellen.
Erstellen und Verwenden eines Graphs:
import tensorflow as tf
# Erstellen eines Graphs
graph = tf.Graph()
with graph.as_default():
a = tf.constant(2)
b = tf.constant(3)
c = a + b
# Ausführen des Graphs in einer Session
with tf.compat.v1.Session(graph=graph) as sess:
result = sess.run(c)
print("Ergebnis:", result)
# Ausgabe:
# Ergebnis: 5
8. Sitzung (Session)
Eine Session wird verwendet, um den Computational Graph auszuführen. Sie verwaltet die Ressourcen und den Zustand des Graphs während der Ausführung.
Erstellen und Verwenden einer Session:
# Erstellen und Ausführen einer Session
with tf.compat.v1.Session() as sess:
a = tf.constant(2)
b = tf.constant(3)
c = a + b
result = sess.run(c)
print("Ergebnis:", result)
# Ausgabe:
# Ergebnis: 5
Mit diesen Grundlagen und Beispielen können Sie beginnen, TensorFlow für Ihre maschinellen Lernprojekte zu verwenden. TensorFlow bietet eine leistungsstarke und flexible Umgebung für die Arbeit mit Tensors und die Erstellung von Modellen.
