Geekly articles weekly

Keras Bewertung für TensorFlow



Übersetzung des Übersichtsleitfadens von Tensorflow.org. In diesem Handbuch erhalten Sie die Grundlagen für den Einstieg in Keras. Das Lesen dauert 10 Minuten.

Import tf.keras


tf.keras ist eine Implementierung der TensorFlow Keras API-Spezifikation. Dies ist eine High-Level-API zum tf.data und Trainieren von Modellen, die erstklassige Unterstützung für TensorFlow-spezifische Funktionen wie eifrige Ausführung , tf.data Pipelines und Estimators umfasst . tf.keras die Verwendung von TensorFlow ohne Einbußen bei Flexibilität und Leistung.

Importieren Sie zunächst tf.keras als Teil Ihres TensorFlow-Setups:

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

tf.keras kann jeden Keras-kompatiblen Code ausführen. tf.keras jedoch tf.keras :

  • Die Version von tf.keras in der neuesten TensorFlow-Version unterscheidet sich möglicherweise von der neuesten Version von keras in PyPI. Schauen Sie sich tf.keras.__version__ .
  • Wenn Sie Modellgewichte speichern, führt tf.keras dies standardmäßig im Prüfpunktformat aus. save_format='h5' Parameter save_format='h5' , um HDF5 zu verwenden (oder fügen Sie dem .h5 Erweiterung .h5 ).

Erstellen Sie ein einfaches Modell


Sequenzielles Modell


In Keras sammeln Sie Layer zum Erstellen von Modellen . Ein Modell ist (normalerweise) ein Layerdiagramm. Der gebräuchlichste Modelltyp ist der Ebenenstapel: tf.keras.Sequential model.

Wir konstruieren ein einfaches, vollständig verbundenes Netzwerk (d. H. Ein mehrschichtiges Perzeptron):

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

Ebenen anpassen


Viele verschiedene tf.keras.layers Layer sind tf.keras.layers . Die meisten von ihnen verwenden einen gemeinsamen Argumentkonstruktor:

  • activation : Legt die Aktivierungsfunktion für die Ebene fest. Dieser Parameter gibt den Namen der eingebauten Funktion oder des aufgerufenen Objekts an. Der Parameter hat keinen Standardwert.
  • kernel_initializer und bias_initializer : Initialisierungsschemata, die Layer-Gewichte erzeugen (Core und Shift). Dieser Parameter kann der Name oder das aufgerufene Objekt sein. Der Standardinitialisierer ist "Glorot uniform" .
  • kernel_regularizer und bias_regularizer : Regularisierungsschemata, die zu Layer-Gewichten (Core und Shift) hinzugefügt wurden, z. B. L1- oder L2-Regularisierung. Standardmäßig ist die Regularisierung nicht festgelegt.

Die folgenden Beispiele für Instanzen der Ebenen `tf.keras.layers.Dense` verwenden Konstruktorargumente:

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

Schulung und Bewertung


Trainingsaufbau


Konfigurieren Sie nach dem compile des Modells den Lernprozess, indem Sie die compile aufrufen:

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

tf.keras.Model.compile akzeptiert drei wichtige Argumente:

  • optimizer : Dieses Objekt definiert den Trainingsablauf. tf.keras.optimizers Optimiererinstanzen aus dem Modul tf.keras.optimizers , z. B. tf.keras.optimizers.Adam oder tf.keras.optimizers.SGD . Wenn Sie nur die Standardoptionen verwenden möchten, können Sie auch Optimierer mit Schlüsselwörtern wie 'adam' oder 'sgd' .
  • loss : Dies ist eine Funktion, die im Lernprozess minimiert wird. Zu den gebräuchlichen Varianten gehören der Standardfehler ( mse ), categorical_crossentropy und binary_crossentropy . Verlustfunktionen werden durch den Namen oder die Übergabe des aufgerufenen Objekts aus dem Modul tf.keras.losses .
  • metrics : Dient zum Überwachen des Trainings. Dies sind Zeichenfolgenamen oder aufgerufene Objekte aus dem Modul tf.keras.metrics .
  • run_eagerly=True Sie außerdem sicher, dass Sie den Parameter run_eagerly=True an den Compiler übergeben, um sicherzustellen, dass das Modell run_eagerly=True trainiert und ausgewertet wird

Als Nächstes sehen wir einige Beispiele für die Modellkonfiguration für das Training:

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

Aus NumPy-Daten lernen


Verwenden Sie für kleinere Datensätze die Speicher-Arrays von NumPy, um das Modell zu trainieren und auszuwerten. Das Modell wird auf Trainingsdaten mit der "Fit" -Methode "trainiert":

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit hat drei wichtige Argumente:

  • epochs : Lernen gliedert sich in * Epochen *. Die Ära ist eine Iteration über alle Eingabedaten (dies erfolgt in kleinen Stapeln).
  • batch_size : Beim Übertragen von NumPy-Daten zerlegt das Modell die Daten in kleinere Blöcke (Batches) und iteriert während des Trainings über diese Blöcke. Diese Nummer gibt die Größe jedes Datenblocks an. Beachten Sie, dass der letzte Block möglicherweise kleiner ist, wenn die Gesamtzahl der Datensätze nicht durch die Stapelgröße geteilt wird.
  • validation_data : Beim Prototyping eines Modells möchten Sie dessen Leistung anhand von Validierungsdaten auf einfache Weise verfolgen. Durch Übergeben eines Tupels von Eingabedaten und Bezeichnungen mit diesem Argument kann das Modell die Werte der Verlustfunktion und der Metriken im Ausgabemodus für die Daten anzeigen, die am Ende jeder Ära übertragen werden.

Hier ist ein Beispiel mit validation_data :

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))

Schulung mit tf.data-Datensätzen


Verwenden Sie die Datasets-API, um große Datenbanken oder Schulungen auf mehreren Geräten zu skalieren. Übergeben Sie die Instanz von "tf.data.Dataset" an die fit Methode:

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

Da Dataset Daten in batch_size bereitstellt, ist für diesen Code das Argument batch_size nicht erforderlich.

Datensätze können auch verwendet werden, um Folgendes zu überprüfen:

 dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)

Einschätzung und Vorhersage


Die tf.keras.Model.predict tf.keras.Model.evaluate und tf.keras.Model.predict können die tf.data.Dataset NumPy und tf.data.Dataset .

So können Sie die Verluste im Ausgabemodus und die Messdaten für die bereitgestellten Daten abschätzen :

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

Und so können Sie die Ausgabe der letzten Ebene im Ausgabemodus für die bereitgestellten Daten in Form eines NumPy-Arrays vorhersagen :

Komplexe Modelle erstellen


Die funktionale API


Das tf.keras.Sequential Modell ist ein einfacher Ebenenstapel, mit dem Sie sich kein beliebiges Modell vorstellen können. Verwenden Sie die Keras-Funktions-API, um komplexe Modelltopologien zu erstellen, z.

  • Modelle mit mehreren Eingängen
  • Modelle mit mehreren Ausgängen,
  • Modelle mit gemeinsamen Ebenen (dieselbe Ebene wird mehrmals aufgerufen),
  • Modelle mit inkonsistenten Datenströmen (z. B. Restbeziehungen).

Das Erstellen eines Modells mit einer funktionalen API funktioniert wie folgt:

  1. Die Ebeneninstanz ist aufrufbar und gibt einen Tensor zurück.
  2. Eingabe- und Ausgabetensoren werden verwendet, um die Instanz von tf.keras.Model zu bestimmen
  3. Dieses Modell wird genau wie das 'Sequential'-Modell trainiert.

Im folgenden Beispiel wird mithilfe der funktionalen API ein einfaches, vollständig verbundenes Netzwerk erstellt:

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

Erstellen Sie mit diesen Ein- und Ausgängen eine Instanz des Modells.

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

Unterklassen von Modellen


Erstellen Sie ein vollständig anpassbares Modell, indem Sie die Unterklasse tf.keras.Model und Ihre eigene direkte Verteilung definieren. Erstellen Sie Ebenen in der Methode __init__ und legen Sie sie als Attribute der Klasseninstanz fest. Definieren Sie die direkte Weitergabe in der call .

Die Unterklassifizierung eines Modells ist besonders nützlich, wenn die Eager-Ausführung aktiviert ist, da Sie die direkte Verteilung zwingend schreiben können.

Hinweis: Wenn Ihr Modell immer zwingend ausgeführt werden soll, können Sie dynamic=True wenn Sie den super aufrufen.
Schlüsselpunkt: Verwenden Sie die richtige API, um zu arbeiten. Die Unterklassifizierung eines Modells bietet zwar Flexibilität, Sie müssen jedoch dafür mit einer höheren Komplexität und einem höheren Potenzial für benutzerdefinierte Fehler bezahlen. Wenn möglich, wählen Sie die funktionale API.
Das folgende Beispiel zeigt ein untergeordnetes tf.keras.Model-Modell mit benutzerdefinierter Direktverteilung, die nicht unbedingt erforderlich ist:

 class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

Erstellen Sie eine Instanz der neuen Modellklasse:

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Benutzerdefinierte Ebenen


Erstellen Sie eine benutzerdefinierte Ebene, indem Sie tf.keras.layers.Layer unterklassifizieren und die folgenden Methoden implementieren:

  • __init__ : __init__ optional die Sublayer an, die in dieser Ebene verwendet werden sollen.
  • * build : Lagengewichte erstellen. Fügen Sie Gewichte mit der Methode add_weight
  • call : Direktverteilung definieren.
  • Optional kann der Layer durch Implementieren der get_config Methode und der from_config Klassenmethode from_config .

Unten sehen Sie ein Beispiel für eine Benutzerebene, die die Matrix ( matmul ), die der Eingabe zugeführt wird, mit der matmul multipliziert:

 class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): #       . self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)

Erstellen Sie ein Modell mit Ihrer benutzerdefinierten Ebene:

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Kolbeki


Kolbek ist ein Objekt, das auf das Modell übertragen wird, um sein Verhalten während des Trainings anzupassen und zu erweitern. Sie können Ihren eigenen benutzerdefinierten Rückruf schreiben oder die integrierten tf.keras.callbacks die tf.keras.callbacks umfassen:

tf.keras.callbacks.ModelCheckpoint : Speichern von Modell-Haltepunkten in regelmäßigen Abständen.
tf.keras.callbacks.LearningRateScheduler : tf.keras.callbacks.LearningRateScheduler dynamisch ändern.
tf.keras.callbacks.EarlyStopping : tf.keras.callbacks.EarlyStopping Trainings, wenn sich das Ergebnis der Validierung nicht mehr verbessert.
tf.keras.callbacks.TensorBoard: Überwachen des Modellverhaltens mit
Tensorboard

Um tf.keras.callbacks.Callback , übergeben Sie es an die Methode fit model:

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))

Speichern und Wiederherstellen


Nur Gewichtswerte speichern


Speichern und Laden von Modellgewichten mit tf.keras.Model.save_weights :

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) 

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

Standardmäßig werden Modellgewichte im TensorFlow-Prüfpunktformat gespeichert. Gewichte können auch im Keras HDF5-Format gespeichert werden (Standardwert für die universelle Keras-Implementierung):

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

Nur Modellkonfiguration speichern


Die Konfiguration des Modells kann gespeichert werden - dies serialisiert die Architektur des Modells ohne Gewichte. Eine gespeicherte Konfiguration kann dasselbe Modell wiederherstellen und initialisieren, auch ohne Code, der das ursprüngliche Modell definiert. Keras unterstützt die Serialisierungsformate JSON und YAML:

 #     JSON json_string = model.to_json() json_string 

 import json import pprint pprint.pprint(json.loads(json_string))

Modell aus JSON wiederherstellen (neu initialisieren):

 fresh_model = tf.keras.models.model_from_json(json_string)

Um das Modell in YAML zu serialisieren, muss vor dem Import von TensorFlow `pyyaml` installiert werden:

 yaml_string = model.to_yaml() print(yaml_string)

Wiederherstellen eines Modells aus YAML:

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

Hinweis: Modelle mit Unterklassen können nicht serialisiert werden, da ihre Architektur durch Python-Code im Hauptteil der Methode `call` definiert wird.

Speichern des gesamten Modells in einer Datei


Das gesamte Modell kann in einer Datei gespeichert werden, die die Werte der Gewichte, die Konfiguration des Modells und sogar die Konfiguration des Optimierers enthält. Auf diese Weise können Sie einen Modell-Haltepunkt festlegen und später von genau derselben Position aus weiter trainieren, auch ohne Zugriff auf den Quellcode.

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

Eifrige Ausführung


Eager Execution ist eine zwingende Programmierumgebung, die Operationen sofort ausführt. Dies ist für Keras nicht erforderlich, wird jedoch von tf.keras und ist nützlich, um Ihr Programm und das Debuggen zu überprüfen.

Alle Gebäudemodelle der `tf.keras` API sind mit Eiferausführung kompatibel. Obwohl die sequentiellen und funktionalen APIs verwendet werden können, ist eine eifrige Ausführung besonders nützlich, wenn Sie ein Modell in Unterklassen unterteilen und benutzerdefinierte Layer erstellen. Bei diesen APIs müssen Sie die direkte Verteilung in Form von Code schreiben (anstelle der APIs, die Modelle durch Zusammenstellen vorhandener Layer erstellen).

Verteilung


Mehrere GPUs


tf.keras Modelle können mit tf.distribute.Strategy auf mehreren GPUs tf.distribute.Strategy . Diese API bietet verteiltes Lernen über mehrere GPUs mit nur geringen oder keinen Änderungen an vorhandenem Code.

Derzeit ist tf.distribute.MirroredStrategy einzige unterstützte Verteilungsstrategie. MirroredStrategy repliziert Diagramme mit
Synchrones Lernen mit All-Reduce auf einer Maschine. Um ` distribute.Strategy , verschachteln Sie die Installation, den Entwurf und die Kompilierung des Optimierers des Modells .scope() Strategy .scope() `und trainieren Sie dann das Modell.

Im folgenden Beispiel wird tf.keras.Model mehrere GPUs auf demselben Computer verteilt.

Zunächst definieren wir ein Modell im Bereich einer verteilten Strategie:

 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()

Dann trainieren wir das Modell wie gewohnt an den Daten:

 x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)

Nach der Überprüfung wird die Übersetzung auch auf Tensorflow.org angezeigt. Wenn Sie an der Übersetzung der Dokumentation der Tensorflow.org-Website ins Russische teilnehmen möchten, wenden Sie sich bitte an eine Person oder einen Kommentar. Korrekturen oder Kommentare sind willkommen.

Source: https://habr.com/ru/post/de482126/

More articles:


All Articles