Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Conceptos básicos de personalización: tensores y operaciones

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
  • Usa la aceleración de la GPU
  • demostrar tf.data.Dataset

Importar TensorFlow

Para empezar, importe el tensorflow módulo. 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 discutiremos mucho más adelante.

import tensorflow as tf

Tensores

Un tensor es una matriz multidimensional. Al igual que en NumPy ndarray objetos, tf.Tensor objetos tienen un tipo de datos y una forma. Además, tf.Tensor s pueden residir en el acelerador de la memoria (como una GPU). TensorFlow ofrece una amplia 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 de Python nativos, 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 y NumPy tf.Tensor s son:

  1. Los tensores pueden estar respaldados por una memoria aceleradora (como GPU, TPU).
  2. Los tensores son inmutables.

Compatibilidad NumPy

La conversión entre un TensorFlow tf.Tensor s y una NumPy ndarray es fácil:

  • Las operaciones de TensorFlow convierten automáticamente los ndarrays de NumPy en tensores.
  • Las operaciones de NumPy convierten automáticamente los tensores en ndarrays de NumPy.

Los tensores se convierten explícitamente a ndarrays NumPy utilizando su .numpy() método. Estas conversiones son típicamente barato ya que la matriz y tf.Tensor comparten la representación subyacente de memoria, si es posible. Sin embargo, compartir la representación subyacente no siempre es posible ya que el tf.Tensor puede ser alojado en la memoria de la GPU, mientras que las matrices NumPy siempre están respaldados 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.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

El Tensor.device propiedad 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 está ejecutando este programa y el dispositivo dentro de ese host. Esto es necesario para la ejecución distribuida de un programa de TensorFlow. Los extremos de cadena con GPU:<N> si el tensor se coloca en el N GPU-ésimo en el host.

Colocación explícita de dispositivos

En TensorFlow, la colocación se refiere a cómo las operaciones individuales se asignan (colocado) 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 tensores en ese dispositivo, si es necesario. Sin embargo, las operaciones de TensorFlow se pueden colocar de forma explícita en los dispositivos específicos utilizando el tf.device gestor de contexto, 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.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: 93.77ms
On GPU:
10 loops: 397.49ms

Conjuntos de datos

En esta sección se utiliza el tf.data.Dataset API para construir un gasoducto para alimentar datos a su modelo. El tf.data.Dataset API se utiliza para performant construcción, tuberías de entrada complejas a partir de simple, piezas reutilizables que alimentará a los bucles de formación o evaluación de su modelo.

Crear una fuente Dataset

Crear un conjunto de datos de origen mediante una de las funciones de la fábrica como Dataset.from_tensors , Dataset.from_tensor_slices , o el uso de objetos que se leen de archivos como TextLineDataset o TFRecordDataset . Consulte la guía TensorFlow conjunto de datos 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 transformaciones como map , batch , y shuffle a aplicar transformaciones a conjuntos de datos de registros.

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

ds_file = ds_file.batch(2)

Iterar

tf.data.Dataset objetos de soporte iteración para iterar sobre 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([4 9], shape=(2,), dtype=int32)
tf.Tensor([ 1 16], 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)