Auf einen Blick: Dieses Tutorial zeigt, wie Scikit-Learn für Klassifikationsaufgaben verwendet werden kann, wobei der Fokus auf die Vorhersage von Diabetes anhand von Gesundheitsindikatoren liegt. Es behandelt die Datenvorbereitung, das Modelltraining mit der Support Vector Machine und die Bewertung anhand von Metriken wie der Verwirrungsmatrix.
- Nutzt Gesundheitsdaten wie Glukose und BMI von Diabetikern und Nicht-Diabetikern.
- Verwendet das SVC von scikit-learn für Modelltraining und die Confusion Matrix für die Genauigkeitsbewertung.
Hier zeigen wir, wie man scikit-learn verwendet. Der Code für dieses Beispiel ist hier. Laden Sie die Daten hier von Kaggle herunter.
Welches Machine-Learning-Framework solltest du verwenden?
Bevor wir Ihnen zeigen, wie scikit-learn funktioniert, geht es darum, zu diskutieren, welches ML-Framework verwendet werden soll. Ich habe das gleich vorweg erwähnt, weil zu viele Leute, die mit Data Science anfangen, denken, sie müssten mit TensorFlow anfangen, aber das ist für die meisten Ihrer Probleme übertrieben. Für Low-Level-Ansätze, auf die sich TensorFlow spezialisiert hat, ist es zu kompliziert; es gibt einfachere Ansätze.
Die Daten
| scikit-learn | TensorFlow | Keras | Spark ML |
|
Dieses allgemeine ML-Framework ist sowohl einfach zu bedienen als auch kann die meisten ML-Probleme lösen. Es ist bei Data Scientists sehr beliebt. Sogar Data Scisci, die andere Frameworks verwenden, setzen oft Scikit-Learn-Utilities in Teilen ihres Codes ein. |
TensorFlow ist für einen Zweck konzipiert: neuronale Netze. Es ist sehr niedrigstufig, was bedeutet, dass du viel Wissen über NumPy-Arrays und neuronale Netztheorie brauchst. Google verkauft spezielle CPUs, sogenannte TPUs, die dafür entwickelt wurden, Tensoren in sehr großem Maßstab zu verarbeiten. Sie sehen also, dass sie für rechenintensive Aufgaben wie Gesichtserkennung konzipiert sind, aber die meisten Geschäftsprobleme sind weniger kompliziert als Gesichtserkennung. Wir haben hier Tutorials geschrieben, wie man ML mit TensorFlow und Keras verwendet. |
Wenn du TensorFlow nutzen willst, dann Keras, da es als Frontend fungiert und es dadurch viel einfacher macht. Du wirst weniger wahrscheinlich Fehler machen, die zu falschen Antworten führen. Keras funktioniert auch vor anderen beliebten ML-Frameworks und macht diese zudem leichter zu bedienen. Wir erklären hier, wie man Keras benutzt.
|
Scikit-Learn ist darauf ausgelegt, auf einem Server zu laufen. Wenn Sie eine große Datenmenge haben, möchten Sie vielleicht Spark ML verwenden, da es für den Betrieb über einen Cluster ausgelegt ist. Und Spark ML ist leicht zu verstehen. |
Alle Python-ML-Frameworks beginnen im Grunde gleich, beginnend mit denselben Tools:
- Pandas. Dies organisiert CSV-, JSON-, Spark- und andere Datentypen in Zeilen und Spalten. Pandas vereinfacht alle Datentypen erheblich, aber seine fortschrittlichen Funktionen können kompliziert werden.
- NumPy. Dies ist eng mit Pandas und Matplotlib verbunden. NumPy funktioniert am besten bei der wichtigsten Machine-Learning-Aufgabe: der rechnerisch aufwändigen Operation, Matrizen in mehreren Dimensionen zu multiplizieren. Mit zunehmender Dimensionen können sie Ihren Computer schnell ohne Speicher verlieren.
- Matplotlib. Das zeichnet Diagramme wie Histogramme, Liniendiagramme usw. Daten zu erfassen ist eine gute Möglichkeit, Daten zu erkunden, während du mit den Daten arbeitest, und sie können deine Ergebnisse am Ende deines Programms veranschaulichen.
- Seaborn. Dieses Framework, zusätzlich zu Matplotlib, ist speziell für Data Science entwickelt.
Die Daten, die wir betrachten, sind Glukose, Body-Mass-Index usw., entnommen von zwei Gruppen von Menschen: denen, die Diabetiker sind, und solchen, die es nicht sind. Diese Klassifikation 1 (Diabetiker) und 0 (nicht) steht in der Ergebnisspalte . Das Ziel ist es, diese Daten zu nutzen, um ein prädiktives Modell zu trainieren, das anhand bestimmter Gesundheitsindikatoren zeigt, ob eine Person wahrscheinlich Diabetes hat oder erleiden wird.
Der Algorithmus
Es gibt viele Herangehensweisen an ein Klassifikationsproblem, wie logistische Regression oder sogar neuronale Netze. Hier verwenden wir die Support Vector Machine (SVM).
Der erste Schritt besteht darin, die Daten in einen Datenrahmen einzulesen.
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
data = pd.read_csv('/home/ubuntu/Downloads/diabetes.csv', delimiter=',')
Dann schau es dir an.
data.head()
Maschinelles Lernen erfordert, dass man die Daten in Features und Labels aufteilt.
- Merkmale sind die Eigenschaften dessen, was du betrachtest, auch als unabhängige Variablen bekannt.
- Labels sind das, was du vorhersagen willst, also die abhängigen Variablen.
Klassifikation bedeutet, dass es eine endliche Anzahl von Ergebnissen gibt. Hier gibt es zwei, man könnte es also ein binäres Klassifikationsproblem nennen.
Wie Sie sehen können, ist das Ergebnis, egal ob jemand Diabetes hat oder nicht, die letzte Spalte. Der Rest sind also Merkmale. Es wird leicht sein, diese Daten aufzuteilen, da die Etiketten am Ende stehen.
Pregnancies Glucose BloodPressure SkinThickness Insulin BMI \
0 6 148 72 35 0 33.6
1 1 85 66 29 0 26.6
2 8 183 64 0 0 23.3
3 1 89 66 23 94 28.1
4 0 137 40 35 168 43.1
DiabetesPedigreeFunction Age Outcome
0 0.627 50 1
1 0.351 31 0
2 0.672 32 1
3 0.167 21 0
4 2.288 33 1
Der Pandas drop()- Befehl bedeutet, einen neuen Dataframe zu erstellen, indem ein bestehender Dataframe genommen und eine oder mehrere Spalten entfernt werden. Axis=1 bedeutet, dass wir uns auf die Spalten und nicht auf die Zeilen beziehen (was für Pandas auch als Index bezeichnet wird).
x = data.drop("Outcome", axis=1)
data['Outcome'] ist eine Pandas-Serie und kein Pandas-Datenrahmen. Das bedeutet, es hat nur eine Spalte, aber dennoch die Index-Spalte. np.ravel() flacht das zu einem Array ab.
y=np.ravel(data['Outcome'])
Das Standardverfahren besteht darin, die Eingabedaten zu nehmen und Trainings- und Testdatensätze zu erstellen, indem man sie um einen bestimmten Betrag aufteilt. Hier wählen wir 50%.
- Trainingsdatensätze werden verwendet, um das Modell zu trainieren.
- Testdatensätze werden verwendet, um Vorhersagen auf Basis dieses trainierten Modells zu treffen.
Wir verwenden x und y, da die bekannte Gleichung für eine Gerade y = mx + b gilt. Für maschinelles Lernen ist y ein Vektor und m und x sind Matrizen, was einen n-dimensionalen Vektor bedeutet. B ist eine Verzerrung, also eine einzelne reelle Zahl.
x_train, x_test, y_train, y_test = train_test_split(x,y, test_size = 0.5, random_state=50)
Nun normalisieren wir die Daten. Im Grunde berechnet dies den Wert ((x - μ) / δ), wobei μ der Mittelwert und δ die Standardabweichung ist. Dadurch werden alle Merkmale auf derselben Skala gesetzt, was eine reguläre maschinelle Lernpraxis ist. Mit anderen Worten: Große Zahlen werden klein gemacht, sodass alle Zahlen ungefähr gleich groß sind.
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler().fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
Zuerst deklarieren wir das Modell. Wir verwenden eine Support-Vector-Maschine.
from sklearn.svm import SVC
svc_model = SVC()
Dann trainieren wir es: So einfach ist es, wenn man Scikit-Learn verwendet. Es ist keine weitere Datenmanipulation erforderlich.
svc_model.fit(x_train, y_train)
Die fit() -Funktion reagiert mit dieser Information.
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='rbf', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)
Jetzt nutzen wir die Testdaten, um Vorhersagen zu erstellen.
y_predict = svc_model.predict(x_test)
Dann zeigen wir, wie genau diese Vorhersagen sind, indem wir eine sogenannte Verwirrungsmatrix erstellen. Das ist eine visuelle Möglichkeit, zu sehen, wie oft das Modell richtig war und wie oft es falsch war.
from sklearn.metrics import classification_report, confusion_matrix
cm = np.array(confusion_matrix(y_test, y_predict, labels=[0,1]))
confusion = pd.DataFrame(cm, index=['Diabetic', 'Not Diabetic'], columns=['Predicted Diabetes', 'Predicted Healthy'])
Predicted Diabetes Predicted Healthy
Diabetic 225 23
Not Diabetic 68 68
Es ist anfangs etwas schwierig, diese Darstellung zu verstehen, also stell es dir so vor:
Diabetic (Outcome = 1) True positive. Patient is diabetic and model correctly predicted that. False positive. Patient was not diabetic but model said patient was diabetic.
Not Diabetic (Outcome = 0) False positive. Patient was not diabetic, but model said patient was diabetic.
True negative, patient not diabetic and model predicted that.
Hier ist eine grafische Möglichkeit, die gleichen Ergebnisse mit der leistungsstarken Seaborn-Erweiterung zu Matplotlib darzustellen:
sns.heatmap(confusion,annot=True,fmt='g')
Der Klassifikationsbericht druckt eine Zusammenfassung des Modells aus und zeigt eine Genauigkeit von 77 %. Das bedeutet, dass unser Modell Diabetes in 77 % der Fälle genau vorhersagt.
print(classification_report(y_test, y_predict))
precision recall f1-score support
0 0.77 0.91 0.83 248
1 0.75 0.50 0.60 136
micro avg 0.76 0.76 0.76 384
macro avg 0.76 0.70 0.72 384
weighted avg 0.76 0.76 0.75 384
Die Ergebnisse waren nahezu dieselben wie bei der Verwendung von Keras als neuronalem Netzwerk.
scikit Lernleitfaden
Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.