Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

A máquina de vetores de suporte (SVM) é um modelo de aprendizado de máquina poderoso e versátil, adequado para classificação linear e não linear, regressão e detecção de valores discrepantes. Este artigo apresentará o algoritmo da máquina de vetores de suporte e sua implementação no scikit-learn, e explorará brevemente a análise de componentes principais e sua aplicação no scikit-learn.

1. Visão geral das máquinas de vetores de suporte

Máquina de vetores de suporte (SVM) é um algoritmo amplamente utilizado na área de aprendizado de máquina, favorecido por sua característica de fornecer precisão significativa com menos recursos computacionais. O SVM pode ser usado para tarefas de classificação e regressão, mas é mais amplamente utilizado em problemas de classificação.

O que é uma máquina de vetores de suporte?

O objetivo das máquinas de vetores de suporte é $Nãoão$ espaço dimensional ($Nãoão$ é o número de recursos) para encontrar um hiperplano que possa distinguir claramente os pontos de dados. Este hiperplano permite que pontos de dados de diferentes categorias sejam separados e o mais distantes possível do hiperplano para garantir a robustez da classificação.

Para conseguir uma separação eficaz dos pontos de dados, podem existir vários hiperplanos. Nosso objetivo é escolher um hiperplano com margem máxima, ou seja, a distância máxima entre duas classes. Maximizar as margens ajuda a melhorar a precisão da classificação.

Hiperplanos e vetores de suporte

Um hiperplano é um limite de decisão que divide pontos de dados. Os pontos de dados localizados em ambos os lados do hiperplano podem ser classificados em diferentes categorias. As dimensões do hiperplano dependem do número de recursos: se os recursos de entrada forem 2, o hiperplano é uma linha reta; se os recursos forem 3, o hiperplano é um plano bidimensional; Quando o número de recursos excede 3, o hiperplano torna-se difícil de entender intuitivamente.

Os vetores de suporte referem-se aos pontos mais próximos do hiperplano, que afetam a posição e a direção do hiperplano. Com esses vetores de suporte, podemos maximizar a margem do classificador. A remoção dos vetores de suporte altera a posição do hiperplano, portanto eles são cruciais para a construção de um SVM.

Intuição de grande margem

Na regressão logística, usamos a função sigmóide para compactar o valor de saída da função linear no intervalo [0,1] e atribuir rótulos com base em um limite (0,5). No SVM, usamos o valor de saída de uma função linear para decidir a classificação: se a saída for maior que 1, ela pertence a uma classe; se a saída for -1, ela pertence a outra classe; O SVM forma o intervalo marginal [-1,1] definindo o limite do valor de saída como 1 e -1.

2. Pré-processamento e visualização de dados

Predição de diagnósticos de câncer benigno e maligno usando máquinas de vetores de suporte.

Informações básicas sobre o conjunto de dados

• O número de recursos é 30, por exemplo:
  • Raio (distância média do centro aos pontos do perímetro)
  • Textura (desvio padrão dos valores da escala de cinza)
  • perímetro
  • área
  • Suavidade (variação local no comprimento do raio)
  • Compacidade (Perímetro ^ 2 / Área - 1,0)
  • Concavidade (a gravidade da porção deprimida do contorno)
  • Covinhas (o número de partes côncavas do contorno)
  • simetria
  • Dimensão Fractal ("Aproximação da Costa" - 1)
• O conjunto de dados contém 569 amostras e a distribuição de classes é de 212 amostras malignas e 357 amostras benignas.
• Categoria alvo:
  • maligno
  • benigno

Importe as bibliotecas necessárias

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline
sns.set_style('whitegrid')
1
2
3
4
5
6
7

Carregar conjunto de dados

from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()

# 创建 DataFrame
col_names = list(cancer.feature_names)
col_names.append('target')
df = pd.DataFrame(np.c_[cancer.data, cancer.target], columns=col_names)
df.head()
1
2
3
4
5
6
7
8
9

Visão geral dos dados

df.info()print(cancer.target_names)
# ['malignant', 'benign']

# 数据描述：
df.describe()
# 统计摘要：
df.info()
1
2
3
4
5
6
7

Visualização de dados

Matriz de gráfico de dispersão de pares de recursos

sns.pairplot(df, hue='target', vars=[
    'mean radius', 'mean texture', 'mean perimeter', 'mean area',
    'mean smoothness', 'mean compactness', 'mean concavity',
    'mean concave points', 'mean symmetry', 'mean fractal dimension'
])
1
2
3
4
5

Gráfico de barras de distribuição de categoria

sns.countplot(x=df['target'], label="Count")
1

Gráfico de dispersão da área média versus suavidade média

plt.figure(figsize=(10, 8))
sns.scatterplot(x='mean area', y='mean smoothness', hue='target', data=df)
1
2

Mapa térmico de correlações entre variáveis

plt.figure(figsize=(20,10))
sns.heatmap(df.corr(), annot=True)
1
2

3. Treinamento de modelo (resolução de problemas)

No aprendizado de máquina, o treinamento do modelo é uma etapa crítica na busca de soluções para problemas.Abaixo apresentaremos como usarscikit-learn Realize o treinamento do modelo e demonstre o desempenho da máquina de vetores de suporte (SVM) em diferentes kernels.

Preparação e pré-processamento de dados

Primeiro, precisamos preparar e pré-processar os dados. A seguir está um exemplo de código para pré-processamento de dados:

from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, MinMaxScaler

X = df.drop('target', axis=1)
y = df.target

print(f"'X' shape: {X.shape}")
print(f"'y' shape: {y.shape}")
# 'X' shape: (569, 30)
# 'y' shape: (569,)

pipeline = Pipeline([
    ('min_max_scaler', MinMaxScaler()),
    ('std_scaler', StandardScaler())
])

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

No código que usamos MinMaxScaler eStandardScaler Dimensione os dados. Os dados são divididos em conjuntos de treinamento e teste, com 30% dos dados utilizados para teste.

Avalie o desempenho do modelo

Para avaliar o desempenho do modelo, definimos um print_score função, que pode gerar a precisão, relatório de classificação e matriz de confusão de resultados de treinamento e teste:

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import pandas as pd

def print_score(clf, X_train, y_train, X_test, y_test, train=True):
    if train:
        pred = clf.predict(X_train)
        clf_report = pd.DataFrame(classification_report(y_train, pred, output_dict=True))
        print("Train Result:n================================================")
        print(f"Accuracy Score: {accuracy_score(y_train, pred) * 100:.2f}%")
        print("_______________________________________________")
        print(f"CLASSIFICATION REPORT:n{clf_report}")
        print("_______________________________________________")
        print(f"Confusion Matrix: n {confusion_matrix(y_train, pred)}n")
    else:
        pred = clf.predict(X_test)
        clf_report = pd.DataFrame(classification_report(y_test, pred, output_dict=True))
        print("Test Result:n================================================")        
        print(f"Accuracy Score: {accuracy_score(y_test, pred) * 100:.2f}%")
        print("_______________________________________________")
        print(f"CLASSIFICATION REPORT:n{clf_report}")
        print("_______________________________________________")
        print(f"Confusion Matrix: n {confusion_matrix(y_test, pred)}n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Máquina de vetores de suporte (SVM)

A máquina de vetores de suporte (SVM) é um algoritmo de classificação poderoso cujo desempenho é afetado por hiperparâmetros. A seguir serão apresentados os principais parâmetros do SVM e seu impacto no desempenho do modelo:

• Parâmetros C : controla a compensação entre classificar corretamente os pontos de treinamento e ter limites de decisão suaves.menor$C$(solto) torna os custos de classificação incorreta (penalidades) mais baixos (margens suaves), enquanto maiores $C$(estrito) torna a classificação incorreta mais cara (margem rígida), forçando o modelo a interpretar os dados de entrada de forma mais estrita.
• parâmetro gama : controle o escopo de influência de um único conjunto de treinamento.maior$\gamma$ Tornar o escopo de influência mais próximo (pontos de dados mais próximos têm maior peso), menor$\gamma$ Amplie o alcance (soluções mais amplas).
• parâmetro de grau: Função de kernel polinomial ('poly' ), ignorado por outros kernels. Os valores ideais dos hiperparâmetros podem ser encontrados por meio de pesquisa em grade.

SVM de kernel linear

O SVM de kernel linear é adequado para a maioria das situações, especialmente quando o conjunto de dados possui um grande número de recursos. A seguir está um exemplo de código usando SVM de kernel linear:

from sklearn.svm import LinearSVC

model = LinearSVC(loss='hinge', dual=True)
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6
7

Os resultados do treinamento e do teste são os seguintes:

Resultados do treinamento:

Accuracy Score: 86.18%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    1.000000    0.819079  0.861809    0.909539      0.886811
recall       0.630872    1.000000  0.861809    0.815436      0.861809
f1-score     0.773663    0.900542  0.861809    0.837103      0.853042
support    149.000000  249.000000  0.861809  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[ 94  55]
 [  0 249]]
1
2
3
4
5
6
7
8
9
10
11
12

Resultado dos testes:

Accuracy Score: 89.47%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   1.000000    0.857143  0.894737    0.928571      0.909774
recall      0.714286    1.000000  0.894737    0.857143      0.894737
f1-score    0.833333    0.923077  0.894737    0.878205      0.890013
support    63.000000  108.000000  0.894737  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 45  18]
 [  0 108]]
1
2
3
4
5
6
7
8
9
10
11
12

SVM de kernel polinomial

SVM de kernel polinomial é adequado para dados não lineares. A seguir está um exemplo de código usando um kernel polinomial de segunda ordem:

from sklearn.svm import SVC

model = SVC(kernel='poly', degree=2, gamma='auto', coef0=1, C=5)
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6
7

Os resultados do treinamento e do teste são os seguintes:

Resultados do treinamento:

Accuracy Score: 96.98%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    0.985816    0.961089  0.969849    0.973453      0.970346
recall       0.932886    0.991968  0.969849    0.962427      0.969849
f1-score     0.958621    0.976285  0.969849    0.967453      0.969672
support    149.000000  249.000000  0.969849  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[139  10]
 [  2 247]]
1
2
3
4
5
6
7
8
9
10
11
12

Resultado dos testes:

Accuracy Score: 97.08%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   0.967742    0.972477   0.97076    0.970109      0.970733
recall      0.952381    0.981481   0.97076    0.966931      0.970760
f1-score    0.960000    0.976959   0.97076    0.968479      0.970711
support    63.000000  108.000000   0.97076  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 60   3]
 [  2 106]]
1
2
3
4
5
6
7
8
9
10
11
12

SVM do kernel de função de base radial (RBF)

Os kernels de função de base radial (RBF) são adequados para processamento de dados não lineares. A seguir está um exemplo de código usando o núcleo RBF:

model = SVC(kernel='rbf', gamma=0.5, C=0.1)
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5

Os resultados do treinamento e do teste são os seguintes:

Resultados do treinamento:

Accuracy Score: 62.56%
_______________________________________________
CLASSIFICATION REPORT:
             0.0         1.0  accuracy   macro avg  weighted avg
precision    0.0    0.625628  0.625628    0.312814      0.392314
recall       0.0    1.000000  0.625628    0.500000      0.625628
f1-score     0.0    0.769231  0.625628    0.384615      0.615385
support    149.0  249.0    0.625628  398.0        398.0
_______________________________________________
Confusion Matrix: 
 [[  0 149]
 [  0 249]]
1
2
3
4
5
6
7
8
9
10
11
12

Resultado dos testes:

Accuracy Score: 64.97%
_______________________________________________
CLASSIFICATION REPORT:
             0.0         1.0  accuracy   macro avg  weighted avg
precision    0.0    0.655172  0.649661    0.327586      0.409551
recall       0.0    1.000000  0.649661    0.500000      0.649661
f1-score     0.0    0.792453  0.649661    0.396226      0.628252
support    63.0  108.0    0.649661  171.0        171.0
_______________________________________________
Confusion Matrix: 
 [[  0  63]
 [  0 108]]
1
2
3
4
5
6
7
8
9
10
11
12

Resumir

Através do processo de treinamento e avaliação do modelo acima, podemos observar as diferenças de desempenho de diferentes kernels SVM. O SVM de kernel linear tem um bom desempenho em termos de precisão e tempo de treinamento e é adequado para situações com dimensões de dados mais altas. SVM de kernel polinomial e SVM de kernel RBF têm melhor desempenho em dados não lineares, mas podem levar a ajuste excessivo sob certas configurações de parâmetros. A escolha de kernels e hiperparâmetros apropriados é crucial para melhorar o desempenho do modelo.

4. Preparação de dados SVM

entrada digital : SVM assume que os dados de entrada são numéricos. Se os dados de entrada forem variáveis ​​categóricas, pode ser necessário convertê-los em variáveis ​​binárias fictícias (uma variável por categoria).

classificação binária :Basic SVM é adequado para problemas de classificação binária. Embora o SVM seja usado principalmente para classificação binária, também existem versões estendidas para regressão e classificação multiclasse.

X_train = pipeline.fit_transform(X_train)
X_test = pipeline.transform(X_test)
1
2

Treinamento e avaliação de modelo

A seguir são mostrados os resultados de treinamento e teste de diferentes kernels SVM:

SVM de kernel linear

print("=======================Linear Kernel SVM==========================")
model = SVC(kernel='linear')
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6

Resultados do treinamento:

Accuracy Score: 98.99%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    1.000000    0.984190   0.98995    0.992095      0.990109
recall       0.973154    1.000000   0.98995    0.986577      0.989950
f1-score     0.986395    0.992032   0.98995    0.989213      0.989921
support    149.000000  249.000000   0.98995  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[145   4]
 [  0 249]]

测试结果

Accuracy Score: 97.66%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   0.968254    0.981481  0.976608    0.974868      0.976608
recall      0.968254    0.981481  0.976608    0.974868      0.976608
f1-score    0.968254    0.981481  0.976608    0.974868      0.976608
support    63.000000  108.000000  0.976608  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 61   2]
 [  2 106]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

SVM de kernel polinomial

print("=======================Polynomial Kernel SVM==========================")
from sklearn.svm import SVC

model = SVC(kernel='poly', degree=2, gamma='auto')
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6
7
8

Resultados do treinamento:

Accuracy Score: 85.18%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    0.978723    0.812500  0.851759    0.895612      0.874729
recall       0.617450    0.991968  0.851759    0.804709      0.851759
f1-score     0.757202    0.893309  0.851759    0.825255      0.842354
support    149.000000  249.000000  0.851759  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[ 92  57]
 [  2 247]]

测试结果：

Accuracy Score: 82.46%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   0.923077    0.795455  0.824561    0.859266      0.842473
recall      0.571429    0.972222  0.824561    0.771825      0.824561
f1-score    0.705882    0.875000  0.824561    0.790441      0.812693
support    63.000000  108.000000  0.824561  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 36  27]
 [  3 105]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Kernel de função de base radial SVM

print("=======================Radial Kernel SVM==========================")
from sklearn.svm import SVC

model = SVC(kernel='rbf', gamma=1)
model.fit(X_train, y_train)

print_score(model, X_train, y_train, X_test, y_test, train=True)
print_score(model, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6
7
8

Resultados do treinamento:

Accuracy Score: 100.00%
_______________________________________________
CLASSIFICATION REPORT:
             0.0    1.0  accuracy  macro avg  weighted avg
precision    1.0    1.0       1.0        1.0           1.0
recall       1.0    1.0       1.0        1.0           1.0
f1-score     1.0    1.0       1.0        1.0           1.0
support    149.0  249.0       1.0      398.0         398.0
_______________________________________________
Confusion Matrix: 
 [[149   0]
 [  0 249]]

测试结果：

Accuracy Score: 63.74%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   1.000000    0.635294  0.637427    0.817647      0.769659
recall      0.015873    1.000000  0.637427    0.507937      0.637427
f1-score    0.031250    0.776978  0.637427    0.404114      0.502236
support    63.000000  108.000000  0.637427  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[  1  62]
 [  0 108]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Suporta ajuste de hiperparâmetros de máquina vetorial

from sklearn.model_selection import GridSearchCV

param_grid = {'C': [0.01, 0.1, 0.5, 1, 10, 100], 
              'gamma': [1, 0.75, 0.5, 0.25, 0.1, 0.01, 0.001], 
              'kernel': ['rbf', 'poly', 'linear']} 

grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=1, cv=5)
grid.fit(X_train, y_train)

best_params = grid.best_params_
print(f"Best params: {best_params}")

svm_clf = SVC(**best_params)
svm_clf.fit(X_train, y_train)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=True)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Resultados do treinamento:

Accuracy Score: 98.24%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    0.986301    0.980159  0.982412    0.983230      0.982458
recall       0.966443    0.991968  0.982412    0.979205      0.982412
f1-score     0.976271    0.986028  0.982412    0.981150      0.982375
support    149.000000  249.000000  0.982412  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[144   5]
 [  2 247]]

测试结果：

Accuracy Score: 98.25%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   0.983871    0.981651  0.982456    0.982761      0.982469
recall      0.968254    0.990741  0.982456    0.979497      0.982456
f1-score    0.976000    0.986175  0.982456    0.981088      0.982426
support    63.000000  108.000000  0.982456  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 61   2]
 [  1 107]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5. Análise de componentes principais

Introdução ao PCA

A análise de componentes principais (PCA) é uma técnica que atinge a redução da dimensionalidade linear projetando dados em um espaço de dimensão inferior.

• Use decomposição de valor singular: Projete dados em um espaço de baixa dimensão por meio da decomposição de valores singulares.
• aprendizagem não supervisionada: O PCA não requer dados rotulados para redução de dimensionalidade.
• Transformação de recursos: tente descobrir quais recursos explicam a maior variação nos dados.

Visualização PCA

Como os dados de alta dimensão são difíceis de visualizar diretamente, podemos usar o PCA para encontrar os dois primeiros componentes principais e visualizar os dados no espaço bidimensional. Para conseguir isso, os dados precisam ser primeiro normalizados para que a variação de cada recurso seja uma variação unitária.

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# 数据标准化
scaler = StandardScaler()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# PCA 降维
pca = PCA(n_components=2)
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)

# 可视化前两个主成分
plt.figure(figsize=(8,6))
plt.scatter(X_train[:,0], X_train[:,1], c=y_train, cmap='plasma')
plt.xlabel('First Principal Component')
plt.ylabel('Second Principal Component')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Através dos dois primeiros componentes principais, podemos separar facilmente diferentes categorias de pontos de dados no espaço bidimensional.

Explique os componentes

Embora a redução da dimensionalidade seja poderosa, o significado dos componentes é difícil de compreender diretamente. Cada componente corresponde a uma combinação de características originais, que podem ser obtidas ajustando um objeto PCA.

As propriedades relacionadas aos componentes incluem:

• pontuação do ingrediente: O valor da variável transformada.
• Carga (peso): Peso de combinação de recursos.
• Compressão de dados e preservação de informações: a compactação de dados é obtida por meio do PCA, mantendo as principais informações.
• Filtragem de ruído: O ruído pode ser filtrado durante o processo de redução de dimensionalidade.
• Extração e engenharia de recursos: usado para extrair e construir novos recursos.

Ajuste de parâmetros do modelo de máquina de vetores de suporte (SVM)

Ao usar máquinas de vetores de suporte (SVM) para treinamento de modelos, precisamos ajustar os hiperparâmetros para obter o melhor modelo. A seguir está um exemplo de código para ajustar parâmetros SVM usando pesquisa em grade (GridSearchCV):

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {'C': [0.01, 0.1, 0.5, 1, 10, 100], 
              'gamma': [1, 0.75, 0.5, 0.25, 0.1, 0.01, 0.001], 
              'kernel': ['rbf', 'poly', 'linear']} 

# 网格搜索
grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=1, cv=5)
grid.fit(X_train, y_train)
best_params = grid.best_params_
print(f"Best params: {best_params}")

# 使用最佳参数训练模型
svm_clf = SVC(**best_params)
svm_clf.fit(X_train, y_train)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Resultados do treinamento:

Accuracy Score: 96.48%
_______________________________________________
CLASSIFICATION REPORT:
                  0.0         1.0  accuracy   macro avg  weighted avg
precision    0.978723    0.957198  0.964824    0.967961      0.965257
recall       0.926174    0.987952  0.964824    0.957063      0.964824
f1-score     0.951724    0.972332  0.964824    0.962028      0.964617
support    149.000000  249.000000  0.964824  398.000000    398.000000
_______________________________________________
Confusion Matrix: 
 [[138  11]
 [  3 246]]

测试结果：

Accuracy Score: 96.49%
_______________________________________________
CLASSIFICATION REPORT:
                 0.0         1.0  accuracy   macro avg  weighted avg
precision   0.967213    0.963636  0.964912    0.965425      0.964954
recall      0.936508    0.981481  0.964912    0.958995      0.964912
f1-score    0.951613    0.972477  0.964912    0.962045      0.964790
support    63.000000  108.000000  0.964912  171.000000    171.000000
_______________________________________________
Confusion Matrix: 
 [[ 59   4]
 [  2 106]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6. Resumo

Neste artigo aprendemos o seguinte:

• Máquina de vetores de suporte (SVM): Compreenda os conceitos básicos de SVM e sua implementação em Python.
• Função do kernel SVM: Incluindo funções lineares de base radial (RBF) e funções de kernel polinomiais.
• preparação de dados: Como preparar dados para o algoritmo SVM.
• Ajuste de hiperparâmetros: Ajustando hiperparâmetros SVM por meio de pesquisa em grade.
• Análise de Componentes Principais (PCA): Como usar o PCA para reduzir a complexidade dos dados e reutilizá-los no scikit-learn.

---

referir-se:Tutorial de Máquina de Vetor de Suporte e PCA para Iniciantes
Recomendo minhas colunas relacionadas:

• registro de erros do python
• notas python
• estrutura de dados

---