---

September 2015

Band 30, Nummer 9

Dieser Artikel wurde maschinell übersetzt.

Testlauf – Computing mit künstlichen Spiking-Neuronen

Durch James McCaffrey

Ist ein faszinierende Bereich der Informatik mit künstlicher einen Neuronen computing – kleine Softwarekomponenten, die das Verhalten der biologischen Neuronen zu modellieren. Künstliche einen Neuronen sind im Zusammenhang mit jedoch stark von der künstlichen Neuronen in einem gemeinsamen Netzwerk Software.

Lassen Sie mich State rechts oben vorne, dass die Erläuterung der künstlichen einen Neuronen nicht sofort nützlich in Ihre normalen täglichen Programmieraufgaben sein wird. Aber es gibt Ihnen einen Einblick in was die Zukunft des Computings wie möglicherweise, und nur unter Umständen einen Neuronen der künstliche Identitätsintegrationstools interessant.

Die beste Methode, um ein Gefühl für welche einen ein Neuron ist abzurufen und worauf dieser Artikel ist ist auf einen Blick auf das Demoprogramm in Abbildung 1.

Abbildung 1 künstliche angestiegen Neuron-Demo

Die Demo zeigt die Eingabe- und Werte für ein einzelnes einen Neuron. Es gibt drei Eingabedatenströme manchmal Züge Spitze bezeichnet.

Jede Eingabe Spitze Züge hat 16 Werte 0 oder 1. Die drei Eingabe-Sammlung sind:

0 0 1 0 1 0 1 1 1 1 0 0 1 0 1 1
1 0 1 1 0 0 0 1 1 1 0 1 1 0 1 1
1 1 0 1 0 0 0 1 1 0 1 1 1 1 1 1

Diese Werte 0 oder 1 stellen die Eingabe mit der Zeit einige andere einen Neurons dar. Anders ausgedrückt, zum Zeitpunkt t = 0, der Wert aus der ersten Sammlung Zug ist 0; zum Zeitpunkt t = 1, die Eingabe ist 0; t = 2, die Eingabe ist 1. und so weiter = bis t 15, wenn der Wert 1 ist.

Zum Zeitpunkt t = 0, die einen Neuron empfängt Eingaben von allen drei Streams, also bei t = 0, die Eingabe des Neurons abgeschlossen ist (0, 1, 1). zum Zeitpunkt t = 1, die Eingabe ist (0, 0, 1); und so weiter = bis t 15 wird die Eingabe (1, 1, 1).

Der nächste Teil des Demoprogramms Zeigt numerische Konstanten, die das Verhalten des Neurons zu definieren. Es gibt drei Gewichtungen mit Werten (4, -2, 3), die jede Eingabe Zug entsprechen. Die Bedeutung der potenzielle Speicherverluste (1), das Potenzial für Schwellenwert (8), das Potenzial der Sammlung (4) und die Wartezeit nach der Sammlung (2) werden in Kürze erläutert. Im Kontext der Neuronen angestiegen bedeutet der Begriff "Potenzial" (lose) elektrischen Spannung statt "möglich" oder "vor den Risiken warnt."

Das Demoprogramm simuliert 16 Mal Ticks. Bei jedem Takt Eingabe die drei Werte von 0 oder 1 zusammen mit dem Status des Neurons (aktiv oder inaktiv) und die aktuellen elektrischen (V) des Neurons angezeigt werden. Beachten Sie, dass zum Zeitpunkt t = 6 des Neurons erreicht potenziellen v = 8 und Spitzen v = 12. Hinter den Kulissen wie jede Gruppe von Eingabewerten verarbeitet wird, ein Ausgabewert 0 oder 1 generiert und in einem Puffer gespeichert. Nachdem alle Eingabewerte verarbeitet wurden, zeigt das Demoprogramm die resultierende Ausgabe Spitze Zug:

0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0

Zu diesem Zeitpunkt sind Sie wahrscheinlich nicht zu beeindruckt. Befindet sich eine Reihe von Werten von 0 oder 1 und eine Reihe von Werten von 0 oder 1 kommt. Aber etwas Geduld, und sehen Sie, warum künstliche einen Neuronen dazu beitragen können, um eine grundlegende Änderung in Computer und computing führen.

In diesem Artikel wird vorausgesetzt, dass mindestens für Anfänger Programmierkenntnisse jedoch nicht vorausgesetzt Sie wissen nichts über die Neuronen angestiegen. Ich habe das Demoprogramm mit c# codiert sollten, aber Sie es in eine andere Sprache, z. B. Python oder JavaScript Umgestalten. Der Demo-Code ist kurz und in seiner Gesamtheit in diesem Artikel dargestellt wird. Die vollständige Quelle ist auch verfügbar im Codedownload.

Grundlegendes zu einen Neuronen

Betrachten Sie den Graph in Abbildung 2. Das Diagramm zeigt den elektrischen potenziellen Wert V der Demo angestiegen Neuron von Zeit t = 0 und t = 15. Es gibt viele verschiedene Varianten von Neuronen angestiegen. Das Demoprogramm basiert auf einem Modell aufgerufen, das von Speicherverlusten integrieren und Fire einen Neuron.

Abbildung 2 von Speicherverlusten integrieren und Fire angestiegen Neuron Verhalten

Das elektrische Potenzial des Neurons tendenziell zunimmt. V erfüllt, oder einen Schwellenwert für den gleich 8, angegeben durch die gestrichelte Linie wird der V-Wert sofort, Spitzen Einrichten von 4 (die Spitze potenzielle) und dann sofort auf 0 zurückgesetzt. Einen Ereignissen zum Zeitpunkt t = 6 und t = 13. Wenn ein Ereignis einen auftritt, wird 1 Ausgabe Spitze Zug, andernfalls ausgegeben 0 ausgegeben wird.

Ja, ebenso wie V berechnet wird, für jeden Wert von t? Zum Zeitpunkt t = 0, die drei Eingabewerte sind (0, 1, 1). Denken Sie daran, dass die drei Gewichtungswerte des Neurons sind (4, -2, 3). Erstens ist die Summe der Produkte der Eingaben Zeiten Gewichtungen berechnet und der aktuelle Wert der V hinzugefügt. Wenn V als 0 zu Beginn der Demo dann angesehen wird:

V = V + sum
   = 0 + (0)(4) + (1)(-2) + (1)(3)
   = 0 + 1
   = 1

Dies ist der integrieren. Als Nächstes wird der Wert von Speicherverlusten subtrahiert. Für die Demo Speicherverluste also = 1:

V = V - leak
   = 1 - 1
   = 0

Der neue Wert der V = 0 nicht den Schwellenwert von 8 überschreiten, damit das Neuron Spitze nicht und es wird eine 0 Zuordnen der Ausgabe Spitze Zug. Als Nächstes zum Zeitpunkt t = 1, die Eingabewerte sind (0, 0, 1). Kombinieren die Schritte integrieren und Speicherverluste erhalten:

V = V + sum - leak
    = 0 + (0)(4) + (0)(-2) + (1)(3) - 1
    = 0 + 3 - 1
    = 2

Künstliche von Speicherverlusten integrieren und Fire einen Neuronen werden erheblich vereinfacht. Beachten Sie, dass alle Werte sind ganze Zahlen, die in Kombination mit dem Entwurf der Einfachheit bedeuten, dass die Neuronen der künstliche effizient in Software oder Hardware implementiert werden können.

In Abbildung 2, sehen Sie, dass ein spitzenereignis, zum Zeitpunkt t auftritt = 6. T = 5, V = 5, also die Berechnung integrieren und Verluste für t = 6 ist:

V = V + sum - leak
    = 5 + (1)(4) + (0)(-2) + (0)(3) - 1
    = 5 + 4 - 1
    = 8

An diesem Punkt erfüllt V den Schwellenwert von 8, damit der Wert des V, bis 8 + 4 = 12 Spitzen, ein Ausgabewert 1 ausgegeben wird, und dann V sofort auf 0 zurückgesetzt wird. Nach einem spitzenereignis gibt das simulierte Neuron einen Zustand der Inaktivität, in denen Eingabewerte ignoriert werden. Die Demo wird dieser Wartezeit auf 2, also manchmal t = 7 und t = 8, V bleibt bei 0, unabhängig von den Werten der Eingaben. Zum Zeitpunkt t = 9, des Neurons aktiv ist, und setzt das normale Verhalten.

Das Demoprogramm implementieren

Der Code für das Demoprogramm mit ein paar kleinen Änderungen, um Platz zu sparen werden im Abbildung 3. Um das Demoprogramm zu erstellen, wenn ich Visual Studio gestartet und erstellt ein neues C#-Konsolenanwendungsprojekt mit dem Namen SpikingNeuron. Das Demoprogramm hat keine signifikante Microsoft .NET Framework Abhängigkeiten, also eine relativ neue Version von Visual Studio arbeiten.

Abbildung 3 angestiegen Neuron-Programm

using System;
namespace SpikingNeuron
{
  class SpikingNeuronProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin spiking neuron demo");
      int[][] inputs = new int[3][];
      inputs[0] = new int[] { 0, 0, 1, 0, 1, 0, 1, 1,
        1, 1, 0, 0, 1, 0, 1, 1 };
      inputs[1] = new int[] { 1, 0, 1, 1, 0, 0, 0, 1,
        1, 1, 0, 1, 1, 0, 1, 1 };
      inputs[2] = new int[] { 1, 1, 0, 1, 0, 0, 0, 1,
        1, 0, 1, 1, 1, 1, 1, 1 };
      Console.WriteLine("The inputs are: ");
      for (int i = 0; i < inputs.Length; ++i)
        ShowVector(inputs[i], false);
      Console.WriteLine("");
      int[] output = new int[16];
      int[] wts = new int[] { 4, -2, 3 };
      Console.Write("The weights are: ");
      ShowVector(wts, true);
      Console.WriteLine("");
      int leak = 1;
      Console.WriteLine("Leak potential is: " + leak);
      int v = 0; // electrical potential (voltage)
      int thresh = 8; // Threshold
      int spike = 4;  // Increase in v at spike
      int tNext = 0; // Time when neuron is active
      int latency = 2; // Inactive after spike
      Console.WriteLine("Threshold is: " + thresh);
      Console.WriteLine("Spike is: " + spike);
      Console.WriteLine("Latency time is: " + latency);
      Console.WriteLine("Starting processing\");
      for (int t = 0; t < 16; ++t)
      {
        Console.WriteLine("----------------------");
        Console.Write(" ");
        Console.Write("t = ");
        if (t <= 9) Console.Write(" ");
        Console.Write(t + ". ");
        Console.Write("Inputs = " + inputs[0][t] +
          " " + inputs[1][t] +
          " " + inputs[2][t]);
        if (t != tNext) // Neuron not active
        {
          Console.Write(". Neuron is inactive. ");
          Console.WriteLine("V = " + v);
          output[t] = 0;
        }
        else // Neuron is active
        {
          Console.Write(". Neuron is   active. ");
          int sum = 0;
          for (int j = 0; j < inputs.Length; ++j)
            sum += inputs[j][t] * wts[j];
          v = v + sum;
          v = v - leak;
          if (v < 0)
            v = 0;
          Console.WriteLine("V = " + v);
          if (v >= thresh) // Spike and reset
          {
            v = v + spike;
            Console.WriteLine(" Spiking, V = " + v);
            output[t] = 1;
            v = 0;
            tNext = t + 1 + latency;
          }
          else
          {
            output[t] = 0;
            tNext = t + 1;
          }
        } // Active
      } // t
      Console.WriteLine("----------------------");
      Console.WriteLine("Output spike train = ");
      ShowVector(output, false);
      Console.WriteLine("End spiking neuron demo");
      Console.ReadLine();
    } // Main
    static void ShowVector(int[] vector, bool plus)
    {
      for (int i = 0; i < vector.Length; ++i)
      {
        if (plus == true && vector[i] >= 0)
          Console.Write("+");
        Console.Write(vector[i] + " ");
      }
      Console.WriteLine("");
    }
  } // Program
} // ns

Nachdem der Vorlagencode im Text-Editor geladen, im Projektmappen-Explorer-Fenster ich SpikingNeuronProgram.cs Datei Program.cs umbenannt und Visual Studio zum Umbenennen der Program-Klasse für mich zulässig. Am Anfang des Quellcodes, die ich entfernt nicht benötigte alle using-Anweisungen, lassen einfach den Verweis auf den System-Namespace der obersten Ebene.

Der Code in der Main-Methode beginnt mit dem Einrichten der Eingabedaten und Speicherpuffers für die Ausgabewerte:

int[][] inputs = new int[3][];
inputs[0] = new int[] { 0, 0, 1, 0, 1, 0, 1, 1,
  1, 1, 0, 0, 1, 0, 1, 1 };
...
int[] output = new int[16];

Es gibt drei Eingabedatenströme. Künstliche einen Neuronen können eine beliebige Anzahl von Datenströmen aufnehmen. Jeder Datenstrom hat 16 Werte 0 oder 1. Die Länge der Eingabe ist beliebig, aber aus Sicht des Programmierers, stellen Sie sich jede Demo Eingabedatenstrom als 16-Bit-Wert ohne Vorzeichen.

Als Nächstes wird die Demo Werte, mit die des Neurons Verhalten definieren:

int[] wts = new int[] { 4, -2, 3 };
int leak = 1;
int v = 0; // Electrical potential (voltage)
int thresh = 8; // Needed to fire an output spike
int spike = 4;  // Increase in v at spike event
int tNext = 0; // Next time when neuron is active
int latency = 2; // Number t inactive after spike

Beachten Sie, dass die Gewichtungen für Eingabedatenströme 0 und 2 sind positiv und daher reagieren, um den elektrischen Potenzial des Neurons zu erhöhen, aber die Gewichtung für Eingabedatenstrom 1 negativ ist, damit sie das Risiko verringert. Diese werden manchmal auch als excitatory (vergrößern) und inhibitory (verringert) Eingaben unterschieden.

Hier wird der Wert von Speicherverlusten auf 1 festgelegt. Eine Alternative zu berücksichtigen ist der Leakage stochastischen vornehmen. Das heißt, nach dem Zufallsprinzip den Speicherverlust Wert zwischen, sagen nutzen, 0 und 3 zu jedem Zeitpunkt Tick. Oder Sie könnten den Wert von Speicherverlusten proportional zur aktuellen potenzielle variieren. Sie können auch erwägen Latenz Zeitraum zurücksetzen Sammlung einen zufälligen Wert.

Die gesamte Verarbeitung wird durch eine Schleife zeitgesteuerten gesteuert:

for (int t = 0; t < 16; ++t)
{
  // Compute new V
  // Spike if V >= threshold
  // Emit a 0 or 1
}

Innerhalb der Schleife Zeit überprüft die Demo zuerst prüfen, ob das Neuron inaktiv ist:

if (t != tNext) // Neuron is not active
{
  Console.Write(". Neuron is inactive. ");
  Console.WriteLine("V = " + v);
  output[t] = 0;
}
else
{
  // Active
}

Variable tNext wird der nächste Wert für die Uhrzeit des Neurons aktiv sein soll. In den meisten Fällen werden tNext t + 1. Eine inaktive Neuron ist im Wesentlichen inaktiv, sodass es keine Änderung an der elektrischen Potenzial erfolgt und keine Sammlung auftreten kann. In der Verzweigung aktiv Neuron wird der elektrische potenzielle V berechnet:

int sum = 0;
for (int j = 0; j < inputs.Length; ++j)
  sum += inputs[j][t] * wts[j];
v = v + sum;
v = v - leak;
if (v < 0) v = 0;

J ist hier der Index des Eingabestreams (0, 1, 2) und der Zeitindex "t" ist. Eingaben [1], [8] ist beispielsweise der Wert 0 oder 1 für Eingabedatenstrom 1 zum Zeitpunkt t = 8. Nach der Verlust von V subtrahiert wird, wird der resultierende Wert überprüft, um sicherzustellen, dass V negative gehen nicht. In echten Neuronen kann elektrischen Potenziale tatsächlich negativ ist, jedoch eine Option in Betracht ziehen, sodass V negative wechseln können.

Nachdem V berechnet wurde, seinen Wert wird überprüft, ob ein spitzenereignis erfolgen soll, siehe Abbildung 4.

Abbildung 4: Überprüfen, ob ein Spitzenereignis erfolgen soll

if (v >= thresh) // Spike and reset
{
  v = v + spike;
  Console.WriteLine(" Spiking, V = " + v);
  output[t] = 1;  // Fire
  v = 0;
  tNext = t + 1 + latency;
}
else // No spike
{
  output[t] = 0;
  tNext = t + 1;
}

Wenn ein spitzenereignis auftritt, wird der aktuelle Wert der V erhöht (4 in der Demo) und sofort auf 0 zurückgesetzt. Anders ausgedrückt, wird der temporäre dotierten Wert v überhaupt nicht verwendet. Eine Alternative zur Auswahl ist nicht automatisch zurückgesetzt, v = 0. Stattdessen können Sie zurücksetzen, indem Sie einige Betrag vom dotierten V Wert subtrahiert. Z. B. zum Zeitpunkt t = 6 in der Demo V vorübergehend Spitzen von 8 bis 12. Wenn Sie einen Sammlung zurücksetzen Wert 10, dann verwendet anstelle von 12 auf 0 zurücksetzen, werden des Neurons auf 2 von 12 zurückgesetzt.

Was ist der Grund?

Künstliche einen Neuronen werden für verschiedene Zwecke durch unterschiedliche Personengruppen studiert. Neurobiologists versuchen, Softwaremodelle zu erstellen, die das Verhalten von echten Neuronen genau zu replizieren, um Einblicke in biologische Prozesse zugreifen zu können. Es stellt sich heraus, dass das Modell von Speicherverlusten integrieren und Spitze Neuron ist zu einfach, um das Verhalten der echten Neuronen replizieren vollständig mehr komplexer Modelle in der Regel verwendet werden.

Künstliche einen Neuronen dienen auch als Grundlage für maschinelles lernen Klassifizierung Systeme. Obwohl künstliche neuronale Netzwerke, die mit simulierte Neuronen Real-Werte haben seit Jahrzehnten Netzwerke von künstlich einen Neuronen studiert wurde noch nicht viel untersucht. Meiner Meinung nach Forschungsergebnisse in diesem Bereich sind nicht eindeutig, und es ist nicht klar, ob die Netzwerke von künstlich einen Neuronen alle Vorteil gegenüber dem klassischen echtwerttyp künstliche Neuronen bereitstellen. Es gibt noch viele offene Forschungsfragen.

Schließlich sind künstliche einen Neuronen einer verwendet wird, erstellen Sie einen grundlegend neuen Ansatz für Computer und Programmierung. Der USA Defense Advanced Research Projects Agency (DARPA) Systemen von Neuromorphic Adaptive Kunststoff skalierbare Electronics (SyNAPSE)-Projekt zielt darauf ab, um Computer zu erstellen, die biologische Ebenen skaliert werden können. Statt der herkömmlichen Hardware-Architektur, wurden einige anfängliche vielversprechend Entwürfe Milliarden von verbundener künstliche von Speicherverlusten integrieren und Fire einen Neuronen verwendet. Wenn in diesem Zusammenhang erfolgreich verlaufen sind, kann es möglich, Computer zu erstellen, die fast inconceivably leistungsfähiger als aktueller Systeme sind.

---

Dr. James McCaffrey ist in Redmond (Washington) für Microsoft Research tätig. Er hat an verschiedenen Microsoft-Produkten mitgearbeitet, unter anderem an Internet Explorer und Bing. Dr. McCaffrey erreichen Sie unter jammc@microsoft.com.

Dank den folgenden technischen Experten von Microsoft für die Überprüfung dieses Artikels: Alexander Bello und Dan Liebling