Merken Sie den Termin vor! Google I / O kehrt vom 18. bis 20. Mai zurück Registrieren Sie sich jetzt
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Migrieren Sie Ihren TensorFlow 1-Code zu TensorFlow 2

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Dieses Handbuch richtet sich an Benutzer von TensorFlow-APIs auf niedriger Ebene. Wenn Sie die High-Level-APIs ( tf.keras ) verwenden, müssen Sie möglicherweise nur wenig oder gar keine Maßnahmen ergreifen, um Ihren Code vollständig TensorFlow 2.x-kompatibel zu machen:

Es ist weiterhin möglich, unveränderten 1.x-Code (mit Ausnahme von Contrib ) in TensorFlow 2.x auszuführen:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

Auf diese Weise können Sie jedoch viele der in TensorFlow 2.x vorgenommenen Verbesserungen nicht nutzen. Dieses Handbuch hilft Ihnen dabei, Ihren Code zu aktualisieren, wodurch er einfacher, leistungsfähiger und einfacher zu warten ist.

Automatisches Konvertierungsskript

Bevor Sie versuchen, die in diesem Handbuch beschriebenen Änderungen zu implementieren, müssen Sie zunächst versuchen, das Upgrade-Skript auszuführen .

Dadurch wird ein erster Durchgang beim Aktualisieren Ihres Codes auf TensorFlow 2.x ausgeführt, Ihr Code kann jedoch nicht für Version 2 idiomatisch werden. Ihr Code verwendet möglicherweise weiterhin tf.compat.v1 Endpunkte, um auf Platzhalter, Sitzungen, Sammlungen und andere Funktionen im 1.x-Stil zuzugreifen.

Verhaltensänderungen auf höchster Ebene

Wenn Ihr Code in TensorFlow 2.x mit tf.compat.v1.disable_v2_behavior , müssen Sie möglicherweise noch globale Verhaltensänderungen berücksichtigen. Die wichtigsten Änderungen sind:

  • v1.enable_eager_execution() Ausführung, v1.enable_eager_execution() : Jeder Code, der implizit einen tf.Graph verwendet, tf.Graph fehl. with tf.Graph().as_default() Sie sicher, dass Sie diesen Code in einen with tf.Graph().as_default() .

  • Ressourcenvariablen, v1.enable_resource_variables() : Einige Codes hängen möglicherweise von nicht deterministischen Verhaltensweisen ab, die durch TensorFlow-Referenzvariablen aktiviert werden. Ressourcenvariablen werden beim Schreiben gesperrt und bieten so intuitivere Konsistenzgarantien.

    • Dies kann das Verhalten in Randfällen ändern.
    • Dies kann zu zusätzlichen Kopien führen und zu einer höheren Speichernutzung führen.
    • Dies kann deaktiviert werden, indem use_resource=False an den Konstruktor tf.Variable .
  • v1.enable_v2_tensorshape() , v1.enable_v2_tensorshape() : TensorFlow 2.x vereinfacht das Verhalten von v1.enable_v2_tensorshape() . Anstelle von t.shape[0].value Sie t.shape[0] sagen. Diese Änderungen sollten klein sein, und es ist sinnvoll, sie sofort zu beheben. Beispiele finden Sie im Abschnitt TensorShape .

  • Kontrollfluss, v1.enable_control_flow_v2() : Die Implementierung des TensorFlow 2.x-Kontrollflusses wurde vereinfacht und erzeugt daher verschiedene Diagrammdarstellungen. Bitte melden Sie Fehler für alle Probleme.

Erstellen Sie Code für TensorFlow 2.x.

In diesem Handbuch werden einige Beispiele für die Konvertierung von TensorFlow 1.x-Code in TensorFlow 2.x beschrieben. Durch diese Änderungen kann Ihr Code Leistungsoptimierungen und vereinfachte API-Aufrufe nutzen.

In jedem Fall lautet das Muster:

1. Ersetzen Sie v1.Session.run Aufrufe

Jeder Aufruf von v1.Session.run sollte durch eine Python-Funktion ersetzt werden.

  • Die feed_dict und v1.placeholder werden zu Funktionsargumenten.
  • Die fetches werden zum Rückgabewert der Funktion.
  • Während der Konvertierung ermöglicht die eifrige Ausführung ein einfaches Debuggen mit Standard-Python-Tools wie pdb .

tf.function Sie anschließend einen tf.function Dekorator hinzu, damit er in der Grafik effizient ausgeführt wird. Weitere Informationen zur Funktionsweise finden Sie im Autogrammhandbuch .

Beachten Sie, dass:

  • Im Gegensatz zu v1.Session.run hat eine tf.function eine feste Rückgabesignatur und gibt immer alle Ausgaben zurück. Wenn dies zu Leistungsproblemen führt, erstellen Sie zwei separate Funktionen.

  • Es ist keine tf.control_dependencies oder ähnliche Operationen erforderlich: Eine tf.function verhält sich so, als würde sie in der angegebenen Reihenfolge ausgeführt. tf.Variable Zuweisungen und tf.assert werden beispielsweise automatisch ausgeführt.

Der Abschnitt zum Konvertieren von Modellen enthält ein Arbeitsbeispiel für diesen Konvertierungsprozess.

2. Verwenden Sie Python-Objekte, um Variablen und Verluste zu verfolgen

Von jeder namenbasierten Variablenverfolgung wird in TensorFlow 2.x dringend abgeraten. Verwenden Sie Python-Objekte, um Variablen zu verfolgen.

Verwenden Sie tf.Variable anstelle von v1.get_variable .

Jedes v1.variable_scope sollte in ein Python-Objekt konvertiert werden. In der Regel ist dies einer der folgenden:

Wenn Sie benötigen , um aggregierte Listen von Variablen (wie tf.Graph.get_collection(tf.GraphKeys.VARIABLES) ), die Verwendung .variables und .trainable_variables Attribute der Layer - und Model - Objekte.

Diese Layer und Model Klassen implementieren mehrere andere Eigenschaften, die die Notwendigkeit globaler Sammlungen beseitigen. Ihre .losses Eigenschaft kann ein Ersatz für die Verwendung der tf.GraphKeys.LOSSES Auflistung sein.

Weitere Informationen finden Sie in den Keras-Handbüchern .

3. Aktualisieren Sie Ihre Trainingsschleifen

Verwenden Sie die API der höchsten Ebene, die für Ihren Anwendungsfall geeignet ist. tf.keras.Model.fit Sie tf.keras.Model.fit Aufbau eigener Trainingsschleifen vor.

Diese Funktionen auf hoher Ebene verwalten viele Details auf niedriger Ebene, die leicht übersehen werden können, wenn Sie Ihre eigene Trainingsschleife schreiben. Beispielsweise erfassen sie automatisch die Regularisierungsverluste und setzen beim Aufruf des Modells das Argument training=True .

4. Aktualisieren Sie Ihre Dateneingabepipelines

Verwenden Sie tf.data Datasets für die Dateneingabe. Diese Objekte sind effizient, ausdrucksstark und lassen sich gut in den Tensorflow integrieren.

Sie können direkt an die Methode tf.keras.Model.fit werden.

model.fit(dataset, epochs=5)

Sie können über direktes Standard-Python iteriert werden:

for example_batch, label_batch in dataset:
    break

5. Migrieren Sie aus compat.v1 Symbolen von compat.v1

Das Modul tf.compat.v1 enthält die vollständige TensorFlow 1.x-API mit ihrer ursprünglichen Semantik.

Das TensorFlow 2.x-Upgrade-Skript konvertiert Symbole in ihre v2-Entsprechungen, wenn eine solche Konvertierung sicher ist, dh wenn festgestellt werden kann, dass das Verhalten der TensorFlow 2.x-Version genau gleichwertig ist (z. B. wird v1.arg_max zu tf.argmax , da diese die gleiche Funktion haben).

Nachdem das Upgrade-Skript mit einem Teil des Codes ausgeführt wurde, werden wahrscheinlich viele compat.v1 von compat.v1 . Es lohnt sich, den Code durchzugehen und diese manuell in das v2-Äquivalent zu konvertieren (es sollte im Protokoll erwähnt werden, falls es eines gibt).

Modelle konvertieren

Low-Level-Variablen & Operatorausführung

Beispiele für die Verwendung von APIs auf niedriger Ebene sind:

Vor dem Konvertieren

So können diese Muster im Code mit TensorFlow 1.x aussehen.

import tensorflow as tf
import tensorflow.compat.v1 as v1

import tensorflow_datasets as tfds
g = v1.Graph()

with g.as_default():
  in_a = v1.placeholder(dtype=v1.float32, shape=(2))
  in_b = v1.placeholder(dtype=v1.float32, shape=(2))

  def forward(x):
    with v1.variable_scope("matmul", reuse=v1.AUTO_REUSE):
      W = v1.get_variable("W", initializer=v1.ones(shape=(2,2)),
                          regularizer=lambda x:tf.reduce_mean(x**2))
      b = v1.get_variable("b", initializer=v1.zeros(shape=(2)))
      return W * x + b

  out_a = forward(in_a)
  out_b = forward(in_b)
  reg_loss=v1.losses.get_regularization_loss(scope="matmul")

with v1.Session(graph=g) as sess:
  sess.run(v1.global_variables_initializer())
  outs = sess.run([out_a, out_b, reg_loss],
                feed_dict={in_a: [1, 0], in_b: [0, 1]})

print(outs[0])
print()
print(outs[1])
print()
print(outs[2])
[[1. 0.]
 [1. 0.]]

[[0. 1.]
 [0. 1.]]

1.0

Nach dem Konvertieren

Im konvertierten Code:

  • Die Variablen sind lokale Python-Objekte.
  • Die forward definiert weiterhin die Berechnung.
  • Der Aufruf von Session.run wird durch einen Aufruf zum forward .
  • Der optionale tf.function Decorator kann zur Leistung hinzugefügt werden.
  • Die Regularisierungen werden manuell berechnet, ohne auf eine globale Sammlung Bezug zu nehmen.
  • Es werden keine Sitzungen oder Platzhalter verwendet .
W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")

@tf.function
def forward(x):
  return W * x + b

out_a = forward([1,0])
print(out_a)
tf.Tensor(
[[1. 0.]
 [1. 0.]], shape=(2, 2), dtype=float32)
out_b = forward([0,1])

regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)

Modelle basierend auf tf.layers

Das Modul v1.layers enthält Layer-Funktionen, die sich auf v1.variable_scope stützten, um v1.variable_scope zu definieren und wiederzuverwenden.

Vor dem Konvertieren

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    x = v1.layers.conv2d(x, 32, 3, activation=v1.nn.relu,
          kernel_regularizer=lambda x:0.004*tf.reduce_mean(x**2))
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    x = v1.layers.dropout(x, 0.1, training=training)
    x = v1.layers.dense(x, 64, activation=v1.nn.relu)
    x = v1.layers.batch_normalization(x, training=training)
    x = v1.layers.dense(x, 10)
    return x
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

print(train_out)
print()
print(test_out)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:414: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  warnings.warn('`tf.layers.conv2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py:2273: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  warnings.warn('`layer.apply` is deprecated and '
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.379358   -0.55901194  0.48704922  0.11619566  0.23902717  0.01691487
   0.07227738  0.14556988  0.2459927   0.2501198 ]], shape=(1, 10), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/pooling.py:310: UserWarning: `tf.layers.max_pooling2d` is deprecated and will be removed in a future version. Please use `tf.keras.layers.MaxPooling2D` instead.
  warnings.warn('`tf.layers.max_pooling2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:329: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  warnings.warn('`tf.layers.flatten` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:268: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  warnings.warn('`tf.layers.dropout` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:171: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  warnings.warn('`tf.layers.dense` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/normalization.py:308: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.keras.layers.BatchNormalization` instead. In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation).
  '`tf.layers.batch_normalization` is deprecated and '

Nach dem Konvertieren

Die meisten Argumente blieben gleich. Beachten Sie jedoch die Unterschiede:

  • Das training wird beim Ausführen vom Modell an jede Ebene übergeben.
  • Das erste Argument für die ursprüngliche model (die Eingabe x ) ist weg. Dies liegt daran, dass Objektebenen das Erstellen des Modells vom Aufrufen des Modells trennen.

Beachten Sie auch Folgendes:

0.

Gemischte Variablen & v1.layers

Vorhandener Code mischt häufig untergeordnete TensorFlow 1.x-Variablen und v1.layers mit übergeordneten v1.layers .

Vor dem Konvertieren

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    W = v1.get_variable(
      "W", dtype=v1.float32,
      initializer=v1.ones(shape=x.shape),
      regularizer=lambda x:0.004*tf.reduce_mean(x**2),
      trainable=True)
    if training:
      x = x + W
    else:
      x = x + W * 0.5
    x = v1.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

Nach dem Konvertieren

Befolgen Sie zum Konvertieren dieses Codes das Muster der Zuordnung von Ebenen zu Ebenen wie im vorherigen Beispiel.

Das allgemeine Muster lautet:

  • Sammeln Sie __init__ in __init__ .
  • Erstellen Sie die Variablen in build .
  • Führen Sie die Berechnungen im call und geben Sie das Ergebnis zurück.

Das v1.variable_scope ist im Wesentlichen eine eigene Ebene. tf.keras.layers.Layer es also als tf.keras.layers.Layer . Weitere Informationen finden Sie im Handbuch Neue Ebenen und Modelle über Unterklassen erstellen .

# Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
  def __init__(self, *args, **kwargs):
    super(CustomLayer, self).__init__(*args, **kwargs)

  def build(self, input_shape):
    self.w = self.add_weight(
        shape=input_shape[1:],
        dtype=tf.float32,
        initializer=tf.keras.initializers.ones(),
        regularizer=tf.keras.regularizers.l2(0.02),
        trainable=True)

  # Call method will sometimes get used in graph mode,
  # training will get turned into a tensor
  @tf.function
  def call(self, inputs, training=None):
    if training:
      return inputs + self.w
    else:
      return inputs + self.w * 0.5
custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
[1.5]
[2.]
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

# Build the model including the custom layer
model = tf.keras.Sequential([
    CustomLayer(input_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
])

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

Einige Dinge zu beachten:

  • Unterklassifizierte Keras-Modelle und -Ebenen müssen sowohl in v1-Diagrammen (keine automatischen Steuerungsabhängigkeiten) als auch im eifrigen Modus ausgeführt werden:

  • Vergessen Sie nicht, ein training zu akzeptieren, um Folgendes call :

    • Manchmal ist es ein tf.Tensor
    • Manchmal ist es ein Python-Boolescher Wert
  • Erstellen Sie Modellvariablen im Konstruktor oder Model.build mit `self.add_weight:

  • tf.Tensors Sie tf.Tensors in Ihren Objekten:

    • Sie können entweder in einer tf.function oder im eifrigen Kontext erzeugt werden, und diese Tensoren verhalten sich unterschiedlich
    • Verwenden Sie tf.Variable s für state, sie können immer aus beiden Kontexten verwendet werden
    • tf.Tensors sind nur für Zwischenwerte

Ein Hinweis zu Slim und Contrib.Layern

Eine große Menge älterer TensorFlow 1.x-Codes verwendet die Slim- Bibliothek, die mit TensorFlow 1.x als tf.contrib.layers . Als contrib Modul ist dies in TensorFlow 2.x nicht mehr verfügbar, auch nicht in tf.compat.v1 . Das Konvertieren von Code mit Slim in TensorFlow 2.x ist v1.layers als das Konvertieren von Repositorys, die v1.layers . In der Tat kann es sinnvoll sein, zuerst Ihren Slim-Code in v1.layers und dann in Keras zu konvertieren.

  • Entfernen Sie arg_scopes , alle Argumente müssen explizit sein.
  • Wenn Sie sie verwenden, teilen Sie normalizer_fn und activation_fn in ihre eigenen Ebenen auf.
  • Trennbare Conv-Ebenen werden einer oder mehreren verschiedenen Keras-Ebenen zugeordnet (Tiefen-, Punkt- und trennbare Keras-Ebenen).
  • Slim und v1.layers haben unterschiedliche Argumentnamen und Standardwerte.
  • Einige Argumente haben unterschiedliche Maßstäbe.
  • Wenn Sie vorab trainierte Slim-Modelle verwenden, probieren Sie die vorab festgelegten Modelle von Keras aus tf.keras.applications oder die aus dem ursprünglichen Slim-Code exportierten TensorFlow 2.x SavedModels von TF Hub aus.

Einige tf.contrib Ebenen wurden möglicherweise nicht in den Kern von TensorFlow verschoben, sondern in das TensorFlow-Addons-Paket .

Ausbildung

Es gibt viele Möglichkeiten, Daten einem tf.keras Modell tf.keras . Sie akzeptieren Python-Generatoren und Numpy-Arrays als Eingabe.

Die empfohlene Methode zum Einspeisen von Daten in ein Modell ist die Verwendung des Pakets tf.data , das eine Sammlung von Hochleistungsklassen zum Bearbeiten von Daten enthält.

Wenn Sie noch tf.queue , werden diese nur noch als Datenstrukturen und nicht mehr als Eingabe-Pipelines unterstützt.

Verwenden von TensorFlow-Datensätzen

Das TensorFlow Datasets- Paket ( tfds ) enthält Dienstprogramme zum Laden vordefinierter Datasets alstf.data.Dataset Objekte.

In diesem Beispiel können Sie das MNIST-Dataset mit tfds :

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1...
WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead pass
`try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`.
Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.

Bereiten Sie dann die Daten für das Training vor:

  • Skalieren Sie jedes Bild neu.
  • Mische die Reihenfolge der Beispiele.
  • Sammeln Sie Stapel von Bildern und Etiketten.
BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

Um das Beispiel kurz zu halten, schneiden Sie den Datensatz so, dass nur 5 Stapel zurückgegeben werden:

train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
image_batch, label_batch = next(iter(train_data))

Verwenden Sie Keras-Trainingsschleifen

Wenn Sie nicht über Low-Level - Kontrolle über Ihren Trainingsprozess benötigen, mit Keras eingebauter in fit , zu evaluate und predict Methoden empfohlen. Diese Methoden bieten eine einheitliche Schnittstelle zum Trainieren des Modells unabhängig von der Implementierung (sequentiell, funktional oder unterklassifiziert).

Die Vorteile dieser Methoden umfassen:

  • Sie akzeptieren Numpy-Arrays, Python-Generatoren und tf.data.Datasets .
  • Sie wenden Regularisierung und Aktivierungsverluste automatisch an.
  • Sie unterstützen tf.distribute für das Training mit mehreren Geräten .
  • Sie unterstützen beliebige Callables als Verluste und Metriken.
  • Sie unterstützen Rückrufe wie tf.keras.callbacks.TensorBoard und benutzerdefinierte Rückrufe.
  • Sie sind performant und verwenden automatisch TensorFlow-Diagramme.

Hier ist ein Beispiel für das Trainieren eines Modells mithilfe eines Dataset . (Einzelheiten dazu finden Sie im Abschnitt Tutorials .)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))
Epoch 1/5
5/5 [==============================] - 1s 9ms/step - loss: 2.0191 - accuracy: 0.3608
Epoch 2/5
5/5 [==============================] - 0s 9ms/step - loss: 0.4736 - accuracy: 0.9059
Epoch 3/5
5/5 [==============================] - 0s 8ms/step - loss: 0.2973 - accuracy: 0.9626
Epoch 4/5
5/5 [==============================] - 0s 9ms/step - loss: 0.2108 - accuracy: 0.9911
Epoch 5/5
5/5 [==============================] - 0s 8ms/step - loss: 0.1791 - accuracy: 0.9874
5/5 [==============================] - 0s 6ms/step - loss: 1.5504 - accuracy: 0.7500
Loss 1.5504140853881836, Accuracy 0.75

Schreiben Sie Ihre eigene Schleife

Wenn der Trainingsschritt des Keras-Modells für Sie funktioniert, Sie jedoch außerhalb dieses Schritts mehr Kontrolle benötigen, sollten Sie die Methode tf.keras.Model.train_on_batch in Ihrer eigenen tf.keras.Model.train_on_batch verwenden.

Denken Sie daran: Viele Dinge können als tf.keras.callbacks.Callback .

Diese Methode bietet viele der Vorteile der im vorherigen Abschnitt erwähnten Methoden, gibt dem Benutzer jedoch die Kontrolle über die äußere Schleife.

Sie können auch tf.keras.Model.test_on_batch oder tf.keras.Model.evaluate , um die Leistung während des Trainings zu überprüfen.

Um das obige Modell weiter zu trainieren:

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

for epoch in range(NUM_EPOCHS):
  # Reset the metric accumulators
  model.reset_metrics()

  for image_batch, label_batch in train_data:
    result = model.train_on_batch(image_batch, label_batch)
    metrics_names = model.metrics_names
    print("train: ",
          "{}: {:.3f}".format(metrics_names[0], result[0]),
          "{}: {:.3f}".format(metrics_names[1], result[1]))
  for image_batch, label_batch in test_data:
    result = model.test_on_batch(image_batch, label_batch,
                                 # Return accumulated metrics
                                 reset_metrics=False)
  metrics_names = model.metrics_names
  print("\neval: ",
        "{}: {:.3f}".format(metrics_names[0], result[0]),
        "{}: {:.3f}".format(metrics_names[1], result[1]))
train:  loss: 0.138 accuracy: 1.000
train:  loss: 0.161 accuracy: 1.000
train:  loss: 0.159 accuracy: 0.969
train:  loss: 0.241 accuracy: 0.953
train:  loss: 0.172 accuracy: 0.969

eval:  loss: 1.550 accuracy: 0.800
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.094 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.119 accuracy: 0.984
train:  loss: 0.099 accuracy: 1.000

eval:  loss: 1.558 accuracy: 0.841
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.061 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000

eval:  loss: 1.536 accuracy: 0.841
train:  loss: 0.059 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.058 accuracy: 1.000
train:  loss: 0.054 accuracy: 1.000
train:  loss: 0.055 accuracy: 1.000

eval:  loss: 1.497 accuracy: 0.863
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000

eval:  loss: 1.463 accuracy: 0.878

Passen Sie den Trainingsschritt an

Wenn Sie mehr Flexibilität und Kontrolle benötigen, können Sie dies tun, indem Sie Ihre eigene Trainingsschleife implementieren. Es gibt drei Schritte:

  1. Iterieren Sie über einen Python-Generator odertf.data.Dataset , umtf.data.Dataset von Beispielen zu erhalten.
  2. Verwenden Sietf.GradientTape , um Farbverläufe zu erfassen.
  3. Verwenden Sie einen der tf.keras.optimizers , um Gewichtsaktualisierungen auf die Variablen des Modells anzuwenden.

Merken:

  • Immer auch ein training Argument auf der call - Methode von subclassed Schichten und Modellen.
  • Stellen Sie sicher, dass Sie das Modell mit dem richtig eingestellten training aufrufen.
  • Je nach Verwendung sind Modellvariablen möglicherweise erst vorhanden, wenn das Modell für einen Datenstapel ausgeführt wird.
  • Sie müssen beispielsweise Regularisierungsverluste für das Modell manuell behandeln.

Beachten Sie die Vereinfachungen in Bezug auf Version 1:

  • Es ist nicht erforderlich, variable Initialisierer auszuführen. Variablen werden bei der Erstellung initialisiert.
  • Es ist nicht erforderlich, manuelle Steuerungsabhängigkeiten hinzuzufügen. Selbst in tf.function funktionieren Operationen wie im eifrigen Modus.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)
Finished epoch 0
Finished epoch 1
Finished epoch 2
Finished epoch 3
Finished epoch 4

Neue Metriken und Verluste

In TensorFlow 2.x sind Metriken und Verluste Objekte. Diese arbeiten sowohl eifrig als auch in tf.function .

Ein Verlustobjekt ist aufrufbar und erwartet (y_true, y_pred) als Argumente:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815

Ein metrisches Objekt verfügt über die folgenden Methoden:

Das Objekt selbst ist aufrufbar. Durch Aufrufen wird der Status wie bei update_state mit neuen Beobachtungen update_state und das neue Ergebnis der Metrik zurückgegeben.

Sie müssen die Variablen einer Metrik nicht manuell initialisieren, und da TensorFlow 2.x automatische Steuerungsabhängigkeiten aufweist, müssen Sie sich auch nicht um diese kümmern.

Der folgende Code verwendet eine Metrik, um den mittleren Verlust zu verfolgen, der in einer benutzerdefinierten Trainingsschleife beobachtet wird.

# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))
Epoch:  0
  loss:     0.139
  accuracy: 0.997
Epoch:  1
  loss:     0.116
  accuracy: 1.000
Epoch:  2
  loss:     0.105
  accuracy: 0.997
Epoch:  3
  loss:     0.089
  accuracy: 1.000
Epoch:  4
  loss:     0.078
  accuracy: 1.000

Keras-Metriknamen

In TensorFlow 2.x sind Keras-Modelle hinsichtlich der Behandlung von Metriknamen konsistenter.

Wenn Sie nun eine Zeichenfolge in der Liste der Metriken übergeben, wird diese genaue Zeichenfolge als name der Metrik verwendet. Diese Namen sind im von model.fit zurückgegebenen model.fit und in den an keras.callbacks Protokollen keras.callbacks . wird auf die Zeichenfolge festgelegt, die Sie in der Metrikliste übergeben haben.

model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
5/5 [==============================] - 1s 8ms/step - loss: 0.0901 - acc: 0.9923 - accuracy: 0.9923 - my_accuracy: 0.9923
history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

Dies unterscheidet sich von früheren Versionen, in denen das Übergeben von metrics=["accuracy"] zu dict_keys(['loss', 'acc'])

Keras-Optimierer

Die Optimierer in v1.train , wie z. B. v1.train.AdamOptimizer und v1.train.GradientDescentOptimizer , haben Entsprechungen in tf.keras.optimizers .

Konvertieren Sie v1.train in keras.optimizers

Beachten Sie beim Konvertieren Ihrer Optimierer Folgendes:

Neue tf.keras.optimizers für einige tf.keras.optimizers

Es gibt keine Änderungen für optimizers.SGD , optimizers.Adam oder optimizers.RMSprop .

Die folgenden Standardlernraten haben sich geändert:

TensorBoard

TensorFlow 2.x enthält wesentliche Änderungen an der tf.summary API, die zum Schreiben von Zusammenfassungsdaten für die Visualisierung in TensorBoard verwendet wird. Für eine allgemeine Einführung in die neue tf.summary stehen mehrere Tutorials zur Verfügung , die die TensorFlow 2.x-API verwenden. Dies beinhaltet ein TensorBoard TensorFlow 2.x-Migrationshandbuch .

Speichern und laden

Checkpoint-Kompatibilität

TensorFlow 2.x verwendet objektbasierte Prüfpunkte .

Wenn Sie vorsichtig sind, können weiterhin namenbasierte Checkpoints im alten Stil geladen werden. Der Codekonvertierungsprozess kann zu Änderungen des Variablennamens führen, es gibt jedoch Problemumgehungen.

Am einfachsten ist es, die Namen des neuen Modells mit den Namen im Checkpoint abzustimmen:

  • Variablen noch alle einen haben name Argument Sie einstellen können.
  • Keras Modelle auch einen name Argument als die sie für ihre Variablen als Präfix gesetzt.
  • Mit der Funktion v1.name_scope können Präfixe für Variablennamen festgelegt werden. Dies unterscheidet sich stark von tf.variable_scope . Es wirkt sich nur auf Namen aus und verfolgt keine Variablen und keine Wiederverwendung.

Wenn dies für Ihren Anwendungsfall nicht funktioniert, versuchen Sie die Funktion v1.train.init_from_checkpoint . Es ist ein assignment_map Argument erforderlich, das die Zuordnung von alten zu neuen Namen angibt.

Das TensorFlow Estimator-Repository enthält ein Konvertierungstool zum Aktualisieren der Prüfpunkte für vorgefertigte Schätzer von TensorFlow 1.x auf 2.0. Es kann als Beispiel dafür dienen, wie ein Tool für einen ähnlichen Anwendungsfall erstellt wird.

Kompatibilität der gespeicherten Modelle

Es gibt keine wesentlichen Kompatibilitätsprobleme für gespeicherte Modelle.

  • TensorFlow 1.x saved_models funktionieren in TensorFlow 2.x.
  • TensorFlow 2.x saved_models funktionieren in TensorFlow 1.x, wenn alle Operationen unterstützt werden.

Eine Graph.pb oder Graph.pbtxt

Es gibt keine einfache Möglichkeit, eine Graph.pb Datei auf TensorFlow 2.x zu aktualisieren. Am besten aktualisieren Sie den Code, der die Datei generiert hat.

Wenn Sie jedoch ein "eingefrorenes Diagramm" haben (ein tf.Graph in dem die Variablen in Konstanten umgewandelt wurden), können Sie dies mit v1.wrap_function in eine concrete_function v1.wrap_function :

def wrap_frozen_graph(graph_def, inputs, outputs):
  def _imports_graph_def():
    tf.compat.v1.import_graph_def(graph_def, name="")
  wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
  import_graph = wrapped_import.graph
  return wrapped_import.prune(
      tf.nest.map_structure(import_graph.as_graph_element, inputs),
      tf.nest.map_structure(import_graph.as_graph_element, outputs))

Hier ist zum Beispiel ein eingefrorenes Diagramm für Inception v1 aus dem Jahr 2016:

path = tf.keras.utils.get_file(
    'inception_v1_2016_08_28_frozen.pb',
    'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
    untar=True)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz
24698880/24695710 [==============================] - 1s 0us/step

Laden Sie das tf.GraphDef :

graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())

Wickeln Sie es in eine concrete_function :

inception_func = wrap_frozen_graph(
    graph_def, inputs='input:0',
    outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')

Übergeben Sie einen Tensor als Eingabe:

input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
TensorShape([1, 28, 28, 96])

Schätzer

Schulung mit Schätzern

Schätzer werden in TensorFlow 2.x unterstützt.

Wenn Sie Schätzer verwenden, können Sie input_fn , tf.estimator.TrainSpec und tf.estimator.EvalSpec von TensorFlow 1.x verwenden.

Hier ist ein Beispiel für die Verwendung von input_fn mit Zug- und Auswertungsspezifikationen.

Erstellen der Spezifikationen input_fn und train / eval

# Define the estimator's input_fn
def input_fn():
  datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
  mnist_train, mnist_test = datasets['train'], datasets['test']

  BUFFER_SIZE = 10000
  BATCH_SIZE = 64

  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255

    return image, label[..., tf.newaxis]

  train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  return train_data.repeat()

# Define train and eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
                                    max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
                                  steps=STEPS_PER_EPOCH)

Verwenden einer Keras-Modelldefinition

Es gibt einige Unterschiede bei der Erstellung Ihrer Schätzer in TensorFlow 2.x.

Es wird empfohlen, dass Sie Ihr Modell mit Keras definieren und dann das Dienstprogramm tf.keras.estimator.model_to_estimator , um Ihr Modell in einen Schätzer tf.keras.estimator.model_to_estimator . Der folgende Code zeigt, wie Sie dieses Dienstprogramm beim Erstellen und Trainieren eines Schätzers verwenden.

def make_model():
  return tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
  ])
model = make_model()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(
  keras_model = model
)

tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
INFO:tensorflow:Using the Keras model provided.
INFO:tensorflow:Using the Keras model provided.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/backend.py:434: UserWarning: `tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.
  warnings.warn('`tf.keras.backend.set_learning_phase` is deprecated and '
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  warnings.warn('`Model.state_updates` will be removed in a future version. '
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.37597787.
INFO:tensorflow:Loss for final step: 0.37597787.
({'accuracy': 0.6, 'loss': 1.6160676, 'global_step': 25}, [])

Verwenden eines benutzerdefinierten model_fn

Wenn Sie über einen vorhandenen benutzerdefinierten Schätzer model_fn , den Sie pflegen müssen, können Sie Ihren model_fn in ein Keras-Modell konvertieren.

Aus Kompatibilitätsgründen wird ein benutzerdefiniertes model_fn jedoch weiterhin im Diagrammmodus im 1.x-Stil ausgeführt. Dies bedeutet, dass es keine eifrige Ausführung und keine automatischen Steuerungsabhängigkeiten gibt.

Benutzerdefiniertes model_fn mit minimalen Änderungen

Damit Ihr benutzerdefiniertes model_fn in TensorFlow 2.x tf.compat.v1 , können tf.compat.v1 Symbole wie optimizers und metrics verwendet werden, wenn Sie minimale Änderungen am vorhandenen Code bevorzugen.

Die Verwendung eines Keras-Modells in einem benutzerdefinierten model_fn ähnelt der Verwendung in einer benutzerdefinierten Trainingsschleife:

  • Stellen Sie die training in geeigneter Weise auf der Grundlage des mode Argument.
  • Übergeben Sie die trainable_variables des Modells explizit an den Optimierer.

In Bezug auf eine benutzerdefinierte Schleife gibt es jedoch wichtige Unterschiede:

  • Anstatt Model.losses , extrahieren Sie die Verluste mit Model.get_losses_for .
  • Extrahieren Sie die Aktualisierungen des Modells mit Model.get_updates_for .

Der folgende Code erstellt einen Schätzer aus einem benutzerdefinierten model_fn , der alle diese model_fn veranschaulicht.

def my_model_fn(features, labels, mode):
  model = make_model()

  optimizer = tf.compat.v1.train.AdamOptimizer()
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  predictions = model(features, training=training)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)

  accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
                                           predictions=tf.math.argmax(predictions, axis=1),
                                           name='acc_op')

  update_ops = model.get_updates_for(None) + model.get_updates_for(features)
  minimize_op = optimizer.minimize(
      total_loss,
      var_list=model.trainable_variables,
      global_step=tf.compat.v1.train.get_or_create_global_step())
  train_op = tf.group(minimize_op, update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op, eval_metric_ops={'accuracy': accuracy})

# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.35726172.
INFO:tensorflow:Loss for final step: 0.35726172.
({'accuracy': 0.59375, 'loss': 1.6248872, 'global_step': 25}, [])

Benutzerdefiniertes model_fn mit TensorFlow 2.x-Symbolen

Wenn Sie alle TensorFlow 1.x-Symbole model_fn und Ihr benutzerdefiniertes model_fn auf TensorFlow 2.x aktualisieren model_fn , müssen Sie den Optimierer und die Metriken auf tf.keras.optimizers und tf.keras.metrics .

Im benutzerdefinierten model_fn müssen neben den oben genannten Änderungen weitere Upgrades vorgenommen werden:

Für das obige Beispiel von my_model_fn wird der migrierte Code mit TensorFlow 2.x-Symbolen wie folgt angezeigt:

def my_model_fn(features, labels, mode):
  model = make_model()

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  predictions = model(features, training=training)

  # Get both the unconditional losses (the None part)
  # and the input-conditional losses (the features part).
  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)

  # Upgrade to tf.keras.metrics.
  accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
  accuracy = accuracy_obj.update_state(
      y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))

  train_op = None
  if training:
    # Upgrade to tf.keras.optimizers.
    optimizer = tf.keras.optimizers.Adam()
    # Manually assign tf.compat.v1.global_step variable to optimizer.iterations
    # to make tf.compat.v1.train.global_step increased correctly.
    # This assignment is a must for any `tf.train.SessionRunHook` specified in
    # estimator, as SessionRunHooks rely on global step.
    optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
    # Get both the unconditional updates (the None part)
    # and the input-conditional updates (the features part).
    update_ops = model.get_updates_for(None) + model.get_updates_for(features)
    # Compute the minimize_op.
    minimize_op = optimizer.get_updates(
        total_loss,
        model.trainable_variables)[0]
    train_op = tf.group(minimize_op, *update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op,
    eval_metric_ops={'Accuracy': accuracy_obj})

# Create the Estimator and train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.47094986.
INFO:tensorflow:Loss for final step: 0.47094986.
({'Accuracy': 0.59375, 'loss': 1.7570661, 'global_step': 25}, [])

Vorgefertigte Schätzer

Vorgefertigte Schätzer in der Familie von tf.estimator.DNN* , tf.estimator.Linear* und tf.estimator.DNNLinearCombined* werden weiterhin in der TensorFlow 2.x-API unterstützt. Einige Argumente haben sich jedoch geändert:

  1. input_layer_partitioner : In input_layer_partitioner entfernt.
  2. loss_reduction : Aktualisiert auf tf.keras.losses.Reduction anstelle von tf.compat.v1.losses.Reduction . Der Standardwert wird auch von tf.compat.v1.losses.Reduction.SUM in tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE tf.compat.v1.losses.Reduction.SUM .
  3. optimizer , dnn_optimizer und linear_optimizer : Dieses Argument wurde anstelle des tf.compat.v1.train.Optimizer auf tf.keras.optimizers aktualisiert.

So migrieren Sie die oben genannten Änderungen:

  1. Für input_layer_partitioner ist keine Migration erforderlich, da die Distribution Strategy dies in TensorFlow 2.x automatisch übernimmt.
  2. Überprüfen tf.keras.losses.Reduction für loss_reduction tf.keras.losses.Reduction auf die unterstützten Optionen.
  3. Für optimizer :

Checkpoint Converter

Die Migration zu keras.optimizers mit TensorFlow 1.x gespeicherte Prüfpunkte, da tf.keras.optimizers einen anderen Satz von Variablen generiert, die in Prüfpunkten gespeichert werden sollen. Probieren Sie das Checkpoint Converter-Tool aus , um den alten Checkpoint nach Ihrer Migration zu TensorFlow 2.x wiederverwendbar zu machen.

 curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 15165  100 15165    0     0  40656      0 --:--:-- --:--:-- --:--:-- 40656

Das Tool verfügt über eine integrierte Hilfe:

 python checkpoint_converter.py -h
2021-01-06 02:31:26.297951: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0
usage: checkpoint_converter.py [-h]
                               {dnn,linear,combined} source_checkpoint
                               source_graph target_checkpoint

positional arguments:
  {dnn,linear,combined}
                        The type of estimator to be converted. So far, the
                        checkpoint converter only supports Canned Estimator.
                        So the allowed types include linear, dnn and combined.
  source_checkpoint     Path to source checkpoint file to be read in.
  source_graph          Path to source graph file to be read in.
  target_checkpoint     Path to checkpoint file to be written out.

optional arguments:
  -h, --help            show this help message and exit

TensorShape

Diese Klasse wurde vereinfacht, um int s anstelle von tf.compat.v1.Dimension Objekten zu halten. Es ist also nicht erforderlich, .value , um ein int .

Auf einzelne tf.compat.v1.Dimension Objekte kann weiterhin über tf.TensorShape.dims .

Das Folgende zeigt die Unterschiede zwischen TensorFlow 1.x und TensorFlow 2.x.

# Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
TensorShape([16, None, 256])

Wenn Sie dies in TensorFlow 1.x hatten:

value = shape[i].value

Dann machen Sie dies in TensorFlow 2.x:

value = shape[i]
value
16

Wenn Sie dies in TensorFlow 1.x hatten:

for dim in shape:
    value = dim.value
    print(value)

Dann machen Sie dies in TensorFlow 2.x:

for value in shape:
  print(value)
16
None
256

Wenn Sie dies in TensorFlow 1.x hatten (oder eine andere Dimensionsmethode verwendet haben):

dim = shape[i]
dim.assert_is_compatible_with(other_dim)

Dann machen Sie dies in TensorFlow 2.x:

other_dim = 16
Dimension = tf.compat.v1.Dimension

if shape.rank is None:
  dim = Dimension(None)
else:
  dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
True
shape = tf.TensorShape(None)

if shape:
  dim = shape.dims[i]
  dim.is_compatible_with(other_dim) # or any other dimension method

Der boolesche Wert einer tf.TensorShape ist True wenn der Rang bekannt ist, andernfalls False .

print(bool(tf.TensorShape([])))      # Scalar
print(bool(tf.TensorShape([0])))     # 0-length vector
print(bool(tf.TensorShape([1])))     # 1-length vector
print(bool(tf.TensorShape([None])))  # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100])))       # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None)))  # A tensor with unknown rank.
True
True
True
True
True
True

False

Andere Änderungen

  • Entfernen Sie tf.colocate_with : Die Geräteplatzierungsalgorithmen von TensorFlow haben sich erheblich verbessert. Dies sollte nicht länger notwendig sein. Wenn das Entfernen zu einer Leistungsminderung führt, melden Sie bitte einen Fehler .

  • Ersetzen v1.ConfigProto Verwendung von tf.config durch die entsprechenden Funktionen von tf.config .

Schlussfolgerungen

Der Gesamtprozess ist:

  1. Führen Sie das Upgrade-Skript aus.
  2. Entfernen Sie Contrib-Symbole.
  3. Wechseln Sie Ihre Modelle zu einem objektorientierten Stil (Keras).
  4. Verwenden tf.keras tf.estimator tf.keras oder tf.estimator Trainings- und Bewertungsschleifen.
  5. Verwenden Sie andernfalls benutzerdefinierte Schleifen. Vermeiden Sie jedoch Sitzungen und Sammlungen.

Das Konvertieren von Code in idiomatisches TensorFlow 2.x erfordert ein wenig Arbeit, aber jede Änderung führt zu:

  • Weniger Codezeilen.
  • Erhöhte Klarheit und Einfachheit.
  • Einfacheres Debuggen.