Partage de technologie

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

La machine à vecteurs de support (SVM) est un modèle d'apprentissage automatique puissant et polyvalent adapté à la classification linéaire et non linéaire, à la régression et à la détection des valeurs aberrantes. Cet article présentera l'algorithme de machine à vecteurs de support et son implémentation dans scikit-learn, et explorera brièvement l'analyse en composantes principales et son application dans scikit-learn.

1. Aperçu des machines à vecteurs de support

La machine à vecteurs de support (SVM) est un algorithme largement utilisé dans le domaine de l'apprentissage automatique, privilégié pour sa caractéristique de fournir une précision significative avec moins de ressources informatiques. SVM peut être utilisé à la fois pour des tâches de classification et de régression, mais il est plus largement utilisé dans les problèmes de classification.

Qu'est-ce qu'une machine à vecteurs supports ?

Le but des machines à vecteurs de support est de $N$ espace dimensionnel ($N$ est le nombre d'entités) pour trouver un hyperplan capable de distinguer clairement les points de données. Cet hyperplan permet de séparer les points de données de différentes catégories et les plus éloignés possible de l'hyperplan pour assurer la robustesse de la classification.

Afin d'obtenir une séparation efficace des points de données, plusieurs hyperplans peuvent exister. Notre objectif est de choisir un hyperplan avec une marge maximale, c'est-à-dire la distance maximale entre deux classes. Maximiser les marges contribue à améliorer la précision de la classification.

Hyperplans et vecteurs de support

Un hyperplan est une limite de décision qui divise les points de données. Les points de données situés des deux côtés de l’hyperplan peuvent être classés en différentes catégories. Les dimensions de l'hyperplan dépendent du nombre d'entités : si les entités en entrée sont 2, l'hyperplan est une ligne droite ; si les entités sont 3, l'hyperplan est un plan bidimensionnel. Lorsque le nombre de fonctionnalités dépasse 3, l’hyperplan devient difficile à comprendre intuitivement.

Les vecteurs de support font référence aux points les plus proches de l'hyperplan, qui affectent la position et la direction de l'hyperplan. Avec ces vecteurs supports, nous pouvons maximiser la marge du classificateur. La suppression des vecteurs de support modifie la position de l'hyperplan, ils sont donc cruciaux pour la construction d'un SVM.

Intuition à grande marge

En régression logistique, nous utilisons la fonction sigmoïde pour compresser la valeur de sortie de la fonction linéaire dans la plage [0,1] et attribuer des étiquettes en fonction d'un seuil (0,5). Dans SVM, nous utilisons la valeur de sortie d'une fonction linéaire pour décider de la classification : si la sortie est supérieure à 1, elle appartient à une classe ; si la sortie est -1, elle appartient à une autre classe. SVM forme la plage marginale [-1,1] en définissant le seuil de la valeur de sortie sur 1 et -1.

2. Prétraitement et visualisation des données

Prédire les diagnostics de cancer bénin et malin à l'aide de machines à vecteurs de support.

Informations de base sur l'ensemble de données

• Le nombre de fonctionnalités est de 30, par exemple :
  • Rayon (distance moyenne du centre aux points du périmètre)
  • Texture (écart type des valeurs en niveaux de gris)
  • périmètre
  • zone
  • Lissé (variation locale de la longueur du rayon)
  • Compacité (Périmètre ^ 2 / Surface - 1,0)
  • Concavité (la gravité de la partie déprimée du contour)
  • Fossettes (le nombre de parties concaves du contour)
  • symétrie
  • Dimension fractale ("approximation du littoral" - 1)
• L'ensemble de données contient 569 échantillons et la répartition par classe est de 212 échantillons malins et 357 échantillons bénins.
• Catégorie cible :
  • malin
  • bénin

Importer les bibliothèques nécessaires

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

Charger l'ensemble de données

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

Aperçu des données

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

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

visualisation de données

Matrice de nuages ​​de points de paires de caractéristiques

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

Graphique à barres de répartition des catégories

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

Nuage de points de la surface moyenne par rapport à la douceur moyenne

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

Carte thermique des corrélations entre variables

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

3. Formation sur modèle (résolution de problèmes)

En apprentissage automatique, la formation de modèles est une étape cruciale dans la recherche de solutions aux problèmes.Ci-dessous, nous présenterons comment utiliserscikit-learn Effectuer une formation sur le modèle et démontrer les performances de la machine à vecteurs de support (SVM) sous différents noyaux.

Préparation et prétraitement des données

Tout d’abord, nous devons préparer et prétraiter les données. Voici un exemple de code pour le prétraitement des données :

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

Dans le code que nous utilisons MinMaxScaler etStandardScaler Mettez à l'échelle les données. Les données sont divisées en ensembles de formation et de test, 30 % des données étant utilisées pour les tests.

Évaluer les performances du modèle

Pour évaluer les performances du modèle, nous définissons un print_score Fonction, qui peut produire l'exactitude, le rapport de classification et la matrice de confusion des résultats de formation et de test :

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

Machine à vecteurs de support (SVM)

La machine à vecteurs de support (SVM) est un puissant algorithme de classification dont les performances sont affectées par les hyperparamètres. Ce qui suit présentera les principaux paramètres de SVM et leur impact sur les performances du modèle :

• Paramètres C : contrôle le compromis entre la classification correcte des points d'entraînement et l'obtention de limites de décision lisses.plus petit$C$(faible) réduit les coûts de mauvaise classification (pénalités) (marges douces), tandis que des coûts plus élevés $C$(strict) rend une mauvaise classification plus coûteuse (marge dure), obligeant le modèle à interpréter les données d'entrée de manière plus stricte.
• paramètre gamma : Contrôler la portée d’influence d’un seul ensemble de formation.plus grand$\gamma$ Rendre la portée de l'influence plus proche (les points de données les plus proches ont un poids plus élevé), plus petit$\gamma$ Élargir la portée (solutions plus larges).
• paramètre de degré: Fonction du noyau polynomial ('poly' ), ignoré par les autres noyaux. Les valeurs optimales des hyperparamètres peuvent être trouvées grâce à la recherche par grille.

SVM à noyau linéaire

Le SVM à noyau linéaire convient à la plupart des situations, en particulier lorsque l'ensemble de données comporte un grand nombre de fonctionnalités. Voici un exemple de code utilisant le SVM à noyau linéaire :

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

Les résultats de la formation et des tests sont les suivants :

Résultats de la formation :

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

Résultats de test:

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 à noyau polynomial

Le noyau polynomial SVM convient aux données non linéaires. Voici un exemple de code utilisant un noyau polynomial du second ordre :

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

Les résultats de la formation et des tests sont les suivants :

Résultats de la formation :

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

Résultats de test:

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 du noyau de fonction de base radiale (RBF)

Les noyaux de fonction de base radiale (RBF) conviennent au traitement de données non linéaires. Voici un exemple de code utilisant le noyau 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

Les résultats de la formation et des tests sont les suivants :

Résultats de la formation :

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

Résultats de test:

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

Résumer

Grâce au processus de formation et d'évaluation du modèle ci-dessus, nous pouvons observer les différences de performances des différents noyaux SVM. Le SVM à noyau linéaire fonctionne bien en termes de précision et de temps de formation, et convient aux situations avec des dimensions de données plus élevées. Le SVM à noyau polynomial et le SVM à noyau RBF ont de meilleures performances sur les données non linéaires, mais peuvent conduire à un surajustement sous certains paramètres. Le choix des noyaux et des hyperparamètres appropriés est crucial pour améliorer les performances du modèle.

4. Préparation des données SVM

entrée numérique : SVM suppose que les données d'entrée sont numériques. Si les données d'entrée sont des variables catégorielles, vous devrez peut-être les convertir en variables binaires factices (une variable par catégorie).

classification binaire :Basic SVM convient aux problèmes de classification binaire. Bien que SVM soit principalement utilisé pour la classification binaire, il existe également des versions étendues pour la régression et la classification multi-classes.

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

Formation et évaluation des modèles

Ce qui suit montre les résultats de formation et de test des différents noyaux SVM :

SVM à noyau linéaire

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

Résultats de la formation :

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 à noyau polynomial

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

Résultats de la formation :

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

SVM à noyau de fonction à base radiale

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

Résultats de la formation :

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

Prise en charge du réglage des hyperparamètres de la machine vectorielle

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

Résultats de la formation :

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. Analyse en composantes principales

Introduction à l'APC

L'analyse en composantes principales (ACP) est une technique qui permet de réduire la dimensionnalité linéaire en projetant des données dans un espace de dimension inférieure. Les étapes spécifiques sont les suivantes :

• Utiliser la décomposition en valeurs singulières: Projetez des données dans un espace de faible dimension grâce à une décomposition en valeurs singulières.
• apprentissage non supervisé: PCA ne nécessite pas de données étiquetées pour la réduction de dimensionnalité.
• Transformation des fonctionnalités: Essayez de trouver quelles caractéristiques expliquent le plus de variance dans les données.

Visualisation ACP

Étant donné que les données de grande dimension sont difficiles à visualiser directement, nous pouvons utiliser l'ACP pour trouver les deux premières composantes principales et visualiser les données dans un espace bidimensionnel. Pour y parvenir, les données doivent d'abord être normalisées afin que la variance de chaque caractéristique soit une variance unitaire.

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

Grâce aux deux premiers composants principaux, nous pouvons facilement séparer différentes catégories de points de données dans un espace bidimensionnel.

Expliquer les composants

Bien que la réduction de dimensionnalité soit puissante, la signification des composants est difficile à comprendre directement. Chaque composant correspond à une combinaison de fonctionnalités originales, qui peuvent être obtenues en ajustant un objet PCA.

Les propriétés liées aux composants incluent :

• score d'ingrédient: La valeur de la variable transformée.
• Charge (poids): Combinaison de poids des fonctionnalités.
• Compression des données et préservation des informations: La compression des données est réalisée via PCA tout en conservant les informations clés.
• Filtrage du bruit: Le bruit peut être filtré pendant le processus de réduction de dimensionnalité.
• Extraction et ingénierie de fonctionnalités: Utilisé pour extraire et construire de nouvelles fonctionnalités.

Ajustement des paramètres du modèle de machine à vecteurs de support (SVM)

Lorsque nous utilisons des machines à vecteurs de support (SVM) pour la formation de modèles, nous devons ajuster les hyperparamètres pour obtenir le meilleur modèle. Voici un exemple de code permettant d'ajuster les paramètres SVM à l'aide de la recherche par grille (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

Résultats de la formation :

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. Résumé

Dans cet article, nous avons appris ce qui suit :

• Machine à vecteurs de support (SVM): Comprendre les concepts de base de SVM et son implémentation en Python.
• Fonction du noyau SVM: Y compris les fonctions de base linéaires et radiales (RBF) et les fonctions de noyau polynomial.
• préparation des données: Comment préparer les données pour l'algorithme SVM.
• Réglage des hyperparamètres: Réglage des hyperparamètres SVM via la recherche de grille.
• Analyse en composantes principales (ACP): Comment utiliser PCA pour réduire la complexité des données et les réutiliser dans scikit-learn.

---

faire référence à:Tutoriel sur la machine à vecteurs de support et l'ACP pour débutants
Recommander mes chroniques associées :

• journal des erreurs python
• remarques sur Python
• Structure de données

---