Pipelines de données à la vitesse des TPU: tf.data.Dataset et TFRecords

1. Présentation

Les TPU sont très rapides. Le flux de données d'entraînement doit suivre le rythme de leur vitesse d'entraînement. Dans cet atelier, vous allez apprendre à charger des données à partir de GCS avec l'API tf.data.Dataset pour alimenter votre TPU.

Cet atelier est la première partie de la série "Keras sur TPU". Vous pouvez les effectuer dans l'ordre suivant ou indépendamment.

• [CET ATELIER] Pipelines de données à la vitesse des TPU : tf.data.Dataset et TFRecords
• Votre premier modèle Keras, avec apprentissage par transfert
• Réseaux de neurones convolutifs, avec Keras et les TPU
• Réseaux de neurones convolutifs (convnets) modernes, SqueezeNet et Xception, avec Keras et des TPU

Points abordés

• utiliser l'API tf.data.Dataset pour charger les données d'entraînement ;
• utiliser le format TFRecord pour charger efficacement les données d'entraînement à partir de GCS ;

Commentaires

Si vous remarquez quelque chose d'inhabituel dans cet atelier de programmation, veuillez nous en informer. Vous pouvez envoyer vos commentaires via les problèmes GitHub [lien vers les commentaires].

2. Démarrage rapide de Google Colaboratory

Cet atelier utilise Google Collaboratory et ne nécessite aucune configuration de votre part. Colaboratory est une plate-forme de notebooks en ligne à des fins pédagogiques. Il propose un entraînement sans frais sur CPU, GPU et TPU.

Vous pouvez ouvrir cet exemple de notebook et exécuter quelques cellules pour vous familiariser avec Colaboratory.

Welcome to Colab.ipynb

Sélectionner un backend TPU

Dans le menu Colab, sélectionnez Exécution > Modifier le type d'exécution, puis sélectionnez TPU. Dans cet atelier de programmation, vous allez utiliser un puissant TPU (Tensor Processing Unit) pour l'entraînement accéléré par le matériel. La connexion au runtime se fait automatiquement lors de la première exécution. Vous pouvez également utiliser le bouton "Connect" (Se connecter) en haut à droite.

Exécution de notebooks

Exécutez les cellules une par une en cliquant sur une cellule et en utilisant Maj+ENTRÉE. Vous pouvez également exécuter l'intégralité du notebook avec Exécuter > Exécuter tout.

Sommaire

Tous les notebooks contiennent une table des matières. Vous pouvez l'ouvrir à l'aide de la flèche noire sur la gauche.

Cellules masquées

Certaines cellules n'affichent que leur titre. Il s'agit d'une fonctionnalité de notebook spécifique à Colab. Vous pouvez double-cliquer dessus pour afficher le code qu'ils contiennent, mais ce n'est généralement pas très intéressant. Fonctions de support ou de visualisation, généralement. Vous devez toujours exécuter ces cellules pour que les fonctions à l'intérieur soient définies.

Authentification

Colab peut accéder à vos buckets Google Cloud Storage privés à condition que vous vous authentifiiez avec un compte autorisé. L'extrait de code ci-dessus déclenche un processus d'authentification.

3. [INFO] Que sont les Tensor Processing Units (TPU) ?

En bref

Les TPU sont des accélérateurs matériels spécialisés dans les tâches de deep learning. Dans cet atelier de programmation, vous allez découvrir comment les utiliser avec Keras et TensorFlow 2. Les Cloud TPU sont disponibles dans une configuration de base avec huit cœurs, mais aussi dans des configurations plus importantes appelées "pods TPU" pouvant comporter jusqu'à 2 048 cœurs. Le matériel supplémentaire peut être utilisé pour accélérer l'entraînement en augmentant la taille du lot d'entraînement.

Code permettant d'entraîner un modèle sur un TPU dans Keras (et de revenir au GPU ou au CPU si un TPU n'est pas disponible) :

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=...)

Aujourd'hui, nous allons utiliser des TPU pour créer et optimiser un classificateur de fleurs à des vitesses interactives (minutes par exécution d'entraînement).

Pourquoi utiliser des TPU ?

Les GPU modernes sont organisés autour de "cœurs" programmables, une architecture très flexible qui leur permet de gérer diverses tâches telles que le rendu 3D, le deep learning, les simulations physiques, etc. Les TPU, quant à eux, associent un processeur vectoriel classique à une unité de multiplication matricielle dédiée. Ils excellent dans toutes les tâches où les multiplications matricielles de grande taille sont prédominantes, comme les réseaux de neurones.

Illustration : couche de réseau de neurones dense sous forme de multiplication matricielle, avec un lot de huit images traitées simultanément par le réseau de neurones. Veuillez effectuer une multiplication ligne x colonne pour vérifier qu'il s'agit bien d'une somme pondérée de toutes les valeurs de pixels d'une image. Les couches de convolution peuvent également être représentées sous forme de multiplications matricielles, bien que ce soit un peu plus compliqué ( explication ici, dans la section 1).

Le matériel

MXU et VPU

Un cœur de TPU v2 est composé d'une unité de multiplication matricielle (MXU) qui exécute les multiplications matricielles et d'une unité de traitement vectoriel (VPU) pour toutes les autres tâches telles que les activations, softmax, etc. La VPU gère les calculs float32 et int32. L'unité matricielle, quant à elle, fonctionne dans un format à virgule flottante de précision mixte (16-32 bits).

Virgule flottante et bfloat16 à précision mixte

L'unité matricielle calcule les multiplications matricielles à l'aide d'entrées bfloat16 et de sorties float32. Les accumulations intermédiaires sont effectuées avec une précision float32.

L'entraînement des réseaux de neurones est généralement résistant au bruit introduit par une précision à virgule flottante réduite. Dans certains cas, le bruit aide même l'optimiseur à converger. La précision en virgule flottante 16 bits est traditionnellement utilisée pour accélérer les calculs, mais les formats float16 et float32 ont des plages très différentes. La réduction de la précision de float32 à float16 entraîne généralement des dépassements de capacité et des sous-dépassements. Des solutions existent, mais un travail supplémentaire est généralement nécessaire pour que float16 fonctionne.

C'est pourquoi Google a introduit le format bfloat16 dans les TPU. bfloat16 est un float32 tronqué avec exactement les mêmes bits d'exposant et la même plage que float32. De plus, les TPU calculent les multiplications matricielles en précision mixte avec des entrées bfloat16, mais des sorties float32. Cela signifie qu'en général, aucune modification de code n'est nécessaire pour bénéficier des gains de performances liés à la précision réduite.

L'utilisation de la précision mixte bfloat16/float32 est la valeur par défaut sur les TPU. Aucune modification de code n'est nécessaire dans votre code TensorFlow pour l'activer. Vous continuez à travailler avec float32 dans l'ensemble de votre code. Lors de l'exécution d'une multiplication matricielle, le TPU tronque automatiquement ses entrées en bfloat16. La matrice obtenue est de type float32.

Tableau systolique

L'unité MXU implémente les multiplications de matrices dans le matériel à l'aide d'une architecture dite "de tableau systolique" dans laquelle les éléments de données circulent dans un tableau d'unités de calcul matérielles. (En médecine, le terme "systolique" fait référence aux contractions cardiaques et au flux sanguin, ici au flux de données.)

L'élément de base d'une multiplication matricielle est un produit scalaire entre une ligne d'une matrice et une colonne de l'autre matrice (voir l'illustration en haut de cette section). Pour une multiplication matricielle Y=X*W, un élément du résultat serait :

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]

Sur un GPU, ce produit scalaire serait programmé dans un "cœur" de GPU, puis exécuté sur autant de "cœurs" que possible en parallèle pour essayer de calculer toutes les valeurs de la matrice résultante à la fois. Si la matrice résultante est de 128 x 128, cela nécessiterait 128 x 128=16 000 "cœurs" disponibles, ce qui n'est généralement pas possible. Les plus grands GPU comptent environ 4 000 cœurs. Un TPU, en revanche, utilise le strict minimum de matériel pour les unités de calcul du MXU : uniquement bfloat16 x bfloat16 => float32 accumulateurs-multiplicateurs. Elles sont si petites qu'un TPU peut en implémenter 16 000 dans une MXU 128x128 et traiter cette multiplication matricielle en une seule fois.

Illustration du tableau systolique de l'unité matricielle. Les éléments de calcul sont des multiplicateurs-accumulateurs. Les valeurs d'une matrice sont chargées dans le tableau (points rouges). Les valeurs de l'autre matrice sont transmises au tableau (points gris). Les lignes verticales propagent les valeurs vers le haut. Les lignes horizontales propagent les sommes partielles. Il appartient à l'utilisateur de vérifier que, lorsque les données circulent dans le tableau, le résultat de la multiplication matricielle sort du côté droit.

De plus, lorsque les produits scalaires sont calculés dans une MXU, les sommes intermédiaires circulent simplement entre les unités de calcul adjacentes. Il n'est pas nécessaire de les stocker et de les récupérer dans la mémoire ou même dans un fichier de registre. Le résultat final est que l'architecture de réseau systolique TPU présente un avantage significatif en termes de densité et de puissance, ainsi qu'un avantage non négligeable en termes de vitesse par rapport à un GPU, lors du calcul des multiplications matricielles.

Cloud TPU

Lorsque vous demandez un Cloud TPU v2 sur Google Cloud Platform, vous obtenez une machine virtuelle (VM) dotée d'une carte TPU connectée à un port PCI. La carte TPU comporte quatre puces TPU à double cœur. Chaque cœur de TPU comprend une VPU (Vector Processing Unit) et une MXU (MatriX multiply Unit) de 128 x 128. Ce "Cloud TPU" est ensuite généralement connecté via le réseau à la VM qui l'a demandé. Voici à quoi ressemble l'image complète :

Illustration : votre VM avec un accélérateur "Cloud TPU" associé au réseau. Le "Cloud TPU" lui-même est constitué d'une VM avec une carte TPU connectée à un port PCI, qui comporte quatre puces TPU à double cœur.

Pods TPU

Dans les centres de données Google, les TPU sont connectés à une interconnexion de calcul hautes performances (HPC, High Performance Computing), ce qui peut les faire apparaître comme un très grand accélérateur. Google les appelle des pods. Ils peuvent englober jusqu'à 512 cœurs de TPU v2 ou 2 048 cœurs de TPU v3.

Illustration : un pod TPU v3. Cartes et racks TPU connectés via une interconnexion HPC.

Pendant l'entraînement, les gradients sont échangés entre les cœurs de TPU à l'aide de l'algorithme all-reduce ( bonne explication de all-reduce ici). Le modèle en cours d'entraînement peut tirer parti du matériel en s'entraînant sur de grandes tailles de lot.

Illustration : synchronisation des gradients lors de l'entraînement à l'aide de l'algorithme All-Reduce sur le réseau HPC à mailles toriques bidimensionnelles des TPU Google.

Le logiciel

Entraînement avec une grande taille de lot

La taille de lot idéale pour les TPU est de 128 éléments de données par cœur de TPU, mais le matériel peut déjà afficher une bonne utilisation à partir de huit éléments de données par cœur de TPU. N'oubliez pas qu'un Cloud TPU comporte huit cœurs.

Dans cet atelier de programmation, nous utiliserons l'API Keras. Dans Keras, le lot que vous spécifiez correspond à la taille de lot globale pour l'ensemble du TPU. Vos lots seront automatiquement divisés par huit et exécutés sur les huit cœurs du TPU.

Pour obtenir d'autres conseils sur les performances, consultez le Guide sur les performances des TPU. Pour les tailles de batch très importantes, une attention particulière peut être nécessaire dans certains modèles. Pour en savoir plus, consultez LARSOptimizer.

En coulisses : XLA

Les programmes TensorFlow définissent des graphes de calcul. Le TPU n'exécute pas directement le code Python, mais le graphe de calcul défini par votre programme TensorFlow. En coulisses, un compilateur appelé XLA (accelerated Linear Algebra compiler) transforme le graphique TensorFlow des nœuds de calcul en code machine TPU. Ce compilateur effectue également de nombreuses optimisations avancées sur votre code et votre disposition de mémoire. La compilation se produit automatiquement lorsque le travail est envoyé au TPU. Vous n'avez pas besoin d'inclure explicitement XLA dans votre chaîne de compilation.

Illustration : pour s'exécuter sur un TPU, le graphe de calcul défini par votre programme TensorFlow est d'abord traduit en représentation XLA (compilateur d'algèbre linéaire accélérée), puis compilé par XLA en code machine TPU.

Utiliser des TPU dans Keras

Les TPU sont compatibles avec l'API Keras à partir de TensorFlow 2.1. La compatibilité avec Keras fonctionne sur les TPU et les pods TPU. Voici un exemple qui fonctionne sur les TPU, les GPU et les 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=...)

Dans cet extrait de code :

• TPUClusterResolver().connect() trouve le TPU sur le réseau. Il fonctionne sans paramètre sur la plupart des systèmes Google Cloud (jobs AI Platform, Colaboratory, Kubeflow, VM de deep learning créées à l'aide de l'utilitaire "ctpu up"). Ces systèmes savent où se trouve leur TPU grâce à une variable d'environnement TPU_NAME. Si vous créez un TPU manuellement, définissez la variable d'environnement TPU_NAME sur la VM à partir de laquelle vous l'utilisez, ou appelez TPUClusterResolver avec des paramètres explicites : TPUClusterResolver(tp_uname, zone, project).
• TPUStrategy est la partie qui implémente l'algorithme de distribution et de synchronisation des gradients "all-reduce".
• La stratégie est appliquée à l'aide d'un champ d'application. Le modèle doit être défini dans la portée de la stratégie (scope()).
• La fonction tpu_model.fit attend un objet tf.data.Dataset en entrée pour l'entraînement du TPU.

Tâches courantes de portage de TPU

• Bien qu'il existe de nombreuses façons de charger des données dans un modèle TensorFlow, l'utilisation de l'API tf.data.Dataset est requise pour les TPU.
• Les TPU sont très rapides. L'ingestion de données devient souvent un goulot d'étranglement lorsqu'elles sont exécutées sur ces processeurs. Le Guide des performances des TPU contient des outils permettant de détecter les goulots d'étranglement des données et d'autres conseils sur les performances.
• Les nombres int8 ou int16 sont traités comme des nombres int32. Le TPU ne dispose pas de matériel entier fonctionnant sur moins de 32 bits.
• Certaines opérations TensorFlow ne sont pas compatibles. Cliquez ici pour consulter la liste. La bonne nouvelle, c'est que cette limite ne s'applique qu'au code d'entraînement, c'est-à-dire aux passes avant et arrière de votre modèle. Vous pouvez toujours utiliser toutes les opérations TensorFlow dans votre pipeline d'entrée de données, car elles seront exécutées sur le processeur.
• tf.py_func n'est pas compatible avec les TPU.

4. Chargement des données…

Nous allons travailler avec un ensemble de données d'images de fleurs. L'objectif est d'apprendre à les classer en cinq types de fleurs. Le chargement des données s'effectue à l'aide de l'API tf.data.Dataset. Commençons par découvrir l'API.

Pratique

Veuillez ouvrir le notebook suivant, exécuter les cellules (Shift+ENTRÉE) et suivre les instructions chaque fois que vous voyez le libellé "WORK REQUIRED" (ACTION REQUISE).

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

Informations supplémentaires

À propos de l'ensemble de données "flowers"

L'ensemble de données est organisé en cinq dossiers. Chaque dossier contient des fleurs d'un seul type. Les dossiers sont nommés "sunflowers" (tournesols), "daisy" (marguerites), "dandelion" (pissenlits), "tulips" (tulipes) et "roses" (roses). Les données sont hébergées dans un bucket public sur Google Cloud Storage. Extrait :

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

Pourquoi tf.data.Dataset ?

Keras et TensorFlow acceptent les ensembles de données dans toutes leurs fonctions d'entraînement et d'évaluation. Une fois que vous avez chargé des données dans un ensemble de données, l'API propose toutes les fonctionnalités courantes utiles pour les données d'entraînement des réseaux de neurones :

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

Pour obtenir des conseils sur les performances et les bonnes pratiques concernant les ensembles de données, consultez cet article. Cliquez ici pour accéder à la documentation de référence.

Principes de base de tf.data.Dataset

Les données se présentent généralement sous la forme de plusieurs fichiers (ici, des images). Vous pouvez créer un ensemble de données de noms de fichiers en appelant :

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

Vous "mappez" ensuite une fonction à chaque nom de fichier, ce qui chargera et décodera généralement le fichier en données réelles en mémoire :

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)

Pour itérer sur un ensemble de données :

for data in my_dataset:
  print(data)

Ensembles de données de tuples

Dans l'apprentissage supervisé, un ensemble de données d'entraînement est généralement constitué de paires de données d'entraînement et de réponses correctes. Pour ce faire, la fonction de décodage peut renvoyer des tuples. Vous disposerez alors d'un ensemble de données de tuples, qui seront renvoyés lorsque vous itérerez dessus. Les valeurs renvoyées sont des Tensors TensorFlow prêts à être utilisés par votre modèle. Vous pouvez appeler .numpy() sur eux pour afficher les valeurs brutes :

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

Conclusion : le chargement des images une par une est lent !

Au fur et à mesure que vous itérez sur cet ensemble de données, vous verrez que vous pouvez charger environ une à deux images par seconde. C'est trop lent ! Les accélérateurs matériels que nous utiliserons pour l'entraînement peuvent supporter un taux bien supérieur. Passez à la section suivante pour découvrir comment nous allons y parvenir.

Solution

Voici le notebook de solution. Vous pouvez l'utiliser si vous êtes bloqué.

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

Points abordés

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 Ensembles de données de tuples
• 😀 Itérer dans les ensembles de données

Veuillez prendre quelques instants pour passer en revue cette checklist.

5. Charger les données rapidement

Les accélérateurs matériels TPU (Tensor Processing Unit) que nous utiliserons dans cet atelier sont très rapides. Le défi consiste souvent à leur fournir des données assez rapidement pour les occuper. Google Cloud Storage (GCS) est capable de maintenir un débit très élevé, mais comme pour tous les systèmes de stockage cloud, l'établissement d'une connexion entraîne des échanges réseau. Il n'est donc pas idéal que nos données soient stockées sous la forme de milliers de fichiers individuels. Nous allons les regrouper dans un plus petit nombre de fichiers et utiliser la puissance de tf.data.Dataset pour lire plusieurs fichiers en parallèle.

Lecture complète

Le code qui charge les fichiers image, les redimensionne à une taille commune, puis les stocke dans 16 fichiers TFRecord se trouve dans le notebook suivant. Veuillez la lire rapidement. Il n'est pas nécessaire de l'exécuter, car des données au format TFRecord approprié seront fournies pour le reste de l'atelier de programmation.

Flower pictures to TFRecords.ipynb

Disposition idéale des données pour un débit GCS optimal

En règle générale, il est préférable de répartir vos données dans plusieurs fichiers de taille moyenne (de quelques dizaines à quelques centaines de Mo). Si vous avez trop de fichiers (des milliers, par exemple), le temps d'accès à chacun d'eux peut devenir un problème. Si vous n'avez pas assez de fichiers (un ou deux, par exemple), vous ne bénéficiez pas des avantages du streaming à partir de plusieurs fichiers en parallèle.

Format de fichier TFRecord

Le format de fichier préféré de TensorFlow pour stocker des données est le format TFRecord basé sur protobuf. D'autres formats de sérialisation fonctionneraient également, mais vous pouvez charger un ensemble de données à partir de fichiers TFRecord directement en écrivant :

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

Pour des performances optimales, il est recommandé d'utiliser le code plus complexe suivant pour lire plusieurs fichiers TFRecord à la fois. Ce code lira N fichiers en parallèle et ignorera l'ordre des données au profit de la vitesse de lecture.

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

Aide-mémoire TFRecord

Trois types de données peuvent être stockés dans les TFRecords : les chaînes d'octets (liste d'octets), les entiers de 64 bits et les nombres à virgule flottante de 32 bits. Elles sont toujours stockées sous forme de listes. Un élément de données unique sera une liste de taille 1. Vous pouvez utiliser les fonctions d'assistance suivantes pour stocker des données dans des enregistrements TFRecord.

Écrire des chaînes d'octets

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

Écrire des nombres entiers

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

flottants d'écriture

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

Écrire un TFRecord à l'aide des assistants ci-dessus

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

Pour lire les données des TFRecords, vous devez d'abord déclarer la mise en page des enregistrements que vous avez stockés. Dans la déclaration, vous pouvez accéder à n'importe quel champ nommé en tant que liste à longueur fixe ou à longueur variable :

Lecture à partir de TFRecords

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)

Extraits de code utiles :

lire des éléments de données individuels ;

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

lire des listes d'éléments de taille fixe

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

lire un nombre variable d'éléments de données

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 VarLenFeature renvoie un vecteur creux. Une étape supplémentaire est requise après le décodage du TFRecord :

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

Il est également possible d'avoir des champs facultatifs dans les TFRecords. Si vous spécifiez une valeur par défaut lors de la lecture d'un champ, cette valeur est renvoyée à la place d'une erreur si le champ est manquant.

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

Points abordés

• 🤔 Fractionner les fichiers de données pour un accès rapide depuis GCS
• 😓 comment écrire des TFRecords. (Vous avez déjà oublié la syntaxe ? (Pas de panique, vous pouvez ajouter cette page à vos favoris pour vous en servir de pense-bête.)
• 🤔 Charger un ensemble de données à partir de TFRecords à l'aide de TFRecordDataset

Veuillez prendre quelques instants pour passer en revue cette checklist.

6. Félicitations !

Vous pouvez maintenant fournir des données à un TPU. Veuillez passer à l'atelier suivant.

• [CET ATELIER] Pipelines de données à la vitesse des TPU : tf.data.Dataset et TFRecords
• Votre premier modèle Keras, avec apprentissage par transfert
• Réseaux de neurones convolutifs, avec Keras et les TPU
• Réseaux de neurones convolutifs (convnets) modernes, SqueezeNet et Xception, avec Keras et des TPU

Les TPU en pratique

Les TPU et les GPU sont disponibles sur Cloud AI Platform :

• Sur les VM Deep Learning
• Dans AI Platform Notebooks
• Dans les tâches AI Platform Training

Enfin, vos commentaires nous intéressent. N'hésitez pas à nous contacter si vous remarquez quelque chose d'inhabituel dans cet atelier ou si vous pensez qu'il devrait être amélioré. Vous pouvez envoyer vos commentaires via les problèmes GitHub [lien vers les commentaires].

Auteur : Martin Görner Twitter : @martin_gorner