TensorFlow.js – Handschriftliche Ziffernerkennung mit CNNs

1. Einführung

In dieser Anleitung erstellen wir ein TensorFlow.js-Modell, mit dem handschriftliche Ziffern mithilfe eines Convolutional Neural Network erkannt werden können. Zuerst trainieren wir den Classifier, indem wir ihn Tausende von Bildern handschriftlicher Ziffern und deren Labels „betrachten“ lassen. Anschließend bewerten wir die Genauigkeit des Klassifikators anhand von Testdaten, die dem Modell noch nie präsentiert wurden.

Diese Aufgabe wird als Klassifizierungsaufgabe betrachtet, da wir das Modell trainieren, dem Eingabebild eine Kategorie (die Ziffer, die auf dem Bild zu sehen ist) zuzuweisen. 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. Bei einem Schwarz-Weiß-Bild einer bestimmten Größe wird klassifiziert, welche Ziffer im Bild zu sehen ist. Dazu sind folgende Schritte erforderlich:

Laden Sie die Daten.
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

TensorFlow.js-Syntax zum Erstellen von Convolutional-Modellen mit der TensorFlow.js Layers API.
Klassifizierungsaufgaben in TensorFlow.js formulieren
So überwachen Sie das Training im Browser mit der tfjs-vis-Bibliothek.

Voraussetzungen

Eine aktuelle Version von Chrome oder einem anderen modernen Browser, der ES6-Module unterstützt.
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.

Außerdem sollten Sie mit den Inhalten unseres ersten Trainings-Tutorials vertraut sein.

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>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>TensorFlow.js Tutorial</title>

  <!-- Import TensorFlow.js -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.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>

  <!-- Import the data file -->
  <script src="data.js" type="module"></script>

  <!-- Import the main script file -->
  <script src="script.js" type="module"></script>

</head>

<body>
</body>
</html>

JavaScript-Dateien für die Daten und den Code erstellen

Erstellen Sie im selben Ordner wie die HTML-Datei oben eine Datei mit dem Namen data.js und kopieren Sie den Inhalt von diesem Link in diese Datei.
Erstellen Sie im selben Ordner wie in Schritt 1 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 worden sein. tf ist ein Verweis auf die TensorFlow.js-Bibliothek, tfvis ist ein Verweis auf die tfjs-vis-Bibliothek.

Sie sollten die Meldung Hello TensorFlow sehen. Wenn das der Fall ist, können Sie mit dem nächsten Schritt fortfahren.

3. Daten laden

In dieser Anleitung trainieren Sie ein Modell, das Ziffern in Bildern wie den unten gezeigten erkennen soll. Diese Bilder sind 28 × 28 Pixel große Graustufenbilder aus einem Dataset namens MNIST.

mnist 4 mnist 3 mnist 8

Wir haben Code bereitgestellt, mit dem diese Bilder aus einer speziellen Sprite-Datei (~10 MB) geladen werden, die wir für Sie erstellt haben, damit wir uns auf den Trainingsabschnitt konzentrieren können.

Sie können sich die Datei data.js ansehen, um zu verstehen, wie die Daten geladen werden. Oder Sie entwickeln nach Abschluss dieser Anleitung einen eigenen Ansatz zum Laden der Daten.

Der bereitgestellte Code enthält eine Klasse MnistData mit zwei öffentlichen Methoden:

nextTrainBatch(batchSize): Gibt einen zufälligen Batch von Bildern und deren Labels aus dem Trainings-Dataset zurück.
nextTestBatch(batchSize): Gibt einen Batch von Bildern und deren Labels aus dem Testset zurück.

Die Klasse „MnistData“ führt auch die wichtigen Schritte des Mischens und Normalisierens der Daten aus.

Insgesamt gibt es 65.000 Bilder. Wir verwenden bis zu 55.000 Bilder, um das Modell zu trainieren, und behalten 10.000 Bilder, mit denen wir die Leistung des Modells testen können, wenn wir fertig sind. Und das alles machen wir im Browser.

Laden wir die Daten und prüfen wir, ob sie korrekt geladen wurden.

Fügen Sie Ihrer Datei „script.js“ den folgenden Code hinzu.

import {MnistData} from './data.js';

async function showExamples(data) {
  // Create a container in the visor
  const surface =
    tfvis.visor().surface({ name: 'Input Data Examples', tab: 'Input Data'});  

  // Get the examples
  const examples = data.nextTestBatch(20);
  const numExamples = examples.xs.shape[0];
  
  // Create a canvas element to render each example
  for (let i = 0; i < numExamples; i++) {
    const imageTensor = tf.tidy(() => {
      // Reshape the image to 28x28 px
      return examples.xs
        .slice([i, 0], [1, examples.xs.shape[1]])
        .reshape([28, 28, 1]);
    });
    
    const canvas = document.createElement('canvas');
    canvas.width = 28;
    canvas.height = 28;
    canvas.style = 'margin: 4px;';
    await tf.browser.toPixels(imageTensor, canvas);
    surface.drawArea.appendChild(canvas);

    imageTensor.dispose();
  }
}

async function run() {  
  const data = new MnistData();
  await data.load();
  await showExamples(data);
}

document.addEventListener('DOMContentLoaded', run);

Aktualisieren Sie die Seite. Nach einigen Sekunden sollte links ein Bereich mit einer Reihe von Bildern angezeigt werden.

4. Aufgabe konzipieren

Unsere Eingabedaten sehen so aus.

Unser Ziel ist es, ein Modell zu trainieren, das ein Bild als Eingabe verwendet und für jede der 10 möglichen Klassen, zu denen das Bild gehören kann (die Ziffern 0 bis 9), eine Vorhersage in Form einer Punktzahl ausgibt.

Jedes Bild ist 28 Pixel breit und 28 Pixel hoch und hat einen Farbkanal, da es sich um ein Graustufenbild handelt. Die Form jedes Bildes ist also [28, 28, 1].

Denken Sie daran, dass wir eine Zuordnung von 1 bis 10 sowie die Form jedes Eingabebeispiels vornehmen, da dies für den nächsten Abschnitt wichtig ist.

5. Modellarchitektur definieren

In diesem Abschnitt schreiben wir Code, um die Modellarchitektur zu beschreiben. Die Modellarchitektur ist eine elegante Art zu sagen: „Welche Funktionen werden vom Modell ausgeführt?“ oder alternativ „Welchen Algorithmus verwendet unser Modell, um seine Antworten zu berechnen?“.

Beim maschinellen Lernen definieren wir eine Architektur (oder einen Algorithmus) und lassen die Parameter dieses Algorithmus durch den Trainingsprozess lernen.

Fügen Sie die folgende Funktion hinzu.

script.js-Datei zum Definieren der Modellarchitektur

function getModel() {
  const model = tf.sequential();
  
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const IMAGE_CHANNELS = 1;  
  
  // In the first layer of our convolutional neural network we have 
  // to specify the input shape. Then we specify some parameters for 
  // the convolution operation that takes place in this layer.
  model.add(tf.layers.conv2d({
    inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
    kernelSize: 5,
    filters: 8,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));

  // The MaxPooling layer acts as a sort of downsampling using max values
  // in a region instead of averaging.  
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Repeat another conv2d + maxPooling stack. 
  // Note that we have more filters in the convolution.
  model.add(tf.layers.conv2d({
    kernelSize: 5,
    filters: 16,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Now we flatten the output from the 2D filters into a 1D vector to prepare
  // it for input into our last layer. This is common practice when feeding
  // higher dimensional data to a final classification output layer.
  model.add(tf.layers.flatten());

  // Our last layer is a dense layer which has 10 output units, one for each
  // output class (i.e. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).
  const NUM_OUTPUT_CLASSES = 10;
  model.add(tf.layers.dense({
    units: NUM_OUTPUT_CLASSES,
    kernelInitializer: 'varianceScaling',
    activation: 'softmax'
  }));

  
  // Choose an optimizer, loss function and accuracy metric,
  // then compile and return the model
  const optimizer = tf.train.adam();
  model.compile({
    optimizer: optimizer,
    loss: 'categoricalCrossentropy',
    metrics: ['accuracy'],
  });

  return model;
}

Sehen wir uns das etwas genauer an.

Faltungen

model.add(tf.layers.conv2d({
  inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
  kernelSize: 5,
  filters: 8,
  strides: 1,
  activation: 'relu',
  kernelInitializer: 'varianceScaling'
}));

Hier verwenden wir ein sequenzielles Modell.

Wir verwenden einen conv2d-Layer anstelle eines Dense-Layers. Wir können nicht auf alle Details der Funktionsweise von Faltungen eingehen, aber hier sind einige Ressourcen, in denen die zugrunde liegende Operation erklärt wird:

Sehen wir uns die einzelnen Argumente im Konfigurationsobjekt für conv2d an:

inputShape: Die Form der Daten, die in die erste Ebene des Modells einfließen. In diesem Fall sind unsere MNIST-Beispiele 28 × 28 Pixel große Schwarz-Weiß-Bilder. Das kanonische Format für Bilddaten ist [row, column, depth]. Wir möchten also eine Form von [28, 28, 1] konfigurieren. 28 Zeilen und Spalten für die Anzahl der Pixel in jeder Dimension und eine Tiefe von 1, da unsere Bilder nur einen Farbkanal haben. Beachten Sie, dass wir keine Batchgröße in der Eingabeform angeben. Die Batchgröße von Layern ist nicht festgelegt, sodass Sie während der Inferenz einen Tensor mit beliebiger Batchgröße übergeben können.
kernelSize Die Größe der gleitenden Faltungsfilterfenster, die auf die Eingabedaten angewendet werden sollen. Hier legen wir einen kernelSize von 5 fest, der ein quadratisches 5×5-Faltungsfenster angibt.
filters: Die Anzahl der Filterfenster der Größe kernelSize, die auf die Eingabedaten angewendet werden sollen. Hier wenden wir acht Filter auf die Daten an.
strides: Die Schrittweite des gleitenden Fensters, d. h. um wie viele Pixel der Filter verschoben wird, wenn er sich über das Bild bewegt. Hier geben wir Strides von 1 an. Das bedeutet, dass der Filter in Schritten von 1 Pixel über das Bild gleitet.
activation: Die Aktivierungsfunktion, die nach Abschluss der Faltung auf die Daten angewendet werden soll. In diesem Fall wenden wir eine Rectified Linear Unit (ReLU)-Funktion an, die eine sehr häufig verwendete Aktivierungsfunktion in ML-Modellen ist.
kernelInitializer: Die Methode, die zum zufälligen Initialisieren der Modellgewichte verwendet werden soll. Dies ist sehr wichtig für die Trainingsdynamik. Wir gehen hier nicht auf die Initialisierung ein, aber VarianceScaling (hier verwendet) ist im Allgemeinen eine gute Initialisierungsmethode.

Datendarstellung vereinfachen

model.add(tf.layers.flatten());

Bilder sind hochdimensionale Daten und Faltungsvorgänge erhöhen in der Regel die Größe der Daten, die in sie eingeflossen sind. Bevor wir sie an unsere endgültige Klassifizierungsebene übergeben, müssen wir die Daten in ein langes Array umwandeln. Dichte Ebenen (die wir als letzte Ebene verwenden) akzeptieren nur tensor1ds. Dieser Schritt ist daher bei vielen Klassifizierungsaufgaben üblich.

Endgültige Wahrscheinlichkeitsverteilung berechnen

const NUM_OUTPUT_CLASSES = 10;
model.add(tf.layers.dense({
  units: NUM_OUTPUT_CLASSES,
  kernelInitializer: 'varianceScaling',
  activation: 'softmax'
}));

Wir verwenden eine Dense-Ebene mit einer Softmax-Aktivierung, um Wahrscheinlichkeitsverteilungen für die 10 möglichen Klassen zu berechnen. Die Klasse mit dem höchsten Wert ist die vorhergesagte Ziffer.

Optimizer und Verlustfunktion auswählen

const optimizer = tf.train.adam();
model.compile({
  optimizer: optimizer,
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy'],
});

Wir kompilieren das Modell und geben einen Optimizer, eine Verlustfunktion und Messwerte an, die wir im Blick behalten möchten.

Im Gegensatz zu unserem ersten Tutorial verwenden wir hier categoricalCrossentropy als Verlustfunktion. Wie der Name schon sagt, wird diese Funktion verwendet, wenn die Ausgabe unseres Modells eine Wahrscheinlichkeitsverteilung ist. categoricalCrossentropy misst den Fehler zwischen der Wahrscheinlichkeitsverteilung, die von der letzten Ebene unseres Modells generiert wird, und der Wahrscheinlichkeitsverteilung, die durch unser tatsächliches Label angegeben wird.

Wenn unsere Ziffer beispielsweise tatsächlich eine 7 ist, könnten wir die folgenden Ergebnisse erhalten:

Index	0	1	2	3	4	5	6	7	8	9
True Label	0	0	0	0	0	0	0	1	0	0
Vorhersage	0,1	0,01	0,01	0,01	0,20	0,01	0,01	0,60	0,03	0,02

Die kategorische Kreuzentropie ergibt eine einzelne Zahl, die angibt, wie ähnlich der Vorhersagevektor unserem Vektor mit dem tatsächlichen Label ist.

Die hier verwendete Darstellung der Labels wird als One-Hot-Codierung bezeichnet und ist bei Klassifizierungsproblemen üblich. Jeder Klasse ist für jedes Beispiel eine Wahrscheinlichkeit zugeordnet. Wenn wir genau wissen, was es sein sollte, können wir die Wahrscheinlichkeit auf 1 und die anderen auf 0 setzen. Weitere Informationen zur One-Hot-Codierung finden Sie auf dieser Seite.

Der andere Messwert, den wir beobachten, ist accuracy. Bei einem Klassifizierungsproblem ist das der Prozentsatz der korrekten Vorhersagen im Verhältnis zu allen Vorhersagen.

6. Modell trainieren

Kopieren Sie die folgende Funktion in die Datei „script.js“.

async function train(model, data) {
  const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];
  const container = {
    name: 'Model Training', tab: 'Model', styles: { height: '1000px' }
  };
  const fitCallbacks = tfvis.show.fitCallbacks(container, metrics);
  
  const BATCH_SIZE = 512;
  const TRAIN_DATA_SIZE = 5500;
  const TEST_DATA_SIZE = 1000;

  const [trainXs, trainYs] = tf.tidy(() => {
    const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
    return [
      d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  const [testXs, testYs] = tf.tidy(() => {
    const d = data.nextTestBatch(TEST_DATA_SIZE);
    return [
      d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  return model.fit(trainXs, trainYs, {
    batchSize: BATCH_SIZE,
    validationData: [testXs, testYs],
    epochs: 10,
    shuffle: true,
    callbacks: fitCallbacks
  });
}

Fügen Sie dann den folgenden Code in Ihre

run-Funktion.

const model = getModel();
tfvis.show.modelSummary({name: 'Model Architecture', tab: 'Model'}, model);
  
await train(model, data);

Aktualisieren Sie die Seite. Nach einigen Sekunden sollten Diagramme mit dem Trainingsfortschritt angezeigt werden.

Sehen wir uns das etwas genauer an.

Messwerte überwachen

const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];

Hier legen wir fest, welche Messwerte wir beobachten möchten. Wir beobachten Verlust und Genauigkeit im Trainingsset sowie Verlust und Genauigkeit im Validierungsset (val_loss bzw. val_acc). Weitere Informationen zum Validierungsset finden Sie unten.

Daten als Tensoren vorbereiten

const BATCH_SIZE = 512;
const TRAIN_DATA_SIZE = 5500;
const TEST_DATA_SIZE = 1000;

const [trainXs, trainYs] = tf.tidy(() => {
  const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
  return [
    d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

const [testXs, testYs] = tf.tidy(() => {
  const d = data.nextTestBatch(TEST_DATA_SIZE);
  return [
    d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

Hier erstellen wir zwei Datasets: ein Trainings-Dataset, mit dem wir das Modell trainieren, und ein Validierungs-Dataset, mit dem wir das Modell am Ende jeder Epoche testen. Die Daten im Validierungs-Dataset werden dem Modell jedoch während des Trainings nie angezeigt.

Mit der von uns bereitgestellten Datenklasse ist es ganz einfach, Tensoren aus den Bilddaten abzurufen. Wir passen die Tensoren jedoch weiterhin an die vom Modell erwartete Form an, [num_examples, image_width, image_height, channels], bevor wir sie dem Modell zuführen können. Für jedes Dataset haben wir sowohl Eingaben (die Xs) als auch Labels (die Ys).

return model.fit(trainXs, trainYs, {
  batchSize: BATCH_SIZE,
  validationData: [testXs, testYs],
  epochs: 10,
  shuffle: true,
  callbacks: fitCallbacks
});

Wir rufen „model.fit“ auf, um den Trainingszyklus zu starten. Wir übergeben auch die Eigenschaft „validationData“, um anzugeben, welche Daten das Modell nach jeder Epoche zum Testen verwenden soll (aber nicht zum Trainieren).

Wenn wir mit unseren Trainingsdaten gut, aber mit unseren Validierungsdaten nicht gut abschneiden, bedeutet das, dass das Modell wahrscheinlich überangepasst an die Trainingsdaten ist und sich nicht gut auf Eingaben verallgemeinern lässt, die es noch nicht gesehen hat.

7. Modell bewerten

Die Validierungsgenauigkeit gibt eine gute Schätzung dafür ab, wie gut unser Modell bei Daten abschneidet, die es noch nicht gesehen hat (sofern diese Daten in gewisser Weise dem Validierungsset ähneln). Möglicherweise möchten wir jedoch eine detailliertere Aufschlüsselung der Leistung für die verschiedenen Klassen.

Dafür gibt es einige Methoden in tfjs-vis.

Fügen Sie den folgenden Code am Ende der Datei „script.js“ ein

const classNames = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine'];

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}


async function showAccuracy(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = {name: 'Accuracy', tab: 'Evaluation'};
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

async function showConfusion(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = {name: 'Confusion Matrix', tab: 'Evaluation'};
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

Was bewirkt dieser Code?

Trifft eine Vorhersage.
Berechnet Genauigkeitsmesswerte.
Messwerte anzeigen

Sehen wir uns die einzelnen Schritte an.

Vorhersagen treffen

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}

Zuerst müssen wir einige Vorhersagen treffen. Hier werden 500 Bilder verwendet, um vorherzusagen, welche Ziffern darauf zu sehen sind. Sie können diese Zahl später erhöhen, um eine größere Anzahl von Bildern zu testen.

Insbesondere die Funktion argmax liefert den Index der Klasse mit der höchsten Wahrscheinlichkeit. Das Modell gibt für jede Klasse eine Wahrscheinlichkeit aus. Wir ermitteln die höchste Wahrscheinlichkeit und verwenden sie als Vorhersage.

Außerdem können wir Vorhersagen für alle 500 Beispiele gleichzeitig treffen. Das ist die Leistungsfähigkeit der Vektorisierung, die TensorFlow.js bietet.

Genauigkeit pro Klasse anzeigen

async function showAccuracy() {
  const [preds, labels] = doPrediction();
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = { name: 'Accuracy', tab: 'Evaluation' };
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

Anhand einer Reihe von Vorhersagen und Labels lässt sich die Genauigkeit für jede Klasse berechnen.

Wahrheitsmatrix anzeigen

async function showConfusion() {
  const [preds, labels] = doPrediction();
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = { name: 'Confusion Matrix', tab: 'Evaluation' };
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

Eine Wahrheitsmatrix ähnelt der Genauigkeit pro Klasse, wird aber weiter aufgeschlüsselt, um Muster von Falschklassifizierungen zu zeigen. So können Sie sehen, ob das Modell bei bestimmten Klassenpaaren Probleme hat.

Bewertung anzeigen

Fügen Sie den folgenden Code am Ende Ihrer Ausführungsfunktion hinzu, um die Auswertung anzuzeigen.

await showAccuracy(model, data);
await showConfusion(model, data);

Die Anzeige sollte so aussehen:

Das wars! Sie haben gerade ein Convolutional Neural Network trainiert.

8. Wichtigste Erkenntnisse

Das Vorhersagen von Kategorien für Eingabedaten wird als Klassifizierungsaufgabe bezeichnet.

Für Klassifizierungsaufgaben ist eine geeignete Datenrepräsentation für die Labels erforderlich.

Häufig werden Labels als One-Hot-Codierung von Kategorien dargestellt.

Daten vorbereiten:

Es ist sinnvoll, einige Daten zurückzuhalten, die das Modell während des Trainings nie sieht, damit Sie das Modell damit bewerten können. Das wird als Validierungsset bezeichnet.

Modell erstellen und ausführen:

Es hat sich gezeigt, dass Convolutional-Modelle bei Bildaufgaben gut funktionieren.
Bei Klassifizierungsproblemen wird in der Regel die kategorische Kreuzentropie für die Verlustfunktionen verwendet.
Beobachten Sie das Training, um zu sehen, ob der Verlust sinkt und die Genauigkeit steigt.

Modell bewerten

Legen Sie fest, wie Sie Ihr Modell nach dem Training bewerten möchten, um zu sehen, wie gut es das ursprüngliche Problem löst.
Mit der klassenspezifischen Genauigkeit und Wahrheitsmatrizen erhalten Sie eine detailliertere Aufschlüsselung der Modellleistung als nur mit der Gesamtgenauigkeit.