Come possono essere utilizzate librerie come scikit-learn per implementare la classificazione SVM in Python e quali sono le funzioni chiave coinvolte?

/ / Pubblicato in Intelligenza Artificiale, Apprendimento automatico EITC/AI/MLP con Python, Supporta la macchina vettoriale, Supporta l'ottimizzazione della macchina vettoriale, Revisione d'esame

Le Support Vector Machines (SVM) sono una classe potente e versatile di algoritmi di apprendimento automatico supervisionati particolarmente efficaci per attività di classificazione. Librerie come scikit-learn in Python forniscono robuste implementazioni di SVM, rendendolo accessibile sia a professionisti che a ricercatori. Questa risposta chiarirà come utilizzare scikit-learn per implementare la classificazione SVM, descrivendo in dettaglio le funzioni chiave coinvolte e fornendo esempi illustrativi.

Introduzione alla SVM

Le Support Vector Machines operano trovando l'iperpiano che meglio separa i dati in classi diverse. In uno spazio bidimensionale, questo iperpiano è semplicemente una linea, ma nelle dimensioni superiori diventa un piano o iperpiano. L'iperpiano ottimale è quello che massimizza il margine tra le due classi, dove il margine è definito come la distanza tra l'iperpiano e i punti dati più vicini da ciascuna classe, noti come vettori di supporto.

Scikit-impara e SVM

Scikit-learn è una potente libreria Python per l'apprendimento automatico che fornisce strumenti semplici ed efficienti per il data mining e l'analisi dei dati. È basato su NumPy, SciPy e matplotlib. Il modulo `svm` all'interno di scikit-learn fornisce l'implementazione degli algoritmi SVM.

Funzioni chiave

1. `svm.SVC`: Questa è la classe principale per eseguire la classificazione utilizzando SVM. SVC sta per Support Vector Classification.
2. `adatto`: Questo metodo viene utilizzato per addestrare il modello sui dati forniti.
3. `predire`: una volta addestrato il modello, questo metodo viene utilizzato per prevedere le etichette delle classi per i dati di test forniti.
4. `punteggio`: Questo metodo viene utilizzato per valutare l'accuratezza del modello sui dati di test.
5. `GridSearchCV`: viene utilizzato per l'ottimizzazione degli iperparametri per trovare i parametri migliori per il modello SVM.

Implementazione della classificazione SVM con scikit-learn

Consideriamo i passaggi necessari per implementare la classificazione SVM utilizzando scikit-learn.

Passaggio 1: importazione di librerie

Innanzitutto, importa le librerie necessarie:

python
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix
Passaggio 2: caricamento del set di dati

A scopo dimostrativo, utilizzeremo il set di dati Iris, un set di dati ben noto nella comunità del machine learning:

python
# Load the Iris dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target
Passaggio 3: suddivisione del set di dati

Suddividi il set di dati in set di training e test:

python
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Passaggio 4: ridimensionamento delle funzionalità

Il ridimensionamento delle funzionalità è importante per SVM poiché è sensibile alla scala delle funzionalità di input:

python
# Standardize features by removing the mean and scaling to unit variance
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Passaggio 5: addestramento del modello SVM

Istanziare il classificatore SVM e addestrarlo sui dati di training:

python
# Create an instance of SVC and fit the data
svc = SVC(kernel='linear', C=1.0)
svc.fit(X_train, y_train)

Qui abbiamo utilizzato un kernel lineare e abbiamo impostato il parametro di regolarizzazione "C" su 1.0. Il parametro del kernel specifica il tipo di iperpiano utilizzato per separare i dati. I kernel comuni includono "lineare", "poli" (polinomio), "rbf" (funzione di base radiale) e "sigmoide".

Passaggio 6: fare previsioni

Utilizza il modello addestrato per fare previsioni sui dati del test:

python
# Predict the class labels for the test set
y_pred = svc.predict(X_test)
Passaggio 7: valutazione del modello

Valuta le prestazioni del modello utilizzando metriche come la matrice di confusione e il rapporto di classificazione:

python
# Evaluate the model
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

La matrice di confusione fornisce un riepilogo dei risultati della previsione, mentre il rapporto di classificazione include precisione, richiamo, punteggio F1 e supporto per ciascuna classe.

Ottimizzazione degli iperparametri con GridSearchCV

L'ottimizzazione degli iperparametri è essenziale per ottimizzare le prestazioni di un modello SVM. `GridSearchCV` di Scikit-learn può essere utilizzato per eseguire una ricerca esaustiva su una griglia di parametri specificata:

python
from sklearn.model_selection import GridSearchCV

# Define the parameter grid
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [1, 0.1, 0.01, 0.001],
    'kernel': ['rbf']
}

# Create a GridSearchCV instance
grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=2)
grid.fit(X_train, y_train)

# Print the best parameters and the corresponding score
print("Best parameters found: ", grid.best_params_)
print("Best score: ", grid.best_score_)

# Use the best estimator to make predictions
grid_predictions = grid.predict(X_test)

# Evaluate the model with the best parameters
print(confusion_matrix(y_test, grid_predictions))
print(classification_report(y_test, grid_predictions))

In questo esempio, abbiamo cercato "C" e "gamma" su una griglia di valori utilizzando il kernel RBF. L'istanza `GridSearchCV` adatta il modello con i migliori parametri trovati durante la ricerca.

Visualizzazione del confine decisionale

Per una migliore comprensione del funzionamento del classificatore SVM, è spesso utile visualizzare il confine decisionale. Ciò è più semplice in uno spazio di funzionalità bidimensionale. Di seguito è riportato un esempio che utilizza un set di dati sintetico:

python
from sklearn.datasets import make_blobs

# Generate a synthetic dataset
X, y = make_blobs(n_samples=100, centers=2, random_state=6)

# Fit the SVM model
svc = SVC(kernel='linear', C=1.0)
svc.fit(X, y)

# Create a mesh to plot the decision boundary
h = .02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

# Predict the class for each point in the mesh
Z = svc.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot the decision boundary
plt.contourf(xx, yy, Z, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', marker='o')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('SVM Decision Boundary')
plt.show()

Il codice precedente genera un set di dati sintetico con due classi, adatta un modello SVM con un kernel lineare e visualizza il confine decisionale. La funzione "contourf" viene utilizzata per tracciare il confine della decisione e il grafico a dispersione mostra i punti dati. Scikit-learn fornisce un'interfaccia completa e intuitiva per implementare la classificazione SVM in Python. Le funzioni chiave come "svm.SVC", "fit", "predict" e "score" sono essenziali per creare e valutare modelli SVM. L'ottimizzazione degli iperparametri con "GridSearchCV" migliora ulteriormente le prestazioni del modello trovando i parametri ottimali. Visualizzare il confine decisionale può fornire informazioni preziose sul comportamento del classificatore. Seguendo questi passaggi, è possibile implementare e ottimizzare in modo efficace la classificazione SVM utilizzando scikit-learn.

Altre domande e risposte recenti riguardanti Apprendimento automatico EITC/AI/MLP con Python:

Visualizza altre domande e risposte in EITC/AI/MLP Machine Learning con Python

Altre domande e risposte:

Etichettato sotto: , , , , ,