Settembre 2015

Volume 30 Numero 9

Il presente articolo è stato tradotto automaticamente.

Esecuzione di test - Calcolo mediante neuroni artificiali con picchi

Da James McCaffrey

Un'area molto interessante dell'informatica è computing con neuroni artificiali bloccarsi: componenti software di piccole dimensioni che modellano il comportamento di neuroni biologici. Neuroni artificiali bloccarsi sono correlati a ma piuttosto diverso dai neuroni artificiali in una rete neurale software comuni.

Consenti stati destra in anticipo che non è possibile essere immediatamente utili all'utente normali attività quotidiane programmazione per questa discussione di neuroni artificiali bloccarsi. Ma consentirà di comprendere quali potrebbe essere il futuro dell'informatica come e semplicemente interessanti neuroni artificiali bloccarsi propri.

Il modo migliore per ottenere un'idea per i quali un neurone spiking e per vedere quale ha inizio in questo articolo è a esaminare il programma demo in Figura 1.

Figura 1 artificiale bloccarsi Neurone Demo

La demo mostra i valori di input e outpui per un singolo neurone spiking. Esistono tre flussi di input, detti treni di picco.

Ciascuno dei treni picco input dispone di 16 valori 0 o 1. I tre treni di picco di input sono:

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

Questi valori 0 o 1 rappresentano input nel tempo da alcuni altri spiking neurone. In altre parole, al tempo t = 0, il valore di input dal primo treno di picco è 0. al tempo t = 1, l'input è 0. t = 2, l'input è 1. e così via tramite t = 15 quando il valore di input è 1.

Al tempo t = 0, il spiking neurone riceve l'input da tutti i tre flussi, pertanto a t = 0, l'input completo per il neurone è (0, 1, 1); al tempo t = 1, l'input è (0, 0, 1); e così via tramite t = 15 quando l'input è (1, 1, 1).

La parte successiva del programma demo consente di visualizzare le costanti numeriche che definiscono il comportamento del neurone. Esistono tre pesi con valori (4, -2, 3) che corrispondono a ogni input treno. (2) verrà spiegato il significato del potenziale di perdita (1), il potenziale di soglia (8), il potenziale di picco (4) e la latenza di post-picco. Nel contesto di bloccarsi neuroni, il termine "potenziale" significa Sensor (loosely) anziché "eventuale" o "imminenti."

Il programma demo simula i segni di graduazione ora 16. A ogni segno di graduazione, le tre input vengono visualizzati i valori 0 o 1 insieme allo stato di neurone (attivo o inattivo) e il potenziale elettrico corrente (V) del neurone. Si noti che al tempo t = 6 il neurone raggiunge un potenziale di V = 8 e picchi a V = 12. Dietro le quinte, mentre viene elaborato ogni set di valori di input, un valore di output pari a 0 o 1 verrà generato e salvato in un buffer. Dopo l'elaborazione di tutti i valori di input, il programma demo Visualizza treno picco output risultante:

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

A questo punto, si è probabilmente non troppo colpiti. Una serie di valori 0 o 1 passa e viene reso disponibile una serie di valori 0 o 1. Ma chi è assalito e si vedrà perché neuroni artificiali bloccarsi possono consentire di portare a una modifica fondamentale nel computer e di elaborazione.

In questo articolo si presuppone che siano disponibili almeno delle competenze di programmazione per principianti, ma non si conoscono i neuroni di bloccarsi. Ho codificato il programma demo utilizza c#, ma non dovrebbe essere molto difficile il refactoring in un altro linguaggio, ad esempio Python o JavaScript. Il codice demo è breve e viene presentato nella sua interezza in questo articolo. L'origine completa è anche disponibile nel download del codice fornito.

Conoscenza bloccarsi neuroni

Esaminiamo il grafico in Figura 2. Il grafico viene visualizzato il valore di potenziale elettrico, V, della demo bloccarsi neurone da tempo t = 0 per t = 15. Esistono numerose varianti di bloccarsi neuroni. Il programma demo si basa su un modello denominato il neurone spiking integrare e incendio debole.

Figura 2 bloccarsi integrare e incendio debole Neurone comportamento

Potenziale elettrico del neurone tende ad aumentare nel tempo. Quando V soddisfa o supera la soglia spiking pari a 8, indicato dalla linea tratteggiata, il valore V immediatamente picchi di backup da 4 (il picco potenziale) e quindi viene immediatamente reimpostato su 0. Si verificano eventi bloccarsi al tempo t = 6 e t = 13. Se si verifica un evento spiking, 1 viene generato per l'output picco treno, in caso contrario che viene generato un valore 0.

In tal caso, solo come vengono V calcolati per ogni valore di t? Al tempo t = 0, i tre valori di input sono (0, 1, 1). Tenere presente che i valori di peso tre del neurone sono (4, -2, 3). In primo luogo, la somma dei prodotti di pesi volte input viene calcolata e aggiunto al valore corrente di V. Se V è considerato uguale a 0 all'inizio della demo quindi:

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

Questo è il passaggio di integrazione. Successivamente, viene sottratto il valore di perdita. Per la dimostrazione, perdite = 1 così:

V = V - leak
   = 1 - 1
   = 0

Il nuovo valore V = 0 non superi il valore di soglia di 8 in modo che il neurone non di picco e genera un 0 per il training di picco output. Successivamente, al tempo t = 1, i valori di input sono (0, 0, 1). La combinazione di passaggi di integrazione e perdita offre:

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

Artificiali debole integrare e incendio bloccarsi neuroni sono estremamente semplici. Si noti che tutti i valori sono numeri interi, che, combinato con semplicità di progettazione, significa che neuroni artificiali possono essere implementati in modo efficiente nel software o hardware.

In Figura 2, si noterà che si verifica un evento di picco al tempo t = 6. T = 5, V = 5, quindi il calcolo di integrazione e perdita per t = 6 è:

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

A questo punto, V soddisfa il valore di soglia pari a 8, in modo che il valore di V picchi di 8 + 4 = 12, viene generato un valore di output 1 e quindi V immediatamente viene reimpostato su 0. Dopo un evento di picco neurone simulato passa allo stato di inattività in cui vengono ignorati i valori di input. La demo imposta il periodo di latenza a 2, in modo corretto t = 7 e t = 8, V rimane impostata su 0 indipendentemente dai valori di input. Al tempo t = 9, il neurone diventa attivo e riprende un comportamento normale.

Implementare il programma Demo

Il codice per il programma demo, con poche modifiche minori per risparmiare spazio, viene presentato in Figura 3. Per creare il programma demo, ho avviato Visual Studio e creato un nuovo progetto applicazione console di c# denominato SpikingNeuron. Il programma demo non ha significative Microsoft .NET Framework dipendenze quindi funzionerà con qualsiasi versione relativamente recente di Visual Studio .

Figura 3 bloccarsi Neurone programma

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

Dopo il codice del modello caricato nell'editor di testo, nella finestra Esplora soluzioni è rinominato il file Program.cs in SpikingNeuronProgram.cs e Visual Studio rinominare class Program per me è consentito. Nella parte superiore del codice sorgente rimosso tutte le necessarie utilizzando le istruzioni, lasciando solo il riferimento per lo spazio dei nomi di sistema principale.

Il codice nel metodo Main inizia impostando i dati di input e un buffer di archiviazione per i valori di output:

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];

Sono disponibili tre flussi di input. Neuroni artificiali bloccarsi in grado di gestire qualsiasi numero di flussi. Ogni flusso dispone di 16 valori 0 o 1. La lunghezza di input è arbitraria ma dal punto di vista del programmatore, è possibile pensare ogni flusso di input demo come un valore senza segno a 16 bit.

Successivamente, la demo imposta i valori che definiscono il comportamento del neurone:

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

Si noti che i pesi per flussi di input 0 e 2 sono positivi e agiscono di conseguenza per aumentare il potenziale elettrico del neurone, ma il peso per il flusso di input 1 è negativo, in modo riduce il rischio potenziale. Talvolta queste si distinguono come excitatory (aumento) e input inibitori (riduzione).

Il valore di perdita qui è impostato su 1. Un'alternativa da considerare è che la perdita stocastico; in modo casuale variare il valore di perdita tra, ad esempio, 0 e 3 in ogni ora segni di graduazione. Oppure è possibile variare il valore di perdita sia proporzionale al potenziale rischio corrente. È anche possibile rendere i picchi di utilizzo di reimpostare il periodo di tempo di latenza un valore casuale.

Tutta l'elaborazione viene controllato da un ciclo basato sul tempo:

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

All'interno del ciclo di tempo, la demo verifica innanzitutto se è attivo il neurone:

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

Variabile tNext è il valore di tempo successivo quando sarà attivo il neurone. Nella maggior parte dei casi, tNext sarà t + 1. Un neurone inattivo è essenzialmente in modalità sospensione, pertanto non esiste alcuna modifica al potenziale elettrico e non si verifica alcun sovraccarico. All'interno di diramazione neurone attivo, viene calcolato il V potenziale elettrico:

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;

Qui j è l'indice del flusso di input (0, 1, 2) e t è l'indice di tempo. Ad esempio, gli input [1] [8] è il valore 0 o 1 per il flusso di input 1 al tempo t = 8. Dopo la perdita viene sottratto V, il valore risultante viene controllato per verificare che non va negativo V. Tuttavia, in neuroni reali, potenziali elettriche possono infatti essere negativi, pertanto un'opzione da considerare è consentire V passare negativo.

Dopo che viene calcolato V, il relativo valore viene controllato per verificare se deve verificarsi un evento di picco, come illustrato nella Figura 4.

Figura 4 verifica se un evento di picco di

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;
}

Quando si verifica un evento di picco, il valore corrente di V viene incrementato (4 nella demo) e quindi immediatamente reimpostato su 0. In altre parole, il valore chiodato temporaneo di V non viene utilizzato in tutti. Alternativa da prendere in considerazione, è possibile reimpostare automaticamente a V = 0. In alternativa, è possibile reimpostare sottraendo una quantità dal valore V chiodata. Ad esempio, al tempo t = 6 demo, V temporaneamente picchi da 8 a 12. Se si utilizza quindi un valore di reimpostazione di picco pari a 10, invece di reimpostazione da 12 a 0, reimposta il neurone da 12 a 2.

Che cos'è il punto?

Neuroni artificiali bloccarsi vengono analizzati da diversi gruppi di persone per scopi diversi. Neurobiologists tenta di creare modelli di software esattamente replicano il comportamento di neuroni reali per ottenere informazioni sui processi biologici. Si scopre che il modello neurone di integrare e picco debole è troppo semplice replicare completamente il comportamento di neuroni reali, più modelli complessi vengono in genere utilizzati.

Neuroni artificiali bloccarsi anche servono da base per i sistemi di classificazione di apprendimento automatico. Sebbene le reti neurali artificiale che non sono state utilizzo con valori reali simulati neuroni essere stata ampiamente studiati per decenni, reti di neuroni artificiali bloccarsi esplorato gran parte. A mio parere, risultati di ricerca in questa area sono senza risultati e non è chiaro se le reti di neuroni artificiali bloccarsi forniscono un vantaggio rispetto classici neuroni artificiali con valori reali. Esistono ancora numerose domande research aperto.

Infine, neuroni artificiali bloccarsi in uso nel tentativo per creare un approccio innovativo per computer e della programmazione. Stati Uniti. Progetto di sistemi di Neuromorphic adattivo plastica scalabile Electronics (SyNAPSE) Defense Advanced Research progetti Agency (DARPA) mira a creare i computer che supportano livelli biologici. Anziché utilizzare l'architettura hardware tradizionali, alcuni progetti promesse iniziale utilizzato miliardi di interconnessi artificiali debole integrare e incendio bloccarsi neuroni. Se questi sforzi ottenuto esito positivo, è possibile creare i computer che sono quasi inconceivably più potenti sistemi correnti.

Ripristino di emergenza.James McCaffrey* lavora per Microsoft Research a Redmond, Washington. Ha lavorato su numerosi prodotti Microsoft, inclusi Internet Explorer e Bing. Dr. È possibile contattarlo McCaffrey jammc@microsoft.com.*

Grazie ai seguenti esperti tecnici Microsoft per la revisione di questo articolo: Todd Bello e Dan Liebling