Frage Wie speichere ich Daten mit TensorFlow?


Es gibt ein kleines Snippet über das Laden von spärlichen Daten, aber ich habe keine Ahnung, wie man es benutzt.

SparseTensors spielen nicht gut mit Warteschlangen. Wenn Sie SparseTensors verwenden, müssen Sie die String-Datensätze mit tf.parse_example nach dem Batch-Vorgang dekodieren (anstatt tf.parse_single_example vor dem Batch-Vorgang zu verwenden).

Quelle

Ich denke, ich verstehe nicht wirklich, wie die Daten geladen werden.

Die Daten, die ich laden möchte, sind in der SVM Licht Format

Die Art, wie ich darüber nachdenke, besteht darin, den Trainingssatz in das TFRecords-Dateiformat zu konvertieren und dann diese konvertierten Daten mit Tensorflow zu laden. Die Sache ist, ich weiß nicht, wie ich meine Daten formatieren soll, so dass Tensorflow es als SparseTensors analysiert.

Hier ist ein Auszug aus ein die auf GitHub verfügbaren Beispiele:

def convert_to(images, labels, name):
  num_examples = labels.shape[0]
  if images.shape[0] != num_examples:
    raise ValueError("Images size %d does not match label size %d." %
                     (images.shape[0], num_examples))
  rows = images.shape[1]
  cols = images.shape[2]
  depth = images.shape[3]

  filename = os.path.join(FLAGS.directory, name + '.tfrecords')
  print('Writing', filename)
  writer = tf.python_io.TFRecordWriter(filename)
  for index in range(num_examples):
    image_raw = images[index].tostring()
    example = tf.train.Example(features=tf.train.Features(feature={
        'height': _int64_feature(rows),
        'width': _int64_feature(cols),
        'depth': _int64_feature(depth),
        'label': _int64_feature(int(labels[index])),
        'image_raw': _bytes_feature(image_raw)}))
    writer.write(example.SerializeToString())
  writer.close()

Es codiert die Bilddaten als einen großen Blob. Der Unterschied zu meinen Daten besteht darin, dass nicht jedes Merkmal ausgefüllt ist. Ich könnte meine Daten auf die gleiche Weise beibehalten, aber ich bin mir nicht sicher, ob dies die Art ist, die Funktionen zu nutzen.

Das kann nicht wichtig sein, da ich die Dinge auf der anderen Seite dekodieren werde, aber gibt es einen besseren Weg, dies für spärliche Daten zu tun?

Wie für das Lesen, Hier ist ein Beispiel, das dichte Tensordaten liest.

Ich habe verstanden, dass ich tauschen sollte tf.parse_single_example mit tf.parse_example und mach es nach dem Dosieren.

Wie kann ich Tensorflow jedoch mitteilen, dass meine Daten spärlich sind? Wie verknüpfe ich die Feature-Indizes, die ich mit den Feature-Werten im Tensor habe? Wie kann ich vor dem Laden der Daten ein Batching durchführen?

EDIT 1:

Hier ist, was ich versucht habe, ich bekomme ValueError: Shape () must have rank 1 Error:

from tqdm import *

def convert_to_tensor_file(path, out_file_name):

    feature_set = set()

    filename = os.path.join(FLAGS.directory, out_file_name + '.tfrecords')
    writer = tf.python_io.TFRecordWriter(filename)

    with open(path, 'r') as f:
        for line in tqdm(f):
            data = line.strip().split(' ')
            features = {
                "label": _int64_feature(int(data[0]))
            }
            for feature in data[1:]:
                index, value = feature.split(':')

                feature_set.add(index)

                features[index] = _int64_feature(int(value))

            example = tf.train.Example(features=tf.train.Features(feature=features))
            writer.write(example.SerializeToString())
        writer.close()

    return feature_set

feature_set = convert_to_tensor_file(TRAIN, 'train')

def load_tensor_file(name):
    filename = os.path.join(FLAGS.directory, name + '.tfrecords')

    features = {
        'label': tf.FixedLenFeature([], tf.int64),
    }

    for feature in feature_set:
        features[feature] = tf.VarLenFeature(tf.int64)

    with tf.name_scope('input'):
        filename_queue = tf.train.string_input_producer([filename])

        reader = tf.TFRecordReader()
        _, serialized_example = reader.read(filename_queue)
        features = tf.parse_example(serialized_example, features=features)

load_tensor_file('train')

Vielen Dank,


15
2018-04-28 14:34


Ursprung


Antworten:


Zuerst, um zu erklären, was diese Dokumentation bedeutet:

  1. Für dichte Daten machst du normalerweise:

    Serialisiertes Beispiel (vom Reader) -> parse_single_example -> batch queue -> benutze es.

  2. Für spärliche Daten müssen Sie Folgendes tun:

    Serialisiertes Beispiel (vom Reader) -> batch queue -> parse_example -> benutze es.

Ein Beispiel dafür wäre:

reader  = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
batch_serialized_examples = tf.shuffle_batch([serialized_example], batch_size)
feature_to_type = {
  'label': tf.FixedLenFeature([1], dtype=tf.int64),
  'sparse_feature': tf.VarLenFeature(dtype=tf.int64)
}
features = tf.parse_example(batch_serialized_examples, feature_to_type)

Hinweis, shuffle_batch nimmt eine Reihe von Strings und gibt Stapel von Strings zurück. label sollte aus Ihrem Beispiel len von == 1 festgelegt werden.


16
2018-04-29 00:50



Speichern Sie Indizes und Werte in Ihren TFRecords-Beispielen, und parsen Sie mit SparseFeature. Um beispielsweise eine dünn besetzte Darstellung für Folgendes zu speichern und zu laden:

[[0, 0, 0, 0, 0, 7],
 [0, 5, 0, 0, 0, 0],
 [0, 0, 0, 0, 9, 0],
 [0, 0, 0, 0, 0, 0]]

Dies erstellt ein TFRecords-Beispiel:

my_example = tf.train.Example(features=tf.train.Features(feature={
    'index_0': tf.train.Feature(int64_list=tf.train.Int64List(value=[0, 1, 2])),
    'index_1': tf.train.Feature(int64_list=tf.train.Int64List(value=[5, 1, 4])),
    'values': tf.train.Feature(int64_list=tf.train.Int64List(value=[7, 5, 9]))
}))
my_example_str = my_example.SerializeToString()

Und das parsiert es mit SparseFeature:

my_example_features = {'sparse': tf.SparseFeature(index_key=['index_0', 'index_1'],
                                                  value_key='values',
                                                  dtype=tf.int64,
                                                  size=[4, 6])}
serialized = tf.placeholder(tf.string)
parsed = tf.parse_single_example(serialized, features=my_example_features)
session.run(parsed, feed_dict={serialized: my_example_str})

## {'sparse': SparseTensorValue(indices=array([[0, 5], [1, 1], [2, 4]]),
##                              values=array([7, 5, 9]),
##                              dense_shape=array([4, 6]))}

Weitere Exposition: Sparse Tensors und TFRecords


5
2018-04-27 14:19



Für das libsvm-Format können Sie wie folgt schreiben und analysieren, wenn Sie ein spärliches Tensor-Ergebnis wünschen (im Gegensatz zu einem dichten Tensor-Ergebnis mit der Padding-Strategie).

    #---write
    _float_feature = lambda v: tf.train.Feature(float_list=tf.train.FloatList(value=v))
    _int_feature = lambda v: tf.train.Feature(int64_list=tf.train.Int64List(value=v))

    indexes = []
    values = []

    for item in l[start:]:
      index,value = item.split(':')
      indexes.append(int(index))
      values.append(float(value))

    example = tf.train.Example(features=tf.train.Features(feature={
      'label': _int_feature([label]),
      'num_features': _int_feature([num_features]),
      'index': _int_feature(indexes),
      'value': _float_feature(values)
      }))

    writer.write(example.SerializeToString())

    #---read
    def decode(batch_serialized_examples):
        features = tf.parse_example(
            batch_serialized_examples,
            features={
                'label' : tf.FixedLenFeature([], tf.int64),
                'index' : tf.VarLenFeature(tf.int64),
                'value' : tf.VarLenFeature(tf.float32),
            })

        label = features['label']
        index = features['index']
        value = features['value']

        return label, index, value

Auf diese Weise erhalten Sie Label als dichten Tensor, Index und Wert als zwei Sparse-Tensoren, Sie können ein eigenständiges Beispiel des Schreibens des libsvm-Formats in TFRecord sehen und es für die mlp-Klassifikation auslesen

https://github.com/chenghuige/tensorflow-example/tree/master/examples/tf-record/sparse https://github.com/chenghuige/tensorflow-example/tree/master/examples/text-classification


3
2017-08-15 03:08



Wenn Sie sparsame Werte als Eingaben übergeben, müssen Sie sparse Platzhalter mit verwenden tf.sparse_placeholder.

Sie sollten dann Ihre sparsen Tensoren zu dichten Tensor konvertieren tf.sparse_to_dense.

Dazu müssen Sie die Werte, die Form und die Indizes der Sparse-Matrix explizit übergeben, während Sie die Daten in feed_dict einspeisen und später verwenden tf.sparse_to_dense in der Grafik.

In der Grafik:

dense = tf.sparse_to_dense(
    sparse_indices=sparse_placeholder.indices,
    output_shape=sparse_placeholder.shape,
    sparse_values=sparse_placeholder.values,
validate_indices=False)

Im feed_dict:

sparse_placeholder:tf.SparseTensorValue(indices=indices,values=sparse_values,dense_shape=sparse_shape)

0
2018-03-17 10:13