Cualquier pitón biblioteca máquinas de vectores soporte en torno a que permite el aprendizaje en línea?

Question

Yo sé que hay algunas librerías que permiten utilizar máquinas de vectores soporte de código Python, pero estoy en busca específicamente para las bibliotecas que permiten a enseñar en línea (esto es, sin tener que darle todos los datos a la vez) .

¿Hay alguna?

Answer 1

LibSVM incluye un envoltorio de Python que funciona a través de TRAGO.

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

Answer 2

No han oído hablar de uno. Pero lo que realmente necesita el aprendizaje en línea? Estoy usando SVM desde hace bastante tiempo y nunca detectado un problema donde tenía que utilizar el aprendizaje en línea. Por lo general, puedo configurar un umbral en el número de cambios de ejemplos de entrenamiento (tal vez 100 o 1000) y luego simplemente lotes reciclar a todos.

Si su problema es a escala, donde es absolutamente necesario para utilizar el aprendizaje en línea, entonces puede que desee echar un vistazo a vowpal wabbit .

reeditado más adelante, después de comentario:

Olivier Grisel sugiere utilizar una envoltura alrededor de ctypes laSVM . Como yo no sabía nada de LaSVM antes y se ve muy bien, estoy intrigado a probarlo en mis propios problemas:.)

Si estás limitado a usar el Python-VM solamente (dispositivo integrado, robot), me gustaría sugerir que el uso votado / perceptrón promediado, que realiza cerca de una SVM, pero es fácil de implementar y "en línea" de por defecto.

Elefant tiene algo de código en línea en SVM.

Answer 3

Si bien no hay enlaces Python allí, el algoritmo descrito en http://leon.bottou.org/projects/sgd es entrenado de una manera en línea y es fácilmente reimplementado usando, por ejemplo numpy.

Answer 4

Pegasos es un algoritmo SVM en línea que realiza bastante bien . También es bastante fácil de implementar, incluso sin una unión específica de Python. Hay una C aplicación en el sitio web del autor de que es adaptable o integrable también.

Answer 5

¿Por qué quiere entrenar en línea? Adición de instancias entrenamientos normalmente requeriría para volver a resolver el problema de programación cuadrática asociada a la SVM.

A manera de manejar esto es la formación de una SVM en modo por lotes, y cuando los nuevos datos está disponible, comprobar si estos puntos de datos están en el margen de [-1, 1] de la hiperplano. Si es así, reciclar a la SVM utilizando todos los viejos vectores de soporte, y los nuevos datos de entrenamiento que cae en el margen.

Por supuesto, los resultados pueden ser ligeramente diferente en comparación con el entrenamiento por lotes de todos sus datos, ya que algunos puntos pueden descartarse que sería vectores de soporte más adelante. Así que de nuevo, ¿por qué quiere llevar a cabo la formación en línea de ustedes SVM?