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 Führen Sie in Google Colab aus Quelle auf GitHub anzeigen Notizbuch herunterladen

Dieses Dokument 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.0-kompatibel zu machen:

In TensorFlow 2.0 ist es weiterhin möglich, unveränderten 1.X-Code (mit Ausnahme von Contrib) auszuführen:

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

Auf diese Weise können Sie jedoch viele der in TensorFlow 2.0 vorgenommenen Verbesserungen nicht nutzen. Dieses Handbuch hilft Ihnen beim Aktualisieren Ihres Codes und macht ihn einfacher, leistungsfähiger und einfacher zu warten.

Automatisches Konvertierungsskript

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

Dies führt einen ersten Durchgang beim Upgrade Ihres Codes auf TensorFlow 2.0 durch. Aber es kann Ihren Code nicht idiomatisch für 2.0 machen. 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.0 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 TF-Referenzvariablen aktiviert werden. Ressourcenvariablen werden beim Schreiben gesperrt und bieten so intuitivere Konsistenzgarantien.

    • Dies kann das Verhalten in Randfällen ändern.
    • Dies kann zusätzliche Kopien erstellen und eine höhere Speichernutzung haben.
    • Dies kann deaktiviert werden, indem use_resource=False an den Konstruktor tf.Variable .
  • v1.enable_v2_tensorshape() , v1.enable_v2_tensorshape() : TF 2.0 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 unter TensorShape .

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

Machen Sie den Code 2.0-native

In diesem Handbuch werden einige Beispiele für die Konvertierung von TensorFlow 1.x-Code in TensorFlow 2.0 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 werden kann. Weitere Informationen zur Funktionsweise finden Sie im Autogrammhandbuch .

Beachten Sie, dass:

  • Im Gegensatz zu v1.Session.run 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 TF 2.0 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-Anleitungen .

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 TF2-Upgrade-Skript konvertiert Symbole in ihre 2.0-Entsprechungen, wenn eine solche Konvertierung sicher ist, dh wenn es feststellen kann, dass das Verhalten der 2.0-Version genau gleichwertig ist (z. B. wird v1.arg_max in tf.argmax , da das sind die gleichen Funktionen).

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

Modelle konvertieren

Low-Level-Variablen und 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.
  • Keine Sitzungen oder Platzhalter.
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)
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:4: conv2d (from tensorflow.python.keras.legacy_tf_layers.convolutional) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.keras.layers.Conv2D` instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:424: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.__call__` method instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:5: max_pooling2d (from tensorflow.python.keras.legacy_tf_layers.pooling) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.MaxPooling2D instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:6: flatten (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.Flatten instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:7: dropout (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.dropout instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:8: dense (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.Dense instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:9: batch_normalization (from tensorflow.python.keras.legacy_tf_layers.normalization) is deprecated and will be removed in a future version.
Instructions for updating:
Use 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.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.07562444 -0.27538717  0.21692204  0.2411264  -0.01209673 -0.0923705
   0.19058049 -0.00468709 -0.17215249 -0.07528099]], shape=(1, 10), dtype=float32)

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:

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.04),
                           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)
])

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)
print(train_out)
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

test_out = model(test_data, training=False)
print(test_out)
tf.Tensor(
[[-0.32132083  0.22252844 -0.11330387 -0.4613616  -0.08817139 -0.52697927
  -0.1538124   0.23069203 -0.15860984 -0.453844  ]], shape=(1, 10), dtype=float32)

# Here are all the trainable variables.
len(model.trainable_variables)
8
# Here is the regularization loss.
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.08671833>]

Gemischte Variablen & v1.layers

Bestehender Code mischt häufig TF 1.x-Variablen und Operationen auf niedrigerer Ebene mit v1.layers höherer Ebene.

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 . Einzelheiten finden Sie in der Anleitung .

# 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:

  • Untergeordnete 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 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 & Contrib.Layer

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.0 nicht mehr verfügbar, auch nicht in tf.compat.v1 . Das Konvertieren von Code mit Slim in TF 2.0 ist v1.layers als das Konvertieren von Repositorys mit 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 v1.layers Namen und Standardwerte
  • Einige Argumente haben unterschiedliche Maßstäbe
  • Wenn Sie vorgefertigte Slim-Modelle verwenden, probieren Sie Keras 'vorgefertigte Modelle aus tf.keras.applications oder TF Hubs TF2 SavedModels aus, die aus dem ursprünglichen Slim-Code exportiert wurden.

Einige tf.contrib Ebenen wurden möglicherweise nicht in den Kern von TensorFlow verschoben, sondern in das TF-Add-On-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.

Datensätze verwenden

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

Laden Sie in diesem Beispiel 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 geringe 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 in den 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 [==============================] - 0s 6ms/step - loss: 1.5665 - accuracy: 0.4969
Epoch 2/5
5/5 [==============================] - 0s 6ms/step - loss: 0.5249 - accuracy: 0.8656
Epoch 3/5
5/5 [==============================] - 0s 5ms/step - loss: 0.3246 - accuracy: 0.9438
Epoch 4/5
5/5 [==============================] - 0s 6ms/step - loss: 0.2407 - accuracy: 0.9719
Epoch 5/5
5/5 [==============================] - 0s 5ms/step - loss: 0.1841 - accuracy: 0.9906
5/5 [==============================] - 0s 4ms/step - loss: 1.5957 - accuracy: 0.5375
Loss 1.5956770181655884, Accuracy 0.5375000238418579

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 genannten 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.145 accuracy: 1.000
train:  loss: 0.183 accuracy: 0.984
train:  loss: 0.216 accuracy: 0.953
train:  loss: 0.229 accuracy: 0.938
train:  loss: 0.201 accuracy: 0.969

eval:  loss: 1.588 accuracy: 0.628
train:  loss: 0.097 accuracy: 1.000
train:  loss: 0.101 accuracy: 1.000
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.130 accuracy: 0.984
train:  loss: 0.127 accuracy: 1.000

eval:  loss: 1.580 accuracy: 0.766
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.081 accuracy: 1.000
train:  loss: 0.079 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.077 accuracy: 1.000

eval:  loss: 1.542 accuracy: 0.809
train:  loss: 0.067 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.063 accuracy: 1.000
train:  loss: 0.063 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000

eval:  loss: 1.503 accuracy: 0.816
train:  loss: 0.055 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.048 accuracy: 1.000
train:  loss: 0.051 accuracy: 1.000
train:  loss: 0.048 accuracy: 1.000

eval:  loss: 1.482 accuracy: 0.828

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 oder tf.data.Dataset , um tf.data.Dataset von Beispielen zu erhalten.
  2. Verwenden Sie tf.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.
  • Abhängig von der 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.0 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.0 über automatische Steuerungsabhängigkeiten verfügt, 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.207
  accuracy: 0.991
Epoch:  1
  loss:     0.167
  accuracy: 0.994
Epoch:  2
  loss:     0.147
  accuracy: 0.997
Epoch:  3
  loss:     0.123
  accuracy: 0.997
Epoch:  4
  loss:     0.109
  accuracy: 0.997

Keras-Metriknamen

In TensorFlow 2.0 sind Keras-Modelle konsistenter im Umgang mit Metriknamen.

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 [==============================] - 0s 6ms/step - loss: 0.1233 - acc: 0.9937 - accuracy: 0.9937 - my_accuracy: 0.9937

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 haben wie v1.train.AdamOptimizer und v1.train.GradientDescentOptimizer 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 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 TF 2-API verwenden. Dies beinhaltet ein TensorBoard TF 2-Migrationshandbuch

Speichern & Laden

Checkpoint-Kompatibilität

TensorFlow 2.0 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 Prüfpunkt 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ätsbedenken 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.0 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 dieses 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.0 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 Bewertungsspezifikationen.

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 & 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.0.

Wir empfehlen, 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/tmp333woaev

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp333woaev

INFO:tensorflow:Using the Keras model provided.

INFO:tensorflow:Using the Keras model provided.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/keras.py:220: set_learning_phase (from tensorflow.python.keras.backend) is deprecated and will be removed after 2020-10-11.
Instructions for updating:
Simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/keras.py:220: set_learning_phase (from tensorflow.python.keras.backend) is deprecated and will be removed after 2020-10-11.
Instructions for updating:
Simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp333woaev', '_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, '_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/tmp333woaev', '_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, '_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/tmp333woaev/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/tmp333woaev/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/tmp333woaev/keras/keras_model.ckpt

INFO:tensorflow:Warm-starting from: /tmp/tmp333woaev/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/tmp333woaev/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp333woaev/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.946777, step = 0

INFO:tensorflow:loss = 2.946777, 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/tmp333woaev/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp333woaev/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.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training_v1.py:2048: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training_v1.py:2048: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:37Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:37Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmp333woaev/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.84716s

INFO:tensorflow:Inference Time : 0.84716s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:38

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:38

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.715625, global_step = 25, loss = 1.5356585

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.715625, global_step = 25, loss = 1.5356585

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.52498615.

INFO:tensorflow:Loss for final step: 0.52498615.

({'accuracy': 0.715625, 'loss': 1.5356585, '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 TF 2.0 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/tmpnhx_c2r_

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpnhx_c2r_

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpnhx_c2r_', '_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, '_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/tmpnhx_c2r_', '_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, '_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/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.7539256, step = 0

INFO:tensorflow:loss = 2.7539256, 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/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpnhx_c2r_/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 2020-10-15T01:27:41Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:41Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmpnhx_c2r_/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.94175s

INFO:tensorflow:Inference Time : 0.94175s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:42

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:42

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.678125, global_step = 25, loss = 1.5622549

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.678125, global_step = 25, loss = 1.5622549

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.39462265.

INFO:tensorflow:Loss for final step: 0.39462265.

({'accuracy': 0.678125, 'loss': 1.5622549, 'global_step': 25}, [])

Benutzerdefiniertes model_fn mit TF 2.0-Symbolen

Wenn Sie alle TF 1.x-Symbole model_fn und Ihr benutzerdefiniertes model_fn auf natives TF 2.0 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 2.0-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 & 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/tmp3kddt__h

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp3kddt__h

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp3kddt__h', '_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, '_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/tmp3kddt__h', '_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, '_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/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.4914804, step = 0

INFO:tensorflow:loss = 2.4914804, 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/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp3kddt__h/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 2020-10-15T01:27:45Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:45Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmp3kddt__h/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.91708s

INFO:tensorflow:Inference Time : 0.91708s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:46

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:46

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.690625, global_step = 25, loss = 1.554177

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.690625, global_step = 25, loss = 1.554177

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.3999393.

INFO:tensorflow:Loss for final step: 0.3999393.

({'Accuracy': 0.690625, 'loss': 1.554177, 'global_step': 25}, [])

Vorgefertigte Schätzer

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

  1. input_layer_partitioner : In 2.0 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 tf.keras.optimizers auf tf.keras.optimizers anstelle des tf.compat.v1.train.Optimizer aktualisiert.

So migrieren Sie die oben genannten Änderungen:

  1. Für input_layer_partitioner ist keine Migration erforderlich, da die Distribution Strategy dies in TF 2.0 automatisch übernimmt.
  2. Überprüfen tf.keras.losses.Reduction für loss_reduction tf.keras.losses.Reduction auf die unterstützten Optionen.
  3. Wenn Sie für optimizer kein optimizer , dnn_optimizer oder linear_optimizer dnn_optimizer oder das optimizer als string in Ihrem Code angeben, müssen Sie nichts ändern. tf.keras.optimizers wird tf.keras.optimizers verwendet. Andernfalls müssen Sie es von tf.compat.v1.train.Optimizer auf die entsprechenden tf.keras.optimizers

Checkpoint Converter

Bei der Migration zu keras.optimizers werden mit TF 1.x gespeicherte Prüfpunkte tf.keras.optimizers , da tf.keras.optimizers einen anderen Satz von Variablen generiert, die in Prüfpunkten gespeichert werden sollen. Versuchen Sie das Checkpoint Converter-Tool, um alte Checkpoints nach Ihrer Migration auf TF 2.0 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  32265      0 --:--:-- --:--:-- --:--:-- 32197

Das Tool verfügt über eine integrierte Hilfe:

 python checkpoint_converter.py -h
2020-10-15 01:27:47.423752: I tensorflow/stream_executor/platform/default/dso_loader.cc:48] Successfully opened dynamic library libcudart.so.10.1
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.0.

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

Wenn Sie dies in TF 1.x hatten:

value = shape[i].value

Dann machen Sie dies in TF 2.0:

value = shape[i]
value
16

Wenn Sie dies in TF 1.x hatten:

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

Dann machen Sie dies in TF 2.0:

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

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

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

Dann machen Sie dies in TF 2.0:

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

Sonstige Ä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.0 erfordert ein wenig Arbeit, aber jede Änderung führt zu:

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