Compartir tecnología

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

La máquina de vectores de soporte (SVM) es un modelo de aprendizaje automático potente y versátil adecuado para clasificación, regresión y detección de valores atípicos lineales y no lineales. Este artículo presentará el algoritmo de la máquina de vectores de soporte y su implementación en scikit-learn, y explorará brevemente el análisis de componentes principales y su aplicación en scikit-learn.

1. Descripción general de las máquinas de vectores de soporte

La máquina de vectores de soporte (SVM) es un algoritmo ampliamente utilizado en el campo del aprendizaje automático, favorecido por su característica de proporcionar una precisión significativa con menos recursos informáticos. SVM se puede utilizar tanto para tareas de clasificación como de regresión, pero se utiliza más ampliamente en problemas de clasificación.

¿Qué es una máquina de vectores de soporte?

El objetivo de las máquinas de vectores de soporte es $norte$ espacio dimensional ($norte$ es el número de características) para encontrar un hiperplano que pueda distinguir claramente los puntos de datos. Este hiperplano permite separar puntos de datos de diferentes categorías y alejarlos lo más posible del hiperplano para garantizar la solidez de la clasificación.

Para lograr una separación efectiva de los puntos de datos, pueden existir múltiples hiperplanos. Nuestro objetivo es elegir un hiperplano con el margen máximo, es decir, la distancia máxima entre dos clases. Maximizar los márgenes ayuda a mejorar la precisión de la clasificación.

Hiperplanos y vectores de soporte.

Un hiperplano es un límite de decisión que divide puntos de datos. Los puntos de datos ubicados a ambos lados del hiperplano se pueden clasificar en diferentes categorías. Las dimensiones del hiperplano dependen del número de características: si las características de entrada son 2, el hiperplano es una línea recta; si las características son 3, el hiperplano es un plano bidimensional. Cuando el número de funciones supera las 3, el hiperplano se vuelve difícil de entender intuitivamente.

Los vectores de soporte se refieren a los puntos más cercanos al hiperplano, que afectan la posición y dirección del hiperplano. Con estos vectores de soporte, podemos maximizar el margen del clasificador. La eliminación de los vectores de soporte cambia la posición del hiperplano, por lo que son cruciales para construir una SVM.

Intuición de gran margen

En la regresión logística, usamos la función sigmoidea para comprimir el valor de salida de la función lineal en el rango [0,1] y asignamos etiquetas según un umbral (0,5). En SVM, utilizamos el valor de salida de una función lineal para decidir la clasificación: si la salida es mayor que 1, pertenece a una clase; si la salida es -1, pertenece a otra clase; SVM forma el rango marginal [-1,1] estableciendo el umbral del valor de salida en 1 y -1.

2. Preprocesamiento y visualización de datos.

Predecir diagnósticos de cáncer benigno y maligno utilizando máquinas de vectores de soporte.

Información básica sobre el conjunto de datos.

• El número de funciones es 30, por ejemplo:
  • Radio (distancia promedio desde el centro hasta los puntos del perímetro)
  • Textura (desviación estándar de los valores de escala de grises)
  • perímetro
  • área
  • Suavidad (variación local en la longitud del radio)
  • Compacidad (Perímetro^2 / Área - 1,0)
  • Concavidad (la gravedad de la porción deprimida del contorno)
  • Hoyuelos (el número de partes cóncavas del contorno)
  • simetría
  • Dimensión fractal ("Aproximación a la línea costera" - 1)
• El conjunto de datos contiene 569 muestras y la distribución de clases es 212 muestras malignas y 357 muestras benignas.
• Categoría objetivo:
  • maligno
  • benigno

Importar bibliotecas necesarias

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

Cargar conjunto de datos

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

Resumen de datos

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

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

Visualización de datos

Matriz de diagrama de dispersión de pares de características

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 distribución de categorías

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

Diagrama de dispersión de área promedio versus suavidad promedio

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

Mapa de calor de correlaciones entre variables.

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

3. Entrenamiento modelo (resolución de problemas)

En el aprendizaje automático, el entrenamiento de modelos es un paso fundamental para encontrar soluciones a los problemas.A continuación presentaremos cómo utilizarscikit-learn Realice un entrenamiento de modelos y demuestre el rendimiento de la máquina de vectores de soporte (SVM) en diferentes núcleos.

Preparación y preprocesamiento de datos.

Primero, necesitamos preparar y preprocesar los datos. El siguiente es un ejemplo de código para el preprocesamiento de datos:

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

En el código que usamos MinMaxScaler yStandardScaler Escalar los datos. Los datos se dividen en conjuntos de entrenamiento y prueba, y el 30% de los datos se utilizan para pruebas.

Evaluar el rendimiento del modelo

Para evaluar el desempeño del modelo, definimos un print_score función, que puede generar la precisión, el informe de clasificación y la matriz de confusión de los resultados del entrenamiento y las pruebas:

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 vectores de soporte (SVM)

La máquina de vectores de soporte (SVM) es un potente algoritmo de clasificación cuyo rendimiento se ve afectado por hiperparámetros. A continuación se presentarán los principales parámetros de SVM y su impacto en el rendimiento del modelo:

• Parámetros C : Controla el equilibrio entre clasificar correctamente los puntos de entrenamiento y tener límites de decisión fluidos.menor$C$(suelto) hace que los costos de clasificación errónea (sanciones) sean más bajos (márgenes suaves), mientras que los mayores $C$(estricto) hace que la clasificación errónea sea más costosa (margen estricto), lo que obliga al modelo a interpretar los datos de entrada de manera más estricta.
• parámetro gamma : Controla el alcance de influencia de un único conjunto de entrenamiento.más grande$\gamma$ Hacer que el alcance de influencia sea más cercano (los puntos de datos más cercanos tienen mayor peso), más pequeño$\gamma$ Ampliar el alcance (soluciones más amplias).
• parámetro de grado: Función kernel polinomial ('poly' ), ignorado por otros núcleos. Los valores óptimos de hiperparámetros se pueden encontrar mediante la búsqueda en cuadrícula.

SVM de núcleo lineal

SVM de núcleo lineal es adecuado para la mayoría de situaciones, especialmente cuando el conjunto de datos tiene una gran cantidad de características. El siguiente es un ejemplo de código que utiliza SVM de kernel lineal:

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

Los resultados del entrenamiento y las pruebas son los siguientes:

Resultados del entrenamiento:

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

Resultados de la prueba:

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 núcleo polinómico

El SVM de núcleo polinómico es adecuado para datos no lineales. El siguiente es un ejemplo de código que utiliza un núcleo polinomial de segundo orden:

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

Los resultados del entrenamiento y las pruebas son los siguientes:

Resultados del entrenamiento:

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

Resultados de la prueba:

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 del núcleo de función de base radial (RBF)

Los núcleos de función de base radial (RBF) son adecuados para procesar datos no lineales. El siguiente es un ejemplo de código que utiliza el 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

Los resultados del entrenamiento y las pruebas son los siguientes:

Resultados del entrenamiento:

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

Resultados de la prueba:

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

A través del proceso de capacitación y evaluación del modelo anterior, podemos observar las diferencias de rendimiento de diferentes núcleos SVM. SVM de núcleo lineal funciona bien en términos de precisión y tiempo de entrenamiento, y es adecuado para situaciones con dimensiones de datos más altas. El SVM de núcleo polinómico y el SVM de núcleo RBF tienen un mejor rendimiento en datos no lineales, pero pueden provocar un sobreajuste en determinadas configuraciones de parámetros. Elegir núcleos e hiperparámetros apropiados es crucial para mejorar el rendimiento del modelo.

4. Preparación de datos SVM

entrada digital : SVM asume que los datos de entrada son numéricos. Si los datos de entrada son variables categóricas, es posible que necesite convertirlos en variables ficticias binarias (una variable por categoría).

clasificación binaria :Basic SVM es adecuado para problemas de clasificación binaria. Aunque SVM se utiliza principalmente para clasificación binaria, también existen versiones extendidas para regresión y clasificación multiclase.

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

Formación y evaluación de modelos.

A continuación se muestran los resultados del entrenamiento y las pruebas de diferentes kernels SVM:

SVM de núcleo lineal

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 del entrenamiento:

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 núcleo polinómico

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 del entrenamiento:

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

Función de base radial Kernel 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 del entrenamiento:

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

Admite ajuste de hiperparámetros de máquina vectorial

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 del entrenamiento:

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álisis de componentes principales

Introducción a la PCA

El análisis de componentes principales (PCA) es una técnica que logra la reducción de la dimensionalidad lineal proyectando datos en un espacio de dimensiones inferiores. Los pasos específicos son los siguientes:

• Usar descomposición de valores singulares: Proyecta datos en un espacio de baja dimensión mediante descomposición de valores singulares.
• aprendizaje sin supervisión: PCA no requiere datos etiquetados para la reducción de dimensionalidad.
• Transformación de características: Intente encontrar qué características explican la mayor variación en los datos.

visualización PCA

Dado que los datos de alta dimensión son difíciles de visualizar directamente, podemos usar PCA para encontrar los dos primeros componentes principales y visualizar los datos en un espacio bidimensional. Para lograr esto, primero es necesario normalizar los datos para que la varianza de cada característica sea una varianza unitaria.

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

A través de los dos primeros componentes principales, podemos separar fácilmente diferentes categorías de puntos de datos en un espacio bidimensional.

Explicar los componentes

Aunque la reducción de dimensionalidad es poderosa, el significado de los componentes es difícil de entender directamente. Cada componente corresponde a una combinación de características originales, que se pueden obtener adaptando un objeto PCA.

Las propiedades relacionadas con los componentes incluyen:

• puntuación de ingredientes: El valor de la variable transformada.
• Carga (peso): Peso combinado de características.
• Compresión de datos y preservación de la información.: La compresión de datos se logra mediante PCA conservando información clave.
• Filtrado de ruido: El ruido se puede filtrar durante el proceso de reducción de dimensionalidad.
• Extracción e ingeniería de características.: Se utiliza para extraer y construir nuevas funciones.

Ajuste de parámetros del modelo de máquina de vectores de soporte (SVM)

Cuando utilizamos máquinas de vectores de soporte (SVM) para el entrenamiento de modelos, debemos ajustar los hiperparámetros para obtener el mejor modelo. El siguiente es un código de muestra para ajustar los parámetros de SVM mediante la búsqueda de cuadrícula (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 del entrenamiento:

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. Resumen

En este artículo aprendimos lo siguiente:

• Máquina de vectores de soporte (SVM): Comprender los conceptos básicos de SVM y su implementación en Python.
• Función del núcleo SVM: Incluye funciones lineales, de base radial (RBF) y funciones kernel polinómicas.
• preparación de datos: Cómo preparar datos para el algoritmo SVM.
• Ajuste de hiperparámetros: Ajuste de hiperparámetros SVM mediante búsqueda en cuadrícula.
• Análisis de Componentes Principales (PCA): Cómo utilizar PCA para reducir la complejidad de los datos y reutilizarlos en scikit-learn.

---

Referirse a:Tutorial de PCA y máquinas de vectores de soporte para principiantes
Recomendar mis columnas relacionadas:

• registro de errores de Python
• notas de pitón
• estructura de datos

---