Tensorflow One Hot Encoder?

tf.one_hot() está disponible en TF y es fácil de usar.

Supongamos que tiene 4 categorías posibles (gato, perro, pájaro, humano) y 2 instancias (gato, humano). Así que tu {[3] } y tu indices=[0, 3]

import tensorflow as tf
res = tf.one_hot(indices=[0, 3], depth=4)
with tf.Session() as sess:
    print sess.run(res)

Tenga en cuenta que si proporciona index=-1 obtendrá todos los ceros en su vector one-hot.

Respuesta antigua, cuando esta función no estaba disponible.

Después de mirar la documentación de python , no he encontrado nada similar. Una cosa que fortalecer mi creencia de que no existe es que en su propio ejemplo escriben one_hot manualmente.

def dense_to_one_hot(labels_dense, num_classes=10):
  """Convert class labels from scalars to one-hot vectors."""
  num_labels = labels_dense.shape[0]
  index_offset = numpy.arange(num_labels) * num_classes
  labels_one_hot = numpy.zeros((num_labels, num_classes))
  labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
  return labels_one_hot

También puedes hacer esto en scikitlearn.

numpy lo hace!

import numpy as np
np.eye(n_labels)[target_vector]

Una forma simple y corta de codificar en caliente cualquier entero o lista de intergers:

a = 5 
b = [1, 2, 3]
# one hot an integer
one_hot_a = tf.nn.embedding_lookup(np.identity(10), a)
# one hot a list of integers
one_hot_b = tf.nn.embedding_lookup(np.identity(max(b)+1), b)

Las versiones recientes de TensorFlow (nightlies y quizás incluso 0.7.1) tienen un op llamado tf.one_hot que hace lo que quiere. ¡Mira esto!

Por otro lado, si tiene una matriz densa y desea buscar y agregar valores en ella, debería usar la función embedding_lookup.

Tal vez se deba a cambios en Tensorflow desde noviembre de 2015, pero la respuesta de @dga produjo errores. Hice que funcionara con las siguientes modificaciones:

sparse_labels = tf.reshape(label_batch, [-1, 1])
derived_size = tf.shape(sparse_labels)[0]
indices = tf.reshape(tf.range(0, derived_size, 1), [-1, 1])
concated = tf.concat(1, [indices, sparse_labels])
outshape = tf.concat(0, [tf.reshape(derived_size, [1]), tf.reshape(num_labels, [1])])
labels = tf.sparse_to_dense(concated, outshape, 1.0, 0.0)

Echa un vistazo a tf.nn.embedding_lookup . Se asigna desde identificadores categóricos a sus incrustaciones.

Para un ejemplo de cómo se usa para los datos de entrada, vea aquí.

Puede usar tf.sparse_to_dense :

El argumento sparse_indices indica hacia dónde deben ir, output_shape se debe establecer en el número de salidas posibles (por ejemplo, el número de etiquetas), y sparse_values debe ser 1 con el tipo deseado (determinará el tipo de la salida del tipo de sparse_values).

Hay embedding_ops en Scikit Flow y ejemplos que tratan con variables categóricas, etc.

Si acaba de empezar a aprender TensorFlow, le sugeriría que pruebe ejemplos en TensorFlow/skflow primero y luego, una vez que esté más familiarizado con TensorFlow, sería bastante fácil para usted insertar código TensorFlow para construir un modelo personalizado que desee (también hay ejemplos para esto).

Espero que esos ejemplos para la comprensión de imágenes y texto puedan empezar y háganos saber si usted encuentra cualquier problema! (publicar problemas o etiquetar skflow en SO).

Las versiones actuales de tensorflow implementan la siguiente función para crear tensores one-hot:

Https://www.tensorflow.org/versions/master/api_docs/python/array_ops.html#one_hot

Hay un par de maneras de hacerlo.

ans = tf.constant([[5, 6, 0, 0], [5, 6, 7, 0]]) #batch_size*max_seq_len
labels = tf.reduce_sum(tf.nn.embedding_lookup(np.identity(10), ans), 1)

>>> [[ 0.  0.  0.  0.  0.  1.  1.  0.  0.  0.]
>>> [ 0.  0.  0.  0.  0.  1.  1.  1.  0.  0.]]

La otra forma de hacerlo es.

labels2 = tf.reduce_sum(tf.one_hot(ans, depth=10, on_value=1, off_value=0, axis=1), 2)

 >>> [[0 0 0 0 0 1 1 0 0 0]
 >>> [0 0 0 0 0 1 1 1 0 0]]

Mi versión de @CFB y @dga ejemplo, acortado un poco para facilitar la comprensión.

num_labels = 10
labels_batch = [2, 3, 5, 9]

sparse_labels = tf.reshape(labels_batch, [-1, 1])
derived_size = len(labels_batch)
indices = tf.reshape(tf.range(0, derived_size, 1), [-1, 1])
concated = tf.concat(1, [indices, sparse_labels]) 
labels = tf.sparse_to_dense(concated, [derived_size, num_labels], 1.0, 0.0)

Como se mencionó anteriormente por @dga, Tensorflow tiene tf.one_hot ahora:

labels = tf.constant([5,3,2,4,1])
highest_label = tf.reduce_max(labels)
labels_one_hot = tf.one_hot(labels, highest_label + 1)

array([[ 0.,  0.,  0.,  0.,  0.,  1.],
       [ 0.,  0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  1.,  0.],
       [ 0.,  1.,  0.,  0.,  0.,  0.]], dtype=float32)

Es necesario especificar la profundidad, de lo contrario obtendrá un tensor podado-caliente.

Si te gusta hacerlo manualmente:

labels = tf.constant([5,3,2,4,1])
size = tf.shape(labels)[0]
highest_label = tf.reduce_max(labels)
labels_t = tf.reshape(labels, [-1, 1])
indices = tf.reshape(tf.range(size), [-1, 1])
idx_with_labels = tf.concat([indices, labels_t], 1)
labels_one_hot = tf.sparse_to_dense(idx_with_labels, [size, highest_label + 1], 1.0)

array([[ 0.,  0.,  0.,  0.,  0.,  1.],
       [ 0.,  0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  1.,  0.],
       [ 0.,  1.,  0.,  0.,  0.,  0.]], dtype=float32)

Observe el orden de los argumentos en tf.concat ()

In [7]: one_hot = tf.nn.embedding_lookup(np.eye(5), [1,2])

In [8]: one_hot.eval()
Out[8]: 
array([[ 0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.]])

Funciona en la versión 1.3.0 de TF. A partir de Sep 2017.