Prática de classificação de algoritmo de máquina de vetor de suporte (SVM)

Prática de classificação de algoritmo de máquina de vetor de suporte Python (SVM)

Introdução ao Algoritmo

SVM

Antes, usamos muitos algoritmos lineares para fazer modelos preditivos, como regressão logística , laço e regressão de cume . Mas na vida real, muitas coisas não são linearmente separáveis ​​(ou seja, podem ser classificadas desenhando uma linha reta), e SVM é tratar linearmente inseparáveis ​​e transformar o problema de classificação em um problema de classificação plana. Neste algoritmo, tratamos cada item de dados como um ponto, e no espaço n-dimensional (onde n é o número de recursos que você tem) como um ponto, cada valor de recurso é um valor de uma coordenada específica. Em seguida, classificamos encontrando o hiperplano que distingue as duas classes.

Usamos um gráfico para ilustrar este ponto:

no uso real, não precisamos entender o princípio de determinar o melhor plano de classificação, só precisamos lembrar uma regra prática para determinar o hiperplano correto: “Escolha isolar melhor dois tipos de hiperplanos ". Nesta cena, o hiperplano azul "A" fez bem esse trabalho.

Fontes de dados

Classificação de saúde fetal: https://www.kaggle.com/andrewmvd/fetal-health-classification

Os dados contêm eletrocardiograma fetal, movimento fetal, contração uterina e outros valores característicos, e o que precisamos fazer é classificar a saúde fetal (saúde fetal) por meio desses valores característicos.

O conjunto de dados contém 2.126 registros de recursos extraídos de exames de eletrocardiograma, que são divididos em 3 categorias por três especialistas obstétricos e representados por números: 1 geral, 2 patologia suspeita, 3 patologia determinada.

Mineração de dados

1. Importe bibliotecas de terceiros e leia arquivos

import pandas as pd
import numpy as np
import winreg
from sklearn.model_selection import train_test_split#划分数据集与测试集
from sklearn import svm#导入算法模块
from sklearn.metrics import accuracy_score#导入评分模块
###################
real_address = winreg.OpenKey(winreg.HKEY_CURRENT_USER,r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders',)
file_address=winreg.QueryValueEx(real_address, "Desktop")[0]
file_address+='\\'
file_origin=file_address+"\\源数据-分析\\fetal_health.csv"
health=pd.read_csv(file_origin)
#设立桌面绝对路径，读取源数据文件，这样将数据直接下载到桌面上就可以了，省得还要去找
###################

A regra antiga é primeiro importar os módulos necessários para a modelagem, por sua vez, e ler os arquivos.

2. Limpe os dados

Encontre valores ausentes: a

partir dos resultados acima, não há valores ausentes nos dados.

3. Modelagem

train=health.drop(["fetal_health"],axis=1)
X_train,X_test,y_train,y_test=train_test_split(train,health["fetal_health"],random_state=1)
###考虑到接下来可能需要进行其他的操作，所以定了一个随机种子，保证接下来的train和test是同一组数

O índice da coluna é dividido em valores de recursos e valores previstos, e os dados são divididos em conjunto de treinamento e conjunto de teste.

svm_linear=svm.SVC(C=10,kernel="linear",decision_function_shape="ovr")#参数部分会在下面进行讲解
svm_linear.fit(X_train,y_train)
print("SVM训练模型评分："+str(accuracy_score(y_train,svm_linear.predict(X_train))))
print("SVM待测模型评分："+str(accuracy_score(y_test,svm_linear.predict(X_test))))

O algoritmo SVM é introduzido e os parâmetros do algoritmo são configurados em sequência. Após a modelagem, a precisão do conjunto de teste é pontuada. Os resultados obtidos são os seguintes:

Pode-se observar que a precisão do modelo é de cerca de 89 %.

4. Parâmetros

Aqui, explicamos apenas alguns parâmetros importantes, para outros parâmetros, os amigos podem explorar por si próprios.

sklearn.svm.SVC (C, kernel, grau, gama, coef0, encolhimento, probabilidade, tol, tamanho_cache, peso_classe, verbose, citador_max, forma_da_função, estado_aleatório)

1. C : Parâmetro de penalidade, geralmente o padrão é 1. Quanto maior for o C, menos erro de classificação é permitido, mas quanto maior for o C, pode causar sobreajuste e o efeito de generalização é muito baixo. Quanto menor o C, mais forte é a regularização, e a classificação não vai se preocupar se a classificação está correta, apenas exige que quanto maior o intervalo, melhor, e a classificação não tem sentido neste momento. Portanto, isso requer que amigos façam alguns ajustes.

2. Kernel (função kernel) : A introdução da função kernel visa resolver o problema da inseparabilidade linear.Após o ponto de classificação ser mapeado para um espaço de alta dimensão, ele é transformado em um problema que pode ser dividido linearmente.

Usamos uma tabela para ilustrar vários parâmetros da função do kernel:

As funções do kernel mais comumente usadas são Linear e RBF :

(1) Núcleo linear : Principalmente utilizado para casos separáveis ​​linearmente, com poucos parâmetros e velocidade rápida.Para dados gerais, o efeito de classificação já é ideal.

(2) Núcleo RBF : é usado principalmente no caso de linearidade inseparável.Em comparação com outros algoritmos lineares, esta também é uma vantagem muito importante. Independentemente de se tratar de uma amostra pequena ou grande, de alta ou baixa dimensão, a função kernel RBF é aplicável.

Em seguida, use uma função de limite de classificação para mostrar claramente a diferença entre os dois:

import numpy as np
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use("fivethirtyeight")
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Spectral)
plt.show()# 手动生成一个随机的平面点分布，并画出来
def plot_decision_boundary(pred_func):
	x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    h = 0.01
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)

Defina manualmente um ponto de distribuição plano aleatório

from sklearn import svm
clf = svm.SVC(C=1,kernel="linear",decision_function_shape="ovo")
clf.fit(X, y)
plot_decision_boundary(lambda x: clf.predict(x))
plt.title("SVM-Linearly")
plt.show()

Vamos primeiro dar uma olhada no efeito da classificação linear do kernel em sua classificação:

Vamos dar uma olhada no kernel rbf para classificação não linear:

clf = svm.SVC(C=1,kernel="rbf",decision_function_shape="ovo")
clf.fit(X, y)
plot_decision_boundary(lambda x: clf.predict(x))
plt.title("SVM-Nonlinearity")
plt.show()

Os resultados são os seguintes:

A diferença entre o kernel linear e o kernel rbf pode ser facilmente vista nas duas figuras acima Nos dois resultados acima, é óbvio que a precisão do modelo da função do kernel rbf é melhor. Mas, no processo de execução, pode-se sentir que a velocidade de execução da função do kernel rbf é ligeiramente mais lenta do que a da função do kernel linear e, conforme a quantidade de dados aumenta, o tempo de execução sempre aumentará.

3. decision_function_shape :. O svm original só é usado para dois problemas de classificação Se for estendido para problemas multi-classificação, uma certa estratégia de fusão deve ser adopted.'ovo' one-to-one é a divisão entre dois, 'ovr' Um para muitos é a divisão de uma categoria de outras categorias.
Aqui está um foco em um para muitos : aprenda um modelo de duas classes para cada categoria, separe essa categoria de outras categorias tanto quanto possível, de modo que tantos modelos de duas classes quanto o número de categorias sejam gerados. Execute todos os classificadores binários em pontos de teste para fazer previsões. O classificador com a pontuação mais alta na categoria correspondente vence e o rótulo da categoria é retornado como o resultado da previsão.

resumo

O SVM é um modelo de duas categorias e os dados processados ​​podem ser divididos em três categorias:

1. Separável linear, maximizando o intervalo duro, aprendendo um classificador linear, correspondendo a uma linha reta no plano
2. Separável aproximadamente linear, maximizando o intervalo suave, aprendendo classificador linear
3. Inseparabilidade linear, através da função kernel e suave intervalo Maximize, aprenda um classificador não linear, corresponda à curva no plano

Um ponto que o svm é melhor do que os modelos lineares é que ele pode lidar com dados de classificação não linear, mesmo dados de dimensões mais altas, como esta classificação de dados:

Há muitos lugares que não estão indo muito bem. Os internautas são bem-vindos para fazer sugestões e espero encontrar alguns amigos para discutirmos juntos.