Condivisione della tecnologia

한어Русский язык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.

1. Panoramica delle macchine a vettori di supporto

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.

Cos'è una macchina vettoriale di supporto?

L'obiettivo delle macchine a vettori di supporto è quello di $N$ spazio dimensionale ($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.

Iperpiani e vettori di supporto

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.

Intuizione ad ampio margine

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.

2. Preelaborazione e visualizzazione dei dati

Previsione di diagnosi di cancro benigno e maligno utilizzando macchine vettoriali di supporto.

Informazioni di base sul set di dati

• Il numero di funzioni è 30, ad esempio:
  • Raggio (distanza media dal centro ai punti perimetrali)
  • Texture (deviazione standard dei valori della scala di grigi)
  • perimetro
  • la zona
  • Levigatura (variazione locale nella lunghezza del raggio)
  • Compattezza (perimetro^2 / area - 1.0)
  • Concavità (la gravità della parte depressa del contorno)
  • fossette (il numero di parti concave del contorno)
  • simmetria
  • Dimensione frattale ("Approssimazione della linea costiera" - 1)
• Il set di dati contiene 569 campioni e la distribuzione delle classi è di 212 campioni maligni e 357 campioni benigni.
• Categoria di destinazione:
  • maligno
  • benigno

Importa le librerie necessarie

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

Carica il set di dati

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

Panoramica dei dati

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

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

visualizzazione dati

Matrice del grafico a dispersione di coppie di caratteristiche

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

Grafico a barre di distribuzione delle categorie

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

Grafico a dispersione dell'area media rispetto alla levigatezza media

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

Mappa termica delle correlazioni tra variabili

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

3. Formazione modello (soluzione di problemi)

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.

Preparazione e preelaborazione dei dati

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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.

Valutare le prestazioni del modello

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")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Supporto macchina vettoriale (SVM)

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:

• parametri C : controlla il compromesso tra la corretta classificazione dei punti di formazione e la possibilità di avere confini decisionali uniformi.più piccola$C$(sciolto) riduce i costi di errata classificazione (penalità) (margini deboli), mentre aumenta $C$(rigoroso) rende la classificazione errata più costosa (margine rigido), costringendo il modello a interpretare i dati di input in modo più rigoroso.
• parametro gamma : controlla l'ambito di influenza di un singolo set di allenamento.più grandi$\gamma$ Rendi l'ambito di influenza più vicino (i punti dati più vicini hanno un peso maggiore), più piccolo$\gamma$ Ampliare la portata (soluzioni più ampie).
• parametro del grado: Funzione del kernel polinomiale ('poly' ), ignorato da altri kernel. I valori ottimali degli iperparametri possono essere trovati tramite la ricerca nella griglia.

Kernel lineare SVM

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)
1
2
3
4
5
6
7

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]]
1
2
3
4
5
6
7
8
9
10
11
12

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]]
1
2
3
4
5
6
7
8
9
10
11
12

Kernel polinomiale SVM

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)
1
2
3
4
5
6
7

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]]
1
2
3
4
5
6
7
8
9
10
11
12

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]]
1
2
3
4
5
6
7
8
9
10
11
12

SVM del kernel con funzione a base radiale (RBF).

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)
1
2
3
4
5

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]]
1
2
3
4
5
6
7
8
9
10
11
12

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]]
1
2
3
4
5
6
7
8
9
10
11
12

Riassumere

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.

4. Preparazione dei dati SVM

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)
1
2

Formazione e valutazione del modello

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)
1
2
3
4
5
6

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]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Kernel polinomiale SVM

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

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]]
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

Funzione a base radiale 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

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]]
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

Supporta l'ottimizzazione degli iperparametri della macchina vettoriale

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

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]]
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. Analisi delle componenti principali

Introduzione all'PCA

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:

• Utilizza la scomposizione in valori singolari: Proietta i dati in uno spazio a bassa dimensionalità attraverso la scomposizione di valori singolari.
• apprendimento non supervisionato: PCA non richiede dati etichettati per la riduzione della dimensionalità.
• Trasformazione delle caratteristiche: provare a scoprire quali caratteristiche spiegano la maggiore varianza nei dati.

Visualizzazione PCA

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Attraverso le prime due componenti principali, possiamo facilmente separare diverse categorie di punti dati nello spazio bidimensionale.

Spiegare i componenti

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:

• punteggio degli ingredienti: Il valore della variabile trasformata.
• Carico (peso): peso della combinazione di funzionalità.
• Compressione dei dati e conservazione delle informazioni: La compressione dei dati viene ottenuta tramite PCA mantenendo le informazioni chiave.
• Filtraggio del rumore: Il rumore può essere filtrato durante il processo di riduzione della dimensionalità.
• Estrazione e ingegneria delle funzionalità: utilizzato per estrarre e costruire nuove funzionalità.

Regolazione dei parametri del modello Support Vector Machine (SVM).

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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]]
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. Riepilogo

In questo articolo abbiamo appreso quanto segue:

• Supporto macchina vettoriale (SVM): Comprendere i concetti di base di SVM e la sua implementazione in Python.
• Funzione del kernel SVM: Incluse funzioni lineari, basi radiali (RBF) e funzioni kernel polinomiali.
• preparazione dei dati: Come preparare i dati per l'algoritmo SVM.
• Ottimizzazione degli iperparametri: Ottimizzazione degli iperparametri SVM tramite la ricerca nella griglia.
• Analisi delle componenti principali (PCA): Come utilizzare PCA per ridurre la complessità dei dati e riutilizzarli in scikit-learn.

---

fare riferimento a:Tutorial per principianti su macchine a vettori di supporto e PCA
Consiglia le mie colonne correlate:

• registro degli errori di Python
• note di pitone
• struttura dati

---