Hvordan kan biblioteker som scikit-learn brukes til å implementere SVM-klassifisering i Python, og hva er nøkkelfunksjonene involvert?

/ / Publisert i Kunstig intelligens , EITC/AI/MLP maskinlæring med Python, Støtte vektor maskin, Støtte vektor maskinoptimalisering, Eksamensgjennomgang

Support Vector Machines (SVM) er en kraftig og allsidig klasse med overvåkede maskinlæringsalgoritmer som er spesielt effektive for klassifiseringsoppgaver. Biblioteker som scikit-learn i Python gir robuste implementeringer av SVM, noe som gjør det tilgjengelig for både praktikere og forskere. Dette svaret vil belyse hvordan scikit-learn kan brukes for å implementere SVM-klassifisering, detaljering av nøkkelfunksjonene som er involvert og gir illustrerende eksempler.

Introduksjon til SVM

Support Vector Machines opererer ved å finne hyperplanet som best skiller dataene i forskjellige klasser. I et todimensjonalt rom er dette hyperplanet ganske enkelt en linje, men i høyere dimensjoner blir det et plan eller hyperplan. Det optimale hyperplanet er det som maksimerer marginen mellom de to klassene, der marginen er definert som avstanden mellom hyperplanet og de nærmeste datapunktene fra hver klasse, kjent som støttevektorer.

Scikit-learn og SVM

Scikit-learn er et kraftig Python-bibliotek for maskinlæring som gir enkle og effektive verktøy for datautvinning og dataanalyse. Den er bygget på NumPy, SciPy og matplotlib. `svm`-modulen i scikit-learn gir implementering av SVM-algoritmer.

Nøkkelfunksjoner

1. `svm.SVC`: Dette er hovedklassen for å utføre klassifisering ved bruk av SVM. SVC står for Support Vector Classification.
2. 'passe': Denne metoden brukes til å trene modellen på de gitte dataene.
3. `forutsi`: Når modellen er trent, brukes denne metoden til å forutsi klasseetikettene for de gitte testdataene.
4. `score`: Denne metoden brukes til å evaluere nøyaktigheten til modellen på testdataene.
5. `GridSearchCV`: Dette brukes til hyperparameterinnstilling for å finne de beste parametrene for SVM-modellen.

Implementering av SVM-klassifisering med scikit-learn

La oss vurdere trinnene som er involvert i implementering av SVM-klassifisering ved hjelp av scikit-learn.

Trinn 1: Importere biblioteker

Importer først de nødvendige bibliotekene:

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
Trinn 2: Lasting av datasettet

For demonstrasjonsformål vil vi bruke Iris-datasettet, et velkjent datasett i maskinlæringsfellesskapet:

python
# Load the Iris dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target
Trinn 3: Deling av datasettet

Del opp datasettet i trenings- og testsett:

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)
Trinn 4: Funksjonsskalering

Funksjonsskalering er viktig for SVM siden den er følsom for skalaen til inngangsfunksjonene:

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)
Trinn 5: Trening av SVM-modellen

Instantier SVM-klassifisereren og tren den på treningsdataene:

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

Her brukte vi en lineær kjerne og satte regulariseringsparameteren 'C' til 1.0. Kjerneparameteren spesifiserer typen hyperplan som brukes til å skille dataene. Vanlige kjerner inkluderer 'lineær', 'poly' (polynom), 'rbf' (radial basisfunksjon) og 'sigmoid'.

Trinn 6: Lag spådommer

Bruk den trente modellen til å forutsi testdataene:

python
# Predict the class labels for the test set
y_pred = svc.predict(X_test)
Trinn 7: Evaluering av modellen

Evaluer modellens ytelse ved å bruke beregninger som forvirringsmatrise og klassifiseringsrapport:

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

Forvirringsmatrisen gir et sammendrag av prediksjonsresultatene, mens klassifiseringsrapporten inkluderer presisjon, tilbakekalling, F1-score og støtte for hver klasse.

Hyperparameterjustering med GridSearchCV

Hyperparameterinnstilling er avgjørende for å optimalisere ytelsen til en SVM-modell. Scikit-learns `GridSearchCV` kan brukes til å utføre et uttømmende søk over et spesifisert parametergitter:

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

I dette eksemplet søkte vi over et rutenett med verdier for 'C' og 'gamma' ved å bruke RBF-kjernen. `GridSearchCV`-forekomsten gjenoppretter modellen med de beste parameterne som ble funnet under søket.

Visualisere beslutningsgrensen

For en bedre forståelse av hvordan SVM-klassifikatoren fungerer, er det ofte nyttig å visualisere beslutningsgrensen. Dette er mer enkelt i et todimensjonalt funksjonsrom. Nedenfor er et eksempel på bruk av et syntetisk datasett:

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()

Koden ovenfor genererer et syntetisk datasett med to klasser, passer til en SVM-modell med en lineær kjerne, og visualiserer beslutningsgrensen. `contourf`-funksjonen brukes til å plotte beslutningsgrensen, og spredningsplottet viser datapunktene.Scikit-learn gir et omfattende og brukervennlig grensesnitt for implementering av SVM-klassifisering i Python. Nøkkelfunksjonene som `svm.SVC`, `fit`, `predict` og `score` er avgjørende for å bygge og evaluere SVM-modeller. Hyperparameterinnstilling med `GridSearchCV` forbedrer modellytelsen ytterligere ved å finne de optimale parameterne. Å visualisere beslutningsgrensen kan gi verdifull innsikt i klassifisererens atferd. Ved å følge disse trinnene kan man effektivt implementere og optimalisere SVM-klassifisering ved å bruke scikit-learn.

Andre nyere spørsmål og svar vedr EITC/AI/MLP maskinlæring med Python:

Se flere spørsmål og svar i EITC/AI/MLP Machine Learning with Python

Flere spørsmål og svar:

Merket under: , , , , ,