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

Migrieren Sie Ihre TensorFlow 1 Code TensorFlow 2

Auf TensorFlow.org Führen Sie in Google Colab Quelltext anzeigen auf GitHub Download Notebook

Dieses Dokument für die Nutzer von niedrigem Niveau TensorFlow APIs. Wenn Sie das hohe Level - APIs (verwenden tf.keras ) kann es zu wenig oder gar keine Aktion , die Sie Ihren Code ergreifen müssen , sein voll machen TensorFlow 2.0 kompatibel:

Es ist immer noch möglich 1.x Code, unmodifizierten (läuft mit Ausnahme contrib ), in TensorFlow 2.0:

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

Allerdings bedeutet dies nicht lassen Sie nutzen viele der Verbesserungen in TensorFlow 2.0 gemacht nehmen. Dieser Leitfaden hilft Ihnen, Ihren Code zu aktualisieren, es einfacher, leistungsfähiger zu machen und leichter zu pflegen.

Automatische Konvertierung Skript

Der erste Schritt, bevor die Änderungen in diesem Dokument beschrieben zu implementieren, ist zu versuchen , den laufenden Upgrade - Skript .

Dies wird einen Anstich tun, um Ihren Code zu TensorFlow 2.0 zu aktualisieren. Aber es kann nicht Ihren Code idiomatischen bis 2,0 machen. Ihr Code kann immer noch Gebrauch machen tf.compat.v1 Endpunkte Zugang Platzhalter, Sitzungen, Sammlungen und andere 1.x-Stil - Funktionalität.

Top-Level-Verhaltensänderungen

Wenn Ihr Code funktioniert in TensorFlow 2.0 mit tf.compat.v1.disable_v2_behavior() , gibt es noch globale Verhaltensänderungen Sie Adresse benötigen. Die wichtigsten Änderungen sind:

  • Eager Ausführung, v1.enable_eager_execution() : Jeder Code, der ein implizit verwendet tf.Graph fehl. Achten Sie darauf , diesen Code in einem einzuwickeln with tf.Graph().as_default() Kontext.

  • Ressourcenvariablen, v1.enable_resource_variables() : Einiger Code kann auf nicht-deterministisches Verhalten hängt aktiviert durch TF Referenzvariablen. Ressourcenvariablen sind gesperrt, während geschrieben wird, und so bieten intuitive Konsistenz gewährleistet.

    • Dies kann das Verhalten in Grenzfällen ändern.
    • Dies kann zusätzliche Kopien erstellen und eine höhere Speichernutzung haben.
    • Dies kann , indem deaktiviert werden use_resource=False an den tf.Variable Konstruktor.
  • Tensor Formen, v1.enable_v2_tensorshape() : TF 2.0 vereinfacht das Verhalten von Tensor Formen. Statt t.shape[0].value kann man sagen , t.shape[0] . Diese Änderungen sollten klein sein, und es macht Sinn, sie sofort zu beheben. Siehe TensorShape für Beispiele.

  • Der Steuerfluss, v1.enable_control_flow_v2() : Die TF 2.0 Steuerfluß Implementierung vereinfacht wurde, und erzeugt so unterschiedliche Grafikdarstellungen. Bitte Datei Fehler für alle Probleme.

Machen Sie den Code 2.0-native

Dieser Leitfaden wird zu Fuß durch einige Beispiele von 2,0 TensorFlow 1.x Code TensorFlow konvertieren. Diese Änderungen werden den Code nehmen Vorteil von Performance-Optimierungen und vereinfachte API-Aufrufe lassen.

In jedem Fall ist das Muster:

1. Ersetzen v1.Session.run Anrufe

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

  • Die feed_dict und v1.placeholder s werden Funktionsargumente.
  • Die fetches werden die Rückgabewert der Funktion.
  • Bei der Konvertierung ermöglicht eifrig Ausführung leicht Debuggen mit Standard - Python - Tool wie pdb .

Danach fügen Sie einen tf.function Dekorateur es läuft effizient in Diagramm zu machen. Sehen Sie sich den Autograph Guide für weitere Informationen , wie das funktioniert.

Beachten Sie, dass:

  • Im Gegensatz zu v1.Session.run ein tf.function hat eine feste Rendite Signatur und liefert immer alle Ausgänge. Wenn diese Leistungsprobleme verursacht, erzeugen zwei getrennte Funktionen.

  • Es besteht keine Notwendigkeit für eine tf.control_dependencies oder ähnliche Operationen: A tf.function verhält sich , als ob es geschrieben in der Reihenfolge ausgeführt wurden. tf.Variable Zuweisungen und tf.assert s, zum Beispiel, werden automatisch ausgeführt.

2. Verwenden Sie Python Objekte zu verfolgen Variablen und Verluste

Alle namensbasierte variable Tracking wird in TF 2.0 dringend abgeraten. Verwenden Sie Python-Objekte zu Variablen zu verfolgen.

Verwenden tf.Variable statt v1.get_variable .

Jeder v1.variable_scope sollte auf ein Python - Objekt umgewandelt werden. Typischerweise wird dies einer der folgenden sein:

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

Diese Layer und Model - Klassen implementieren mehrere andere Eigenschaften , die die Notwendigkeit einer globalen Sammlungen entfernen. Ihre .losses Eigenschaft kann ein Ersatz sein für die Verwendung tf.GraphKeys.LOSSES Sammlung.

Siehe die keras Führungen für weitere Einzelheiten.

3. Ihre Loops Ausbildung Upgrade

Verwenden Sie den höchsten Level-API, die für Ihren Anwendungsfall funktioniert. Bevorzugen tf.keras.Model.fit über Ihre eigenen Trainingsschlaufen zu bauen.

Diese hohe Level-Funktionen verwalten eine Menge von den Low-Level-Details, die leicht zu übersehen sein könnten, wenn Sie Ihre eigene Trainingsschleife schreiben. Zum Beispiel sie die Regularisierung Verluste automatisch zu sammeln und die eingestellte training=True Argument , wenn das Modell aufrufen.

4. Ihre Dateneingabeleitungen Upgrade

Verwenden tf.data Datensätze für die Dateneingabe. Diese Objekte sind effizient, ausdrucksstark, und integrieren sich gut mit tensorflow.

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

 model.fit(dataset, epochs=5)
 

Sie können über direkt Standard Python wiederholt werden:

 for example_batch, label_batch in dataset:
    break
 

5. Migrate off compat.v1 Symbole

Das tf.compat.v1 Modul enthält den vollständigen TensorFlow 1.x API, mit seiner ursprünglichen Semantik.

Das TF2 Upgrade - v1.arg_max tf.argmax Skript werden Symbole auf ihre 2,0 Äquivalente umwandeln , wenn eine solche Umwandlung sicher ist, das heißt, wenn es , dass das Verhalten der 2.0 - Version bestimmen kann genau entspricht (zum Beispiel, wird es umbenennen v1.arg_max zu tf.argmax , da sind diejenigen, die gleiche Funktion).

Nachdem das Upgrade - Skript mit einem Stück Code durchgeführt wird, ist es wahrscheinlich , es gibt viele die Nennungen compat.v1 . Es lohnt sich durch den Code zu gehen und diese manuell in das 2,0 Äquivalent Umwandlung (es sollte im Protokoll erwähnt werden, wenn es einen gibt).

Konvertieren von Modellen

Konfiguration

 import tensorflow as tf


import tensorflow_datasets as tfds
 

Low-Level-Variablen Operator & Ausführung

Beispiele für Low-Level-API Verwendung umfassen:

Vor der Konvertierung

Hier ist, was diese Muster wie in Code aussehen kann TensorFlow 1.x mit

 in_a = tf.placeholder(dtype=tf.float32, shape=(2))
in_b = tf.placeholder(dtype=tf.float32, shape=(2))

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

out_a = forward(in_a)
out_b = forward(in_b)

reg_loss=tf.losses.get_regularization_loss(scope="matmul")

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

 

nach der Konvertierung

Im konvertierte Code:

  • Die Variablen sind lokale Python-Objekte.
  • Die forward Funktion definiert noch die Berechnung.
  • Der Session.run Anruf wird mit einem Aufruf ersetzt forward
  • Das optionale tf.function Dekorateur kann für die Leistung hinzugefügt werden.
  • Die Bereinigungen werden manuell berechnet, ohne an eine globale Sammlung zu verweisen.
  • 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)
 

Alle Modelle basieren auf tf.layers

Die v1.layers Modul dient Schicht-Funktionen enthalten , die auf verlassen v1.variable_scope zu definieren und die Wiederverwendung Variablen.

Vor der Konvertierung

 def model(x, training, scope='model'):
  with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
    x = tf.layers.conv2d(x, 32, 3, activation=tf.nn.relu,
          kernel_regularizer=tf.contrib.layers.l2_regularizer(0.04))
    x = tf.layers.max_pooling2d(x, (2, 2), 1)
    x = tf.layers.flatten(x)
    x = tf.layers.dropout(x, 0.1, training=training)
    x = tf.layers.dense(x, 64, activation=tf.nn.relu)
    x = tf.layers.batch_normalization(x, training=training)
    x = tf.layers.dense(x, 10)
    return x

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

nach der Konvertierung

Die meisten Argumente gleich geblieben. Aber beachten Sie die Unterschiede:

  • Das training Argument wird durch das Modell zu jeder Schicht übergeben , wenn es ausgeführt wird .
  • Das erste Argument der ursprünglichen model (der Eingang x ) ist verschwunden. Dies liegt daran, Objektschichten trennen das Modell aus dem Aufruf der Modellerstellung.

Beachten Sie auch, dass:

  • Wenn Sie wurden regularizers von initializers verwenden tf.contrib , haben diese mehr Argument Änderungen als andere.
  • Der Code nicht schreibt mehr Sammlungen, so Funktionen wie v1.losses.get_regularization_loss nicht mehr diese Werte zurück, die möglicherweise Ihre Trainingsschlaufen zu brechen.
 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.11456077 -0.3126101   0.13154565 -0.50197905 -0.02416557  0.36460522
  -0.24887308 -0.37784547  0.05524942  0.01696768]], 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.077528305>]

Gemischte Variablen & v1.layers

Bestehende Code oft Mischungen niedrigere Ebene TF 1.x Variablen und Operationen mit höherer Ebene v1.layers .

Vor der Konvertierung

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

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

nach der Konvertierung

Um diesen Code zu konvertieren, folgt dem Muster der Kartierung Schichten Schichten wie im vorherigen Beispiel.

Das allgemeine Muster ist:

  • Collect Schichtparameter in __init__ .
  • Erstellen Sie die Variablen in build .
  • Führen Sie die Berechnungen in call und gibt das Ergebnis.

Die v1.variable_scope ist im Wesentlichen eine Schicht aus seinem eigenen. So umschreiben es als tf.keras.layers.Layer . Siehe die Führung für Details.

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

  • Unterklassen Keras Modelle & Schichten müssen in beiden v1 Graphen (keine automatische Steuerung Abhängigkeiten) und in eifrig Modus laufen

    • Wickeln Sie den call() in einem tf.function() erhalten Autogramme und automatische Steuerung Abhängigkeiten
  • Vergessen Sie nicht akzeptieren training Argument call .

    • Manchmal ist es ein tf.Tensor
    • Manchmal ist es ein Python boolean.
  • Erstellen Sie Modellvariablen in Konstruktor oder Model.build mit self.add_weight() .

  • Bewahren Sie keine tf.Tensors in Ihre Objekte.

    • Sie könnten entweder in einem erstellt bekommen tf.function oder im eifrigen Kontext, und diese Tensoren verhalten sich anders.
    • Verwenden tf.Variable s für Staat, sind sie aus beiden Kontexten immer nutzbar
    • tf.Tensors sind nur für Zwischenwerte.

Ein Hinweis auf Slim & contrib.layers

Eine große Menge an älterem TensorFlow 1.x Code verwendet die Slim - Bibliothek, die mit TensorFlow 1.x wie verpackt wurde tf.contrib.layers . Als contrib - Modul, das ist nicht mehr verfügbar in TensorFlow 2.0, auch in tf.compat.v1 . Konvertieren von Code unter Verwendung von Slim TF 2.0 ist mehr beteiligt als Repositories umgewandelt werden, die Verwendung v1.layers . In der Tat kann es Sinn machen , Ihren Slim - Code zu konvertieren v1.layers zuerst, dann zu Keras konvertieren.

  • Entfernen arg_scopes , alle Argumente müssen explizit sein
  • Wenn Sie sie, Split normalizer_fn und activation_fn in ihre eigenen Schichten
  • Trennbare conv Schichten MAP zu einem oder mehreren verschiedenen Schichten Keras (Tiefe, punktuellen und trennbaren Schichten Keras)
  • Slim und v1.layers haben unterschiedliche Namen arg & Standardwerte
  • Einige Argumente haben unterschiedliche Maßstäbe
  • Wenn Sie Slim verwenden Modelle vorbestellt trainiert, ausprobieren Keras pre-traimed Modelle von tf.keras.applications oder TF - Hub ‚s TF2 SavedModels vom Original Slim - Code exportiert.

Einige tf.contrib Schichten möglicherweise nicht zu dem Kern TensorFlow bewegt worden sind , aber stattdessen auf das verschoben worden TF Add-ons - Paket .

Ausbildung

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

Der empfohlene Weg einzuspeisen Daten an ein Modell ist , das verwenden tf.data - Paket, das für die Manipulation von Daten , die eine Sammlung von hohen Leistungsklassen enthält.

Wenn Sie immer noch verwenden tf.queue , werden diese nur noch als Datenstrukturen unterstützt, nicht als Eingangsleitungen.

Mit Datasets

Die TensorFlow Datensätze Paket ( tfds ) enthält Werkzeuge zum Laden von Datensätzen als vordefinierte tf.data.Dataset Objekte.

In diesem Beispiel lädt die MNISTdataset, 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.

Dann bereitet die Daten für die Ausbildung:

  • jedes Bild neu skaliert werden.
  • Mische die Reihenfolge der Beispiele.
  • Collect Reihen 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 nur 5 Chargen zurück:

 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 Keras Trainingsschlaufen

Wenn Sie nicht geringe Kontrolle über Ihren Trainingsprozess benötigen, mit Keras eingebauter in fit , zu evaluate und predict Methoden empfohlen. Diese Methoden stellen eine einheitliche Schnittstelle das Modell unabhängig von der Durchführung (sequentiell, funktionelle oder Unter eingestuft) zu trainieren.

Die Vorteile dieser Methoden sind:

  • Sie akzeptieren Numpy Arrays, Python - Generatoren und tf.data.Datasets
  • Sie gelten Regularisierung und Aktivierung Verluste automatisch.
  • Sie unterstützen tf.distribute für Mehrgerätetraining .
  • 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, automatisch TensorFlow Diagrammen.

Hier ist ein Beispiel für die Ausbildung eines Modells unter Verwendung eines Dataset . (Einzelheiten dazu , wie das funktioniert , sehen 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.5323 - accuracy: 0.5063
Epoch 2/5
5/5 [==============================] - 0s 6ms/step - loss: 0.4105 - accuracy: 0.9219
Epoch 3/5
5/5 [==============================] - 0s 7ms/step - loss: 0.2495 - accuracy: 0.9531
Epoch 4/5
5/5 [==============================] - 0s 6ms/step - loss: 0.1806 - accuracy: 0.9875
Epoch 5/5
5/5 [==============================] - 0s 6ms/step - loss: 0.1416 - accuracy: 0.9937
5/5 [==============================] - 0s 4ms/step - loss: 1.5655 - accuracy: 0.6469
Loss 1.565544605255127, Accuracy 0.6468750238418579

Schreiben Sie Ihre eigene Schleife

Wenn die Trainingsschritt arbeitet der Keras Modell für Sie, aber Sie mehr Kontrolle außerhalb brauchen , dass der Schritt, sollten Sie die Verwendung von tf.keras.Model.train_on_batch Verfahren, in Ihren eigenen Daten-Iterationsschleife.

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

Dieses Verfahren hat viele der Vorteile der Verfahren im vorhergehenden Abschnitt erwähnt, sondern gibt dem Benutzer die Kontrolle der äußeren Schleife.

Sie können auch verwenden tf.keras.Model.test_on_batch oder tf.keras.Model.evaluate zu Kontroll Leistung während des Trainings.

Um weiterhin das obige Modell der Ausbildung:

 # 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.122 accuracy: 0.984
train:  loss: 0.133 accuracy: 0.984
train:  loss: 0.164 accuracy: 0.969
train:  loss: 0.167 accuracy: 0.969
train:  loss: 0.161 accuracy: 0.984

eval:  loss: 1.583 accuracy: 0.669
train:  loss: 0.074 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.089 accuracy: 1.000
train:  loss: 0.095 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000

eval:  loss: 1.567 accuracy: 0.747
train:  loss: 0.065 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.069 accuracy: 1.000
train:  loss: 0.067 accuracy: 1.000

eval:  loss: 1.545 accuracy: 0.772
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.063 accuracy: 0.984
train:  loss: 0.050 accuracy: 1.000
train:  loss: 0.051 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000

eval:  loss: 1.520 accuracy: 0.778
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.046 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000

eval:  loss: 1.494 accuracy: 0.791

Passen Sie den Trainingsschritt

Wenn Sie mehr Flexibilität und Kontrolle benötigen, können Sie es von Ihrer eigenen Trainingsschleife implementieren. Es gibt drei Schritte:

  1. Iterate über einen Python - Generator oder tf.data.Dataset zu bekommen Chargen von Beispielen.
  2. Verwenden Sie tf.GradientTape zu sammeln Steigungen.
  3. Verwenden Sie eine der tf.keras.optimizers Gewicht Aktuelles zu den Modellgrößen gelten.

Merken:

  • Immer auch ein training Argument auf der call - Methode von subclassed Schichten und Modellen.
  • Achten Sie darauf , das Modell mit dem nennen training richtig Argument gesetzt.
  • Je nach Nutzung, können nicht existieren Modellvariablen, bis das Modell auf einer Charge von Daten ausgeführt wird.
  • Sie müssen manuell Dinge wie für das Modell Regularisierung Verluste handhaben.

Beachten Sie die Vereinfachungen in Bezug auf v1:

  • Es besteht keine Notwendigkeit Variableninitialisierungen zu laufen. Variablen werden bei der Erstellung initialisiert.
  • Es besteht keine Notwendigkeit manueller Steuerung Abhängigkeiten hinzuzufügen. Auch in tf.function Operationen wirken als in eifrig 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

New-style-Metriken und Verluste

In TensorFlow 2.0, Metriken und Verluste sind Objekte. Diese arbeiten beide eifrig und in tf.function s.

Ein Verlust Objekt ist aufrufbar und erwartet die (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 hat die folgenden Methoden:

Das Objekt selbst ist aufrufbar. Der Aufruf aktualisiert und zeigt den Zustand mit neuen Beobachtungen, wie mit update_state , und gibt das neue Ergebnis der Metrik.

Sie müssen nicht von Hand auf eine Metrik Variablen initialisieren, und weil TensorFlow 2.0 automatische Steuerung Abhängigkeiten, die Sie nicht Sorge über denjenigen abweichen müssen.

Der folgende Code verwendet eine Metrik innerhalb einer benutzerdefinierten Trainingsschleife beobachtet Spur des Mittelverlust zu halten.

 # 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.175
  accuracy: 0.994
Epoch:  1
  loss:     0.149
  accuracy: 0.991
Epoch:  2
  loss:     0.133
  accuracy: 0.991
Epoch:  3
  loss:     0.113
  accuracy: 0.997
Epoch:  4
  loss:     0.101
  accuracy: 0.997

Keras metrische Namen

In TensorFlow 2.0 keras Modelle sind konsistent über metrischen Namen Handhabung.

Nun , wenn Sie übergeben eine Zeichenfolge in der Liste der Metriken, die genaue Zeichenfolge als die Metrik verwendet wird name . Diese Namen sind sichtbar in der Geschichte Objekt durch zurück model.fit , und in den Protokollen übergeben keras.callbacks . gesetzt ist Sie in der Metrik Liste der String übergeben.

 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.1076 - acc: 0.9969 - accuracy: 0.9969 - my_accuracy: 0.9969

 history.history.keys()
 
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

Dies unterscheidet sich von früheren Versionen , bei denen vorbei metrics=["accuracy"] in Folge hätte dict_keys(['loss', 'acc'])

Keras Optimizern

Die Optimizern in v1.train , wie v1.train.AdamOptimizer und v1.train.GradientDescentOptimizer , haben Entsprechungen in tf.keras.optimizers .

Konvertieren v1.train zu keras.optimizers

Hier sind die Dinge im Auge zu behalten, wenn Ihr Optimizern Umwandlung:

Neue Standardwerte 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 Schreibzusammengefasste Daten für die Visualisierung in TensorBoard verwendet. Für eine allgemeine Einführung in die neuen tf.summary gibt es mehrere Tutorien zur Verfügung , die die TF 2 API verwenden. Dazu gehört auch eine TensorBoard TF 2 Migration Guide

Laden und speichern

Checkpoint-Kompatibilität

TensorFlow 2.0 Anwendungen objektbasierte Checkpoints .

Im alten Stil namensbasierte Checkpoints können noch geladen werden, wenn Sie vorsichtig sind. Der Codeumwandlungsprozess in Variablennamen Änderungen ergeben kann, aber es gibt Abhilfen.

Die einfachste Ansatz in dem Kontrollpunkt die Namen des neuen Modells mit den Namen aufreihen:

  • 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.
  • Die v1.name_scope Funktion kann verwendet werden , um variable Namenspräfixe einzustellen. Das ist sehr verschieden von tf.variable_scope . Es betrifft nur Namen und keine Variablen & Wiederverwendung verfolgen.

Wenn das nicht für Ihren Anwendungsfall nicht funktioniert, versuchen Sie die v1.train.init_from_checkpoint Funktion. Es dauert ein assignment_map Argument, das die Zuordnung von alten Namen neue Namen angibt.

Das TensorFlow Estimator Repository enthält ein Konvertierungstool die Checkpoints für premade Schätzer von TensorFlow 1.x auf 2.0 zu aktualisieren. Es kann als Beispiel dafür dienen, wie ein Werkzeug für einen ähnlichen Anwendungsfall zu bauen.

Gespeicherte Modelle Kompatibilität

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

  • TensorFlow 1.x saved_models Arbeit in TensorFlow 2.x.
  • TensorFlow 2.x saved_models Arbeit in TensorFlow 1.x-wenn alle ops unterstützt.

A Graph.pb oder Graph.pbtxt

Es gibt keine einfache Möglichkeit , eine rohe Upgrade Graph.pb Datei zu TensorFlow 2.0. Ihre beste Wette ist, den Code zu aktualisieren, die die Datei erzeugt.

Aber, wenn Sie eine „Frozen Graph“ haben (a tf.Graph wobei die Variablen in Konstanten gedreht wurden), dann ist es möglich , dies auf eine konvertieren concrete_function mit 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))
 

Zum Beispiel, hier ist ein Frozed Diagramm für Inception v1, ab 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 die tf.GraphDef :

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

Wickeln Sie es in ein concrete_function :

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

Direkt einen Tensor als Eingang:

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

Schätzer

Training mit Schätzer

Schätzer sind in TensorFlow 2.0 unterstützt.

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

Hier ist ein Beispiel unter Verwendung von input_fn mit Zug und Spezifikationen zu bewerten.

Erstellen der input_fn und Zug / eval specs

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

 

Mit Hilfe einer Keras Modelldefinition

Es gibt einige Unterschiede, wie Ihr Schätzer in TensorFlow 2.0 zu konstruieren.

Wir empfehlen Ihnen , Ihr Modell zu definieren mit Keras, dann die Verwendung tf.keras.estimator.model_to_estimator Dienstprogramm Ihr Modell in einen Schätzer zu drehen. Der folgende Code zeigt, wie dieses Dienstprogramm zu verwenden, bei der Erstellung und einen Schätzer zu trainieren.

 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/tmpb3_a632k

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

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/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

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

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

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

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

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

INFO:tensorflow:loss = 2.270717, step = 0

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

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpb3_a632k/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-07-23T01:32:32Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:32Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

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

INFO:tensorflow:Restoring parameters from /tmp/tmpb3_a632k/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 : 1.01619s

INFO:tensorflow:Inference Time : 1.01619s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:33

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:33

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.671875, global_step = 25, loss = 1.5162958

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.671875, global_step = 25, loss = 1.5162958

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

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

INFO:tensorflow:Loss for final step: 0.39261085.

INFO:tensorflow:Loss for final step: 0.39261085.

({'accuracy': 0.671875, 'loss': 1.5162958, 'global_step': 25}, [])

Verwenden einer benutzerdefinierten model_fn

Wenn Sie eine vorhandene benutzerdefinierte Schätzer haben model_fn , dass Sie pflegen müssen, können Sie konvertieren model_fn ein Keras Modell zu verwenden.

Jedoch aus Gründen der Kompatibilität, eine benutzerdefinierte model_fn noch in 1.x-Stil Graph - Modus. Das heißt, es gibt keine eifrige Ausführung und keine automatische Steuerung Abhängigkeiten.

Custom model_fn mit minimalen Änderungen

Um die benutzerdefinierte zu machen model_fn Arbeit in TF 2.0, wenn Sie nur minimale Änderungen an den vorhandenen Code bevorzugen, tf.compat.v1 Symbole wie optimizers und metrics verwendet werden.

Ein Keras Modell in einem benutzerdefinierten Mit model_fn ähnelt es in einer benutzerdefinierten Trainingsschleife zu verwenden:

  • Stellen Sie die training in geeigneter Weise auf der Grundlage des mode Argument.
  • Explizit das Modell übergeben trainable_variables an den Optimierer.

Aber es gibt wichtige Unterschiede in Bezug auf eine individuelle Schleife :

  • Anstelle der Verwendung von Model.losses , extrahiert die Verluste mit Model.get_losses_for .
  • Extrahieren des Modells Updates mit Model.get_updates_for .

Der folgende Code erstellt einen Schätzer von einem benutzerdefinierten model_fn , alle diese Bedenken darstellt.

 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/tmpjb2yik9a

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

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

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

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

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

INFO:tensorflow:loss = 2.6231384, step = 0

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

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpjb2yik9a/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-07-23T01:32:36Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:36Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

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

INFO:tensorflow:Restoring parameters from /tmp/tmpjb2yik9a/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 : 1.09900s

INFO:tensorflow:Inference Time : 1.09900s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:37

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:37

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.621875, global_step = 25, loss = 1.6634324

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.621875, global_step = 25, loss = 1.6634324

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

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

INFO:tensorflow:Loss for final step: 0.56862533.

INFO:tensorflow:Loss for final step: 0.56862533.

({'accuracy': 0.621875, 'loss': 1.6634324, 'global_step': 25}, [])

Custom model_fn mit TF 2.0 Symbole

Wenn Sie loswerden alle TF 1.x Symbole erhalten möchten und aktualisieren Sie Ihre individuelle model_fn zu nativem TF 2.0, müssen Sie den Optimierer und Metriken aktualisieren tf.keras.optimizers und tf.keras.metrics .

In der benutzerdefinierten model_fn neben den oben Änderungen müssen mehr Upgrades vorgenommen werden:

Für das obige Beispiel von my_model_fn wird der migrierten Code mit 2,0 - Symbole gezeigt als:

 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/tmppkb1q1hq

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

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

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

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

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

INFO:tensorflow:loss = 2.6947184, step = 0

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

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmppkb1q1hq/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-07-23T01:32:40Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:40Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

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

INFO:tensorflow:Restoring parameters from /tmp/tmppkb1q1hq/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 : 1.05743s

INFO:tensorflow:Inference Time : 1.05743s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:41

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:41

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.784375, global_step = 25, loss = 1.4717665

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.784375, global_step = 25, loss = 1.4717665

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

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

INFO:tensorflow:Loss for final step: 0.5751184.

INFO:tensorflow:Loss for final step: 0.5751184.

({'Accuracy': 0.784375, 'loss': 1.4717665, 'global_step': 25}, [])

vorgefertigte Schätzer

Vorgefertigte Schätzer in der Familie von tf.estimator.DNN* , tf.estimator.Linear* und tf.estimator.DNNLinearCombined* unterstützt nach wie vor in der TensorFlow 2.0 API haben jedoch einige Argumente geändert:

  1. input_layer_partitioner : Entfernt in 2.0.
  2. loss_reduction : Aktualisiert tf.keras.losses.Reduction statt tf.compat.v1.losses.Reduction . Der Standardwert wird auch geändert tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE von tf.compat.v1.losses.Reduction.SUM .
  3. optimizer , dnn_optimizer und linear_optimizer : diese arg wurde aktualisiert tf.keras.optimizers anstelle des tf.compat.v1.train.Optimizer .

Um die oben genannten Änderungen zu migrieren:

  1. Keine Migration ist für erforderlich input_layer_partitioner seit Distribution Strategy automatisch in TF 2.0 behandelt.
  2. Für loss_reduction , überprüfen tf.keras.losses.Reduction für die unterstützten Optionen.
  3. Für optimizer args, wenn Sie in einem nicht passieren optimizer , dnn_optimizer oder linear_optimizer arg, oder wenn Sie die angeben optimizer arg als string im Code, die Sie nicht ändern etwas brauchen. tf.keras.optimizers wird standardmäßig verwendet. Andernfalls müssen Sie es von aktualisieren tf.compat.v1.train.Optimizer zu seinem entsprechenden tf.keras.optimizers

Checkpoint Converter

Die Migration auf keras.optimizers wird Checkpoints brechen gespeichert TF 1.x, als tf.keras.optimizers einen anderen Satz von Variablen erzeugt in Checkpoints gespeichert werden. Um alten Kontrollpunkt wiederverwendbar nach der Migration auf TF 2.0, versuchen Sie das Kontrollpunkt - Konverter - Tool .

 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 15157  100 15157    0     0  63684      0 --:--:-- --:--:-- --:--:-- 63684

Das Tool verfügt über eingebaute Hilfe:

 python checkpoint_converter.py -h
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 zu halten , vereinfacht int s, statt tf.compat.v1.Dimension Objekte. So gibt es keine Notwendigkeit zu nennen .value() ein um eine int .

Einzelne tf.compat.v1.Dimension Objekte sind noch erreichbar von tf.TensorShape.dims .

Im Folgenden 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 hatte dies in TF 1.x:

 value = shape[i].value
 

Dann tun Sie dies in TF 2.0:

 value = shape[i]
value
 
16

Wenn Sie hatte dies in TF 1.x:

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

Dann tun Sie dies in TF 2.0:

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

Wenn Sie dies in TF 1.x haben (gebraucht oder andere Dimension Methode):

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

Dann tun 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 eines tf.TensorShape ist True , wenn der Rang bekannt ist, False anders.

 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

Weitere Änderungen

  • Entfernen tf.colocate_with : TensorFlow des Geräts Platzierung Algorithmen haben sich deutlich verbessert. Dies sollte nicht mehr notwendig sein. Wenn das Entfernen es eine Performance degredation verursacht Sie einen Bug- .

  • Ersetzen v1.ConfigProto Nutzung mit den entsprechenden Funktionen von tf.config .

Schlussfolgerungen

Der gesamte Prozess ist:

  1. Führen Sie den Upgrade-Skript.
  2. Entfernen contrib Symbole.
  3. Schalten Sie Ihre Modelle auf einer objektorientierten Stil (Keras).
  4. Verwenden tf.keras oder tf.estimator Ausbildung und Bewertung Schleifen , wo Sie können.
  5. Andernfalls Verwendung benutzerdefinierte Loops, aber sicher sein, Sitzungen und Sammlungen zu vermeiden.

Es dauert ein wenig Arbeit zu konvertieren Code zu idiomatischen TensorFlow 2.0, aber jede Änderung ergibt:

  • Weniger Codezeilen.
  • Eine größere Klarheit und Einfachheit.
  • Einfachere Fehlersuche.