Ta strona została przetłumaczona przez Cloud Translation API.

Switch to English

Lepsza wydajność dzięki funkcji tf.

Zobacz na TensorFlow.org

Uruchom w Google Colab

Wyświetl źródło na GitHub

Pobierz notatnik

W TensorFlow 2, chętny wykonanie jest włączona domyślnie. Interfejs użytkownika jest intuicyjny i elastyczny (wykonywanie jednorazowych operacji jest znacznie łatwiejsze i szybsze), ale może to nastąpić kosztem wydajności i możliwości wdrożenia.

Można użyć tf.function aby wykresy z programów. Jest to narzędzie do transformacji, które tworzy niezależne od Pythona wykresy przepływu danych z kodu Pythona. Pomoże to stworzyć wydajnych i przenośnych modeli, a to jest wymagane do korzystania SavedModel .

Ten poradnik pomoże Ci konceptualizacji jak tf.function pracuje pod maską, więc można go używać efektywnie.

Główne dania na wynos i rekomendacje to:

Debugowania w trybie chętnie, a następnie ozdobić @tf.function .
Nie polegaj na efektach ubocznych Pythona, takich jak mutacje obiektów lub dołączanie list.
tf.function działa najlepiej z OPS TensorFlow; Wywołania NumPy i Python są konwertowane na stałe.

Organizować coś

import tensorflow as tf

2021-08-02 22:19:19.897689: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

Zdefiniuj funkcję pomocniczą, aby zademonstrować rodzaje błędów, które możesz napotkać:

import traceback
import contextlib

# Some helper code to demonstrate the kinds of errors you might encounter.
@contextlib.contextmanager
def assert_raises(error_class):
  try:
    yield
  except error_class as e:
    print('Caught expected exception \n  {}:'.format(error_class))
    traceback.print_exc(limit=2)
  except Exception as e:
    raise e
  else:
    raise Exception('Expected {} to be raised but no error was raised!'.format(
        error_class))

Podstawy

Stosowanie

Function definiowania (na przykład przez zastosowanie @tf.function dekorator) jest jak operacja rdzeń TensorFlow: Można go wykonać z niecierpliwością; możesz obliczyć gradienty; i tak dalej.

@tf.function  # The decorator converts `add` into a `Function`.
def add(a, b):
  return a + b

add(tf.ones([2, 2]), tf.ones([2, 2]))  #  [[2., 2.], [2., 2.]]

2021-08-02 22:19:21.085343: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-08-02 22:19:21.729717: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.730560: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-02 22:19:21.730612: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-02 22:19:21.734128: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-02 22:19:21.734207: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-08-02 22:19:21.735374: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-08-02 22:19:21.735738: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-08-02 22:19:21.736864: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-08-02 22:19:21.737722: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-08-02 22:19:21.737879: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-02 22:19:21.737966: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.738897: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.739704: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-02 22:19:21.740395: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-02 22:19:21.740962: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.741884: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-02 22:19:21.741958: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.742923: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:21.743725: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-02 22:19:21.743765: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-02 22:19:22.334929: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-02 22:19:22.334965: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-02 22:19:22.334973: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-02 22:19:22.335203: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:22.336233: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:22.337138: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-02 22:19:22.337941: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
2021-08-02 22:19:22.644502: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-08-02 22:19:22.644894: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000194999 Hz
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[2., 2.],
       [2., 2.]], dtype=float32)>

v = tf.Variable(1.0)
with tf.GradientTape() as tape:
  result = add(v, 1.0)
tape.gradient(result, v)

<tf.Tensor: shape=(), dtype=float32, numpy=1.0>

Można użyć Function s wewnątrz innych Function y.

@tf.function
def dense_layer(x, w, b):
  return add(tf.matmul(x, w), b)

dense_layer(tf.ones([3, 2]), tf.ones([2, 2]), tf.ones([2]))

2021-08-02 22:19:22.724228: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-02 22:19:23.126294: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
<tf.Tensor: shape=(3, 2), dtype=float32, numpy=
array([[3., 3.],
       [3., 3.],
       [3., 3.]], dtype=float32)>

Function S może być szybszy niż kod chętny, zwłaszcza dla wykresów z wielu małych ops. Ale w przypadku wykresów z kilkoma kosztownymi operacjami (takich jak sploty) możesz nie zauważyć dużego przyspieszenia.

import timeit
conv_layer = tf.keras.layers.Conv2D(100, 3)

@tf.function
def conv_fn(image):
  return conv_layer(image)

image = tf.zeros([1, 200, 200, 100])
# Warm up
conv_layer(image); conv_fn(image)
print("Eager conv:", timeit.timeit(lambda: conv_layer(image), number=10))
print("Function conv:", timeit.timeit(lambda: conv_fn(image), number=10))
print("Note how there's not much difference in performance for convolutions")

2021-08-02 22:19:23.150560: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-02 22:19:23.552403: I tensorflow/stream_executor/cuda/cuda_dnn.cc:359] Loaded cuDNN version 8100
Eager conv: 0.004413468006532639
Function conv: 0.004342082997027319
Note how there's not much difference in performance for convolutions

Rysunek kalkowy

Ta sekcja naraża jak Function działa pod maską, w tym szczegółów implementacji, które mogą ulec zmianie w przyszłości. Jednak po zrozumieć, dlaczego i kiedy śledzenie dzieje, jest dużo łatwiejszy w obsłudze tf.function Skutecznie!

Co to jest „śledzenie”?

Function uruchamia swój program w TensorFlow Graph . Jednak tf.Graph nie może reprezentować wszystkie rzeczy, które chcesz napisać w gorliwym programu TensorFlow. Na przykład, Python obsługuje polimorfizm, ale tf.Graph wymaga od swoich wejść mieć określony typ danych i rozmiar. Możesz też wykonywać zadania poboczne, takie jak odczytywanie argumentów wiersza poleceń, zgłaszanie błędów lub praca z bardziej złożonym obiektem Pythona; żadna z tych rzeczy, które można uruchomić w tf.Graph .

Function mostów tę lukę poprzez oddzielenie kodu w dwóch etapach:

1) W pierwszym etapie, zwanym „śledzenia”, Function tworzy nowy tf.Graph . Kod Python działa normalnie, ale wszystkie operacje TensorFlow (jak dodanie dwóch tensorów) są odraczane: są one przechwycone przez tf.Graph a nie uciekać.

2) W drugim etapie, o tf.Graph który zawiera wszystko, co zostało odroczone w pierwszym etapie jest prowadzony. Ten etap jest znacznie szybszy niż etap śledzenia.

W zależności od jego wejścia, Function nie będzie działać zawsze pierwszy etap, kiedy jest ona wywoływana. Patrz „reguły śledzenia” poniżej, aby uzyskać lepsze poczucie, jak to sprawia, że określenie. Pominięcie pierwszego etapu i wykonanie tylko drugiego etapu zapewnia wysoką wydajność TensorFlow.

Kiedy Function ma zdecydować prześledzić, etap śledzenia natychmiast następuje drugi etap, więc wywołanie Function zarówno tworzy i uruchamia tf.Graph . Później zobaczymy, jak można uruchomić tylko etap śledzenia z get_concrete_function .

Kiedy przekazywać argumenty różnych typów do Function , oba stopnie uruchamiane są:

@tf.function
def double(a):
  print("Tracing with", a)
  return a + a

print(double(tf.constant(1)))
print()
print(double(tf.constant(1.1)))
print()
print(double(tf.constant("a")))
print()

Tracing with Tensor("a:0", shape=(), dtype=int32)
tf.Tensor(2, shape=(), dtype=int32)

Tracing with Tensor("a:0", shape=(), dtype=float32)
tf.Tensor(2.2, shape=(), dtype=float32)

Tracing with Tensor("a:0", shape=(), dtype=string)
tf.Tensor(b'aa', shape=(), dtype=string)

Zauważ, że jeśli wielokrotnie wywołać Function z tego samego typu argumentu, TensorFlow pominie etap wykrywania i ponownie użyć wcześniej prześledzić wykres, jak wygenerowany wykres byłby identyczny.

# This doesn't print 'Tracing with ...'
print(double(tf.constant("b")))

tf.Tensor(b'bb', shape=(), dtype=string)

Można użyć pretty_printed_concrete_signatures() , aby zobaczyć wszystkie dostępne ślady:

print(double.pretty_printed_concrete_signatures())

double(a)
  Args:
    a: int32 Tensor, shape=()
  Returns:
    int32 Tensor, shape=()

double(a)
  Args:
    a: float32 Tensor, shape=()
  Returns:
    float32 Tensor, shape=()

double(a)
  Args:
    a: string Tensor, shape=()
  Returns:
    string Tensor, shape=()

Do tej pory widziałem, że tf.function tworzy buforowane dynamiczną warstwę wysyłki nad wykresem TensorFlow za śledzenia logiki. Aby być bardziej szczegółowym o terminologii:

tf.Graph jest surowy, język-agnostyk, przenośny przedstawieniem obliczeń TensorFlow.
ConcreteFunction okłady tf.Graph .
Function zarządza cache ConcreteFunction s i wybiera odpowiedni dla swoich wejściach.
tf.function owija funkcję Pythona, powracając do Function obiektu.
Kalka tworzy tf.Graph i zawija je w ConcreteFunction , znany również jako ślad.

Zasady śledzenia

Function określa, czy do ponownego użycia prześledzić ConcreteFunction obliczając klucz cache z args i kwargs wejście jest. Kluczowym cache jest kluczem, który identyfikuje ConcreteFunction oparte na argumentach wejściowych i kwargs z Function rozmowy, zgodnie z następującymi zasadami (które mogą ulec zmianie):

Kluczem generowane przez tf.Tensor jest jego kształt i dtype.
Kluczem generowane przez tf.Variable to unikatowy identyfikator zmiennej.
Klucz generowany Python prymitywne (jak int , float , str ) jest jego wartość.
Klucz generowany dla zagnieżdżonych dict s, list s, tuple s, namedtuple s, i attr y jest spłaszczony krotką liści klawiszy (patrz nest.flatten ). (W wyniku tego spłaszczenia wywołanie konkretnej funkcji z inną strukturą zagnieżdżenia niż ta użyta podczas śledzenia spowoduje wystąpienie błędu TypeError).
Dla wszystkich innych typów Pythona klucz jest unikalny dla obiektu. W ten sposób funkcja lub metoda jest śledzona niezależnie dla każdej instancji, z którą jest wywoływana.

Kontrolowanie cofania

Odtworzyć, co jest, gdy Function tworzy więcej niż jeden ślad, pomaga, zapewnia, że TensorFlow generuje odpowiednie wykresy dla każdego zestawu danych wejściowych. Jednak śledzenie to kosztowna operacja! Jeśli Function odtwarza nowy wykres dla każdego połączenia, przekonasz się, że wykonaniem kodu wolniej niż jeśli nie używać tf.function .

Aby kontrolować zachowanie śledzenia, możesz użyć następujących technik:

Określ input_signature w tf.function aby ograniczyć śledzenia.

@tf.function(input_signature=(tf.TensorSpec(shape=[None], dtype=tf.int32),))
def next_collatz(x):
  print("Tracing with", x)
  return tf.where(x % 2 == 0, x // 2, 3 * x + 1)

print(next_collatz(tf.constant([1, 2])))
# You specified a 1-D tensor in the input signature, so this should fail.
with assert_raises(ValueError):
  next_collatz(tf.constant([[1, 2], [3, 4]]))

# You specified an int32 dtype in the input signature, so this should fail.
with assert_raises(ValueError):
  next_collatz(tf.constant([1.0, 2.0]))

Tracing with Tensor("x:0", shape=(None,), dtype=int32)
tf.Tensor([4 1], shape=(2,), dtype=int32)
Caught expected exception 
  <class 'ValueError'>:
Caught expected exception 
  <class 'ValueError'>:
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/1851403433.py", line 9, in <module>
    next_collatz(tf.constant([[1, 2], [3, 4]]))
ValueError: Python inputs incompatible with input_signature:
  inputs: (
    tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32))
  input_signature: (
    TensorSpec(shape=(None,), dtype=tf.int32, name=None))
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/1851403433.py", line 13, in <module>
    next_collatz(tf.constant([1.0, 2.0]))
ValueError: Python inputs incompatible with input_signature:
  inputs: (
    tf.Tensor([1. 2.], shape=(2,), dtype=float32))
  input_signature: (
    TensorSpec(shape=(None,), dtype=tf.int32, name=None))

Określić [brak] wymiar tf.TensorSpec umożliwić elastyczność w śladowych ponownego użycia.
Od TensorFlow mecze tensory na podstawie ich kształtu, używając None wymiar jako zamiennika pozwoli Function s do śladów wykorzystania na wejściu zmiennie rozmiarze. Wejście zmiennie wielkości może wystąpić, jeśli sekwencje o różnej długości, lub obrazy o różnych rozmiarach dla każdej partii (patrz transformatorowe i Głębokie Dream tutoriale na przykład).

@tf.function(input_signature=(tf.TensorSpec(shape=[None], dtype=tf.int32),))
def g(x):
  print('Tracing with', x)
  return x

# No retrace!
print(g(tf.constant([1, 2, 3])))
print(g(tf.constant([1, 2, 3, 4, 5])))

Tracing with Tensor("x:0", shape=(None,), dtype=int32)
tf.Tensor([1 2 3], shape=(3,), dtype=int32)
tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

Przesyłaj argumenty Pythona do tensorów, aby ograniczyć cofanie się.
Często Python argumenty są używane do hiperparametrów sterowania i konstrukcji wykresu - na przykład num_layers=10 lub training=True lub nonlinearity='relu' . Tak więc, jeśli argument Pythona ulegnie zmianie, sensowne jest ponowne prześledzenie wykresu.
Jednak jest możliwe, że argument Pythona nie jest używany do kontrolowania konstrukcji grafu. W takich przypadkach zmiana wartości Pythona może wywołać niepotrzebne cofanie. Weźmy na przykład tę pętlę treningową, którą AutoGraph będzie dynamicznie rozwijał. Pomimo wielu śladów wygenerowany wykres jest w rzeczywistości identyczny, więc ponowne śledzenie nie jest konieczne.

def train_one_step():
  pass

@tf.function
def train(num_steps):
  print("Tracing with num_steps = ", num_steps)
  tf.print("Executing with num_steps = ", num_steps)
  for _ in tf.range(num_steps):
    train_one_step()

print("Retracing occurs for different Python arguments.")
train(num_steps=10)
train(num_steps=20)

print()
print("Traces are reused for Tensor arguments.")
train(num_steps=tf.constant(10))
train(num_steps=tf.constant(20))

Retracing occurs for different Python arguments.
Tracing with num_steps =  10
Executing with num_steps =  10
Tracing with num_steps =  20
Executing with num_steps =  20

Traces are reused for Tensor arguments.
Tracing with num_steps =  Tensor("num_steps:0", shape=(), dtype=int32)
Executing with num_steps =  10
Executing with num_steps =  20

Jeśli trzeba siły odtworzyć, należy utworzyć nową Function . Oddzielne Function obiekty nie są gwarantowane do śladów akcji.

def f():
  print('Tracing!')
  tf.print('Executing')

tf.function(f)()
tf.function(f)()

Tracing!
Executing
Tracing!
Executing

Uzyskanie konkretnych funkcji

Za każdym razem, gdy funkcja jest śledzona, tworzona jest nowa konkretna funkcja. Można bezpośrednio uzyskać konkretną funkcję, za pomocą get_concrete_function .

print("Obtaining concrete trace")
double_strings = double.get_concrete_function(tf.constant("a"))
print("Executing traced function")
print(double_strings(tf.constant("a")))
print(double_strings(a=tf.constant("b")))

Obtaining concrete trace
Executing traced function
tf.Tensor(b'aa', shape=(), dtype=string)
tf.Tensor(b'bb', shape=(), dtype=string)

# You can also call get_concrete_function on an InputSpec
double_strings_from_inputspec = double.get_concrete_function(tf.TensorSpec(shape=[], dtype=tf.string))
print(double_strings_from_inputspec(tf.constant("c")))

Tracing with Tensor("a:0", shape=(), dtype=string)
tf.Tensor(b'cc', shape=(), dtype=string)

Drukowanie ConcreteFunction wyświetla podsumowanie jego argumentów wejściowych (z rodzajów) i jej typ wyjściowego.

print(double_strings)

ConcreteFunction double(a)
  Args:
    a: string Tensor, shape=()
  Returns:
    string Tensor, shape=()

Możesz także bezpośrednio pobrać sygnaturę konkretnej funkcji.

print(double_strings.structured_input_signature)
print(double_strings.structured_outputs)

((TensorSpec(shape=(), dtype=tf.string, name='a'),), {})
Tensor("Identity:0", shape=(), dtype=string)

Użycie konkretnego śladu z niekompatybilnymi typami spowoduje błąd

with assert_raises(tf.errors.InvalidArgumentError):
  double_strings(tf.constant(1))

Caught expected exception 
  <class 'tensorflow.python.framework.errors_impl.InvalidArgumentError'>:
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/3196284684.py", line 2, in <module>
    double_strings(tf.constant(1))
tensorflow.python.framework.errors_impl.InvalidArgumentError: cannot compute __inference_double_162 as input #0(zero-based) was expected to be a string tensor but is a int32 tensor [Op:__inference_double_162]

Możesz zauważyć, że argumenty Pythona są traktowane w specjalny sposób w sygnaturze wejściowej konkretnej funkcji. Przed TensorFlow 2.3 argumenty Pythona były po prostu usuwane z podpisu konkretnej funkcji. Począwszy od TensorFlow 2.3, argumenty Pythona pozostają w sygnaturze, ale są ograniczone do przyjęcia wartości ustawionej podczas śledzenia.

@tf.function
def pow(a, b):
  return a ** b

square = pow.get_concrete_function(a=tf.TensorSpec(None, tf.float32), b=2)
print(square)

ConcreteFunction pow(a, b=2)
  Args:
    a: float32 Tensor, shape=<unknown>
  Returns:
    float32 Tensor, shape=<unknown>

assert square(tf.constant(10.0)) == 100

with assert_raises(TypeError):
  square(tf.constant(10.0), b=3)

Caught expected exception 
  <class 'TypeError'>:
Traceback (most recent call last):
  File "/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/function.py", line 1725, in _call_impl
    cancellation_manager)
  File "/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/function.py", line 1770, in _call_with_flat_signature
    self._flat_signature_summary(), ", ".join(sorted(kwargs))))
TypeError: pow(a) got unexpected keyword arguments: b.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/2310937119.py", line 4, in <module>
    square(tf.constant(10.0), b=3)
TypeError: ConcreteFunction pow(a, b) was constructed with int value 2 in b, but was called with int value 3

Uzyskiwanie wykresów

Każda funkcja beton jest wywoływalnym wrapper wokół tf.Graph . Chociaż zdobycie rzeczywistej tf.Graph obiekt nie jest coś będziesz normalnie trzeba zrobić, można uzyskać go łatwo z dowolnej funkcji betonowej.

graph = double_strings.graph
for node in graph.as_graph_def().node:
  print(f'{node.input} -> {node.name}')

[] -> a
['a', 'a'] -> add
['add'] -> Identity

Debugowanie

W ogóle, debugowanie kodu jest łatwiejsze niż w trybie chętny wewnątrz tf.function . Należy upewnić się, że Twój kod wykonuje wolne od błędów w trybie chętny przed zdobienia z tf.function . Aby pomóc w procesie debugowania, można zadzwonić tf.config.run_functions_eagerly(True) , aby globalnie wyłączania i ponownego włączania tf.function .

Podczas tropienia problemów, które pojawiają się tylko w tf.function , oto kilka wskazówek:

Plain Old Python print połączeń wykonać tylko podczas śledzenia, pomaga wyśledzić, gdy funkcja gets (re) prześledzić.
tf.print połączenia będą wykonywać za każdym razem, a może pomóc wyśledzić wartości pośrednich podczas wykonywania.
tf.debugging.enable_check_numerics to łatwy sposób, aby wyśledzić gdzie Koncepcja nieliczby i Inf są tworzone.
pdb (the debugger Python ) może pomóc zrozumieć, co się dzieje podczas śledzenia. (Zastrzeżenie: pdb spadnie ci do kodu źródłowego autograf przekształconych).

Transformacje autografu

Autograph to biblioteka, która jest domyślnie włączona w tf.function i przekształca podzbiór Python kodu chętny do wykresu kompatybilne ops TensorFlow. Obejmuje to przepływ sterowania, jak if , for , while .

TensorFlow ops jak tf.cond i tf.while_loop kontynuować pracę, ale przepływ sterowania jest często łatwiej pisać i zrozumieć, kiedy napisany w Pythonie.

# A simple loop

@tf.function
def f(x):
  while tf.reduce_sum(x) > 1:
    tf.print(x)
    x = tf.tanh(x)
  return x

f(tf.random.uniform([5]))

[0.908887744 0.961447954 0.0590943098 0.0116709471 0.153706789]
[0.720598102 0.744922042 0.059025608 0.0116704153 0.152507633]
[0.617279708 0.632109761 0.0589571483 0.0116698844 0.151336148]
[0.549231172 0.559503257 0.0588889234 0.0116693536 0.150191292]
[0.499943793 0.507608831 0.0588209368 0.0116688227 0.149072066]
[0.462072939 0.46808 0.058753185 0.0116682919 0.147977531]
[0.431772232 0.4366467 0.0586856641 0.011667761 0.146906793]
[0.406801313 0.410861045 0.0586183853 0.0116672302 0.145858988]
<tf.Tensor: shape=(5,), dtype=float32, numpy=
array([0.3857533 , 0.38920352, 0.05855133, 0.0116667 , 0.14483333],
      dtype=float32)>

Jeśli jesteś ciekawy, możesz sprawdzić kod generowany przez autograf.

print(tf.autograph.to_code(f.python_function))

def tf__f(x):
    with ag__.FunctionScope('f', '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 (x,)

        def set_state(vars_):
            nonlocal x
            (x,) = vars_

        def loop_body():
            nonlocal x
            ag__.converted_call(ag__.ld(tf).print, (ag__.ld(x),), None, fscope)
            x = ag__.converted_call(ag__.ld(tf).tanh, (ag__.ld(x),), None, fscope)

        def loop_test():
            return (ag__.converted_call(ag__.ld(tf).reduce_sum, (ag__.ld(x),), None, fscope) > 1)
        ag__.while_stmt(loop_test, loop_body, get_state, set_state, ('x',), {})
        try:
            do_return = True
            retval_ = ag__.ld(x)
        except:
            do_return = False
            raise
        return fscope.ret(retval_, do_return)

Warunkowe

Autograph przekonwertuje pewne if <condition> oświadczenia do równoważnych tf.cond połączeń. Podstawienie to jest jeśli <condition> jest tensora. W przeciwnym razie, if instrukcja jest wykonywana jako warunkowe Pythona.

Warunek Pythona jest wykonywany podczas śledzenia, więc do wykresu zostanie dodana dokładnie jedna gałąź warunku. Bez AutoGraph ten śledzony wykres nie byłby w stanie wykonać alternatywnej gałęzi, jeśli istnieje przepływ sterowania zależny od danych.

tf.cond ślady i dodaje obie gałęzie warunkowego do wykresu, dynamicznie wybierając oddział w czasie wykonywania. Śledzenie może mieć niezamierzone skutki uboczne; sprawdź autograf śledzenie efektów aby uzyskać więcej informacji.

@tf.function
def fizzbuzz(n):
  for i in tf.range(1, n + 1):
    print('Tracing for loop')
    if i % 15 == 0:
      print('Tracing fizzbuzz branch')
      tf.print('fizzbuzz')
    elif i % 3 == 0:
      print('Tracing fizz branch')
      tf.print('fizz')
    elif i % 5 == 0:
      print('Tracing buzz branch')
      tf.print('buzz')
    else:
      print('Tracing default branch')
      tf.print(i)

fizzbuzz(tf.constant(5))
fizzbuzz(tf.constant(20))

Tracing for loop
Tracing fizzbuzz branch
Tracing fizz branch
Tracing buzz branch
Tracing default branch
1
2
fizz
4
buzz
1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizzbuzz
16
17
fizz
19
buzz

Zobacz dokumentację referencyjną dla dodatkowych ograniczeń autograf skonwertowana if.

Pętle

Autograf będzie konwertować niektóre for i while wypowiedzi na ekwiwalent TensorFlow zapętlenie ops, jak tf.while_loop . Jeśli nie przeprowadzeniu modyfikacji for lub while pętla jest wykonany w postaci pętli Pythona.

Ta zamiana jest dokonywana w następujących sytuacjach:

for x in y : jeśli y jest tensora przeliczyć tf.while_loop . W szczególnym przypadku, w którym y oznacza tf.data.Dataset , kombinacja tf.data.Dataset ops są generowane.
while <condition> : jeśli <condition> jest Tensor, konwersja do tf.while_loop .

Pyton Wykonuje pętli podczas śledzenia, dodając dodatkowe ops do tf.Graph dla każdej iteracji.

Pętla TensorFlow śledzi treść pętli i dynamicznie wybiera liczbę iteracji do uruchomienia w czasie wykonywania. Ciało pętli pojawia się tylko raz w generowanym tf.Graph .

Zobacz dokumentację referencyjną dla dodatkowych ograniczeń autograf konwertowane for i while wypowiedzi.

Zapętlanie danych Pythona

Typowym pułapka jest w pętli danych python / NumPy obrębie tf.function . Ta pętla wykona podczas procesu wykrywania, dodając kopię modelu do tf.Graph dla każdej iteracji pętli.

Jeśli chcesz, aby owinąć całą pętlę szkoleniowy w tf.function , najbezpieczniejszym sposobem na to jest, by zakończyć swoje dane jako tf.data.Dataset tak, że autograf będzie dynamicznie rozwinąć pętlę treningową.

def measure_graph_size(f, *args):
  g = f.get_concrete_function(*args).graph
  print("{}({}) contains {} nodes in its graph".format(
      f.__name__, ', '.join(map(str, args)), len(g.as_graph_def().node)))

@tf.function
def train(dataset):
  loss = tf.constant(0)
  for x, y in dataset:
    loss += tf.abs(y - x) # Some dummy computation.
  return loss

small_data = [(1, 1)] * 3
big_data = [(1, 1)] * 10
measure_graph_size(train, small_data)
measure_graph_size(train, big_data)

measure_graph_size(train, tf.data.Dataset.from_generator(
    lambda: small_data, (tf.int32, tf.int32)))
measure_graph_size(train, tf.data.Dataset.from_generator(
    lambda: big_data, (tf.int32, tf.int32)))

train([(1, 1), (1, 1), (1, 1)]) contains 11 nodes in its graph
train([(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)]) contains 32 nodes in its graph
train(<FlatMapDataset shapes: (<unknown>, <unknown>), types: (tf.int32, tf.int32)>) contains 10 nodes in its graph
train(<FlatMapDataset shapes: (<unknown>, <unknown>), types: (tf.int32, tf.int32)>) contains 10 nodes in its graph

Podczas owijania danych python / NumPy w zbiorze danych, pamiętając tf.data.Dataset.from_generator porównaniu tf.data.Dataset.from_tensors . Były zachowa dane Pythonie sprowadzić go poprzez tf.py_function co może mieć wpływ na wydajność, podczas gdy ten ostatni pakiet kopię danych jako jedna duża tf.constant() węzła na wykresie, które mogą mieć wpływ pamięci.

Odczyt danych z plików poprzez TFRecordDataset , CsvDataset itp jest najbardziej skutecznym sposobem, aby konsumować dane, a następnie TensorFlow sama może zarządzać asynchroniczne ładowanie i preselekcji danych, bez konieczności angażowania Python. Aby dowiedzieć się więcej, zobacz tf.data : rurociągi wejściowe Budowa TensorFlow przewodnika.

Kumulacja wartości w pętli

Typowym wzorcem jest gromadzenie wartości pośrednich z pętli. Zwykle odbywa się to poprzez dodawanie do listy Pythona lub dodawanie wpisów do słownika Pythona. Ponieważ jednak są to efekty uboczne Pythona, nie będą działać zgodnie z oczekiwaniami w dynamicznie rozwijanej pętli. Zastosowanie tf.TensorArray gromadzić wynika z dynamicznie rozwiniętym pętli.

batch_size = 2
seq_len = 3
feature_size = 4

def rnn_step(inp, state):
  return inp + state

@tf.function
def dynamic_rnn(rnn_step, input_data, initial_state):
  # [batch, time, features] -> [time, batch, features]
  input_data = tf.transpose(input_data, [1, 0, 2])
  max_seq_len = input_data.shape[0]

  states = tf.TensorArray(tf.float32, size=max_seq_len)
  state = initial_state
  for i in tf.range(max_seq_len):
    state = rnn_step(input_data[i], state)
    states = states.write(i, state)
  return tf.transpose(states.stack(), [1, 0, 2])

dynamic_rnn(rnn_step,
            tf.random.uniform([batch_size, seq_len, feature_size]),
            tf.zeros([batch_size, feature_size]))

<tf.Tensor: shape=(2, 3, 4), dtype=float32, numpy=
array([[[0.7595345 , 0.8288754 , 0.07420504, 0.85769975],
        [1.5213574 , 0.9227042 , 0.45271885, 1.3538495 ],
        [1.6639059 , 1.3852738 , 1.2920266 , 1.419443  ]],

       [[0.09766459, 0.5416999 , 0.16834688, 0.9857919 ],
        [0.39503837, 1.428416  , 0.5706631 , 1.376408  ],
        [0.8582125 , 1.5586668 , 1.5131071 , 1.4433464 ]]], dtype=float32)>

Ograniczenia

TensorFlow Function posiada kilka ograniczeń, których autorem projektu, który powinien być świadomy podczas konwersji funkcję Pythona do Function .

Wywoływanie efektów ubocznych Pythona

Skutki uboczne, takie jak drukowanie, dołączanie do list i mutowania globalnych, może zachowywać się wewnątrz Function , czasami wykonując dwa razy lub nie wszystkie. Oni tylko się zdarzyć po raz pierwszy można nazwać Function z zestawem wejść. Następnie, prześledzić tf.Graph jest reexecuted, bez wykonywania kodu Pythona.

Ogólną zasadą jest unikanie polegania na efektach ubocznych Pythona w swojej logice i używanie ich tylko do debugowania śladów. Inaczej, API TensorFlow jak tf.data , tf.print , tf.summary , tf.Variable.assign i tf.TensorArray są najlepszym sposobem zapewnienia kod będzie wykonywany przez program TensorFlow z każdej rozmowy.

@tf.function
def f(x):
  print("Traced with", x)
  tf.print("Executed with", x)

f(1)
f(1)
f(2)

Traced with 1
Executed with 1
Executed with 1
Traced with 2
Executed with 2

Jeśli chcesz wykonać kod Pythona podczas każdego wywołania jest Function , tf.py_function jest klapa wyjście. Wadą tf.py_function jest to, że nie przenośny lub szczególnie wydajnych, nie mogą być zapisywane z SavedModel i nie działa dobrze w rozproszonych (multi-GPU, TPU) konfiguracje. Ponadto, ponieważ tf.py_function musi być podłączony do wykresu, to rzuca wszystkie wejścia / wyjścia do tensorów.

Zmiana globalnych i wolnych zmiennych Pythona

Zmiana Pythona globalne i zmienne wolne liczy się jako efekt uboczny Pythona, więc zdarza się tylko podczas śledzenia.

external_list = []

@tf.function
def side_effect(x):
  print('Python side effect')
  external_list.append(x)

side_effect(1)
side_effect(1)
side_effect(1)
# The list append only happened once!
assert len(external_list) == 1

Python side effect

Należy unikać mutacji pojemników jak list, dicts, innych obiektów, które żyją poza nią Function . Zamiast tego użyj argumentów i obiektów TF. Na przykład, w sekcji „Gromadzenie wartości w pętli” ma jeden przykład tego, jak lista-podobne czynności mogą być realizowane.

Można, w niektórych przypadkach chwytania i manipulowania stan, jeśli jest to tf.Variable . W ten sposób ciężar modeli Keras są na bieżąco z wielokrotnych wezwań do tej samej ConcreteFunction .

Korzystanie z iteratorów i generatorów Pythona

Wiele funkcji Pythona, takich jak generatory i iteratory, opiera się na środowisku uruchomieniowym Pythona do śledzenia stanu. Ogólnie rzecz biorąc, chociaż te konstrukcje działają zgodnie z oczekiwaniami w trybie przyspieszonym, są przykładami efektów ubocznych Pythona i dlatego występują tylko podczas śledzenia.

@tf.function
def buggy_consume_next(iterator):
  tf.print("Value:", next(iterator))

iterator = iter([1, 2, 3])
buggy_consume_next(iterator)
# This reuses the first value from the iterator, rather than consuming the next value.
buggy_consume_next(iterator)
buggy_consume_next(iterator)

Value: 1
Value: 1
Value: 1

Podobnie jak przy TensorFlow posiada wyspecjalizowane tf.TensorArray list konstruktów, ma wyspecjalizowane tf.data.Iterator dla iteracji konstrukcji. Patrz sekcja dotycząca przekształceń autograf na przegląd. Również tf.data API może pomóc wdrożyć wzory generator:

@tf.function
def good_consume_next(iterator):
  # This is ok, iterator is a tf.data.Iterator
  tf.print("Value:", next(iterator))

ds = tf.data.Dataset.from_tensor_slices([1, 2, 3])
iterator = iter(ds)
good_consume_next(iterator)
good_consume_next(iterator)
good_consume_next(iterator)

Value: 1
Value: 2
Value: 3

Usuwanie tf.Variables między `Function` połączeń

Innym błędem, który możesz napotkać, jest zmienna zbierana przez śmieci. ConcreteFunction y zachować tylko WeakRefs do zmiennych one blisko skończy, więc należy zachować odniesienie do wszelkich zmiennych.

external_var = tf.Variable(3)
@tf.function
def f(x):
  return x * external_var

traced_f = f.get_concrete_function(4)
print("Calling concrete function...")
print(traced_f(4))

# The original variable object gets garbage collected, since there are no more
# references to it.
external_var = tf.Variable(4)
print()
print("Calling concrete function after garbage collecting its closed Variable...")
with assert_raises(tf.errors.FailedPreconditionError):
  traced_f(4)

Calling concrete function...
tf.Tensor(12, shape=(), dtype=int32)

Calling concrete function after garbage collecting its closed Variable...
Caught expected exception 
  <class 'tensorflow.python.framework.errors_impl.FailedPreconditionError'>:
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/3862898592.py", line 16, in <module>
    traced_f(4)
tensorflow.python.framework.errors_impl.FailedPreconditionError: 2 root error(s) found.
  (0) Failed precondition:  Could not find variable _AnonymousVar3. This could mean that the variable has been deleted. In TF1, it can also mean the variable is uninitialized. Debug info: container=localhost, status=Not found: Resource localhost/_AnonymousVar3/N10tensorflow3VarE does not exist.
     [[node ReadVariableOp (defined at tmp/ipykernel_17014/3862898592.py:4) ]]
  (1) Failed precondition:  Could not find variable _AnonymousVar3. This could mean that the variable has been deleted. In TF1, it can also mean the variable is uninitialized. Debug info: container=localhost, status=Not found: Resource localhost/_AnonymousVar3/N10tensorflow3VarE does not exist.
     [[node ReadVariableOp (defined at tmp/ipykernel_17014/3862898592.py:4) ]]
     [[ReadVariableOp/_2]]
0 successful operations.
0 derived errors ignored. [Op:__inference_f_782]

Function call stack:
f -> f

Znane problemy

Jeśli Function nie jest ocena poprawnie, błąd może być wyjaśnione przez tych znanych problemów, które planowane są do zamocowania w przyszłości.

W zależności od zmiennych globalnych i wolnych Pythona

Function tworzy nowy ConcreteFunction kiedy nazywa nową wartość argumentu Pythona. Jednak nie robi tego, że do zamknięcia Python, globalnych lub nonlocals tej Function . Jeżeli ich wartość zmienia się między połączeniami do Function The Function będzie nadal korzystać z wartości, jakie mieli, kiedy została ona wywodzi. Różni się to od działania zwykłych funkcji Pythona.

Z tego powodu zalecamy funkcjonalny styl programowania, który używa argumentów zamiast zamykać nazwy zewnętrzne.

@tf.function
def buggy_add():
  return 1 + foo

@tf.function
def recommended_add(foo):
  return 1 + foo

foo = 1
print("Buggy:", buggy_add())
print("Correct:", recommended_add(foo))

Buggy: tf.Tensor(2, shape=(), dtype=int32)
Correct: tf.Tensor(2, shape=(), dtype=int32)

print("Updating the value of `foo` to 100!")
foo = 100
print("Buggy:", buggy_add())  # Did not change!
print("Correct:", recommended_add(foo))

Updating the value of `foo` to 100!
Buggy: tf.Tensor(2, shape=(), dtype=int32)
Correct: tf.Tensor(101, shape=(), dtype=int32)

Możesz zamykać nazwy zewnętrzne, o ile nie aktualizujesz ich wartości.

W zależności od obiektów Pythona

Zalecenie przekazać obiektów Pythona jako argumenty pod tf.function ma kilka znanych problemów, które według przewidywań będą ustalane w przyszłości. Ogólnie rzecz biorąc, można liczyć na konsekwentne śledzenie jeśli używasz Pythona prymitywny lub tf.nest -Kompatybilny strukturę jako argument lub przekazać w innej instancji obiektu do Function . Jednak Function nie będzie utworzyć nowy ślad kiedy przechodzą ten sam obiekt i tylko zmienić jego atrybuty.

class SimpleModel(tf.Module):
  def __init__(self):
    # These values are *not* tf.Variables.
    self.bias = 0.
    self.weight = 2.

@tf.function
def evaluate(model, x):
  return model.weight * x + model.bias

simple_model = SimpleModel()
x = tf.constant(10.)
print(evaluate(simple_model, x))

tf.Tensor(20.0, shape=(), dtype=float32)

print("Adding bias!")
simple_model.bias += 5.0
print(evaluate(simple_model, x))  # Didn't change :(

Adding bias!
tf.Tensor(20.0, shape=(), dtype=float32)

Przy użyciu tej samej Function do oceny zaktualizowanego instancję modelu będzie buggy od zaktualizowany model ma ten sam klucz cache jako oryginalnego modelu.

Z tego powodu zaleca się, aby napisać Function , aby uniknąć zależności od modyfikowalnych atrybutów obiektu lub tworzenia nowych obiektów.

Jeśli nie jest to możliwe, jeden obejście jest stworzenie nowej Function y za każdym razem modyfikować swój obiekt zmusić retracing:

def evaluate(model, x):
  return model.weight * x + model.bias

new_model = SimpleModel()
evaluate_no_bias = tf.function(evaluate).get_concrete_function(new_model, x)
# Don't pass in `new_model`, `Function` already captured its state during tracing.
print(evaluate_no_bias(x))

tf.Tensor(20.0, shape=(), dtype=float32)

print("Adding bias!")
new_model.bias += 5.0
# Create new Function and ConcreteFunction since you modified new_model.
evaluate_with_bias = tf.function(evaluate).get_concrete_function(new_model, x)
print(evaluate_with_bias(x)) # Don't pass in `new_model`.

Adding bias!
tf.Tensor(25.0, shape=(), dtype=float32)

Jak odtworzyć mogą być drogie , można użyć tf.Variable s jako atrybuty obiektów, które mogą być zmutowanych (lecz nie zmieniły, uważaj!) Dla podobny efekt bez konieczności powrotu pola.

class BetterModel:

  def __init__(self):
    self.bias = tf.Variable(0.)
    self.weight = tf.Variable(2.)

@tf.function
def evaluate(model, x):
  return model.weight * x + model.bias

better_model = BetterModel()
print(evaluate(better_model, x))

tf.Tensor(20.0, shape=(), dtype=float32)

print("Adding bias!")
better_model.bias.assign_add(5.0)  # Note: instead of better_model.bias += 5
print(evaluate(better_model, x))  # This works!

Adding bias!
tf.Tensor(25.0, shape=(), dtype=float32)

Tworzenie tf.Zmiennych

Function obsługuje tylko tworząc zmienne raz, kiedy po raz pierwszy nazywa, a następnie ich użyciem. Nie można tworzyć tf.Variables w nowych śladów. Tworzenie nowych zmiennych w kolejnych wywołaniach jest obecnie niedozwolone, ale będzie w przyszłości.

Przykład:

@tf.function
def f(x):
  v = tf.Variable(1.0)
  return v

with assert_raises(ValueError):
  f(1.0)

Caught expected exception 
  <class 'ValueError'>:
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/3018268426.py", line 7, in <module>
    f(1.0)
ValueError: in user code:

    /tmp/ipykernel_17014/3018268426.py:3 f  *
        v = tf.Variable(1.0)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:262 __call__  **
        return cls._variable_v2_call(*args, **kwargs)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:256 _variable_v2_call
        shape=shape)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:67 getter
        return captured_getter(captured_previous, **kwargs)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py:769 invalid_creator_scope
        "tf.function-decorated function tried to create "

    ValueError: tf.function-decorated function tried to create variables on non-first call.

Można tworzyć zmienne wewnątrz Function tak długo, jak te zmienne są tworzone tylko po raz pierwszy funkcja jest wykonywana.

class Count(tf.Module):
  def __init__(self):
    self.count = None

  @tf.function
  def __call__(self):
    if self.count is None:
      self.count = tf.Variable(0)
    return self.count.assign_add(1)

c = Count()
print(c())
print(c())

tf.Tensor(1, shape=(), dtype=int32)
tf.Tensor(2, shape=(), dtype=int32)

Używanie z wieloma optymalizatorami Keras

Można spotkać ValueError: tf.function-decorated function tried to create variables on non-first call. przy użyciu więcej niż jednego optymalizator Keras z tf.function . Ten błąd występuje, ponieważ optymalizujące wewnętrznie tworzyć tf.Variables gdy stosuje gradienty po raz pierwszy.

opt1 = tf.keras.optimizers.Adam(learning_rate = 1e-2)
opt2 = tf.keras.optimizers.Adam(learning_rate = 1e-3)

@tf.function
def train_step(w, x, y, optimizer):
   with tf.GradientTape() as tape:
       L = tf.reduce_sum(tf.square(w*x - y))
   gradients = tape.gradient(L, [w])
   optimizer.apply_gradients(zip(gradients, [w]))

w = tf.Variable(2.)
x = tf.constant([-1.])
y = tf.constant([2.])

train_step(w, x, y, opt1)
print("Calling `train_step` with different optimizer...")
with assert_raises(ValueError):
  train_step(w, x, y, opt2)

Calling `train_step` with different optimizer...
Caught expected exception 
  <class 'ValueError'>:
Traceback (most recent call last):
  File "/tmp/ipykernel_17014/3551158538.py", line 8, in assert_raises
    yield
  File "/tmp/ipykernel_17014/3167358578.py", line 18, in <module>
    train_step(w, x, y, opt2)
ValueError: in user code:

    /tmp/ipykernel_17014/3167358578.py:9 train_step  *
        optimizer.apply_gradients(zip(gradients, [w]))
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:636 apply_gradients  **
        self._create_all_weights(var_list)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:821 _create_all_weights
        _ = self.iterations
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:828 __getattribute__
        return super(OptimizerV2, self).__getattribute__(name)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:988 iterations
        aggregation=tf_variables.VariableAggregation.ONLY_FIRST_REPLICA)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:1194 add_weight
        aggregation=aggregation)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/tracking/base.py:815 _add_variable_with_custom_getter
        **kwargs_for_getter)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/keras/engine/base_layer_utils.py:139 make_variable
        shape=variable_shape if variable_shape else None)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:260 __call__
        return cls._variable_v1_call(*args, **kwargs)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:221 _variable_v1_call
        shape=shape)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/variables.py:67 getter
        return captured_getter(captured_previous, **kwargs)
    /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py:769 invalid_creator_scope
        "tf.function-decorated function tried to create "

    ValueError: tf.function-decorated function tried to create variables on non-first call.

Jeśli trzeba zmienić optymalizator podczas treningu, obejście tego problemu jest stworzenie nowej Function dla każdego optymalizatora, nazywając ConcreteFunction bezpośrednio.

opt1 = tf.keras.optimizers.Adam(learning_rate = 1e-2)
opt2 = tf.keras.optimizers.Adam(learning_rate = 1e-3)

# Not a tf.function.
def train_step(w, x, y, optimizer):
   with tf.GradientTape() as tape:
       L = tf.reduce_sum(tf.square(w*x - y))
   gradients = tape.gradient(L, [w])
   optimizer.apply_gradients(zip(gradients, [w]))

w = tf.Variable(2.)
x = tf.constant([-1.])
y = tf.constant([2.])

# Make a new Function and ConcreteFunction for each optimizer.
train_step_1 = tf.function(train_step).get_concrete_function(w, x, y, opt1)
train_step_2 = tf.function(train_step).get_concrete_function(w, x, y, opt2)
for i in range(10):
  if i % 2 == 0:
    train_step_1(w, x, y) # `opt1` is not used as a parameter. 
  else:
    train_step_2(w, x, y) # `opt2` is not used as a parameter.

Używanie z wieloma modelami Keras

Można również spotkać ValueError: tf.function-decorated function tried to create variables on non-first call. przechodząc różne instancje modelu do tej samej Function .

Ten błąd występuje, ponieważ modele Keras (które nie mają ich kształt wejścia zdefiniowane ) i warstw Keras tworzyć tf.Variables s przy ich pierwszym nazywa. Może być próbą zainicjowania tych zmiennych wewnątrz Function , która już została wywołana. Aby uniknąć tego błędu, spróbuj dzwoniąc model.build(input_shape) , aby zainicjować wszystkie ciężary przed treningiem modelu.

Dalsza lektura

Aby dowiedzieć się, jak wyeksportować i wczytać Function , patrz podręcznik SavedModel . Aby dowiedzieć się więcej na temat optymalizacji wykresu, które są wykonywane po śledzenia, zobacz przewodnik grapplerem . Aby dowiedzieć się, jak zoptymalizować swój profil rurociągu danych i modelu, patrz podręcznik Profiler .