le mie informazioni di contatto
Posta[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Support Vector Machine (SVM) è un modello di machine learning potente e versatile adatto alla classificazione lineare e non lineare, alla regressione e al rilevamento di valori anomali. Questo articolo introdurrà l'algoritmo della Support Vector Machine e la sua implementazione in scikit-learn ed esplorerà brevemente l'analisi dei componenti principali e la sua applicazione in scikit-learn.
La Support Vector Machine (SVM) è un algoritmo ampiamente utilizzato nel campo dell'apprendimento automatico, favorito per la sua caratteristica di fornire una precisione significativa con minori risorse di calcolo. SVM può essere utilizzato sia per attività di classificazione che di regressione, ma è ampiamente utilizzato nei problemi di classificazione.
L'obiettivo delle macchine a vettori di supporto è quello di N.N.N spazio dimensionale ( N.N.N è il numero di caratteristiche) per trovare un iperpiano in grado di distinguere chiaramente i punti dati. Questo iperpiano consente di separare i punti dati di diverse categorie e di posizionarli il più lontano possibile dall'iperpiano per garantire la robustezza della classificazione.
Per ottenere una separazione efficace dei punti dati, possono esistere più iperpiani. Il nostro obiettivo è scegliere un iperpiano con il massimo margine, ovvero la massima distanza tra due classi. L'ottimizzazione dei margini aiuta a migliorare l'accuratezza della classificazione.
Un iperpiano è un confine decisionale che divide i punti dati. I punti dati situati su entrambi i lati dell'iperpiano possono essere classificati in diverse categorie. Le dimensioni dell'iperpiano dipendono dal numero di elementi: se gli elementi in input sono 2, l'iperpiano è una linea retta; se gli elementi sono 3, l'iperpiano è un piano bidimensionale. Quando il numero di caratteristiche supera 3, l'iperpiano diventa difficile da comprendere intuitivamente.
I vettori di supporto si riferiscono a quei punti più vicini all'iperpiano, che influenzano la posizione e la direzione dell'iperpiano. Con questi vettori di supporto possiamo massimizzare il margine del classificatore. La rimozione dei vettori di supporto modifica la posizione dell'iperpiano, quindi sono cruciali per costruire una SVM.
Nella regressione logistica, utilizziamo la funzione sigmoide per comprimere il valore di output della funzione lineare nell'intervallo [0,1] e assegnare etichette in base a una soglia (0,5). In SVM utilizziamo il valore di output di una funzione lineare per decidere la classificazione: se l'output è maggiore di 1, appartiene a una classe; se l'output è -1, appartiene a un'altra classe. SVM forma l'intervallo marginale [-1,1] impostando la soglia del valore di uscita su 1 e -1.
Previsione di diagnosi di cancro benigno e maligno utilizzando macchine vettoriali di supporto.
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)
Nell'apprendimento automatico, l'addestramento dei modelli è un passaggio fondamentale nella ricerca di soluzioni ai problemi.Di seguito introdurremo come utilizzarescikit-learn
Effettuare l'addestramento del modello e dimostrare le prestazioni della Support Vector Machine (SVM) con kernel diversi.
Innanzitutto, dobbiamo preparare e preelaborare i dati. Di seguito è riportato un esempio di codice per la preelaborazione dei dati:
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)
Nel codice che usiamo MinMaxScaler
EStandardScaler
Ridimensionare i dati. I dati sono suddivisi in set di training e test, con il 30% dei dati utilizzati per i test.
Per valutare le prestazioni del modello, definiamo a print_score
funzione, che può produrre l'accuratezza, il rapporto di classificazione e la matrice di confusione dei risultati della formazione e dei 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")
Support Vector Machine (SVM) è un potente algoritmo di classificazione le cui prestazioni sono influenzate dagli iperparametri. Di seguito verranno introdotti i principali parametri di SVM e il loro impatto sulle prestazioni del modello:
'poly'
), ignorato da altri kernel. I valori ottimali degli iperparametri possono essere trovati tramite la ricerca nella griglia.Il kernel lineare SVM è adatto alla maggior parte delle situazioni, soprattutto quando il set di dati ha un gran numero di funzionalità. Di seguito è riportato un esempio di codice che utilizza SVM del kernel lineare:
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)
I risultati della formazione e dei test sono i seguenti:
Risultati della formazione:
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]]
Risultati del 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]]
Il kernel polinomiale SVM è adatto per dati non lineari. Quello che segue è un esempio di codice che utilizza un kernel polinomiale del secondo ordine:
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)
I risultati della formazione e dei test sono i seguenti:
Risultati della formazione:
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]]
Risultati del 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]]
I kernel con funzione di base radiale (RBF) sono adatti per l'elaborazione di dati non lineari. Di seguito è riportato un esempio di codice che utilizza il core 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)
I risultati della formazione e dei test sono i seguenti:
Risultati della formazione:
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]]
Risultati del 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]]
Attraverso il processo di formazione e valutazione del modello di cui sopra, possiamo osservare le differenze di prestazioni dei diversi kernel SVM. Il kernel lineare SVM funziona bene in termini di precisione e tempo di addestramento ed è adatto a situazioni con dimensioni di dati più elevate. La SVM del kernel polinomiale e la SVM del kernel RBF offrono prestazioni migliori sui dati non lineari, ma possono portare a un adattamento eccessivo con determinate impostazioni dei parametri. La scelta di kernel e iperparametri appropriati è fondamentale per migliorare le prestazioni del modello.
input digitale : SVM presuppone che i dati di input siano numerici. Se i dati di input sono variabili categoriali, potrebbe essere necessario convertirli in variabili fittizie binarie (una variabile per categoria).
classificazione binaria :SVM di base è adatto per problemi di classificazione binaria. Sebbene SVM venga utilizzato principalmente per la classificazione binaria, esistono anche versioni estese per la regressione e la classificazione multiclasse.
X_train = pipeline.fit_transform(X_train)
X_test = pipeline.transform(X_test)
Di seguito sono mostrati i risultati del training e dei test di diversi kernel SVM:
Kernel lineare SVM
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)
Risultati della formazione:
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)
Risultati della formazione:
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)
Risultati della formazione:
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)
Risultati della formazione:
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'analisi delle componenti principali (PCA) è una tecnica che ottiene la riduzione della dimensionalità lineare proiettando i dati in uno spazio dimensionale inferiore. I passaggi specifici sono i seguenti:
Poiché i dati ad alta dimensione sono difficili da visualizzare direttamente, possiamo utilizzare la PCA per trovare i primi due componenti principali e visualizzare i dati nello spazio bidimensionale. Per raggiungere questo obiettivo, i dati devono essere prima normalizzati in modo che la varianza di ciascuna caratteristica sia 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()
Attraverso le prime due componenti principali, possiamo facilmente separare diverse categorie di punti dati nello spazio bidimensionale.
Sebbene la riduzione della dimensionalità sia potente, il significato dei componenti è difficile da comprendere direttamente. Ogni componente corrisponde ad una combinazione di caratteristiche originali, ottenibili montando un oggetto PCA.
Le proprietà relative ai componenti includono:
Quando si utilizzano le macchine a vettori di supporto (SVM) per l'addestramento del modello, è necessario regolare gli iperparametri per ottenere il modello migliore. Quello che segue è un codice di esempio per regolare i parametri SVM utilizzando la ricerca nella griglia (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)
Risultati della formazione:
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]]
In questo articolo abbiamo appreso quanto segue:
fare riferimento a:Tutorial per principianti su macchine a vettori di supporto e PCA
Consiglia le mie colonne correlate: