W jaki sposób można wykorzystać biblioteki takie jak scikit-learn do implementacji klasyfikacji SVM w Pythonie i jakie kluczowe funkcje są z tym związane?

/ / Opublikowano w Artificial Intelligence, EITC/AI/MLP Uczenie Maszynowe z Pythonem, Maszyna wektorów nośnych, Wsparcie optymalizacji maszyn wektorowych, Przegląd egzaminów

Maszyny wektorów nośnych (SVM) to potężna i wszechstronna klasa nadzorowanych algorytmów uczenia maszynowego, szczególnie skuteczna w zadaniach klasyfikacyjnych. Biblioteki takie jak scikit-learn w Pythonie zapewniają solidne implementacje SVM, dzięki czemu są dostępne zarówno dla praktyków, jak i badaczy. Ta odpowiedź wyjaśni, w jaki sposób można zastosować scikit-learn do wdrożenia klasyfikacji SVM, wyszczególniając kluczowe funkcje i podając ilustrujące przykłady.

Wprowadzenie do SVM

Maszyny wektorów nośnych działają poprzez znalezienie hiperpłaszczyzny, która najlepiej dzieli dane na różne klasy. W przestrzeni dwuwymiarowej hiperpłaszczyzna jest po prostu linią, ale w wyższych wymiarach staje się płaszczyzną lub hiperpłaszczyzną. Optymalna hiperpłaszczyzna to taka, która maksymalizuje margines między dwiema klasami, gdzie margines definiuje się jako odległość między hiperpłaszczyzną a najbliższymi punktami danych z którejkolwiek klasy, zwaną wektorami nośnymi.

Scikit-learn i SVM

Scikit-learn to potężna biblioteka Pythona do uczenia maszynowego, która zapewnia proste i wydajne narzędzia do eksploracji i analizy danych. Jest zbudowany na NumPy, SciPy i matplotlib. Moduł `svm` w scikit-learn zapewnia implementację algorytmów SVM.

Kluczowe funkcje

1. `svm.SVC`: Jest to główna klasa służąca do klasyfikacji przy użyciu SVM. SVC oznacza klasyfikację wektorów nośnych.
2. `pasować`: Ta metoda służy do uczenia modelu na podanych danych.
3. `przewidzieć`: Po przeszkoleniu modelu ta metoda służy do przewidywania etykiet klas dla danych testowych.
4. `wynik`: Ta metoda służy do oceny dokładności modelu na danych testowych.
5. `GridSearchCV`: Służy do dostrajania hiperparametrów w celu znalezienia najlepszych parametrów dla modelu SVM.

Implementacja klasyfikacji SVM za pomocą scikit-learn

Rozważmy kroki związane z implementacją klasyfikacji SVM za pomocą scikit-learn.

Krok 1: Importowanie bibliotek

Najpierw zaimportuj niezbędne biblioteki:

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
Krok 2: Ładowanie zbioru danych

Do celów demonstracyjnych użyjemy zbioru danych Iris, dobrze znanego zbioru danych w społeczności uczących się maszyn:

python
# Load the Iris dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target
Krok 3: Dzielenie zbioru danych

Podziel zbiór danych na zbiory szkoleniowe i testowe:

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)
Krok 4: Skalowanie funkcji

Skalowanie funkcji jest ważne dla SVM, ponieważ jest wrażliwe na skalę funkcji wejściowych:

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)
Krok 5: Trenowanie modelu SVM

Utwórz instancję klasyfikatora SVM i wytrenuj go na danych szkoleniowych:

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

Tutaj użyliśmy jądra liniowego i ustawiliśmy parametr regularyzacji „C” na 1.0. Parametr jądra określa typ hiperpłaszczyzny używanej do oddzielania danych. Typowe jądra obejmują „liniowe”, „wielomianowe” (wielomian), „rbf” (promieniowa funkcja bazowa) i „esigmoidalne”.

Krok 6: Dokonywanie prognoz

Użyj przeszkolonego modelu, aby dokonać przewidywań na temat danych testowych:

python
# Predict the class labels for the test set
y_pred = svc.predict(X_test)
Krok 7: Ocena modelu

Oceń wydajność modelu za pomocą wskaźników, takich jak macierz pomyłek i raport klasyfikacyjny:

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

Matryca zamieszania zawiera podsumowanie wyników prognoz, podczas gdy raport klasyfikacyjny obejmuje precyzję, przypominanie, wynik F1 i wsparcie dla każdej klasy.

Strojenie hiperparametrów za pomocą GridSearchCV

Dostrajanie hiperparametrów jest niezbędne do optymalizacji wydajności modelu SVM. Funkcja `GridSearchCV` Scikit-learn może zostać użyta do przeprowadzenia wyczerpującego wyszukiwania w określonej siatce parametrów:

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

W tym przykładzie przeszukaliśmy siatkę wartości „C” i „gamma”, używając jądra RBF. Instancja `GridSearchCV` uzupełnia model o najlepsze parametry znalezione podczas wyszukiwania.

Wizualizacja granicy decyzji

Aby lepiej zrozumieć działanie klasyfikatora SVM, często przydatna jest wizualizacja granicy decyzyjnej. Jest to prostsze w dwuwymiarowej przestrzeni cech. Poniżej znajduje się przykład wykorzystania syntetycznego zbioru danych:

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

Powyższy kod generuje syntetyczny zbiór danych z dwiema klasami, dopasowuje model SVM z jądrem liniowym i wizualizuje granicę decyzyjną. Funkcja „contourf” służy do wykreślenia granicy decyzyjnej, a wykres punktowy pokazuje punkty danych. Scikit-learn zapewnia kompleksowy i przyjazny dla użytkownika interfejs do implementowania klasyfikacji SVM w Pythonie. Kluczowe funkcje, takie jak `svm.SVC`, `fit`, `predict` i `score` są niezbędne do budowania i oceny modeli SVM. Dostrajanie hiperparametrów za pomocą `GridSearchCV` dodatkowo zwiększa wydajność modelu poprzez znajdowanie optymalnych parametrów. Wizualizacja granicy decyzyjnej może dostarczyć cennych informacji na temat zachowania klasyfikatora. Wykonując te kroki, można skutecznie wdrożyć i zoptymalizować klasyfikację SVM za pomocą scikit-learn.

Inne niedawne pytania i odpowiedzi dotyczące EITC/AI/MLP Uczenie Maszynowe z Pythonem:

Zobacz więcej pytań i odpowiedzi w EITC/AI/MLP Machine Learning with Python

Więcej pytań i odpowiedzi:

Tagged under: , , , , ,