 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver fuente en GitHub |  Descargar cuaderno |
Este es un tutorial introductorio de TensorFlow que muestra cómo:
- Importar el paquete requerido
- Crea y usa tensores
- Utilice la aceleración de GPU
- Demuestre
tf.data.Dataset
Importar TensorFlow
Para comenzar, importe el módulo tensorflow . A partir de TensorFlow 2, la ejecución ansiosa está activada de forma predeterminada. Esto permite una interfaz más interactiva para TensorFlow, cuyos detalles analizaremos mucho más adelante.
import tensorflow as tf
Tensores
Un tensor es una matriz multidimensional. Similar a los objetos ndarray NumPy, los objetos tf.Tensor tienen un tipo de datos y una forma. Además, tf.Tensor s puede residir en la memoria del acelerador (como una GPU). TensorFlow ofrece una rica biblioteca de operaciones ( tf.add , tf.matmul , tf.linalg.inv , etc.) que consumen y producen tf.Tensor s. Estas operaciones convierten automáticamente los tipos nativos de Python, por ejemplo:
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)
Cada tf.Tensor tiene una forma y un tipo de datos:
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'>
Las diferencias más obvias entre las matrices NumPy y tf.Tensor s son:
- Los tensores pueden estar respaldados por una memoria aceleradora (como GPU, TPU).
- Los tensores son inmutables.
Compatibilidad NumPy
La conversión entre un TensorFlow tf.Tensor sy un NumPy ndarray es fácil:
- Las operaciones de TensorFlow convierten automáticamente los ndarrays de NumPy en tensores.
- Las operaciones NumPy convierten automáticamente los tensores en ndarrays NumPy.
Los tensores se convierten explícitamente en ndarrays NumPy utilizando su método .numpy() . Estas conversiones suelen ser económicas ya que la matriz y tf.Tensor comparten la representación de la memoria subyacente, si es posible. Sin embargo, no siempre es posible compartir la representación subyacente, ya que tf.Tensor puede estar alojado en la memoria de la GPU, mientras que las matrices NumPy siempre están respaldadas por la memoria del host, y la conversión implica una copia de la GPU a la memoria del host.
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.]]
Aceleración de GPU
Muchas operaciones de TensorFlow se aceleran con la GPU para el cálculo. Sin anotaciones, TensorFlow decide automáticamente si usar la GPU o la CPU para una operación, copiando el tensor entre la CPU y la memoria de la GPU, si es necesario. Los tensores producidos por una operación suelen estar respaldados por la memoria del dispositivo en el que se ejecutó la operación, por ejemplo:
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
Nombres de dispositivos
La propiedad Tensor.device proporciona un nombre de cadena completo del dispositivo que aloja el contenido del tensor. Este nombre codifica muchos detalles, como un identificador de la dirección de red del host en el que se ejecuta este programa y el dispositivo dentro de ese host. Esto es necesario para la ejecución distribuida de un programa de TensorFlow. La cadena termina con GPU:<N> si el tensor se coloca en la N -ésima GPU del host.
Colocación explícita de dispositivos
En TensorFlow, la ubicación se refiere a cómo se asignan (colocan) operaciones individuales en un dispositivo para su ejecución. Como se mencionó, cuando no se proporciona una guía explícita, TensorFlow decide automáticamente qué dispositivo ejecutar una operación y copia los tensores en ese dispositivo, si es necesario. Sin embargo, las operaciones de TensorFlow se pueden colocar explícitamente en dispositivos específicos mediante el tf.device contexto tf.device , por ejemplo:
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: 102.06ms On GPU: 10 loops: 231.87ms
Conjuntos de datos
Esta sección utiliza la API tf.data.Dataset para crear una canalización para alimentar datos a su modelo. La APItf.data.Dataset se utiliza para crear canalizaciones de entrada complejas y de alto rendimiento a partir de piezas simples y reutilizables que alimentarán los ciclos de entrenamiento o evaluación de su modelo.
Crear un Dataset origen
Cree un conjunto de datos de origen usando una de las funciones de fábrica como Dataset.from_tensors , Dataset.from_tensor_slices , o usando objetos que leen desde archivos como TextLineDataset o TFRecordDataset . Consulta la guía del conjunto de datos de TensorFlow para obtener más información.
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)
Aplicar transformaciones
Utilice las funciones de transformación como map , batch y shuffle para aplicar transformaciones a los registros del conjunto de datos.
ds_tensors = ds_tensors.map(tf.square).shuffle(2).batch(2)
ds_file = ds_file.batch(2)
Iterar
tf.data.Dataset objetostf.data.Dataset admiten la iteración para recorrer los registros:
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([16 9], shape=(2,), dtype=int32) tf.Tensor([25 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)