Google a récemment fourni un accès gratuit à son unité de traitement des
tenseurs (TPU) sur la plate-
forme d' apprentissage automatique basée sur le
cloud du
Colaboratory . Le processeur tensor est un circuit intégré spécialisé (ASIC) développé par Google pour les tâches d'apprentissage automatique à l'aide de la bibliothèque TensorFlow. J'ai décidé d'essayer d'apprendre le réseau convolutionnel TPU sur Keras, qui reconnaît les objets dans les images CIFAR-10. Le code de solution complet peut être consulté et exécuté sur l'
ordinateur portable .
Photo cloud.google.comProcesseurs tenseur
On Habré a déjà écrit comment les TPU sont organisés (
ici ,
ici et
ici ), et aussi
pourquoi les TPU sont bien adaptés à la formation des réseaux de neurones . Par conséquent, je ne vais pas me plonger dans les détails de l'architecture TPU, mais ne considérer que les fonctionnalités qui doivent être prises en compte lors de la formation des réseaux de neurones.
Maintenant, il existe trois générations de processeurs tenseurs, les performances des TPU de dernière génération sont de 420 TFlops (des milliards d'opérations en virgule flottante par seconde), il contient 128 Go de mémoire à large bande passante. Cependant, seuls les TPU de deuxième génération sont disponibles sur le Colaboratory, qui ont 180 TFlops de performances et 64 Go de mémoire. À l'avenir, je considérerai ces TPU.
Le processeur tensor se compose de quatre puces, chacune contenant deux cœurs, un total de huit cœurs en TPU. La formation TPU est menée en parallèle sur tous les cœurs en utilisant la réplication: une copie du graphique TensorFlow avec un huitième du volume de données s'exécute sur chaque cœur.
La base du processeur tensoriel est une unité matricielle (MXU). Il utilise la structure de données astucieuse d'un
tableau systolique 128x128 pour une implémentation efficace des opérations matricielles. Par conséquent, afin de maximiser l'utilisation des ressources d'équipement TPU, la dimension du mini-échantillon ou des caractéristiques doit être un multiple de 128 (
source ). De plus, en raison de la nature du système de mémoire TPU, il est souhaitable que la dimension du mini-échantillon et des caractéristiques soit un multiple de 8.
Plateforme de collaboration
Colaboratory est la plate-forme cloud de Google pour faire progresser la technologie d'apprentissage automatique. Vous pouvez obtenir gratuitement une machine virtuelle avec les bibliothèques populaires installées TensorFlow, Keras, sklearn, pandas, etc. La chose la plus pratique est que vous pouvez exécuter des ordinateurs portables similaires à Jupyter sur le Colaboratory. Les ordinateurs portables sont stockés sur Google Drive, vous pouvez les distribuer et même organiser la collaboration. Voici à quoi ressemble le portable du Colaboratoire (la
photo est cliquable ):
Vous écrivez le code dans un navigateur sur un ordinateur portable, il s'exécute sur une machine virtuelle dans Google Cloud. La voiture vous est délivrée pour 12 heures, après quoi elle s'arrête. Cependant, rien ne vous empêche de démarrer une autre machine virtuelle et de travailler encore 12 heures. N'oubliez pas qu'après l'arrêt de la machine virtuelle, toutes les données qu'elle contient sont supprimées. Par conséquent, n'oubliez pas de sauvegarder les données nécessaires sur votre ordinateur ou Google Drive, et après avoir redémarré la machine virtuelle, téléchargez à nouveau.
Les instructions détaillées pour travailler sur la plateforme du Colaboratoire sont
ici ,
ici et
ici .
Connectez le processeur tensoriel au Colaboratory
Par défaut, Colaboratory n'utilise pas d'accélérateurs de calcul GPU ou TPU. Vous pouvez les connecter dans le menu Runtime -> Changer le type d'exécution -> Accélérateur matériel. Dans la liste qui apparaît, sélectionnez "TPU":
Après avoir choisi le type d'accélérateur, la machine virtuelle à laquelle l'ordinateur portable Colaboratory est connecté redémarrera et TPU sera disponible.
Si vous avez téléchargé des données sur la machine virtuelle, elles seront supprimées lors du redémarrage. Vous devez télécharger à nouveau les données.
Keras Neural Network pour la reconnaissance CIFAR-10
À titre d'exemple, essayons de former un réseau neuronal Keras sur TPU qui reconnaît les images de l'
ensemble de données CIFAR-10 . Il s'agit d'un jeu de données populaire contenant de petites images d'objets de 10 classes: avion, voiture, oiseau, chat, cerf, chien, grenouille, cheval, bateau et camion. Les classes ne se croisent pas, chaque objet de l'image appartient à une seule classe.
Téléchargez l'ensemble de données CIFAR-10 à l'aide de Keras:
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
Pour créer un réseau neuronal, j'ai obtenu une fonction distincte. Nous allons créer deux fois le même modèle: la première version du modèle pour TPU, sur laquelle nous nous entraînerons, et la seconde pour le CPU, où nous reconnaîtrons les objets.
def create_model(): input_layer = Input(shape=(32, 32, 3), dtype=tf.float32, name='Input') x = BatchNormalization()(input_layer) x = Conv2D(32, (3, 3), padding='same', activation='relu')(x) x = Conv2D(32, (3, 3), activation='relu', padding='same')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Dropout(0.25)(x) x = BatchNormalization()(x) x = Conv2D(64, (3, 3), padding='same', activation='relu')(x) x = Conv2D(64, (3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Dropout(0.25)(x) x = Flatten()(x) x = Dense(512, activation='relu')(x) x = Dropout(0.5)(x) output_layer = Dense(10, activation='softmax')(x) model = Model(inputs=[input_layer], outputs=[output_layer]) model.compile( optimizer=tf.train.AdamOptimizer(0.001), loss=tf.keras.losses.sparse_categorical_crossentropy, metrics=['sparse_categorical_accuracy']) return model
Jusqu'à présent, les optimiseurs Keras ne peuvent pas être utilisés sur les TPU, par conséquent, lors de la compilation d'un modèle, l'optimiseur de TensorFlow est spécifié.
Nous créons un modèle Keras pour le CPU, que nous convertirons à l'étape suivante en un modèle pour TPU:
cpu_model = create_model()
Convertir le réseau neuronal Keras en modèle TPU
Les modèles sur Keras et TensorFlow peuvent être formés sur le GPU sans aucune modification. Vous ne pouvez pas faire cela sur TPU jusqu'à présent, vous devez donc convertir le modèle que nous avons créé en un modèle pour TPU.
Vous devez d'abord savoir où se trouve le TPU à notre disposition. Sur la plate-forme Colaboratory, cela peut être fait avec la commande suivante:
TPU_WORKER = 'grpc://' + os.environ['COLAB_TPU_ADDR']
Dans mon cas, l'adresse TPU s'est avérée être la suivante -
grpc://10.102.233.146:8470 . Les adresses étaient différentes pour différents lancements.
Vous pouvez maintenant obtenir le modèle pour TPU en utilisant la fonction
keras_to_tpu_model :
tf.logging.set_verbosity(tf.logging.INFO) tpu_model = tf.contrib.tpu.keras_to_tpu_model( cpu_model, strategy=tf.contrib.tpu.TPUDistributionStrategy( tf.contrib.cluster_resolver.TPUClusterResolver(TPU_WORKER)))
La première ligne inclut la journalisation au niveau Info. Voici le journal de conversion du modèle:
INFO:tensorflow:Querying Tensorflow master (b'grpc://10.102.233.146:8470') for TPU system metadata.
INFO:tensorflow:Found TPU system:
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
...
WARNING:tensorflow:tpu_model (from tensorflow.contrib.tpu.python.tpu.keras_support) is experimental and may change or be removed at any time, and without warning.Vous pouvez voir que le TPU a été trouvé à l'adresse que nous avons indiquée plus tôt, il a 8 cœurs. Nous voyons également un avertissement
tpu_model que
tpu_model est expérimental et peut être modifié ou supprimé à tout moment. J'espère qu'avec le temps, il sera possible de former des modèles Keras directement sur TPU sans aucune conversion.
Nous formons le modèle sur TPU
Le modèle de TPU peut être formé de la manière habituelle pour Keras en appelant la méthode
fit :
history = tpu_model.fit(x_train, y_train, batch_size=128*8, epochs=50, verbose=2)
Quelles sont les fonctionnalités ici. Nous nous souvenons que pour utiliser efficacement les TPU, la taille du mini-échantillon doit être un multiple de 128. De plus, la formation est effectuée sur chaque cœur de TPU en utilisant un huitième de toutes les données du mini-échantillon. Par conséquent, nous avons défini la taille du mini-échantillon pendant la formation sur 128 * 8, nous obtenons 128 images pour chaque noyau TPU. Vous pouvez utiliser une taille plus grande, par exemple 256 ou 512, puis les performances seront plus élevées.
Dans mon cas, la formation d'une époque nécessite en moyenne 6 s.
La qualité de l'éducation à la 50e ère:
Epoch 50/50
- 6s - loss: 0.2727 - sparse_categorical_accuracy: 0.9006La part des bonnes réponses aux données pour la formation était de 90,06%. Nous vérifions la qualité des données de test à l'aide de TPU:
scores = tpu_model.evaluate(x_test, y_test, verbose=0, batch_size=batch_size * 8) print(" : %.2f%%" % (scores[1]*100))
: 80.79%Enregistrez maintenant les poids du modèle entraîné:
tpu_model.save_weights("cifar10_model.h5")
TensorFlow nous enverra un message indiquant que les poids sont transférés du TPU au CPU:
INFO:tensorflow:Copying TPU weights to the CPUIl est à noter que les poids du réseau formé ont été enregistrés sur le disque de la machine virtuelle du Colaboratory. Lorsque la machine virtuelle est arrêtée, toutes les données qu'elle contient seront effacées. Si vous ne voulez pas perdre de poids entraînés, enregistrez-les sur votre ordinateur:
from google.colab import files files.download("cifar10_model.h5")
Reconnaître les objets sur le CPU
Essayons maintenant d'utiliser un modèle formé sur TPU afin de reconnaître les objets dans les images en utilisant le CPU. Pour ce faire, créez à nouveau le modèle et chargez-y les poids formés sur TPU:
model = create_model() model.load_weights("cifar10_model.h5")
Le modèle est prêt à l'emploi sur le processeur central. Essayons de reconnaître avec son aide l'une des images de la suite de tests CIFAR-10:
index=111 plt.imshow(toimage(x_test[index])) plt.show()
L'image est petite, mais vous pouvez comprendre qu'il s'agit d'un avion. Nous commençons la reconnaissance:
Nous obtenons une liste des valeurs de sortie des neurones, presque toutes sont proches de zéro, à l'exception de la première valeur, qui correspond au plan.
[[9.81738389e-01 2.91262069e-07 1.82225723e-02 9.78524668e-07
5.89265142e-07 6.76223244e-10 1.03252004e-10 9.23009047e-09
3.71878523e-05 3.16599618e-08]]
La reconnaissance a réussi!
Résumé
Il a été possible de démontrer l'opérabilité du TPU sur la plate-forme Colaboratory, il peut être utilisé pour la formation de réseaux de neurones sur Keras. Cependant, l'ensemble de données CIFAR-10 est trop petit; il ne suffit pas de charger complètement les ressources TPU. L'accélération par rapport au GPU s'est avérée petite (vous pouvez vous vérifier en choisissant le GPU comme accélérateur au lieu du TPU et en recyclant à nouveau le modèle).
Sur Habré il y a un article dans lequel on
mesure les performances des TPU et GPU V100 sur la formation du réseau ResNet-50 . Sur cette tâche, le TPU a montré les mêmes performances que les quatre GPU V100. C'est bien que Google fournisse gratuitement un accélérateur d'apprentissage de réseau neuronal aussi puissant!
Vidéo montrant la formation du réseau neuronal Keras sur TPU.
Liens utiles
- Ordinateur portable de laboratoire avec code d'apprentissage complet du modèle TPU Keras .
- Cahier de collaboration avec un exemple de formation Keras TPU pour reconnaître les vêtements et les chaussures de Fashion MNIST .
- Processeurs tenseur dans Google Cloud .
- Caractéristiques de l'architecture et utilisation des processeurs tenseurs .