Erste Schritte mit Scikit-learn zur Klassifizierung im maschinellen Lernen

Neuauflage von Plato

Verfolger: 0

Erste Schritte mit Scikit-learn für die Klassifizierung im maschinellen Lernen

Bild vom Herausgeber

Scikit-learn ist eine der am häufigsten verwendeten Bibliotheken für maschinelles Lernen, die in Python erstellt wurde. Seine Popularität ist auf seine einfache und konsistente Codestruktur zurückzuführen, die für Anfänger geeignet ist. Außerdem ist ein hohes Maß an Support verfügbar, zusammen mit der Flexibilität, Funktionalitäten von Drittanbietern zu integrieren, was die Bibliothek robust und produktionstauglich macht. Die Bibliothek enthält mehrere Machine-Learning-Modelle für Klassifizierung, Regression und Clustering. In diesem Tutorial werden wir das Problem der Mehrklassenklassifizierung durch verschiedene Algorithmen untersuchen. Lassen Sie uns direkt eintauchen und unsere scikit-learn-Modelle erstellen.

pip install scikit-learn

Wir werden den „Wine“-Datensatz verwenden, der im Datensatzmodul von scikit-learn verfügbar ist. Dieser Datensatz besteht aus insgesamt 178 Proben und 3 Klassen. Der Datensatz ist bereits vorverarbeitet und in Merkmalsvektoren konvertiert, sodass wir ihn direkt zum Trainieren unserer Modelle verwenden können.

from sklearn.datasets import load_wine X, y = load_wine(return_X_y=True)

Wir behalten 67 % der Daten für Schulungen und die restlichen 33 % für Tests.

from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42
)

Jetzt werden wir mit 5 verschiedenen Modellen unterschiedlicher Komplexität experimentieren und ihre Ergebnisse auf unserem Datensatz auswerten.

model_lr = LogisticRegression()
model_lr.fit(X_train, y_train)
y_pred_lr = model_lr.predict(X_test) print("Accuracy Score: ", accuracy_score(y_pred_lr, y_test))
print(classification_report(y_pred_lr, y_test))

Output

Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

model_knn = KNeighborsClassifier(n_neighbors=1)
model_knn.fit(X_train, y_train)
y_pred_knn = model_knn.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_knn, y_test))
print(classification_report(y_pred_knn, y_test))

Output

Accuracy Score: 0.7796610169491526 precision recall f1-score support 0 0.90 0.78 0.84 23 1 0.75 0.82 0.78 22 2 0.67 0.71 0.69 14 accuracy 0.78 59 macro avg 0.77 0.77 0.77 59
weighted avg 0.79 0.78 0.78 59

Beim Ändern des Parameters 'n_neighbors=2' beobachten wir eine Abnahme des Genauigkeitswerts. Daher zeigt es, dass die Daten einfach genug sind und ein besseres Lernen mit einem einzigen zu berücksichtigenden Nachbarn erreicht wird.

Output

Accuracy Score: 0.6949152542372882 precision recall f1-score support 0 0.90 0.72 0.80 25 1 0.75 0.69 0.72 26 2 0.33 0.62 0.43 8 accuracy 0.69 59 macro avg 0.66 0.68 0.65 59
weighted avg 0.76 0.69 0.72 59

from sklearn.naive_bayes import GaussianNB model_nb = GaussianNB()
model_nb.fit(X_train, y_train)
y_pred_nb = model_nb.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_nb, y_test))
print(classification_report(y_pred_nb, y_test))

Output

Accuracy Score: 1.0 precision recall f1-score support 0 1.00 1.00 1.00 20 1 1.00 1.00 1.00 24 2 1.00 1.00 1.00 15 accuracy 1.00 59 macro avg 1.00 1.00 1.00 59
weighted avg 1.00 1.00 1.00 59

from sklearn.tree import DecisionTreeClassifier model_dtclassifier = DecisionTreeClassifier()
model_dtclassifier.fit(X_train, y_train)
y_pred_dtclassifier = model_dtclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_dtclassifier, y_test))
print(classification_report(y_pred_dtclassifier, y_test))

Output

Accuracy Score: 0.9661016949152542 precision recall f1-score support 0 0.95 0.95 0.95 20 1 1.00 0.96 0.98 25 2 0.93 1.00 0.97 14 accuracy 0.97 59 macro avg 0.96 0.97 0.97 59
weighted avg 0.97 0.97 0.97 59

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV def get_best_parameters(): params = { "n_estimators": [10, 50, 100], "max_features": ["auto", "sqrt", "log2"], "max_depth": [5, 10, 20, 50], "min_samples_split": [2, 4, 6], "min_samples_leaf": [2, 4, 6], "bootstrap": [True, False], } model_rfclassifier = RandomForestClassifier(random_state=42) rf_randomsearch = RandomizedSearchCV( estimator=model_rfclassifier, param_distributions=params, n_iter=5, cv=3, verbose=2, random_state=42, ) rf_randomsearch.fit(X_train, y_train) best_parameters = rf_randomsearch.best_params_ print("Best Parameters:", best_parameters) return best_parameters parameters_rfclassifier = get_best_parameters() model_rfclassifier = RandomForestClassifier( **parameters_rfclassifier, random_state=42
) model_rfclassifier.fit(X_train, y_train) y_pred_rfclassifier = model_rfclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_rfclassifier, y_test))
print(classification_report(y_pred_rfclassifier, y_test))

Output


Best Parameters: {'n_estimators': 100, 'min_samples_split': 6, 'min_samples_leaf': 4, 'max_features': 'log2', 'max_depth': 5, 'bootstrap': True}
Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

In diesem Algorithmus haben wir einige Hyperparameter-Tunings durchgeführt, um die beste Genauigkeit zu erreichen. Wir haben ein Parameterraster definiert, das aus mehreren Werten besteht, aus denen Sie für jeden Parameter auswählen können. Darüber hinaus haben wir den Randomized Search CV-Algorithmus verwendet, um den besten Parameterraum für das Modell zu suchen. Schließlich füttern wir die erhaltenen Parameter an den Klassifikator und trainieren das Modell.

Modelle	Genauigkeit	Beobachtungen
Logistische Regression	98.30%	Erreicht eine große Genauigkeit. Das Modell kann den Testdatensatz gut verallgemeinern.
K-Nächste Nachbarn	77.96%	Der Algorithmus ist nicht in der Lage, die Datendarstellung gut zu lernen.
Naiver Bayes	100%	Das Modell ist weniger komplex, daher überpasst es die Daten, um absolute Genauigkeit zu erhalten.
Entscheidungsbaum-Klassifizierer	96.61%	Erreicht eine anständige Genauigkeit.
Zufälliger Waldklassifizierer	98.30%	Da es sich um einen Ensemble-basierten Ansatz handelt, schneidet es besser ab als Decision Tree. Durch die Durchführung der Hyperparameter-Abstimmung wird eine ähnliche Genauigkeit wie bei der logistischen Regression erreicht.

In diesem Tutorial haben wir gelernt, wie man mit dem Erstellen und Trainieren von Modellen für maschinelles Lernen in scikit-learn beginnt. Wir haben einige Algorithmen implementiert und evaluiert, um eine grundlegende Vorstellung von ihrer Leistung zu bekommen. Man kann jederzeit fortschrittliche Strategien für Feature Engineering, Hyperparameter-Tuning oder Training anwenden, um die Leistung zu verbessern. Um mehr über die Funktionalitäten zu erfahren, die scikit-learn bietet, schauen Sie sich die offizielle Dokumentation an – Einführung in maschinelles Lernen mit scikit-learn, Maschinelles Lernen in Python mit scikit-learn.

Yesha Shastri ist ein leidenschaftlicher KI-Entwickler und Autor, der einen Master in Machine Learning von der Université de Montréal anstrebt. Yesha ist fasziniert, verantwortungsbewusste KI-Techniken zu erforschen, um Herausforderungen zu lösen, die der Gesellschaft zugute kommen, und ihre Erkenntnisse mit der Gemeinschaft zu teilen.