Ich versuche, die Beziehung zwischen Entscheidungsfunktion und Vorhersage zu verstehen, die Instanzmethoden von SVC sind ( http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html ). Bisher habe ich festgestellt, dass die Entscheidungsfunktion paarweise Bewertungen zwischen Klassen zurückgibt. Ich hatte den Eindruck, dass Predict die Klasse auswählt, die ihre paarweise Punktzahl maximiert, aber ich habe dies getestet und unterschiedliche Ergebnisse erzielt. Hier ist der Code, mit dem ich versucht habe, die Beziehung zwischen den beiden zu verstehen. Zuerst habe ich die paarweise Bewertungsmatrix generiert und dann die Klasse ausgedruckt, die eine maximale paarweise Bewertung aufweist, die sich von der von clf.predict vorhergesagten Klasse unterscheidet.
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 Entscheidungsfunktionen?
quelle
decision_function
Teil: "Abstand der Proben X zur trennenden Hyperebene" geschrieben ist.sklearn.svm.SVC
Verwendet standardmäßig eine paarweise (Eins-gegen-Eins) Zerlegung und gibt für jede Stichprobe Abstände zu allen n (n-1) / 2-Hyperebenen zurück.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)))]
. Die höchste Stimme vonvotes
ist im Grunde, waspredict
tut.Antworten:
Ich verstehe Ihren Code nicht vollständig, aber lassen Sie uns das Beispiel der Dokumentationsseite durchgehen, 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 Stichproben an:
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 Desionsfunktion sagt uns, auf welcher Seite der Hyperebene, die vom Klassifikator erzeugt wird, wir sind (und wie weit wir davon entfernt sind). Basierend auf diesen Informationen beschriftet der Schätzer die Beispiele mit dem entsprechenden Etikett.
quelle
SVC.decision_function
wird es komplizierter.Für Interessierte werde ich ein kurzes Beispiel für die
predict
von C ++ ( hier ) in Python übersetzte Funktion veröffentlichen :# 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
unddecision_function
, aber beachten Sie, dass diese beim Aufrufen alle vom Modell intern verwendet werdenpredict(X)
. Tatsächlich sind alle Argumente innerhalb des Modells nach dem Anpassen für Sie zugänglich:# 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))
quelle
a = clf.dual_coef_
zua = clf._dual_coef_
und die Ausgabe vondecision_function
dem gleiche ist wieclf._decision_function
, und das Ergebnis derpredict
auch Kongruenz mitclf.predict
Unter datascience.sx gibt es eine wirklich gute Frage und Antwort für das Mehrklassen-Eins-gegen-Eins-Szenario:
Frage
Antworten
quelle
b
) zum Punktprodukt addiert oder subtrahiert werden? Ich habe auf Wikipedia geschaut und es wird subtrahiert, aber in dem Artikel wird es hinzugefügt. Ist das überhaupt so wichtig? Ich bin ziemlich besorgt, weil ich die Entscheidungsfunktion alsw.x + b
statt berechnew.x - b
.Wenn Sie anrufen
decision_function()
, erhalten Sie die Ausgabe von jedem der paarweisen Klassifizierer (n * (n-1) / 2 Nummern insgesamt). Siehe Seiten 127 und 128 von "Support Vector Machines for Pattern Classification" .Jeder Klassifikator gibt eine Abstimmung darüber ab, wie die richtige Antwort lautet (basierend auf dem Vorzeichen der Ausgabe dieses Klassifikators).
predict()
gibt die Klasse mit den meisten Stimmen zurück.quelle
Sie haben wahrscheinlich eine etwas komplizierte mathematische Beziehung. Wenn Sie jedoch den
decision_function
In-LinearSVC
Klassifikator verwenden, wird die Beziehung zwischen diesen beiden klarer! Denn dann erhaltendecision_function
Sie Punkte für jedes Klassenlabel (nicht identisch mit SVC) und sagen voraus, dass die Klasse die beste Punktzahl erhält.quelle
Predict () folgt einem paarweisen Abstimmungsschema, das die Klasse mit den meisten Stimmen über alle paarweisen Vergleiche zurückgibt. Wenn zwei Klassen die gleiche Punktzahl erzielen, wird die Klasse mit dem niedrigsten Index zurückgegeben.
Unten ein Python-Beispiel, das dieses Abstimmungsschema auf die paarweisen Punktzahlen (n * (n-1) / 2) anwendet, die von einer Eins-gegen-Eins-Entscheidungsfunktion () zurückgegeben werden.
from sklearn import svm from sklearn import datasets from numpy import argmax, zeros from itertools import combinations # do pairwise comparisons, return class with most +1 votes def ovo_vote(classes, decision_function): combos = list(combinations(classes, 2)) votes = zeros(len(classes)) for i in range(len(decision_function[0])): if decision_function[0][i] > 0: votes[combos[i][0]] = votes[combos[i][0]] + 1 else: votes[combos[i][1]] = votes[combos[i][1]] + 1 winner = argmax(votes) return classes[winner] # load the digits data set digits = datasets.load_digits() X, y = digits.data, digits.target # set the SVC's decision function shape to "ovo" estimator = svm.SVC(gamma=0.001, C=100., decision_function_shape='ovo') # train SVC on all but the last digit estimator.fit(X.data[:-1], y[:-1]) # print the value of the last digit print("To be classified digit: ", y[-1:][0]) # print the predicted class pred = estimator.predict(X[-1:]) print("Perform classification using predict: ", pred[0]) # get decision function df = estimator.decision_function(X[-1:]) # print the decision function itself print("Decision function consists of",len(df[0]),"elements:") print(df) # get classes, here, numbers 0 to 9 digits = estimator.classes_ # print which class has most votes vote = ovo_vote(digits, df) print("Perform classification using decision function: ", vote)
quelle