2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Support Vector Machine (SVM) ist ein leistungsstarkes und vielseitiges Modell für maschinelles Lernen, das sich für lineare und nichtlineare Klassifizierung, Regression und Ausreißererkennung eignet. In diesem Artikel werden der Support-Vector-Machine-Algorithmus und seine Implementierung in Scikit-Learn vorgestellt und kurz die Hauptkomponentenanalyse und ihre Anwendung in Scikit-Learn untersucht.
Support Vector Machine (SVM) ist ein weit verbreiteter Algorithmus im Bereich des maschinellen Lernens, der wegen seiner Eigenschaft, mit weniger Rechenressourcen eine hohe Genauigkeit zu liefern, beliebt ist. SVM kann sowohl für Klassifizierungs- als auch für Regressionsaufgaben verwendet werden, wird jedoch am häufigsten bei Klassifizierungsproblemen eingesetzt.
Das Ziel von Support-Vektor-Maschinen ist es NNN Dimensionsraum ( NNN ist die Anzahl der Features), um eine Hyperebene zu finden, die die Datenpunkte klar unterscheiden kann. Mit dieser Hyperebene können Datenpunkte verschiedener Kategorien getrennt und so weit wie möglich von der Hyperebene entfernt werden, um die Robustheit der Klassifizierung sicherzustellen.
Um eine effektive Trennung von Datenpunkten zu erreichen, können mehrere Hyperebenen vorhanden sein. Unser Ziel ist es, eine Hyperebene mit maximalem Spielraum zu wählen, also dem maximalen Abstand zwischen zwei Klassen. Die Maximierung der Margen trägt zur Verbesserung der Klassifizierungsgenauigkeit bei.
Eine Hyperebene ist eine Entscheidungsgrenze, die Datenpunkte teilt. Datenpunkte, die sich auf beiden Seiten der Hyperebene befinden, können in verschiedene Kategorien eingeteilt werden. Die Abmessungen der Hyperebene hängen von der Anzahl der Features ab: Wenn die Eingabemerkmale 2 sind, ist die Hyperebene eine gerade Linie; wenn es 3 Features sind, ist die Hyperebene eine zweidimensionale Ebene. Wenn die Anzahl der Features 3 überschreitet, wird es schwierig, die Hyperebene intuitiv zu verstehen.
Unterstützungsvektoren beziehen sich auf die Punkte, die der Hyperebene am nächsten liegen und die Position und Richtung der Hyperebene beeinflussen. Mit diesen Unterstützungsvektoren können wir den Spielraum des Klassifikators maximieren. Durch das Entfernen von Unterstützungsvektoren ändert sich die Position der Hyperebene, daher sind sie für den Aufbau einer SVM von entscheidender Bedeutung.
Bei der logistischen Regression verwenden wir die Sigmoidfunktion, um den Ausgabewert der linearen Funktion in den Bereich [0,1] zu komprimieren und Beschriftungen basierend auf einem Schwellenwert (0,5) zuzuweisen. In SVM verwenden wir den Ausgabewert einer linearen Funktion, um die Klassifizierung zu bestimmen: Wenn die Ausgabe größer als 1 ist, gehört sie zu einer Klasse; wenn die Ausgabe -1 ist, gehört sie zu einer anderen Klasse. SVM bildet den Grenzbereich [-1,1], indem es den Schwellenwert des Ausgabewerts auf 1 und -1 setzt.
Vorhersage gutartiger und bösartiger Krebsdiagnosen mithilfe von Support-Vektor-Maschinen.
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)
Beim maschinellen Lernen ist das Modelltraining ein entscheidender Schritt bei der Lösungsfindung für Probleme.Im Folgenden stellen wir die Verwendung vorscikit-learn Führen Sie ein Modelltraining durch und demonstrieren Sie die Leistung der Support Vector Machine (SVM) unter verschiedenen Kerneln.
Zuerst müssen wir die Daten vorbereiten und vorverarbeiten. Das Folgende ist ein Codebeispiel für die Datenvorverarbeitung:
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)
Im Code verwenden wir MinMaxScaler UndStandardScaler Skalieren Sie die Daten. Die Daten sind in Trainings- und Testsätze unterteilt, wobei 30 % der Daten zum Testen verwendet werden.
Um die Leistung des Modells zu bewerten, definieren wir a print_score Funktion, die die Genauigkeit, den Klassifizierungsbericht und die Verwirrungsmatrix von Trainings- und Testergebnissen ausgeben kann:
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) ist ein leistungsstarker Klassifizierungsalgorithmus, dessen Leistung durch Hyperparameter beeinflusst wird. Im Folgenden werden die Hauptparameter von SVM und ihre Auswirkungen auf die Modellleistung vorgestellt:
'poly' ), von anderen Kerneln ignoriert. Die optimalen Hyperparameterwerte können durch Rastersuche gefunden werden.Die lineare Kernel-SVM eignet sich für die meisten Situationen, insbesondere wenn der Datensatz eine große Anzahl von Funktionen aufweist. Das Folgende ist ein Codebeispiel für die Verwendung einer linearen Kernel-SVM:
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)
Die Trainings- und Testergebnisse sind wie folgt:
Trainingsergebnisse:
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]]
Testergebnisse:
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]]
Der polynomische Kernel SVM eignet sich für nichtlineare Daten. Das Folgende ist ein Codebeispiel unter Verwendung eines Polynomkerns zweiter Ordnung:
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)
Die Trainings- und Testergebnisse sind wie folgt:
Trainingsergebnisse:
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]]
Testergebnisse:
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]]
Radiale Basisfunktionskerne (RBF) eignen sich für die Verarbeitung nichtlinearer Daten. Das Folgende ist ein Codebeispiel unter Verwendung des RBF-Kerns:
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)
Die Trainings- und Testergebnisse sind wie folgt:
Trainingsergebnisse:
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]]
Testergebnisse:
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]]
Durch den oben genannten Modellschulungs- und Bewertungsprozess können wir die Leistungsunterschiede verschiedener SVM-Kernel beobachten. Die lineare Kernel-SVM bietet eine gute Leistung in Bezug auf Genauigkeit und Trainingszeit und eignet sich für Situationen mit höheren Datendimensionen. Polynom-Kernel-SVM und RBF-Kernel-SVM bieten eine bessere Leistung bei nichtlinearen Daten, können jedoch unter bestimmten Parametereinstellungen zu einer Überanpassung führen. Die Auswahl geeigneter Kernel und Hyperparameter ist entscheidend für die Verbesserung der Modellleistung.
digitale Eingabe : SVM geht davon aus, dass die Eingabedaten numerisch sind. Wenn es sich bei den Eingabedaten um kategoriale Variablen handelt, müssen Sie diese möglicherweise in binäre Dummy-Variablen (eine Variable pro Kategorie) konvertieren.
binäre Klassifizierung :Basic SVM eignet sich für binäre Klassifizierungsprobleme. Obwohl SVM hauptsächlich für die binäre Klassifizierung verwendet wird, gibt es auch erweiterte Versionen für die Regression und die Klassifizierung mehrerer Klassen.
X_train = pipeline.fit_transform(X_train)
X_test = pipeline.transform(X_test)
Das Folgende zeigt die Trainings- und Testergebnisse verschiedener SVM-Kernel:
Lineare Kernel-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)
Trainingsergebnisse:
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)
Trainingsergebnisse:
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)
Trainingsergebnisse:
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)
Trainingsergebnisse:
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]]
Die Hauptkomponentenanalyse (PCA) ist eine Technik, die eine lineare Dimensionsreduktion durch die Projektion von Daten in einen niedrigerdimensionalen Raum erreicht. Die spezifischen Schritte sind wie folgt:
Da es schwierig ist, hochdimensionale Daten direkt zu visualisieren, können wir PCA verwenden, um die ersten beiden Hauptkomponenten zu finden und die Daten im zweidimensionalen Raum zu visualisieren. Um dies zu erreichen, müssen die Daten zunächst normalisiert werden, sodass die Varianz jedes Merkmals eine Einheitsvarianz ist.
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()
Durch die ersten beiden Hauptkomponenten können wir verschiedene Kategorien von Datenpunkten im zweidimensionalen Raum leicht trennen.
Obwohl die Reduzierung der Dimensionalität wirkungsvoll ist, ist die Bedeutung der Komponenten schwer direkt zu verstehen. Jede Komponente entspricht einer Kombination ursprünglicher Merkmale, die durch Anpassen eines PCA-Objekts erhalten werden können.
Zu den komponentenbezogenen Eigenschaften gehören:
Wenn wir Support Vector Machines (SVM) für das Modelltraining verwenden, müssen wir die Hyperparameter anpassen, um das beste Modell zu erhalten. Im Folgenden finden Sie Beispielcode zum Anpassen von SVM-Parametern mithilfe der Rastersuche (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)
Trainingsergebnisse:
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 diesem Artikel haben wir Folgendes gelernt:
beziehen auf:Support Vector Machine & PCA-Tutorial für Anfänger
Empfehlen Sie meine verwandten Kolumnen:
Er widmet sich seit mehr als 30 Jahren der Technologieforschung und beherrscht verschiedene Sprachen wie Java, Linux, Javascript, PHP, CSS usw. Er hat viele Beiträge im Open-Source-Bereich geleistet Entwicklerdokumentationsstation, um einige Themen in der Technologieentwicklung als zukünftige Referenz zu teilen
