Wie kann man CSV-Daten in TensorFlow * tatsächlich * lesen?

Ich bin relativ neu in der Welt von TensorFlow und ziemlich ratlos darüber, wie Sie CSV-Daten tatsächlich in TensorFlow in verwendbare Beispiel- / Etikettentensoren einlesen würden. Das Beispiel aus dem TensorFlow-Tutorial zum Lesen von CSV-Daten ist ziemlich fragmentiert und gibt Ihnen nur einen Teil des Weges zum Trainieren von CSV-Daten.

Hier ist mein Code, den ich basierend auf diesem CSV-Tutorial zusammengestellt habe:

from __future__ import print_function
import tensorflow as tf

def file_len(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1

filename = "csv_test_data.csv"

# setup text reader
file_length = file_len(filename)
filename_queue = tf.train.string_input_producer([filename])
reader = tf.TextLineReader(skip_header_lines=1)
_, csv_row = reader.read(filename_queue)

# setup CSV decoding
record_defaults = [[0],[0],[0],[0],[0]]
col1,col2,col3,col4,col5 = tf.decode_csv(csv_row, record_defaults=record_defaults)

# turn features back into a tensor
features = tf.stack([col1,col2,col3,col4])

print("loading, " + str(file_length) + " line(s)\n")
with tf.Session() as sess:
  tf.initialize_all_variables().run()

  # start populating filename queue
  coord = tf.train.Coordinator()
  threads = tf.train.start_queue_runners(coord=coord)

  for i in range(file_length):
    # retrieve a single instance
    example, label = sess.run([features, col5])
    print(example, label)

  coord.request_stop()
  coord.join(threads)
  print("\ndone loading")

Und hier ist ein kurzes Beispiel aus der CSV-Datei, die ich lade - ziemlich grundlegende Daten - 4 Feature-Spalten und 1 Beschriftungsspalte:

0,0,0,0,0
0,15,0,0,0
0,30,0,0,0
0,45,0,0,0

Der obige Code druckt lediglich jedes Beispiel einzeln aus der CSV-Datei , was zwar nett, aber für das Training verdammt nutzlos ist.

Ich habe hier Probleme damit, wie Sie diese einzelnen Beispiele, die einzeln geladen werden, tatsächlich in einen Trainingsdatensatz umwandeln. Hier ist zum Beispiel ein Notizbuch, an dem ich im Udacity Deep Learning-Kurs gearbeitet habe. Grundsätzlich möchte ich die CSV-Daten, die ich lade, in etwas wie train_dataset und train_labels kopieren :

def reformat(dataset, labels):
  dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)
  # Map 2 to [0.0, 1.0, 0.0 ...], 3 to [0.0, 0.0, 1.0 ...]
  labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)
  return dataset, labels
train_dataset, train_labels = reformat(train_dataset, train_labels)
valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)
test_dataset, test_labels = reformat(test_dataset, test_labels)
print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels.shape)
print('Test set', test_dataset.shape, test_labels.shape)

Ich habe versucht tf.train.shuffle_batch, so etwas zu verwenden, aber es hängt unerklärlicherweise:

  for i in range(file_length):
    # retrieve a single instance
    example, label = sess.run([features, colRelevant])
    example_batch, label_batch = tf.train.shuffle_batch([example, label], batch_size=file_length, capacity=file_length, min_after_dequeue=10000)
    print(example, label)

Zusammenfassend sind hier meine Fragen:

• Was fehlt mir an diesem Prozess?
  • Es scheint, als ob mir eine wichtige Intuition fehlt, wie man eine Eingabepipeline richtig erstellt.
• Gibt es eine Möglichkeit, die Länge der CSV-Datei nicht zu kennen?
  • Es fühlt sich ziemlich unelegant an, die Anzahl der zu verarbeitenden Zeilen kennen zu müssen (die for i in range(file_length)Codezeile oben).

Bearbeiten: Sobald Jaroslaw darauf hinwies, dass ich hier wahrscheinlich imperative und grafische Konstruktionsteile verwechseln würde, wurde es klarer. Ich konnte den folgenden Code zusammenstellen, der meiner Meinung nach näher an dem liegt, was normalerweise beim Trainieren eines Modells aus CSV (ohne Modell-Trainingscode) gemacht wird:

from __future__ import print_function
import numpy as np
import tensorflow as tf
import math as math
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('dataset')
args = parser.parse_args()

def file_len(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1

def read_from_csv(filename_queue):
  reader = tf.TextLineReader(skip_header_lines=1)
  _, csv_row = reader.read(filename_queue)
  record_defaults = [[0],[0],[0],[0],[0]]
  colHour,colQuarter,colAction,colUser,colLabel = tf.decode_csv(csv_row, record_defaults=record_defaults)
  features = tf.stack([colHour,colQuarter,colAction,colUser])  
  label = tf.stack([colLabel])  
  return features, label

def input_pipeline(batch_size, num_epochs=None):
  filename_queue = tf.train.string_input_producer([args.dataset], num_epochs=num_epochs, shuffle=True)  
  example, label = read_from_csv(filename_queue)
  min_after_dequeue = 10000
  capacity = min_after_dequeue + 3 * batch_size
  example_batch, label_batch = tf.train.shuffle_batch(
      [example, label], batch_size=batch_size, capacity=capacity,
      min_after_dequeue=min_after_dequeue)
  return example_batch, label_batch

file_length = file_len(args.dataset) - 1
examples, labels = input_pipeline(file_length, 1)

with tf.Session() as sess:
  tf.initialize_all_variables().run()

  # start populating filename queue
  coord = tf.train.Coordinator()
  threads = tf.train.start_queue_runners(coord=coord)

  try:
    while not coord.should_stop():
      example_batch, label_batch = sess.run([examples, labels])
      print(example_batch)
  except tf.errors.OutOfRangeError:
    print('Done training, epoch reached')
  finally:
    coord.request_stop()

  coord.join(threads) 

Ich denke, Sie verwechseln hier imperative und grafische Konstruktionsteile. Die Operation tf.train.shuffle_batcherstellt einen neuen Warteschlangenknoten, und ein einzelner Knoten kann zum Verarbeiten des gesamten Datensatzes verwendet werden. Ich denke, Sie hängen, weil Sie eine Reihe von shuffle_batchWarteschlangen in Ihrer for-Schleife erstellt und keine Warteschlangenläufer für sie gestartet haben.

Die normale Verwendung der Eingabepipeline sieht folgendermaßen aus:

1. Fügen Sie Knoten hinzu shuffle_batch, die eine Pipeline eingeben möchten
2. (Optional, um unbeabsichtigte Änderungen am Diagramm zu verhindern) Schließen Sie das Diagramm ab

--- Ende der Graphkonstruktion, Beginn der imperativen Programmierung -

3. tf.start_queue_runners
4. while(True): session.run()

Um skalierbarer zu sein (um Python GIL zu vermeiden), können Sie alle Ihre Daten mithilfe der TensorFlow-Pipeline generieren. Wenn die Leistung jedoch nicht kritisch ist, können Sie ein Numpy-Array an eine Eingabepipeline anschließen. Verwenden Sie slice_input_producer.hier ein Beispiel mit einigen PrintKnoten, um zu sehen, was los ist (Nachrichten in Printgehen an stdout, wenn der Knoten ausgeführt wird).

tf.reset_default_graph()

num_examples = 5
num_features = 2
data = np.reshape(np.arange(num_examples*num_features), (num_examples, num_features))
print data

(data_node,) = tf.slice_input_producer([tf.constant(data)], num_epochs=1, shuffle=False)
data_node_debug = tf.Print(data_node, [data_node], "Dequeueing from data_node ")
data_batch = tf.batch([data_node_debug], batch_size=2)
data_batch_debug = tf.Print(data_batch, [data_batch], "Dequeueing from data_batch ")

sess = tf.InteractiveSession()
sess.run(tf.initialize_all_variables())
tf.get_default_graph().finalize()
tf.start_queue_runners()

try:
  while True:
    print sess.run(data_batch_debug)
except tf.errors.OutOfRangeError as e:
  print "No more inputs."

Sie sollten so etwas sehen

[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
[[0 1]
 [2 3]]
[[4 5]
 [6 7]]
No more inputs.

Die "8, 9" -Nummern füllten nicht die gesamte Charge aus, sodass sie nicht produziert wurden. Sie tf.Printwerden auch in sys.stdout gedruckt, sodass sie für mich separat im Terminal angezeigt werden.

PS: Eine minimale Anzahl von Verbindungen batchzu einer manuell initialisierten Warteschlange befindet sich in Github-Ausgabe 2193

Zu Debugging-Zwecken möchten Sie möglicherweise timeouteine Sitzung festlegen, damit Ihr IPython-Notizbuch nicht an leeren Warteschlangenwarteschlangen hängt. Ich benutze diese Hilfsfunktion für meine Sitzungen

def create_session():
  config = tf.ConfigProto(log_device_placement=True)
  config.gpu_options.per_process_gpu_memory_fraction=0.3 # don't hog all vRAM
  config.operation_timeout_in_ms=60000   # terminate on long hangs
  # create interactive session to register a default session
  sess = tf.InteractiveSession("", config=config)
  return sess

Hinweise zur Skalierbarkeit:

1. tf.constantInline-Kopie Ihrer Daten in das Diagramm. Es gibt eine grundlegende Grenze von 2 GB für die Größe der Diagrammdefinition, sodass dies eine Obergrenze für die Datengröße ist
2. Sie können diese Grenze umgehen, indem Sie v=tf.Variabledie Daten verwenden und dort speichern, indem Sie v.assign_opmit einem tf.placeholderauf der rechten Seite ausführen und dem Platzhalter ein numpy-Array zuweisen ( feed_dict).
3. Dadurch werden immer noch zwei Kopien von Daten erstellt. Um Speicherplatz zu sparen, können Sie eine eigene Version slice_input_producererstellen, die auf Numpy-Arrays ausgeführt wird, und Zeilen einzeln mit hochladenfeed_dict

Oder Sie könnten dies versuchen, der Code lädt den Iris-Datensatz mithilfe von Pandas und Numpy in den Tensorflow und eine einfache Ausgabe mit einem Neuron wird in der Sitzung gedruckt. Hoffe, es hilft für ein grundlegendes Verständnis .... [Ich habe nicht den Weg eines heißen Dekodierungsetiketts hinzugefügt].

import tensorflow as tf 
import numpy
import pandas as pd
df=pd.read_csv('/home/nagarjun/Desktop/Iris.csv',usecols = [0,1,2,3,4],skiprows = [0],header=None)
d = df.values
l = pd.read_csv('/home/nagarjun/Desktop/Iris.csv',usecols = [5] ,header=None)
labels = l.values
data = numpy.float32(d)
labels = numpy.array(l,'str')
#print data, labels

#tensorflow
x = tf.placeholder(tf.float32,shape=(150,5))
x = data
w = tf.random_normal([100,150],mean=0.0, stddev=1.0, dtype=tf.float32)
y = tf.nn.softmax(tf.matmul(w,x))

with tf.Session() as sess:
    print sess.run(y)

Sie können die neueste tf.data-API verwenden:

dataset = tf.contrib.data.make_csv_dataset(filepath)
iterator = dataset.make_initializable_iterator()
columns = iterator.get_next()
with tf.Session() as sess:
   sess.run([iteator.initializer])

Wenn jemand hierher gekommen ist, um nach einer einfachen Möglichkeit zu suchen, absolut große und gesplittete CSV-Dateien in der tf.estimator-API zu lesen, siehe unten meinen Code

CSV_COLUMNS = ['ID','text','class']
LABEL_COLUMN = 'class'
DEFAULTS = [['x'],['no'],[0]]  #Default values

def read_dataset(filename, mode, batch_size = 512):
    def _input_fn(v_test=False):
#         def decode_csv(value_column):
#             columns = tf.decode_csv(value_column, record_defaults = DEFAULTS)
#             features = dict(zip(CSV_COLUMNS, columns))
#             label = features.pop(LABEL_COLUMN)
#             return add_engineered(features), label

        # Create list of files that match pattern
        file_list = tf.gfile.Glob(filename)

        # Create dataset from file list
        #dataset = tf.data.TextLineDataset(file_list).map(decode_csv)
        dataset = tf.contrib.data.make_csv_dataset(file_list,
                                                   batch_size=batch_size,
                                                   column_names=CSV_COLUMNS,
                                                   column_defaults=DEFAULTS,
                                                   label_name=LABEL_COLUMN)

        if mode == tf.estimator.ModeKeys.TRAIN:
            num_epochs = None # indefinitely
            dataset = dataset.shuffle(buffer_size = 10 * batch_size)
        else:
            num_epochs = 1 # end-of-input after this

        batch_features, batch_labels = dataset.make_one_shot_iterator().get_next()

        #Begins - Uncomment for testing only -----------------------------------------------------<
        if v_test == True:
            with tf.Session() as sess:
                print(sess.run(batch_features))
        #End - Uncomment for testing only -----------------------------------------------------<
        return add_engineered(batch_features), batch_labels
    return _input_fn

Beispiel für die Verwendung in TF.estimator:

train_spec = tf.estimator.TrainSpec(input_fn = read_dataset(
                                                filename = train_file,
                                                mode = tf.estimator.ModeKeys.TRAIN,
                                                batch_size = 128), 
                                      max_steps = num_train_steps)

2.0-kompatible Lösung : Diese Antwort wird möglicherweise von anderen im obigen Thread bereitgestellt, aber ich werde zusätzliche Links bereitstellen, die der Community helfen.

dataset = tf.data.experimental.make_csv_dataset(
      file_path,
      batch_size=5, # Artificially small to make examples easier to show.
      label_name=LABEL_COLUMN,
      na_value="?",
      num_epochs=1,
      ignore_errors=True, 
      **kwargs)

Weitere Informationen finden Sie in diesem Tensorflow-Tutorial .