Exemple d'utilisation de liaisons python pour la bibliothèque SVM, LIBSVM
J'ai un besoin urgent d'un exemple de tâche de classification utilisant LibSVM en python. Je ne sais pas à quoi devrait ressembler l’entrée, quelle fonction est responsable de la formation et laquelle est responsable des tests Merci.
LIBSVM lit les données d'un tuple contenant deux listes. La première liste contient les classes et la deuxième liste contient les données d'entrée. créez un ensemble de données simple avec deux classes possiblesVous devez également spécifier le noyau que vous souhaitez utiliser en créant svm_parameter.
>> from libsvm import *
>> prob = svm_problem([1,-1],[[1,0,1],[-1,0,-1]])
>> param = svm_parameter(kernel_type = LINEAR, C = 10)
## training the model
>> m = svm_model(prob, param)
#testing the model
>> m.predict([1, 1, 1])
Les exemples de code listés ici ne fonctionnent pas avec LibSVM 3.1, donc j'ai plus ou moins porté l'exemple de mossplix :
from svmutil import *
svm_model.predict = lambda self, x: svm_predict([0], [x], self)[0][0]
prob = svm_problem([1,-1], [[1,0,1], [-1,0,-1]])
param = svm_parameter()
param.kernel_type = LINEAR
param.C = 10
m=svm_train(prob, param)
m.predict([1,1,1])
Cet exemple illustre l'utilisation d'une classe classificateur SVM; c'est aussi simple que possible tout en affichant l'intégralité du flux de travail LIBSVM.
Étape 1: Importer NumPy & LIBSVM
import numpy as NP
from svm import *
Étape 2: Générer des données synthétiques: pour cet exemple, 500 points dans une limite donnée (remarque: de nombreux ensembles de données réels sont fournis sur la LIBSVM site Internet )
Data = NP.random.randint(-5, 5, 1000).reshape(500, 2)
Étape 3: Maintenant, choisissez une limite de décision non linéaire pour un classificateur une classe:
rx = [ (x**2 + y**2) < 9 and 1 or 0 for (x, y) in Data ]
Étape 4: Ensuite, partitionnez arbitrairement les données avec cette limite de décision:
Classe I: ceux qui mentent sur ou à l'intérieur un cercle
Classe II: tous les points à l'extérieur la limite de décision (cercle)
_ {Le bâtiment de modèle SVM commence ici; toutes les étapes précédentes étaient uniquement destinées à préparer des données synthétiques.
Étape 5: Construisez le description du problème en appelant svm_problem, en passant par la fonction de limite de décision} et le données, puis lie ce résultat à une variable.
px = svm_problem(rx, Data)
Étape 6: _ Sélectionnez un fonction du noyau} _ pour le mappage non linéaire.
Pour cet exemple, j'ai choisi RBF (fonction de base radiale) comme fonction de noyau
pm = svm_parameter(kernel_type=RBF)
Étape 7: Formez le classificateur, .__ en appelant svm_model, en passant le description du problème} _ (px) & noyau (pm)
v = svm_model(px, pm)
Step 8: Enfin, testez le classifieur formé en appelant delete sur l'objet modèle formé ('v').
v.predict([3, 1])
# returns the class label (either '1' or '0')
Pour l'exemple ci-dessus, j'ai utilisé la version 3.0 de LIBSVM (la version stable actuelle à l'époque cette réponse a été publiée).
Enfin, w/r/t la partie de votre question concernant le choix de fonction du noyau, Les vecteurs de support technique sont non spécifiques à une fonction du noyau particulière - par exemple, J'aurais pu choisir un noyau différent (gaussien, polynôme, etc.).
LIBSVM inclut toutes les fonctions du noyau les plus couramment utilisées - ce qui est une aide précieuse car vous pouvez voir toutes les alternatives plausibles et en sélectionner une pour l'utiliser dans votre modèle. Il suffit d'appeler svm_parameter et de transmettre une valeur pour type de noyau} (une abréviation de trois lettres correspondant au noyau choisi).
Enfin, la fonction de noyau que vous choisissez pour la formation doit correspondre à la fonction de noyau utilisée par rapport aux données de test.
Vous pourriez envisager d'utiliser
http://scikit-learn.sourceforge.net/
Cela a une excellente liaison de libsvm en python et devrait être facile à installer
Ajout à @shinNoNoir:
param.kernel_type représente le type de fonction du noyau que vous souhaitez utiliser, 0: linéaire 1: polynôme 2: RBF 3: Sigmoid
N'oubliez pas non plus que, svm_problem (y, x): ici y représente les étiquettes de classe et x, les instances de classe et x et y ne peuvent être que des listes, des nuplets et des dictionnaires. (Pas de tableau numpy)
SVM via SciKit-learn:
from sklearn.svm import SVC
X = [[0, 0], [1, 1]]
y = [0, 1]
model = SVC().fit(X, y)
tests = [[0.,0.], [0.49,0.49], [0.5,0.5], [2., 2.]]
print(model.predict(tests))
# prints [0 0 1 1]
Pour plus de détails ici: http://scikit-learn.org/stable/modules/svm.html#svm
param = svm_parameter('-s 0 -t 2 -d 3 -c '+str(C)+' -g '+str(G)+' -p '+str(self.epsilon)+' -n '+str(self.nu))
Je ne connais pas les versions précédentes, mais dans LibSVM 3.xx, la méthode svm_parameter('options') prend uniquement un argument.
Dans mon cas, C, G, p et nu sont les valeurs dynamiques. Vous apportez des modifications en fonction de votre code.
options:
-s svm_type : set type of SVM (default 0)
0 -- C-SVC (multi-class classification)
1 -- nu-SVC (multi-class classification)
2 -- one-class SVM
3 -- epsilon-SVR (regression)
4 -- nu-SVR (regression)
-t kernel_type : set type of kernel function (default 2)
0 -- linear: u'*v
1 -- polynomial: (gamma*u'*v + coef0)^degree
2 -- radial basis function: exp(-gamma*|u-v|^2)
3 -- sigmoid: tanh(gamma*u'*v + coef0)
4 -- precomputed kernel (kernel values in training_set_file)
-d degree : set degree in kernel function (default 3)
-g gamma : set gamma in kernel function (default 1/num_features)
-r coef0 : set coef0 in kernel function (default 0)
-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
-m cachesize : set cache memory size in MB (default 100)
-e epsilon : set tolerance of termination criterion (default 0.001)
-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
-v n: n-fold cross validation mode
-q : quiet mode (no outputs)
Source de la documentation: https://www.csie.ntu.edu.tw/~cjlin/libsvm/
Voici un exemple factice que j'ai mis en purée:
import numpy
import matplotlib.pyplot as plt
from random import seed
from random import randrange
import svmutil as svm
seed(1)
# Creating Data (Dense)
train = list([randrange(-10, 11), randrange(-10, 11)] for i in range(10))
labels = [-1, -1, -1, 1, 1, -1, 1, 1, 1, 1]
options = '-t 0' # linear model
# Training Model
model = svm.svm_train(labels, train, options)
# Line Parameters
w = numpy.matmul(numpy.array(train)[numpy.array(model.get_sv_indices()) - 1].T, model.get_sv_coef())
b = -model.rho.contents.value
if model.get_labels()[1] == -1: # No idea here but it should be done :|
w = -w
b = -b
print(w)
print(b)
# Plotting
plt.figure(figsize=(6, 6))
for i in model.get_sv_indices():
plt.scatter(train[i - 1][0], train[i - 1][1], color='red', s=80)
train = numpy.array(train).T
plt.scatter(train[0], train[1], c=labels)
plt.plot([-5, 5], [-(-5 * w[0] + b) / w[1], -(5 * w[0] + b) / w[1]])
plt.xlim([-13, 13])
plt.ylim([-13, 13])
plt.show()
