Einführung in Module, Layer und Modelle

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

Um maschinelles Lernen in TensorFlow durchzuführen, müssen Sie wahrscheinlich ein Modell definieren, speichern und wiederherstellen.

Ein Modell ist abstrakt:

  • Eine Funktion , die etwas auf Tensoren (a Vorwärtsdurchlauf) Berechnet
  • Einige Variablen, die als Reaktion auf das Training aktualisiert werden können

In dieser Anleitung gehen Sie unter die Oberfläche von Keras, um zu sehen, wie TensorFlow-Modelle definiert sind. Hier wird untersucht, wie TensorFlow Variablen und Modelle sammelt und wie sie gespeichert und wiederhergestellt werden.

Aufstellen

import tensorflow as tf
from datetime import datetime

%load_ext tensorboard

Definieren von Modellen und Ebenen in TensorFlow

Die meisten Modelle bestehen aus Schichten. Schichten sind Funktionen mit bekannter mathematischer Struktur, die wiederverwendet werden können und trainierbare Variablen haben. In TensorFlow, die meisten High-Level - Implementierungen von Schichten und Modelle, wie Keras oder Sonnet , auf der gleichen grundlegenden Klasse gebaut: tf.Module .

Hier ist ein Beispiel für eine sehr einfache tf.Module , die auf einem Skalar - Tensor arbeitet:

class SimpleModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)
    self.a_variable = tf.Variable(5.0, name="train_me")
    self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
  def __call__(self, x):
    return self.a_variable * x + self.non_trainable_variable

simple_module = SimpleModule(name="simple")

simple_module(tf.constant(5.0))
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>

Module und im weiteren Sinne Schichten sind tiefgreifende Terminologie für "Objekte": Sie haben einen internen Zustand und Methoden, die diesen Zustand verwenden.

Es ist nichts Besonderes __call__ wie ein handeln ausnehmen Python aufrufbar ; Sie können Ihre Modelle mit beliebigen Funktionen aufrufen.

Sie können die Trainierbarkeit von Variablen aus beliebigen Gründen ein- und ausschalten, einschließlich des Einfrierens von Layern und Variablen während der Feinabstimmung.

Durch Subklassen tf.Module , alle tf.Variable oder tf.Module zugewiesen Instanzen dieses Objekts Eigenschaften werden automatisch gesammelt. Auf diese Weise können Sie und Lastvariablen speichern, und auch Sammlungen von erstellen tf.Module s.

# All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,)
all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>)
2021-08-28 01:38:55.862075: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

Dies ist ein Beispiel für ein zweischichtiges lineares Schichtenmodell aus Modulen.

Zuerst eine dichte (lineare) Schicht:

class Dense(tf.Module):
  def __init__(self, in_features, out_features, name=None):
    super().__init__(name=name)
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def __call__(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

Und dann das komplette Modell, das zwei Ebeneninstanzen erstellt und diese anwendet:

class SequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model!
my_model = SequentialModule(name="the_model")

# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[2.958162 0.      ]], shape=(1, 2), dtype=float32)

tf.Module Instanzen automatisch collect rekursiv alle tf.Variable oder tf.Module Instanzen zugeordnet. Auf diese Weise können Sie Sammlungen von verwalten tf.Module s mit einem einzigen Modell Instanz, und speichern und ganze Modelle laden.

print("Submodules:", my_model.submodules)
Submodules: (<__main__.Dense object at 0x7f5bc0146a90>, <__main__.Dense object at 0x7f5be4795090>)
for var in my_model.variables:
  print(var, "\n")
<tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 2.0533006 ,  1.4813653 , -0.6483693 ],
       [ 0.95604163,  0.6168949 , -0.825315  ],
       [-0.15973066, -0.7782317 , -0.14400753]], dtype=float32)> 

<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[ 0.25682792, -0.01160651],
       [ 0.5660645 , -2.1430922 ],
       [ 1.0312889 ,  0.4799369 ]], dtype=float32)>

Warten auf das Erstellen von Variablen

Sie haben hier vielleicht bemerkt, dass Sie sowohl Eingabe- als auch Ausgabegrößen für den Layer definieren müssen. Dies ist so , die w variable eine bekannte Form hat und zugeordnet werden können.

Indem Sie die Variablenerstellung auf den ersten Aufruf des Moduls mit einer bestimmten Eingabeform verschieben, müssen Sie die Eingabegröße nicht im Voraus angeben.

class FlexibleDenseModule(tf.Module):
  # Note: No need for `in_features`
  def __init__(self, out_features, name=None):
    super().__init__(name=name)
    self.is_built = False
    self.out_features = out_features

  def __call__(self, x):
    # Create variables on first call.
    if not self.is_built:
      self.w = tf.Variable(
        tf.random.normal([x.shape[-1], self.out_features]), name='w')
      self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
      self.is_built = True

    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)
# Used in a module
class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = FlexibleDenseModule(out_features=3)
    self.dense_2 = FlexibleDenseModule(out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)

Diese Flexibilität ist deshalb TensorFlow Schichten oft nur noch die Form ihrer Ausgänge angegeben werden , wie in tf.keras.layers.Dense , anstatt sowohl die Eingangs- und Ausgangsgröße.

Gewichte sparen

Sie können eine sparen tf.Module sowohl als Kontrollpunkt und einem SavedModel .

Prüfpunkte sind nur die Gewichte (d. h. die Werte der Variablenmenge innerhalb des Moduls und seiner Untermodule):

chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
'my_checkpoint'

Checkpoints bestehen aus zwei Arten von Dateien: den Daten selbst und einer Indexdatei für Metadaten. Die Indexdatei verfolgt, was tatsächlich gespeichert wird und die Nummerierung der Prüfpunkte, während die Prüfpunktdaten die Variablenwerte und ihre Attributsuchpfade enthalten.

ls my_checkpoint*
my_checkpoint.data-00000-of-00001  my_checkpoint.index

Sie können in einen Prüfpunkt schauen, um sicherzustellen, dass die gesamte Sammlung von Variablen gespeichert wird, sortiert nach dem Python-Objekt, das sie enthält.

tf.train.list_variables(chkp_path)
[('_CHECKPOINTABLE_OBJECT_GRAPH', []),
 ('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
 ('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
 ('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
 ('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]

Während des verteilten Trainings (mehrere Maschinen) können sie zersplittert werden, weshalb sie nummeriert sind (zB '00000-of-00001'). In diesem Fall gibt es jedoch nur einen Shard.

Wenn Sie Modelle wieder laden, überschreiben Sie die Werte in Ihrem Python-Objekt.

new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")

# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0., 0.]], dtype=float32)>

Speicherfunktionen

TensorFlow können Modelle ohne die ursprünglichen Python - Objekte ausgeführt werden , wie gezeigt , TensorFlow Serving und TensorFlow Lite , wenn Sie selbst ein geübtes Modell von Download TensorFlow Hub .

TensorFlow muss wissen , wie die Berechnungen in Python beschrieben zu tun, aber ohne den ursprünglichen Code. Dazu können Sie ein Diagramm machen, die in der beschriebene Einführung in der grafischen Darstellungen und Funktionen Führung .

Dieser Graph enthält Operationen oder ops, die die Funktion implementieren.

Sie können ein Diagramm , in dem Modell oben definieren , indem Sie die @tf.function Dekorateur , um anzuzeigen , dass dieser Code sollte als Graph laufen.

class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  @tf.function
  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")

Das von Ihnen erstellte Modul funktioniert genauso wie zuvor. Jede an die Funktion übergebene eindeutige Signatur erstellt einen separaten Graphen. Überprüfen Sie die Einführung in der grafischen Darstellungen und Funktionen führen für weitere Einzelheiten.

print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0. 0.]
  [0. 0.]]], shape=(1, 2, 2), dtype=float32)

Sie können das Diagramm visualisieren, indem Sie es innerhalb einer TensorBoard-Zusammenfassung verfolgen.

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)

# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True)
tf.profiler.experimental.start(logdir)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
tf.Tensor([[0.        5.3894534]], shape=(1, 2), dtype=float32)

Starten Sie TensorBoard, um den resultierenden Trace anzuzeigen:

%tensorboard --logdir logs/func

Ein Screenshot des Diagramms in TensorBoard

Erstellen eines SavedModel

Die empfohlene Art und Weise vollständig ausgebildete Modelle des Teilens verwenden SavedModel . SavedModel enthält sowohl eine Sammlung von Funktionen , und eine Sammlung von Gewichten.

Sie können das gerade trainierte Modell wie folgt speichern:

tf.saved_model.save(my_model, "the_saved_model")
INFO:tensorflow:Assets written to: the_saved_model/assets
# Inspect the SavedModel in the directory
ls -l the_saved_model
total 24
drwxr-sr-x 2 kbuilder kokoro  4096 Aug 28 01:38 assets
-rw-rw-r-- 1 kbuilder kokoro 14702 Aug 28 01:38 saved_model.pb
drwxr-sr-x 2 kbuilder kokoro  4096 Aug 28 01:38 variables
# The variables/ directory contains a checkpoint of the variables
ls -l the_saved_model/variables
total 8
-rw-rw-r-- 1 kbuilder kokoro 408 Aug 28 01:38 variables.data-00000-of-00001
-rw-rw-r-- 1 kbuilder kokoro 356 Aug 28 01:38 variables.index

Die saved_model.pb Datei ist ein Protokollpuffer des funktionellen beschreibt tf.Graph .

Modelle und Layer können aus dieser Darstellung geladen werden, ohne tatsächlich eine Instanz der Klasse zu erstellen, die sie erstellt hat. Dies ist in Situationen erwünscht, in denen Sie keinen Python-Interpreter haben (oder wünschen), wie z.

Sie können das Modell als neues Objekt laden:

new_model = tf.saved_model.load("the_saved_model")

new_model , erstellt von einem gespeicherten Modell lädt, ist ein internes TensorFlow Benutzerobjekt ohne der Klasse Wissen. Es ist nicht vom Typ SequentialModule .

isinstance(new_model, SequentialModule)
False

Dieses neue Modell arbeitet mit den bereits definierten Eingabesignaturen. Sie können einem so wiederhergestellten Modell keine weiteren Signaturen hinzufügen.

print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0. 0.]
  [0. 0.]]], shape=(1, 2, 2), dtype=float32)

So verwenden SavedModel , sind Sie in der Lage TensorFlow Gewichte und Grafiken unter Verwendung speichern tf.Module , und sie dann wieder laden.

Keras-Modelle und -Ebenen

Beachten Sie, dass Keras bis zu diesem Zeitpunkt nicht erwähnt wird. Sie können Ihren eigenen High-Level - API auf der bauen tf.Module , und die Menschen haben.

In diesem Abschnitt wird untersucht , wie Sie Keras verwendet tf.Module . Eine vollständige Anleitung zu Keras Modellen finden Sie im finden Keras Führung .

Keras-Schichten

tf.keras.layers.Layer ist die Basisklasse aller Keras Schichten, und es erbt von tf.Module .

Sie können ein Modul in eine Keras Ebene umwandeln nur durch die übergeordnete Auslagern und dann Ändern __call__ zu call :

class MyDense(tf.keras.layers.Layer):
  # Adding **kwargs to support base Keras layer arguments
  def __init__(self, in_features, out_features, **kwargs):
    super().__init__(**kwargs)

    # This will soon move to the build step; see below
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def call(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

simple_layer = MyDense(name="simple", in_features=3, out_features=3)

Keras Schichten haben ihre eigenen __call__ , die einige Buchhaltung im nächsten Abschnitt beschrieben ist , und ruft dann call() . Sie sollten keine Änderung der Funktionalität feststellen.

simple_layer([[2.0, 2.0, 2.0]])
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[0.      , 5.477686, 0.      ]], dtype=float32)>

Der build - Schritt

Wie bereits erwähnt, ist es in vielen Fällen praktisch, mit der Erstellung von Variablen zu warten, bis Sie sich der Eingabeform sicher sind.

Keras-Ebenen verfügen über einen zusätzlichen Lebenszyklusschritt, der Ihnen mehr Flexibilität bei der Definition Ihrer Ebenen ermöglicht. Dies wird in der definierten build - Funktion.

build ist genau einmal aufgerufen, und es wird mit der Form des Eingangs genannt. Es wird normalerweise verwendet, um Variablen (Gewichte) zu erstellen.

Sie können neu schreiben MyDense Schicht oben auf die Größe seiner Eingänge , flexibel zu sein:

class FlexibleDense(tf.keras.layers.Layer):
  # Note the added `**kwargs`, as Keras supports many arguments
  def __init__(self, out_features, **kwargs):
    super().__init__(**kwargs)
    self.out_features = out_features

  def build(self, input_shape):  # Create the state of the layer (weights)
    self.w = tf.Variable(
      tf.random.normal([input_shape[-1], self.out_features]), name='w')
    self.b = tf.Variable(tf.zeros([self.out_features]), name='b')

  def call(self, inputs):  # Defines the computation from inputs to outputs
    return tf.matmul(inputs, self.w) + self.b

# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)

Zu diesem Zeitpunkt wurde das Modell noch nicht erstellt, daher gibt es keine Variablen:

flexible_dense.variables
[]

Durch Aufrufen der Funktion werden Variablen mit entsprechender Größe zugewiesen:

# Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
Model results: tf.Tensor(
[[ 0.15033138 -0.39541537 -1.2892584 ]
 [ 0.22549689 -0.59312296 -1.9338875 ]], shape=(2, 3), dtype=float32)
flexible_dense.variables
[<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-0.18548656,  0.6042436 , -1.0683438 ],
        [-0.452863  , -0.8545634 , -0.13075647],
        [ 0.7135152 ,  0.05261215,  0.5544711 ]], dtype=float32)>,
 <tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

Da build nur einmal aufgerufen wird, werden Eingaben abgelehnt, wenn die Eingangsform mit der Schicht der Variablen nicht kompatibel:

try:
  print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
  print("Failed:", e)
Failed: In[0] mismatch In[1] shape: 4 vs. 3: [1,4] [3,3] 0 0 [Op:MatMul]

Keras-Ebenen haben viel mehr zusätzliche Funktionen, darunter:

  • Optionale Verluste
  • Unterstützung für Metriken
  • Integrierte Unterstützung für eine optionale training Argument , um zwischen Ausbildung und Inferenz Verwendung
  • get_config und from_config Methoden , die es Ihnen ermöglichen, genau Konfigurationen zu speichern , um Modell Klonen in Python zu ermöglichen

Lesen Sie mehr über sie in der vollständigen Anleitung , um benutzerdefinierte Schichten und Modelle.

Keras-Modelle

Sie können Ihr Modell als verschachtelte Keras-Layer definieren.

Allerdings Keras bietet auch eine voll funktionsfähige Modellklasse genannt tf.keras.Model . Sie erbt von tf.keras.layers.Layer , so ein Keras Modell verwendet werden können, verschachtelt und in der gleichen Weise wie Keras Schichten gespeichert. Keras-Modelle verfügen über zusätzliche Funktionen, die das Trainieren, Evaluieren, Laden, Speichern und sogar Trainieren auf mehreren Computern vereinfachen.

Sie können die definieren SequentialModule von oben mit nahezu identischen Code, wieder Umwandeln __call__ zu call() und die Änderung der parent:

class MySequentialModel(tf.keras.Model):
  def __init__(self, name=None, **kwargs):
    super().__init__(**kwargs)

    self.dense_1 = FlexibleDense(out_features=3)
    self.dense_2 = FlexibleDense(out_features=2)
  def call(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")

# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[-3.6328888  -0.01937295]], shape=(1, 2), dtype=float32)

Es stehen dieselben Funktionen zur Verfügung, einschließlich Tracking-Variablen und Submodulen.

my_sequential_model.variables
[<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-0.38431257, -0.19461048, -0.79379857],
        [-0.7217358 , -1.3580434 , -0.6475546 ],
        [-0.7105836 ,  2.407939  ,  1.2566456 ]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
 array([[ 1.037039  , -0.0270372 ],
        [ 0.20872033, -0.06744759],
        [ 0.60117465,  0.00604309]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
my_sequential_model.submodules
(<__main__.FlexibleDense at 0x7f5c58d093d0>,
 <__main__.FlexibleDense at 0x7f5c53cee550>)

Aufschalten tf.keras.Model ist ein sehr Pythonic Ansatz TensorFlow Modelle zu bauen. Wenn Sie Modelle aus anderen Frameworks migrieren, kann dies sehr einfach sein.

Wenn Sie Modelle bauen , die einfach Assemblagen von bestehenden Schichten und Eingänge sind, können Sie Zeit und Raum unter Verwendung des speichern funktionalen API , die sich um Modellrekonstruktion und Architektur mit zusätzlichen Features kommt.

Hier ist das gleiche Modell mit der funktionalen API:

inputs = tf.keras.Input(shape=[3,])

x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)

my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)

my_functional_model.summary()
Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 3)]               0         
_________________________________________________________________
flexible_dense_3 (FlexibleDe (None, 3)                 12        
_________________________________________________________________
flexible_dense_4 (FlexibleDe (None, 2)                 8         
=================================================================
Total params: 20
Trainable params: 20
Non-trainable params: 0
_________________________________________________________________
my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[-6.5035987, -2.943335 ]], dtype=float32)>

Der wesentliche Unterschied besteht darin, dass die Eingabeform im Vorfeld im funktionalen Konstruktionsprozess festgelegt wird. Das input_shape Argument in diesem Fall nicht vollständig angegeben werden; Sie können einige Dimensionen wie verlassen None .

Keras-Modelle speichern

Keras Modelle werden mit Fixpunkten, und das wird das gleiche wie aussehen tf.Module .

Keras Modelle können auch mit gespeichert werden tf.saved_model.save() , wie sie Module sind. Keras-Modelle verfügen jedoch über praktische Methoden und andere Funktionen:

my_sequential_model.save("exname_of_file")
INFO:tensorflow:Assets written to: exname_of_file/assets

Genauso einfach können sie wieder geladen werden in:

reconstructed_model = tf.keras.models.load_model("exname_of_file")
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.

Keras SavedModels auch speichern metrisch, Verlust und Optimierer Staaten.

Dieses rekonstruierte Modell kann verwendet werden und liefert dasselbe Ergebnis, wenn es mit denselben Daten aufgerufen wird:

reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[-3.6328888 , -0.01937295]], dtype=float32)>

Es gibt weitere Informationen zum Speichern und Serialisieren von Keras-Modellen, einschließlich der Bereitstellung von Konfigurationsmethoden für benutzerdefinierte Layer zur Feature-Unterstützung. Schauen Sie sich die aus Führung , um das Speichern und Serialisierung .

Was kommt als nächstes

Wenn Sie weitere Informationen über Keras wissen wollen, können Sie die vorhandenen Keras Führer folgen hier .

Ein weiteres Beispiel für einen High-Level - API auf gebaut tf.module ist Sonnet von DeepMind, die auf bedeckt ist ihre Website .