April 2017
Band 32, Nummer 4
Dieser Artikel wurde maschinell übersetzt.
Test Run: Kernelperzeptronen unter Verwendung von C#
Durch James McCaffrey
.jpg "James McCaffrey")
Ein Kernel-Perceptron ist eine Machine learning (ML)-Klassifizierung, die für binäre Vorhersagen verwendet werden kann. Ein Kernel-Perceptron kann z. B. das Geschlecht einer Person Vorhersagen (männlich =-1, Weiblich = + 1) basierend auf Alter, Einkommen, Höhe und Gewicht. Kernel perzeptrons sind eine erweiterte Variante der normalen perzeptrons und komplexere Daten behandeln können.
Eine gute Möglichkeit, worauf dieser Artikel ist ist auf einen Blick auf das Demoprogramm in Abbildung 1 und zugehörige Daten in Abbildung 2. Das Ziel des Demoprogramms vorherzusagen, die Klasse ist-1 oder + 1, dummy Eingabedaten, die nur zwei vorhersagevariablen, X0 und x 1. Ist z. B. die ersten Trainingsdaten Element (2.0, 3.0, -1), d. h. wenn die Eingabewerte X0 = 2.0 und X1 = 3.0, die richtige Klasse ist-1.
.png "Kernel-Perceptron-Demo")
Abbildung 1 Kernel Perceptron Demo
.png "Kernel Perceptron Trainingsdaten")
Abbildung 2 Kernel Perceptron Trainingsdaten
Die Schulung von Datenpunkten 21 haben eine zirkuläre Geometrie, was bedeutet, dass einfache lineare Klassifizierung Techniken, wie gewöhnliche perzeptrons oder logistische Regression außer Kraft gesetzt werden. Diese Daten werden nicht linear Trennbar bezeichnet.
Das Demoprogramm verwendet die Trainingsdaten, um ein Vorhersagemodell mithilfe einer Kernel-Perceptron zu erstellen. Im Gegensatz zu vielen Vorhersagemodelle, die aus einem Satz von numerischen Werten, die als Gewichtungen bezeichnete bestehen, erstellt ein Vorhersagemodell Kernel einen Satz von Leistungsindikatorwerten, eines für jedes Datenelement Schulung. Das Demoprogramm zeigt die Werte der Zähler für die ersten beiden Datenelemente (1 und 2) und die letzten zwei Datenelemente (0 und 1).
Nach dem Training prognostiziert Kernel Perceptron-Modell alle 21 Datenelemente korrekt ist, die zu erwarten ist. Das trainierte Modell gilt für vier neue Prüfung Datenelemente, die nicht während des Trainings verwendet wurden. Das erste Testelement hat Eingaben (2.0, 4.0) und eine Klasse von-1. Das Vorhersagemodell prognostiziert ordnungsgemäß dieses Elements. Das Modell vorhergesagt insgesamt ordnungsgemäß drei der vier Testelemente 0,75 Genauigkeit.
Hinter den Kulissen verwendet der Kernel-perzeptron eine Funktion namens Kernels radiale-Funktion (RB). Die Kernelfunktion erfordert einen Parameter namens Sigma. Der Wert der Sigma muss bestimmt werden, durch ausprobieren und Sigma = 1.5 in der Demo. Beachten Sie, dass durch Festlegen von Sigma 0,5, das Demoprogramm Genauigkeit von 100 Prozent erreichen. Ich verwendete Sigma = 1.5 um darauf hinweisen, dass bei den meisten Datasets Genauigkeit von 100 Prozent erzielen wird nicht.
Dieser Artikel setzt Sie über fortgeschrittene oder höher Programmierkenntnisse verfügen, jedoch nicht davon ausgegangen, dass Sie sich Kernel perzeptrons auskennen. Das Demoprogramm ist mit c# codiert, aber Sie haben keine Probleme, die den Code in einer anderen Sprache wie z. B. Python oder JavaScript Umgestaltung, wenn Sie möchten. Alle Schlüssel Demo-Code, mit Ausnahme der Daten hartcodiert und einige Anweisungen anzuzeigen, wird in diesem Artikel vorgestellten. Vollständige Demo-Quellcode an, einschließlich Daten, ist im begleitenden Download verfügbar.
Grundlegendes zu Kernelfunktionen
Um zu erfahren, Kernel-perzeptrons müssen Sie den Kernel-Funktionen im Allgemeinen verstehen. Es gibt viele Kernelfunktionen, aber die am häufigsten verwendeten eine und den Typ im Demoprogramm verwendet wird RB Kernel aufgerufen. Die Kernelfunktion RB akzeptiert zwei Vektoren (d. h. Arrays) und einen Parameter namens Sigma und einen einzelnen Wert zwischen 0,0 und 1,0, ein Maß für die Ähnlichkeit zwischen den beiden Arrays zurückgibt. Ein Rückgabewert exakt 1,0 bedeutet, dass die beiden Arrays sind identisch. Weniger ähnlich wie die beiden Arrays sind, je kleiner der Wert der RB, annähert, aber nie ganz erreichen 0,0.
Die Gleichung für RB lautet:
K(x1, x2) = exp( - || x1 - x2 ||^2 / (2 * sigma^2) )
Hier steht K für Kernel, X1 und X2 sind zwei Arrays, die die gleiche Länge aufweisen, Sigma ist eine kostenlose-Parameter mit dem Wert 1.0 oder 1.5 die || Gibt an, euklidischen Abstand und exp bedeutet die Eulersche Zahl (e) potenziert mit einem Exponenten.
Die RB wird am besten anhand eines Beispiels erläutert. Nehmen wir an X1 = ("2.0", "1.0", "3.0") und X2 = (0.0, 1.0, 5.0), und Sigma ist 1.0. Zuerst berechnen Sie den quadrierten euklidischen Abstand:
|| x1 - x2 ||^2 = (2.0 - 0.0)^2 + (1.0 - 1.0)^2 + (3.0 - 5.0)^2
= 4.0 + 0.0 + 4.0
= 8.0
Anschließend Teilen Sie die Quadrat der Entfernung von 2 Mal Sigma Quadrat:
8.0 / (2 * (1.0)^2) = 8.0 / 2.0 = 4.0
Zuletzt, nehmen Sie Eulersche Zahl (e = ungefähr 2,71828) und erhöhen Sie sie auf den negativen Wert des vorherigen Ergebnis:
K = e^(-4.0) = 0.0183
Beachten Sie, dass wenn X1 X2 entspricht, die Quadrat der Euklidische Entfernung 0, und dann geteilt durch 2 Mal Sigma Quadrat ist 0, und e potenziert mit 0. ist 1.0. Die weniger ähnlich X1 und X2 sind, die größere quadratischen Differenz ist, und e potenziert mit einem negativen Wert für große ruft sehr klein, 0,0 annähert. Je größer der Wert der Sigma ist, desto größer ist als der Wert von K K weiterhin variiert jedoch von 1,0 (gleich Vektoren) auf 0,0 exklusive (sehr unterschiedliche Vektoren). Die Reihenfolge der Arrayparameter ist unerheblich, daher K (X1, X2) = K (X2, X1).
Das Demoprogramm definiert die Kernelfunktion RB als:
static double Kernel(double[] d1, double[] d2, double sigma) {
double num = 0.0;
for (int i = 0; i < d1.Length - 1; ++i)
num += (d1[i] - d2[i]) * (d1[i] - d2[i]);
double denom = 2.0 * sigma * sigma;
double z = num / denom;
double result = Math.Exp(-z);
return result;
}
Die Funktion wird davon ausgegangen, dass die letzte Zelle der einzelnen Arrays die klassenbezeichnung (+ 1 oder-1) enthält, damit die letzte Zelle in der Berechnung enthalten ist. Es gibt mehrere andere Kernelfunktionen, die mit einem Kernel-Perceptron, einschließlich der linearen Kernel, Polynomen Kernel, Fisher-Kernel und Sigmoidfunktion Kernel verwendet werden können. Berechnen der Kernel-Funktionen ist relativ einfach. Was jedoch nicht offensichtlich ist, ist darin, dass Kernel-Funktionen einige bemerkenswerten mathematischen Eigenschaften, mit denen einfache Klassifizierer, wie eine normale Perceptron, in Klassifizierer umgewandelt werden, die nicht linear trennbare Daten verarbeiten kann.
Grundlegendes zu normalen Perzeptrons
Eine gewöhnliche Perceptron kann binäre Klassifizierung für einfache, linear Trennbar Daten ausführen. Eine gewöhnliche Perceptron besteht aus einem Satz von Gewichtungen, in denen die Anzahl der Gewichtungen gleich der Anzahl der Vorhersagewerte und eine zusätzliche spezielle Gewichtung Bias aufgerufen. Nehmen wir beispielsweise an, Sie haben ein binäres klassifikationsproblem, in denen drei vorhersagevariablen bestehen. Und angenommen, die Gewichte Perceptron w0, 1.5 w1 = 1.1 und w2 = =-3.0, und drei vorhersagevariablen Werte X0 = 4.0, X1 3.0 = X2 = 5.0 und die Verschiebung ist b = 2.5. Die Vorhersage wird dem Vorzeichen (positiv oder negativ), der die Summe der Produkte für die Gewichtung und Eingabewerte sowie die Bias berechnet:
sum = (w0)(x0) + (w1)(x1) +(w2)(x2) + b
= (1.5)(4.0) + (1.1)(3.0) + (-3.0)(5.0) + 2.5
= 6.0 + 3.3 + (-15.0) + 2.5
= -3.2
prediction = sign(sum)
= -1
Im Grunde genommen also ganz einfach. Aber woher die Gewichtungen und Bias Werte stammen aus? Sie nehmen Trainingsdaten, die Eingabe-und die richtigen Werte bekannt ist und dann eine mathematische Optimierungsalgorithmus verwenden, um Werte für die Gewichtungen und Bias zu finden, damit die berechnete Klassenwerte genau die bekannten Klasse falsch-Werte übereinstimmen.
Beachten Sie, dass in Perceptron verwendet, der Biaswert häufig berücksichtigt wird, um eine reguläre Gewichtung ein dummy Eingabewert 1.0 zugeordnet werden. Verwenden das Schema, im vorherigen Beispiel müsste Eingaben x = (1.0, 4.0, 3.0, 5.0) und das Gewicht w = (2.5, 1.5, 1.1,-3.0), zurückgegeben wird, die folgenden (die das gleiche Ergebnis wie zuvor):
sum = (2.5)(1.0) + (1.5)(4.0) + (1.1)(3.0) + (-3.0)(5.0)
= -3.2
Anders gesagt kann ein Biaswert Perceptron explizit oder implizit sein. Sie sollten nicht die Verwirrung unterschätzen dies führen kann.
Nun können leider gewöhnliche perzeptrons nur linear trennbare Daten klassifizieren, die sie sehr begrenzten in Übung macht. Jedoch durch eine Kernelfunktion in Verbindung mit einem Perceptron verwenden, ist es möglich, eine Klassifizierung zu erstellen, die mit nicht linear Trennbar Daten, z. B. die Demodaten in arbeiten Abbildung 2.
Der Kernel-Perceptron-Algorithmus
Auf den ersten Blick Kernel Perceptron-Algorithmus wird nicht im Zusammenhang mit der normalen Perceptron-Algorithmus, aber tatsächlich sind die beiden tief verknüpft. Angenommen, es sind nur vier trainingsdatenelemente: td [0] = (2.0, 3.0, -1), td [1] = (3.0, 2.0, + 1), td [2] = (3.0, 5.0, + 1), td [3] = (4.0, 3.0, -1). Und angenommen trainierten Kernel Perceptron-Modell Sie falsche Indikatorwerte ein = (1, 2, 3, 4) zugewiesen. (Verwendet für die falsche Leistungsindikatoren, da in Forschungsliteratur sie in der Regel die griechischen Symbol-Sigma angegeben sind die ähnelt Kleinbuchstaben "a" Englisch "a".)
Die Klasse der neuen Daten Artikel X = (3.0, 6.0) Vorhersagen, berechnen Sie die gewichtete Summe (durch einen Wert und die richtige Schulung für Artikel) der Kernelfunktion auf das neue Datenelement und jedes der vier Training Elemente angewendet:
K(td[0], x) = 0.1083
K(td[1], x) = 0.0285
K(td[2], x) = 0.8007
K(td[3], x) = 0.1083
sum = (1)(0.1083)(-1) + (2)(0.0285)(+1) + (3)(0.8007)(+1) + (4)(0.1083)(-1)
= +1.9175
prediction = sign(sum)
= +1
Etwas erwähnt Sinne der Kernel-perzeptron untersucht die Ähnlichkeit des Datenelements klassifiziert werden und alle Datenelemente für Training und aggregiert die Werte für die Ähnlichkeit – verwenden die falschen Leistungsindikatoren als Gewichtungen – in einen einzelnen Wert, der vorhergesagte Klasse angibt.
Um Kernel Perceptron Vorhersagen benötigen Sie an die Trainingsdaten und die zugehörigen falsche Indikatorwerte. Wenn Sie eine normale Perceptron trainieren, verwenden Sie einen iterativen Prozess. In jeder Iteration verwenden Sie die aktuellen Werte der Gewichtungen und Bias, um eine vorhergesagte Klasse zu berechnen. Wenn die vorhergesagte Klasse falsch ist (die Klasse in den Trainingsdaten nicht übereinstimmen) Sie die Gewichtungen ein bisschen so anpassen, dass die vorhergesagte Klasse näher auf den Wert der bekannten Klasse falsch ist.
In einem Perceptron Kernel verwenden Sie ein ähnliches iterative Prozess, sondern Schulung Gewichtungswerte anpassen, wenn eine berechnete Klasse liegt, erhöhen Sie den falschen Indikator für das aktuelle Element der Schulung. Wirklich bemerkenswert! Mathematische Machbarkeitsstudie warum dies funktioniert ist erstaunlich ansprechende und finden Sie im Wikipedia-Eintrag zu Kernel perzeptronenebenen.
In Pseudocode ausgedrückt, ist der Kernel Perceptron Trainingsalgorithmus:
loop a few times
for each curr training item, i
for each other training item, j
sum += a[j] * K(td[i], td[j], sigma) * y[j];
end-for
pred = sign(sum)
if (pred is wrong) increment a[i]
end-for
end-loop
Die beiden Parameter in der Trainingsalgorithmus erforderlich sind, werden die Anzahl der Iterationen und den Wert der Sigma für die Kernelfunktion. Beide Werte müssen durch ein Bit Versuch und Irrtum bestimmt werden. Das Demoprogramm 10 Mal durchlaufen und 1.5 Sigma verwendet.
Beachten Sie, dass der Trainingsalgorithmus gewöhnliche Perceptron Trainingsdaten verwendet, um die Gewichtungen und Bias Werte zu generieren und dann die Trainingsdaten konzeptionell verwirft. Der Kernel Perceptron Trainingsalgorithmus generiert falsche Indikatorwerte, die Gewichte mathematisch miteinander verknüpft, aber der Algorithmus muss zu die Trainingsdaten halten, um vorhersagen zu treffen.
Struktur des Demoprogramms
Die allgemeine Struktur des Demoprogramms mit ein paar kleinen Änderungen, um Platz zu sparen werden im Abbildung 3. Ich verwendet eine statische Methode Stil statt auf einer objektorientierten Programmierstil, aus Gründen der Einfachheit. Die Main-Methode hat die Steuerelementlogik. Es gibt zwei Hilfsmethoden Kernel und Genauigkeit.
Abbildung 3 Kernel Perceptron Demo Programmstruktur
using System;
namespace KernelPerceptron
{
class KernelPerceptronProgram
{
static void Main(string[] args)
{
Console.WriteLine("Begin demo ");
int numFeatures = 2;
Console.WriteLine("Goal is classification(-1/+1) ");
Console.WriteLine("Setting up 21 training items ");
double[][] trainData = new double[21][];
trainData[0] = new double[] { 2.0, 3.0, -1 };
trainData[1] = new double[] { 2.0, 5.0, -1 };
. . .
trainData[20] = new double[] { 5.0, 6.0, +1 };
int numTrain = trainData.Length;
double[][] testData = new double[4][];
testData[0] = new double[] { 2.0, 4.0, -1 };
. .
testData[3] = new double[] { 5.5, 5.5, +1 };
int[] a = new int[trainData.Length];
int maxEpoch = 10;
int epoch = 0;
double sigma = 1.5; // for the kernel function
Console.WriteLine("Starting train, sigma = 1.5 ");
...
Console.WriteLine("Training complete ");
double trainAcc = Accuracy(trainData, a,
trainData, sigma, false); // silent
Console.WriteLine("Accuracy = " +
trainAcc.ToString("F4"));
Console.WriteLine("Analyzing test data: ");
double testAcc = Accuracy(testData, a,
trainData, sigma, true); // verbose
Console.WriteLine("End kernel perceptron demo ");
Console.ReadLine();
} // Main
static double Kernel(double[] d1, double[] d2,
double sigma) { . . }
static double Accuracy(double[][] data, int[] a,
double[][] trainData, double sigma, bool verbose)
{ . . }
} // Program
} // ns
Das Demoprogramm die Code, Visual Studio gestartet ich und erstellt eine neue C#-Konsolenanwendungsprogramm und mit dem Namen KernelPerceptron. Ich verwendete Visual Studio 2015, aber das Demoprogramm hat keine nennenswerten .NET Framework-Abhängigkeiten, daher kann jede aktuelle Version verwendet werden.
Nach dem Laden des Vorlagencode in Editor-Fenster, ich mit der rechten Maustaste auf die Datei "Program.cs" im Fenster Projektmappen-Explorer die Datei in KernelPerceptronProgram.cs umbenannt, und Visual Studio die für mich automatisch die Programmklasse umbenennen. Am Anfang der Vorlage generierte Code habe ich gelöscht unnötige using-Anweisungen, lassen nur die eine, die Namespace der obersten Ebene System verweist.
Die Main-Methode richtet die Trainings- und Daten wie folgt:
int numFeatures = 2;
double[][] trainData = new double[21][];
trainData[0] = new double[] { 2.0, 3.0, -1 };
. .
trainData[20] = new double[] { 5.0, 6.0, +1 };
int numTrain = trainData.Length;
double[][] testData = new double[4][];
testData[0] = new double[] { 2.0, 4.0, -1 };
. .
testData[3] = new double[] { 5.5, 5.5, +1 };
Die Demo verwendet zwei vorhersagevariablen (auch als Funktionen in der ML-Terminologie) zur Vereinfachung, aber Kernel perzeptrons kann eine beliebige Anzahl von vorhersagevariablen verarbeiten. Die Daten hartcodiert sind jedoch in einem nicht-Demoszenario würden Sie wahrscheinlich die Daten aus einer Textdatei laden. Diese Demo verwendet-1 und + 1, um die beiden möglichen Klassen darstellen. Diese Codierung ist typisch für perzeptrons, jedoch Klassen können werden codiert als 0 und 1 stattdessen (obwohl diese Codierung einige Änderungen an der Codelogik erfordern würde).
Schulung ist für diese Anweisung vorbereitet:
int[] a = new int[numTrain]; // "Wrong counters"
double sigma = 1.5; // For the kernel function
int maxEpoch = 10;
int epoch = 0;
Arrays eine enthält den falschen Leistungsindikatoren für jedes Element der Schulung und Sigma ist die kostenlose Parameter für die Kernelfunktion RB. Der Wert der Sigma und die Schleifensteuerungsvariable MaxEpoch wurden durch systematisches bestimmt. Funktionswerte weiter, alle möglichen Kernel vorab berechnet und in einer Matrix gespeichert:
double[][] kernelMatrix = new double[numTrain][];
for (int i = 0; i < kernelMatrix.Length; ++i)
kernelMatrix[i] = new double[numTrain];
for (int i = 0; i < numTrain; ++i) {
for (int j = 0; j < numTrain; ++j) {
double k = Kernel(trainData[i], trainData[j], sigma);
kernelMatrix[i][j] = kernelMatrix[j][i] = k;
}
}
Die Idee besteht darin, dass während des Trainings die Kernel-Ähnlichkeit zwischen alle Paare von Schulung Elemente wird mehrmals verwendet werden, damit es sinnvoll, diese Werte nicht im Voraus berechnen.
Der Lernschleife ist:
while (epoch < maxEpoch) {
for (int i = 0; i < numTrain; ++i) {
// Get "desired" correct class into di
for (int j = 0; j < numTrain; ++j) {
// Get "other" desired class into dj
// Compute y = weighted sum of products
}
if ((di == -1 && y >= 0.0) || (di == 1 && y <= 0.0))
++a[i]; // increment wrong counter
}
++epoch;
}
Das aktuelle Element der Schulung mit diesem Code wird die gewünschte richtige-Klasse (-1 oder + 1) entnommen:
int di = (int)trainData[i][numFeatures];
Ich verwende hier di gewünschten Wert stehen. Zwei andere allgemeine Variablennamen sind t (für Zielwert) und y (die nur für die allgemeine Ausgabe steht).
Die inneren geschachtelten for-Schleife, die die gewichtete Summe der Kernel Werte berechnet ist das Herzstück des Kernel Perceptron-Learning-Algorithmus:
double y = 0.0; // Weighted sum of kernel results
for (int j = 0; j < numTrain;; ++j) {
int dj = (int)trainData[j][numFeatures];
double kern = kernelMatrix[i][j];
y += a[j] * dj * kern;
}
Der Code der Demo berechnet Kernel für alle Paare von Schulung Elemente. Aber wenn ein zugeordneten falscher Leistungsindikator den Wert 0 hat, wird der Product-Begriff 0 sein. Daher ist eine wichtige Optimierung der optionale, wenn die Anzahl der Elemente der Schulung groß ist die Berechnung des Kernels überspringen, wenn der Wert der [i] bzw. eine [j] 0 ist. Training-Elemente, die falsche den Zählerwert 0 enthalten, können, vollständig entfernt werden.
Eine explizite vorhergesagte Klasse Berechne ich nicht, weil dies einfacher zu überprüfen, ob die vorhergesagte Klasse direkt liegt:
if ((di == -1 && y >= 0.0) || (di == 1 && y <= 0.0))
++a[i]; // wrong counter for curr data
Müssen Sie darauf achten, überprüfen Sie y > = 0,0 oder y < = 0,0 statt y > 0,0 oder y < 0,0, da beim ersten Durchlaufen der Schleife Training alle Werte in falsche der ein Array sind 0 (null) und haben daher die gewichteten Summe Produkte 0,0.
Nachdem der Lernschleife beendet wird, wird der Kernel-perzeptron effektiv von den Trainingsdaten, die falsch-Counter-Array und das Sigma RB Kernel-Parameter definiert.
Erstellen von Vorhersagen
Hilfsfunktion Genauigkeit von Vorhersagen. Die Definition der Methode beginnt mit:
static double Accuracy(double[][] data, int[] a,
double[][] trainData, double sigma, bool verbose)
{
int numFeatures = data[0].Length - 1;
double[] x = new double[numFeatures];
int numCorrect = 0;
int numWrong = 0;
...
Der Parameter mit dem Namen Data enthält eine Array von Arrays Stil Matrix der Daten ausgewertet. Parameterarray a enthält die falsche Indikatorwerte Schulung generiert.
Im Text der Funktion ähnelt der Tastencode genau den Trainings-Code, anstatt einen falschen Indikator für die aktuelle Trainingsdaten Element für eine unzutreffende Vorhersage getroffen, eine einzelne NumWrong oder NumCorrect Variablen erhöht wird:
if ((di == -1 && y >= 0.0) || (di == 1 && y <= 0.0))
++numWrong;
else
++numCorrect;
Nachdem alle Datenelemente untersucht untersucht wurden, wird der Prozentsatz der richtigen Vorhersagen zurückgegeben:
return (1.0 * numCorrect) / (numCorrect + numWrong);
Die Genauigkeit-Methode hat einen verbose-Parameter, wodurch bei "true" Diagnoseinformationen angezeigt werden:
if (verbose == true)
{
Console.Write("Input: ");
for (int j = 0; j < data[i].Length - 1; ++j)
Console.Write(data[i][j].ToString("F1") + " ");
// Etc.
}
Verwenden den Code aus der Methode Genauigkeit, könnten Sie eine dedizierte Predict-Methode schreiben, die akzeptiert ein Array von x-Werte (ohne eine bekannte richtige-Klasse), die Trainingsdaten, die falsch-Counter-Array und den RB Kernel Sigma-Wert, der + 1 oder-1 Vorhersagewert zurückgibt.
Zusammenfassung
Kernel-perzeptrons sind nicht sehr häufig verwendet. Dies ist größtenteils auf die Tatsache, dass eine leistungsfähigere binären klassifikationstechniken verfügbar sind, ist eine viel Mysterium ML Kernelmethoden im Allgemeinen um. Wenn Sie eine Internetsuche nach Kernel perzeptrons tun, finden Sie viele Verweise, die die schöne mathematische Beziehung zwischen den normalen perzeptrons und Kernel-perzeptrons, aber sehr wenige praktische Implementierungsinformationen anzuzeigen. Meiner Meinung nach ist der wichtigste Vorteil von Kernel-perzeptrons verstehen, dass das wissen es erleichtert, komplexere ML-Kernel-Methoden kennen (die ich in einem zukünftigen Artikel vorstellen werde).
Nachteile der Kernel-perzeptrons ist, dass um eine Vorhersage treffen, das gesamte Trainingsdataset (mit Ausnahme der Elemente, die falsche den Zählerwert 0 enthalten) untersucht werden müssen. Ist der Trainingssatz große, könnte dies in Echtzeit in einigen Szenarien nicht realisierbar Vorhersagen.
Kernel-perzeptrons sind sicherlich die einfachste Art des Kernelmethoden. Der Kernel-Trick kann auf andere linearen Klassifizierern angewendet werden. In der Tat ist die Kernel-Lösung eine maximale Rand linearen Klassifizierung die Grundlage für Support Vector Machine (SVM) Klassifizierer, die in den späten 1990ern beliebt waren.
Dr. James McCaffreyist 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.
Unser Dank gilt den folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: ANI Anirudh und Chris Lee