Essayez ceci si votre code TensorFlow est lent

Vue d'ensemble du contenu Vue d’ensemble établissement Profiter des graphiques Utilisation de tf.function Voir le speed-up Quand est un tf.function tracing ? Les prochaines étapes Vue d’ensemble Ce guide va sous la surface de TensorFlow et Keras pour démontrer comment TensorFlow fonctionne. . Collection des guides de Keras Dans ce guide, vous apprendrez comment TensorFlow vous permet de faire des changements simples à votre code pour obtenir des graphiques, comment les graphiques sont stockés et représentés, et comment vous pouvez les utiliser pour accélérer vos modèles. Remarque : Pour ceux d’entre vous qui ne connaissent que TensorFlow 1.x, ce guide démontre une vision très différente des graphiques. Pour ceux d’entre vous qui ne connaissent que TensorFlow 1.x, ce guide démontre une vision très différente des graphiques. Note: vous permet de passer de l'exécution à l'exécution graphique. Pour une spécification plus complète de Allez à la Le Guide. This is a big-picture overview that covers how tf.function tf.function Une meilleure performance avec tf.function Qu’est-ce que les graphes ? Dans les trois guides précédents, vous avez exécuté TensorFlow Cela signifie que les opérations TensorFlow sont exécutées par Python, opération par opération, et que les résultats sont retournés à Python. eagerly Alors que l'exécution exigeante a plusieurs avantages uniques, l'exécution graphique permet la portabilité en dehors de Python et a tendance à offrir une meilleure performance. signifie que les calculs de tensor sont exécutés comme un Parfois désigné comme un Ou tout simplement un « graphique ». Graph execution Graphique TensorFlow tf.Graph objets, qui représentent des unités de calcul; et objets, qui représentent les unités de données qui circulent entre les opérations. Puisque ces graphiques sont des structures de données, ils peuvent être enregistrés, exécutés et restaurés sans le code Python d'origine. Graphs are data structures that contain a set of tf.Operation tf.Tensor tf.Graph Voici à quoi ressemble un graphique TensorFlow représentant un réseau neuronal à deux couches lorsqu'il est visualisé dans TensorBoard: Les avantages des graphes Avec un graphique, vous avez beaucoup de flexibilité. Vous pouvez utiliser votre graphique TensorFlow dans des environnements qui n'ont pas d'interprète Python, tels que les applications mobiles, les appareils embarqués et les serveurs backend. Exporté à partir de Python. Des modèles sauvés Les graphiques sont également facilement optimisés, permettant au compilateur d'effectuer des transformations telles que: Déduisez statiquement la valeur des tensors en pliant des nœuds constants dans votre calcul (« pliage constant »). Sous-parts séparés d'un calcul qui sont indépendants et les divisent entre les fils ou les appareils. Simplifiez les opérations arithmétiques en éliminant les sous-expressions communes. Il existe tout un système d’optimisation. pour effectuer ceci et d'autres vitesses. Grapplers En bref, les graphiques sont extrêmement utiles et laissent votre TensorFlow fonctionner et courir et courir efficacement . fast in parallel on multiple devices Cependant, vous voulez toujours définir vos modèles d'apprentissage automatique (ou d'autres calculs) en Python pour la commodité, puis construire automatiquement des graphiques lorsque vous en avez besoin. établissement Importer les bibliothèques nécessaires : import tensorflow as tf import timeit from datetime import datetime 2024-08-15 01:23:58.511668: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2024-08-15 01:23:58.532403: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2024-08-15 01:23:58.538519: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered Profiter des graphiques Créer et exécuter un graphique dans TensorFlow en utilisant soit en tant qu’appel direct, soit en tant que décorateur. prend une fonction régulière comme entrée et renvoie un Le . est un appelable Python qui construit des graphiques TensorFlow à partir de la fonction Python. Tout comme son équivalent Python. tf.function tf.function tf.types.experimental.PolymorphicFunction A PolymorphicFunction tf.function # Define a Python function. def a_regular_function(x, y, b): x = tf.matmul(x, y) x = x + b return x # The Python type of `a_function_that_uses_a_graph` will now be a # `PolymorphicFunction`. a_function_that_uses_a_graph = tf.function(a_regular_function) # Make some tensors. x1 = tf.constant([[1.0, 2.0]]) y1 = tf.constant([[2.0], [3.0]]) b1 = tf.constant(4.0) orig_value = a_regular_function(x1, y1, b1).numpy() # Call a `tf.function` like a Python function. tf_function_value = a_function_that_uses_a_graph(x1, y1, b1).numpy() assert(orig_value == tf_function_value) WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1723685041.078349 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.081709 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.084876 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.088691 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.100124 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.103158 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.106072 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.109491 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.112991 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.115870 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.118785 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685041.122189 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.369900 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.372045 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.374040 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.376123 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.378174 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.380184 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.382098 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.384064 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.386002 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.387981 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.389902 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.391922 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.431010 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.433093 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.435050 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.437074 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.439053 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.441049 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.442965 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.444941 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.446890 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.450623 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.453482 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1723685042.455908 10585 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 A l’extérieur, a ressemble à une fonction normale que vous écrivez en utilisant les opérations TensorFlow. Cependant, il est Le sous-jacent s derrière un API (apprendre plus dans le C’est ainsi qu’a est en mesure de vous donner les avantages de l'exécution de graphiques, tels que la vitesse et la déploiabilité (voir au dessus) tf.function en dessous très différent PolymorphicFunction encapsulates several tf.Graph Polymorphisme tf.function Les avantages des graphes s’applique à une fonction : tf.function et toutes les autres fonctions qu'il appelle def inner_function(x, y, b): x = tf.matmul(x, y) x = x + b return x # Using the `tf.function` decorator makes `outer_function` into a # `PolymorphicFunction`. @tf.function def outer_function(x): y = tf.constant([[2.0], [3.0]]) b = tf.constant(4.0) return inner_function(x, y, b) # Note that the callable will create a graph that # includes `inner_function` as well as `outer_function`. outer_function(tf.constant([[1.0, 2.0]])).numpy() array([[12.]], dtype=float32) Si vous avez utilisé TensorFlow 1.x, vous remarquerez que vous n'avez jamais eu besoin de définir un ou . Placeholder tf.Session Convertir les fonctions Python en graphiques Toute fonction que vous écrivez avec TensorFlow contiendra un mélange d'opérations TF intégrées et de logique Python, telles que: Les lignes, les loops, , à , à Alors que les opérations TensorFlow sont facilement capturées par un , La logique spécifique à Python doit subir une étape supplémentaire pour faire partie du graphique. Utilisez une bibliothèque appelée AutoGraph ( Convertir le code Python en code générateur de graphiques. if-then break return continue tf.Graph tf.function tf.autograph def simple_relu(x): if tf.greater(x, 0): return x else: return 0 # Using `tf.function` makes `tf_simple_relu` a `PolymorphicFunction` that wraps # `simple_relu`. tf_simple_relu = tf.function(simple_relu) print("First branch, with graph:", tf_simple_relu(tf.constant(1)).numpy()) print("Second branch, with graph:", tf_simple_relu(tf.constant(-1)).numpy()) First branch, with graph: 1 Second branch, with graph: 0 Bien qu'il soit peu probable que vous ayez besoin de voir les graphiques directement, vous pouvez inspecter les sorties pour vérifier les résultats exacts. # This is the graph-generating output of AutoGraph. print(tf.autograph.to_code(simple_relu)) def tf__simple_relu(x): with ag__.FunctionScope('simple_relu', 'fscope', ag__.ConversionOptions(recursive=True, user_requested=True, optional_features=(), internal_convert_user_code=True)) as fscope: do_return = False retval_ = ag__.UndefinedReturnValue() def get_state(): return (do_return, retval_) def set_state(vars_): nonlocal do_return, retval_ (do_return, retval_) = vars_ def if_body(): nonlocal do_return, retval_ try: do_return = True retval_ = ag__.ld(x) except: do_return = False raise def else_body(): nonlocal do_return, retval_ try: do_return = True retval_ = 0 except: do_return = False raise ag__.if_stmt(ag__.converted_call(ag__.ld(tf).greater, (ag__.ld(x), 0), None, fscope), if_body, else_body, get_state, set_state, ('do_return', 'retval_'), 2) return fscope.ret(retval_, do_return) # This is the graph itself. print(tf_simple_relu.get_concrete_function(tf.constant(1)).graph.as_graph_def()) node { name: "x" op: "Placeholder" attr { key: "_user_specified_name" value { s: "x" } } attr { key: "dtype" value { type: DT_INT32 } } attr { key: "shape" value { shape { } } } } node { name: "Greater/y" op: "Const" attr { key: "dtype" value { type: DT_INT32 } } attr { key: "value" value { tensor { dtype: DT_INT32 tensor_shape { } int_val: 0 } } } } node { name: "Greater" op: "Greater" input: "x" input: "Greater/y" attr { key: "T" value { type: DT_INT32 } } } node { name: "cond" op: "StatelessIf" input: "Greater" input: "x" attr { key: "Tcond" value { type: DT_BOOL } } attr { key: "Tin" value { list { type: DT_INT32 } } } attr { key: "Tout" value { list { type: DT_BOOL type: DT_INT32 } } } attr { key: "_lower_using_switch_merge" value { b: true } } attr { key: "_read_only_resource_inputs" value { list { } } } attr { key: "else_branch" value { func { name: "cond_false_31" } } } attr { key: "output_shapes" value { list { shape { } shape { } } } } attr { key: "then_branch" value { func { name: "cond_true_30" } } } } node { name: "cond/Identity" op: "Identity" input: "cond" attr { key: "T" value { type: DT_BOOL } } } node { name: "cond/Identity_1" op: "Identity" input: "cond:1" attr { key: "T" value { type: DT_INT32 } } } node { name: "Identity" op: "Identity" input: "cond/Identity_1" attr { key: "T" value { type: DT_INT32 } } } library { function { signature { name: "cond_false_31" input_arg { name: "cond_placeholder" type: DT_INT32 } output_arg { name: "cond_identity" type: DT_BOOL } output_arg { name: "cond_identity_1" type: DT_INT32 } } node_def { name: "cond/Const" op: "Const" attr { key: "dtype" value { type: DT_BOOL } } attr { key: "value" value { tensor { dtype: DT_BOOL tensor_shape { } bool_val: true } } } } node_def { name: "cond/Const_1" op: "Const" attr { key: "dtype" value { type: DT_BOOL } } attr { key: "value" value { tensor { dtype: DT_BOOL tensor_shape { } bool_val: true } } } } node_def { name: "cond/Const_2" op: "Const" attr { key: "dtype" value { type: DT_INT32 } } attr { key: "value" value { tensor { dtype: DT_INT32 tensor_shape { } int_val: 0 } } } } node_def { name: "cond/Const_3" op: "Const" attr { key: "dtype" value { type: DT_BOOL } } attr { key: "value" value { tensor { dtype: DT_BOOL tensor_shape { } bool_val: true } } } } node_def { name: "cond/Identity" op: "Identity" input: "cond/Const_3:output:0" attr { key: "T" value { type: DT_BOOL } } } node_def { name: "cond/Const_4" op: "Const" attr { key: "dtype" value { type: DT_INT32 } } attr { key: "value" value { tensor { dtype: DT_INT32 tensor_shape { } int_val: 0 } } } } node_def { name: "cond/Identity_1" op: "Identity" input: "cond/Const_4:output:0" attr { key: "T" value { type: DT_INT32 } } } ret { key: "cond_identity" value: "cond/Identity:output:0" } ret { key: "cond_identity_1" value: "cond/Identity_1:output:0" } attr { key: "_construction_context" value { s: "kEagerRuntime" } } arg_attr { key: 0 value { attr { key: "_output_shapes" value { list { shape { } } } } } } } function { signature { name: "cond_true_30" input_arg { name: "cond_identity_1_x" type: DT_INT32 } output_arg { name: "cond_identity" type: DT_BOOL } output_arg { name: "cond_identity_1" type: DT_INT32 } } node_def { name: "cond/Const" op: "Const" attr { key: "dtype" value { type: DT_BOOL } } attr { key: "value" value { tensor { dtype: DT_BOOL tensor_shape { } bool_val: true } } } } node_def { name: "cond/Identity" op: "Identity" input: "cond/Const:output:0" attr { key: "T" value { type: DT_BOOL } } } node_def { name: "cond/Identity_1" op: "Identity" input: "cond_identity_1_x" attr { key: "T" value { type: DT_INT32 } } } ret { key: "cond_identity" value: "cond/Identity:output:0" } ret { key: "cond_identity_1" value: "cond/Identity_1:output:0" } attr { key: "_construction_context" value { s: "kEagerRuntime" } } arg_attr { key: 0 value { attr { key: "_output_shapes" value { list { shape { } } } } attr { key: "_user_specified_name" value { s: "x" } } } } } } versions { producer: 1882 min_consumer: 12 } La plupart du temps, fonctionnera sans considérations particulières. cependant, il y a quelques avertissements, et le Le guide peut aider ici, ainsi que le . tf.function tf.function Autographe de référence complète Polymorphisme : 1 Beaucoup de graphiques tf.function à est spécialisée dans un type spécifique d'entrée (par exemple, des tensors avec un Des objets avec le même ) de tf.Graph dtype id() Chaque fois que vous appelez un avec un ensemble d'arguments qui ne peuvent être traités par aucun de ses graphiques existants (tels que les arguments avec de nouveaux ou des formes incompatibles), il crée une nouvelle specialized to those new arguments. The type specification of a Les entrées sont représentées par Elle est également appelée la Pour plus d'informations sur une nouvelle est générée, comment cela peut être contrôlé, et comment Cela peut être utile, allez à la Section de la Le Guide. tf.function dtypes tf.Graph tf.Graph tf.types.experimental.FunctionType signature tf.Graph FunctionType Les règles du tracking Une meilleure performance avec tf.function Le Boutique Les correspondant à cette signature dans un Le . peut être considérée comme un enveloppe autour d'une . tf.function tf.Graph ConcreteFunction A ConcreteFunction tf.Graph @tf.function def my_relu(x): return tf.maximum(0., x) # `my_relu` creates new graphs as it observes different input types. print(my_relu(tf.constant(5.5))) print(my_relu([1, -1])) print(my_relu(tf.constant([3., -3.]))) tf.Tensor(5.5, shape=(), dtype=float32) tf.Tensor([1. 0.], shape=(2,), dtype=float32) tf.Tensor([3. 0.], shape=(2,), dtype=float32) Si le a déjà été appelé avec les mêmes types d'entrée, il ne crée pas une nouvelle . tf.function tf.Graph # These two calls do *not* create new graphs. print(my_relu(tf.constant(-2.5))) # Input type matches `tf.constant(5.5)`. print(my_relu(tf.constant([-1., 1.]))) # Input type matches `tf.constant([3., -3.])`. tf.Tensor(0.0, shape=(), dtype=float32) tf.Tensor([0. 1.], shape=(2,), dtype=float32) Parce qu'il est soutenu par plusieurs graphiques, a est (comme le suggère le nom "PolymorphicFunction") Cela lui permet de prendre en charge plus de types d'entrée qu'un seul. could represent, and to optimize each Pour une meilleure performance. tf.function polymorphic tf.Graph tf.Graph # There are three `ConcreteFunction`s (one for each graph) in `my_relu`. # The `ConcreteFunction` also knows the return type and shape! print(my_relu.pretty_printed_concrete_signatures()) Input Parameters: x (POSITIONAL_OR_KEYWORD): TensorSpec(shape=(), dtype=tf.float32, name=None) Output Type: TensorSpec(shape=(), dtype=tf.float32, name=None) Captures: None Input Parameters: x (POSITIONAL_OR_KEYWORD): List[Literal[1], Literal[-1]] Output Type: TensorSpec(shape=(2,), dtype=tf.float32, name=None) Captures: None Input Parameters: x (POSITIONAL_OR_KEYWORD): TensorSpec(shape=(2,), dtype=tf.float32, name=None) Output Type: TensorSpec(shape=(2,), dtype=tf.float32, name=None) Captures: None Utiliser tf. fonction tf. fonction Jusqu'à présent, vous avez appris à convertir une fonction Python en un graphique simplement en utilisant as a decorator or wrapper. But in practice, getting fonctionner correctement peut être compliqué! Dans les sections suivantes, vous apprendrez comment faire fonctionner votre code comme prévu avec . tf.function tf.function tf.function Exécution graphique vs. exécution désirée Le code en a peut être exécuté à la fois avec envie et comme graphique. par défaut, Exécuter son code comme un graphique : tf.function tf.function @tf.function def get_MSE(y_true, y_pred): sq_diff = tf.pow(y_true - y_pred, 2) return tf.reduce_mean(sq_diff) y_true = tf.random.uniform([5], maxval=10, dtype=tf.int32) y_pred = tf.random.uniform([5], maxval=10, dtype=tf.int32) print(y_true) print(y_pred) tf.Tensor([2 0 7 2 3], shape=(5,), dtype=int32) tf.Tensor([9 9 1 1 5], shape=(5,), dtype=int32) get_MSE(y_true, y_pred) Pour vérifier que votre Le graphique fait le même calcul que sa fonction Python équivalente, vous pouvez le faire exécuter avec Il s’agit d’un changement qui La capacité de créer et d'exécuter des graphiques, au lieu d'exécuter le code normalement. tf.function tf.config.run_functions_eagerly(True) turns off tf.function tf.config.run_functions_eagerly(True) get_MSE(y_true, y_pred) # Don't forget to set it back when you are done. tf.config.run_functions_eagerly(False) Toutefois, peut se comporter différemment sous le graphique et l'exécution enthousiaste. fonction est un exemple de la différence entre ces deux modes. Voyons ce qui se passe lorsque vous insérez un d’exprimer sa position et de l’appeler à plusieurs reprises. tf.function print print @tf.function def get_MSE(y_true, y_pred): print("Calculating MSE!") sq_diff = tf.pow(y_true - y_pred, 2) return tf.reduce_mean(sq_diff) Regardez ce qui est imprimé : error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) Calculating MSE! La sortie est-elle surprenante ? Il n'a été imprimé qu'une seule fois, même s'il était appelé des times. get_MSE Trois Pour expliquer, le La déclaration est exécutée lorsque exécute le code d'origine afin de créer le graphique dans un processus connu sous le nom de "tracking" Section de la guide. n'est pas capturé dans le graphique. Ce graphique est ensuite exécuté pour les trois appels . print tf.function Traçage tf.function Tracing captures the TensorFlow operations into a graph, and print without ever running the Python code again Pour vérifier le bon sens, désactivons l’exécution du graphique pour comparer : # Now, globally set everything to run eagerly to force eager execution. tf.config.run_functions_eagerly(True) # Observe what is printed below. error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) Calculating MSE! Calculating MSE! Calculating MSE! tf.config.run_functions_eagerly(False) est a , et il y a d'autres différences que vous devriez être conscient de lors de la conversion d'une fonction en une En savoir plus dans la Section de la Le Guide. print Les effets secondaires de Python tf.function limitations Better performance with tf.function Remarque : Si vous souhaitez imprimer des valeurs à la fois dans l’exécution d’eager et de graphique, utilisez tf.print à la place. Remarque : Si vous souhaitez imprimer des valeurs à la fois dans l’exécution d’eager et de graphique, utilisez tf.print à la place. Exécution non stricte L'exécution graphique n'exécute que les opérations nécessaires pour produire les effets observables, qui comprennent: La valeur de retour de la fonction Documented well-known side-effects such as: Input/output operations, like tf.print Debugging operations, such as the assert functions in tf.debugging Mutations of tf.Variable Ce comportement est généralement connu comme "exécution non stricte", et diffère de l'exécution exigeante, qui passe par toutes les opérations du programme, nécessaires ou non. En particulier, la vérification des erreurs d'exécution ne compte pas comme un effet observable.Si une opération est oubliée parce qu'elle est inutile, elle ne peut pas élever d'erreurs d'exécution. Dans l’exemple suivant, l’opération « inutile » est oublié lors de l'exécution du graphique, de sorte que l'erreur n'est pas soulevée car elle serait en exécution. Ne comptez pas sur une erreur soulevée lors de l'exécution d'un graphique. tf.gather InvalidArgumentError def unused_return_eager(x): # Get index 1 will fail when `len(x) == 1` tf.gather(x, [1]) # unused return x try: print(unused_return_eager(tf.constant([0.0]))) except tf.errors.InvalidArgumentError as e: # All operations are run during eager execution so an error is raised. print(f'{type(e).__name__}: {e}') tf.Tensor([0.], shape=(1,), dtype=float32) @tf.function def unused_return_graph(x): tf.gather(x, [1]) # unused return x # Only needed operations are run during graph execution. The error is not raised. print(unused_return_graph(tf.constant([0.0]))) tf.Tensor([0.], shape=(1,), dtype=float32) Les meilleures pratiques tf.function Cela peut prendre un certain temps pour s'habituer au comportement de Pour commencer rapidement, les utilisateurs de première fois devraient jouer avec des fonctionnalités de décoration de jouets avec pour acquérir de l'expérience avec aller de l'enthousiasme à l'exécution graphique. tf.function @tf.function peut être votre meilleur pari pour écrire des programmes compatibles graphiques TensorFlow. voici quelques conseils: Conception pour tf.function Échanger entre l'exécution d'eager et de graphique tôt et souvent avec tf.config.run_functions_eagerly pour déterminer si/ quand les deux modes divergent. Créez des variables tf.Variables en dehors de la fonction Python et modifiez-les à l'intérieur. Il en va de même pour les objets qui utilisent tf.Variable, tels que tf.keras.layers, tf.keras.Models et tf.keras.optimizers. Évitez les fonctions d'écriture qui dépendent des variables Python externes, à l'exclusion des objets tf.Variables et Keras. En savoir plus dans Dépendant des variables mondiales et libres de Python du guide tf.function. Préférez écrire des fonctions qui prennent des tensors et d'autres types de TensorFlow comme input. Vous pouvez passer dans d'autres types d'objets, mais soyez prudent! En savoir plus dans En fonction des objets Python du guide tf.function. Incluez autant de calculs que possible sous une fonction tf. pour maximiser le gain de performance. Par exemple, décorez une étape d'entraînement entière ou l'ensemble de la boucle d'entraînement. Voir le speed-up usually improves the performance of your code, but the amount of speed-up depends on the kind of computation you run. Small computations can be dominated by the overhead of calling a graph. You can measure the difference in performance like so: tf.function x = tf.random.uniform(shape=[10, 10], minval=-1, maxval=2, dtype=tf.dtypes.int32) def power(x, y): result = tf.eye(10, dtype=tf.dtypes.int32) for _ in range(y): result = tf.matmul(x, result) return result print("Eager execution:", timeit.timeit(lambda: power(x, 100), number=1000), "seconds") Eager execution: 4.1027931490000356 seconds power_as_graph = tf.function(power) print("Graph execution:", timeit.timeit(lambda: power_as_graph(x, 100), number=1000), "seconds") Graph execution: 0.7951284349999241 seconds est couramment utilisé pour accélérer les boucles d'entraînement, et vous pouvez en apprendre plus sur le Section de la avec un guide. tf.function Accélérer votre entraînement avec tf.function Écrire un cycle de formation à partir de zéro Remarque : Vous pouvez également essayer tf.function(jit_compile=True) pour un boost de performance plus significatif, surtout si votre code est lourd sur le flux de contrôle TensorFlow et utilise de nombreux petits tensors. Vous pouvez également essayer pour une augmentation significative des performances, en particulier si votre code est lourd sur le flux de contrôle TensorFlow et utilise de nombreux petits tensors. Section de la . Note: tf.function(jit_compile=True) tf.function(jitcompile=True) XLA Vue d'ensemble XLA Vue d'ensemble Performance et trade-offs Les graphiques peuvent accélérer votre code, mais le processus de leur création a un peu d'avantage.Pour certaines fonctions, la création du graphique prend plus de temps que l'exécution du graphique. This investment is usually quickly paid back with the performance boost of subsequent executions, but it's important to be aware that the first few steps of any large model training can be slower due to tracing. Peu importe la taille de votre modèle, vous voulez éviter le suivi fréquent. Section, le Le guide discute de la façon de définir les spécifications d'entrée et d'utiliser des arguments de tensor pour éviter le retracement.Si vous trouvez que vous obtenez des performances inhabituellement mauvaises, il est une bonne idée de vérifier si vous retracez accidentellement. Contrôle du retrait tf.function Quand est un Le traceur ? tf. fonction tf. fonction Pour savoir quand votre est tracer, ajoutez un à son code, comme une règle de pouce, Il exécutera le chaque fois qu’il suit la trace. tf.function print tf.function print @tf.function def a_function_with_python_side_effect(x): print("Tracing!") # An eager-only side effect. return x * x + tf.constant(2) # This is traced the first time. print(a_function_with_python_side_effect(tf.constant(2))) # The second time through, you won't see the side effect. print(a_function_with_python_side_effect(tf.constant(3))) Tracing! tf.Tensor(6, shape=(), dtype=int32) tf.Tensor(11, shape=(), dtype=int32) # This retraces each time the Python argument changes, # as a Python argument could be an epoch count or other # hyperparameter. print(a_function_with_python_side_effect(2)) print(a_function_with_python_side_effect(3)) Tracing! tf.Tensor(6, shape=(), dtype=int32) Tracing! tf.Tensor(11, shape=(), dtype=int32) De nouveaux arguments Python déclenchent toujours la création d'un nouveau graphique, d'où le tracking supplémentaire. Les prochaines étapes Vous pouvez en apprendre plus sur sur la page de référence API et en suivant le Le Guide. tf.function Une meilleure performance avec tf.function Publié à l'origine sur le site Web de TensorFlow, cet article apparaît ici sous un nouveau titre et est sous licence CC BY 4.0. Publié à l'origine sur le site Web de TensorFlow, cet article apparaît ici sous un nouveau titre et est sous licence CC BY 4.0. TensorFlow TensorFlow