TensorFlow.js – Vorhersagen aus 2D-Daten treffen

1. Einführung

In diesem Codelab trainieren Sie ein Modell, um Vorhersagen aus numerischen Daten zu treffen, die eine Reihe von Autos beschreiben.

In dieser Übung werden Schritte gezeigt, die beim Training vieler verschiedener Arten von Modellen üblich sind. Dabei werden jedoch ein kleines Dataset und ein einfaches (flaches) Modell verwendet. Das primäre Ziel ist es, Sie mit der grundlegenden Terminologie, den Konzepten und der Syntax für das Trainieren von Modellen mit TensorFlow.js vertraut zu machen und Ihnen eine Grundlage für weitere Erkundungen und Lernprozesse zu bieten.

Da wir ein Modell trainieren, um kontinuierliche Zahlen vorherzusagen, wird diese Aufgabe manchmal als Regressionsaufgabe bezeichnet. Wir trainieren das Modell, indem wir ihm viele Beispiele für Eingaben zusammen mit der richtigen Ausgabe zeigen. Das wird als beaufsichtigtes Lernen bezeichnet.

Umfang

Sie erstellen eine Webseite, auf der mit TensorFlow.js ein Modell im Browser trainiert wird. Wenn das Modell die PS-Zahl eines Autos kennt, kann es den Kraftstoffverbrauch (Kilometer pro Liter) vorhersagen.

Dazu gehen Sie so vor:

Laden Sie die Daten und bereiten Sie sie für das Training vor.
Definieren Sie die Architektur des Modells.
Trainieren Sie das Modell und überwachen Sie seine Leistung während des Trainings.
Bewerten Sie das trainierte Modell, indem Sie einige Vorhersagen treffen.

Lerninhalte

Best Practices für die Datenvorbereitung für maschinelles Lernen, einschließlich Shuffling und Normalisierung.
TensorFlow.js-Syntax zum Erstellen von Modellen mit der tf.layers API.
So überwachen Sie das Training im Browser mit der tfjs-vis-Bibliothek.

Voraussetzungen

Eine aktuelle Version von Chrome oder einem anderen modernen Browser.
Ein Texteditor, der entweder lokal auf Ihrem Computer oder im Web über Codepen oder Glitch ausgeführt wird.
Kenntnisse von HTML, CSS, JavaScript und den Chrome-Entwicklertools (oder den Entwicklertools Ihres bevorzugten Browsers).
Ein grundlegendes konzeptionelles Verständnis von neuronalen Netzwerken. Wenn Sie eine Einführung oder Auffrischung benötigen, können Sie sich dieses Video von 3blue1brown oder dieses Video zu Deep Learning in JavaScript von Ashi Krishnan ansehen.

2. Einrichten

HTML-Seite erstellen und JavaScript einfügen

Kopieren Sie den folgenden Code in eine HTML-Datei mit dem Namen .

index.html

<!DOCTYPE html>
<html>
<head>
  <title>TensorFlow.js Tutorial</title>

  <!-- Import TensorFlow.js -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@2.0.0/dist/tf.min.js"></script>
  <!-- Import tfjs-vis -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-vis@1.0.2/dist/tfjs-vis.umd.min.js"></script>
</head>
<body>
  <!-- Import the main script file -->
  <script src="script.js"></script>
</body>
</html>

JavaScript-Datei für den Code erstellen

Erstellen Sie im selben Ordner wie die HTML-Datei oben eine Datei mit dem Namen script.js und fügen Sie den folgenden Code ein.

console.log('Hello TensorFlow');

Jetzt ausprobieren

Nachdem Sie die HTML- und JavaScript-Dateien erstellt haben, können Sie sie testen. Öffnen Sie die Datei „index.html“ in Ihrem Browser und öffnen Sie die Entwicklertools-Konsole.

Wenn alles funktioniert, sollten zwei globale Variablen erstellt und in der Entwicklertools-Konsole verfügbar sein:

tf ist ein Verweis auf die TensorFlow.js-Bibliothek.
tfvis ist ein Verweis auf die tfjs-vis-Bibliothek.

Öffnen Sie die Entwicklertools Ihres Browsers. In der Konsolenausgabe sollte die Meldung Hello TensorFlow angezeigt werden. Wenn ja, können Sie mit dem nächsten Schritt fortfahren.

3. Eingabedaten laden, formatieren und visualisieren

Als Erstes laden, formatieren und visualisieren wir die Daten, mit denen wir das Modell trainieren möchten.

Wir laden das Dataset „cars“ aus einer JSON-Datei, die wir für Sie gehostet haben. Sie enthält viele verschiedene Funktionen zu jedem Auto. In dieser Anleitung möchten wir nur Daten zu „Horsepower“ (PS) und „Miles Per Gallon“ (Meilen pro Gallone) extrahieren.

Fügen Sie den folgenden Code hinzu.

script.js Datei

/**
 * Get the car data reduced to just the variables we are interested
 * and cleaned of missing data.
 */
async function getData() {
  const carsDataResponse = await fetch('https://storage.googleapis.com/tfjs-tutorials/carsData.json');
  const carsData = await carsDataResponse.json();
  const cleaned = carsData.map(car => ({
    mpg: car.Miles_per_Gallon,
    horsepower: car.Horsepower,
  }))
  .filter(car => (car.mpg != null && car.horsepower != null));

  return cleaned;
}

Dadurch werden auch alle Einträge entfernt, für die entweder keine Meilen pro Gallone oder keine PS definiert sind. Wir stellen diese Daten auch in einem Streudiagramm dar, um zu sehen, wie sie aussehen.

Fügen Sie den folgenden Code am Ende von ein.

script.js file.

async function run() {
  // Load and plot the original input data that we are going to train on.
  const data = await getData();
  const values = data.map(d => ({
    x: d.horsepower,
    y: d.mpg,
  }));

  tfvis.render.scatterplot(
    {name: 'Horsepower v MPG'},
    {values},
    {
      xLabel: 'Horsepower',
      yLabel: 'MPG',
      height: 300
    }
  );

  // More code will be added below
}

document.addEventListener('DOMContentLoaded', run);

Wenn Sie die Seite aktualisieren. Auf der linken Seite der Seite sollte ein Bereich mit einem Streudiagramm der Daten angezeigt werden. Die Anzeige sollte ungefähr so aussehen.

Dieses Feld wird als Visier bezeichnet und wird von tfjs-vis bereitgestellt. Sie bieten einen praktischen Ort für Visualisierungen.

Bei der Arbeit mit Daten ist es im Allgemeinen sinnvoll, sich die Daten anzusehen und sie bei Bedarf zu bereinigen. In diesem Fall mussten wir bestimmte Einträge aus carsData entfernen, die nicht alle erforderlichen Felder enthielten. Durch die Visualisierung der Daten können wir erkennen, ob die Daten eine Struktur aufweisen, die das Modell lernen kann.

Das Diagramm oben zeigt, dass es eine negative Korrelation zwischen PS und MPG gibt. Das heißt, je höher die PS-Zahl ist, desto weniger Meilen pro Gallone werden in der Regel erzielt.

Aufgabe konzipieren

Unsere Eingabedaten sehen jetzt so aus.

...
{
  "mpg":15,
  "horsepower":165,
},
{
  "mpg":18,
  "horsepower":150,
},
{
  "mpg":16,
  "horsepower":150,
},
...

Unser Ziel ist es, ein Modell zu trainieren, das eine Zahl, Horsepower, als Eingabe verwendet und eine Zahl, Miles per Gallon, vorhersagt. Merken Sie sich diese 1:1-Zuordnung, da sie für den nächsten Abschnitt wichtig ist.

Wir werden diese Beispiele, die PS und den Kraftstoffverbrauch, in ein neuronales Netzwerk eingeben, das anhand dieser Beispiele eine Formel (oder Funktion) lernt, um den Kraftstoffverbrauch anhand der PS vorherzusagen. Dieses Lernen aus Beispielen, für die wir die richtigen Antworten haben, wird als überwachtes Lernen bezeichnet.

4. Modellarchitektur definieren

In diesem Abschnitt schreiben wir Code, um die Modellarchitektur zu beschreiben. Die Modellarchitektur ist nur eine elegante Art zu sagen, welche Funktionen das Modell bei der Ausführung ausführt oder alternativ welchen Algorithmus unser Modell zur Berechnung seiner Antworten verwendet.

ML-Modelle sind Algorithmen, die eine Eingabe entgegennehmen und eine Ausgabe erzeugen. Bei neuronalen Netzen besteht der Algorithmus aus einer Reihe von Neuronen-Layern mit „Gewichtungen“ (Zahlen), die die Ausgabe steuern. Im Trainingsprozess werden die idealen Werte für diese Gewichte ermittelt.

Fügen Sie die folgende Funktion hinzu.

script.js Datei zum Definieren der Modellarchitektur

function createModel() {
  // Create a sequential model
  const model = tf.sequential();

  // Add a single input layer
  model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));

  // Add an output layer
  model.add(tf.layers.dense({units: 1, useBias: true}));

  return model;
}

Dies ist eines der einfachsten Modelle, die wir in tensorflow.js definieren können. Sehen wir uns jede Zeile genauer an.

Modell instanziieren

const model = tf.sequential();

Dadurch wird ein tf.Model-Objekt instanziiert. Dieses Modell ist sequential, weil die Eingaben direkt in die Ausgabe fließen. Andere Arten von Modellen können Verzweigungen oder sogar mehrere Eingaben und Ausgaben haben, aber in vielen Fällen sind Ihre Modelle sequenziell. Sequenzielle Modelle haben auch eine nutzerfreundlichere API.

Ebenen hinzufügen

model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));

Dadurch wird unserem Netzwerk eine Eingabeschicht hinzugefügt, die automatisch mit einer dense-Schicht mit einer verborgenen Einheit verbunden wird. Eine dense-Schicht ist ein Schichttyp, bei dem die Eingaben mit einer Matrix (den Gewichten) multipliziert und dann eine Zahl (der Bias) zum Ergebnis addiert wird. Da dies die erste Ebene des Netzwerks ist, müssen wir inputShape definieren. Der inputShape ist [1], da wir die 1 als Eingabe haben (die Leistung eines bestimmten Autos).

Mit units wird festgelegt, wie groß die Gewichtsmatrix in der Ebene sein soll. Wenn wir den Wert hier auf 1 setzen, bedeutet das, dass es für jede der Eingabefunktionen der Daten ein Gewicht gibt.

model.add(tf.layers.dense({units: 1}));

Mit dem Code oben wird die Ausgabeschicht erstellt. Wir setzen units auf 1, da wir die Zahl 1 ausgeben möchten.

Instanz erstellen

Fügen Sie den folgenden Code hinzu:

run Funktion, die wir zuvor definiert haben.

// Create the model
const model = createModel();
tfvis.show.modelSummary({name: 'Model Summary'}, model);

Dadurch wird eine Instanz des Modells erstellt und eine Zusammenfassung der Ebenen auf der Webseite angezeigt.

5. Daten für das Training vorbereiten

Um die Leistungsvorteile von TensorFlow.js zu nutzen, die das Trainieren von Modellen für maschinelles Lernen ermöglichen, müssen wir unsere Daten in Tensoren umwandeln. Außerdem führen wir eine Reihe von Transformationen an unseren Daten durch, die Best Practices entsprechen, nämlich Shuffling und Normalisierung.

Fügen Sie den folgenden Code hinzu.

script.js Datei

/**
 * Convert the input data to tensors that we can use for machine
 * learning. We will also do the important best practices of _shuffling_
 * the data and _normalizing_ the data
 * MPG on the y-axis.
 */
function convertToTensor(data) {
  // Wrapping these calculations in a tidy will dispose any
  // intermediate tensors.

  return tf.tidy(() => {
    // Step 1. Shuffle the data
    tf.util.shuffle(data);

    // Step 2. Convert data to Tensor
    const inputs = data.map(d => d.horsepower)
    const labels = data.map(d => d.mpg);

    const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
    const labelTensor = tf.tensor2d(labels, [labels.length, 1]);

    //Step 3. Normalize the data to the range 0 - 1 using min-max scaling
    const inputMax = inputTensor.max();
    const inputMin = inputTensor.min();
    const labelMax = labelTensor.max();
    const labelMin = labelTensor.min();

    const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
    const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));

    return {
      inputs: normalizedInputs,
      labels: normalizedLabels,
      // Return the min/max bounds so we can use them later.
      inputMax,
      inputMin,
      labelMax,
      labelMin,
    }
  });
}

Sehen wir uns an, was hier passiert.

Daten mischen

// Step 1. Shuffle the data
tf.util.shuffle(data);

Hier wird die Reihenfolge der Beispiele, die dem Trainingsalgorithmus zugeführt werden, zufällig festgelegt. Das Mischen ist wichtig, da das Dataset während des Trainings in der Regel in kleinere Teilmengen, sogenannte Batches, unterteilt wird, mit denen das Modell trainiert wird. Durch das Mischen enthält jeder Batch eine Vielzahl von Daten aus der gesamten Datenverteilung. So helfen wir dem Modell:

Keine Dinge lernen, die ausschließlich von der Reihenfolge abhängen, in der die Daten eingegeben wurden
Sie dürfen nicht empfindlich auf die Struktur in Untergruppen reagieren. Wenn das Modell beispielsweise in der ersten Hälfte des Trainings nur Autos mit hoher Leistung sieht, lernt es möglicherweise eine Beziehung, die nicht für den Rest des Datasets gilt.

In Tensoren konvertieren

// Step 2. Convert data to Tensor
const inputs = data.map(d => d.horsepower)
const labels = data.map(d => d.mpg);

const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
const labelTensor = tf.tensor2d(labels, [labels.length, 1]);

Hier erstellen wir zwei Arrays: eines für unsere Eingabebeispiele (die PS-Einträge) und eines für die tatsächlichen Ausgabewerte (die im maschinellen Lernen als Labels bezeichnet werden).

Anschließend wandeln wir die Arraydaten in einen 2D-Tensor um. Der Tensor hat die Form [num_examples, num_features_per_example]. Hier haben wir inputs.length Beispiele und jedes Beispiel hat 1 Eingabe-Features (die Pferdestärke).

Daten normalisieren

//Step 3. Normalize the data to the range 0 - 1 using min-max scaling
const inputMax = inputTensor.max();
const inputMin = inputTensor.min();
const labelMax = labelTensor.max();
const labelMin = labelTensor.min();

const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));

Als Nächstes wenden wir eine weitere Best Practice für das Training von Machine-Learning-Modellen an. Wir normalisieren die Daten. Hier werden die Daten mit Min-Max-Skalierung in den numerischen Bereich 0-1 normalisiert. Die Normalisierung ist wichtig, da viele Machine-Learning-Modelle, die Sie mit TensorFlow.js erstellen, für die Verarbeitung von Zahlen konzipiert sind, die nicht zu groß sind. Häufig werden Daten auf Bereiche wie 0 to 1 oder -1 to 1 normalisiert. Sie werden mehr Erfolg beim Trainieren Ihrer Modelle haben, wenn Sie Ihre Daten regelmäßig in einem angemessenen Bereich normalisieren.

Daten und Normalisierungsgrenzen zurückgeben

return {
  inputs: normalizedInputs,
  labels: normalizedLabels,
  // Return the min/max bounds so we can use them later.
  inputMax,
  inputMin,
  labelMax,
  labelMin,
}

Wir möchten die Werte beibehalten, die wir während des Trainings für die Normalisierung verwendet haben, damit wir die Ausgaben denormalisieren können, um sie wieder in den ursprünglichen Maßstab zu bringen, und zukünftige Eingabedaten auf dieselbe Weise normalisieren können.

6. Modell trainieren

Nachdem wir unsere Modellinstanz erstellt und unsere Daten als Tensoren dargestellt haben, haben wir alles, was wir für den Trainingsprozess benötigen.

Kopieren Sie die folgende Funktion in Ihre

script.js file.

async function trainModel(model, inputs, labels) {
  // Prepare the model for training.
  model.compile({
    optimizer: tf.train.adam(),
    loss: tf.losses.meanSquaredError,
    metrics: ['mse'],
  });

  const batchSize = 32;
  const epochs = 50;

  return await model.fit(inputs, labels, {
    batchSize,
    epochs,
    shuffle: true,
    callbacks: tfvis.show.fitCallbacks(
      { name: 'Training Performance' },
      ['loss', 'mse'],
      { height: 200, callbacks: ['onEpochEnd'] }
    )
  });
}

Sehen wir uns das genauer an.

Training vorbereiten

// Prepare the model for training.
model.compile({
  optimizer: tf.train.adam(),
  loss: tf.losses.meanSquaredError,
  metrics: ['mse'],
});

Wir müssen das Modell „kompilieren“, bevor wir es trainieren. Dazu müssen wir eine Reihe sehr wichtiger Dinge angeben:

optimizer: Dies ist der Algorithmus, der die Aktualisierungen des Modells steuert, wenn es Beispiele sieht. In TensorFlow.js sind viele Optimierer verfügbar. Wir haben den Adam-Optimizer ausgewählt, da er in der Praxis sehr effektiv ist und keine Konfiguration erfordert.
loss: Diese Funktion gibt an, wie gut das Modell die einzelnen Batches (Datenteilmengen) lernt, die ihm präsentiert werden. Hier verwenden wir meanSquaredError, um die Vorhersagen des Modells mit den tatsächlichen Werten zu vergleichen.

const batchSize = 32;
const epochs = 50;

Als Nächstes wählen wir eine Batchgröße und eine Anzahl von Epochen aus:

batchSize bezieht sich auf die Größe der Datenteilmengen, die das Modell bei jeder Trainingsiteration sieht. Gängige Batchgrößen liegen in der Regel zwischen 32 und 512. Es gibt keine ideale Batchgröße für alle Probleme. Die mathematischen Gründe für verschiedene Batchgrößen werden in diesem Tutorial nicht behandelt.
epochs bezieht sich auf die Häufigkeit, mit der das Modell das gesamte von Ihnen bereitgestellte Dataset durchläuft. Hier durchlaufen wir das Dataset 50 Mal.

Zugschleife starten

return await model.fit(inputs, labels, {
  batchSize,
  epochs,
  callbacks: tfvis.show.fitCallbacks(
    { name: 'Training Performance' },
    ['loss', 'mse'],
    { height: 200, callbacks: ['onEpochEnd'] }
  )
});

model.fit ist die Funktion, die wir aufrufen, um die Trainingsschleife zu starten. Da es sich um eine asynchrone Funktion handelt, geben wir das von ihr zurückgegebene Promise zurück, damit der Aufrufer feststellen kann, wann das Training abgeschlossen ist.

Um den Trainingsfortschritt zu überwachen, übergeben wir einige Callbacks an model.fit. Wir verwenden tfvis.show.fitCallbacks, um Funktionen zu generieren, mit denen Diagramme für die zuvor angegebenen Messwerte „loss“ und „mse“ erstellt werden.

Zusammenfassung

Jetzt müssen wir die definierten Funktionen über unsere run-Funktion aufrufen.

Fügen Sie den folgenden Code am Ende von ein.

run-Funktion.

// Convert the data to a form we can use for training.
const tensorData = convertToTensor(data);
const {inputs, labels} = tensorData;

// Train the model
await trainModel(model, inputs, labels);
console.log('Done Training');

Wenn Sie die Seite aktualisieren, sollten die folgenden Grafiken nach einigen Sekunden aktualisiert werden.

Sie werden durch die Callbacks erstellt, die wir zuvor erstellt haben. Sie zeigen den Verlust und den mittleren quadratischen Fehler (MSE) an, die am Ende jeder Epoche über das gesamte Dataset gemittelt werden.

Beim Trainieren eines Modells sollte der Verlust sinken. Da unser Messwert ein Maß für den Fehler ist, sollte er in diesem Fall ebenfalls sinken.

7. Vorhersagen treffen

Nachdem unser Modell trainiert wurde, möchten wir einige Vorhersagen treffen. Wir werten das Modell aus, indem wir uns ansehen, was es für einen einheitlichen Bereich von Zahlen mit niedriger bis hoher Leistung vorhersagt.

Fügen Sie Ihrer Datei „script.js“ die folgende Funktion hinzu.

function testModel(model, inputData, normalizationData) {
  const {inputMax, inputMin, labelMin, labelMax} = normalizationData;

  // Generate predictions for a uniform range of numbers between 0 and 1;
  // We un-normalize the data by doing the inverse of the min-max scaling
  // that we did earlier.
  const [xs, preds] = tf.tidy(() => {

    const xsNorm = tf.linspace(0, 1, 100);
    const predictions = model.predict(xsNorm.reshape([100, 1]));

    const unNormXs = xsNorm
      .mul(inputMax.sub(inputMin))
      .add(inputMin);

    const unNormPreds = predictions
      .mul(labelMax.sub(labelMin))
      .add(labelMin);

    // Un-normalize the data
    return [unNormXs.dataSync(), unNormPreds.dataSync()];
  });


  const predictedPoints = Array.from(xs).map((val, i) => {
    return {x: val, y: preds[i]}
  });

  const originalPoints = inputData.map(d => ({
    x: d.horsepower, y: d.mpg,
  }));


  tfvis.render.scatterplot(
    {name: 'Model Predictions vs Original Data'},
    {values: [originalPoints, predictedPoints], series: ['original', 'predicted']},
    {
      xLabel: 'Horsepower',
      yLabel: 'MPG',
      height: 300
    }
  );
}

Einige Dinge, die in der obigen Funktion zu beachten sind:

const xsNorm = tf.linspace(0, 1, 100);
const predictions = model.predict(xsNorm.reshape([100, 1]));

Wir generieren 100 neue „Beispiele“, die dem Modell zur Verfügung gestellt werden. Mit „Model.predict“ werden diese Beispiele in das Modell eingegeben. Beachten Sie, dass sie eine ähnliche Form ([num_examples, num_features_per_example]) wie beim Training haben müssen.

// Un-normalize the data
const unNormXs = xsNorm
  .mul(inputMax.sub(inputMin))
  .add(inputMin);

const unNormPreds = predictions
  .mul(labelMax.sub(labelMin))
  .add(labelMin);

Um die Daten wieder in den ursprünglichen Bereich (und nicht in den Bereich von 0 bis 1) zu bringen, verwenden wir die Werte, die wir bei der Normalisierung berechnet haben, kehren die Vorgänge aber einfach um.

return [unNormXs.dataSync(), unNormPreds.dataSync()];

.dataSync() ist eine Methode, mit der wir einen typedarray der in einem Tensor gespeicherten Werte abrufen können. So können wir diese Werte in regulärem JavaScript verarbeiten. Dies ist eine synchrone Version der Methode .data(), die im Allgemeinen bevorzugt wird.

Schließlich verwenden wir tfjs-vis, um die Originaldaten und die Vorhersagen des Modells darzustellen.

Fügen Sie den folgenden Code hinzu.

run-Funktion.

// Make some predictions using the model and compare them to the
// original data
testModel(model, data, tensorData);

Aktualisieren Sie die Seite. Wenn das Training des Modells abgeschlossen ist, sollte in etwa Folgendes angezeigt werden.

Das wars! Sie haben gerade ein einfaches Machine-Learning-Modell trainiert. Derzeit wird die sogenannte lineare Regression verwendet, bei der versucht wird, eine Linie an den Trend in den Eingabedaten anzupassen.

8. Wichtigste Erkenntnisse

Die Schritte beim Trainieren eines Modells für maschinelles Lernen sind:

Formulieren Sie Ihre Aufgabe:

Handelt es sich um ein Regressions- oder ein Klassifizierungsproblem?
Kann das mit beaufsichtigtem oder unbeaufsichtigtem Lernen erfolgen?
Welche Form haben die Eingabedaten? Wie sollten die Ausgabedaten aussehen?

Daten vorbereiten:

Bereinigen Sie Ihre Daten und untersuchen Sie sie nach Möglichkeit manuell auf Muster.
Daten vor dem Training mischen
Normalisieren Sie Ihre Daten in einen angemessenen Bereich für das neuronale Netzwerk. In der Regel sind 0–1 oder -1–1 gute Bereiche für numerische Daten.
Daten in Tensoren konvertieren

Modell erstellen und ausführen:

Definieren Sie Ihr Modell mit tf.sequential oder tf.model und fügen Sie dann mit tf.layers.* Ebenen hinzu.
Wählen Sie ein Optimierungstool aus ( adam ist in der Regel eine gute Wahl) und Parameter wie Batchgröße und Anzahl der Epochen.
Wählen Sie eine geeignete Verlustfunktion für Ihr Problem und einen Genauigkeitsmesswert aus, um den Fortschritt zu bewerten. meanSquaredError ist eine häufig verwendete Verlustfunktion für Regressionsprobleme.
Training beobachten, um zu sehen, ob der Verlust sinkt

Modell bewerten

Wählen Sie einen Bewertungs-Messwert für Ihr Modell aus, den Sie während des Trainings beobachten können. Nach dem Training können Sie einige Testvorhersagen treffen, um die Vorhersagequalität zu beurteilen.

9. Zusätzlicher Schritt: Weitere Möglichkeiten

Experimentieren Sie mit der Anzahl der Epochen. Wie viele Epochen sind erforderlich, bis sich die Kurve abflacht?
Experimentieren Sie mit einer höheren Anzahl von Einheiten in der verborgenen Ebene.
Experimentieren Sie mit dem Hinzufügen weiterer verborgener Ebenen zwischen der ersten verborgenen Ebene und der endgültigen Ausgabeschicht. Der Code für diese zusätzlichen Ebenen sollte in etwa so aussehen.

model.add(tf.layers.dense({units: 50, activation: 'sigmoid'}));

Das Wichtigste an diesen verborgenen Schichten ist, dass sie eine nicht lineare Aktivierungsfunktion einführen, in diesem Fall die sigmoid. Weitere Informationen zu Aktivierungsfunktionen

Prüfen Sie, ob das Modell eine Ausgabe wie im Bild unten erzeugen kann.