Un ejemplo que usa enlaces de python para la biblioteca de SVM, LIBSVM

Question

Tengo una gran necesidad de un ejemplo de tarea de clasificación usando LibSVM en python. No sé cómo debería verse la Entrada y qué función es la responsable del entrenamiento y cuál para la prueba Gracias

Answer 1

LIBSVM lee los datos de una tupla que contiene dos listas. La primera lista contiene las clases y la segunda lista contiene los datos de entrada. cree un conjunto de datos simple con dos clases posibles , también necesita especificar qué kernel desea usar creando 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]) 
 

Answer 2

Este ejemplo demuestra una de una sola clase SVM clasificador; es lo más simple posible al tiempo que muestra el flujo de trabajo LIBSVM completo.

Paso 1: Import NumPy & LIBSVM

import numpy as NP 
    from svm import * 

Paso 2: Generar datos sintéticos: Para este ejemplo, 500 puntos dentro de un límite determinado (nota: un buen número los conjuntos de datos reales se proporcionan en el LIBSVM website)

Data = NP.random.randint(-5, 5, 1000).reshape(500, 2) 

Paso 3: Ahora, elegir un cierto límite de decisión no lineal para un de una sola clase clasificador:

rx = [ (x**2 + y**2) < 9 and 1 or 0 for (x, y) in Data ] 

Paso 4: continuación, arbitrariamente particionar los datos w/r/t este límite de decisión:

• Clase I: aquellos que se encuentran en o dentro un arbitraria círculo

• Clase II: todos los puntos fuera la frontera de decisión (círculo)

---

Aquí comienza el Model Building SVM; todos los pasos anteriores a este fueron solo para preparar algunos datos sintéticos.

Paso 5: Construir la descripción problema llamando svm_problem, pasando en la función de límite decisión y los datos, a continuación, enlazar este resultado a una variable.

px = svm_problem(rx, Data) 

Paso 6: Seleccione una función kernel para el mapeo no lineal

Para este ejemplo, los grupos i eligieron RBF (función de base radial) como mi función kernel

pm = svm_parameter(kernel_type=RBF) 

Paso 7: entrenar el clasificador, llamando svm_model, pasando en la descripción problema (px) & kernel (pm)

v = svm_model(px, pm) 

Paso 8: último , pruebe el clasificador entrenado llamando al predecir en el objeto de modelo entrenado ('v')

v.predict([3, 1]) 
# returns the class label (either '1' or '0') 

---

Para el ejemplo anterior, solía versión 3,0 de LIBSVM (la versión estable actual en el momento esta respuesta fue publicada).

Por último, w/r/t de la parte de su pregunta con respecto a la elección de kernel función, las SVM se no específica a una función del núcleo en particular - por ejemplo, podría haber elegido una diferente núcleo (gaussiano, polinomio, etc.).

LIBSVM incluye todas las funciones del núcleo más comúnmente utilizados - que es una gran ayuda porque se puede ver todas las alternativas posibles y seleccionar uno para su uso en el modelo, es sólo una cuestión de llamar svm_parameter y pasando un valor para kernel_type (una abreviatura de tres letras para el kernel elegido).

Finalmente, la función del kernel que elija para el entrenamiento debe coincidir con la función del núcleo utilizada en comparación con los datos de prueba.

Answer 3

Se podría considerar el uso de

http://scikit-learn.sourceforge.net/

que tiene una gran unión de libsvm pitón y debe ser fácil de instalar

Answer 4

Los ejemplos de código enumerados aquí no funcionan con LibSVM 3.1, por lo que 've más o menos portado the example by 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]) 

Answer 5

Agregando a @shinNoNoir:

param.kernel_type representa el tipo de función kernel que desea utilizar, 0: Lineal 1: polinomio 2: RBF 3: sigmoide

también tiene en cuenta que, svm_problem (y, x): aquí y es la clase de etiquetas y X es el instancias de clases y X e y sólo puede ser listas, tuplas y diccionarios. (ninguna matriz numpy)

Answer 6

param = svm_parameter('-s 0 -t 2 -d 3 -c '+str(C)+' -g '+str(G)+' -p '+str(self.epsilon)+' -n '+str(self.nu)) 

no sé acerca de las versiones anteriores, pero en LibSVM 3.xx el método svm_parameter('options') tomará j ust un argumento.

En mi caso C, G, p y nu son los valores dinámicos. Usted realiza cambios de acuerdo con su código.

---

opciones:

-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) 

---

fuente de documentación: https://www.csie.ntu.edu.tw/~cjlin/libsvm/

Answer 7

SVM través 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] 

Para más detalles aquí: http://scikit-learn.org/stable/modules/svm.html#svm

Answer 8

Aquí está un ejemplo ficticio Trituré arriba:

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()