tensorflow
Läsa data

Räkna exempel i CSV-fil

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 gör att string_input_producer kö för att stängas efter bearbetning av varje fil i listan en gång. Det leder till att höja OutOfRangeError som fångas i try: OutOfRangeError Som standard producerar string_input_producer filnamnen oändligt.

tf.initialize_local_variables() är en tensorflow Op, som, när den körs, initialiserar num_epoch lokal variabel inuti string_input_producer .

tf.train.start_queue_runners() startar extra trampor som hanterar att lägga till data i köerna asynkront.

Läs & analysera TFRecord-fil

TFRecord-filer är det ursprungliga tensorflow-binära formatet för lagring av data (tensors). För att läsa filen kan du använda en kod som liknar CSV-exemplet:

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)

Sedan måste du analysera exemplen från serialized_example Queue. Du kan göra det antingen med tf.parse_example , vilket kräver tidigare batchning, men är snabbare eller 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 förenar på varandra följande värden för givna tensorer av form [x, y, z] till tensorer med form [batch_size, x, y, z] . features dikterar namnen på funktionerna till tensorflows definitioner av funktioner . Du använder parse_single_example på liknande sätt:

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 och tf.parse_single_example returnerar en tf.parse_single_example till tensorn med värdena.

För att parse_single_example kommer från parse_single_example bör du extrahera tensorerna från diket och använda tf.train.batch som tidigare:

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

Du läser uppgifterna som tidigare och skickar listan över alla tensorer som ska utvärderas till 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

Slumpmässig blandning av exemplen

För att slumpa bland exemplen kan du använda funktionen tf.train.shuffle_batch istället för tf.train.batch , enligt följande:

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

tf.train.shuffle_batch (liksom tf.train.batch ) skapar en tf.Queue och fortsätter att lägga till serialized_examples till den.

capacity mäter hur många element som kan lagras i kön på en gång. Större kapacitet leder till större minnesanvändning, men lägre latens orsakad av trådar som väntar på att fylla den.

min_after_dequeue är det minsta antalet element som finns i kön efter att ha fått element från det. shuffle_batch kön blandar inte elementen perfekt jämnt - den är utformad med enorma data, som inte passar ett minne, i åtanke. I stället läser den mellan min_after_dequeue och capacity , lagrar dem i minnet och väljer slumpmässigt ett parti av dem. Efter det berättar det några fler element för att behålla antalet mellan min_after_dequeue och capacity . Således är det större värdet på min_after_dequeue , desto mer slumpmässiga element är - valet av batch_size kommer garanterat att tas från åtminstone min_after_dequeue varandra följande element, men den större capacity måste vara och min_after_dequeue längre tid tar det att fylla köen initialt.

Läser data för n-epoker med batchning

Anta att dina dataexempel redan har lästs för en pythons variabel och du vill läsa den n gånger, i partier av given storlek:

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

För att slå samman data i batchar, eventuellt med slumpmässig blandning, kan du använda tf.train.batch eller tf.train.batch_shuffle , men du måste skicka till den tensorn som skulle producera hela data n gånger:

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

The limit_epochs konverterar numpy-arrayen till tensor under huven och returnerar en tensor som producerar den n gånger och kastar en OutOfRangeError efteråt. enqueue_many=True argument som skickas till shuffle_batch anger att varje tensor i [limited_tensor] ska tolkas som att den innehåller ett antal exempel. Observera att kapaciteten för batchkön kan vara mindre än antalet exempel i tensorn.

Man kan behandla data som vanligt:

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

Hur man laddar bilder och etiketter från en TXT-fil

Det har inte förklarats i Tensorflow-dokumentationen hur man laddar bilder och etiketter direkt från en TXT-fil. Koden nedan illustrerar hur jag har uppnått det. Men det betyder inte att det är det bästa sättet att göra det och att detta sätt kommer att hjälpa i ytterligare steg.

Till exempel laddar jag etiketterna i ett enda heltal {0,1} medan dokumentationen använder en en varm vektor [0,1].

# 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)