Sé que hay algunas bibliotecas que permiten utilizar máquinas de vectores de soporte del código python, pero estoy buscando específicamente bibliotecas que permitan enseñarlas en línea (esto es, sin tener que dar todos los datos a la vez).Cualquier biblioteca de Python Support Vector Machine que permita el aprendizaje en línea?
¿Hay alguno?
LibSVM incluye un contenedor de python que funciona a través de SWIG.
Ejemplo svm-test.py de su distribución:
#!/usr/bin/env python
from svm import *
# a three-class problem
labels = [0, 1, 1, 2]
samples = [[0, 0], [0, 1], [1, 0], [1, 1]]
problem = svm_problem(labels, samples);
size = len(samples)
kernels = [LINEAR, POLY, RBF]
kname = ['linear','polynomial','rbf']
param = svm_parameter(C = 10,nr_weight = 2,weight_label = [1,0],weight = [10,1])
for k in kernels:
param.kernel_type = k;
model = svm_model(problem,param)
errors = 0
for i in range(size):
prediction = model.predict(samples[i])
probability = model.predict_probability
if (labels[i] != prediction):
errors = errors + 1
print "##########################################"
print " kernel %s: error rate = %d/%d" % (kname[param.kernel_type], errors, size)
print "##########################################"
param = svm_parameter(kernel_type = RBF, C=10)
model = svm_model(problem, param)
print "##########################################"
print " Decision values of predicting %s" % (samples[0])
print "##########################################"
print "Numer of Classes:", model.get_nr_class()
d = model.predict_values(samples[0])
for i in model.get_labels():
for j in model.get_labels():
if j>i:
print "{%d, %d} = %9.5f" % (i, j, d[i,j])
param = svm_parameter(kernel_type = RBF, C=10, probability = 1)
model = svm_model(problem, param)
pred_label, pred_probability = model.predict_probability(samples[1])
print "##########################################"
print " Probability estimate of predicting %s" % (samples[1])
print "##########################################"
print "predicted class: %d" % (pred_label)
for i in model.get_labels():
print "prob(label=%d) = %f" % (i, pred_probability[i])
print "##########################################"
print " Precomputed kernels"
print "##########################################"
samples = [[1, 0, 0, 0, 0], [2, 0, 1, 0, 1], [3, 0, 0, 1, 1], [4, 0, 1, 1, 2]]
problem = svm_problem(labels, samples);
param = svm_parameter(kernel_type=PRECOMPUTED,C = 10,nr_weight = 2,weight_label = [1,0],weight = [10,1])
model = svm_model(problem, param)
pred_label = model.predict(samples[0])
no ha oído hablar de uno. ¿Pero realmente necesitas aprendizaje en línea? Estoy usando SVM durante bastante tiempo y nunca tuve un problema donde tuve que usar el aprendizaje en línea. Por lo general, establezco un umbral en el número de cambios de los ejemplos de entrenamiento (tal vez 100 o 1000) y luego simplemente renovo todos los lotes.
Si su problema está en una escala, donde tiene que usar el aprendizaje en línea, entonces es posible que desee echar un vistazo a vowpal wabbit.
reeditado más adelante, después de comentario:
Olivier Grisel sugiere utilizar un envoltorio alrededor ctypes LaSVM. Como antes no sabía nada sobre LaSVM y se ve muy bien, me intriga probarlo con mis propios problemas :).
Si está limitado a usar Python-VM solamente (dispositivo integrado, robot), le sugiero que use el perceptrón votado/promediado, que funciona cerca de un SVM, pero es fácil de implementar y "en línea" por defecto.
Acabo de ver que Elefant tiene algún código SVM en línea.
Lo necesito para el aprendizaje de refuerzo. –
¿Alguien ha podido construir VW en Linux? Tengo el impulso instalado, pero VW parece asumir una versión mucho más antigua. – Cerin
LaSVM parece ser el ganador aquí. Tiene una pequeña base de código. Admite explícitamente el aprendizaje en línea. Compila fácilmente (probado en Ubuntu 9.10). No tiene una API de Python directa, pero crea dos utilidades de línea de comandos simples que pueden llamarse fácilmente desde Python para construir el modelo (la_svm) y usar el modelo (la_test). – Cerin
¿Por qué le gustaría entrenarlo en línea? Agregar instancias de entrenamientos generalmente requeriría volver a resolver el problema de programación cuadrático asociado con el SVM.
Una forma de manejar esto es entrenar un SVM en modo por lotes, y cuando haya nuevos datos disponibles, verifique si estos puntos de datos están en el margen [-1, +1] del hiperplano. Si es así, reentrenar el SVM utilizando todos los vectores de soporte antiguos, y los nuevos datos de entrenamiento que caen en el margen.
Por supuesto, los resultados pueden ser ligeramente diferentes en comparación con el entrenamiento por lotes en todos sus datos, ya que algunos puntos se pueden descartar que serían vectores de soporte más adelante. Entonces, de nuevo, ¿por qué quieres realizar la capacitación en línea de tu SVM?
Ya mencioné su primera pregunta anterior. Lo estoy usando para un proyecto de aprendizaje reforzado, por lo tanto, necesita aprender en línea. –
tenga en cuenta que el modo por lotes puede ser peor que al azar, si se implementa ingenuamente. – Davide
Esta metodología no se escalaría. Volver a entrenar todo el conjunto de datos para cada nuevo registro tendría, en el mejor de los casos, un rendimiento exponencial. El aprendizaje en línea tendría un rendimiento constante o lineal, dependiendo de la implementación. – Cerin
Si bien no hay enlaces de python allí, el algoritmo descrito en http://leon.bottou.org/projects/sgd está entrenado en línea y se puede volver a implementar fácilmente utilizando, p. numpy
El descenso de gradiente estocástico (SGD) también se implementa en scikit-learn (http://scikit-learn.sourceforge.net/). Aunque el ajuste en línea de los clasificadores basados en SGD todavía no está expuesto, será en los próximos 6 meses. –
Pegasos es un algoritmo SVM en línea que funciona bastante bien. También es bastante fácil de implementar, incluso sin un enlace específico de Python. Hay un C implementation en el sitio web del autor que también se puede adaptar o incrustar.
Dado que el sitio web o los documentos de LibSVM no lo mencionan explícitamente, envié un correo electrónico a Chih-Jen Lin, preguntándole sobre el soporte de aprendizaje incremental/en línea. Su respuesta fue: "Desafortunadamente no. La razón es que todavía no vemos una configuración estándar para el aprendizaje incremental/decremental". – Cerin
Lo que muestra el código de ejemplo no es aprendizaje en línea. – mrgloom