Definitiver Leitfaden zur logistischen Regression in Python

Einleitung

Manchmal verwechselt mit lineare Regression von Anfängern – aufgrund der Aufteilung des Begriffs Regression - logistische Regression ist ganz anders als lineare Regression. Während die lineare Regression Werte wie 2, 2.45, 6.77 oder kontinuierliche Wertemacht es zu einem Regression Algorithmus, logistische Regression sagt Werte wie 0 oder 1, 1 oder 2 oder 3 voraus, die sind diskrete Wertemacht es zu einem Einstufung Algorithmus. Ja, es heißt Regression ist aber ein Einstufung Algorithmus. Mehr dazu gleich.

Wenn Ihr Data-Science-Problem kontinuierliche Werte beinhaltet, können Sie daher a anwenden Regression Algorithmus (lineare Regression ist einer von ihnen). Andernfalls, wenn es um die Klassifizierung von Eingaben, diskreten Werten oder Klassen geht, können Sie a anwenden Einstufung Algorithmus (Logistische Regression ist einer von ihnen).

In diesem Leitfaden führen wir eine logistische Regression in Python mit der Scikit-Learn-Bibliothek durch. Wir werden auch erklären, warum das Wort „Rückgang“ im Namen vorhanden ist und wie die logistische Regression funktioniert.

Dazu laden wir zunächst Daten, die klassifiziert, visualisiert und vorverarbeitet werden. Dann werden wir ein logistisches Regressionsmodell erstellen, das diese Daten versteht. Dieses Modell wird dann ausgewertet und verwendet, um Werte basierend auf neuen Eingaben vorherzusagen.

Motivation

Das Unternehmen, für das Sie arbeiten, ist eine Partnerschaft mit einem türkischen landwirtschaftlichen Betrieb eingegangen. Diese Partnerschaft beinhaltet den Verkauf von Kürbiskernen. Kürbiskerne sind sehr wichtig für die menschliche Ernährung. Sie enthalten einen guten Anteil an Kohlenhydraten, Fett, Eiweiß, Kalzium, Kalium, Phosphor, Magnesium, Eisen und Zink.

Im Data-Science-Team besteht Ihre Aufgabe darin, die Kürbiskernsorten nur anhand von Daten zu unterscheiden – oder klassifizieren die Daten nach Saatguttyp.

Die türkische Farm arbeitet mit zwei Kürbiskernsorten, eine heißt Çerçevelik und der andere Ürgüp Sivrisi.

Um die Kürbiskerne zu klassifizieren, hat sich Ihr Team an das Papier von 2021 gehalten „Der Einsatz maschineller Lernmethoden bei der Klassifizierung von Kürbiskernen (Cucurbita pepo L.). Genetische Ressourcen und Pflanzenevolution“ von Koklu, Sarigil und Ozbek – in diesem Artikel gibt es eine Methodik zum Fotografieren und Extrahieren der Samenmessungen aus den Bildern.

Nach Abschluss des im Papier beschriebenen Prozesses wurden die folgenden Messungen extrahiert:

• Gebiet – die Anzahl der Pixel innerhalb der Grenzen eines Kürbiskerns
• Perimeter – der Umfang in Pixel eines Kürbiskerns
• Hauptachsenlänge – auch der Umfang in Pixel eines Kürbiskerns
• Länge der Nebenachse – der kleine Achsabstand eines Kürbiskerns
• Exzentrizität – die Exzentrizität eines Kürbiskerns
• Konvexer Bereich – die Anzahl der Pixel der kleinsten konvexen Schale in der Region, die durch den Kürbiskern gebildet wird
• Umfang – das Verhältnis einer Kürbiskernfläche zu den Pixeln des Begrenzungsrahmens
• Äquivalenter Durchmesser – die Quadratwurzel aus der Multiplikation der Fläche des Kürbiskerns mit vier dividiert durch Pi
• Kompaktheit – das Verhältnis der Fläche des Kürbiskerns zur Fläche des Kreises mit gleichem Umfang
• Solidität – der konvexe und konvexe Zustand der Kürbiskerne
• Rundheit – die Ovalität von Kürbiskernen ohne Berücksichtigung der Kantenverzerrungen
• Streckung – das Seitenverhältnis der Kürbiskerne

Das sind die Maße, mit denen Sie arbeiten müssen. Neben den Messungen gibt es auch die Klasse Etikett für die beiden Arten von Kürbiskernen.

Um mit der Klassifizierung der Samen zu beginnen, importieren wir die Daten und beginnen mit der Betrachtung.

Den Datensatz verstehen

Nach dem Herunterladen des Datensatzes können wir ihn mithilfe von in eine Datenrahmenstruktur laden pandas Bibliothek. Da es sich um eine Excel-Datei handelt, verwenden wir die read_excel() Verfahren:

import pandas as pd

fpath = 'dataset/pumpkin_seeds_dataset.xlsx' 
df = pd.read_excel(fpath)

Sobald die Daten geladen sind, können wir mithilfe von einen kurzen Blick auf die ersten 5 Zeilen werfen head() Verfahren:

df.head() 

Das führt zu:

	Area 	Perimeter 	Major_Axis_Length 	Minor_Axis_Length 	Convex_Area 	Equiv_Diameter 	Eccentricity 	Solidity 	Extent 	Roundness 	Aspect_Ration 	Compactness 	Class
0 	56276 	888.242 	326.1485 			220.2388 			56831 			267.6805 		0.7376 			0.9902 		0.7453 	0.8963 		1.4809 			0.8207 			Çerçevelik
1 	76631 	1068.146 	417.1932 			234.2289 			77280 			312.3614 		0.8275 			0.9916 		0.7151 	0.8440 		1.7811 			0.7487 			Çerçevelik
2 	71623 	1082.987 	435.8328 			211.0457 			72663 			301.9822 		0.8749 			0.9857 		0.7400 	0.7674 		2.0651 			0.6929 			Çerçevelik
3 	66458 	992.051 	381.5638 			222.5322 			67118 			290.8899 		0.8123 			0.9902 		0.7396 	0.8486 		1.7146 			0.7624 			Çerçevelik
4 	66107 	998.146 	383.8883 			220.4545 			67117 			290.1207 		0.8187 			0.9850 		0.6752 	0.8338 		1.7413 			0.7557 			Çerçevelik

Hier haben wir alle Messungen in ihren jeweiligen Spalten, unsere Funktionenund auch die Klasse Spalte, unsere Ziel, das letzte im Datenrahmen. Wir können sehen, wie viele Messungen wir haben, indem wir die verwenden shape Attribut:

df.shape 

Die Ausgabe ist:

(2500, 13)

Das Shape-Ergebnis sagt uns, dass der Datensatz 2500 Einträge (oder Zeilen) und 13 Spalten enthält. Da wir wissen, dass es eine Zielspalte gibt, bedeutet dies, dass wir 12 Feature-Spalten haben.

Wir können jetzt die Zielvariable, den Kürbiskern, untersuchen Class. Da wir diese Variable vorhersagen werden, ist es interessant zu sehen, wie viele Proben von jedem Kürbiskern wir haben. Je kleiner der Unterschied zwischen der Anzahl der Instanzen in unseren Klassen ist, desto ausgewogener ist normalerweise unsere Stichprobe und desto besser sind unsere Vorhersagen.

Diese Inspektion kann durch Zählen jeder Samenprobe mit dem durchgeführt werden value_counts() Verfahren:

df['Class'].value_counts() 

Der obige Code zeigt:

Çerçevelik       1300
Ürgüp Sivrisi    1200
Name: Class, dtype: int64

Wir können sehen, dass es 1300 Proben von gibt Çerçevelik Samen und 1200 Proben der Ürgüp Sivrisi Samen. Beachten Sie, dass der Unterschied zwischen ihnen 100 Samples beträgt, ein sehr kleiner Unterschied, der gut für uns ist und darauf hinweist, dass es nicht erforderlich ist, die Anzahl der Samples neu auszugleichen.

Schauen wir uns auch die deskriptiven Statistiken unserer Features mit an describe() Methode, um zu sehen, wie gut die Daten verteilt sind. Wir transponieren auch die resultierende Tabelle mit T um den Vergleich zwischen Statistiken zu erleichtern:

df.describe().T

Die resultierende Tabelle ist:

					count 	mean 			std 			min 		25% 			50% 			75% 			max
Area 				2500.0 	80658.220800 	13664.510228 	47939.0000 	70765.000000 	79076.00000 	89757.500000 	136574.0000
Perimeter 			2500.0 	1130.279015 	109.256418 		868.4850 	1048.829750 	1123.67200 		1203.340500 	1559.4500
Major_Axis_Length 	2500.0 	456.601840 		56.235704 		320.8446 	414.957850 		449.49660 		492.737650 		661.9113
Minor_Axis_Length 	2500.0 	225.794921 		23.297245 		152.1718 	211.245925 		224.70310 		240.672875 		305.8180
Convex_Area 		2500.0 	81508.084400 	13764.092788 	48366.0000 	71512.000000 	79872.00000 	90797.750000 	138384.0000
Equiv_Diameter 		2500.0 	319.334230 		26.891920 		247.0584 	300.167975 		317.30535 		338.057375 		417.0029
Eccentricity 		2500.0 	0.860879 		0.045167 		0.4921 		0.831700 		0.86370 		0.897025 		0.9481
Solidity 			2500.0 	0.989492 		0.003494 		0.9186 		0.988300 		0.99030 		0.991500 		0.9944
Extent 				2500.0 	0.693205 		0.060914 		0.4680 		0.658900 		0.71305 		0.740225 		0.8296
Roundness 			2500.0 	0.791533 		0.055924 		0.5546 		0.751900 		0.79775 		0.834325 		0.9396
Aspect_Ration 		2500.0 	2.041702 		0.315997 		1.1487 		1.801050 		1.98420 		2.262075 		3.1444
Compactness 		2500.0 	0.704121 		0.053067 		0.5608 		0.663475 		0.70770 		0.743500 		0.9049

Durch einen Blick auf die Tabelle, beim Vergleich der bedeuten und Standardabweichung (std)-Spalten ist ersichtlich, dass die meisten Merkmale einen Mittelwert haben, der weit von der Standardabweichung entfernt ist. Das deutet darauf hin, dass sich die Datenwerte nicht um den Mittelwert konzentrieren, sondern eher um ihn herum verstreut sind – mit anderen Worten, sie haben es hohe Variabilität.

Auch beim Betrachten der Minimum (min) und maximal (max) Spalten, einige Funktionen, wie z Area und Convex_Area, weisen große Unterschiede zwischen Minimal- und Maximalwerten auf. Das bedeutet, dass diese Spalten sehr kleine Daten und auch sehr große Datenwerte haben, oder höhere Amplitude zwischen Datenwerten.

Bei hoher Variabilität, hoher Amplitude und Merkmalen mit unterschiedlichen Maßeinheiten würden die meisten unserer Daten davon profitieren, wenn sie für alle Merkmale oder Wesen denselben Maßstab hätten skaliert. Die Datenskalierung zentriert die Daten um den Mittelwert und reduziert seine Varianz.

Dieses Szenario deutet wahrscheinlich auch darauf hin, dass es Ausreißer und Extremwerte in den Daten gibt. Also am besten gleich welche haben Ausreißerbehandlung Neben der Skalierung der Daten.

Es gibt einige maschinelle Lernalgorithmen, zum Beispiel baumbasierte Algorithmen wie z Random Forest-Klassifizierung, die nicht von hoher Datenvarianz, Ausreißern und Extremwerten betroffen sind. Logistische Regression anders ist, basiert es auf einer Funktion, die unsere Werte kategorisiert, und die Parameter dieser Funktion können von Werten beeinflusst werden, die außerhalb des allgemeinen Datentrends liegen und eine hohe Varianz aufweisen.

Wir werden in Kürze mehr über die logistische Regression verstehen, wenn wir sie implementieren können. Im Moment können wir unsere Daten weiter untersuchen.

Visualisierung der Daten

Bisher haben wir mit der deskriptiven Statistik eine etwas abstrakte Momentaufnahme einiger Qualitäten der Daten. Ein weiterer wichtiger Schritt besteht darin, es zu visualisieren und unsere Hypothese von hoher Varianz, Amplitude und Ausreißern zu bestätigen. Um zu sehen, ob sich das, was wir bisher beobachtet haben, in den Daten zeigt, können wir einige Diagramme zeichnen.

Es ist auch interessant zu sehen, wie sich die Merkmale auf die beiden Klassen beziehen, die vorhergesagt werden. Importieren wir dazu die seaborn verpacken und verwenden pairplot Diagramm, um jede Merkmalsverteilung und jede Klassentrennung pro Merkmal zu betrachten:

import seaborn as sns


sns.pairplot(data=df, hue='Class')

Wenn wir uns den Pairplot ansehen, können wir sehen, dass in den meisten Fällen die Punkte der Çerçevelik Klasse sind klar von den Punkten der getrennt Ürgüp Sivrisi Klasse. Entweder sind die Punkte einer Klasse rechts, wenn die anderen links sind, oder einige sind oben, während die anderen unten sind. Wenn wir eine Art Kurve oder Linie verwenden würden, um Klassen zu trennen, zeigt dies, dass es einfacher ist, sie zu trennen, wenn sie gemischt wären, wäre die Klassifizierung eine schwierigere Aufgabe.

Im Eccentricity, Compactness und Aspect_Ration Spalten sind auch einige Punkte, die „isoliert“ sind oder vom allgemeinen Datentrend abweichen – Ausreißer – leicht zu erkennen.

Wenn Sie die Diagonale von links oben nach rechts unten im Diagramm betrachten, beachten Sie, dass die Datenverteilungen auch gemäß unseren Klassen farbcodiert sind. Die Verteilungsformen und der Abstand zwischen beiden Kurven sind weitere Indikatoren dafür, wie trennbar sie sind – je weiter voneinander entfernt, desto besser. In den meisten Fällen sind sie nicht überlagert, was bedeutet, dass sie leichter zu trennen sind, was ebenfalls zu unserer Aufgabe beiträgt.

Der Reihe nach können wir auch die Boxplots aller Variablen mit plotten sns.boxplot() Methode. Meistens ist es hilfreich, die Boxplots horizontal auszurichten, damit die Formen der Boxplots die gleichen sind wie die Verteilungsformen, das können wir mit tun orient Argument:

sns.boxplot(data=df, orient='h') 

Beachten Sie das in der obigen Darstellung Area und Convex_Area haben im Vergleich zu den Größen der anderen Säulen eine so hohe Größe, dass sie die anderen Boxplots zerquetschen. Um alle Boxplots betrachten zu können, können wir die Features skalieren und erneut plotten.

Bevor wir das tun, wollen wir einfach verstehen, dass, wenn es zum Beispiel Werte von Merkmalen gibt, die eng mit anderen Werten verbunden sind – wenn es Werte gibt, die auch größer werden, wenn andere Merkmalswerte größer werden, mit a positive Korrelation; oder wenn es Werte gibt, die das Gegenteil tun, kleiner werden, während andere Werte kleiner werden, mit a negative Korrelation.

Dies ist wichtig, da starke Beziehungen in Daten bedeuten können, dass einige Spalten von anderen Spalten abgeleitet wurden oder eine ähnliche Bedeutung wie unser Modell haben. In diesem Fall könnten die Modellergebnisse überschätzt werden und wir wollen Ergebnisse, die näher an der Realität liegen. Wenn es starke Korrelationen gibt, bedeutet dies auch, dass wir die Anzahl der Merkmale reduzieren und weniger Spalten verwenden können, wodurch das Modell besser wird sparsam.

Werfen wir einen Blick auf die Korrelationen zwischen Variablen und können dann mit der Vorverarbeitung der Daten fortfahren. Wir werden die Korrelationen mit den berechnen corr() Methode und visualisieren Sie sie mit Seaborn's heatmap(). Die Heatmap-Standardgröße ist in der Regel klein, daher importieren wir sie matplotlib (allgemeine Visualisierungs-Engine/Bibliothek, auf der Seaborn aufbaut) und ändern Sie die Größe mit figsize:

import matplotlib.pyplot as plt
plt.figure(figsize=(15, 10))

correlations = df.corr()
sns.heatmap(correlations, annot=True) 

In dieser Heatmap sind die Werte näher an 1 oder -1 die Werte, auf die wir achten müssen. Der erste Fall bezeichnet eine hohe positive Korrelation und der zweite eine hohe negative Korrelation. Beide Werte, wenn nicht über 0.8 oder -0.8, sind für unser logistisches Regressionsmodell von Vorteil.

Bei hohen Korrelationen wie z 0.99 zwischen Aspec_Ration und Compactness, das bedeutet, dass wir uns dafür entscheiden können, nur zu verwenden Aspec_Ration oder nur Compactness, anstelle von beiden (da sie fast gleich wären Prädiktoren von einander). Dasselbe gilt für Eccentricity und Compactness mit -0.98 Korrelation, z Area und Perimeter mit 0.94 Korrelation und einige andere Spalten.

Vorverarbeitung der Daten

Da wir die Daten bereits eine Weile erforscht haben, können wir mit der Vorverarbeitung beginnen. Lassen Sie uns zunächst alle Funktionen für die Klassenvorhersage verwenden. Nachdem wir ein erstes Modell, eine Baseline, erhalten haben, können wir einige der stark korrelierten Spalten entfernen und mit der Baseline vergleichen.

Die Feature-Spalten werden unsere sein X data und die Klassenspalte our y Zieldaten:

y = df['Class']
X = df.drop(columns=['Class'], axis=1)

Umwandlung kategorialer Merkmale in numerische Merkmale

In Bezug auf unsere Class Spalte – ihre Werte sind keine Zahlen, das heißt, wir müssen sie auch umwandeln. Es gibt viele Möglichkeiten, diese Transformation durchzuführen; Hier verwenden wir die replace() Methode und ersetzen Çerçevelik zu 0 und Ürgüp Sivrisi zu 1.

y = y.replace('Çerçevelik', 0).replace('Ürgüp Sivrisi', 1)

Denken Sie an die Zuordnung! Wenn Sie Ergebnisse aus Ihrem Modell lesen, möchten Sie diese zumindest in Gedanken zurückwandeln oder für andere Benutzer wieder in den Klassennamen zurückverwandeln.

Aufteilen von Daten in Trainings- und Testsätze

Bei unserer Untersuchung haben wir festgestellt, dass die Funktionen skaliert werden mussten. Wenn wir jetzt oder automatisch skalieren würden, würden wir die Werte mit dem Ganzen skalieren X und y. In diesem Fall würden wir vorstellen Datenlecks, da die Werte des baldigen Testsets die Skalierung beeinflusst hätten. Datenlecks sind eine häufige Ursache für nicht reproduzierbare Ergebnisse und eine illusorisch hohe Leistung von ML-Modellen.

Das Nachdenken über die Skalierung zeigt, dass wir zuerst aufteilen müssen X und y Daten weiter in Zug- und Testsätze und dann zu passen ein Scaler auf dem Trainingsset und zu transformieren sowohl die Zug- als auch die Testsätze (ohne dass der Testsatz jemals den Scaler beeinflusst, der dies tut). Dazu verwenden wir Scikit-Learn train_test_split() Verfahren:

from sklearn.model_selection import train_test_split
SEED = 42 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=.25, 
                                                    random_state=SEED)

Rahmen test_size=.25 stellt sicher, dass wir 25 % der Daten für Tests und 75 % für Schulungen verwenden. Dies könnte weggelassen werden, sobald es die Standardaufteilung ist, aber die Pythonisch Art und Weise, Code zu schreiben, rät, dass „explizit besser als implizit“ ist.

Nach dem Aufteilen der Daten in Trainings- und Testsätze empfiehlt es sich, zu prüfen, wie viele Datensätze in jedem Satz enthalten sind. Das geht mit der shape Attribut:

X_train.shape, X_test.shape, y_train.shape, y_test.shape

Dies zeigt:

((1875, 12), (625, 12), (1875,), (625,))

Wir können sehen, dass wir nach der Aufteilung 1875 Datensätze zum Training und 625 zum Testen haben.

Skalierungsdaten

Sobald wir unsere Trainings- und Testsets fertig haben, können wir mit der Skalierung der Daten mit Scikit-Learn fortfahren StandardScaler -Objekt (oder andere von der Bibliothek bereitgestellte Skalierer). Um ein Auslaufen zu vermeiden, ist der Scaler an der montiert X_train Daten und die Zugwerte werden dann verwendet, um sowohl die Zug- als auch die Testdaten zu skalieren – oder zu transformieren:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Da Sie normalerweise anrufen:

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Die ersten beiden Zeilen können mit einem Singular reduziert werden fit_transform() call, der zum Scaler am Set passt und ihn in einem Rutsch umwandelt. Wir können jetzt die Boxplot-Diagramme reproduzieren, um den Unterschied nach dem Skalieren der Daten zu sehen.

In Anbetracht der Tatsache, dass die Skalierung Spaltennamen entfernt, können wir vor dem Plotten Zugdaten in einem Datenrahmen mit Spaltennamen organisieren, um die Visualisierung zu erleichtern:

column_names = df.columns[:12] 
X_train = pd.DataFrame(X_train, columns=column_names)

sns.boxplot(data=X_train, orient='h')

Wir können endlich alle unsere Boxplots sehen! Beachten Sie, dass sie alle Ausreißer haben, und die Features, die eine weiter von der Normalverteilung entfernte Verteilung aufweisen (mit Kurven, die entweder nach links oder rechts geneigt sind), wie z Solidity, Extent, Aspect_Ration und Compactedness, sind dieselben, die höhere Korrelationen hatten.

Ausreißer mit IQR-Methode entfernen

Wir wissen bereits, dass die logistische Regression durch Ausreißer beeinflusst werden kann. Eine der Möglichkeiten, sie zu behandeln, ist die Verwendung einer Methode namens Interquartilbereich or IQR. Der erste Schritt der IQR-Methode besteht darin, unsere Zugdaten in vier Teile zu unterteilen, die Quartile genannt werden. Das erste Quartil, Q1, beläuft sich auf 25 % der Daten, die zweite, Q2, zu 50%, der dritte, Q3, auf 75 %, und der letzte, Q4, zu 100%. Die Boxen im Boxplot werden durch die IQR-Methode definiert und sind eine visuelle Darstellung davon.

Bei einem horizontalen Boxplot markiert die vertikale Linie links 25 % der Daten, die vertikale Linie in der Mitte 50 % der Daten (oder den Median) und die letzte vertikale Linie rechts 75 % der Daten . Je gleichmäßiger die beiden durch die vertikalen Linien definierten Quadrate sind – oder je mehr die mittlere vertikale Linie in der Mitte liegt – bedeutet, dass unsere Daten näher an der Normalverteilung oder weniger verzerrt sind, was für unsere Analyse hilfreich ist.

Neben der IQR-Box gibt es auch horizontale Linien auf beiden Seiten davon. Diese Linien markieren die durch definierten minimalen und maximalen Verteilungswerte

$$
Minimum = Q1 – 1.5*IQR
$$

und

$$
Maximum = Q3 + 1.5*IQR
$$

IQR ist genau der Unterschied zwischen Q3 und Q1 (oder Q3 – Q1) und es ist der zentralste Datenpunkt. Aus diesem Grund filtern wir bei der Ermittlung des IQR die Ausreißer in den Extremwerten der Daten oder in den Minimal- und Maximalpunkten heraus. Boxplots geben uns einen kleinen Vorgeschmack auf das Ergebnis der IQR-Methode.

Wir können Pandas verwenden quantile() Methode, um unsere Quantile zu finden, und iqr von dem scipy.stats Paket, um den Interquartil-Datenbereich für jede Spalte zu erhalten:

from scipy.stats import iqr

Q1 = X_train.quantile(q=.25)
Q3 = X_train.quantile(q=.75)

IQR = X_train.apply(iqr)

Jetzt haben wir Q1, Q3 und IQR, wir können die Werte herausfiltern, die näher am Median liegen:

minimum = X_train < (Q1-1.5*IQR)
maximum = X_train > (Q3+1.5*IQR)


filter = ~(minimum | maximum).any(axis=1)


X_train = X_train[filter]

Nachdem wir unsere Trainingszeilen gefiltert haben, können wir sehen, wie viele davon noch in den Daten enthalten sind shape:

X_train.shape

Das führt zu:

(1714, 12)

Wir können sehen, dass die Anzahl der Zeilen nach dem Filtern von 1875 auf 1714 gestiegen ist. Das bedeutet, dass 161 Zeilen Ausreißer oder 8.5 % der Daten enthielten.

Nach dem Entfernen von Ausreißern sind wir fast bereit, Daten in das Modell aufzunehmen. Für die Modellanpassung verwenden wir Zugdaten. X_train wird gefiltert, aber was ist y_train?

y_train.shape

Dies gibt aus:

(1875,)

Beachte das y_train hat immer noch 1875 Zeilen. Wir müssen die Anzahl von übereinstimmen y_train Zeilen auf die Anzahl der X_train Zeilen und nicht nur beliebig. Wir müssen die y-Werte der von uns entfernten Instanzen von Kürbiskernen entfernen, die wahrscheinlich über die verteilt sind y_train einstellen. Die gefiltert X_train stil hat seine ursprünglichen Indizes und der Index hat Lücken, wo wir Ausreißer entfernt haben! Wir können dann den Index der verwenden X_train DataFrame, in dem nach den entsprechenden Werten gesucht werden soll y_train:

y_train = y_train.iloc[X_train.index]

Danach können wir uns die ansehen y_train wieder formen:

y_train.shape

Welche Ausgänge:

(1714,)

Jetzt, y_train hat auch 1714 Zeilen und sie sind die gleichen wie die X_train Reihen. Wir sind endlich bereit, unser logistisches Regressionsmodell zu erstellen!

Implementieren des logistischen Regressionsmodells

Der schwierige Teil ist geschafft! Die Vorverarbeitung ist normalerweise schwieriger als die Modellentwicklung, wenn es um die Verwendung von Bibliotheken wie Scikit-Learn geht, die die Anwendung von ML-Modellen auf nur wenige Zeilen reduziert haben.

Zuerst importieren wir die LogisticRegression Klasse und instanziieren Sie sie, indem Sie eine erstellen LogisticRegression Objekt:

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression(random_state=SEED)

Zweitens passen wir unsere Zugdaten an die an logreg Modell mit dem fit() Methode und sagen Sie unsere Testdaten mit der predict() Methode, Speichern der Ergebnisse als y_pred:

logreg.fit(X_train.values, y_train)
y_pred = logreg.predict(X_test)

Wir haben mit unserem Modell bereits Vorhersagen getroffen! Schauen wir uns die ersten 3 Zeilen an X_train um zu sehen, welche Daten wir verwendet haben:

X_train[:3]

Der obige Code gibt aus:

       Area          Perimeter     Major_Axis_Length    Minor_Axis_Length    Convex_Area   Equiv_Diameter       Eccentricity  Solidity      Extent        Roundness     Aspect_Ration        Compactness
0      -1.098308     -0.936518     -0.607941            -1.132551            -1.082768     -1.122359            0.458911      -1.078259     0.562847      -0.176041     0.236617             -0.360134
1      -0.501526     -0.468936     -0.387303            -0.376176            -0.507652     -0.475015            0.125764      0.258195      0.211703      0.094213      -0.122270            0.019480
2      0.012372      -0.209168     -0.354107            0.465095              0.003871      0.054384            -0.453911     0.432515      0.794735      0.647084      -0.617427            0.571137

Und bei den ersten 3 Vorhersagen in y_pred um die Ergebnisse zu sehen:

y_pred[:3] 

Das führt zu:

array([0, 0, 0])

Für diese drei Reihen waren unsere Vorhersagen, dass sie Samen der ersten Klasse waren, Çerçevelik.

Mit der logistische Regression, anstatt die endgültige Klasse vorherzusagen, wie z 0, können wir auch die Wahrscheinlichkeit vorhersagen, dass die Zeile zu den gehört 0 Klasse. Das passiert tatsächlich, wenn die logistische Regression Daten klassifiziert, und das predict() -Methode leitet diese Vorhersage dann durch einen Schwellenwert, um eine „harte“ Klasse zurückzugeben. Um die Wahrscheinlichkeit der Zugehörigkeit zu einer Klasse vorherzusagen, predict_proba() wird genutzt:

y_pred_proba = logreg.predict_proba(X_test)

Schauen wir uns auch die ersten 3 Werte der y-Wahrscheinlichkeitsvorhersagen an:

y_pred_proba[:3] 

Welche Ausgänge:

        # class 0   class 1   
array([[0.54726628, 0.45273372],
       [0.56324527, 0.43675473],
       [0.86233349, 0.13766651]])

Anstelle von drei Nullen haben wir jetzt eine Spalte für jede Klasse. In der Spalte links beginnend mit 0.54726628, sind die Wahrscheinlichkeiten der Daten, die sich auf die Klasse beziehen 0; und in der rechten Spalte beginnend mit 0.45273372, sind die Wahrscheinlichkeit, dass es sich auf die Klasse bezieht 1.

Es gibt weitere Informationen darüber, wie die vorhergesagte Ausgabe erstellt wurde. Das war es eigentlich nicht 0, aber eine 55% ige Chance auf Klasse 0, und eine 45% ige Chance auf Klasse 1. Dies zeigt, wie die ersten drei X_test Datenpunkte, die sich auf die Klasse beziehen 0, sind nur beim dritten Datenpunkt mit einer Wahrscheinlichkeit von 86 % wirklich eindeutig – und nicht so sehr bei den ersten beiden Datenpunkten.

Bei der Übermittlung von Ergebnissen mithilfe von ML-Methoden ist es in der Regel am besten, eine weiche Klasse und die zugehörige Wahrscheinlichkeit als zurückzugeben "Vertrauen" dieser Klassifikation.

Wir werden mehr darüber sprechen, wie das berechnet wird, wenn wir tiefer in das Modell einsteigen. Zu diesem Zeitpunkt können wir mit dem nächsten Schritt fortfahren.

Bewerten des Modells mit Klassifizierungsberichten

Der dritte Schritt besteht darin, zu sehen, wie das Modell bei Testdaten abschneidet. Wir können Scikit-Learn importieren classification_report() und passieren unsere y_test und y_pred als Argumente. Danach können wir seine Antwort ausdrucken.

Der Klassifizierungsbericht enthält die am häufigsten verwendeten Klassifizierungsmetriken, wie z Präzision, erinnern, f1-Ergebnis und Genauigkeit.

1. Präzision: um zu verstehen, welche korrekten Vorhersagewerte von unserem Klassifikator als korrekt angesehen wurden. Precision dividiert diese True-Positives-Werte durch alles, was als positiv vorhergesagt wurde:

$$
Genauigkeit = frac{Text{wahr positiv}}{Text{wahr positiv} + Text{falsch positiv}}
$$

2. Erinnern: Um zu verstehen, wie viele der True Positives von unserem Klassifikator identifiziert wurden. Der Rückruf wird berechnet, indem die wahren Positiven durch alles geteilt werden, was als positiv hätte vorhergesagt werden sollen:

$$
Erinnerung = frac{Text{wahr positiv}}{Text{wahr positiv} + Text{falsch negativ}}
$$

3. F1-Punktzahl: ist das ausgewogene oder harmonische Mittel von Präzision und Rückruf. Der niedrigste Wert ist 0 und der höchste 1. Wann f1-score gleich 1 ist, bedeutet dies, dass alle Klassen korrekt vorhergesagt wurden – dies ist mit echten Daten sehr schwer zu erreichen:

$$
text{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

4. Genauigkeit: beschreibt, wie viele Vorhersagen unser Klassifikator richtig gemacht hat. Der niedrigste Genauigkeitswert ist 0 und der höchste 1. Dieser Wert wird normalerweise mit 100 multipliziert, um einen Prozentsatz zu erhalten:

$$
Genauigkeit = frac{Text{Anzahl richtiger Vorhersagen}}{Text{Gesamtzahl der Vorhersagen}}
$$

from sklearn.metrics import classification_report
cr = classification_report(y_test, y_pred)
print(cr)

Wir können uns dann die Ausgabe des Klassifizierungsberichts ansehen:

				precision    recall  f1-score   support

           0       0.83      0.91      0.87       316
           1       0.90      0.81      0.85       309

    accuracy                           0.86       625
   macro avg       0.86      0.86      0.86       625
weighted avg       0.86      0.86      0.86       625

Das ist unser Ergebnis. Beachte das precision, recall, f1-score und accuracy Alle Metriken sind sehr hoch, über 80 %, was ideal ist – aber diese Ergebnisse wurden wahrscheinlich durch hohe Korrelationen beeinflusst und werden auf lange Sicht nicht Bestand haben.

Die Genauigkeit des Modells beträgt 86 %, was bedeutet, dass die Klassifizierung in 14 % der Fälle falsch ist. Wir haben diese Gesamtinformationen, aber es wäre interessant zu wissen, ob die 14% Fehler bei der Klassifizierung der Klasse passieren 0 oder klasse 1. Um zu identifizieren, welche Klassen fälschlicherweise als welche und in welcher Häufigkeit identifiziert werden, können wir a berechnen und darstellen Verwirrung Matrix der Vorhersagen unseres Modells.

Bewertung des Modells mit einer Konfusionsmatrix

Lassen Sie uns die Konfusionsmatrix berechnen und dann plotten. Danach können wir jeden Teil davon verstehen. Um die Konfusionsmatrix zu zeichnen, verwenden wir Scikit-Learn confusion_matrix(), die wir aus importieren metrics Modul.

Die Verwirrungsmatrix ist mit einem Seaborn einfacher zu visualisieren heatmap(). Nachdem wir sie generiert haben, übergeben wir unsere Konfusionsmatrix als Argument für die Heatmap:

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d')

5. Verwirrung Matrix: Die Matrix zeigt, wie viele Stichproben das Modell für jede Klasse richtig oder falsch gemacht hat. Die Werte, die richtig waren und korrekt vorhergesagt wurden, werden aufgerufen wahre positive, und diejenigen, die als positiv vorhergesagt wurden, aber nicht positiv waren, werden aufgerufen Fehlalarm. Dieselbe Nomenklatur von wahre Negative und falsche Negative wird für negative Werte verwendet;

Wenn wir uns das Diagramm der Verwirrungsmatrix ansehen, können wir sehen, dass wir es getan haben 287 Werte, die waren 0 und vorhergesagt als 0 - oder wahre positive für die Klasse 0 (die Çerçevelik-Samen). Wir haben auch 250 echte Positive für den Unterricht 1 (Ürgüp Sivrisi-Samen). Die wahren Positiven befinden sich immer in der Matrixdiagonalen, die von links oben nach rechts unten geht.

Wir haben auch 29 Werte, die sein sollten 0, aber vorhergesagt als 1 (Fehlalarm) und 59 Werte, die waren 1 und vorhergesagt als 0 (falsche Negative). Mit diesen Zahlen können wir verstehen, dass der Fehler, den das Modell am meisten macht, darin besteht, dass es falsch negative Ergebnisse vorhersagt. Daher kann es meistens dazu führen, dass ein Ürgüp Sivrisi-Samen als Çerçevelik-Samen klassifiziert wird.

Diese Art von Fehler erklärt sich auch durch die 81%-ige Erinnerung an die Klasse 1. Beachten Sie, dass die Metriken verbunden sind. Und der Unterschied im Rückruf kommt daher, dass 100 Proben weniger der Klasse Ürgüp Sivrisi vorhanden sind. Dies ist eine der Auswirkungen, wenn man nur ein paar Samples weniger als die andere Klasse hat. Um die Erinnerung weiter zu verbessern, können Sie entweder mit Klassengewichtungen experimentieren oder mehr Ürgüp-Sivrisi-Samples verwenden.

Bisher haben wir die meisten traditionellen Data-Science-Schritte ausgeführt und das logistische Regressionsmodell als Blackbox verwendet.

Jetzt ist es an der Zeit, die Black Box zu öffnen und hineinzuschauen, um tiefer in das Verständnis der Funktionsweise der logistischen Regression einzudringen.

Gehen Sie tiefer in die Funktionsweise der logistischen Regression ein

Das Regression Das Wort ist nicht zufällig vorhanden. Um zu verstehen, was die logistische Regression tut, können wir uns daran erinnern, was ihre Schwester, die lineare Regression, mit den Daten macht. Die lineare Regressionsformel lautete wie folgt:

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n
$$

Wobei b₀ war der Regressionsabschnitt, b¹ der Koeffizient und x¹ die Daten.

Diese Gleichung führte zu einer geraden Linie, die zur Vorhersage neuer Werte verwendet wurde. In Erinnerung an die Einführung besteht der Unterschied jetzt darin, dass wir keine neuen Werte vorhersagen, sondern eine Klasse. Diese gerade Linie muss sich also ändern. Mit der logistischen Regression führen wir eine Nichtlinearität ein und die Vorhersage erfolgt jetzt mithilfe einer Kurve anstelle einer Linie:

Beachten Sie, dass, während die lineare Regressionslinie weitergeht und aus kontinuierlichen unendlichen Werten besteht, die logistische Regressionskurve in der Mitte geteilt werden kann und Extreme in 0- und 1-Werten hat. Diese „S“-Form ist der Grund, warum Daten klassifiziert werden – die Punkte, die näher beieinander liegen oder auf das höchste Ende fallen, gehören zur Klasse 1, während die Punkte, die im unteren Quadranten oder näher an 0 liegen, zur Klasse 0 gehören. Die Mitte von das „S“ ist die Mitte zwischen 0 und 1, 0.5 – es ist die Schwelle für die logistischen Regressionspunkte.

Wir verstehen bereits den visuellen Unterschied zwischen logistischer und linearer Regression, aber was ist mit der Formel? Die Formel für die logistische Regression lautet wie folgt:

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n
$$

Es kann auch geschrieben werden als:

$$
y_{prob} = frac{1}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

Oder sogar geschrieben werden als:

$$
y_{prob} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

In der obigen Gleichung haben wir die Wahrscheinlichkeit der Eingabe anstelle ihres Wertes. Er hat 1 als Zähler, sodass er einen Wert zwischen 0 und 1 ergeben kann, und 1 plus einen Wert im Nenner, sodass sein Wert 1 und etwas anderes ist – das bedeutet, dass das Ergebnis eines ganzen Bruchs nicht größer als 1 sein kann .

Und was ist der Wert, der im Nenner steht? es ist e, die Basis des natürlichen Logarithmus (ungefähr 2.718282), potenziert mit der linearen Regression:

$$
e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

Eine andere Schreibweise wäre:

$$
ln links( frac{p}{1-p} rechts) = {(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

In dieser letzten Gleichung ln ist der natürliche Logarithmus (Basis e) und p die Wahrscheinlichkeit ist, also ist der Logarithmus der Wahrscheinlichkeit des Ergebnisses derselbe wie das Ergebnis der linearen Regression.

Mit anderen Worten, mit dem Ergebnis der linearen Regression und dem natürlichen Logarithmus können wir die Wahrscheinlichkeit ermitteln, ob eine Eingabe zu einer entworfenen Klasse gehört oder nicht.

Der gesamte Ableitungsprozess der logistischen Regression ist wie folgt:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

$$
p(1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}) = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

$$
p + p*e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

p
=

e

(

b
0

+

b
1

*

x
1

+

b
2

*

x
2

+

b
3

*

x
3

+
...
+

b
n

*

x
n

)

-
p
*

e

(

b
0

+

b
1

*

x
1

+

b
2

*

x
2

+

b
3

*

x
3

+
...
+

b
n

*

x
n

)

$$
frac{p}{1-p} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

$$
ln links( frac{p}{1-p} rechts) = (b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)
$$

Das bedeutet, dass das logistische Regressionsmodell auch Koeffizienten und einen Schnittpunktwert hat. Weil es eine lineare Regression verwendet und mit dem natürlichen Logarithmus (e).

Wir können die Werte der Koeffizienten und den Achsenabschnitt unseres Modells sehen, genauso wie wir es für die lineare Regression getan haben, indem wir verwenden coef_ und intercept_ Eigenschaften:

logreg.coef_

Welche zeigt die Koeffizienten von jedem der 12 Merkmale:

array([[ 1.43726172, -1.03136968,  0.24099522, -0.61180768,  1.36538261,
        -1.45321951, -1.22826034,  0.98766966,  0.0438686 , -0.78687889,
         1.9601197 , -1.77226097]])

logreg.intercept_

Daraus ergibt sich:

array([0.08735782])

Mit den Koeffizienten und Schnittwerten können wir die vorhergesagten Wahrscheinlichkeiten unserer Daten berechnen. Nehmen wir die erste X_test wieder Werte, als Beispiel:

X_test[:1]

Dies gibt die erste Zeile von zurück X_test als NumPy-Array:

array([[-1.09830823, -0.93651823, -0.60794138, -1.13255059, -1.0827684 ,
        -1.12235877,  0.45891056, -1.07825898,  0.56284738, -0.17604099,
         0.23661678, -0.36013424]])

Nach der Anfangsgleichung:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

In Python haben wir:

import math

lin_reg = logreg.intercept_[0] + 
((logreg.coef_[0][0]* X_test[:1][0][0])+ 
(logreg.coef_[0][1]* X_test[:1][0][1])+ 
(logreg.coef_[0][2]* X_test[:1][0][2])+ 
(logreg.coef_[0][3]* X_test[:1][0][3])+ 
(logreg.coef_[0][4]* X_test[:1][0][4])+ 
(logreg.coef_[0][5]* X_test[:1][0][5])+ 
(logreg.coef_[0][6]* X_test[:1][0][6])+ 
(logreg.coef_[0][7]* X_test[:1][0][7])+ 
(logreg.coef_[0][8]* X_test[:1][0][8])+ 
(logreg.coef_[0][9]* X_test[:1][0][9])+ 
(logreg.coef_[0][10]* X_test[:1][0][10])+ 
(logreg.coef_[0][11]* X_test[:1][0][11]))

px = math.exp(lin_reg)/(1 +(math.exp(lin_reg)))
px

Das führt zu:

0.45273372469369133

Wenn wir uns das noch einmal anschauen predict_proba Ergebnis des ersten X_test Linie, wir haben:

logreg.predict_proba(X_test[:1])

Das bedeutet, dass uns die ursprüngliche logistische Regressionsgleichung die Wahrscheinlichkeit der Eingabe bezüglich der Klasse liefert 1, um herauszufinden, welche Wahrscheinlichkeit für die Klasse gilt 0, können wir einfach:

1 - px

Beachten Sie, dass beide px und 1-px sind identisch mit predict_proba Ergebnisse. So wird die logistische Regression berechnet und warum Regression ist Teil seines Namens. Aber was ist mit dem Begriff logistisch?

Die logistisch kommt von logit, das ist eine Funktion, die wir bereits gesehen haben:

$$
ln links( frac{p}{1-p} rechts)
$$

Wir haben es gerade mit gerechnet px und 1-px. Dies ist das Logit, auch genannt Log-Quoten da es gleich dem Logarithmus der Chancen wo ist p ist eine Wahrscheinlichkeit.

Zusammenfassung

In diesem Leitfaden haben wir einen der grundlegendsten Klassifizierungsalgorithmen für maschinelles Lernen untersucht, dh logistische Regression.

Anfangs haben wir die logistische Regression als Blackbox mit der maschinellen Lernbibliothek von Scikit-Learn implementiert und später Schritt für Schritt verstanden, um klar zu machen, warum und woher die Begriffe Regression und Logistik kommen.

Wir haben die Daten auch untersucht und untersucht, da wir verstanden haben, dass dies einer der wichtigsten Teile einer datenwissenschaftlichen Analyse ist.

Von hier aus würde ich Ihnen raten, damit herumzuspielen Logistische Mehrklassenregression, logistische Regression für mehr als zwei Klassen – Sie können denselben logistischen Regressionsalgorithmus auf andere Datasets mit mehreren Klassen anwenden und die Ergebnisse interpretieren.

Ich würde Ihnen auch raten, die L1 und L2 zu studieren Regularisierungen, sie sind eine Möglichkeit, die höheren Daten zu „bestrafen“, damit sie näher an den Normalwert herankommen und die Komplexität des Modells aushalten, damit der Algorithmus zu einem besseren Ergebnis gelangen kann. Die von uns verwendete Scikit-Learn-Implementierung verfügt bereits standardmäßig über eine L2-Regularisierung. Eine andere Sache, die man sich ansehen sollte, ist der Unterschied Löser, sowie lbgs, die die Leistung des logistischen Regressionsalgorithmus optimieren.

Es ist auch wichtig, einen Blick auf die zu werfen statistisch Ansatz zur logistischen Regression. Es hat Annahmen über das Verhalten von Daten und über andere Statistiken, die vorhanden sein müssen, um zufriedenstellende Ergebnisse zu gewährleisten, wie zum Beispiel:

• die Beobachtungen sind unabhängig;
• es gibt keine Multikollinearität zwischen erklärenden Variablen;
• es gibt keine extremen Ausreißer;
• es besteht eine lineare Beziehung zwischen erklärenden Variablen und dem Logit der Antwortvariablen;
• die Stichprobengröße ausreichend groß ist.

Beachten Sie, wie viele dieser Annahmen bereits in unserer Analyse und Verarbeitung von Daten berücksichtigt wurden.

Ich hoffe, Sie erkunden weiterhin, was die logistische Regression in all ihren verschiedenen Ansätzen zu bieten hat!