Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Funktion

TensorFlow 1 Version Quelle auf GitHub anzeigen

Kompiliert eine Funktion in ein aufrufbares TensorFlow-Diagramm.

Wird in den Notizbüchern verwendet

Wird in der Anleitung verwendet Wird in den Tutorials verwendet

tf.function Konstrukte eine aufrufbare dass führt eine TensorFlow Graph ( tf.Graph ) durch die Spur-Kompilierung der TensorFlow Operationen erstellt func , effektiv ausführt func als TensorFlow Graphen.

Anwendungsbeispiel:

@tf.function
def f(x, y):
  return x ** 2 + y
x = tf.constant([2, 3])
y = tf.constant([3, -2])
f(x, y)
<tf.Tensor: ... numpy=array([7, 7], ...)>

Eigenschaften

func möglicherweise einen datenabhängigen Kontrollfluss, einschließlich der Anweisungen if , for , while break , continue und return :

@tf.function
def f(x):
  if tf.reduce_sum(x) > 0:
    return x * x
  else:
    return -x // 2
f(tf.constant(-2))
<tf.Tensor: ... numpy=1>

func ‚s - Verschluss kann tf.Tensor und tf.Variable Objekte:

@tf.function
def f():
  return x ** 2 + y
x = tf.constant([-2, -3])
y = tf.Variable([3, -2])
f()
<tf.Tensor: ... numpy=array([7, 7], ...)>

func kann auch tf.print mit Nebenwirkungen wie tf.print , tf.Variable und anderen verwenden:

v = tf.Variable(1)
@tf.function
def f(x):
  for i in tf.range(x):
    v.assign_add(i)
f(3)
v
<tf.Variable ... numpy=4>
l = []
@tf.function
def f(x):
  for i in x:
    l.append(i + 1)    # Caution! Will only happen once when tracing
f(tf.constant([1, 2, 3]))
l
[<tf.Tensor ...>]

Verwenden Sie stattdessen TensorFlow-Sammlungen wie tf.TensorArray :

@tf.function
def f(x):
  ta = tf.TensorArray(dtype=tf.int32, size=0, dynamic_size=True)
  for i in range(len(x)):
    ta = ta.write(i, x[i] + 1)
  return ta.stack()
f(tf.constant([1, 2, 3]))
<tf.Tensor: ..., numpy=array([2, 3, 4], ...)>

tf.function ist polymorph

Intern kann tf.function mehr als ein Diagramm tf.function , um Argumente mit unterschiedlichen Datentypen oder Formen zu unterstützen, da TensorFlow effizientere Diagramme erstellen kann, die auf Formen und d-Typen spezialisiert sind. tf.function behandelt auch jeden reinen Python-Wert als undurchsichtige Objekte und erstellt für jeden Satz von Python-Argumenten, auf den er stößt, ein separates Diagramm.

Um ein individuelles Diagramm zu erhalten, verwenden Sie die Methode get_concrete_function des durch tf.function erstellten tf.function . Es kann mit den gleichen Argumenten wie genannt wird func und gibt ein spezielles tf.Graph Objekt:

@tf.function
def f(x):
  return x + 1
isinstance(f.get_concrete_function(1).graph, tf.Graph)
True
@tf.function
def f(x):
  return tf.abs(x)
f1 = f.get_concrete_function(1)
f2 = f.get_concrete_function(2)  # Slow - builds new graph
f1 is f2
False
f1 = f.get_concrete_function(tf.constant(1))
f2 = f.get_concrete_function(tf.constant(2))  # Fast - reuses f1
f1 is f2
True

Numerische Python-Argumente sollten nur verwendet werden, wenn sie nur wenige unterschiedliche Werte annehmen, z. B. Hyperparameter wie die Anzahl der Schichten in einem neuronalen Netzwerk.

Signaturen eingeben

Für Tensor-Argumente instanziiert tf.function ein separates Diagramm für jeden eindeutigen Satz von Eingabeformen und Datentypen. Im folgenden Beispiel werden zwei separate Diagramme erstellt, die jeweils auf eine andere Form spezialisiert sind:

@tf.function
def f(x):
  return x + 1
vector = tf.constant([1.0, 1.0])
matrix = tf.constant([[3.0]])
f.get_concrete_function(vector) is f.get_concrete_function(matrix)
False

Optional kann eine "Eingabesignatur" bereitgestellt tf.function , um die verfolgten Graphen zu steuern. Die Eingabesignatur gibt die Form und den Typ jedes Tensor-Arguments für die Funktion mithilfe eines tf.TensorSpec Objekts an. Es können allgemeinere Formen verwendet werden. Dies ist nützlich, um zu vermeiden, dass mehrere Diagramme erstellt werden, wenn Tensoren dynamische Formen haben. Es schränkt auch die Form und den Datentyp der Tensoren ein, die verwendet werden können:

@tf.function(
    input_signature=[tf.TensorSpec(shape=None, dtype=tf.float32)])
def f(x):
  return x + 1
vector = tf.constant([1.0, 1.0])
matrix = tf.constant([[3.0]])
f.get_concrete_function(vector) is f.get_concrete_function(matrix)
True

Variablen dürfen nur einmal erstellt werden

tf.function nur beim ersten tf.Variable neue tf.Variable Objekte erstellt werden:

class MyModule(tf.Module):
  def __init__(self):
    self.v = None