¡El Día de la Comunidad de ML es el 9 de noviembre! Únase a nosotros para recibir actualizaciones de TensorFlow, JAX, y más Más información

Introducción a los tensores

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno
import tensorflow as tf
import numpy as np

Los tensores son matrices multidimensionales con un tipo uniforme (llamado un dtype ). Puede ver todos soportados dtypes en tf.dtypes.DType .

Si está familiarizado con NumPy , tensores son (o algo así) como np.arrays .

Todos los tensores son inmutables como los números y las cadenas de Python: nunca se puede actualizar el contenido de un tensor, solo crear uno nuevo.

Lo esencial

Creemos algunos tensores básicos.

Aquí hay un tensor "escalar" o "rango 0". Un escalar contiene un valor único y no "ejes".

# This will be an int32 tensor by default; see "dtypes" below.
rank_0_tensor = tf.constant(4)
print(rank_0_tensor)
tf.Tensor(4, shape=(), dtype=int32)

Un tensor "vector" o "rango-1" es como una lista de valores. Un vector tiene un eje:

# Let's make this a float tensor.
rank_1_tensor = tf.constant([2.0, 3.0, 4.0])
print(rank_1_tensor)
tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)

Un tensor de "matriz" o "rango 2" tiene dos ejes:

# If you want to be specific, you can set the dtype (see below) at creation time
rank_2_tensor = tf.constant([[1, 2],
                             [3, 4],
                             [5, 6]], dtype=tf.float16)
print(rank_2_tensor)
tf.Tensor(
[[1. 2.]
 [3. 4.]
 [5. 6.]], shape=(3, 2), dtype=float16)
Un escalar, forma: [] Un vector, forma: [3] Una matriz, forma: [3, 2]
Un escalar, el número 4La línea con 3 secciones, cada una con un número.Una cuadrícula de 3x2, con cada celda que contiene un número.

Los tensores pueden tener más ejes; aquí hay un tensor con tres ejes:

# There can be an arbitrary number of
# axes (sometimes called "dimensions")
rank_3_tensor = tf.constant([
  [[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]],
  [[10, 11, 12, 13, 14],
   [15, 16, 17, 18, 19]],
  [[20, 21, 22, 23, 24],
   [25, 26, 27, 28, 29]],])

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

Hay muchas formas de visualizar un tensor con más de dos ejes.

A 3-eje tensor, forma: [3, 2, 5]

Puede convertir un tensor a una matriz NumPy ya sea usando np.array o la tensor.numpy método:

np.array(rank_2_tensor)
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)
rank_2_tensor.numpy()
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)

Los tensores a menudo contienen flotadores e ints, pero tienen muchos otros tipos, que incluyen:

  • números complejos
  • instrumentos de cuerda

La base tf.Tensor clase requiere tensores para ser "rectangular" --- que es, a lo largo de cada eje, cada elemento es del mismo tamaño. Sin embargo, existen tipos especializados de tensores que pueden manejar diferentes formas:

Puede hacer matemáticas básicas con tensores, incluida la suma, la multiplicación por elementos y la multiplicación de matrices.

a = tf.constant([[1, 2],
                 [3, 4]])
b = tf.constant([[1, 1],
                 [1, 1]]) # Could have also said `tf.ones([2,2])`

print(tf.add(a, b), "\n")
print(tf.multiply(a, b), "\n")
print(tf.matmul(a, b), "\n")
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)
print(a + b, "\n") # element-wise addition
print(a * b, "\n") # element-wise multiplication
print(a @ b, "\n") # matrix multiplication
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32)

Los tensores se utilizan en todo tipo de operaciones (ops).

c = tf.constant([[4.0, 5.0], [10.0, 1.0]])

# Find the largest value
print(tf.reduce_max(c))
# Find the index of the largest value
print(tf.argmax(c))
# Compute the softmax
print(tf.nn.softmax(c))
tf.Tensor(10.0, shape=(), dtype=float32)
tf.Tensor([1 0], shape=(2,), dtype=int64)
tf.Tensor(
[[2.6894143e-01 7.3105854e-01]
 [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)

Acerca de las formas

Los tensores tienen formas. Algo de vocabulario:

  • Forma: La longitud (número de elementos) de cada uno de los ejes de un tensor.
  • Rango: Número de ejes del tensor. Un escalar tiene rango 0, un vector tiene rango 1, una matriz tiene rango 2.
  • Eje o Dimensión: Una dimensión particular de un tensor.
  • Tamaño: El número total de elementos en el tensor, el vector de la forma del producto.

Tensores y tf.TensorShape los objetos tienen propiedades convenientes para acceder a éstos:

rank_4_tensor = tf.zeros([3, 2, 4, 5])
Una clasificación-4 tensor, forma: [3, 2, 4, 5]
La forma de un tensor es como un vector.Un tensor de 4 ejes
print("Type of every element:", rank_4_tensor.dtype)
print("Number of axes:", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along the last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (3*2*4*5): ", tf.size(rank_4_tensor).numpy())
Type of every element: <dtype: 'float32'>
Number of axes: 4
Shape of tensor: (3, 2, 4, 5)
Elements along axis 0 of tensor: 3
Elements along the last axis of tensor: 5
Total number of elements (3*2*4*5):  120

Si bien a menudo se hace referencia a los ejes por sus índices, siempre debe realizar un seguimiento del significado de cada uno. A menudo, los ejes se ordenan de global a local: el eje del lote primero, seguido de las dimensiones espaciales y las características de cada ubicación al final. De esta manera, los vectores de características son regiones contiguas de memoria.

Orden de eje típico
Mantenga un registro de lo que es cada eje. Un tensor de 4 ejes podría ser: Lote, Ancho, Alto, Características

Indexación

Indexación de un solo eje

TensorFlow sigue las reglas de indexación estándar de Python, similar a la indexación de una lista o una cadena en Python , y las reglas básicas para NumPy indexación.

  • índices comienzan en 0
  • los índices negativos cuentan hacia atrás desde el final
  • dos puntos, : , se utilizan para rebanadas: start:stop:step
rank_1_tensor = tf.constant([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print(rank_1_tensor.numpy())
[ 0  1  1  2  3  5  8 13 21 34]

La indexación con un escalar elimina el eje:

print("First:", rank_1_tensor[0].numpy())
print("Second:", rank_1_tensor[1].numpy())
print("Last:", rank_1_tensor[-1].numpy())
First: 0
Second: 1
Last: 34

Indexación con un : rebanada mantiene el eje:

print("Everything:", rank_1_tensor[:].numpy())
print("Before 4:", rank_1_tensor[:4].numpy())
print("From 4 to the end:", rank_1_tensor[4:].numpy())
print("From 2, before 7:", rank_1_tensor[2:7].numpy())
print("Every other item:", rank_1_tensor[::2].numpy())
print("Reversed:", rank_1_tensor[::-1].numpy())
Everything: [ 0  1  1  2  3  5  8 13 21 34]
Before 4: [0 1 1 2]
From 4 to the end: [ 3  5  8 13 21 34]
From 2, before 7: [1 2 3 5 8]
Every other item: [ 0  1  3  8 21]
Reversed: [34 21 13  8  5  3  2  1  1  0]

Indexación multieje

Los tensores de rango superior se indexan pasando varios índices.

Las mismas reglas exactas que en el caso de un solo eje se aplican a cada eje de forma independiente.

print(rank_2_tensor.numpy())
[[1. 2.]
 [3. 4.]
 [5. 6.]]

Pasando un número entero para cada índice, el resultado es un escalar.

# Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
4.0

Puede indexar utilizando cualquier combinación de enteros y sectores:

# Get row and column tensors
print("Second row:", rank_2_tensor[1, :].numpy())
print("Second column:", rank_2_tensor[:, 1].numpy())
print("Last row:", rank_2_tensor[-1, :].numpy())
print("First item in last column:", rank_2_tensor[0, -1].numpy())
print("Skip the first row:")
print(rank_2_tensor[1:, :].numpy(), "\n")
Second row: [3. 4.]
Second column: [2. 4. 6.]
Last row: [5. 6.]
First item in last column: 2.0
Skip the first row:
[[3. 4.]
 [5. 6.]]

Aquí hay un ejemplo con un tensor de 3 ejes:

print(rank_3_tensor[:, :, 4])
tf.Tensor(
[[ 4  9]
 [14 19]
 [24 29]], shape=(3, 2), dtype=int32)
Seleccionar la última característica en todas las ubicaciones en cada ejemplo del lote
Un tensor de 3x2x5 con todos los valores en el índice-4 del último eje seleccionado.Los valores seleccionados empaquetados en un tensor de 2 ejes.

Lea la guía de corte en rodajas tensor de aprender cómo se puede aplicar la indexación de manipular elementos individuales en sus tensores.

Manipular formas

Reformar un tensor es de gran utilidad.

# Shape returns a `TensorShape` object that shows the size along each axis
x = tf.constant([[1], [2], [3]])
print(x.shape)
(3, 1)
# You can convert this object into a Python list, too
print(x.shape.as_list())
[3, 1]

Puede remodelar un tensor en una nueva forma. El tf.reshape funcionamiento es rápido y barato como los datos subyacentes no tiene que ser duplicado.

# You can reshape a tensor to a new shape.
# Note that you're passing in a list
reshaped = tf.reshape(x, [1, 3])
print(x.shape)
print(reshaped.shape)
(3, 1)
(1, 3)

Los datos mantienen su disposición en memoria y se crea un nuevo tensor, con la forma solicitada, apuntando a los mismos datos. TensorFlow usa un orden de memoria de "fila principal" de estilo C, donde incrementar el índice de la derecha corresponde a un solo paso en la memoria.

print(rank_3_tensor)
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

Si aplana un tensor, puede ver en qué orden se coloca en la memoria.

# A `-1` passed in the `shape` argument says "Whatever fits".
print(tf.reshape(rank_3_tensor, [-1]))
tf.Tensor(
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29], shape=(30,), dtype=int32)

Típicamente el único uso razonable de tf.reshape es combinar o dividir ejes adyacentes (o añadir / eliminar 1 s).

Para este tensor de 3x2x5, remodelar a (3x2) x5 o 3x (2x5) son dos cosas razonables, ya que los cortes no se mezclan:

print(tf.reshape(rank_3_tensor, [3*2, 5]), "\n")
print(tf.reshape(rank_3_tensor, [3, -1]))
tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]], shape=(6, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]], shape=(3, 10), dtype=int32)
Algunas buenas remodelaciones.
Un tensor de 3x2x5Los mismos datos reformados a (3x2) x5Los mismos datos reformados a 3x (2x5)

La remodelación "funcionará" para cualquier forma nueva con el mismo número total de elementos, pero no servirá de nada si no respeta el orden de los ejes.

El intercambio de ejes en tf.reshape no funciona; Usted necesita tf.transpose para eso.

# Bad examples: don't do this

# You can't reorder axes with reshape.
print(tf.reshape(rank_3_tensor, [2, 3, 5]), "\n") 

# This is a mess
print(tf.reshape(rank_3_tensor, [5, 6]), "\n")

# This doesn't work at all
try:
  tf.reshape(rank_3_tensor, [7, -1])
except Exception as e:
  print(f"{type(e).__name__}: {e}")
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]

 [[15 16 17 18 19]
  [20 21 22 23 24]
  [25 26 27 28 29]]], shape=(2, 3, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]
 [24 25 26 27 28 29]], shape=(5, 6), dtype=int32) 

InvalidArgumentError: Input to reshape is a tensor with 30 values, but the requested shape requires a multiple of 7 [Op:Reshape]
Algunas remodelaciones malas.
No puede reordenar los ejes, use tf.transpose para esoCualquier cosa que mezcle las porciones de datos probablemente sea incorrecta.La nueva forma debe encajar exactamente.

Puede encontrarse con formas no completamente especificadas. O bien la forma contiene una None (un eje de longitud es desconocida) o toda la forma es None (el rango de la tensor es desconocido).

A excepción de tf.RaggedTensor , tales formas sólo se producirán en el contexto de las API simbólicos, gráfico de la capacidad de TensorFlow:

Más sobre DTypes

Para inspeccionar una tf.Tensor tipo de datos uso 's la Tensor.dtype propiedad.

Al crear un tf.Tensor de un objeto de Python se puede especificar opcionalmente el tipo de datos.

Si no lo hace, TensorFlow elige un tipo de datos que puede representar sus datos. TensorFlow convierte enteros Python a tf.int32 y Python números de punto flotante a tf.float32 . De lo contrario, TensorFlow usa las mismas reglas que usa NumPy al convertir en matrices.

Puede emitir de un tipo a otro.

the_f64_tensor = tf.constant([2.2, 3.3, 4.4], dtype=tf.float64)
the_f16_tensor = tf.cast(the_f64_tensor, dtype=tf.float16)
# Now, cast to an uint8 and lose the decimal precision
the_u8_tensor = tf.cast(the_f16_tensor, dtype=tf.uint8)
print(the_u8_tensor)
tf.Tensor([2 3 4], shape=(3,), dtype=uint8)

Radiodifusión

La radiodifusión es un concepto tomado de la función equivalente en NumPy . En resumen, bajo ciertas condiciones, los tensores más pequeños se "estiran" automáticamente para adaptarse a tensores más grandes cuando se ejecutan operaciones combinadas en ellos.

El caso más simple y común es cuando intenta multiplicar o agregar un tensor a un escalar. En ese caso, el escalar se transmite para que tenga la misma forma que el otro argumento.

x = tf.constant([1, 2, 3])

y = tf.constant(2)
z = tf.constant([2, 2, 2])
# All of these are the same computation
print(tf.multiply(x, 2))
print(x * y)
print(x * z)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)

Del mismo modo, los ejes con longitud 1 se pueden estirar para que coincidan con los otros argumentos. Ambos argumentos se pueden estirar en el mismo cálculo.

En este caso, una matriz de 3x1 se multiplica por elementos por una matriz de 1x4 para producir una matriz de 3x4. Nota cómo el principal 1 es opcional: La forma de y es [4] .

# These are the same computations
x = tf.reshape(x,[3,1])
y = tf.range(1, 5)
print(x, "\n")
print(y, "\n")
print(tf.multiply(x, y))
tf.Tensor(
[[1]
 [2]
 [3]], shape=(3, 1), dtype=int32) 

tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) 

tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)
Agregar transmitido: a [3, 1] veces a [1, 4] da una [3,4]
Agregar una matriz de 3x1 a una matriz de 4x1 da como resultado una matriz de 3x4

Aquí está la misma operación sin transmisión:

x_stretch = tf.constant([[1, 1, 1, 1],
                         [2, 2, 2, 2],
                         [3, 3, 3, 3]])

y_stretch = tf.constant([[1, 2, 3, 4],
                         [1, 2, 3, 4],
                         [1, 2, 3, 4]])

print(x_stretch * y_stretch)  # Again, operator overloading
tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)

La mayoría de las veces, la transmisión es eficiente tanto en el tiempo como en el espacio, ya que la operación de transmisión nunca materializa los tensores expandidos en la memoria.

¿Ves lo que se parece a transmitir utilizando tf.broadcast_to .

print(tf.broadcast_to(tf.constant([1, 2, 3]), [3, 3]))
tf.Tensor(
[[1 2 3]
 [1 2 3]
 [1 2 3]], shape=(3, 3), dtype=int32)

A diferencia de un op matemática, por ejemplo, broadcast_to no hace nada especial para ahorrar memoria. Aquí estás materializando el tensor.

Puede complicarse aún más. Esta sección del libro de Jake Vanderplas Manual Ciencia Python de datos a transmitir muestra más trucos (de nuevo en NumPy).

tf.convert_to_tensor

La mayoría de las operaciones, como tf.matmul y tf.reshape tomar argumentos de clase tf.Tensor . Sin embargo, notará que en el caso anterior, se aceptan objetos de Python con forma de tensores.

La mayoría, pero no todos, ops llaman convert_to_tensor en argumentos no tensor. Existe un registro de las conversiones, y la mayoría de las clases de objetos como de NumPy ndarray , TensorShape , listas de Python, y tf.Variable serán todos convertir automáticamente.

Ver tf.register_tensor_conversion_function para más detalles, y si usted tiene su propio tipo que le gustaría convertir automáticamente a un tensor.

Tensores irregulares

Un tensor con números variables de elementos a lo largo de algún eje se llama "irregular". Uso tf.ragged.RaggedTensor para los datos desigual.

Por ejemplo, esto no se puede representar como un tensor regular:

A tf.RaggedTensor , forma: [4, None]
Un tensor irregular de 2 ejes, cada fila puede tener una longitud diferente.
ragged_list = [
    [0, 1, 2, 3],
    [4, 5],
    [6, 7, 8],
    [9]]
try:
  tensor = tf.constant(ragged_list)
except Exception as e:
  print(f"{type(e).__name__}: {e}")
ValueError: Can't convert non-rectangular Python sequence to Tensor.

En lugar de crear un tf.RaggedTensor usando tf.ragged.constant :

ragged_tensor = tf.ragged.constant(ragged_list)
print(ragged_tensor)
<tf.RaggedTensor [[0, 1, 2, 3], [4, 5], [6, 7, 8], [9]]>

La forma de un tf.RaggedTensor contendrá algunos ejes con longitudes desconocidos:

print(ragged_tensor.shape)
(4, None)

Tensores de cuerda

tf.string es un dtype , lo que quiere decir que puede representar datos como cadenas de longitud variable (matrices de bytes) en los tensores.

Las cadenas son atómicas y no se pueden indexar como las cadenas de Python. La longitud de la cuerda no es uno de los ejes del tensor. Ver tf.strings para las funciones de manipularlos.

Aquí hay un tensor de cadena escalar:

# Tensors can be strings, too here is a scalar string.
scalar_string_tensor = tf.constant("Gray wolf")
print(scalar_string_tensor)
tf.Tensor(b'Gray wolf', shape=(), dtype=string)

Y un vector de cuerdas:

Un vector de cadenas, forma: [3,]
La longitud de la cuerda no es uno de los ejes del tensor.
# If you have three string tensors of different lengths, this is OK.
tensor_of_strings = tf.constant(["Gray wolf",
                                 "Quick brown fox",
                                 "Lazy dog"])
# Note that the shape is (3,). The string length is not included.
print(tensor_of_strings)
tf.Tensor([b'Gray wolf' b'Quick brown fox' b'Lazy dog'], shape=(3,), dtype=string)

En la copia impresa por encima de la b prefijo indica que tf.string dtype no es una cadena Unicode, pero un byte-cadena. Ver el Tutorial Unicode para más información sobre cómo trabajar con texto Unicode en TensorFlow.

Si pasa caracteres Unicode, están codificados en utf-8.

tf.constant("🥳👍")
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>

Algunas funciones básicas con las cadenas se pueden encontrar en tf.strings , incluyendo tf.strings.split .

# You can use split to split a string into a set of tensors
print(tf.strings.split(scalar_string_tensor, sep=" "))
tf.Tensor([b'Gray' b'wolf'], shape=(2,), dtype=string)
# ...but it turns into a `RaggedTensor` if you split up a tensor of strings,
# as each string might be split into a different number of parts.
print(tf.strings.split(tensor_of_strings))
<tf.RaggedTensor [[b'Gray', b'wolf'], [b'Quick', b'brown', b'fox'], [b'Lazy', b'dog']]>
Tres cadenas de división, forma: [3, None]
Dividir varias cadenas devuelve un tf.RaggedTensor

Y tf.string.to_number :

text = tf.constant("1 10 100")
print(tf.strings.to_number(tf.strings.split(text, " ")))
tf.Tensor([  1.  10. 100.], shape=(3,), dtype=float32)

Aunque no se puede utilizar tf.cast a su vez un tensor de cadena en números, puede convertirlo en bytes, y luego en números.

byte_strings = tf.strings.bytes_split(tf.constant("Duck"))
byte_ints = tf.io.decode_raw(tf.constant("Duck"), tf.uint8)
print("Byte strings:", byte_strings)
print("Bytes:", byte_ints)
Byte strings: tf.Tensor([b'D' b'u' b'c' b'k'], shape=(4,), dtype=string)
Bytes: tf.Tensor([ 68 117  99 107], shape=(4,), dtype=uint8)
# Or split it up as unicode and then decode it
unicode_bytes = tf.constant("アヒル 🦆")
unicode_char_bytes = tf.strings.unicode_split(unicode_bytes, "UTF-8")
unicode_values = tf.strings.unicode_decode(unicode_bytes, "UTF-8")

print("\nUnicode bytes:", unicode_bytes)
print("\nUnicode chars:", unicode_char_bytes)
print("\nUnicode values:", unicode_values)
Unicode bytes: tf.Tensor(b'\xe3\x82\xa2\xe3\x83\x92\xe3\x83\xab \xf0\x9f\xa6\x86', shape=(), dtype=string)

Unicode chars: tf.Tensor([b'\xe3\x82\xa2' b'\xe3\x83\x92' b'\xe3\x83\xab' b' ' b'\xf0\x9f\xa6\x86'], shape=(5,), dtype=string)

Unicode values: tf.Tensor([ 12450  12498  12523     32 129414], shape=(5,), dtype=int32)

El tf.string dtype se utiliza para todos los bytes de datos en bruto en TensorFlow. El tf.io módulo contiene funciones para la conversión de datos hacia y desde bytes, incluyendo imágenes de decodificación y análisis csv.

Tensores escasos

A veces, sus datos son escasos, como un espacio de incrustación muy amplio. TensorFlow apoya tf.sparse.SparseTensor y las operaciones conexas para almacenar datos dispersos de manera eficiente.

A tf.SparseTensor , forma: [3, 4]
Una cuadrícula de 3x4, con valores en solo dos de las celdas.
# Sparse tensors store values by index in a memory-efficient manner
sparse_tensor = tf.sparse.SparseTensor(indices=[[0, 0], [1, 2]],
                                       values=[1, 2],
                                       dense_shape=[3, 4])
print(sparse_tensor, "\n")

# You can convert sparse tensors to dense
print(tf.sparse.to_dense(sparse_tensor))
SparseTensor(indices=tf.Tensor(
[[0 0]
 [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64)) 

tf.Tensor(
[[1 0 0 0]
 [0 0 2 0]
 [0 0 0 0]], shape=(3, 4), dtype=int32)