Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Anpassungsgrundlagen: Tensoren und Operationen

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Dies ist ein einführendes TensorFlow-Tutorial, das zeigt, wie man:

  • Importieren Sie das gewünschte Paket
  • Erstellen und verwenden Sie Tensoren
  • Verwenden Sie die GPU-Beschleunigung
  • Demonstrieren Sie tf.data.Dataset

TensorFlow importieren

Importieren Sie zunächst das tensorflow Modul. Ab TensorFlow 2 ist die eifrige Ausführung standardmäßig aktiviert. Dies ermöglicht ein interaktiveres Frontend für TensorFlow, auf dessen Details wir noch viel später eingehen werden.

 import tensorflow as tf
 

Tensoren

Ein Tensor ist ein mehrdimensionales Array. Ähnlich wie NumPy ndarray Objekte haben tf.Tensor Objekte einen Datentyp und eine Form. Darüber tf.Tensor können sich tf.Tensor im Beschleunigerspeicher befinden (wie eine GPU). TensorFlow bietet eine umfangreiche Bibliothek von Operationen ( tf.add , tf.matmul , tf.linalg.inv usw.), die tf.Tensor verbrauchen und produzieren. Diese Operationen konvertieren automatisch native Python-Typen, zum Beispiel:

 print(tf.add(1, 2))
print(tf.add([1, 2], [3, 4]))
print(tf.square(5))
print(tf.reduce_sum([1, 2, 3]))

# Operator overloading is also supported
print(tf.square(2) + tf.square(3))
 
tf.Tensor(3, shape=(), dtype=int32)
tf.Tensor([4 6], shape=(2,), dtype=int32)
tf.Tensor(25, shape=(), dtype=int32)
tf.Tensor(6, shape=(), dtype=int32)
tf.Tensor(13, shape=(), dtype=int32)

Jeder tf.Tensor hat eine Form und einen Datentyp:

 x = tf.matmul([[1]], [[2, 3]])
print(x)
print(x.shape)
print(x.dtype)
 
tf.Tensor([[2 3]], shape=(1, 2), dtype=int32)
(1, 2)
<dtype: 'int32'>

Die offensichtlichsten Unterschiede zwischen NumPy-Arrays und tf.Tensor sind:

  1. Tensoren können durch Beschleunigerspeicher (wie GPU, TPU) gesichert werden.
  2. Tensoren sind unveränderlich.

NumPy-Kompatibilität

Das Konvertieren zwischen einem TensorFlow tf.Tensor s und einem NumPy ndarray ist einfach:

  • TensorFlow-Operationen konvertieren NumPy-ndarrays automatisch in Tensoren.
  • NumPy-Operationen konvertieren Tensoren automatisch in NumPy-ndarrays.

Tensoren werden mit ihrer .numpy() -Methode explizit in NumPy-ndarrays konvertiert. Diese Konvertierungen sind normalerweise billig, da Array und tf.Tensor die zugrunde liegende Speicherdarstellung gemeinsam nutzen. Die Freigabe der zugrunde liegenden Darstellung ist jedoch nicht immer möglich, da der tf.Tensor möglicherweise im GPU-Speicher gehostet wird, während NumPy-Arrays immer vom tf.Tensor gesichert werden und die Konvertierung eine Kopie von der GPU in den tf.Tensor umfasst.

 import numpy as np

ndarray = np.ones([3, 3])

print("TensorFlow operations convert numpy arrays to Tensors automatically")
tensor = tf.multiply(ndarray, 42)
print(tensor)


print("And NumPy operations convert Tensors to numpy arrays automatically")
print(np.add(tensor, 1))

print("The .numpy() method explicitly converts a Tensor to a numpy array")
print(tensor.numpy())
 
TensorFlow operations convert numpy arrays to Tensors automatically
tf.Tensor(
[[42. 42. 42.]
 [42. 42. 42.]
 [42. 42. 42.]], shape=(3, 3), dtype=float64)
And NumPy operations convert Tensors to numpy arrays automatically
[[43. 43. 43.]
 [43. 43. 43.]
 [43. 43. 43.]]
The .numpy() method explicitly converts a Tensor to a numpy array
[[42. 42. 42.]
 [42. 42. 42.]
 [42. 42. 42.]]

GPU-Beschleunigung

Viele TensorFlow-Operationen werden mithilfe der GPU für die Berechnung beschleunigt. Ohne Anmerkungen entscheidet TensorFlow automatisch, ob die GPU oder die CPU für eine Operation verwendet werden soll. Bei Bedarf wird der Tensor zwischen CPU- und GPU-Speicher kopiert. Durch eine Operation erzeugte Tensoren werden normalerweise durch den Speicher des Geräts gesichert, auf dem die Operation ausgeführt wurde, zum Beispiel:

 x = tf.random.uniform([3, 3])

print("Is there a GPU available: "),
print(tf.config.experimental.list_physical_devices("GPU"))

print("Is the Tensor on GPU #0:  "),
print(x.device.endswith('GPU:0'))
 
Is there a GPU available: 
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
Is the Tensor on GPU #0:  
True

Gerätenamen

Die Tensor.device Eigenschaft stellt einen vollständig qualifizierten Zeichenfolgennamen des Geräts bereit, auf dem sich der Inhalt des Tensors befindet. Dieser Name codiert viele Details, z. B. eine Kennung der Netzwerkadresse des Hosts, auf dem dieses Programm ausgeführt wird, und des Geräts auf diesem Host. Dies ist für die verteilte Ausführung eines TensorFlow-Programms erforderlich. Die Zeichenfolge endet mit GPU:<N> wenn der Tensor auf der N ten GPU auf dem Host platziert ist.

Explizite Geräteplatzierung

In TensorFlow bezieht sich die Platzierung darauf, wie einzelne Vorgänge einem Gerät zur Ausführung zugewiesen (darauf platziert) werden. Wie bereits erwähnt, entscheidet TensorFlow automatisch, welches Gerät eine Operation ausführen soll, wenn keine explizite Anleitung bereitgestellt wird, und kopiert bei Bedarf Tensoren auf dieses Gerät. TensorFlow-Vorgänge können jedoch mithilfe des tf.device Kontextmanagers explizit auf bestimmten Geräten platziert werden, z. B.:

 import time

def time_matmul(x):
  start = time.time()
  for loop in range(10):
    tf.matmul(x, x)

  result = time.time()-start

  print("10 loops: {:0.2f}ms".format(1000*result))

# Force execution on CPU
print("On CPU:")
with tf.device("CPU:0"):
  x = tf.random.uniform([1000, 1000])
  assert x.device.endswith("CPU:0")
  time_matmul(x)

# Force execution on GPU #0 if available
if tf.config.experimental.list_physical_devices("GPU"):
  print("On GPU:")
  with tf.device("GPU:0"): # Or GPU:1 for the 2nd GPU, GPU:2 for the 3rd etc.
    x = tf.random.uniform([1000, 1000])
    assert x.device.endswith("GPU:0")
    time_matmul(x)
 
On CPU:
10 loops: 99.19ms
On GPU:
10 loops: 239.31ms

Datensätze

In diesem Abschnitt wird die API tf.data.Dataset , um eine Pipeline zum Einspeisen von Daten in Ihr Modell zu erstellen. Die tf.data.Dataset API wird verwendet, um performante, komplexe Eingabepipelines aus einfachen, wiederverwendbaren Teilen zu erstellen, die die Trainings- oder Bewertungsschleifen Ihres Modells unterstützen.

Erstellen Sie eine Quelle Dataset

Erstellen Sie ein Quelldatensatz mit einer der Factory-Funktionen wie Dataset.from_tensors , Dataset.from_tensor_slices oder mit Objekten, die aus Dateien wie TextLineDataset oder TFRecordDataset . Weitere Informationen finden Sie im TensorFlow-Datensatzhandbuch .

 ds_tensors = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6])

# Create a CSV file
import tempfile
_, filename = tempfile.mkstemp()

with open(filename, 'w') as f:
  f.write("""Line 1
Line 2
Line 3
  """)

ds_file = tf.data.TextLineDataset(filename)
 

Transformationen anwenden

Verwenden Sie die Transformationsfunktionen wie map , batch und shuffle , um Transformationen auf Dataset-Datensätze anzuwenden.

 ds_tensors = ds_tensors.map(tf.square).shuffle(2).batch(2)

ds_file = ds_file.batch(2)
 

Iterieren

tf.data.Dataset Objekte unterstützen die Iteration, um Datensätze zu tf.data.Dataset :

 print('Elements of ds_tensors:')
for x in ds_tensors:
  print(x)

print('\nElements in ds_file:')
for x in ds_file:
  print(x)
 
Elements of ds_tensors:
tf.Tensor([1 4], shape=(2,), dtype=int32)
tf.Tensor([ 9 25], shape=(2,), dtype=int32)
tf.Tensor([16 36], shape=(2,), dtype=int32)

Elements in ds_file:
tf.Tensor([b'Line 1' b'Line 2'], shape=(2,), dtype=string)
tf.Tensor([b'Line 3' b'  '], shape=(2,), dtype=string)