2024-07-12
한어Русский язык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.
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.
Le but des machines à vecteurs de support est de NNN espace dimensionnel ( NNN 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.
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.
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.
Prédire les diagnostics de cancer bénin et malin à l'aide de machines à vecteurs de support.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
sns.set_style('whitegrid')
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()
df.info()print(cancer.target_names)
# ['malignant', 'benign']
# 数据描述:
df.describe()
# 统计摘要:
df.info()
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'
])
sns.countplot(x=df['target'], label="Count")
plt.figure(figsize=(10, 8))
sns.scatterplot(x='mean area', y='mean smoothness', hue='target', data=df)
plt.figure(figsize=(20,10))
sns.heatmap(df.corr(), annot=True)
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.
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)
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.
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")
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 :
'poly'
), ignoré par les autres noyaux. Les valeurs optimales des hyperparamètres peuvent être trouvées grâce à la recherche par grille.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)
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]]
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]]
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)
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]]
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]]
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)
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]]
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]]
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.
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)
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)
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]]
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)
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]]
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)
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]]
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)
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]]
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 :
É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()
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.
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 :
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)
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]]
Dans cet article, nous avons appris ce qui suit :
faire référence à:Tutoriel sur la machine à vecteurs de support et l'ACP pour débutants
Recommander mes chroniques associées :