tensorflow
Odczytywanie danych

Policz przykłady w pliku CSV

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 powoduje, że kolejka string_input_producer zamyka się po przetworzeniu każdego pliku na liście jeden raz. Prowadzi to do podniesienia OutOfRangeError który jest przechwytywany podczas try: OutOfRangeError Domyślnie string_input_producer tworzy nazwy plików w nieskończoność.

tf.initialize_local_variables() jest operatorem przepływu tensorflow, który po num_epoch inicjuje num_epoch lokalną string_input_producer wewnątrz parametru string_input_producer .

tf.train.start_queue_runners() uruchamia dodatkowe stopnie, które obsługują asynchroniczne dodawanie danych do kolejek.

Przeczytaj i przeanalizuj plik TFRecord

Pliki TFRecord to natywny format binarny tensorflow do przechowywania danych (tensorów). Aby odczytać plik, możesz użyć kodu podobnego do przykładu CSV:

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)

Następnie musisz przeanalizować przykłady z kolejki serialized_example . Możesz to zrobić albo za pomocą tf.parse_example , który wymaga wcześniejszego tf.parse_example , ale jest szybszy lub 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 łączy kolejne wartości zadanych tensorów kształtu [x, y, z] z tensorami kształtu [batch_size, x, y, z] . features dict mapuje nazwy funkcji do definicji tensorflow z dnia cech . Używasz parse_single_example w podobny sposób:

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 i tf.parse_single_example zwracają nazwy funkcji mapowania słownika do tensora z wartościami.

Aby parse_single_example przykłady pochodzące z parse_single_example , należy wyodrębnić tensory ze tf.train.batch i użyć tf.train.batch jak poprzednio:

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

Czytasz dane jak poprzednio, przekazując listę wszystkich tensorów do oceny do 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

Losowe tasowanie przykładów

Aby losowo tf.train.shuffle_batch przykłady, możesz użyć funkcji tf.train.shuffle_batch zamiast tf.train.batch w następujący sposób:

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

tf.train.shuffle_batch (jak również tf.train.batch ) tworzy tf.Queue i dodaje do niego tf.Queue serialized_examples .

capacity mierzy, ile elementów można zapisać w kolejce jednocześnie. Większa pojemność prowadzi do większego zużycia pamięci, ale mniejsze opóźnienia spowodowane przez wątki oczekujące na jej wypełnienie.

min_after_dequeue to minimalna liczba elementów obecnych w kolejce po min_after_dequeue z niej elementów. Kolejka shuffle_batch nie shuffle_batch elementów idealnie równomiernie - została zaprojektowana z myślą o dużych danych, shuffle_batch do pamięci. Zamiast tego odczytuje elementy min_after_dequeue i capacity , zapisuje je w pamięci i losowo wybiera ich partię. Następnie kolejkuje kolejne elementy, aby zachować liczbę między min_after_dequeue i capacity . Tak więc, im większa wartość min_after_dequeue , tym więcej losowych elementów - wybór elementów batch_size jest gwarantowany z co najmniej min_after_dequeue kolejnych elementów, ale większa musi być capacity i im dłużej zajmuje początkowe wypełnienie kolejki.

Odczytywanie danych dla n epok z grupowaniem

Załóżmy, że twoje przykłady danych są już odczytane do zmiennej pytona i chcesz ją odczytać n razy, w partiach o danym rozmiarze:

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

Aby scalić dane w partiach, prawdopodobnie z losowym tasowaniem, możesz użyć tf.train.batch lub tf.train.batch_shuffle , ale musisz przekazać tensor, który wygenerowałby całe dane n razy:

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

limit_epochs konwertuje tablicę numpy na tensor pod maską i zwraca tensor wytwarzający go n razy, a następnie wyrzucający OutOfRangeError. Argument enqueue_many=True przekazany do shuffle_batch oznacza, że każdy tensor na liście tensorów [limited_tensor] powinien być interpretowany jako zawierający wiele przykładów. Należy zauważyć, że pojemność kolejki dozowania może być mniejsza niż liczba przykładów w tensorze.

Dane można przetwarzać jak zwykle:

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

Jak ładować obrazy i etykiety z pliku TXT

W dokumentacji Tensorflow nie wyjaśniono, jak ładować obrazy i etykiety bezpośrednio z pliku TXT. Poniższy kod ilustruje, jak to osiągnąłem. Nie oznacza to jednak, że jest to najlepszy sposób i że ten sposób pomoże w dalszych krokach.

Na przykład ładuję etykiety do jednej wartości całkowitej {0,1}, podczas gdy dokumentacja wykorzystuje wektor z jednym gorącym [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)