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

machine-learning

Question

Estoy en extrema 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 probar Gracias

Answer 1

Agregando a @shinNoNoir:

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

También tenga en cuenta que, svm_problem (y, x): aquí y es las etiquetas de clase y x las instancias de clase y x y y solo pueden ser listas, tuplas y diccionarios. (No matriz numpy)

Answer 2

Aquí hay un ejemplo ficticio que aplasté:

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

Answer 3

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

Paso 1 : Importar NumPy y LIBSVM

 import numpy as NP
from svm import *

Paso 2: Genere datos sintéticos: para este ejemplo, 500 puntos dentro de un límite determinado (nota: se proporcionan bastantes conjuntos de datos reales en el sitio website LIBSVM)

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

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

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

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

• Clase I : los que se encuentran dentro o dentro de un círculo arbitrario

• Clase II : todos los puntos fuera del límite de decisión (círculo)

El edificio modelo de SVM comienza aquí; todos los pasos anteriores a este fueron solo para preparar algunos datos sintéticos.

Paso 5 : construya la descripción del problema llamando a svm_problem , pasando la función de límite de decisión y los datos , luego vincule 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, elegí RBF (función de base radial) como función de mi kernel

pm = svm_parameter(kernel_type=RBF)

Paso 7: entrene al clasificador, llamando a svm_model , pasando la descripción del problema (px) y kernel (pm)

v = svm_model(px, pm)

Paso 8: Finalmente, pruebe el clasificador entrenado llamando a predict en el objeto modelo entrenado (''v'')

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

Para el ejemplo anterior, utilicé la versión 3.0 de LIBSVM (la versión estable actual en el momento en que se publicó esta respuesta ).

Finalmente, w / r / t la parte de su pregunta con respecto a la elección de la función kernel , Support Vector Machines no es específica para una función particular del kernel; por ejemplo, podría haber elegido un núcleo diferente (gaussiano, polinómico, etc.).

LIBSVM incluye todas las funciones del kernel más utilizadas, lo que es de gran ayuda, ya que puede ver todas las alternativas plausibles y seleccionar una para usar en su modelo; solo se trata de llamar a svm_parameter y pasar un valor para kernel_type (a abreviatura de tres letras para el kernel elegido).

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

Answer 4

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. crea un conjunto de datos simple con dos clases posibles, también necesitas especificar qué kernel quieres 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 5

Los ejemplos de código enumerados aquí no funcionan con LibSVM 3.1, por lo que he mostro más o menos el ejemplo 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])

Answer 6

Puede considerar usar

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

Eso tiene un gran enlace python de libsvm y debería ser fácil de instalar

Answer 7

SVM a través de 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 obtener más detalles aquí: http://scikit-learn.org/stable/modules/svm.html#svm

Answer 8

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é sobre las versiones anteriores, pero en LibSVM 3.xx el método svm_parameter(''options'') tomará solo 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/