Les nouveautés en TensorFlow 2.4

Tensorflow Everywhere - User Groups in Sub -saharan Africa - 27/02/2021

Transcript

1. 1 Yannick Serge Obam ML GDE Les nouveautés en TensorFlow 2.4 1 @OBAMSerge
2. Nouvelles fonctionnalités Construction des modèles • tf.experimental.numpy • Keras Preprocessing layers • TF Recommenders Performance et debogage • Nouvelle fonctionalités en tf.data: Service et Snapshot • Améliorations de TensorFlow Profiler 2
3. 3 tf.experimental.numpy 3 Accélérerz NumPy à l’aide de TensorFlow
4. NumPy fonctionne avec TensorFlow Maintenant vous pouvez : • Executer un sous ensemble Nump sur CPU / GPU / TPU • Utiliser le code numpy avec les APIs TensorFlow (tf.linalg, tf.signal, tf.data, tf.keras, tf.distribute) • Compiler le code NumPy à l’aide de `tf.function` et le vectoriser grace à `tf.vectorized_map` Visitez tensorflow.org/guide/tf_numpy pour plus informations 4
5. # Available in TensorFlow Nightly # `pip install tf-nightly` import tensorflow.experimental.numpy as tnp # Write NumPy Code, accelerated by TensorFlow on GPUs x = tnp.random.randn(100, 100).clip(-2, 2) print(x.data.device) /job:localhost/replica:0/task:0/device:GPU:0 # Note that TensorFlow ND Arrays can be passed to APIs expecting NumPy arrays. # This works since ND Array class implements `__array__` interface defined by NumPy. # The code below demonstrates matplotlib plotting on ND Array. 5
6. import tensorflow.experimental.numpy as tnp # Write NumPy Code, accelerated by TensorFlow on GPUs x = tnp.random.randn(100, 100).clip(-2, 2) print(x.data.device) /job:localhost/replica:0/task:0/device:GPU:0 # Note that TensorFlow ND Arrays can be passed to APIs expecting NumPy arrays. # This works since ND Array class implements `__array__` interface defined by NumPy. # The code below demonstrates matplotlib plotting on ND Array. import matplotlib.pyplot as plt plt.hist(x.ravel()) 6
7. Example de Performance 7 Pour plus d’informations : tensorflow.org/guide/tf_numpy
8. # Use NumPy code in input pipelines dataset = tf.data.Dataset.from_tensor_slices(tnp.random.randn(1000, 1024)).map( lambda z: z.clip(-1, 1)).batch(100) 8
9. # Use NumPy code in input pipelines dataset = tf.data.Dataset.from_tensor_slices(tnp.random.randn(1000, 1024)).map( lambda z: z.clip(-1, 1)).batch(100) # Compute gradients through NumPy code def grad(x, wt): with tf.GradientTape() as tape: tape.watch(wt) output = tnp.dot(x, wt) output = 1 / 1 + tnp.exp(-output) return tape.gradient(tnp.sum(output), wt) # Also see tape.batch_jacobian 9
10. # Use NumPy code in input pipelines dataset = tf.data.Dataset.from_tensor_slices(tnp.random.randn(1000, 1024)).map( lambda z: z.clip(-1, 1)).batch(100) # Compute gradients through NumPy code def grad(x, wt): with tf.GradientTape() as tape: tape.watch(wt) output = tnp.dot(x, wt) output = 1 / 1 + tnp.exp(-output) return tape.gradient(tnp.sum(output), wt) # Also see tape.batch_jacobian wt = tnp.random.randn(1024, 1024) # Write code with python control flow for inputs in dataset: gradients = grad(inputs, wt) 10
11. # Use NumPy code in input pipelines dataset = tf.data.Dataset.from_tensor_slices(tnp.random.randn(1000, 1024)).map( lambda z: z.clip(-1, 1)).batch(100) # Compute gradients through NumPy code def grad(x, wt): with tf.GradientTape() as tape: tape.watch(wt) output = tnp.dot(x, wt) output = tf.math.sigmoid(output) # Interleave with TensorFlow APIs return tape.gradient(tnp.sum(output), wt) def per_example_grad(x, wt): return tf.map_fn(lambda y: grad(y, wt), x) # Interleave with TensorFlow APIs wt = tnp.random.randn(1024, 1024) # Write idiomatic code, with python control flow for inputs in dataset: per_example_gradients = per_example_grad(inputs, wt) 11
12. # Use NumPy code in input pipelines dataset = tf.data.Dataset.from_tensor_slices(tnp.random.randn(1000, 1024)).map( lambda z: z.clip(-1, 1)).batch(100) # Compute gradients through NumPy code def grad(x, wt): with tf.GradientTape() as tape: tape.watch(wt) output = tnp.dot(x, wt) output = tf.math.sigmoid(output) return tape.gradient(tnp.sum(output), wt) # Speedup NumPy code with compilation and vectorization @tf.function # Compilation def per_example_grad(x, wt): return tf.vectorized_map(lambda y: grad(y, wt), x) # Auto-vectorization wt = tnp.random.randn(1024, 1024) # Write idiomatic code, with python control flow for inputs in dataset: per_example_gradients = per_example_grad(inputs, wt) 12
13. 13 Keras preprocessing layers 13 Construire de bout en bout des modèles
14. • Lors de la création d'un modèle pour classer du texte, vous devez écrire une logique de prétraitement pour la standardisation, la tokenisation et la vectorisation. • Pour déployer ce modèle, vous devez vous assurer que le texte est prétraité exactement de la même manière. • Cela peut entraîner une duplication de code pour une logique complexe, qui est difficile à maintenir. Background La logique de prétraitement prend du temps
15. Couches de prétraitement Keras Inclure la logique de prétraitement en tant que couches dans votre modèle. Vous permet de: • Enregistrez des modèles qui prennent des images brutes, du texte ou des données structurées en entrée • Déployez des modèles sans avoir à réimplémenter la logique de prétraitement côté serveur • Exécutez facilement l'augmentation des données sur le GPU
16. # Create a text preprocessing layer vectorize_layer = TextVectorization( max_tokens=max_features, output_mode='int', output_sequence_length=sequence_length)
17. # Create a text preprocessing layer vectorize_layer = TextVectorization( max_tokens=max_features, output_mode='int', output_sequence_length=sequence_length) # Adapt it your vocabulary vectorize_layer.adapt(train_texts)
18. # Create a text preprocessing layer vectorize_layer = TextVectorization( max_tokens=max_features, output_mode='int', output_sequence_length=sequence_length) # Adapt it your vocabulary vectorize_layer.adapt(train_texts) # Include it inside your model model = tf.keras.Sequential([ vectorize_layer, layers.Embedding(max_features + 1, 32), layers.Dropout(0.2), layers.GlobalAveragePooling1D(), layers.Dropout(0.2), layers.Dense(1)])
19. # Create a text preprocessing layer vectorize_layer = TextVectorization( max_tokens=max_features, output_mode='int', output_sequence_length=sequence_length) # Adapt it your vocabulary vectorize_layer.adapt(train_texts) # Include it inside your model model = tf.keras.Sequential([ vectorize_layer, layers.Embedding(max_features + 1, 32), layers.Dropout(0.2), layers.GlobalAveragePooling1D(), layers.Dropout(0.2), layers.Dense(1)]) # Save a model that accepts raw strings as input model.save('path/to/location')
20. Text • Standardiser, tokenizer , et vectoriser Images • Redimenssionner, normaliser et exécuter l'augmentation des données sur GPU Structured data • Prise en charge des variables numériques et catégoriels. One hot encoding, hachage..;. Prise en charge immédiate des types de données courants API doc: tensorflow.org/api_docs/python/tf/keras/layers/experimental/preprocessing
21. Pour apprendre plus Guide du développeur et exemples complets • keras.io/guides/preprocessing_layers/ • tensorflow.org/tutorials/images/classification, • tensorflow.org/tutorials/keras/text_classification • keras.io/examples/structured_data/structured_data_classification_from_scratch/
22. 22 TensorFlow Recommenders 22 Construire les systemes de recommandations avec TensorFlow
23. Two-Tower Recommender Example 23
24. import tensorflow_datasets as tfds import tensorflow_recommenders as tfrs # Data on ratings. ratings = tfds.load("movielens/100k-ratings", split="train") # Movie features. movies = tfds.load("movielens/100k-movies", split="train")
25. import tensorflow_datasets as tfds import tensorflow_recommenders as tfrs # Data on ratings. ratings = tfds.load("movielens/100k-ratings", split="train") # Movie features. movies = tfds.load("movielens/100k-movies", split="train") # The user and movie models can be arbitrary Keras models. user_model = tf.keras.Sequential([ tf.keras.layers.Embedding(1000, 32), tf.keras.layers.Dense(64, activation=”relu”) ]) movie_model = tf.keras.layers.Embedding(1700, 64)
26. 26 model = MovielensModel( user_model=user_model, movie_model=movie_model, # The retrieval task will optimize for retrieving the best movies. task=tfrs.tasks.Retrieval( # Model retrieval accuracy measured across all recommendable movies. metrics=tfrs.metrics.FactorizedTopK( candidates=movies.batch(128).map(movie_model) )) )
27. 27 # Train the model. model.compile(optimizer=tf.keras.optimizers.Adagrad(0.5)) model.fit(ratings.batch(4096), epochs=3) # Evaluate retrieval performance. model.evaluate(ratings.batch(4096))
28. En savoir plus sur TensorFlow recommenders Visitez tensorflow.org/recommenders pour les tutoriels et guides 28
29. Snapshot et service 29 Nouveautés de tf.data?
30. • tf.data.Dataset.prefetch • tf.data.Dataset.cache Moyens simples pour améliorer les performances 30
31. Nouvelles fonctionnalités • tf.data.snapshot peut vous aider à éviter le traitement répétitif des données • tf.data.service peut vous aider à mettre à l'échelle horizontalement le traitement des données • Nouvelle API pour une sauvegarde et un chargement efficaces des ensembles de données arbitraires tf.data 31
32. tf.data snapshot 32 Réutiliser le calcul computed before? input dataset read from disk (fast path) write to disk yes no
33. import tensorflow as tf def preprocess(record): ... dataset = tf.data.TFRecordDataset(".../*.tfrecord") dataset = dataset.map(preprocess) dataset = dataset.shuffle(buffer_size=1024) dataset = dataset.batch(batch_size=32) dataset = dataset.prefetch() model = tf.keras.Model(...) model.fit(dataset)
34. import tensorflow as tf def preprocess(record): ... dataset = tf.data.TFRecordDataset(".../*.tfrecord") dataset = dataset.map(preprocess) dataset = dataset.snapshot(“/path/to/snapshot_dir”) dataset = dataset.shuffle(buffer_size=1024) dataset = dataset.batch(batch_size=32) dataset = dataset.prefetch() model = tf.keras.Model(...) model.fit(dataset) snapshot transformation
35. import tensorflow as tf def preprocess(record): ... dataset = tf.data.TFRecordDataset(".../*.tfrecord") dataset = dataset.shuffle(buffer_size=1024) dataset = dataset.map(preprocess) dataset = dataset.batch(batch_size=32) dataset = dataset.prefetch() model = tf.keras.Model(...) model.fit(dataset)
36. import tensorflow as tf def preprocess(record): ... dataset = tf.data.TFRecordDataset(".../*.tfrecord") dataset = dataset.shuffle(buffer_size=1024) dataset = dataset.map(preprocess) dataset = dataset.batch(batch_size=32) dataset = dataset.distribute(“<master_address>”) dataset = dataset.prefetch() model = tf.keras.Model(...) model.fit(dataset) distribute transformation
37. Points clés à retenir • prefetcch et cache accélèrent votre pipeline avec une seule ligne de code • Snapshot permet la réutilisation du prétraitement des données • service facilite le prétraitement des données distribuées
38. 38 TensorFlow Profiler
39. Memory Profile Tool
40. Python Tracer
41. TensorFlow propose de nombreuses nouvelles fonctionnalités pour vous aider à créer de nouveaux modèles et à obtenir les performances dont vous avez besoin. • tf.experimental.numpy • Keras preprocessing layers • librairie TF Recommenders l • Les ameliorations de TensorFlow Profiler En résumé 41
42. Apprendre encore plus • tensorflow.org/tutorials • tensorflow.org/guide Restez à jour • blog.tensorflow.org • youtube.com/tensorflow • twitter.com/tensorflow Merci 42