Pruebe esto si su código de TensorFlow es lento

Contenido Overview Vista general Instalación Aprovechando los gráficos Uso de tf.función Ver la aceleración ¿Cuándo es un tf.function tracing? Próximos pasos Vista general Esta guía va por debajo de la superficie de TensorFlow y Keras para demostrar cómo funciona TensorFlow. . Colección de guías de Keras En esta guía, aprenderá cómo TensorFlow le permite hacer cambios simples a su código para obtener gráficos, cómo los gráficos se almacenan y representan, y cómo puede usarlos para acelerar sus modelos. Nota: Para aquellos de ustedes que sólo están familiarizados con TensorFlow 1.x, esta guía demuestra una visión muy diferente de los gráficos. Para aquellos de ustedes que sólo están familiarizados con TensorFlow 1.x, esta guía demuestra una visión muy diferente de los gráficos. Note: permite cambiar de la ejecución ansiosa a la ejecución gráfica. Para una especificación más completa de Vaya a la La guía. This is a big-picture overview that covers how tf.function tf.function Mejor rendimiento con tf.function ¿Qué son los grafos? En las tres guías anteriores, ejecutó TensorFlow Esto significa que las operaciones de TensorFlow se ejecutan por Python, operación por operación, y devuelven los resultados a Python. eagerly Mientras que la ejecución ansiosa tiene varias ventajas únicas, la ejecución de gráficos permite la portabilidad fuera de Python y tiende a ofrecer un mejor rendimiento. significa que los cálculos tensores se ejecutan como un A veces se le denomina a O simplemente un “grafito”. Graph execution Gráfico TensorFlow tf.Graph objetos, que representan unidades de cálculo; y objetos, que representan las unidades de datos que fluyen entre operaciones. Debido a que estos gráficos son estructuras de datos, se pueden guardar, ejecutar y restaurar sin el código original de Python. Graphs are data structures that contain a set of tf.Operation tf.Tensor tf.Graph Así es como se ve un gráfico TensorFlow que representa una red neural de dos capas cuando se visualiza en TensorBoard: Beneficios de los grafos Con un gráfico, tiene mucha flexibilidad. Puede usar su gráfico TensorFlow en entornos que no tienen un interpretador de Python, como aplicaciones móviles, dispositivos incorporados y servidores de backend. cuando los exporta de Python. Modelos salvados Los gráficos también se optimizan fácilmente, permitiendo al compilador realizar transformaciones como: Deducir estáticamente el valor de los tensores plegando nodos constantes en su cálculo ("plegado constante"). Subpartes separadas de un cálculo que son independientes y las dividen entre filamentos o dispositivos. Simplifica las operaciones aritméticas eliminando las subexpresiones comunes. Hay todo un sistema de optimización. para realizar esta y otras aceleraciones. Grappler En resumen, los gráficos son extremadamente útiles y permiten que tu TensorFlow funcione y correr y correr de manera eficiente . fast in parallel on multiple devices Sin embargo, todavía desea definir sus modelos de aprendizaje automático (o otros cálculos) en Python por conveniencia, y luego construir gráficos automáticamente cuando los necesite. Instalación Importar algunas bibliotecas necesarias: 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 Aprovechando los gráficos Crea y ejecuta un gráfico en TensorFlow utilizando como una llamada directa o como un decorador. toma una función normal como entrada y devuelve a . el es un llamable Python que construye gráficos TensorFlow de la función Python. igual que su equivalente en 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 En el exterior, a se ve como una función normal que escribe usando las operaciones de TensorFlow. Sin embargo, es El subyacente S detrás de una API (leer más en el Es la forma en la que a es capaz de darle las ventajas de la ejecución de gráficos, como la velocidad y la implantación (referir a por encima). tf.function debajo muy diferente PolymorphicFunction encapsulates several tf.Graph Polimorfismo tf.function Beneficios de los grafos Se aplica a una función : tf.function y todas las demás funciones que llama 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 ha utilizado TensorFlow 1.x, notará que en ningún momento necesitó definir una o . Placeholder tf.Session Convertir funciones de Python en gráficos Cualquier función que escriba con TensorFlow contendrá una mezcla de operaciones TF y lógica de Python, tales como: Claves y loops, , de , de , y más. Mientras que las operaciones de TensorFlow son fácilmente capturadas por un , La lógica específica de Python necesita pasar por un paso adicional para convertirse en parte del gráfico. utiliza una biblioteca llamada AutoGraph ( Convertir el código de Python en código generador de gráficos. 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 Aunque es poco probable que necesite ver los gráficos directamente, puede inspeccionar las salidas para comprobar los resultados exactos. Estos no son fáciles de leer, por lo que no hay necesidad de mirar demasiado cuidadosamente! # 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 mayor parte del tiempo, No obstante, hay que tener en cuenta que existen ciertas precauciones, y el El guía puede ayudar aquí, así como el . tf.function tf.function Autógrafo completo de referencia Polimorfismo: una Muchos gráficos tf.function a se especializa en un tipo específico de entradas (por ejemplo, tensores con un Objetos con el mismo ) de tf.Graph dtype id() Cada vez que invocas a con un conjunto de argumentos que no pueden ser manejados por ninguno de sus gráficos existentes (como argumentos con nuevos o formas incompatibles), crea una nueva especializado en esos nuevos argumentos.La especificación del tipo de Las entradas están representadas por También se refiere como el Para obtener más información acerca de cuándo una nueva se genera, cómo se puede controlar, y cómo Puede ser útil, vaya al Sección de la La guía. tf.function dtypes tf.Graph tf.Graph tf.types.experimental.FunctionType signature tf.Graph FunctionType Reglas de rastreo Mejor rendimiento con tf.function El Las tiendas de corresponde a esa firma en un . el Puede considerarse como un engranaje alrededor de un . 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 el ya ha sido llamado con los mismos tipos de entrada, no crea un nuevo . 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) Debido a que está respaldado por múltiples gráficos, a es (como el nombre "PolymorphicFunction" sugiere) Esto le permite soportar más tipos de entrada que un solo Puede representar, y para optimizar cada para un mejor rendimiento. 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 Uso F. Funciones F. Funciones Hasta ahora, has aprendido cómo convertir una función de Python en un gráfico simplemente usando como un decorador o enrollador. pero en la práctica, obtener trabajar correctamente puede ser complicado! En las siguientes secciones, aprenderá cómo hacer que su código funcione como se esperaba con . tf.function tf.function tf.function Execución gráfica vs. eager El código en A puede ser ejecutada tanto de forma ansiosa como como un gráfico. por defecto, ejecuta su código como un gráfico: 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) Para comprobar que su El gráfico está haciendo el mismo cálculo que su función Python equivalente, se puede hacer ejecutar con Este es un cambio que Capacidad de crear y ejecutar gráficos, en lugar de ejecutar el código normalmente. 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) Sin embargo, puede comportarse de manera diferente bajo el gráfico y la ejecución ansiosa. función es un ejemplo de cómo estos dos modos difieren. Vamos a ver qué sucede cuando inserta un declaración a su función y llamarla repetidamente. 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) Observa lo que se imprime: error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) Calculating MSE! ¿Es sorprendente la producción? sólo se publicó una vez, aunque se llamó los tiempos. get_MSE tres Para explicar, el La declaración se ejecuta cuando ejecuta el código original para crear el gráfico en un proceso conocido como "tracking" (referencia al Sección de la La guía. no se captura en el gráfico. ese gráfico se ejecuta luego para las tres llamadas . print tf.function Tracción tf.function Tracing captures the TensorFlow operations into a graph, and print without ever running the Python code again Como prueba de sanidad, apagemos la ejecución de gráficos para comparar: # 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) es a , y hay otras diferencias que debe tener en cuenta al convertir una función en una Aprende más en la Sección de la La guía. print Efectos secundarios de Python tf.function Limitaciones Mejor rendimiento con tf.function Nota: Si desea imprimir valores tanto en eager como en la ejecución de gráficos, utilice tf.print en su lugar. Si desea imprimir valores tanto en eager como en la ejecución de gráficos, utilice en su lugar. Note: tf.print Ejecución no estricta La ejecución de gráficos sólo ejecuta las operaciones necesarias para producir los efectos observables, que incluyen: El valor de devolución de la función 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 Este comportamiento se conoce generalmente como "execución no estricta", y difiere de la ejecución ansiosa, que pasa por todas las operaciones del programa, necesarias o no. En particular, la verificación de errores de tiempo de ejecución no cuenta como un efecto observable.Si una operación se salta porque es innecesaria, no puede plantear errores de tiempo de ejecución. En el siguiente ejemplo, la operación "inútil" se salta durante la ejecución del gráfico, por lo que el error de no se levanta como sería en ejecución ansiosa. No confíe en un error que se levanta durante la ejecución de un gráfico. 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) Las mejores prácticas tf.function Puede tardar algún tiempo en acostumbrarse a la Para comenzar rápidamente, los usuarios de primera vez deben jugar con las funciones de decoración de juguetes con para obtener experiencia con ir de ansioso a la ejecución de gráficos. tf.function @tf.function Puede ser su mejor apuesta para escribir programas compatibles con gráficos de TensorFlow. Diseño para tf.function Cambiar entre eager y ejecución de gráficos temprano y con frecuencia con tf.config.run_functions_eagerly para determinar si / cuando los dos modos divergir. Crear tf.Variables fuera de la función Python y modificarlos en el interior. Lo mismo se aplica a los objetos que usan tf.Variable, como tf.keras.layers, tf.keras.Models y tf.keras.optimizers. Evite las funciones de escritura que dependen de las variables externas de Python, excepto los objetos tf.Variables y Keras. Prefiere escribir funciones que tomen tensores y otros tipos de TensorFlow como entrada. Puede pasar a otros tipos de objeto pero tenga cuidado! Aprenda más en Dependiendo de los objetos de Python de la guía tf.function. Incluya tanto cálculo como sea posible bajo una función tf. para maximizar el aumento de rendimiento. por ejemplo, decorar un paso de entrenamiento completo o el ciclo de entrenamiento completo. Ver la aceleración generalmente mejora el rendimiento de su código, pero la cantidad de aceleración depende del tipo de cálculo que ejecute. cálculos pequeños pueden ser dominados por la superioridad de llamar un gráfico. Puede medir la diferencia en el rendimiento de esta manera: 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 se utiliza comúnmente para acelerar los circuitos de entrenamiento, y puede aprender más sobre él en el Sección de la Con la guía de Keras. tf.function Acelera tu entrenamiento con tf.function Escribir un ciclo de entrenamiento desde cero Nota: También puede probar tf.function(jit_compile=True) para un aumento de rendimiento más significativo, especialmente si su código es pesado en el flujo de control de TensorFlow y utiliza muchos tensores pequeños. También puedes intentar para un aumento de rendimiento más significativo, especialmente si su código es pesado en el flujo de control de TensorFlow y utiliza muchos tensores pequeños. Sección de la . Note: tf.function(jit_compile=True) tf.function(jitcompile=True) Vista general de XLA Vista general de XLA Desempeño y Compromiso Los gráficos pueden acelerar tu código, pero el proceso de crearlos tiene algo de sobrepeso. Para algunas funciones, la creación del gráfico toma más tiempo que la ejecución del gráfico. 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. No importa cuán grande sea su modelo, desea evitar el rastreo frecuente. La sección, el La guía discute cómo configurar las especificaciones de entrada y utilizar argumentos de tensor para evitar el retroceso.Si encuentra que está obteniendo un rendimiento inusual, es una buena idea comprobar si está retrocediendo accidentalmente. Control de retroceso tf.function Cuando es una ¿El rastro? F. Funciones F. Funciones Para saber cuándo su es tracing, añade a de la norma, como una regla de dedo, Será ejecutado el declaración cada vez que se detecta. 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) Los nuevos argumentos de Python siempre desencadenan la creación de un nuevo gráfico, de ahí el rastreo adicional. Próximos pasos Puedes aprender más sobre en la página de referencia de la API y siguiendo el La guía. tf.function Mejor rendimiento con tf.function Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. TensorFlow TensorFlow