Um exemplo usando ligações Python para biblioteca SVM, libsvm
-
26-09-2019 - |
Pergunta
Estou precisando urgentemente de um exemplo de tarefa de classificação usando o LIBSVM no Python. Não sei como deve ser a entrada e qual função é responsável pelo treinamento e qual para testar obrigado
Solução
O LIBSVM lê os dados de uma tupla contendo duas listas. A primeira lista contém as classes e a segunda lista contém os dados de entrada. Crie um conjunto de dados simples com duas classes possíveis, você também precisa especificar qual kernel você deseja usar criando 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])
Outras dicas
Os exemplos de código listados aqui não funcionam com o libsvm 3.1, então eu tenho mais ou menos portado o exemplo 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])
Este exemplo demonstra uma classe Classificador SVM; É o mais simples possível enquanto ainda mostra o fluxo de trabalho completo do LIBSVM.
Passo 1: Importar numpy e libsvm
import numpy as NP
from svm import *
Passo 2: Gerar dados sintéticos: para este exemplo, 500 pontos dentro de um determinado limite (Nota: Muitos real Os conjuntos de dados são fornecidos no LIBSVM local na rede Internet)
Data = NP.random.randint(-5, 5, 1000).reshape(500, 2)
Etapa 3: Agora, escolha algum limite de decisão não linear para um uma classe classificador:
rx = [ (x**2 + y**2) < 9 and 1 or 0 for (x, y) in Data ]
Passo 4: Em seguida, participe arbitrariamente os dados com este limite de decisão:
Classe I.: aqueles que mentem sobre ou dentro de um arbitrário círculo
Classe II: todos os pontos fora o limite de decisão (círculo)
O edifício do modelo SVM começa aqui; Todas as etapas antes deste eram apenas para preparar alguns dados sintéticos.
Etapa 5: Construa o Descrição do Problema ligando svm_problem, passando no Função de limite de decisão e a dados, depois vincule este resultado a uma variável.
px = svm_problem(rx, Data)
Etapa 6: Selecione uma Função do kernel para o mapeamento não linear
Para este exmaple, eu escolhi Rbf (Função de base radial) como minha função de kernel
pm = svm_parameter(kernel_type=RBF)
Etapa 7: Treine o classificador, ligando svm_model, passando no Descrição do Problema (px) e núcleo (PM)
v = svm_model(px, pm)
Etapa 8: Finalmente, teste o classificador treinado ligando prever no objeto modelo treinado ('v')
v.predict([3, 1])
# returns the class label (either '1' or '0')
Para o exemplo acima, usei a versão 3.0 do Libsvm (a versão estável atual na época esta resposta foi postado).
Finalmente, com a parte da sua pergunta sobre a escolha de Função do kernel, As máquinas vetoriais de suporte são não Específico para uma função específica do kernel-EG, eu poderia ter escolhido um kernel diferente (gaussiano, polinomial, etc.).
O LIBSVM inclui todas as funções do kernel mais comumente usadas-que é uma grande ajuda porque você pode ver todas as alternativas plausíveis e selecionar uma para uso em seu modelo, é apenas uma questão de ligar svm_parameter e passando em um valor para kernel_type (Uma abreviação de três letras para o kernel escolhido).
Finalmente, a função do kernel que você escolhe para o treinamento deve corresponder à função do kernel usada com os dados de teste.
Você pode considerar usar
http://scikit-learn.sourceforge.net/
Que tem uma ótima ligação do Python do LIBSVM e deve ser fácil de instalar
Adicionando a @shinnonoir:
param.kernel_type representa o tipo de função do kernel que você deseja usar, 0: linear 1: polinômio 2: rbf 3: sigmoid
Também tenha em mente que, svm_problem (y, x): aqui está y os rótulos de classe e x são as instâncias de classe e x e y só podem ser listas, tuplas e dicionários (sem matriz numpy)
SVM via 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 mais detalhes aqui: http://scikit-learn.org/stable/modules/svm.html#svm
param = svm_parameter('-s 0 -t 2 -d 3 -c '+str(C)+' -g '+str(G)+' -p '+str(self.epsilon)+' -n '+str(self.nu))
Eu não sei sobre as versões anteriores, mas em Libsvm 3.xx o método svm_parameter('options')
Will leva apenas um argumento.
No meu caso C
, G
, p
e nu
são os valores dinâmicos. Você faz alterações de acordo com o seu código.
Opções:
-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)
Fonte de documentação: https://www.csie.ntu.edu.tw/~cjlin/libsvm/
Aqui está um exemplo dummy que eu misturei:
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()