que - Tensorflow: canalización de entrada con datos dispersos para el estimador SVM

tensorflow español pdf

Question

Introducción:

Estoy tratando de entrenar el estimador svm de tensorflow.contrib.learn.python.learn.estimators.svm con datos dispersos. Uso de muestra con datos dispersos en el repositorio github en tensorflow/contrib/learn/python/learn/estimators/svm_test.py#L167 (No tengo permiso para publicar más enlaces, así que aquí la ruta relativa).

El estimador de svm espera como parámetro example_id_column y feature_columns , donde las columnas de características se deben derivar de la clase FeatureColumn , como tf.contrib.layers.feature_column.sparse_column_with_hash_bucket . Consulte tensorflow/contrib/learn/python/learn/estimators/svm.py#L85 Github en tensorflow/contrib/learn/python/learn/estimators/svm.py#L85 y la documentación en tensorflow.org en python/contrib.layers#Feature_columns .

Pregunta:

1. ¿Cómo debo configurar mi canalización de entrada para formatear los datos dispersos de tal forma que pueda usar uno de los tf.contrib.layers feature_columns como entrada para el estimador svm?
2. ¿Cómo sería una función de entrada densa con muchas características?

Fondo

La información que uso es el conjunto de datos a1a del sitio web de LIBSVM . El conjunto de datos tiene 123 características (que corresponderían a 123 feature_columns si los datos fueran densos). Escribí un usuario op para leer los datos como tf.decode_csv() pero para el formato LIBSVM. El op devuelve las etiquetas como tensor denso y las características como tensor disperso. Mi canal de entrada:

NUM_FEATURES = 123
batch_size = 200

# my op to parse the libsvm data
decode_libsvm_module = tf.load_op_library(''./libsvm.so'')

def input_pipeline(filename_queue, batch_size):
    with tf.name_scope(''input''):
        reader = tf.TextLineReader(name="TextLineReader_")
        _, libsvm_row = reader.read(filename_queue, name="libsvm_row_")
        min_after_dequeue = 1000
        capacity = min_after_dequeue + 3 * batch_size
        batch = tf.train.shuffle_batch([libsvm_row], batch_size=batch_size,
                                       capacity=capacity,
                                       min_after_dequeue=min_after_dequeue,
                                       name="text_line_batch_")
        labels, sp_indices, sp_values, sp_shape = /
            decode_libsvm_module.decode_libsvm(records=batch,
                                               num_features=123,
                                               OUT_TYPE=tf.int64, 
                                               name="Libsvm_decoded_")
        # Return the features as sparse tensor and the labels as dense
        return tf.SparseTensor(sp_indices, sp_values, sp_shape), labels

Aquí hay un lote de ejemplo con batch_size = 5 .

def input_fn(dataset_name):
    maybe_download()

    filename_queue_train = tf.train.string_input_producer([dataset_name], 
                                                        name="queue_t_")
    features, labels = input_pipeline(filename_queue_train, batch_size)

    return {
        ''example_id'': tf.as_string(tf.range(1,123,1,dtype=tf.int64)),
        ''features'': features
    }, labels

Esto es lo que intenté hasta ahora:

with tf.Session().as_default() as sess:
    sess.run(tf.global_variables_initializer())

    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)

    feature_column = tf.contrib.layers.sparse_column_with_hash_bucket(
        ''features'', hash_bucket_size=1000, dtype=tf.int64)

    svm_classifier = svm.SVM(feature_columns=[feature_column],
                             example_id_column=''example_id'',
                             l1_regularization=0.0,
                             l2_regularization=1.0)
    svm_classifier.fit(input_fn=lambda: input_fn(TRAIN),
                       steps=30)

    accuracy = svm_classifier.evaluate(
        input_fn= lambda: input_fn(features, labels), 
        steps=1)[''accuracy'']                       
    print(accuracy)
    coord.request_stop()

    coord.join(threads)
    sess.close()

Answer 1

Aquí hay un ejemplo, con datos inventados, que funciona para mí en TensorFlow 1.1.0-rc2. Creo que mi comentario fue engañoso; lo mejor es que convierta ~ 100 características binarias en funciones de valor real ( tf.sparse_tensor_to_dense ) y que use una real_valued_column , ya que sparse_column_with_integerized_feature está ocultando la mayor parte de la información útil del SVM Estimator.

import tensorflow as tf

batch_size = 10
num_features = 123
num_examples = 100

def input_fn():
  example_ids = tf.random_uniform(
      [batch_size], maxval=num_examples, dtype=tf.int64)
  # Construct a SparseTensor with features
  dense_features = (example_ids[:, None]
                    + tf.range(num_features, dtype=tf.int64)[None, :]) % 2
  non_zeros = tf.where(tf.not_equal(dense_features, 0))
  sparse_features = tf.SparseTensor(
      indices=non_zeros,
      values=tf.gather_nd(dense_features, non_zeros),
      dense_shape=[batch_size, num_features])
  features = {
      ''some_sparse_features'': tf.sparse_tensor_to_dense(sparse_features),
      ''example_id'': tf.as_string(example_ids)}
  labels = tf.equal(dense_features[:, 0], 1)
  return features, labels
svm = tf.contrib.learn.SVM(
    example_id_column=''example_id'',
    feature_columns=[
      tf.contrib.layers.real_valued_column(
          ''some_sparse_features'')],
    l2_regularization=0.1, l1_regularization=0.5)
svm.fit(input_fn=input_fn, steps=1000)
positive_example = lambda: {
    ''some_sparse_features'': tf.sparse_tensor_to_dense(
        tf.SparseTensor([[0, 0]], [1], [1, num_features])),
    ''example_id'': [''a'']}
print(svm.evaluate(input_fn=input_fn, steps=20))
print(next(svm.predict(input_fn=positive_example)))
negative_example = lambda: {
    ''some_sparse_features'': tf.sparse_tensor_to_dense(
        tf.SparseTensor([[0, 0]], [0], [1, num_features])),
    ''example_id'': [''b'']}
print(next(svm.predict(input_fn=negative_example)))

Huellas dactilares:

{''accuracy'': 1.0, ''global_step'': 1000, ''loss'': 1.0645389e-06}
{''logits'': array([ 0.01612902], dtype=float32), ''classes'': 1}
{''logits'': array([ 0.], dtype=float32), ''classes'': 0}