Un ejemplo mediante enlaces Python para la biblioteca SVM, LIBSVM

Question

Estoy en extrema necesidad de un ejemplo de tarea de clasificación utilizando LibSVM en Python. No sé cómo la entrada debe ser similar y cuya función es responsable de la formación y cuál para la prueba Gracias

Answer 1

LIBSVM lee los datos de una tupla que contiene dos listas. La primera lista que contiene las clases y la segunda lista contiene los datos de entrada. crear conjunto de datos simple con dos clases posibles también es necesario especificar qué kernel que desea utilizar mediante la creación de 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

Los ejemplos de código que figuran aquí no hacen trabajo con LibSVM 3.1, así que tengo más o menos portado el ejemplo por 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 3

Este ejemplo demuestra una de clase uno SVM clasificador ; es tan simple como sea posible mientras que todavía muestra el flujo de trabajo LIBSVM completa.

Paso 1 : Importación y 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 (nota dada: bastantes reales conjuntos de datos se están provistas en el LIBSVM página web )

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

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

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

Paso 4: A continuación, arbitrariamente dividir los datos w / r / t esta decisión límite:

• Clase I : los que se encuentran en o en una arbitraria círculo

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

---

La construcción de modelos SVM comienza aquí; todos los pasos antes de éste eran sólo para preparar algunos datos sintéticos.

Paso 5 : Construir el descripción del problema llamando svm_problem , que pasa en el frontera de decisión la función y datos , a continuación, se unen este resultado a una variable.

px = svm_problem(rx, Data)

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

En este ejemplo, los grupos i eligió RBF (función de base radial) como mi función del núcleo

pm = svm_parameter(kernel_type=RBF)

Paso 7: entrenar el clasificador, llamando svm_model , que pasa en el descripción del problema (px) y kernel (h)

v = svm_model(px, pm)

Paso 8: Por último, probar el clasificador entrenado llamando predecir en el objeto modelo entrenado ( 'v')

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

---

En el ejemplo anterior, I versión utilizada 3.0 de LIBSVM (la versión actual estable 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 función del núcleo , las SVM son no específica a una función kernel en particular - por ejemplo, podría haber elegido un núcleo diferente (gausiana, polinómica, 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 a svm_parameter y pasando un valor para kernel_type (una abreviatura de tres letras para el núcleo elegido).

Por último, la función del núcleo que elija para la formación debe coincidir con la función del núcleo utilizado en contra de los datos de prueba.

Answer 4

Le recomendamos que utilice

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

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

Answer 5

Adición 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 la clase y X e Y sólo puede ser listas, tuplas y diccionarios (sin matriz numpy)

Answer 6

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 7

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 la voluntad método svm_parameter('options') tarda sólo un argumento .

En mi caso C, G, p y nu son los valores dinámicos. Realiza cambios de acuerdo a 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 8

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