Test Run

Arbeiten mit dem MNIST-Bilderkennungs-Datensatz

James McCaffrey

Laden Sie die Codebeispiele herunter

Ist eines der faszinierendsten Themen im Bereich des maschinellen Lernens Bilderkennung (IR). Beispiele für Systeme, die IR beschäftigen Login-Computerprogramme, die Fingerabdruck oder Netzhaut Identifizierung verwenden und Flughafen-Sicherheitssysteme, die Passagier-Gesichter suchen Einzelpersonen auf irgendeine Art von wanted-Liste zu scannen. Der MNIST-Datensatz ist eine Sammlung von einfachen Bildern, die zum Exper verwendet werden können­Iment mit IR-Algorithmen. Dieser Artikel präsentiert und erklärt ein relativ einfaches C#-Programm, das Sie an das DataSet MNIST führt, die wiederum macht Sie mit IR-Konzepte bekannt.

Es ist unwahrscheinlich, Sie müssen IR in den meisten Softwareanwendungen zu verwenden, aber ich denke, dass Sie die Informationen in diesem Artikel aus vier verschiedenen Gründen nützlich sein könnte. Einerseits gibt es keinen besseren Weg, der MNIST-Datensatz und ein IR-Konzepte als durch das Experimentieren mit den tatsächlichen Code zu verstehen. Zweitens hilft haben eine grundlegende Verständnis der IR die Möglichkeiten und Grenzen von real, anspruchsvolle IR-Systemen zu verstehen Ihnen. Drittens können mehrere von den in diesem Artikel erläutert Programmiertechniken für andere, häufiger Aufgaben verwendet werden. Und Viertens: Sie konnten gerade finden IR in seinem eigenen Recht interessant.

Der beste Weg um zu sehen, wohin dieses Artikels ist es, einen Blick auf das Demoprogramm in Abbildung 1. Das Demoprogramm ist eine klassische Windows Forms-Anwendung. Das Button-Steuerelement mit der Bezeichnung Grafiken laden liest in den Speicher einen Standardbild Anerkennung-Datensatz der MNIST-Datensatz aufgerufen. Der Datensatz besteht aus 60.000 handschriftliche Ziffern von 0 bis 9, die digitalisiert haben. Die Demo hat die Möglichkeit, das aktuell ausgewählte Bild als Bitmap-Bild anzuzeigen (auf der linken Seite des Abbildung 1), und als Matrix der Pixelwerte in hexadezimaler Form (auf der rechten Seite).

Abbildung 1 Anzeige von MNIST Bildern

In den folgenden Abschnitten werde ich Sie durch den Code für den Demo-Programm nötig. Da die Demo einer Windows Forms-Anwendung ist ein Großteil der Code bezieht sich auf Funktionen der Benutzeroberfläche und in mehreren Dateien enthalten ist. Ich konzentriere mich hier auf die Logik. Ich Umgestaltung den Demo-Code in einer einzigen C#-Quelldatei, die unter msdn.microsoft.com/magazine/msdnmag0614. Um den Download zu kompilieren, speichern Sie es auf Ihrem lokalen Computer als MnistViewer.cs, dann ein neues Visual Studio -Projekt erstellen und die Datei dem Projekt hinzufügen. Alternativ kann eine Visual Studio -Befehlsshell (die den Speicherort der c#-Compiler kennt) zu starten, dann navigieren Sie zum Verzeichnis, in dem Sie den Download gespeichert, und geben Sie den Befehl > csc.exe winexe MnistViewer.cs um die ausführbare Datei MnistViewer.exe zu erstellen. Bevor Sie das Demoprogramm ausführen können, müssen Sie zum herunterladen und speichern Datendateien von zwei MNIST, wie ich im nächsten Abschnitt zu erklären, und bearbeiten Sie den Demo-Quellcode auf den Speicherort der diese beiden Dateien hinzu.

Dieser Artikel setzt voraus, Sie haben mindestens Mittelstufe Fähigkeiten mit c# (oder ähnliche Sprache) aber nicht annehmen, dass Sie wissen nichts über IR. Der Demo-Code macht intensiven Gebrauch von der Microsoft .NET Framework also Umgestaltung des Demo-Codes auf eine nicht-.NET-Sprache wie JavaScript eine schwierige Aufgabe sein würde.

Die Terminologie in IR Literatur tendenziell etwas variieren. Bilderkennung kann auch Bild-Klassifizierung, Mustererkennung, Mustererkennung oder Muster-Klassifizierung aufgerufen werden. Obwohl diese Begriffe unterschiedliche Bedeutungen haben, werden sie manchmal austauschbar, verwendet die können machen die Suche im Internets nach relevanten Informationen ein bisschen schwierig.

Der MNIST-Datensatz

Die gemischte National Institute of Standards and Technology (kurz MNIST) Datensatz wurde erstellt von IR-Forscher als Benchmark für den Vergleich verschiedener IR-Algorithms zu handeln. Die Grundidee ist, dass wenn Sie ein IR-Algorithmus oder Software-System, den Sie testen möchten haben, Sie können der Algorithmus oder dem System gegen den MNIST-Datensatz ausführen und vergleichen Sie Ihre Ergebnisse mit zuvor veröffentlichten Ergebnisse für andere Systeme.

Das Daten-Set besteht aus insgesamt 70.000 Aufnahmen; 60.000 Training-Bilder (zum Erstellen einer IR-Modells verwendet) und 10.000 Testbilder (verwendet, um die Genauigkeit des Modells zu bewerten). Jedes MNIST-Bild ist ein digitalisiertes Bild einen einstelligen handschriftlichen Charakter. Jedes Bild ist 28 x 28 Pixel groß. Jeder Pixelwert liegt zwischen 0, d. h. weiß repräsentiert, und 255, die schwarz darstellt. Fortgeschrittene Pixelwerte bedeuten einen Graustufen. Abbildung 2 zeigt die ersten acht Bilder in der Ausbildung gesetzt. Die tatsächliche Zahl, die jedes Bild entspricht ist offensichtlich für den Menschen, aber die Ziffern identifizieren, ist eine sehr schwierige Herausforderung für Computer.

Abbildung 2 ersten acht MNIST-Training-Bilder

Merkwürdigerweise werden die Trainingsdaten und die Testdaten jeweils in zwei Dateien und nicht in einer einzigen Datei gespeichert. Eine Datei enthält die Pixelwerte für die Bilder und die andere die Etiketteninformationen (0 bis 9) für die Bilder. Jedes der vier Dateien auch enthält Header-Informationen und alle vier Dateien werden gespeichert in einem binären Format, das mit dem Gzip-Format komprimiert worden sind.

Beachten Sie im Abbildung 1, das Demoprogramm verwendet nur die 60.000-Element Ausbildung gesetzt. Das Format der Testsatz ist identisch mit der Trainingsmenge. Das primäre Repository für die MNIST-Dateien befindet sich derzeit am yann.lecun.com/exdb/mnist. Die Trainingsdaten Pixel ist in Datei Zug-Bilder-idx3-ubyte.gz und die Bezeichnung Trainingsdaten in Datei Zug-Etiketten-idx1-ubyte.gz gespeichert ist. Das Demoprogramm ausführen, müssen Sie auf die MNIST-Repository-Site herunterladen und entpacken die beiden Training-Daten-Dateien. Um die Dateien zu entpacken, habe ich das kostenlose open-Source-7-Zip-Dienstprogramm.

Erstellen des MNIST-Viewers

Um die MNIST-Demo-Programm zu erstellen, ich Visual Studio gestartet und erstellt ein neues C#-Windows Forms-Projekt mit dem Namen MnistViewer. Die Demo hat keine bedeutenden .NET Versionsabhängigkeiten, also beliebige Version von Visual Studio arbeiten sollte.

Nachdem der Template-Code in den Visual Studio -Editor geladen, ich die UI-Steuerelemente eingerichtet. Ich habe zwei TextBox-Steuerelemente (textBox1, textBox2) die Pfade zu den beiden Trainingsdateien entpackt zu halten. Ich hinzugefügt ein Button-Steuerelement (button1) und gab es ein Label der Grafiken laden. Ich habe zwei weitere TextBox-Steuerelemente ("TextBox3", textBox4), um die Werte für den Index des aktuellen Bildes und den Index des nächsten Bildes zu halten. Mit dem Visual Studio -Designer setzen ich die Anfangswerte der diese Steuerelemente "NA" und "0".

Ich habe ein ComboBox-Steuerelement (comboBox1) für den Bild-Vergrößerung-Wert. Mithilfe des Designers, ich ging Items-Auflistung des Steuerelements und fügte die Zeichenfolgen "1" bis "10." Ich ein zweites Button-Steuerelement (button2) hinzugefügt und gab es ein Label der Anzeige weiter. Ich haben ein PictureBox-Steuerelement (pictureBox1) hinzugefügt und die BackColor-Eigenschaft auf ControlDark festgelegt, so dass das Steuerelement Gliederung gesehen werden konnte. 280 x 280 ermöglicht eine Vergrößerung von bis zu 10 mal die Größe der PictureBox gesetzt (erinnern, ein MNIST Bild ist 28 x 28 Pixel). Ich habe ein Fünftel TextBox (textBox5) zum Anzeigen der hex Werte eines Bildes, dann legen Sie die Multiline-Eigenschaft auf True und die Font-Eigenschaft auf Courier New, 8,25 Pkt., und erweitert seine Größe auf 606 x 412. Und schließlich ein ListBox-Steuerelement (listBox1) für die Meldungen für die Protokollierung hinzugefügt werden.

Nach der Platzierung der Steuerelemente der Benutzeroberfläche auf das Windows Form, hinzugefügt habe ich drei Gültigkeitsbereich der Klasse Felder:

public partial class Form1 : Form
{
  private string pixelFile =
    @"C:\MnistViewer\train-images.idx3-ubyte";
  private string labelFile =
    @"C:\MnistViewer\train-labels.idx1-ubyte";
  private DigitImage[] trainImages = null;
...

Die ersten beiden Zeichenfolgen verweisen auf die Speicherorte der Dateien entpackt Training. Sie müssen diese zwei Zeichenfolgen, um die Demo laufen zu bearbeiten. Das dritte Feld ist ein Array von Objekten für Programm definierten DigitImage.

Ich bearbeitete Formularkonstruktor leicht um die Dateipfade in textBox1 und textBox2, und geben der Vergrößerung einen Anfangswert von 6:

public Form1()
{
  InitializeComponent();
  textBox1.Text = pixelFile;
  textBox2.Text = labelFile;
  comboBox1.SelectedItem = "6";
  this.ActiveControl = button1;
}

Ich habe die ActiveControl-Eigenschaft den anfänglichen Fokus auf das button1-Steuerelement nur für Bequemlichkeit fest.

Erstellen einer Klasse zum halten Sie ein MNIST-Bild

Ich habe eine kleine Containerklasse um ein einzelnes MNIST-Bild darzustellen, wie in Abbildung 3. Ich nannte die DigitImage-Klasse, aber vielleicht möchten in etwas genauer, wie MnistImage umbenennen.

Abbildung 3-DigitImage-Klassendefinition

public class DigitImage
{
  public int width; // 28
  public int height; // 28
  public byte[][] pixels; // 0(white) - 255(black)
  public byte label; // '0' - '9'
  public DigitImage(int width, int height, 
    byte[][] pixels, byte label)
  {
    this.width = width; this.height = height;
    this.pixels = new byte[height][];
    for (int i = 0; i < this.pixels.Length; ++i)
      this.pixels[i] = new byte[width];
    for (int i = 0; i < height; ++i)
      for (int j = 0; j < width; ++j)
        this.pixels[i][j] = pixels[i][j];
    this.label = label;
  }
}

Ich erklärte alle Member der Klasse mit öffentlichen Bereich für Einfachheit und entfernt normal Fehlerprüfung um die Größe des Codes klein zu halten. Felder Breite und Höhe könnte weggelassen haben weil alle MNIST Bilder 28 x 28 Pixel, aber hinzufügen die Felder Breite und Höhe der Klasse mehr Flexibilität bietet. Feld Pixel ist ein Array von Arrays Stil-Matrix. Im Gegensatz zu vielen anderen Sprachen c# hat ein wahre mehrdimensionales Array, und vielleicht möchten es stattdessen verwenden. Jedem Zellwert ist Typ Byte, das ist nur ein ganzzahliger Wert zwischen 0 und 255. Feldbezeichnung wird ebenfalls als Typ Byte deklariert, aber Typ Int oder Char oder Zeichenfolge hätte.

Der DigitImage-Klassenkonstruktor nimmt Werte für Breite, Höhe, die Pixel-Matrix und das Etikett und nur kopiert diese Parameterwerte in die zugehörigen Felder. Ich konnte habe kopiert die Pixelwerte durch Verweis anstelle von Wert, aber, die zu unerwünschten Nebenwirkungen führen, wenn die Quelle-Pixel-Werte geändert.

Die MNIST-Daten laden

Ich doppelgeklickt auf das button1-Steuerelement, um den Ereignishandler zu registrieren. Der Ereignishandler auf dem Bauernhof die meiste Arbeit an die Methode LoadData:

private void button1_Click(object sender, EventArgs e)
{
  this.pixelFile = textBox1.Text;
  this.labelFile = textBox2.Text;
  this.trainImages = LoadData(pixelFile, labelFile);
  listBox1.Items.Add("MNIST images loaded into memory");
}

Die Methode LoadData notiert Abbildung 4. LoadData die Pixel und die Label-Dateien geöffnet und liest sie gleichzeitig. Die Methode beginnt mit der Erstellung einer lokalen 28 x 28-Matrix der Pixelwerte. Die handliche .NET BinaryReader-Klasse dient speziell für Binär-Dateien zu lesen.

Abbildung 4 die LoadData-Methode

public static DigitImage[] LoadData(string pixelFile, string labelFile)
{
  int numImages = 60000;
  DigitImage[] result = new DigitImage[numImages];
  byte[][] pixels = new byte[28][];
  for (int i = 0; i < pixels.Length; ++i)
    pixels[i] = new byte[28];
  FileStream ifsPixels = new FileStream(pixelFile, FileMode.Open);
  FileStream ifsLabels = new FileStream(labelFile, FileMode.Open);
  BinaryReader brImages = new BinaryReader(ifsPixels);
  BinaryReader brLabels = new BinaryReader(ifsLabels);
  int magic1 = brImages.ReadInt32(); // stored as big endian
  magic1 = ReverseBytes(magic1); // convert to Intel format
  int imageCount = brImages.ReadInt32();
  imageCount = ReverseBytes(imageCount);
  int numRows = brImages.ReadInt32();
  numRows = ReverseBytes(numRows);
  int numCols = brImages.ReadInt32();
  numCols = ReverseBytes(numCols);
  int magic2 = brLabels.ReadInt32();
  magic2 = ReverseBytes(magic2);
  int numLabels = brLabels.ReadInt32();
  numLabels = ReverseBytes(numLabels);
  for (int di = 0; di < numImages; ++di)
  {
    for (int i = 0; i < 28; ++i) // get 28x28 pixel values
    {
      for (int j = 0; j < 28; ++j) {
        byte b = brImages.ReadByte();
        pixels[i][j] = b;
      }
    }
    byte lbl = brLabels.ReadByte(); // get the label
    DigitImage dImage = new DigitImage(28, 28, pixels, lbl);
    result[di] = dImage;
  } // Each image
  ifsPixels.Close(); brImages.Close();
  ifsLabels.Close(); brLabels.Close();
  return result;
}

Das Format der MNIST-Ausbildung-Pixel-Datei hat erste magische Integer (32 Bit), die Wert 2051, gefolgt von der Anzahl der Bilder, wie eine ganze Zahl, gefolgt von der Anzahl der Zeilen und die Anzahl der Spalten als Ganzzahlen, von den 60.000 Bilder X 28 X 28 Pixel gefolgt = 47,040,000 Byte-Werte. Also, nach dem Öffnen der Binärdateien, die ersten vier Zahlen gelesen werden mithilfe der ReadInt32-Methode. Beispielsweise wird die Anzahl der Bilder gelesen von:

int imageCount = brImages.ReadInt32();
imageCount = ReverseBytes(imageCount);

Interessant ist, speichern Sie die Dateien MNIST Integer-Werte im big-endian-Format (verwendet von einigen nicht-Intel-Prozessoren) anstatt der üblicheren little-endian-Format, das am häufigsten auf Hardware verwendet wird, die Microsoft-Software ausgeführt wird. Also, wenn Sie normalen PC-Stil-Hardware verwenden, um anzeigen oder verwenden Sie eine der die ganzzahligen Werte, sie von bigEndian in little Endian konvertiert werden müssen. Das bedeutet, die Reihenfolge der vier Bytes, die die ganze Zahl bilden. Beispielsweise ist die magische Zahl 2051 im big endian Form:

00000011 00001000 00000000 00000000

Dieser Wert in little endian Form gespeichert ist:

00000000 00000000 00001000 00000011

Beachten Sie, ist es die vier Bytes, die rückgängig müssen, anstatt die gesamte 32-Bit-Sequenz gemacht werden. Es gibt viele Möglichkeiten, um die Bytereihenfolge umzukehren. Ich habe einen hochrangigen Ansatz, der die .NET BitConverter-Klasse, anstatt einen Low-Level, Bitmanipulation Ansatz nutzt:

public static int ReverseBytes(int v)
{
  byte[] intAsBytes = BitConverter.GetBytes(v);
  Array.Reverse(intAsBytes);
  return BitConverter.ToInt32(intAsBytes, 0);
}

Methode LoadData liest, aber nicht zu verwenden, die Header-Informationen. Vielleicht möchten Sie die vier Werte überprüfen (2051, 60000, 28, 28) um zu überprüfen, die Datei ist nicht beschädigt. Nach dem Öffnen beide Dateien und lesen die Header-Ganzzahlen LoadData liest 28 x 28 = 784 aufeinander folgenden Pixelwerte aus der Pixel-Datei und speichert diese Werte, dann liest einen einzelnes Etikett-Wert aus der Labeldatei und verbindet es mit der Pixelwerte in ein DigitImage-Objekt, das sie dann in den Gültigkeitsbereich der Klasse TrainData Array speichert. Es ist keine explizite Bild-ID. Jedes Bild hat eine implizite Index-ID, die das Bild nullbasierte Position in der Sequenz von Bildern ist.

Anzeigen von Bildern

Ich doppelgeklickt button2 drücken, um die Ereignishandler zu registrieren. Der Code zum Anzeigen eines Bilds ist dargestellt Abbildung 5.

Abbildung 5 ein MNIST Bild anzeigen

private void button2_Click(object sender, EventArgs e)
{
  // Display 'next' image
  int nextIndex = int.Parse(textBox4.Text);
  DigitImage currImage = trainImages[nextIndex];
  int mag = int.Parse(comboBox1.SelectedItem.ToString());
  Bitmap bitMap = MakeBitmap(currImage, mag);
  pictureBox1.Image = bitMap;
  string pixelVals = PixelValues(currImage);
  textBox5.Text = pixelVals;
  textBox3.Text = textBox4.Text; // Update curr idx
  textBox4.Text = (nextIndex + 1).ToString(); // ++next index
  listBox1.Items.Add("Curr image index = " +
    textBox3.Text + " label = " + currImage.label);
}

Der Index des Bildes angezeigt wird aus der textBox4 geholt (nächste Bildindex) zu steuern, dann ein Verweis auf das Bild aus dem TrainImage-Array gezogen wird. Vielleicht möchten eine Überprüfung, um sicherzustellen, dass die Bilddaten in den Speicher geladen wurde, bevor Sie versuchen, Zugriff auf ein Bild hinzufügen. Das Bild wird in zwei Arten, zuerst in ein visueller Form in das PictureBox-Steuerelement, und zweitens als hexadezimale Werte im großen TextBox-Steuerelement angezeigt. Ein PictureBox-Steuerelement Image-Eigenschaft kann ein Bitmap-Objekt zu akzeptieren und wiedergegeben wird, während das Objekt. Sehr nett! Sie können ein Bitmap-Objekt als im Wesentlichen ein Bild vorstellen. Beachten Sie, dass eine .NET Bild-Klasse vorhanden ist, aber es eine abstrakte Klasse, die verwendet wird ist, um die Bitmap-Klasse definieren. Also ist der Schlüssel ein Bild, um ein Bitmap-Objekt aus dem Programm definierten DigitImage Objekt zu generieren. Dies geschieht durch Hilfsmethode MakeBitmap, aufgeführt in Abbildung 6.

Abbildung 6 die MakeBitmap-Methode

public static Bitmap MakeBitmap(DigitImage dImage, int mag)
{
  int width = dImage.width * mag;
  int height = dImage.height * mag;
  Bitmap result = new Bitmap(width, height);
  Graphics gr = Graphics.FromImage(result);
  for (int i = 0; i < dImage.height; ++i)
  {
    for (int j = 0; j < dImage.width; ++j)
    {
      int pixelColor = 255 - dImage.pixels[i][j]; // black digits
      Color c = Color.FromArgb(pixelColor, pixelColor, pixelColor);
      SolidBrush sb = new SolidBrush(c);
      gr.FillRectangle(sb, j * mag, i * mag, mag, mag);
    }
  }
  return result;
}

Die Methode ist nicht lang, aber es ist ein wenig subtil. Der Bitmap-Konstruktor akzeptiert eine Breite und eine Höhe als Ganzzahlen, die für MNIST Grunddaten immer 28 und 28 sein werden. Wenn der Vergrößerungsfaktor 3, dann das Bitmap-Bild wird (28 * 3) durch (28 * 3) = 84 von 84 Pixel in der Größe, und jedes 3 x 3-Quadrat in der Bitmap wird ein Pixel des ursprünglichen Bildes darstellen.

Liefert die Werte für ein Bitmap-Objekt erfolgt indirekt über ein Graphics-Objekt. Innerhalb der verschachtelten Schleife wird der aktuellen Pixelwert von 255 ergänzt, so dass das resultierende Bild eine schwarz/graue Ziffer vor einem weißen Hintergrund. Ohne Ergänzung wäre das Bild einer weiss/grau-Ziffer vor einem schwarzen Hintergrund. Um eine Graustufen-Farbe zu machen, werden die gleichen Werte für die rot-, grün- und blau-Parameter an der FromArgb-Methode übergeben. Eine Alternative ist den Pixelwert an nur einer der die RGB-Parameter, die ein farbiges Bild (Schattierungen von rot, grün oder blau) eher als ein Graustufenbild zu übergeben.

Die FillRectangle-Methode zeichnet einen Bereich des Bitmap-Objekts. Der erste Parameter ist die Farbe. Die zweite und dritte Parameter sind die x- und y-Koordinaten der oberen linken Ecke des Rechtecks. Hinweis, dass x auf-ab, die in das Quellbild Pixelmatrix Index j entspricht. Die vierten und fünften Parameter FillRectangle sind die Breite und Höhe des rechteckigen Bereichs zu malen, ausgehend von der Ecke von der zweiten und dritten Parameter angegeben.

Nehmen wir beispielsweise an die aktuelle Pixel angezeigt werden ist bei i = 2 und j = 5 im Quellbild und hat Wert = 200 (für ein dunkles Grau). Wenn der Vergrößerungsfaktor auf 3 festgelegt ist, wird das Bitmap-Objekt 84 von 84 Pixel groß sein. Die FillRectangle-Methode würde anfangen Malerei an x = (5 * 3) = Spalte 15 und y = (2 * 3) = Zeile 6 der Bitmap, und zeichnen Sie ein Rechteck 3 x 3 Pixel mit Farbe (55,55,55) = dunkelgrau.

Anzeige eines Bilds Pixelwerte

Wenn Sie auf den Code in verweisen Abbildung 5, du wirst sehen, dass Hilfsmethode PixelValues verwendet wird, um die hexadezimale Darstellung eines Bilds Pixelwerte erzeugen. Die Methode ist kurz und einfach:

public static string PixelValues(DigitImage dImage)
{
  string s = "";
  for (int i = 0; i < dImage.height; ++i) {
    for (int j = 0; j < dImage.width; ++j) {
      s += dImage.pixels[i][j].ToString("X2") + " ";
    }
    s += Environment.NewLine;
  }
  return s;
}

Die Methode erstellt eine lange Zeichenfolge mit eingebetteten Newline-Zeichen mit String-Verkettung Einfachheit. Wenn die Zeichenfolge in ein TextBox-Steuerelement, das die Multiline-Eigenschaft auf True festgelegt ist befindet, wird die Zeichenfolge angezeigt, wie in Abbildung 1. Zwar etwas schwieriger zu interpretieren, als 10 Werte stützen hexadezimale Werte sein, formatieren hexadezimale Werte mehr schön.

Wo kann man von hier aus?

Bilderkennung ist ein Problem, das im Prinzip einfach, aber in der Praxis äußerst schwierig. Ein guter erster Schritt in Richtung Verständigung IR ist in der Lage, den bekannten MNIST-Datensatz zu visualisieren, wie in diesem Artikel gezeigt. Wenn man sich Abbildung 1, Sie werden sehen, dass ein MNIST Bild wirklich nichts ist mehr als 784 Werte mit eine zugehörige Bezeichnung, z.B. "4." Bilderkennung läuft also zu finden, eine Funktion, die 784 Werte als ein- und gibt, als Ausgabe 10 Wahrscheinlichkeiten, darstellt die Wahrscheinlichkeiten, daß die Eingänge 0 bis 9, bzw. akzeptiert.

Ein gemeinsames Konzept für IR ist, irgendeine Form des neuronalen Netzes zu verwenden. Zum Beispiel könnten Sie ein neuronales Netz mit 784 Eingabeknoten, verborgene Ebene von 1.000 Knoten und eine Ausgabeebene mit 10 Knoten erstellen. Ein solches Netzwerk hätte insgesamt (784 * 1000) + (1000 * 10) + (1000 + 10) = 795.010 Gewichte und Bias-Werte zu bestimmen. Sogar mit 60.000 Ausbildung Bilder wäre dies ein sehr schwieriges Problem. Aber es gibt einige faszinierende Techniken, die Sie verwenden können, zu helfen, ein gutes Image-Erkennungsmodul. Diese Techniken umfassen mit ein convolutional neuronales Netz und generieren zusätzliche Ausbildung Bilder mit elastischen Verzerrungen.

**Dr.**James McCaffrey arbeitet für Microsoft Research in Redmond, Washington Er arbeitete an verschiedenen Microsoft-Produkten, einschließlich Internet Explorer und Bing. McCaffrey kann erreicht werden unter jammc@microsoft.com.

Unser Dank gilt dem folgenden technischen Experten für die Durchsicht dieses Artikels: Wolf Kienzle (Microsoft Research)