tensorflow
Gegevens lezen

Tel voorbeelden in CSV-bestand

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 zorgt ervoor dat string_input_producer wachtrij wordt geplaatst na verwerking van elk bestand op de lijst eenmaal. Het leidt tot het verhogen van OutOfRangeError die wordt gevangen in try: Standaard produceert string_input_producer de bestandsnamen oneindig.

tf.initialize_local_variables() is een tensorflow Op die, wanneer uitgevoerd, initialiseert num_epoch lokale variabele binnen string_input_producer .

tf.train.start_queue_runners() start extra tf.train.start_queue_runners() die het asynchroon toevoegen van gegevens aan de wachtrijen afhandelen.

TFRecord-bestand lezen en ontleden

TFRecord-bestanden is het native binaire tensorflow-formaat voor het opslaan van gegevens (tensoren). Om het bestand te lezen, kunt u een code gebruiken die lijkt op het CSV-voorbeeld:

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)

Vervolgens moet u de voorbeelden ontleden uit serialized_example Queue. U kunt dit doen met behulp van tf.parse_example , waarvoor eerdere batching nodig is, maar sneller is of 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 voegt opeenvolgende waarden van gegeven tensoren van vorm [x, y, z] met tensoren van vorm [batch_size, x, y, z] . features dict wijst namen van de features toe aan tensorflow's definities van features . U gebruikt parse_single_example op een vergelijkbare manier:

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 en tf.parse_single_example retourneren een functie voor het toewijzen van woordenboekwoorden aan de tensor met de waarden.

Om parse_single_example uit parse_single_example , moet u de tensoren uit het dict halen en tf.train.batch zoals eerder:

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

Je leest de gegevens als eerder en geeft de lijst van alle te evalueren tensoren door aan 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

Willekeurig schudden van de voorbeelden

Om de voorbeelden willekeurig te schudden, kunt u de functie tf.train.shuffle_batch gebruiken in plaats van tf.train.batch , als volgt:

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

tf.train.shuffle_batch (evenals tf.train.batch ) maakt een tf.Queue en voegt er steeds serialized_examples aan toe.

capacity meet hoeveel elementen in één keer in wachtrij kunnen worden opgeslagen. Grotere capaciteit leidt tot groter geheugengebruik, maar lagere latentie veroorzaakt door threads die wachten om het vol te maken.

min_after_dequeue is het minimum aantal elementen dat in de wachtrij aanwezig is nadat elementen min_after_dequeue zijn min_after_dequeue . De wachtrij shuffle_batch elementen niet perfect uniform - het is ontworpen met enorme gegevens, niet geschikt voor geheugen, in het achterhoofd. In plaats daarvan leest het tussen min_after_dequeue en capacity , slaat u ze op in het geheugen en kiest u er willekeurig een batch van. Daarna vraagt het om wat meer elementen, om zijn aantal tussen min_after_dequeue en capacity . Dus, hoe groter de waarde van min_after_dequeue , des te meer willekeurige elementen zijn - de keuze van batch_size elementen wordt gegarandeerd genomen uit ten minste min_after_dequeue opeenvolgende elementen, maar de grotere capacity moet zijn en hoe langer het duurt om de wachtrij aanvankelijk te vullen.

Gegevens lezen voor n tijdvakken met batching

Stel dat uw gegevensvoorbeelden al zijn gelezen in de variabele van een python en u wilt deze n keer lezen, in batches van een gegeven grootte:

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

Om gegevens in batches samen te voegen, mogelijk met willekeurige shuffling, kunt u tf.train.batch of tf.train.batch_shuffle , maar u moet de tensor doorgeven die n keer volledige gegevens zou produceren:

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

De limit_epochs converteert de numpy array naar tensor onder de kap en retourneert een tensor die het n keer produceert en daarna een OutOfRangeError gooit. Het argument enqueue_many=True doorgegeven aan shuffle_batch geeft aan dat elke tensor in de shuffle_batch [limited_tensor] moet worden geïnterpreteerd als een aantal voorbeelden. Merk op dat de capaciteit van de batchwachtrij kleiner kan zijn dan het aantal voorbeelden in de tensor.

Men kan de gegevens zoals gewoonlijk verwerken:

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

Afbeeldingen en labels laden vanuit een TXT-bestand

In de Tensorflow-documentatie is niet uitgelegd hoe afbeeldingen en labels rechtstreeks vanuit een TXT-bestand kunnen worden geladen. De onderstaande code illustreert hoe ik het heb bereikt. Dit betekent echter niet dat dit de beste manier is om dit te doen en dat het op deze manier helpt bij verdere stappen.

Ik laad bijvoorbeeld de labels in één geheel getal {0,1} terwijl de documentatie een één-hete vector [0,1] gebruikt.

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