tensorflow
Lesen der Daten

Zählen Sie Beispiele in einer CSV-Datei

import tensorflow as tf
filename_queue = tf.train.string_input_producer(["file.csv"], num_epochs=1)
reader = tf.TextLineReader()
key, value = reader.read(filename_queue)
col1, col2 = tf.decode_csv(value, record_defaults=[[0], [0]])

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  num_examples = 0
  try:
    while True:
      c1, c2 = sess.run([col1, col2])
      num_examples += 1
  except tf.errors.OutOfRangeError:
    print "There are", num_examples, "examples"

num_epochs=1 string_input_producer dass die string_input_producer Warteschlange geschlossen wird, nachdem jede Datei in der Liste einmal verarbeitet wurde. OutOfRangeError führt dazu, dass OutOfRangeError wird, das in try: abgefangen wird try: Standardmäßig erzeugt string_input_producer die Dateinamen unendlich.

tf.initialize_local_variables() ist ein tensorflow Op, die, wenn sie ausgeführt wird , initialisiert num_epoch lokale Variable innerhalb string_input_producer .

tf.train.start_queue_runners() startet zusätzliche Laufflächen, die das asynchrone Hinzufügen von Daten zu den Warteschlangen ausführen.

TFRecord-Datei lesen und analysieren

TFRecord-Dateien sind das native Tensorflow-Binärformat zum Speichern von Daten (Tensoren). Um die Datei zu lesen, können Sie einen dem CSV-Beispiel ähnlichen Code verwenden:

import tensorflow as tf
filename_queue = tf.train.string_input_producer(["file.tfrecord"], num_epochs=1)
reader = tf.TFRecordReader()
key, serialized_example = reader.read(filename_queue)

Anschließend müssen Sie die Beispiele aus serialized_example Warteschlange serialized_example analysieren. Sie können dies entweder mit tf.parse_example , was vorheriges tf.parse_example erfordert, aber schneller ist, oder tf.parse_single_example :

batch = tf.train.batch([serialized_example], batch_size=100)
parsed_batch = tf.parse_example(batch, features={
  "feature_name_1": tf.FixedLenFeature(shape=[1], tf.int64),
  "feature_name_2": tf.FixedLenFeature(shape=[1], tf.float32)
})

tf.train.batch verbindet aufeinanderfolgende Werte gegebener Tensoren der Form [x, y, z] mit Tensoren der Form [batch_size, x, y, z] . features dict ordnet den Funktionsdefinitionen den Tensorflow- Funktionsnamen zu . Sie verwenden parse_single_example auf ähnliche Weise:

parsed_example = tf.parse_single_example(serialized_example, {
  "feature_name_1": tf.FixedLenFeature(shape=[1], tf.int64),
  "feature_name_2": tf.FixedLenFeature(shape=[1], tf.float32)
})

tf.parse_example und tf.parse_single_example geben ein Dictionary-Zuordnungsfeaturnamen mit den Werten zum Tensor zurück.

Um Batch-Beispiele aus parse_single_example , sollten Sie die Tensoren aus dem parse_single_example extrahieren und tf.train.batch wie zuvor verwenden:

parsed_batch = dict(zip(parsed_example.keys(),
    tf.train.batch(parsed_example.values(), batch_size=100)

Sie lesen die Daten wie zuvor und übergeben die Liste aller zu bewertenden Tensoren an sess.run :

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  try:
    while True:
      data_batch = sess.run(parsed_batch.values())
      # process data
  except tf.errors.OutOfRangeError:
    pass

Zufälliges Mischen der Beispiele

Um die Beispiele zufällig zu mischen, können tf.train.shuffle_batch Funktion tf.train.shuffle_batch anstelle von tf.train.batch wie folgt verwenden:

parsed_batch = tf.train.shuffle_batch([serialized_example],
    batch_size=100, capacity=1000,
    min_after_dequeue=200)

tf.train.shuffle_batch (sowie tf.train.batch ) erstellt eine tf.Queue und fügt tf.Queue serialized_examples hinzu.

capacity misst, wie viele Elemente gleichzeitig in der Warteschlange gespeichert werden können. Größere Kapazität führt zu einer größeren Arbeitsspeicherauslastung, jedoch zu einer geringeren Latenzzeit, die von Threads verursacht wird, die darauf warten, sie aufzufüllen.

min_after_dequeue ist die minimale Anzahl von Elementen, die in der Warteschlange vorhanden sind, nachdem Elemente aus der Warteschlange min_after_dequeue . Die Warteschlange shuffle_batch Elemente nicht perfekt einheitlich - sie ist für große Daten ausgelegt, nicht für einen passenden Speicher. Stattdessen liest es zwischen min_after_dequeue und capacity Elementen, speichert sie im Speicher und wählt zufällig einen Stapel davon aus. Danach reiht es einige weitere Elemente ein, um die Anzahl zwischen min_after_dequeue und capacity zu halten. min_after_dequeue größer der Wert von min_after_dequeue , desto mehr zufällige Elemente sind - die Auswahl der batch_size Elemente wird garantiert aus mindestens aufeinanderfolgenden min_after_dequeue Elementen ausgewählt, aber die größere capacity muss sein und min_after_dequeue länger dauert das Füllen der Warteschlange anfangs.

Daten für n Epochen mit Batching lesen

Angenommen, Ihre Datenbeispiele sind bereits in einer Pythons-Variablen gelesen, und Sie möchten sie n-mal in Stapel mit gegebener Größe lesen:

import numpy as np
import tensorflow as tf
data = np.array([1, 2, 3, 4, 5])
n = 4

Um Daten in Batches zusammenzuführen, möglicherweise mit zufälligem Mischen, können Sie tf.train.batch oder tf.train.batch_shuffle . Sie müssen jedoch den Tensor übergeben, der n-mal ganze Daten ergibt:

limited_tensor = tf.train.limit_epochs(data, n)
batch = tf.train.shuffle_batch([limited_tensor], batch_size=3, enqueue_many=True, capacity=4)

Das limit_epochs konvertiert das numpy-Array in einen Tensor unter der Haube und gibt einen Tensor zurück, der es n-mal produziert und anschließend einen OutOfRangeError wirft. Die enqueue_many=True Argument übergeben shuffle_batch bedeutet , dass jeder Tensor in der Tensor Liste [limited_tensor] sollte so enthält eine Reihe von Beispielen interpretiert werden. Beachten Sie, dass die Kapazität der Stapelwarteschlange kleiner sein kann als die Anzahl der Beispiele im Tensor.

Man kann die Daten wie gewohnt verarbeiten:

with tf.Session() as sess:
  sess.run(tf.initialize_local_variables())
  tf.train.start_queue_runners()
  try:
    while True:
      data_batch = sess.run(batch)
      # process data
  except tf.errors.OutOfRangeError:
    pass

So laden Sie Bilder und Etiketten aus einer TXT-Datei

In der Tensorflow-Dokumentation wurde nicht erklärt, wie Bilder und Etiketten direkt aus einer TXT-Datei geladen werden. Der folgende Code zeigt, wie ich es erreicht habe. Dies bedeutet jedoch nicht, dass dies der beste Weg ist und dass dieser Weg in weiteren Schritten helfen wird.

Zum Beispiel lade ich die Beschriftungen in einem einzigen ganzzahligen Wert {0,1}, während die Dokumentation einen One-Hot-Vektor [0,1] verwendet.

# Learning how to import images and labels from a TXT file
#
# TXT file format
#
# path/to/imagefile_1 label_1
# path/to/imagefile_2 label_2
# ...                 ...
#
# where label_X is either {0,1}

#Importing Libraries
import os
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.python.framework import ops
from tensorflow.python.framework import dtypes

#File containing the path to images and the labels [path/to/images label]
filename = '/path/to/List.txt'

#Lists where to store the paths and labels
filenames = []
labels = []

#Reading file and extracting paths and labels
with open(filename, 'r') as File:
    infoFile = File.readlines() #Reading all the lines from File
    for line in infoFile: #Reading line-by-line
        words = line.split() #Splitting lines in words using space character as separator
        filenames.append(words[0])
        labels.append(int(words[1]))

NumFiles = len(filenames)

#Converting filenames and labels into tensors
tfilenames = ops.convert_to_tensor(filenames, dtype=dtypes.string)
tlabels = ops.convert_to_tensor(labels, dtype=dtypes.int32)

#Creating a queue which contains the list of files to read and the value of the labels
filename_queue = tf.train.slice_input_producer([tfilenames, tlabels], num_epochs=10, shuffle=True, capacity=NumFiles)

#Reading the image files and decoding them
rawIm= tf.read_file(filename_queue[0])
decodedIm = tf.image.decode_png(rawIm) # png or jpg decoder

#Extracting the labels queue
label_queue = filename_queue[1]

#Initializing Global and Local Variables so we avoid warnings and errors
init_op = tf.group(tf.local_variables_initializer() ,tf.global_variables_initializer())

#Creating an InteractiveSession so we can run in iPython
sess = tf.InteractiveSession()

with sess.as_default():
    sess.run(init_op)
    
    # Start populating the filename queue.
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(coord=coord)

    for i in range(NumFiles): #length of your filenames list
        nm, image, lb = sess.run([filename_queue[0], decodedIm, label_queue])
        
        print image.shape
        print nm
        print lb
        
        #Showing the current image
        plt.imshow(image)
        plt.show()

    coord.request_stop()
    coord.join(threads)