Dieser Artikel wurde maschinell übersetzt.

Test Run

Schulungen zu radialen Basisfunktionsnetzwerken

James McCaffrey

James McCaffreyEin radial Basis-Funktion (RBF)-Netzwerk ist ein Softwaresystem, das Daten zu klassifizieren und Vorhersagen kann.RBF Netze haben oberflächlichen Ähnlichkeiten mit neuronalen Netzen, aber eigentlich ganz anders sind.Ein RBF-Netzwerk akzeptiert einen oder mehrere numerische Eingaben und generiert eine oder mehrere numerische Ausgaben.Die Ausgabewerte werden durch die Eingabewerte, plus einen Satz von Parametern der RBF-Zentroide genannt, eine Gruppe namens die RBF breiten, eine Gruppe namens die RBF-Gewichte und eine Gruppe namens die RBF-Verzerrungen bestimmt.

Der Einfachheit halber der Terminologie die Kombination von RBF Gewichte und Bias-Werte sind manchmal Zusammenfassend genannt die Gewichte.Der Kontext, in denen der Begriff Gewichte verwendet in der Regel, macht die Bedeutung klar.Weitere Informationen finden Sie in meinem Artikel "Radial Basis Funktion Netze für Programmierer" in der Oktober-Ausgabe des MSDN Magazine (msdn.microsoft.com/magazine/dn451445).

Wenn ein RBF-Netzwerk zur Klassifikation und Prognose zu verwenden, ist die Herausforderung, einen Satz von Werten für die Zentroide, breiten, Gewichte und Voreingenommenheit zu finden, sodass berechnet Ausgänge am besten eine Reihe von bekannten Ausgaben übereinstimmen.Dies nennt man training des RBF-Netzes.Obwohl Forscher RBF Netze seit ihrer Einführung im Jahr 1988 studiert haben, gibt es nicht viel praktische Anleitung, die erklärt, wie RBF Netz Ausbildung implementiert.In diesem Artikel präsentieren und beschreiben eine komplette Demo-RBF-Netzwerk.

Schauen Sie sich das Demoprogramm in Abbildung 1.Das Programm erstellt ein RBF-Modell, die vorhersagt, die Arten der ein Iris-Blume ("Setosa," "versicolor" oder "Virginica") aus vier Zahlenwerte für der Blume Kelchblatt Länge und Breite, und Blütenblatt Länge und Breite.Das Demoprogramm Datenquelle besteht aus 30 Elementen, die eine Teilmenge einer bekannten 150-Element-Benchmark-Reihe namens Fishers Iris Daten.Die 30 Datenelemente haben wurden vorverarbeitet.Die vier X-Zahlenwerte haben normalisiert worden, sodass Werte kleiner als 0 (null) bedeutet kürzer als der Durchschnitt-Länge oder Breite und Werte größer null länger als durchschnittliche Länge oder Breite bedeuten.Der y-Wert für Arten hat codiert wurde, als (0,0,1), (0,1,0) oder (1,0,0) für Setosa, versicolor, und Virginica, beziehungsweise.

A Radial Basis Function Network Demo Program
Abbildung 1 Radial Basis Funktion Netzwerk Demo-Programm

Die Demo teilt den 30-Item-Datensatz in eine 24-Element-Gruppe für die Ausbildung verwendet werden.Es gibt auch eine Zurückhaltung sechs-Element für Prüfung/Bewertung des sich ergebenden RBF-Modells festgelegt.Er instanziiert ein RBF Netz mit vier Eingabeknoten (eine für jeden eingegebenen Daten-Wert), fünf versteckte Verarbeitung Knoten und drei Ausgabeknoten (eine für jeden Datenwert Ausgabe).Bestimmen die optimale Anzahl der versteckten Knoten ist vor allem eine Frage des Ausprobierens.Die Wahl von fünf in der Demo war willkürlich.

In Abbildung 1 Sie sehen, dass training ein RBF Netz aus drei Phasen besteht.Die erste Phase bestimmt die Zentroide.Sie können als Vertreter X-Werte aus den Trainingsdaten ausgewählt Zentroide vorstellen.Ein RBF-Netzwerk erfordert einen Schwerpunkt für jeden versteckten Knoten, so dass die Demo fünf Zentroide braucht.Der Trainingsalgorithmus wählt die X-Werte vom training Datenelemente [9], [19], [21], [20] und [4].Mit anderen Worten, ist der erste Schwerpunkt (-0.362,-2.019, 0.074 0.112).

Die zweite Phase der Ausbildung bestimmt breiten.Sie können der breiten als Werte vorstellen, die den Abstand zwischen der Zentroide beschreiben.Ein RBF-Netzwerk erfordert eine Breite für jeden versteckten Knoten.Die Demo berechnet einer einzigen gemeinsamen Breite mit dem Wert 3,3318 für alle fünf versteckte Knoten, anstatt computing fünf separate breiten.

Die dritte Phase der Ausbildung bestimmt die RBF Gewichte und Bias-Werte.Sie können Gewichte und Bias-Werte als numerische Konstanten vorstellen.Wenn ein RBF-Netzwerk verfügt über NI-Anzahl der Eingabeknoten, NH-Anzahl der versteckten Knoten und keine Anzahl von Ausgabeknoten, dann das Netzwerk erfordert (NH * NO) Gewicht Werte und keine Bias-Werte.Ja, weil das Demo-RBF-Netzwerk verfügt über eine 4-5-3-Architektur, es braucht 5 * 3 = 15 Gewichte plus drei Vorspannungen, für eine Gesamtmenge von 18 Gewichte und Bias-Werte.Die Demo-Anwendung verwendet Partikel Schwarm Optimierung (PSO), um zu bestimmen, die 18 Gewichte und Voreingenommenheit.

Nachdem Sie das Demo-RBF-Netzwerk mit dem 24-Punkt-Trainingsdataset trainiert haben, füttern Sie die sechs-Punkt-Testdataset ins Netz.In diesem Beispiel prognostiziert im RBF-Netzwerk korrekt die Arten von fünf der sechs Prüflinge für eine Klassifikation Genauigkeitder 0,8333.

Dieser Artikel setzt voraus, dass Sie Programmierkenntnisse in C# und eine grundlegende Vertrautheit mit dem radial Basis Funktion Netzwerk Input-Prozess-Output-Mechanismus erweitert haben.Ich habe diesen Mechanismus in meinem Artikel vom Oktober.Der Source-Code für das Demoprogramm ist zu lang, um in seiner Gesamtheit in diesem Artikel präsentieren, aber der vollständige Code-Download ist verfügbar unter archive.msdn.microsoft.com/mag201312TestRun.

Allgemeine Programmstruktur

Um das Demoprogramm zu erstellen, ich Visual Studio 2012 gestartet und erstellt eine c#-Konsolenanwendung mit dem Namen RadialNetworkTrain.Die Demo hat keine bedeutenden .NET-Abhängigkeiten, also beliebige Version von Visual Studio arbeiten sollte.Nachdem der Template-Code geladen, verbunden im Projektmappen-Explorer Fenster ich Datei Program.cs in die aussagekräftigeren RadialTrainProgram.cs und Visual Studio automatisch umbenannt umbenannt Klasse Programm.An der Spitze des Quellcodes löschte ich alle unnötigen Verweise auf .NET Namespaces, so dass nur den Verweis auf den Namespace System.

Die gesamte Programmstruktur mit einigen WriteLine-Anweisungen entfernt und ein paar kleinere Änderungen, ist dargestellt in Abbildung 2.Neben der Program-Klasse, die Häuser der Main-Methode, die Demo hat eine RadialNetwork-Klasse, die RBF Netzwerk Einrichtung und Schulung kapselt, ein Teilchen-Klasse, die ein Partikel-Objekt für die Verwendung mit dem RBF-Training-Algorithmus definiert, die Gewichte und Bias-Werte bestimmt und eine Helfer-Klasse enthält Dienstprogramm anzeigen Methoden.

Abbildung 2 insgesamt RBF Demo Programm Netzwerkstruktur

using System;
namespace RadialNetworkTrain
{
  class RadialTrainProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin radial basis function (RBF) network training demo");
      double[][] allData = new double[30][];
      allData[0] = new double[] { -0.784, 1.255, -1.332, -1.306, 0, 0, 1 };
      allData[1] = new double[] { -0.995, -0.109, -1.332, -1.306, 0, 0, 1 };
      // Etc.
allData[28] = new double[] { 0.904, -1.473, 1.047, 0.756, 1, 0, 0 };
      allData[29] = new double[] { 1.431, 1.528, 1.209, 1.659, 1, 0, 0 };
      Console.WriteLine("First four and last line of normalized, encoded input data:");
      Helpers.ShowMatrix(allData, 4, 3, true, true);
      double[][] trainData = null;
      double[][] testData = null;
      int seed = 8; // Gives a good demo
      GetTrainTest(allData, seed, out trainData, out testData);
      Helpers.ShowMatrix(trainData, trainData.Length, 3, true, false);
      Helpers.ShowMatrix(testData, testData.Length, 3, true, false);
      int numInput = 4;
      int numHidden = 5;
      int numOutput = 3;
      RadialNetwork rn = new RadialNetwork(numInput, numHidden, numOutput);
      Console.WriteLine("Beginning RBF training");
      int maxIterations = 100; // Max for PSO
      double[] bestWeights = rn.Train(trainData, maxIterations);
      Console.WriteLine("Evaluating RBF accuracy on the test data");
      rn.SetWeights(bestWeights);
      double acc = rn.Accuracy(testData);
      Console.WriteLine("Classification accuracy = " + acc.ToString("F4"));
      Console.WriteLine("End RBF network training demo");
    }
    static void GetTrainTest(double[][] allData, int seed,
      out double[][] trainData, out double[][] testData) { .
.
}
  }
  public class RadialNetwork
  {
    private static Random rnd = null;
    private int numInput;
    private int numHidden;
    private int numOutput;
    private double[] inputs;
    private double[][] centroids;
    private double[] widths;
    private double[][] hoWeights;
    private double[] oBiases;
    private double[] outputs;
    public RadialNetwork(int numInput, int numHidden, int numOutput) { .
.
}
    private static double[][] MakeMatrix(int rows, int cols) { .
.
}
    public void SetWeights(double[] weights) { .
.
}
    public double[] GetWeights() { .
.
}
    private double MeanSquaredError(double[][] trainData,
      double[] weights) { .
.
}
    public double Accuracy(double[][] testData) { .
.
}
    private static int MaxIndex(double[] vector) { .
.
}
    public double[] ComputeOutputs(double[] xValues) { .
.
}
    private static double[] Softmax(double[] rawOutputs) { .
.
}
    public double[] Train(double[][] trainData, int maxIterations) { .
.
}
    private void DoCentroids(double[][] trainData) { .
.
}
    private static double AvgAbsDist(double[] v1, double[] v2,
      int numTerms) { .
.
}
    private int[] DistinctIndices(int n, int range) { .
.
}
    private void DoWidths(double[][] centroids) { .
.
}
    private double[] DoWeights(double[][] trainData, int maxIterations) { .
.
}
    private static double EuclideanDist(double[] v1, double[] v2,
      int numTerms) { .
.
}
    private static void Shuffle(int[] sequence) { .
.
}
  }
  public class Particle
  {
    // Implementation here
  }
  public class Helpers
  {
    // Implementation here
  }
}

Klasse RadialNetwork ist nicht ganz so komplex wie die Programmstruktur schlägt vor, da die meisten Methoden der Klasse Helfer sind. Methode Zug führt den dreiphasige Trainingsprozess durch aufrufenden Helfer, DoCentroids, DoWidths und DoWeights. Private Methoden AvgAbsDist und DistinctIndices sind Helfer für DoCentroids. Methode DoWeights verwendet private Methode Shuffle an Prozess-Training-Datenelemente in einer anderen Reihenfolge jedes Mal durch die iterative Partikel Schwarm Optimierungsalgorithmus.

Das Herz der Demo ist recht einfach. Erstens ist die normalisierten und codierten Daten eingerichtet:

double[][] allData = new double[30][];
allData[0] = new double[] { -0.784, 1.255, -1.332, -1.306, 0, 0, 1 };
allData[1] = new double[] { -0.995, -0.109, -1.332, -1.306, 0, 0, 1 };
// Etc.
allData[28] = new double[] { 0.904, -1.473, 1.047, 0.756, 1, 0, 0 };
allData[29] = new double[] { 1.431, 1.528, 1.209, 1.659, 1, 0, 0 };

Hier sind die Daten Hardcoded Einfachheit. In den meisten Fällen werden Ihre Daten in einer Textdatei oder einer SQL-Tabelle gespeichert werden. Als nächstes ist die Daten in Training und Test Teilmengen unterteilt:

double[][] trainData = null;
double[][] testData = null;
int seed = 8;
GetTrainTest(allData, seed, out trainData, out testData);

Im RBF-Netzwerk wird instanziiert:

int numInput = 4;
int numHidden = 5;
int numOutput = 3;
RadialNetwork rn = new RadialNetwork(numInput,
   numHidden, numOutput);

Wie im vorherigen Abschnitt erwähnt, muss die optimale Anzahl von versteckten Verarbeitung Knoten im Wesentlichen durch Versuch und Irrtum bestimmt. Das Netz ist trainiert:

int maxIterations = 100;
double[] bestWeights = rn.Train(trainData, maxIterations);

Und schließlich wird das resultierende Modell ausgewertet:

rn.SetWeights(bestWeights);
double acc = rn.Accuracy(testData);
Console.WriteLine("Classification accuracy = " +
  acc.ToString("F4"));

Das BestWeights-Array enthält den RBF Gewichte und Bias-Werte festgelegt durch die Zug-Methode. Methode SetWeights lädt diese Gewichte und Bias-Werte. Du musst nicht die Zentroide und breiten explizit geladen werden, da diese Werte von Methode Zug gesetzt wurden.

Radial Basis Funktion Netzwerk Input-Prozess-Output

Um den RBF Netz Trainingsprozess zu verstehen, müssen Sie die RBF Netz ein-verstehen­Prozess-Output-Mechanismus. Das Diagramm in Abbildung 3 zeigt, wie das Demo RBF Netz berechnet die Ausgänge für Test-Datenelement [1] = (0.482, 0.709, 0.452 0.498), nachdem das Netzwerk trainiert wurde. Die X-Eingabewerte werden an jeder versteckte Knoten übergeben. Jeder versteckter Knoten berechnet die lokale Ausgabe anhand seiner eigenen Schwerpunkt und Breite.

Radial Basis Function Network Architecture
Abbildung 3-Radial Basis-Funktion-Netzwerk-Architektur

Beispielsweise die oberste versteckte Knoten Schwerpunkt ist (-0.362,-2.019, 0.074 0.112) und seine Breite 3,3318. Die lokalen Ausgaben von jedem versteckte Knoten werden dann verwendet, um vorläufige Ausgabewerte zu bestimmen, indem eine gewichtete Summe der Eingänge plus ein Bias-Wert berechnet. Z. B. wenn hOutput [0] die lokale Ausgabe des verborgenen Knoten 0 darstellt, ist dann die erste Ausgabe für die oberste Ausgabeknoten (hOutput [0] * w[0][0]) + (hOutput [1] * w[1][0]) + (hOutput [2] * w[2][0]) + (hOutput [3] * w[3][0]) + (hOutput [4] * w[4][0]) + Bias [0] =-12.7999.

Nachdem die drei vorläufige Ausgabewerte berechnet wurden, sind sie in der Endausgabe Werte mittels einer Softmax-Funktion konvertiert. Die Idee ist die vorläufige Ausgabewerte ändern, damit die Endausgabe Werte alle zwischen 0,0 und 1,0 sind, und Summe auf 1,0. Auf diese Weise die Ausgabewerte lose als Wahrscheinlichkeiten interpretiert werden können.

In Abbildung 3, die endgültigen Ausgaben sind (0.2897, 0.6865, 0.0237). Da der mittlere Knoten den höchsten Wert verfügt, wird als 1 interpretiert, und die anderen beiden Werte als 0, geben eine abgeleitete Leistung von (0, 1, 0) interpretiert werden. Erinnern die Testdaten (0.482 0.709, 0.452, 0.498, 0,000 1,000, 0.000), wobei die ersten vier Werte sind Eingänge und die letzten drei Werte sind die Zielwerte das RBF-Netzwerk macht eine korrekte Vorhersage der Arten (Iris versicolor in diesem Fall). Die Frage ist nun: Woher kommen die Werte für des RBF Netzes Zentroide, breiten, Gewichte und Voreingenommenheit?

RBF Netz Zentroide bestimmen

Die Zug-Methode der Klasse RadialNetwork ist im Wesentlichen ein Wrapper um drei Hilfsmethoden, die die eigentliche Arbeit tun:

public double[] Train(double[][] trainData, int maxIterations)
{
  DoCentroids(trainData);
  DoWidths(this.centroids);
  double[] bestWeights = DoWeights(trainData, maxIterations);
  return bestWeights;
}

DoCentroids-Methode bestimmt, repräsentativen Eingang X-Werte. Es gibt hier viele Möglichkeiten. Ein weit verbreiteter Ansatz ist die Verwendung einen k-Means- oder k-Medoids clustering-Algorithmus, der iterativ zuweisen und Datenelemente neu zuweist, so dass ähnliche Datenelemente gruppiert sind. Abschließend wird jedes Cluster Mitglied repräsentative Daten verfügen. Sie können diese als RBF Zentroide verwenden.

Ein anderer Ansatz ist die X-Werte aus zufällig ausgewählten Training Datenelemente zu extrahieren. Dies ist einfach, aber hat das Risiko, dass schlechte Zentroide zufällig ausgewählt werden können.

Das Demoprogramm verwendet, was ein leichtes clustering Ansatz vorgeschlagen diesem Pseudocode bezeichnen könnte:

initialize maxDistance
intialize bestIndices
loop
  select numHidden random indices into train data
  compute an estimated distance between selected data items
  if estimated distance > maxDistance then
    set maxDistance = curr distance
    set bestIndices = curr indices
  end if
end loop
fetch the x-values in train data at bestIndices
store x-values into RBF centroids

Die Idee wird am besten durch Beispiel illustriert. Angenommen, besteht die Trainingsdaten aus der 24 Posten im Abbildung 1. Weiter angenommen, die Schleife zum ersten Mal durch die Verarbeitung der vier zufällig ausgewählte Indizes sind [0], [1], [2] und [3]. Diese entsprechen:

0: ( 1.537, -0.382,  1.317,  0.756)
  1: (-0.468,  2.346, -1.170, -1.048)
  2: ( 1.115,  0.164,  0.560,  0.370)
  3: ( 1.220,  0.436,  0.452,  0.241)

Dies sind die Kandidaten Zentroide. Die Idee ist, erhalten repräsentative X-Werte, was bedeutet, dass Sie nicht möchten, Werte, die eng beieinander liegen. So berechnen Sie einen gewissen Abstand zwischen diesen Kandidaten Zentroide. Hier gibt es viele mögliche Ansätze. Die Demo schätzt einen durchschnittlichen Abstand zwischen allen möglichen Paare aus Kandidaten Zentroide durch die Berechnung einer durchschnittlichen Entfernung zwischen angrenzende Paare von Kandidaten, statt berechnen eine durchschnittliche Entfernung zwischen alle möglichen Paare. In diesem Beispiel berechnet es die Abstände zwischen den Kandidaten [0] und [1], [1] und [2], sowie zwischen [2] und [3].

Ein gemeinsames Konzept für berechnen eine Entfernung ist Euklidische Distanz zu verwenden, die die Quadratwurzel aus der Summe der quadrierten Differenzen zwischen den Werten ist. (Hinweis: Das Demo-RBF-Netzwerk verwendet einen Gaußschen Kernel, der Euklidische Distanz verwendet, um versteckte Knoten lokale Ausgabewerte berechnen.) Das Demoprogramm verwendet jedoch eine Variation des Manhattan-Distanz, wo der Unterschied der absoluten Werte im Durchschnitt ist. So ist der Abstand zwischen Kandidaten [0] und [1]:

d = abs(1.537 - (-0.468)) + .
.
.
+ abs(0.756 - (-1.048)) / 4
  = 2.256

Generieren einer Reihe von Kandidaten Zentroide und berechnen eine geschätzte durchschnittliche Entfernung für den Satz von Kandidaten wiederholt eine angegebene Anzahl von Wiederholungen, und die Kandidaten mit den größten geschätzte durchschnittliche Entfernung als gesetztem Schwerpunkt RBF ausgewählt ist.

Beachten Sie, dass die Bestimmung RBF Netz Zentroide iterativ unbeaufsichtigt Training angesehen werden kann weil die Zielwerte (z. B. 0, 1, 0) in den Trainingsdaten benötigt oder verwendet nicht. Dies bedeutet, dass Zentroide schnell ermittelt werden können. Auch RBF Netz breiten, Gewichte und Bias-Werte können — theoretisch zumindest – viel schneller als äquivalenter neuronales Netz Gewichte und Bias-Werte berechnet werden. Dies gibt RBF Netze einen potenziellen Vorteil über neuronale Netze (aber wie Sie sehen werden, gibt es mehr zur Geschichte).

Während des Prozesses RBF Netz Zentroide zu bestimmen ist die Bestimmung der Kandidaten-Indizes eine interessante Subproblem. Das Demoprogramm verwendet einen cleveren-Algorithmus als Reservoir Probenahme. Die Idee ist, wählen Sie die erste mögliche n Indizes wahrscheinlichkeitstheoretisch ersetzen die ersten Indizes durch die verbleibenden möglichen Indizes:

private int[] DistinctIndices(int n, int range)
{
  // Reservoir sampling.
assumes rnd exists
  int[] result = new int[n];
  for (int i = 0; i < n; ++i)
    result[i] = i;
  for (int t = n; t < range; ++t) {
    int m = rnd.Next(0, t + 1);
    if (m < n) result[m] = t;
  }
  return result;
}

Obwohl die Methode kurz ist, ist es subtil. Alternativen sind mit einem Brute-Force-Ansatz, wo zufällige Indizes werden generiert und dann überprüft, ob alle Duplikate vorhanden sind.

RBF Netz breiten bestimmen

Die Input-Prozess-Output-Mechanismus der RBF-Netzwerk erfordert einen Wert für die Breite für jede versteckte Knoten. Es gibt viele Möglichkeiten für die Bestimmung der Werte für die Breite. Der einfachste Ansatz und verwendet das Demoprogramm ist eine gemeinsame Breite zu berechnen, die alle versteckten Verarbeitung Knoten verwenden können. Forschung in diesem Bereich eher trüb und Schlussfolgerungen sind manchmal widersprüchlich. Das Demoprogramm berechnet eine gemeinsame Breite als Durchschnitt euklidischer Abstand zwischen allen möglichen Paare aus Zentroide. In Pseudocode:

sumOfDists = 0.0
for each pair of centroids
  accumulate Euclidean distance between curr pair
end loop
return accumulated sumOfDists / number of pairs

Aufgrund meiner Erfahrung, ist die Wirksamkeit der RBF Netze extrem empfindlich auf die Werte für versteckte Knoten breiten verwendet. Untersuchungen zeigen, dass eine breite, die zu klein ist tendenziell die Trainingsdaten, führt zu schlechten Einstufung Genauigkeit zu passen. Eine breite, die zu groß ist tendenziell unter passen die Daten, die auch für schlechte Einstufung führt. Wenn Sie mit dem Demo-Code durch Manuelles Festlegen der Werte der RBF Netz breiten experimentieren, können Sie diesen Effekt in Aktion sehen.

Neben der Verwendung des durchschnittlichen Abstand zwischen Zentroide, Davg, für einen gemeinsamen versteckte Knoten Breite, Forschung auch empfiehlt (2 * Davg), oder (Davg / sqrt(2 * numHidden)), und viele andere Werte. Und anstatt einer gemeinsamen Breite, gibt es viele Möglichkeiten für die Berechnung verschiedener Breitenwerte für jeden versteckten Knoten. Meiner Meinung nach die hohe Empfindlichkeit von RBF Netze Breitenwerte, zusammen mit das verwandte fehlen überzeugende Forschungsergebnisse wie zu besten Compute Breitenwerte, sind die wichtigsten Nachteile der Verwendung von RBF Netze gegenüber Alternativen wie neuronalen Netzen und Support-Vector-Machines.

Bestimmung RBF Netz Gewichte und Voreingenommenheit

Nach der Festlegung Zentroide und breiten, besteht der letzte Schritt in der Ausbildung ein RBF-Netzwerk die Werte für die Gewichte und Voreingenommenheit einzuschätzen. Theoretisch RBF Netz Gewichte berechnen Sie können leicht und schnell, da lose sprechend, gibt es n Gleichungen mit n unbekannten Werten. Also, numerische Standardtechniken in der Theorie lässt sich für die Werte von Gewicht zu lösen.

Leider läuft in der Praxis mit standard-Techniken in vielen praktischen Problemen. Viele standard-Techniken zur Lösung von Gleichungen umfassen z. B. die Verwendung der Matrix-Inversion. Matrix-Inversion kann aus vielen Gründen fehlschlagen.

Anstatt eine deterministische aber möglicherweise spröde numerische Technik einzusetzen für RBF Netz Gewichte genau, verwendet das Demoprogramm Particle Swarm Optimization, um die besten Werte zu schätzen. PSO ist ein Meta heuristische basierend auf koordinierte Gruppenverhalten, wie Scharen von Vögeln oder Fischschwärme. In PSO hat ein Teilchen eine Position, die eine mögliche Lösung (den besten Satz der Gewicht-Werte in diesem Fall) darstellt. Jedes Teilchen hat eine Geschwindigkeit, die nächste Position des Partikels bestimmt.

PSO entsteht eine Reihe von Teilchen. Jeder Tick simulierten Zeit bewegt sich jedes Teilchen an eine neue Position auf der Grundlage des Partikels aktuelle Position und Geschwindigkeit, die bekanntesten historischen Position des Partikels und die bekanntesten historischen Position eines der Teilchen. Hier ist die PSO in hochrangigen Pseudocode:

set number of particles
set maxIterations
initialize all particles to random positions
loop maxIterations times
  for each particle
    update curr particle's velocity
    use new velocity to compute new position
    compute error for new position
    check if new particle best position
    check if new best position for all particles
  end for
end loop
return best position found by any particle

PSO ist ein faszinierendes Thema aus eigenem Recht.Erfahren Sie mehr darüber lesen meinem Artikel vom August 2011 "Particle Swarm Optimization" (msdn.microsoft.com/magazine/hh335067).PSO erfordert die Angabe von mehreren freien Param­hielt, einschließlich Gewicht-Konstanten, die den relativen Einfluss der aktuellen Position eines Teilchens zu steuern best, historische und am besten globalen historischen Position.PSO erfordert außerdem die Festlegung der Anzahl der Partikel, die maximale Anzahl von Iterationen und optional ein Fehlerschwellenwert für ein vorzeitiges Ausscheiden des Algorithmus.Sie können experimentieren mit diesen Faktoren, die mit dem Demo-Code.

Neben PSO und traditionellen numerischen Methoden gibt es viele Alternativen für die Suche nach RBF Netz Gewichte, einschließlich einfachen Farbverlauf Abstieg und reellwertige genetische Algorithmen.Obwohl die Theorie der RBF Netze untersucht wurde ziemlich Exten­unauffällig, gibt es relativ wenige überzeugende Forschungsergebnisse über die vergleichende Wirksamkeit der verschiedenen Trainingsmethoden.

Zusammenfassung

Demo-Programm-Code zusammen mit der Erklärung, die hier vorgestellten solltest du eine solide Grundlage für die Untersuchung von RBF Netze geben.Obwohl RBF Netze in der Forschungsgemeinschaft bekannt sind, scheinen sie nicht sehr oft in der Software-Entwickler-Community im Vergleich zu Alternativen wie neuronales Netz-Klassifikatoren, Naive Bayes Klassifikatoren und logistische Regression verwendet werden.Ein möglicher Grund dafür könnte die Knappheit der praktische Beispiele.Ein weiterer möglicher Grund ist die Unsicherheit, die grundlegende RBF Netz Faktoren, vor allem diejenigen im Zusammenhang für die Berechnung der RBF Netz breiten.Meiner Meinung nach gibt es keine solide Forschungsergebnisse zur Beantwortung der Frage ob RBF Netze effektiver, weniger wirksam oder alternative Computerlernen Techniken ungefähr gleichwertig sind.

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

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