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

Modelle und Ebenen

Beim maschinellen Lernen ist ein Modell eine Funktion mit lernbaren Parametern , die eine Eingabe einer Ausgabe zuordnet. Die optimalen Parameter werden erhalten, indem das Modell auf Daten trainiert wird. Ein gut trainiertes Modell bietet eine genaue Zuordnung von der Eingabe zur gewünschten Ausgabe.

In TensorFlow.js gibt es zwei Möglichkeiten, ein Modell für maschinelles Lernen zu erstellen:

  1. Verwenden der Ebenen-API, mit der Sie ein Modell mithilfe von Ebenen erstellen.
  2. Verwenden der Core-API mit untergeordneten tf.matMul() wie tf.matMul() , tf.add() usw.

Zunächst betrachten wir die Layer-API, eine übergeordnete API zum Erstellen von Modellen. Anschließend zeigen wir, wie Sie dasselbe Modell mithilfe der Core-API erstellen.

Erstellen von Modellen mit der Ebenen-API

Es gibt zwei Möglichkeiten, ein Modell mithilfe der Ebenen-API zu erstellen: Ein sequentielles Modell und ein Funktionsmodell . In den nächsten beiden Abschnitten werden die einzelnen Typen genauer betrachtet.

Das sequentielle Modell

Der häufigste Modelltyp ist das Sequential Modell, bei dem es sich um einen linearen Stapel von Schichten handelt. Sie können ein Sequential Modell erstellen, indem Sie eine Liste von Ebenen an die Funktion sequential() :

 const model = tf.sequential({
 layers: [
   tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}),
   tf.layers.dense({units: 10, activation: 'softmax'}),
 ]
});
 

Oder über die add() -Methode:

 const model = tf.sequential();
model.add(tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));
 

WICHTIG: Die erste Ebene im Modell benötigt eine inputShape . inputShape Sie sicher, dass Sie die inputShape ausschließen, wenn Sie die inputShape . Wenn Sie beispielsweise inputShape , die inputShape der Form [B, 784] zu füttern, wobei B eine beliebige inputShape kann, geben inputShape beim Erstellen des Modells inputShape als [784] an.

Sie können auf die Ebenen des Modells über model.layers , insbesondere über model.inputLayers und model.outputLayers .

Das Funktionsmodell

Eine andere Möglichkeit, ein LayersModel zu erstellen, ist die Funktion tf.model() . Der Hauptunterschied zwischen tf.model() und tf.sequential() besteht darin, dass Sie mit tf.model() ein beliebiges Diagramm von Ebenen erstellen können, sofern diese keine Zyklen haben.

Hier ist ein Code-Snippet, das dasselbe Modell wie oben mithilfe der tf.model() definiert:

 // Create an arbitrary graph of layers, by connecting them
// via the apply() method.
const input = tf.input({shape: [784]});
const dense1 = tf.layers.dense({units: 32, activation: 'relu'}).apply(input);
const dense2 = tf.layers.dense({units: 10, activation: 'softmax'}).apply(dense1);
const model = tf.model({inputs: input, outputs: dense2});
 

Wir rufen apply() für jede Ebene auf, um sie mit der Ausgabe einer anderen Ebene zu verbinden. Das Ergebnis von apply() in diesem Fall ein SymbolicTensor , der sich wie ein Tensor jedoch keine konkreten Werte aufweist.

Beachten Sie, dass wir im Gegensatz zum sequentiellen Modell einen SymbolicTensor über tf.input() erstellen, anstatt der ersten Ebene eine inputShape .

apply() kann Ihnen auch einen konkreten Tensor , wenn Sie einen konkreten Tensor an ihn übergeben:

 const t = tf.tensor([-2, 1, 0, 5]);
const o = tf.layers.activation({activation: 'relu'}).apply(t);
o.print(); // [0, 1, 0, 5]
 

Dies kann nützlich sein, wenn Ebenen isoliert getestet und ihre Ausgabe angezeigt werden.

Genau wie in einem sequentiellen Modell können Sie über model.layers und insbesondere model.inputLayers und model.outputLayers auf die Ebenen des Modells model.outputLayers .

Validierung

Sowohl das sequentielle Modell als auch das Funktionsmodell sind Instanzen der LayersModel Klasse. Einer der LayersModel der Arbeit mit einem LayersModel ist die Validierung: Sie müssen die Eingabeform angeben und werden später zur Validierung Ihrer Eingabe verwendet. Das LayersModel auch eine automatische LayersModel durch, wenn die Daten durch die Ebenen fließen. Wenn Sie die Form im Voraus kennen, kann das Modell seine Parameter automatisch erstellen und feststellen, ob zwei aufeinanderfolgende Ebenen nicht miteinander kompatibel sind.

Modellzusammenfassung

Rufen Sie model.summary() auf, um eine nützliche Zusammenfassung des Modells zu drucken. model.summary() gehören:

  • Name und Typ aller Ebenen im Modell.
  • Ausgabeform für jede Ebene.
  • Anzahl der Gewichtsparameter jeder Schicht.
  • Wenn das Modell eine allgemeine Topologie hat (siehe unten), werden die Eingaben jeder Schicht empfangen
  • Die Gesamtzahl der trainierbaren und nicht trainierbaren Parameter des Modells.

Für das oben definierte Modell erhalten wir die folgende Ausgabe auf der Konsole:

Ebene (Typ) Ausgabeform Param #
dicht_Dense1 (dicht) [null, 32] 25120
dicht_Dense2 (dicht) [null, 10] 330
Gesamtparameter: 25450
Trainierbare Parameter: 25450
Nicht trainierbare Parameter: 0

Beachten Sie die null in den Ausgabeformen der Ebenen: Eine Erinnerung daran, dass das Modell erwartet, dass die Eingabe eine Stapelgröße als äußerste Dimension hat, die in diesem Fall aufgrund des null flexibel sein kann.

Serialisierung

Einer der LayersModel der Verwendung eines LayersModel gegenüber der untergeordneten API ist die Möglichkeit, ein Modell zu speichern und zu laden. Ein LayersModel weiß über:

  • die Architektur des Modells, sodass Sie das Modell neu erstellen können.
  • die Gewichte des Modells
  • die Trainingskonfiguration (Verlust, Optimierer, Metriken).
  • den Status des Optimierers, mit dem Sie das Training fortsetzen können.

Das Speichern oder Laden eines Modells umfasst nur eine Codezeile:

 const saveResult = await model.save('localstorage://my-model-1');
const model = await tf.loadLayersModel('localstorage://my-model-1');
 

Im obigen Beispiel wird das Modell im lokalen Speicher des Browsers gespeichert. Siehe die model.save() documentation und den Speichern und Laden Anleitung, wie auf verschiedenen Medien speichern (zB Dateispeicher, IndexedDB , auslösen einen Browser herunterladen, etc.)

Benutzerdefinierte Ebenen

Ebenen sind die Bausteine ​​eines Modells. Wenn Ihr Modell eine benutzerdefinierte Berechnung durchführt, können Sie eine benutzerdefinierte Ebene definieren, die gut mit den übrigen Ebenen interagiert. Im Folgenden definieren wir eine benutzerdefinierte Ebene, die die Summe der Quadrate berechnet:

 class SquaredSumLayer extends tf.layers.Layer {
 constructor() {
   super({});
 }
 // In this case, the output is a scalar.
 computeOutputShape(inputShape) { return []; }

 // call() is where we do the computation.
 call(input, kwargs) { return input.square().sum();}

 // Every layer needs a unique name.
 getClassName() { return 'SquaredSum'; }
}
 

Um es zu testen, können wir die Methode apply() mit einem konkreten Tensor aufrufen:

 const t = tf.tensor([-2, 1, 0, 5]);
const o = new SquaredSumLayer().apply(t);
o.print(); // prints 30
 

WICHTIG: Wenn Sie eine benutzerdefinierte Ebene hinzufügen, können Sie ein Modell nicht mehr serialisieren.

Erstellen von Modellen mit der Core-API

Am Anfang dieses Handbuchs haben wir erwähnt, dass es in TensorFlow.js zwei Möglichkeiten gibt, ein Modell für maschinelles Lernen zu erstellen.

Die allgemeine Faustregel lautet, immer zuerst zu versuchen, die Layer-API zu verwenden, da sie der gut übernommenen Keras-API nachempfunden ist, die bewährten Methoden folgt und die kognitive Belastung verringert . Die Layers-API bietet auch verschiedene Standardlösungen wie Gewichtsinitialisierung, Modellserialisierung, Überwachungstraining, Portabilität und Sicherheitsprüfung.

Möglicherweise möchten Sie die Core-API verwenden, wenn:

  • Sie benötigen maximale Flexibilität oder Kontrolle.
  • Sie benötigen keine Serialisierung oder können Ihre eigene Serialisierungslogik implementieren.

Modelle in der Core-API sind nur Funktionen, die einen oder mehrere Tensors und einen Tensor . Das gleiche Modell wie oben, das mit der Core-API geschrieben wurde, sieht folgendermaßen aus:

 // The weights and biases for the two dense layers.
const w1 = tf.variable(tf.randomNormal([784, 32]));
const b1 = tf.variable(tf.randomNormal([32]));
const w2 = tf.variable(tf.randomNormal([32, 10]));
const b2 = tf.variable(tf.randomNormal([10]));

function model(x) {
  return x.matMul(w1).add(b1).relu().matMul(w2).add(b2).softmax();
}
 

Beachten Sie, dass wir in der Core-API für das Erstellen und Initialisieren der Gewichte des Modells verantwortlich sind. Jedes Gewicht wird von einer Variable die TensorFlow.js signalisiert, dass diese Tensoren lernbar sind. Sie können eine Variable mit tf.variable () erstellen und einen vorhandenen Tensor .

In diesem Handbuch haben Sie sich mit den verschiedenen Möglichkeiten zum Erstellen eines Modells mithilfe der Ebenen und der Kern-API vertraut gemacht. Als Nächstes erfahren Sie im Handbuch zu Trainingsmodellen, wie Sie ein Modell trainieren.