Pipeline di dati a velocità TPU: tf.data.Dataset e TFRecords

1. Panoramica

Le TPU sono molto veloci. Il flusso di dati di addestramento deve tenere il passo con la velocità di addestramento. In questo lab, imparerai a caricare i dati da GCS con l'API tf.data.Dataset per alimentare la TPU.

Questo lab è la prima parte della serie "Keras on TPU". Puoi eseguirle nel seguente ordine o in modo indipendente.

• [QUESTO LAB] Pipeline di dati a velocità TPU: tf.data.Dataset e TFRecords
• Il tuo primo modello Keras, con il transfer learning
• Reti neurali convoluzionali con Keras e TPU
• ConvNet moderne, SqueezeNet, Xception, con Keras e TPU

Obiettivi didattici

• Per utilizzare l'API tf.data.Dataset per caricare i dati di addestramento
• Per utilizzare il formato TFRecord per caricare in modo efficiente i dati di addestramento da GCS

Feedback

Se noti qualcosa di strano in questo codelab, comunicacelo. Il feedback può essere fornito tramite i problemi di GitHub [link al feedback].

2. Guida rapida di Google Colaboratory

Questo lab utilizza Google Collaboratory e non richiede alcuna configurazione da parte tua. Colaboratory è una piattaforma di notebook online per scopi didattici. Offre addestramento senza costi per CPU, GPU e TPU.

Puoi aprire questo notebook di esempio ed eseguire alcune celle per acquisire familiarità con Colaboratory.

Welcome to Colab.ipynb

Seleziona un backend TPU

Nel menu di Colab, seleziona Runtime > Cambia tipo di runtime e poi TPU. In questo codelab utilizzerai una potente TPU (Tensor Processing Unit) supportata per l'addestramento con accelerazione hardware. La connessione al runtime avverrà automaticamente alla prima esecuzione oppure puoi utilizzare il pulsante "Connetti" nell'angolo in alto a destra.

Esecuzione del notebook

Esegui le celle una alla volta facendo clic su una cella e utilizzando Maiusc+Invio. Puoi anche eseguire l'intero notebook con Runtime > Esegui tutto.

Sommario

Tutti i notebook hanno un indice. Puoi aprirlo utilizzando la freccia nera a sinistra.

Celle nascoste

Alcune celle mostreranno solo il titolo. Questa è una funzionalità specifica dei notebook di Colab. Puoi fare doppio clic per visualizzare il codice all'interno, ma di solito non è molto interessante. In genere, funzioni di supporto o visualizzazione. Devi comunque eseguire queste celle per definire le funzioni al loro interno.

Autenticazione

Colab può accedere ai tuoi bucket Google Cloud Storage privati se esegui l'autenticazione con un account autorizzato. Lo snippet di codice riportato sopra attiverà una procedura di autenticazione.

3. [INFO] Che cosa sono le Tensor Processing Unit (TPU)?

In breve

Le TPU sono acceleratori hardware specializzati in attività di deep learning. In questo code lab vedrai come utilizzarli con Keras e TensorFlow 2. Le Cloud TPU sono disponibili in una configurazione di base con 8 core e anche in configurazioni più grandi chiamate "pod TPU" fino a 2048 core. L'hardware aggiuntivo può essere utilizzato per accelerare l'addestramento aumentando la dimensione del batch di addestramento.

Il codice per l'addestramento di un modello su TPU in Keras (e il fallback su GPU o CPU se una TPU non è disponibile):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Oggi utilizzeremo le TPU per creare e ottimizzare un classificatore di fiori a velocità interattive (minuti per esecuzione dell'addestramento).

Perché le TPU?

Le GPU moderne sono organizzate intorno a "core" programmabili, un'architettura molto flessibile che consente loro di gestire una serie di attività come il rendering 3D, il deep learning, le simulazioni fisiche e così via. Le TPU, invece, accoppiano un processore vettoriale classico a un'unità di moltiplicazione della matrice dedicata e sono eccellenti in qualsiasi attività in cui dominano le moltiplicazioni di matrici di grandi dimensioni, come le reti neurali.

Illustrazione: uno strato di rete neurale densa come moltiplicazione di matrici, con un batch di otto immagini elaborate contemporaneamente dalla rete neurale. Esegui una moltiplicazione di una riga per una colonna per verificare che venga effettivamente eseguita una somma ponderata di tutti i valori dei pixel di un'immagine. Anche i livelli convoluzionali possono essere rappresentati come moltiplicazioni di matrici, anche se è un po' più complicato ( spiegazione qui, nella sezione 1).

L'hardware

MXU e VPU

Un core TPU v2 è costituito da un'unità di moltiplicazione a matrice (MXU) che esegue moltiplicazioni di matrici e da un'unità di elaborazione vettoriale (VPU) per tutte le altre attività, come attivazioni, softmax e così via. La VPU gestisce i calcoli float32 e int32. L'MXU, invece, opera in un formato a virgola mobile a precisione mista a 16-32 bit.

Virgola mobile a precisione mista e bfloat16

L'MXU calcola le moltiplicazioni di matrici utilizzando input bfloat16 e output float32. Gli accumuli intermedi vengono eseguiti con precisione float32.

L'addestramento della rete neurale è in genere resistente al rumore introdotto da una precisione in virgola mobile ridotta. In alcuni casi, il rumore aiuta persino lo strumento di ottimizzazione a convergere. La precisione in virgola mobile a 16 bit è stata tradizionalmente utilizzata per accelerare i calcoli, ma i formati float16 e float32 hanno intervalli molto diversi. La riduzione della precisione da float32 a float16 di solito comporta overflow e underflow. Esistono soluzioni, ma in genere è necessario un lavoro aggiuntivo per far funzionare float16.

Per questo motivo, Google ha introdotto il formato bfloat16 nelle TPU. bfloat16 è un float32 troncato con esattamente gli stessi bit di esponente e lo stesso intervallo di float32. Questo, unito al fatto che le TPU calcolano le moltiplicazioni di matrici in precisione mista con input bfloat16 ma output float32, significa che, in genere, non sono necessarie modifiche al codice per trarre vantaggio dai miglioramenti delle prestazioni dovuti alla precisione ridotta.

L'utilizzo della precisione mista bfloat16/float32 è l'impostazione predefinita sulle TPU. Per abilitarlo, non è necessario apportare modifiche al codice TensorFlow. Continui a lavorare con float32 in tutto il codice. Quando esegue una moltiplicazione di matrici, la TPU tronca automaticamente i suoi input a bfloat16. La matrice risultante è float32.

Array sistolico

L'MXU implementa le moltiplicazioni di matrici nell'hardware utilizzando una cosiddetta architettura "array sistolico" in cui gli elementi di dati scorrono attraverso un array di unità di calcolo hardware. In medicina, "sistolico" si riferisce alle contrazioni cardiache e al flusso sanguigno, qui al flusso di dati.

L'elemento di base di una moltiplicazione di matrici è un prodotto scalare tra una riga di una matrice e una colonna dell'altra matrice (vedi l'illustrazione nella parte superiore di questa sezione). Per una moltiplicazione di matrici Y=X*W, un elemento del risultato sarebbe:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

Su una GPU, questo prodotto scalare viene programmato in un "core" della GPU e poi eseguito su tutti i "core" disponibili in parallelo per cercare di calcolare contemporaneamente ogni valore della matrice risultante. Se la matrice risultante è 128x128, sarebbero necessari 128x128=16.000 "core" disponibili, il che in genere non è possibile. Le GPU più grandi hanno circa 4000 core. Una TPU, invece, utilizza l'hardware minimo indispensabile per le unità di calcolo nell'MXU: solo bfloat16 x bfloat16 => float32 moltiplicatori-accumulatori, nient'altro. Sono così piccole che una TPU può implementarne 16.000 in una MXU 128x128 ed elaborare questa moltiplicazione di matrici in una sola volta.

Illustrazione: l'array sistolico MXU. Gli elementi di calcolo sono accumulatori di moltiplicazione. I valori di una matrice vengono caricati nell'array (punti rossi). I valori dell'altra matrice scorrono attraverso l'array (punti grigi). Le linee verticali propagano i valori verso l'alto. Le linee orizzontali propagano le somme parziali. L'utente deve verificare che, man mano che i dati scorrono nell'array, il risultato della moltiplicazione delle matrici esca dal lato destro.

Inoltre, mentre i prodotti scalari vengono calcolati in un'unità di esecuzione della matrice, le somme intermedie scorrono semplicemente tra le unità di calcolo adiacenti. Non devono essere archiviati e recuperati dalla memoria o da un file di registro. Il risultato finale è che l'architettura dell'array sistolico della TPU offre un vantaggio significativo in termini di densità e potenza, nonché un vantaggio di velocità non trascurabile rispetto a una GPU, quando si calcolano le moltiplicazioni di matrici.

Cloud TPU

Quando richiedi una "Cloud TPU v2" su Google Cloud, ottieni una macchina virtuale (VM) con una scheda TPU collegata a PCI. La scheda TPU ha quattro chip TPU dual-core. Ogni core TPU è dotato di una VPU (Vector Processing Unit) e di un'unità MXU (MatriX multiply Unit) 128x128. Questa "Cloud TPU" viene quindi solitamente connessa tramite la rete alla VM che l'ha richiesta. Quindi il quadro completo è il seguente:

Illustrazione: la tua VM con un acceleratore "Cloud TPU" collegato alla rete. "La Cloud TPU" stessa è costituita da una VM con una scheda TPU collegata a PCI con quattro chip TPU dual-core.

TPU pod

Nei data center di Google, le TPU sono connesse a un'interconnessione di computing ad alte prestazioni (HPC), che può farle apparire come un unico acceleratore molto grande. Google li chiama pod e possono comprendere fino a 512 core TPU v2 o 2048 core TPU v3.

Illustrazione: un pod TPU v3. Schede e rack TPU connessi tramite interconnessione HPC.

Durante l'addestramento, i gradienti vengono scambiati tra i core TPU utilizzando l'algoritmo all-reduce ( qui una buona spiegazione di all-reduce). Il modello in fase di addestramento può sfruttare l'hardware eseguendo l'addestramento su dimensioni batch di grandi dimensioni.

Illustrazione: sincronizzazione dei gradienti durante l'addestramento utilizzando l'algoritmo all-reduce sulla rete HPC a mesh toroidale bidimensionale della TPU di Google.

Il software

Addestramento con dimensioni del batch elevate

La dimensione batch ideale per le TPU è di 128 elementi di dati per core TPU, ma l'hardware può già mostrare un buon utilizzo a partire da 8 elementi di dati per core TPU. Ricorda che una Cloud TPU ha 8 core.

In questo codelab utilizzeremo l'API Keras. In Keras, il batch che specifichi è la dimensione del batch globale per l'intera TPU. I batch verranno suddivisi automaticamente in 8 e verranno eseguiti sugli 8 core della TPU.

Per ulteriori suggerimenti sul rendimento, consulta la Guida al rendimento delle TPU. Per batch di dimensioni molto grandi, in alcuni modelli potrebbe essere necessario prestare particolare attenzione. Per ulteriori dettagli, consulta LARSOptimizer.

Dietro le quinte: XLA

I programmi TensorFlow definiscono i grafi di calcolo. La TPU non esegue direttamente il codice Python, ma il grafico di calcolo definito dal programma TensorFlow. Sotto il cofano, un compilatore chiamato XLA (accelerated Linear Algebra compiler) trasforma il grafico di nodi di calcolo di TensorFlow in codice macchina TPU. Questo compilatore esegue anche molte ottimizzazioni avanzate sul codice e sul layout della memoria. La compilazione avviene automaticamente quando il lavoro viene inviato alla TPU. Non devi includere XLA nella catena di build in modo esplicito.

Illustrazione: per essere eseguito sulla TPU, il grafico di calcolo definito dal programma TensorFlow viene prima tradotto in una rappresentazione XLA (accelerated Linear Algebra compiler), poi compilato da XLA in codice macchina TPU.

Utilizzo delle TPU in Keras

Le TPU sono supportate tramite l'API Keras a partire da TensorFlow 2.1. Il supporto di Keras funziona su TPU e pod di TPU. Ecco un esempio che funziona su TPU, GPU e CPU:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

In questo snippet di codice:

• TPUClusterResolver().connect() trova la TPU sulla rete. Funziona senza parametri sulla maggior parte dei sistemi Google Cloud (job AI Platform, Colaboratory, Kubeflow, VM di deep learning create tramite l'utilità "ctpu up"). Questi sistemi sanno dove si trova la TPU grazie a una variabile di ambiente TPU_NAME. Se crei una TPU manualmente, imposta la variabile di ambiente TPU_NAME nella VM da cui la utilizzi o chiama TPUClusterResolver con parametri espliciti: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy è la parte che implementa l'algoritmo di sincronizzazione del gradiente di distribuzione e "all-reduce".
• La strategia viene applicata tramite un ambito. Il modello deve essere definito nell'ambito della strategia scope().
• La funzione tpu_model.fit prevede un oggetto tf.data.Dataset come input per l'addestramento della TPU.

Attività comuni di porting della TPU

• Sebbene esistano molti modi per caricare i dati in un modello TensorFlow, per le TPU è necessario utilizzare l'API tf.data.Dataset.
• Le TPU sono molto veloci e l'importazione dei dati spesso diventa il collo di bottiglia quando vengono eseguite. Nella Guida al rendimento delle TPU sono disponibili strumenti che puoi utilizzare per rilevare i colli di bottiglia dei dati e altri suggerimenti sul rendimento.
• I numeri int8 o int16 vengono trattati come int32. La TPU non dispone di hardware per numeri interi che opera su meno di 32 bit.
• Alcune operazioni di TensorFlow non sono supportate. L'elenco è disponibile qui. La buona notizia è che questa limitazione si applica solo al codice di addestramento, ovvero al passaggio in avanti e indietro attraverso il modello. Puoi comunque utilizzare tutte le operazioni TensorFlow nella pipeline di input dei dati, in quanto verranno eseguite sulla CPU.
• tf.py_func non è supportato sulla TPU.

4. Caricamento dati in corso…

Lavoreremo con un set di dati di immagini di fiori. L'obiettivo è imparare a classificarli in 5 tipi di fiori. Il caricamento dei dati viene eseguito utilizzando l'API tf.data.Dataset. Innanzitutto, scopriamo l'API.

Pratica

Apri il seguente notebook, esegui le celle (Maiusc+Invio) e segui le istruzioni ovunque vedi l'etichetta "LAVORO RICHIESTO".

Fun with tf.data.Dataset (playground).ipynb

Ulteriori informazioni

Informazioni sul set di dati "Fiori"

Il set di dati è organizzato in 5 cartelle. Ogni cartella contiene fiori di un solo tipo. Le cartelle si chiamano girasoli, margherita, tarassaco, tulipani e rose. I dati sono ospitati in un bucket pubblico su Google Cloud Storage. Estratto:

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

Perché tf.data.Dataset?

Keras e TensorFlow accettano i set di dati in tutte le loro funzioni di addestramento e valutazione. Una volta caricati i dati in un set di dati, l'API offre tutte le funzionalità comuni utili per i dati di addestramento della rete neurale:

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

Puoi trovare suggerimenti sul rendimento e best practice per i set di dati in questo articolo. La documentazione di riferimento è disponibile qui.

Nozioni di base di tf.data.Dataset

I dati di solito sono contenuti in più file, in questo caso immagini. Puoi creare un set di dati di nomi di file chiamando:

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

Quindi "mappi" una funzione a ogni nome file, che in genere carica e decodifica il file in dati effettivi in memoria:

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

Per eseguire l'iterazione su un set di dati:

for data in my_dataset:
  print(data)

Set di dati di tuple

Nell'apprendimento supervisionato, un set di dati di addestramento è in genere costituito da coppie di dati di addestramento e risposte corrette. Per consentirlo, la funzione di decodifica può restituire tuple. Avrai quindi un set di dati di tuple e le tuple verranno restituite quando lo iteri. I valori restituiti sono tensori TensorFlow pronti per essere utilizzati dal modello. Puoi chiamare .numpy() per visualizzare i valori non elaborati:

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

Conclusione:caricare le immagini una alla volta è lento.

Man mano che esegui l'iterazione su questo set di dati, vedrai che puoi caricare circa 1-2 immagini al secondo. È troppo lento. Gli acceleratori hardware che utilizzeremo per l'addestramento possono sostenere molte volte questa velocità. Vai alla sezione successiva per scoprire come lo faremo.

Soluzione

Ecco il notebook della soluzione. Puoi utilizzarlo se non riesci a risolvere il problema.

Fun with tf.data.Dataset (solution).ipynb

Argomenti trattati

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 Set di dati di tuple
• 😀 Iterazione dei set di dati

Ti invitiamo a esaminare questo elenco di controllo.

5. Caricamento rapido dei dati

Gli acceleratori hardware Tensor Processing Unit (TPU) che utilizzeremo in questo lab sono molto veloci. La sfida spesso consiste nel fornire loro dati abbastanza velocemente da tenerli occupati. Google Cloud Storage (GCS) è in grado di sostenere una velocità effettiva molto elevata, ma come per tutti i sistemi di archiviazione cloud, l'avvio di una connessione comporta un certo traffico di rete. Pertanto, non è ideale avere i nostri dati memorizzati come migliaia di singoli file. Li elaboreremo in batch in un numero inferiore di file e utilizzeremo la potenza di tf.data.Dataset per leggere da più file in parallelo.

Read-through

Il codice che carica i file immagine, li ridimensiona a una dimensione comune e li archivia in 16 file TFRecord si trova nel seguente blocco note. Leggilo rapidamente. L'esecuzione non è necessaria, poiché per il resto del codelab verranno forniti dati formattati correttamente in TFRecord.

Flower pictures to TFRecords.ipynb

Layout dei dati ideale per una velocità effettiva ottimale di GCS

La regola generale è di dividere i dati in diversi file di dimensioni medio-grandi (da decine a centinaia di MB). Se hai troppi file, ad esempio migliaia, il tempo di accesso a ciascun file potrebbe iniziare a diventare un problema. Se hai pochi file, ad esempio uno o due, non usufruisci dei vantaggi dello streaming da più file in parallelo.

Il formato file TFRecord

Il formato file preferito di TensorFlow per l'archiviazione dei dati è il formato TFRecord basato su protobuf. Anche altri formati di serializzazione funzionerebbero, ma puoi caricare un set di dati dai file TFRecord direttamente scrivendo:

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

Per prestazioni ottimali, ti consigliamo di utilizzare il seguente codice più complesso per leggere contemporaneamente da più file TFRecord. Questo codice leggerà N file in parallelo e ignorerà l'ordine dei dati a favore della velocità di lettura.

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

Scheda di riferimento di TFRecord

In TFRecord possono essere archiviati tre tipi di dati: stringhe di byte (elenco di byte), numeri interi a 64 bit e numeri in virgola mobile a 32 bit. Vengono sempre archiviati come elenchi e un singolo elemento di dati sarà un elenco di dimensioni 1. Puoi utilizzare le seguenti funzioni helper per archiviare i dati in TFRecord.

scrittura di stringhe di byte

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

scrittura di numeri interi

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

Scrittura fluttuante

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

Scrivere un TFRecord, utilizzando gli helper sopra indicati

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

Per leggere i dati da TFRecord, devi prima dichiarare il layout dei record che hai archiviato. Nella dichiarazione, puoi accedere a qualsiasi campo denominato come elenco a lunghezza fissa o variabile:

lettura da TFRecord

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

Snippet di codice utili:

lettura di singoli elementi di dati

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

leggere elenchi di elementi a dimensioni fisse

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

leggere un numero variabile di elementi di dati

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

Una VarLenFeature restituisce un vettore sparso ed è necessario un passaggio aggiuntivo dopo la decodifica del TFRecord:

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

È anche possibile avere campi facoltativi nei TFRecord. Se specifichi un valore predefinito durante la lettura di un campo, questo valore viene restituito al posto di un errore se il campo non è presente.

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

Argomenti trattati

• 🤔 suddivisione dei file di dati per un accesso rapido da GCS
• 😓 come scrivere TFRecord. (Hai già dimenticato la sintassi? Va bene, aggiungi questa pagina ai preferiti come cheat sheet.
• 🤔 caricamento di un set di dati da TFRecord utilizzando TFRecordDataset

Ti invitiamo a esaminare questo elenco di controllo.

6. Complimenti!

Ora puoi fornire dati a una TPU. Continua con il lab successivo

• [QUESTO LAB] Pipeline di dati a velocità TPU: tf.data.Dataset e TFRecords
• Il tuo primo modello Keras, con il transfer learning
• Reti neurali convoluzionali con Keras e TPU
• ConvNet moderne, SqueezeNet, Xception, con Keras e TPU

TPU in pratica

TPU e GPU sono disponibili su Cloud AI Platform:

• Su Deep Learning VM
• In AI Platform Notebooks
• Nei job di AI Platform Training

Infine, ci piacerebbe ricevere un tuo feedback. Comunicaci se noti qualcosa di strano in questo lab o se ritieni che debba essere migliorato. Il feedback può essere fornito tramite i problemi di GitHub [link al feedback].

L'autore: Martin Görner Twitter: @martin_gorner