web-dev-qa-db-de.com

Scikit Lernen Sie die SVC-Entscheidungsfunktion und prognostizieren

Ich versuche, die Beziehung zwischen Decision_function und Predict zu verstehen. Dies sind Instanzmethoden von SVC ( http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html ). Bisher habe ich erfahren, dass die Entscheidungsfunktion paarweise Ergebnisse zwischen den Klassen zurückgibt. Ich hatte den Eindruck, dass Predict die Klasse auswählt, die die paarweise Punktzahl maximiert, aber ich habe dies getestet und unterschiedliche Ergebnisse erzielt. Hier ist der Code, mit dem ich versuchte, die Beziehung zwischen den beiden zu verstehen. Zuerst habe ich die paarweise Score-Matrix erstellt, und dann habe ich die Klasse ausgedruckt, deren maximaler paarweiser Score sich von der Klasse unterscheidet, die von clf.prictict vorhergesagt wurde.

        result = clf.decision_function(vector)[0]
        counter = 0
        num_classes = len(clf.classes_)
        pairwise_scores = np.zeros((num_classes, num_classes))
        for r in xrange(num_classes):
            for j in xrange(r + 1, num_classes):
                pairwise_scores[r][j] = result[counter]
                pairwise_scores[j][r] = -result[counter]
                counter += 1

        index = np.argmax(pairwise_scores)
        class = index_star / num_classes
        print class
        print clf.predict(vector)[0]

Kennt jemand die Beziehung zwischen diesen Vorhersagen und Decision_function?

44
Peter Tseng

Ich verstehe Ihren Code nicht vollständig, aber gehen wir das Beispiel der Dokumentationsseite durch, auf die Sie verwiesen haben:

import numpy as np
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
from sklearn.svm import SVC
clf = SVC()
clf.fit(X, y) 

Wenden wir nun sowohl die Entscheidungsfunktion als auch die Vorhersage auf die Proben an:

clf.decision_function(X)
clf.predict(X)

Die Ausgabe, die wir erhalten, ist:

array([[-1.00052254],
       [-1.00006594],
       [ 1.00029424],
       [ 1.00029424]])
array([1, 1, 2, 2])

Und das ist leicht zu interpretieren: Die Desion-Funktion sagt uns, auf welcher Seite der vom Klassierer erzeugten Hyperebene wir sind (und wie weit wir davon entfernt sind). Basierend auf diesen Informationen beschriftet der Schätzer dann die Beispiele mit dem entsprechenden Etikett.

23
Martin Böschen

Wenn Sie decision_function() aufrufen, erhalten Sie die Ausgabe von jedem der paarweisen Klassifizierer (n * (n-1)/2 Zahlen insgesamt). Siehe Seiten 127 und 128 von "Support-Vektor-Maschinen für die Musterklassifizierung" .

Jeder Klassifizierer stimmt ab, was die richtige Antwort ist (basierend auf dem Vorzeichen der Ausgabe dieses Klassifizierers); predict() gibt die Klasse mit den meisten Stimmen zurück.

14
RomanCobra

Für interessierte interessiere ich ein schnelles Beispiel für die predict-Funktion, die von C++ ( hier ) in Python übersetzt wurde:

# I've only implemented the linear and rbf kernels
def kernel(params, sv, X):
    if params.kernel == 'linear':
        return [np.dot(vi, X) for vi in sv]
    Elif params.kernel == 'rbf':
        return [math.exp(-params.gamma * np.dot(vi - X, vi - X)) for vi in sv]

# This replicates clf.decision_function(X)
def decision_function(params, sv, nv, a, b, X):
    # calculate the kernels
    k = kernel(params, sv, X)

    # define the start and end index for support vectors for each class
    start = [sum(nv[:i]) for i in range(len(nv))]
    end = [start[i] + nv[i] for i in range(len(nv))]

    # calculate: sum(a_p * k(x_p, x)) between every 2 classes
    c = [ sum(a[ i ][p] * k[p] for p in range(start[j], end[j])) +
          sum(a[j-1][p] * k[p] for p in range(start[i], end[i]))
                for i in range(len(nv)) for j in range(i+1,len(nv))]

    # add the intercept
    return [sum(x) for x in Zip(c, b)]

# This replicates clf.predict(X)
def predict(params, sv, nv, a, b, cs, X):
    ''' params = model parameters
        sv = support vectors
        nv = # of support vectors per class
        a  = dual coefficients
        b  = intercepts 
        cs = list of class names
        X  = feature to predict       
    '''
    decision = decision_function(params, sv, nv, a, b, X)
    votes = [(i if decision[p] > 0 else j) for p,(i,j) in enumerate((i,j) 
                                           for i in range(len(cs))
                                           for j in range(i+1,len(cs)))]

    return cs[max(set(votes), key=votes.count)]

Es gibt viele Eingabeargumente für predict und decision_function. Beachten Sie jedoch, dass diese beim Aufruf von predict(X) intern vom Modell verwendet werden. Tatsächlich sind alle Argumente nach dem Anpassen innerhalb des Modells verfügbar:

# Create model
clf = svm.SVC(gamma=0.001, C=100.)

# Fit model using features, X, and labels, Y.
clf.fit(X, y)

# Get parameters from model
params = clf.get_params()
sv = clf.support_vectors
nv = clf.n_support_
a  = clf.dual_coef_
b  = clf._intercept_
cs = clf.classes_

# Use the functions to predict
print(predict(params, sv, nv, a, b, cs, X))

# Compare with the builtin predict
print(clf.predict(X))
12
bcorso

Für das One-vs-One-Szenario mit mehreren Klassen unter datascience.sx gibt es ein wirklich Nice Q & A :

Frage

Ich habe einen Multiclass-SVM-Klassifizierer mit den Bezeichnungen 'A', 'B', 'C', 'D'.

Dies ist der Code, den ich verwende:

>>>print clf.predict([predict_this])
['A']
>>>print clf.decision_function([predict_this])
[[ 185.23220833   43.62763596  180.83305074  -93.58628288   62.51448055  173.43335293]]

Wie kann ich die Ausgabe der Entscheidungsfunktion verwenden, um die Klasse vorherzusagen (A/B/C/D) mit der höchsten Wahrscheinlichkeit und wenn möglich der Wert? ICH haben https://stackoverflow.com/a/20114601/7760998 besucht, es ist jedoch für binäre Klassifizierer und konnte keine gute Ressource finden, die erläutert die Ausgabe von decision_function für Multiclass-Klassifikatoren mit Form ovo (Eins-gegen-Eins).

Bearbeiten:

Das obige Beispiel bezieht sich auf die Klasse 'A'. Für eine andere Eingabe den Klassifizierer prognostizierte 'C' und gab folgendes Ergebnis in decision_function

[[ 96.42193513 -11.13296606 111.47424538 -88.5356536 44.29272494 141.0069203 ]]

Für eine andere Eingabe, die der Klassifikator als 'C' vorausgesagt hat, wurde __. das folgende Ergebnis von decision_function,

[[ 290.54180354 -133.93467605  116.37068951 -392.32251314 -130.84421412   284.87653043]]

Wäre es ovr (one-vs-rest) gewesen, würde es durch die Auswahl von .__ einfacher werden. Einer mit einem höheren Wert, aber in Ovo (Eins-vs-Eins) befinden sich (n * (n - 1)) / 2-Werte in der Ergebnisliste.

Wie lässt sich ableiten, welche Klasse basierend auf der Entscheidung ausgewählt wird Funktion?

Antworten

Ihr Link verfügt über ausreichende Ressourcen, also gehen wir durch:

Wenn Sie decision_function () aufrufen, erhalten Sie die Ausgabe von jedem der paarweisen Klassifizierer (n * (n-1)/2 Zahlen insgesamt). Siehe Seiten 127 und 128 von "Support Vector Machines für die Musterklassifizierung".

Klicken Sie auf den Link "Seite 127 und 128" (hier nicht dargestellt, jedoch in der Antwort für Stackoverflow). Das solltest du sehen:

enter image description here

  • Die SVM-Implementierung von Python verwendet one-vs-one. Genau davon spricht das Buch.
  • Für jeden paarweisen Vergleich messen wir die Entscheidungsfunktion
  • Die Entscheidungsfunktion ist nur die reguläre binäre SVM-Entscheidungsgrenze

Was hat das mit deiner Frage zu tun?

  • clf.decision_function () gibt Ihnen für jeden paarweisen Vergleich $ D $
  • Die Klasse mit den meisten Stimmen gewinnt

Zum Beispiel,

[[96.42193513 -11.13296606 111.47424538 -88.5356536 44.29272494 141.0069203]]

vergleicht:

[AB, AC, AD, BC, BD, CD]

Wir kennzeichnen jeden von ihnen mit dem Zeichen. Wir bekommen:

[A, C, A, C, B, C]

Zum Beispiel ist 96.42193513 positiv und somit ist A das Label für AB.

Jetzt haben wir drei C, C wäre Ihre Vorhersage. Wenn du mein .__ wiederholst. Für die beiden anderen Beispiele erhalten Sie Pythons Prognose. Versuch es!

8
serv-inc

Sie haben wahrscheinlich eine etwas komplizierte mathematische Beziehung. Wenn Sie jedoch den decision_function im LinearSVC-Klassifizierer verwenden, wird die Beziehung zwischen diesen beiden klarer! Denn dann gibt Ihnen decision_function Bewertungen für jede Klassenbezeichnung (nicht dasselbe wie SVC) und Vorhersagen geben der Klasse die beste Bewertung. 

0
Bilal Dadanlar