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

1. Panoramica

Le TPU sono molto veloci. Lo stream di dati di addestramento deve essere in linea 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 Parte 1 della serie "Keras on TPU". Puoi eseguirli nel seguente ordine o indipendentemente.

• [THIS LAB] Pipeline di dati a velocità TPU: tf.data.Dataset e TFRecords
• Il tuo primo modello Keras, con Transfer Learning
• Reti neurali convoluzionali, con Keras e TPU
• Convnet moderne, Squeezenet, Xception, con Keras e TPU

Obiettivi didattici

• 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 che non va in questo lab del codice, faccelo sapere. Il feedback può essere fornito tramite i problemi di GitHub [link per il feedback].

2. Guida rapida di Google Colaboratory

Questo lab utilizza Google Collaboratory e non richiede alcuna configurazione da parte tua. Colaboratory è una piattaforma di blocchi note online a scopo didattico. Offre l'addestramento senza costi di CPU, GPU e TPU.

Puoi aprire questo notebook di esempio ed eseguire un paio di celle per familiarizzare con Colaboratory.

Welcome to Colab.ipynb

Seleziona un backend TPU

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

Esecuzione di blocchi note

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

Sommario

Tutti i blocchi note hanno un sommario. Puoi aprirlo utilizzando la freccia nera a sinistra.

Celle nascoste

Alcune celle mostreranno solo il titolo. Questa è una funzionalità del notebook specifica di Colab. Puoi fare doppio clic per visualizzare il codice al loro interno, ma in genere non è molto interessante. In genere supportano o le funzioni di visualizzazione. Devi comunque eseguire queste celle affinché le funzioni al loro interno vengano definite.

Autenticazione

Colab può accedere ai tuoi bucket Google Cloud Storage privati, a condizione che tu esegua l'autenticazione con un account autorizzato. Lo snippet di codice riportato sopra attiverà un processo 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 lab di codice 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. È possibile utilizzare l'hardware aggiuntivo per accelerare l'addestramento aumentando la dimensione del batch di addestramento.

Il codice per addestrare un modello su TPU in Keras (e per utilizzare GPU o CPU se non è disponibile una TPU):

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 useremo le TPU per creare e ottimizzare un classificatore di fiori a velocità interattive (minuti per addestramento).

Perché le TPU?

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

Illustrazione: un livello di rete neurale denso come moltiplicazione di matrici, con un batch di otto immagini elaborate contemporaneamente dalla rete neurale. Esegui la 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 le moltiplicazioni di matrici e da un'unità di elaborazione di vettori (VPU) per tutte le altre attività come attivazioni, softmax e così via. La VPU gestisce i calcoli float32 e int32. MXU, invece, funziona in un formato in virgola mobile a 16-32 bit a precisione mista.

Virgola mobile con precisione mista e bfloat16

L'unità MXU calcola le moltiplicazioni di matrici utilizzando input bfloat16 e output float32. Le accumulazioni intermedie vengono eseguite 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 l'ottimizzatore 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 solitamente si verifica in overflow e underflow. Esistono delle soluzioni, ma in genere è necessario un lavoro aggiuntivo per far funzionare float16.

Ecco perché Google ha introdotto il formato bfloat16 nelle TPU. bfloat16 è un valore float32 troncato con esattamente gli stessi bit dell'esponente e lo stesso intervallo di float32. Questo, insieme al fatto che le TPU calcolano le moltiplicazioni di matrici con 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 della precisione ridotta.

L'utilizzo della precisione mista bfloat16/float32 è l'impostazione predefinita sulle TPU. Per attivarlo non sono necessarie modifiche al codice di Tensorflow. Continuerai a lavorare con float32 in tutto il codice. Quando si esegue una moltiplicazione matriciale, la TPU troncherà automaticamente gli input in bfloat16. La matrice risultante è float32.

Array sistolico

L'MXU implementa moltiplicazioni matriciali nell'hardware utilizzando una cosiddetta architettura "array sistolica", in cui gli elementi dei dati fluiscono attraverso un array di unità di calcolo hardware. In medicina, "sistolica" 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 matriciale 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, si programma questo prodotto scalare in un "core" GPU e lo si esegue su tutti i "core" disponibili in parallelo per provare a calcolare contemporaneamente ogni valore della matrice risultante. Se la matrice risultante è di 128 x 128, è necessario disporre di 128 x 128 = 16.000 "core", il che in genere non è possibile. Le GPU più grandi hanno circa 4000 core. Una TPU, invece, utilizza il minimo indispensabile di hardware per le unità di calcolo nell'unità MXU: solo moltiplicatori-accumulatori bfloat16 x bfloat16 => float32, nient'altro. Queste sono così piccole che una TPU può implementarne 16K in un MXU di 128x128 ed elaborare questa moltiplicazione della matrice in una volta sola.

Illustrazione: l'array sistolica MXU. Gli elementi di calcolo sono accumulatori multipli. I valori di una matrice vengono caricati nell'array (punti rossi). I valori dell'altra matrice passano attraverso l'array (punti grigi). Le linee verticali propagano i valori verso l'alto. Le linee orizzontali propagano somme parziali. Spetta all'utente verificare che, man mano che i dati passano attraverso l'array, il risultato della moltiplicazione della matrice venga visualizzato sul lato destro.

Inoltre, mentre i prodotti scalare vengono calcolati in un MXU, le somme intermedie si limitano a passare tra le unità di calcolo adiacenti. Non è necessario archiviarli e recuperarli in/da memoria o anche in un file del registro. Il risultato finale è che l'architettura dell'array di sistolica TPU ha un significativo vantaggio in termini di densità e potenza, oltre a un vantaggio in termini di velocità non trascurabile rispetto a una GPU, quando si calcolano le moltiplicazioni delle matrici.

Cloud TPU

Quando richiedi una "Cloud TPU v2" su Google Cloud Platform, ottieni una macchina virtuale (VM) con una scheda TPU collegata al PCI. La scheda TPU ha quattro chip TPU dual-core. Ogni core TPU è dotato di una VPU (Vector Processing Unit) e di una MXU (MatriX moltiplicazione) 128 x 128. Questa "Cloud TPU" viene quindi generalmente connessa tramite la rete alla VM che l'ha richiesta. Il quadro completo sarà quindi simile a questo:

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

Pod TPU

Nei data center di Google, le TPU sono collegate a un'interconnessione HPC (high-performance computing) che può farle apparire come un acceleratore molto grande. Google li chiama pod e possono includere fino a 512 core TPU v2 o 2048 core TPU v3.

Illustrazione: un pod TPU v3. Rack e schede TPU collegate tramite interconnessione HPC.

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

Illustrazione: sincronizzazione delle derive durante l'addestramento mediante l'algoritmo all-reduce sulla rete HPC a mesh toroidale 2D di Google TPU.

Il software

Addestramento con dimensioni dei batch elevate

La dimensione ideale del batch 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 specificato è la dimensione del batch globale per l'intera TPU. I batch verranno automaticamente suddivisi in 8 core e eseguiti su 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 necessaria una particolare attenzione. Per ulteriori dettagli, consulta LARSOptimizer.

Dietro le quinte: XLA

I programmi TensorFlow definiscono i grafici di calcolo. La TPU non esegue direttamente il codice Python, ma esegue il grafico di calcolo definito dal tuo programma TensorFlow. Un compilatore chiamato XLA (Accelerated Linear Algebra compiler) trasforma il grafico TensorFlow dei nodi di calcolo 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 è necessario includere XLA esplicitamente nella catena di compilazione.

Illustrazione: per l'esecuzione su TPU, il grafico di calcolo definito dal programma Tensorflow viene prima tradotto in una rappresentazione XLA (Accelerated Linear Algebra compiler), quindi compilato da XLA nel codice macchina TPU.

Utilizzare le TPU in Keras

Le TPU sono supportate tramite l'API Keras a partire da TensorFlow 2.1. Il supporto 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 di 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 sulla VM da cui la utilizzi oppure chiama TPUClusterResolver con parametri espliciti: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy è la parte che implementa la distribuzione e l'algoritmo di sincronizzazione del gradiente "all-reduce".
• La strategia viene applicata attraverso un ambito. Il modello deve essere definito all'interno di scope().
• La funzione tpu_model.fit prevede un oggetto tf.data.Dataset per l'input per l'addestramento delle TPU.

Attività comuni di porting su TPU

• Sebbene esistano molti modi per caricare i dati in un modello TensorFlow, per le TPU è necessario l'utilizzo dell'API tf.data.Dataset.
• Le TPU sono molto veloci e l'importazione dei dati diventa spesso il collo di bottiglia quando vengono eseguite su queste piattaforme. Nella Guida alle prestazioni TPU puoi trovare strumenti per individuare i colli di bottiglia dei dati e altri suggerimenti per le prestazioni.
• I numeri int8 o int16 vengono trattati come int32. La TPU non ha un hardware intero 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 all'indietro nel modello. Puoi comunque utilizzare tutte le operazioni di TensorFlow nella pipeline di input dei dati perché 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. Per prima cosa, conosciamo l'API.

Pratico

Apri il seguente blocco note, esegui le celle (Maiusc-Invio) e segui le istruzioni ogni volta che vedi l'etichetta "OPERAZIONE RICHIESTA".

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

Ulteriori informazioni

Informazioni sul set di dati "flowers"

Il set di dati è organizzato in 5 cartelle. Ogni cartella contiene fiori di un solo tipo. Le cartelle prendono il nome di girasoli, margherita, dente di leone, 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. Dopo aver caricato i dati in un set di dati, l'API offre tutte le funzionalità comuni utili per i dati di addestramento delle reti neurali:

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

In questo articolo puoi trovare suggerimenti per le prestazioni e best practice per i set di dati. La documentazione di riferimento è disponibile qui.

Nozioni di base su tf.data.Dataset

I dati di solito si trovano in più file, qui le immagini. Puoi creare un set di dati di nomi file chiamando:

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

Poi "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 è generalmente composto da coppie di dati di addestramento e risposte corrette. Per consentire ciò, la funzione di decodifica può restituire tuple. Avrai quindi un set di dati di tuple e le tuple verranno restituite quando esegui l'iterazione. 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, noterai che puoi caricare circa 1-2 immagini al secondo. È troppo lento. Gli acceleratori hardware che utilizzeremo per l'addestramento sono in grado di sostenere molte volte questo ritmo. Vai alla sezione successiva per scoprire come lo faremo.

Soluzione

Ecco il blocco note della soluzione. Se non riesci a procedere, puoi utilizzarla.

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

Argomenti trattati

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 Set di dati di tuple
• 😀 Eseguire l'iterazione dei set di dati

Dedica qualche istante a leggere questo elenco di controllo.

5. Caricamento rapido dei dati

Gli acceleratori hardware TPU (Tensor Processing Unit) che utilizzeremo in questo lab sono molto veloci. Spesso la sfida è fornire i dati abbastanza velocemente da tenerli occupati. Google Cloud Storage (GCS) è in grado di supportare un throughput molto elevato, ma come per tutti i sistemi di archiviazione sul cloud, l'avvio di una connessione comporta alcuni trasferimenti di rete. Pertanto, non è ideale memorizzare i dati sotto forma di migliaia di singoli file. Li raggruppaamo in un numero inferiore di file e utilizziamo la potenza di tf.data.Dataset per leggere da più file in parallelo.

Lettura

Il codice che carica i file immagine, li ridimensiona in base a una dimensione comune e poi li archivia in 16 file TFRecord è nel seguente notebook. Leggilo rapidamente. Non è necessario eseguirlo perché per il resto del codelab verranno forniti dati formattati correttamente in TFRecord.

Flower pictures to TFRecords.ipynb

Layout dei dati ideale per una produttività ottimale di GCS

La regola generale è suddividere i dati in più (da 10 a 100) file di dimensioni medio-grandi (da 10 a 100 MB). Se hai troppi file, ad esempio migliaia, il tempo necessario per accedere a ogni file potrebbe iniziare a essere un problema. Se hai pochi file, ad esempio uno o due, non ottieni i vantaggi dello streaming da più file in parallelo.

Il formato file TFRecord

Il formato di file preferito da TensorFlow per l'archiviazione dei dati è il formato TFRecord basato su protobuf. Possono funzionare anche altri formati di serializzazione, ma puoi caricare un set di dati direttamente dai file TFRecord 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 da più file TFRecord contemporaneamente. Questo codice leggerà da 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

Nei 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, un singolo elemento di dati sarà un elenco di dimensione 1. Puoi utilizzare le seguenti funzioni di supporto 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))

scrivere messaggi mobili

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

scrivendo un TFRecord, usando gli assistenti indicati sopra

# 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 dai TFRecord, devi prima dichiarare il layout dei record archiviati. Nella dichiarazione, puoi accedere a qualsiasi campo denominato come elenco di lunghezza fissa o elenco di lunghezza variabile:

leggi dai 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

Lettura di 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

Lettura di 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

Un attributo 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 in TFRecords. Se specifichi un valore predefinito durante la lettura di un campo, viene restituito il valore predefinito anziché un errore se il campo non è presente.

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

Argomenti trattati

• 🤔 Esegui lo sharding dei file di dati per un accesso rapido da GCS
• 😓 come scrivere TFRecord. (Hai già dimenticato la sintassi? Non c'è problema, aggiungi questa pagina ai preferiti come scheda di riferimento)
• 🤔 Caricamento di un set di dati da TFRecord utilizzando TFRecordDataset

Esamina mentalmente questo elenco di controllo.

6. Complimenti!

Ora puoi alimentare una TPU con dati. Vai al lab successivo

• [THIS LAB] Pipeline di dati a velocità TPU: tf.data.Dataset e TFRecords
• Il tuo primo modello Keras, con Transfer Learning
• Reti neurali convoluzionali, con Keras e TPU
• Convnet moderne, Squeezenet, Xception, con Keras e TPU

TPU nella pratica

TPU e GPU sono disponibili su Cloud AI Platform:

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

Infine, ci piacerebbe ricevere feedback. Facci sapere se noti qualcosa che non va in questo lab o se pensi che dovrebbe essere migliorato. Il feedback può essere fornito tramite i problemi di GitHub [link per il feedback].

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