Încercați acest lucru dacă codul TensorFlow este lent

Conținut Overview Prezentare generală setare Profitând de grafice Utilizarea funcției tf.function Văzând accelerarea Când este un tf.function tracing? Următorii pași Prezentare generală Acest ghid merge sub suprafața TensorFlow și Keras pentru a demonstra cum funcționează TensorFlow. . Colecția de ghiduri Keras În acest ghid, veți afla cum TensorFlow vă permite să efectuați modificări simple la codul dvs. pentru a obține grafice, cum sunt stocate și reprezentate grafice și cum le puteți utiliza pentru a vă accelera modelele. Notă: Pentru cei care sunt familiarizați doar cu TensorFlow 1.x, acest ghid demonstrează o viziune foarte diferită a graficelor. Notă: Pentru cei care sunt familiarizați doar cu TensorFlow 1.x, acest ghid demonstrează o viziune foarte diferită a graficelor. vă permite să treceți de la executarea eager la executarea grafică. Pentru o specificare mai completă a Mergeţi la Ghidul . This is a big-picture overview that covers how tf.function tf.function Performanță mai bună cu tf.function Ce sunt grafurile? În cele trei ghiduri anterioare, ați rulat TensorFlow Aceasta înseamnă că operațiunile TensorFlow sunt executate de Python, operațiune după operațiune și returnează rezultatele înapoi în Python. eagerly În timp ce executarea cu nerăbdare are mai multe avantaje unice, executarea grafică permite portabilitatea în afara Python și tinde să ofere o performanță mai bună. înseamnă că calculele tensiunii sunt efectuate ca o Uneori este denumită a Sau pur și simplu un „graf”. Graph execution Graficul TensorFlow tf.Graph obiecte, care reprezintă unități de calcul; și obiecte, care reprezintă unitățile de date care curg între operațiuni. Deoarece aceste grafice sunt structuri de date, ele pot fi salvate, executate și restaurate fără codul original Python. Graphs are data structures that contain a set of tf.Operation tf.Tensor tf.Graph Iată cum arată un grafic TensorFlow reprezentând o rețea neurală cu două straturi atunci când este vizualizat în TensorBoard: Beneficiile grafilor Cu un grafic, aveți o mare flexibilitate. Puteți utiliza graficul TensorFlow în medii care nu au un interpret Python, cum ar fi aplicațiile mobile, dispozitivele încorporate și serverele backend. atunci când le exportă din Python. Modele salvate Graficele sunt, de asemenea, ușor optimizate, permițând compilatorului să efectueze transformări cum ar fi: Incepeți static valoarea tensorilor prin plierea nodurilor constante în calculul dvs. (" plierea constantă "). Sub-părți separate ale unui calcul care sunt independente și le împart între fire sau dispozitive. Simplificați operațiunile aritmetice prin eliminarea subexpresiilor comune. Există un întreg sistem de optimizare, pentru a face acest lucru și alte viteze. Grapplere Pe scurt, graficele sunt extrem de utile și vă permit să rulați TensorFlow Să alerge și de a alerga eficient . fast in parallel on multiple devices Cu toate acestea, doriți totuși să definiți modelele de învățare automată (sau alte calcule) în Python pentru comoditate și apoi să construiți automat grafice atunci când aveți nevoie de ele. setare Importați câteva biblioteci necesare: 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 Profitând de grafice Creați și rulați un grafic în TensorFlow utilizând , fie ca un apel direct, fie ca decorator. ia o funcție normală ca intrare și returnează o . . este un apelabil Python care construiește grafice TensorFlow din funcția Python. La fel ca în cazul 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 În exterior, a arată ca o funcție obișnuită pe care o scrieți folosind operațiunile TensorFlow. Cu toate acestea, este Subiectul de bază s în spatele unui API (aflați mai multe în Iată cum a este capabil să vă ofere avantajele execuției grafice, cum ar fi viteza și implementarea (referință la de mai sus). tf.function sub Foarte diferit PolymorphicFunction encapsulates several tf.Graph polimorfismului tf.function Beneficiile grafilor Se aplică unei funcţii : tf.function Toate celelalte funcţii pe care le numeşte 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) Dacă ați utilizat TensorFlow 1.x, veți observa că nu ați avut niciodată nevoie să definiți un sau . Placeholder tf.Session Convertirea funcțiilor Python în grafice Orice funcție pe care o scrieți cu TensorFlow va conține un amestec de operațiuni TF încorporate și logică Python, cum ar fi: Cuvânt cheie: Loops, , , În timp ce operaţiunile TensorFlow sunt capturate cu uşurinţă de o , Logica specifică Python trebuie să treacă printr-un pas suplimentar pentru a deveni parte a graficului. utilizează o bibliotecă numită AutoGraph ( convertirea codului Python în cod de generare a graficelor. 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 Deși este puțin probabil că va trebui să vizualizați graficele direct, puteți inspecta rezultatele pentru a verifica rezultatele exacte. Acestea nu sunt ușor de citit, deci nu trebuie să vă uitați prea atent! # 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 } Cea mai mare parte a timpului, va funcţiona fără consideraţii speciale. cu toate acestea, există unele avertismente, şi Ghidul poate ajuta aici, precum și . tf.function tf.function Referință autografă completă Polimorfismul: 1 Multe grafuri tf.function a este specializat într-un anumit tip de intrări (de exemplu, tensori cu un anumit sau obiecte cu acelaşi ) din tf.Graph dtype id() De fiecare dată când apelaţi la cu un set de argumente care nu pot fi tratate de oricare dintre graficele existente (cum ar fi argumentele cu noi sau forme incompatibile), creează o nouă specializate în aceste argumente noi. tipul de specificaţie a Intrările sunt reprezentate de De asemenea, se face referire la Pentru mai multe informații, când un nou este generată, cum poate fi controlată, şi cum poate fi util, du-te la Secţiunea de la Ghidul . tf.function dtypes tf.Graph tf.Graph tf.types.experimental.FunctionType signature tf.Graph FunctionType Reguli de urmărire Performanță mai bună cu tf.function pe Magazinele din Această semnătură corespunde unei . . poate fi considerat ca o înveliş în jurul unei . 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) Dacă a fost deja apelat cu aceleași tipuri de intrare, nu creează un nou . 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) Deoarece este susținută de mai multe grafuri, a este (așa cum sugerează numele "PolymorphicFunction") Acest lucru îi permite să susţină mai multe tipuri de intrare decât un singur poate fi utilizată şi optimizată pentru fiecare Pentru o performanță mai bună. 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 Utilizarea tf.function tf. funcţie Până acum, ați învățat cum să convertiți o funcție Python într-un grafic pur și simplu folosind ca un decorator sau înveliș. dar în practică, obținerea Funcționarea corectă poate fi dificilă!În secțiunile următoare, veți învăța cum să vă faceți codul să funcționeze așa cum era de așteptat cu . tf.function tf.function tf.function Executarea grafică vs. eager execution Codul în a poate fi executată atât cu dorinţă, cât şi ca grafic. execută codul său ca grafic: 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) Pentru a verifica dacă dumneavoastră Graficul face același calcul ca și funcția sa echivalentă Python, puteți să-l executați cu nerăbdare Aceasta este o schimbare care Capacitatea de a crea și de a rula grafice, în loc să execute codul în mod normal. 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) Cu toate acestea, se poate comporta diferit sub grafic și execuție dornică. funcţie este un exemplu al modului în care aceste două moduri diferă. Haideţi să vedem ce se întâmplă când introduceţi un îndeplineşte funcţia sa şi o cheamă în mod repetat. 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) Vezi ce este tipărit: error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) error = get_MSE(y_true, y_pred) Calculating MSE! Este surpriză producția? A fost scrisă o singură dată, chiar dacă a fost Timpului . get_MSE trei Pentru a explica, la Declaraţia este executată atunci când execută codul original pentru a crea graful într-un proces cunoscut sub numele de "tracking" (referă-te la Secţiunea de la Ghidul . nu este capturat în diagramă. acel grafic este apoi executat pentru toate cele trei apeluri . print tf.function urmărire tf.function Tracing captures the TensorFlow operations into a graph, and print without ever running the Python code again Ca o verificare de sănătate, să oprim executarea graficului pentru a compara: # 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) este a , and there are other differences that you should be aware of when converting a function into a Aflați mai multe în Secţiunea de la Ghidul . print Efecte secundare Python tf.function Limitări Performanță mai bună cu tf.function Notă: Dacă doriți să imprimați valori atât în execuția eager, cât și în execuția grafică, utilizați tf.print în schimb. Notă: Dacă doriți să imprimați valori atât în execuția eager, cât și în execuția grafică, utilizați tf.print în schimb. Executarea strictă Executarea grafică execută numai operațiunile necesare pentru a produce efectele observabile, care includ: Valoarea de returnare a funcției 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 Acest comportament este de obicei cunoscut sub numele de "executare non-strictă" și diferă de executarea cu dorință, care trece prin toate operațiunile programului, necesare sau nu. În special, verificarea erorilor de timp de rulare nu se numără ca un efect observabil. Dacă o operațiune este omisă deoarece este inutilă, nu poate ridica erori de timp de rulare. În următorul exemplu, operațiunea „necesară” este omis în timpul executării graficului, astfel încât erorile de nu este ridicat, deoarece ar fi într-o execuție dornică. Nu vă bazați pe o eroare ridicată în timp ce executați un grafic. 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) best practices tf.function Poate fi nevoie de ceva timp pentru a te obișnui cu comportamentul Pentru a începe rapid, utilizatorii de prima dată ar trebui să se joace cu funcțiile de decorare a jucăriilor cu pentru a obține experiență cu trecerea de la eager la execuția grafică. tf.function @tf.function poate fi cel mai bun pariu pentru scrierea programelor compatibile cu graficul TensorFlow. Proiectarea pentru tf.function Schimbați mai devreme și mai des între executarea eager și a diagramei cu tf.config.run_functions_eagerly pentru a determina dacă / când cele două moduri diverge. Creați tf.Variables în afara funcției Python și modificați-le în interior. Același lucru este valabil și pentru obiectele care utilizează tf.Variable, cum ar fi tf.keras.layers, tf.keras.Models și tf.keras.optimizers. Evitați funcțiile de scriere care depind de variabile externe Python, cu excepția obiectelor tf.Variables și Keras. Aflați mai multe în În funcție de variabilele globale și libere Python din ghidul tf.function. Preferați să scrieți funcții care iau tensori și alte tipuri de TensorFlow ca intrare.Puteți trece în alte tipuri de obiecte, dar aveți grijă! Aflați mai multe în În funcție de obiectele Python din ghidul tf.function. Includeți cât mai mult calcul posibil sub o funcție tf. pentru a maximiza câștigul de performanță. De exemplu, decorați o etapă întreagă de antrenament sau întreaga buclă de antrenament. Văzând accelerarea de obicei îmbunătățește performanța codului dvs., dar cantitatea de accelerare depinde de tipul de calcul pe care îl rulați. calculele mici pot fi dominate de suprafața de apelare a unui grafic. Puteți măsura diferența în performanță astfel: 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 este utilizat în mod obișnuit pentru a accelera ciclurile de antrenament, și puteți afla mai multe despre el în Secţiunea de la Cu ghidul lui Keras. tf.function Accelerați pașii de formare cu tf.function Scrierea unui curs de formare de la zero Notă: Puteți încerca, de asemenea, tf.function(jit_compile=True) pentru o creștere mai semnificativă a performanței, mai ales dacă codul dvs. este greu pe fluxul de control TensorFlow și utilizează mai mulți tensori mici. De asemenea, puteți încerca pentru o creștere semnificativă a performanței, mai ales dacă codul dvs. este greu pe fluxul de control TensorFlow și utilizează mai mulți tensori mici. Secţiunea de la . Note: tf.function(jit_compile=True) tf.function(jitcompile=True) XLA Prezentare generală XLA Prezentare generală Performanțe și compromisuri Graficele vă pot accelera codul, dar procesul de creare a acestora are unele probleme.Pentru unele funcții, crearea graficului necesită mai mult timp decât executarea graficului. 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. Indiferent cât de mare este modelul dvs., doriți să evitați urmărirea frecventă. Secţiunea, la Ghidul discută cum să setați specificațiile de intrare și să utilizați argumente de tensiune pentru a evita retracerea. Dacă găsiți că obțineți performanțe neobișnuit de slabe, este o idee bună să verificați dacă retractați accidental. Controlul retragerii tf.function Când este o Să urmărească? tf. funcţie tf. funcţie Pentru a afla când ai este urmărire, adăugaţi o în conformitate cu Codul de procedură, ca regulă de bază, El va executa de fiecare dată când urmează. 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) Argumentele noi Python declanșează întotdeauna crearea unui nou grafic, prin urmare, urmărirea suplimentară. Următorii pași Puteți afla mai multe despre pe pagina de referinţă API şi urmând Ghidul . tf.function Performanță mai bună cu tf.function Publicat inițial pe site-ul TensorFlow, acest articol apare aici sub un titlu nou și este licențiat sub CC BY 4.0. Publicat inițial pe site-ul TensorFlow, acest articol apare aici sub un titlu nou și este licențiat sub CC BY 4.0. TensorFlow TensorFlow