Maschinelles Lernen mit Python - Kurzanleitung
Wir leben im Zeitalter der Daten, das mit besserer Rechenleistung und mehr Speicherressourcen angereichert ist. Diese Daten oder Informationen nehmen von Tag zu Tag zu, aber die eigentliche Herausforderung besteht darin, alle Daten zu verstehen. Unternehmen und Organisationen versuchen, damit umzugehen, indem sie intelligente Systeme unter Verwendung der Konzepte und Methoden aus Data Science, Data Mining und maschinellem Lernen aufbauen. Unter ihnen ist maschinelles Lernen das aufregendste Gebiet der Informatik. Es wäre nicht falsch, wenn wir maschinelles Lernen als Anwendung und Wissenschaft von Algorithmen bezeichnen, die den Daten Sinn verleihen.
Was ist maschinelles Lernen?
Maschinelles Lernen (ML) ist das Gebiet der Informatik, mit dessen Hilfe Computersysteme Daten auf die gleiche Weise sinnvoll machen können wie Menschen.
Mit einfachen Worten, ML ist eine Art künstliche Intelligenz, die mithilfe eines Algorithmus oder einer Methode Muster aus Rohdaten extrahiert. Das Hauptaugenmerk von ML liegt darauf, Computersystemen zu ermöglichen, aus Erfahrungen zu lernen, ohne explizit programmiert zu werden oder menschliches Eingreifen.
Notwendigkeit für maschinelles Lernen
Der Mensch ist derzeit die intelligenteste und fortschrittlichste Spezies der Erde, weil er komplexe Probleme denken, bewerten und lösen kann. Auf der anderen Seite befindet sich die KI noch im Anfangsstadium und hat die menschliche Intelligenz in vielen Aspekten nicht übertroffen. Dann ist die Frage, was ist die Notwendigkeit, um Maschine lernen zu lassen? Der am besten geeignete Grund dafür ist, „Entscheidungen auf der Grundlage von Daten mit Effizienz und Skalierbarkeit zu treffen“.
In letzter Zeit investieren Unternehmen stark in neuere Technologien wie künstliche Intelligenz, maschinelles Lernen und Deep Learning, um die wichtigsten Informationen aus Daten zu erhalten, um mehrere reale Aufgaben auszuführen und Probleme zu lösen. Wir können es datengesteuerte Entscheidungen nennen, die von Maschinen getroffen werden, insbesondere um den Prozess zu automatisieren. Diese datengesteuerten Entscheidungen können anstelle der Programmierlogik bei Problemen verwendet werden, die nicht inhärent programmiert werden können. Tatsache ist, dass wir nicht ohne menschliche Intelligenz auskommen können, aber ein anderer Aspekt ist, dass wir alle reale Probleme mit Effizienz in großem Maßstab lösen müssen. Deshalb entsteht der Bedarf an maschinellem Lernen.
Warum und wann sollen Maschinen lernen?
Wir haben bereits die Notwendigkeit des maschinellen Lernens erörtert, aber es stellt sich die Frage, in welchen Szenarien wir die Maschine zum Lernen bringen müssen. Es kann verschiedene Umstände geben, unter denen wir Maschinen benötigen, um datengesteuerte Entscheidungen effizient und in großem Umfang zu treffen. Im Folgenden sind einige dieser Umstände aufgeführt, unter denen das Erlernen von Maschinen effektiver wäre -
Mangel an menschlichem Fachwissen
Das allererste Szenario, in dem eine Maschine lernen und datengesteuerte Entscheidungen treffen soll, kann der Bereich sein, in dem es an menschlichem Fachwissen mangelt. Die Beispiele können Navigationen in unbekannten Gebieten oder Raumplaneten sein.
Dynamische Szenarien
Es gibt einige Szenarien, die dynamischer Natur sind, dh sie ändern sich im Laufe der Zeit ständig. Bei diesen Szenarien und Verhaltensweisen soll eine Maschine lernen und datengesteuerte Entscheidungen treffen. Einige Beispiele können die Netzwerkkonnektivität und die Verfügbarkeit der Infrastruktur in einer Organisation sein.
Schwierigkeiten bei der Umsetzung von Fachwissen in Rechenaufgaben
Es kann verschiedene Bereiche geben, in denen Menschen ihr Fachwissen haben; Sie können dieses Fachwissen jedoch nicht in Rechenaufgaben umsetzen. Unter solchen Umständen wollen wir maschinelles Lernen. Die Beispiele können die Bereiche Spracherkennung, kognitive Aufgaben usw. sein.
Modell des maschinellen Lernens
Bevor wir das Modell des maschinellen Lernens diskutieren, müssen wir die folgende formale Definition von ML verstehen, die von Professor Mitchell gegeben wurde:
"Ein Computerprogramm soll aus der Erfahrung E in Bezug auf eine Klasse von Aufgaben T und das Leistungsmaß P lernen, wenn sich seine Leistung bei Aufgaben in T, gemessen durch P, mit der Erfahrung E verbessert."
Die obige Definition konzentriert sich im Wesentlichen auf drei Parameter, auch die Hauptkomponenten eines Lernalgorithmus, nämlich Aufgabe (T), Leistung (P) und Erfahrung (E). In diesem Zusammenhang können wir diese Definition vereinfachen als -
ML ist ein KI-Bereich, der aus Lernalgorithmen besteht, die -
Verbessere ihre Leistung (P)
Bei der Ausführung einer Aufgabe (T)
Im Laufe der Zeit mit Erfahrung (E)
Basierend auf dem oben Gesagten stellt das folgende Diagramm ein Modell für maschinelles Lernen dar -
Lassen Sie uns sie jetzt genauer besprechen -
Aufgabe (T)
Aus der Perspektive des Problems können wir die Aufgabe T als das zu lösende reale Problem definieren. Das Problem kann darin bestehen, den besten Immobilienpreis an einem bestimmten Ort zu finden oder die beste Marketingstrategie usw. zu finden. Wenn wir dagegen über maschinelles Lernen sprechen, ist die Definition der Aufgabe anders, da es schwierig ist, ML-basierte Aufgaben zu lösen konventioneller Programmieransatz.
Eine Aufgabe T wird als ML-basierte Aufgabe bezeichnet, wenn sie auf dem Prozess basiert und das System folgen muss, um Datenpunkte zu bearbeiten. Beispiele für ML-basierte Aufgaben sind Klassifizierung, Regression, strukturierte Annotation, Clustering, Transkription usw.
Erfahrung (E)
Wie der Name schon sagt, handelt es sich um das Wissen, das aus Datenpunkten gewonnen wurde, die dem Algorithmus oder Modell zur Verfügung gestellt wurden. Sobald das Dataset bereitgestellt wurde, wird das Modell iterativ ausgeführt und lernt ein inhärentes Muster. Das so erworbene Lernen heißt Erfahrung (E). Wenn wir eine Analogie zum menschlichen Lernen ziehen, können wir uns diese Situation so vorstellen, dass ein Mensch aus verschiedenen Attributen wie Situation, Beziehungen usw. lernt oder Erfahrungen sammelt. Überwachtes, unbeaufsichtigtes und verstärkendes Lernen sind einige Möglichkeiten, um zu lernen oder Erfahrungen zu sammeln. Die Erfahrungen aus unserem ML-Modell oder -Algorithmus werden zur Lösung der Aufgabe T verwendet.
Leistung (P)
Ein ML-Algorithmus soll Aufgaben ausführen und Erfahrungen im Laufe der Zeit sammeln. Das Maß, das angibt, ob der ML-Algorithmus erwartungsgemäß funktioniert oder nicht, ist seine Leistung (P). P ist im Grunde eine quantitative Metrik, die anhand ihrer Erfahrung E angibt, wie ein Modell die Aufgabe T ausführt. Es gibt viele Metriken, die zum Verständnis der ML-Leistung beitragen, z. B. Genauigkeitsbewertung, F1-Bewertung, Verwirrungsmatrix, Präzision und Rückruf , Empfindlichkeit usw.
Herausforderungen beim maschinellen Lernen
Während sich das maschinelle Lernen rasant weiterentwickelt und mit Cybersicherheit und autonomen Autos erhebliche Fortschritte macht, hat dieses Segment der KI insgesamt noch einen langen Weg vor sich. Der Grund dafür ist, dass ML die Anzahl der Herausforderungen nicht bewältigen konnte. Die Herausforderungen, vor denen ML derzeit steht, sind:
Quality of data- Gute Datenqualität für ML-Algorithmen ist eine der größten Herausforderungen. Die Verwendung von Daten geringer Qualität führt zu Problemen im Zusammenhang mit der Datenvorverarbeitung und der Merkmalsextraktion.
Time-Consuming task - Eine weitere Herausforderung für ML-Modelle ist der Zeitaufwand, insbesondere für die Datenerfassung, Merkmalsextraktion und das Abrufen.
Lack of specialist persons - Da die ML-Technologie noch in den Kinderschuhen steckt, ist die Verfügbarkeit von Expertenressourcen eine schwierige Aufgabe.
No clear objective for formulating business problems - Kein klares Ziel und klar definiertes Ziel für geschäftliche Probleme zu haben, ist eine weitere zentrale Herausforderung für ML, da diese Technologie noch nicht so ausgereift ist.
Issue of overfitting & underfitting - Wenn das Modell über- oder unterpasst ist, kann es für das Problem nicht gut dargestellt werden.
Curse of dimensionality- Eine weitere Herausforderung für das ML-Modell sind zu viele Merkmale von Datenpunkten. Dies kann ein echtes Hindernis sein.
Difficulty in deployment - Die Komplexität des ML-Modells macht es ziemlich schwierig, im wirklichen Leben eingesetzt zu werden.
Anwendungen des maschinellen Lernens
Maschinelles Lernen ist die am schnellsten wachsende Technologie und laut Forschern befinden wir uns im goldenen Jahr von KI und ML. Es wird verwendet, um viele reale komplexe Probleme zu lösen, die mit einem herkömmlichen Ansatz nicht gelöst werden können. Im Folgenden finden Sie einige reale Anwendungen von ML -
Emotionsanalyse
Stimmungsanalyse
Fehlererkennung und -verhütung
Wettervorhersage und Vorhersage
Börsenanalyse und -prognose
Sprachsynthese
Spracherkennung
Kundensegmentierung
Objekterkennung
Entdeckung eines Betruges
Betrugsprävention
Produktempfehlung an den Kunden beim Online-Shopping.
Eine Einführung in Python
Python ist eine beliebte objektorientierte Programmiersprache mit den Fähigkeiten einer höheren Programmiersprache. Seine leicht zu erlernende Syntax und Portabilitätsfähigkeit machen es heutzutage beliebt. Die folgenden Fakten geben uns die Einführung in Python -
Python wurde von Guido van Rossum am Stichting Mathematisch Centrum in den Niederlanden entwickelt.
Es wurde als Nachfolger der Programmiersprache 'ABC' geschrieben.
Die erste Version wurde 1991 veröffentlicht.
Der Name Python wurde von Guido van Rossum aus einer TV-Show namens Monty Pythons Flying Circus ausgewählt.
Es ist eine Open-Source-Programmiersprache, dh wir können sie kostenlos herunterladen und zur Entwicklung von Programmen verwenden. Es kann von www.python.org heruntergeladen werden .
Die Programmiersprache Python verfügt über die Funktionen von Java und C. Es hat den eleganten C-Code und andererseits Klassen und Objekte wie Java für die objektorientierte Programmierung.
Es ist eine interpretierte Sprache, dh der Quellcode des Python-Programms wird zuerst in Bytecode konvertiert und dann von der virtuellen Python-Maschine ausgeführt.
Stärken und Schwächen von Python
Jede Programmiersprache hat einige Stärken und Schwächen, ebenso wie Python.
Stärken
Studien und Umfragen zufolge ist Python die fünftwichtigste Sprache sowie die beliebteste Sprache für maschinelles Lernen und Datenwissenschaft. Aufgrund der folgenden Stärken hat Python:
Easy to learn and understand- Die Syntax von Python ist einfacher; Daher ist es selbst für Anfänger relativ einfach, die Sprache zu lernen und zu verstehen.
Multi-purpose language - Python ist eine Mehrzweckprogrammiersprache, da es strukturierte Programmierung, objektorientierte Programmierung sowie funktionale Programmierung unterstützt.
Huge number of modules- Python verfügt über eine große Anzahl von Modulen, die alle Aspekte der Programmierung abdecken. Diese Module sind leicht verfügbar und machen Python zu einer erweiterbaren Sprache.
Support of open source community- Als Open Source-Programmiersprache wird Python von einer sehr großen Entwicklergemeinschaft unterstützt. Aus diesem Grund können die Fehler von der Python-Community leicht behoben werden. Diese Eigenschaft macht Python sehr robust und anpassungsfähig.
Scalability - Python ist eine skalierbare Programmiersprache, da es eine verbesserte Struktur für die Unterstützung großer Programme bietet als Shell-Skripte.
Die Schwäche
Obwohl Python eine beliebte und leistungsstarke Programmiersprache ist, hat es seine eigene Schwäche der langsamen Ausführungsgeschwindigkeit.
Die Ausführungsgeschwindigkeit von Python ist im Vergleich zu kompilierten Sprachen langsam, da Python eine interpretierte Sprache ist. Dies kann der Hauptverbesserungsbereich für die Python-Community sein.
Python installieren
Um in Python arbeiten zu können, müssen wir es zuerst installieren. Sie können die Installation von Python auf eine der folgenden zwei Arten durchführen:
Python einzeln installieren
Verwenden der vorgefertigten Python-Distribution - Anaconda
Lassen Sie uns diese jeweils im Detail besprechen.
Python einzeln installieren
Wenn Sie Python auf Ihrem Computer installieren möchten, müssen Sie nur den für Ihre Plattform geltenden Binärcode herunterladen. Die Python-Distribution ist für Windows-, Linux- und Mac-Plattformen verfügbar.
Im Folgenden finden Sie eine kurze Übersicht über die Installation von Python auf den oben genannten Plattformen:
On Unix and Linux platform
Mit Hilfe der folgenden Schritte können wir Python unter Unix und Linux installieren -
Gehen Sie zuerst zu https://www.python.org/downloads/.
Klicken Sie anschließend auf den Link, um den für Unix / Linux verfügbaren komprimierten Quellcode herunterzuladen.
Laden Sie jetzt Dateien herunter und extrahieren Sie sie.
Als nächstes können wir die Modul- / Setup-Datei bearbeiten, wenn wir einige Optionen anpassen möchten.
Schreiben Sie als Nächstes den Befehl run ./configure script
make
make install
On Windows platform
Mit Hilfe der folgenden Schritte können wir Python auf der Windows-Plattform installieren -
Gehen Sie zuerst zu https://www.python.org/downloads/.
Klicken Sie anschließend auf den Link für die Windows-Installationsdatei python-XYZ.msi. Hier ist XYZ die Version, die wir installieren möchten.
Jetzt müssen wir die heruntergeladene Datei ausführen. Wir gelangen zum Python-Installationsassistenten, der einfach zu bedienen ist. Übernehmen Sie nun die Standardeinstellungen und warten Sie, bis die Installation abgeschlossen ist.
On Macintosh platform
Für Mac OS X, Homebrew, wird ein großartiges und benutzerfreundliches Paketinstallationsprogramm empfohlen, um Python 3 zu installieren. Falls Sie kein Homebrew haben, können Sie es mit Hilfe des folgenden Befehls installieren:
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"
Es kann mit dem folgenden Befehl aktualisiert werden -
$ brew update
Um Python3 auf Ihrem System zu installieren, müssen Sie den folgenden Befehl ausführen:
$ brew install python3
Verwenden der vorgefertigten Python-Distribution: Anaconda
Anaconda ist eine gepackte Zusammenstellung von Python, die alle in der Datenwissenschaft weit verbreiteten Bibliotheken enthält. Wir können die folgenden Schritte ausführen, um die Python-Umgebung mit Anaconda einzurichten:
Step1- Zuerst müssen wir das erforderliche Installationspaket von der Anaconda-Distribution herunterladen. Der Link dafür isthttps://www.anaconda.com/distribution/. Sie können je nach Anforderung zwischen Windows-, Mac- und Linux-Betriebssystemen wählen.
Step2- Wählen Sie als Nächstes die Python-Version aus, die Sie auf Ihrem Computer installieren möchten. Die neueste Python-Version ist 3.7. Dort erhalten Sie die Optionen für das 64-Bit- und das 32-Bit-Grafikinstallationsprogramm.
Step3- Nach Auswahl des Betriebssystems und der Python-Version wird das Anaconda-Installationsprogramm auf Ihren Computer heruntergeladen. Doppelklicken Sie nun auf die Datei und das Installationsprogramm installiert das Anaconda-Paket.
Step4 - Um zu überprüfen, ob es installiert ist oder nicht, öffnen Sie eine Eingabeaufforderung und geben Sie Python wie folgt ein: -
Sie können dies auch in einer ausführlichen Videovorlesung unter überprüfenhttps://www.tutorialspoint.com/python_essentials_online_training/getting_started_with_anaconda.asp.
Warum Python für Data Science?
Python ist die fünftwichtigste Sprache sowie die beliebteste Sprache für maschinelles Lernen und Datenwissenschaft. Die folgenden Funktionen von Python machen es zur bevorzugten Sprachwahl für die Datenwissenschaft:
Umfangreiche Pakete
Python verfügt über eine umfangreiche und leistungsstarke Reihe von Paketen, die für die Verwendung in verschiedenen Domänen bereit sind. Es gibt auch Pakete wie Numpy, Scipy, Pandas, Scikit-Learn usw., die für maschinelles Lernen und Data Science erforderlich sind.
Einfaches Prototyping
Ein weiteres wichtiges Merkmal von Python, das es zur Wahl der Sprache für die Datenwissenschaft macht, ist das einfache und schnelle Prototyping. Diese Funktion ist nützlich für die Entwicklung eines neuen Algorithmus.
Kollaborationsfunktion
Das Gebiet der Datenwissenschaft erfordert grundsätzlich eine gute Zusammenarbeit, und Python bietet viele nützliche Tools, die dies extrem machen.
Eine Sprache für viele Domänen
Ein typisches Data Science-Projekt umfasst verschiedene Bereiche wie Datenextraktion, Datenmanipulation, Datenanalyse, Merkmalsextraktion, Modellierung, Bewertung, Bereitstellung und Aktualisierung der Lösung. Da Python eine Mehrzwecksprache ist, kann der Datenwissenschaftler alle diese Domänen von einer gemeinsamen Plattform aus ansprechen.
Komponenten des Python ML-Ökosystems
Lassen Sie uns in diesem Abschnitt einige Kernbibliotheken von Data Science diskutieren, die die Komponenten des Python-Ökosystems für maschinelles Lernen bilden. Diese nützlichen Komponenten machen Python zu einer wichtigen Sprache für Data Science. Obwohl es viele solcher Komponenten gibt, lassen Sie uns hier einige der wichtigsten Komponenten des Python-Ökosystems diskutieren -
Jupyter Notizbuch
Jupyter-Notebooks bieten grundsätzlich eine interaktive Computerumgebung für die Entwicklung von Python-basierten Data Science-Anwendungen. Sie sind früher als Ipython-Notizbücher bekannt. Im Folgenden sind einige der Funktionen von Jupyter-Notebooks aufgeführt, die es zu einer der besten Komponenten des Python ML-Ökosystems machen:
Jupyter-Notizbücher können den Analyseprozess Schritt für Schritt veranschaulichen, indem sie Dinge wie Code, Bilder, Text, Ausgabe usw. Schritt für Schritt anordnen.
Es hilft einem Datenwissenschaftler, den Denkprozess zu dokumentieren, während er den Analyseprozess entwickelt.
Man kann das Ergebnis auch als Teil des Notizbuchs erfassen.
Mit Hilfe von Jupyter-Notizbüchern können wir unsere Arbeit auch mit Kollegen teilen.
Installation und Ausführung
Wenn Sie die Anaconda-Distribution verwenden, müssen Sie das Jupyter-Notebook nicht separat installieren, da es bereits mit ihm installiert ist. Sie müssen nur zur Anaconda-Eingabeaufforderung gehen und den folgenden Befehl eingeben:
C:\>jupyter notebook
Nach dem Drücken der Eingabetaste wird ein Notebook-Server unter localhost: 8888 Ihres Computers gestartet. Es wird im folgenden Screenshot gezeigt -
Nachdem Sie auf die Registerkarte Neu geklickt haben, erhalten Sie eine Liste mit Optionen. Wählen Sie Python 3 und Sie gelangen zum neuen Notizbuch, in dem Sie arbeiten können. In den folgenden Screenshots erhalten Sie einen Einblick -
Wenn Sie dagegen die Standard-Python-Distribution verwenden, kann das Jupyter-Notebook mit dem beliebten Python-Paket-Installationsprogramm pip installiert werden.
pip install jupyter
Zelltypen in Jupyter Notebook
Im Folgenden sind die drei Zelltypen in einem Jupyter-Notizbuch aufgeführt:
Code cells- Wie der Name schon sagt, können wir diese Zellen zum Schreiben von Code verwenden. Nach dem Schreiben des Codes / Inhalts wird dieser an den Kernel gesendet, der dem Notizbuch zugeordnet ist.
Markdown cells- Wir können diese Zellen verwenden, um den Berechnungsprozess zu notieren. Sie können Dinge wie Text, Bilder, Latexgleichungen, HTML-Tags usw. enthalten.
Raw cells- Der darin geschriebene Text wird so angezeigt, wie er ist. Diese Zellen werden im Wesentlichen verwendet, um den Text hinzuzufügen, den wir nicht durch den automatischen Konvertierungsmechanismus des Jupyter-Notebooks konvertieren möchten.
Für eine detailliertere Untersuchung des Jupyter-Notebooks können Sie auf den Link gehenhttps://www.tutorialspoint.com/jupyter/index.htm.
NumPy
Es ist eine weitere nützliche Komponente, die Python zu einer der Lieblingssprachen für Data Science macht. Es steht im Wesentlichen für Numerical Python und besteht aus mehrdimensionalen Array-Objekten. Mit NumPy können wir die folgenden wichtigen Vorgänge ausführen:
Mathematische und logische Operationen an Arrays.
Fourier-Transformation
Operationen im Zusammenhang mit linearer Algebra.
Wir können NumPy auch als Ersatz für MatLab sehen, da NumPy hauptsächlich zusammen mit Scipy (Scientific Python) und Mat-plotlib (Plotbibliothek) verwendet wird.
Installation and Execution
Wenn Sie die Anaconda-Distribution verwenden, müssen Sie NumPy nicht separat installieren, da es bereits mit installiert ist. Sie müssen das Paket nur mit Hilfe der folgenden Schritte in Ihr Python-Skript importieren:
import numpy as np
Wenn Sie dagegen die Standard-Python-Distribution verwenden, kann NumPy mit dem beliebten Python-Paket-Installationsprogramm pip installiert werden.
pip install NumPy
Für eine detailliertere Untersuchung von NumPy können Sie auf den Link gehenhttps://www.tutorialspoint.com/numpy/index.htm.
Pandas
Es ist eine weitere nützliche Python-Bibliothek, die Python zu einer der Lieblingssprachen für Data Science macht. Pandas wird hauptsächlich zur Datenmanipulation, zum Wrangling und zur Analyse verwendet. Es wurde 2008 von Wes McKinney entwickelt. Mit Hilfe von Pandas können wir bei der Datenverarbeitung die folgenden fünf Schritte ausführen:
Load
Prepare
Manipulate
Model
Analyze
Datendarstellung in Pandas
Die gesamte Darstellung von Daten in Pandas erfolgt mithilfe der folgenden drei Datenstrukturen:
Series- Es handelt sich im Grunde genommen um ein eindimensionales ndarray mit einer Achsenbeschriftung, was bedeutet, dass es sich um ein einfaches Array mit homogenen Daten handelt. Die folgende Reihe ist beispielsweise eine Sammlung von ganzen Zahlen 1,5,10,15,24,25…
1 | 5 | 10 | 15 | 24 | 25 | 28 | 36 | 40 | 89 |
Data frame- Es ist die nützlichste Datenstruktur und wird für fast alle Arten der Darstellung und Manipulation von Daten in Pandas verwendet. Grundsätzlich handelt es sich um eine zweidimensionale Datenstruktur, die heterogene Daten enthalten kann. Im Allgemeinen werden tabellarische Daten mithilfe von Datenrahmen dargestellt. Die folgende Tabelle zeigt beispielsweise die Daten von Schülern mit Namen und Rollennummern, Alter und Geschlecht -
Name |
Rollennummer |
Alter |
Geschlecht |
---|---|---|---|
Aarav |
1 |
15 |
Männlich |
Harshit |
2 |
14 |
Männlich |
Kanika |
3 |
16 |
Weiblich |
Mayank |
4 |
15 |
Männlich |
Panel- Es handelt sich um eine dreidimensionale Datenstruktur, die heterogene Daten enthält. Es ist sehr schwierig, das Panel in grafischer Darstellung darzustellen, es kann jedoch als Container von DataFrame dargestellt werden.
Die folgende Tabelle gibt uns die Dimension und Beschreibung der oben genannten Datenstrukturen, die in Pandas verwendet werden -
Datenstruktur |
Abmessungen |
Beschreibung |
---|---|---|
Serie |
1-D |
Größe unveränderlich, 1-D homogene Daten |
DataFrames |
2-D |
Größe Veränderbare, heterogene Daten in Tabellenform |
Panel |
3-D |
Größenveränderbares Array, Container mit DataFrame. |
Wir können diese Datenstrukturen verstehen, da die höherdimensionale Datenstruktur der Container der niedrigdimensionalen Datenstruktur ist.
Installation und Ausführung
Wenn Sie die Anaconda-Distribution verwenden, müssen Sie Pandas nicht separat installieren, da es bereits installiert ist. Sie müssen das Paket nur mit Hilfe der folgenden Schritte in Ihr Python-Skript importieren:
import pandas as pd
Wenn Sie dagegen die Standard-Python-Distribution verwenden, können Pandas mit dem beliebten Python-Paket-Installationsprogramm pip installiert werden.
pip install Pandas
Nach der Installation von Pandas können Sie es wie oben beschrieben in Ihr Python-Skript importieren.
Beispiel
Das folgende Beispiel zeigt das Erstellen einer Serie aus ndarray mithilfe von Pandas:
In [1]: import pandas as pd
In [2]: import numpy as np
In [3]: data = np.array(['g','a','u','r','a','v'])
In [4]: s = pd.Series(data)
In [5]: print (s)
0 g
1 a
2 u
3 r
4 a
5 v
dtype: object
Für eine detailliertere Untersuchung von Pandas können Sie auf den Link gehen https://www.tutorialspoint.com/python_pandas/index.htm.
Scikit-lernen
Eine weitere nützliche und wichtigste Python-Bibliothek für Data Science und maschinelles Lernen in Python ist Scikit-learn. Das Folgende sind einige Funktionen von Scikit-learn, die es so nützlich machen -
Es basiert auf NumPy, SciPy und Matplotlib.
Es ist Open Source und kann unter BSD-Lizenz wiederverwendet werden.
Es ist für jedermann zugänglich und kann in verschiedenen Zusammenhängen wiederverwendet werden.
Mithilfe dieser Methode kann eine breite Palette von Algorithmen für maschinelles Lernen implementiert werden, die wichtige Bereiche der ML wie Klassifizierung, Clustering, Regression, Dimensionsreduzierung, Modellauswahl usw. abdecken.
Installation und Ausführung
Wenn Sie die Anaconda-Distribution verwenden, müssen Sie Scikit-learn nicht separat installieren, da es bereits mit installiert ist. Sie müssen das Paket nur in Ihrem Python-Skript verwenden. Mit der folgenden Skriptzeile importieren wir beispielsweise einen Datensatz von Brustkrebspatientinnen ausScikit-learn - -
from sklearn.datasets import load_breast_cancer
Wenn Sie dagegen die Standard-Python-Distribution verwenden und NumPy und SciPy verwenden, kann Scikit-learn mit dem beliebten Python-Paket-Installationsprogramm pip installiert werden.
pip install -U scikit-learn
Nach der Installation von Scikit-learn können Sie es wie oben beschrieben in Ihrem Python-Skript verwenden.
Es gibt verschiedene ML-Algorithmen, Techniken und Methoden, mit denen Modelle zur Lösung realer Probleme mithilfe von Daten erstellt werden können. In diesem Kapitel werden wir solche unterschiedlichen Arten von Methoden diskutieren.
Verschiedene Arten von Methoden
Das Folgende sind verschiedene ML-Methoden, die auf einigen breiten Kategorien basieren -
Basierend auf menschlicher Aufsicht
Im Lernprozess sind einige der Methoden, die auf menschlicher Aufsicht basieren, wie folgt:
Supervised Learning
Überwachte Lernalgorithmen oder -methoden sind die am häufigsten verwendeten ML-Algorithmen. Diese Methode oder dieser Lernalgorithmus entnimmt die Datenprobe, dh die Trainingsdaten und die zugehörige Ausgabe, dh Beschriftungen oder Antworten mit jeder Datenprobe während des Trainingsprozesses.
Das Hauptziel von überwachten Lernalgorithmen besteht darin, eine Assoziation zwischen Eingabedatenproben und entsprechenden Ausgaben zu lernen, nachdem mehrere Trainingsdateninstanzen durchgeführt wurden.
Zum Beispiel haben wir
x: Eingangsvariablen und
Y: Ausgabevariable
Wenden Sie nun einen Algorithmus an, um die Zuordnungsfunktion von der Eingabe zur Ausgabe wie folgt zu lernen:
Y = f (x)
Das Hauptziel wäre nun, die Abbildungsfunktion so gut zu approximieren, dass wir selbst bei neuen Eingabedaten (x) die Ausgabevariable (Y) für diese neuen Eingabedaten leicht vorhersagen können.
Es wird als überwacht bezeichnet, da der gesamte Lernprozess so gedacht werden kann, wie er von einem Lehrer oder Betreuer überwacht wird. Beispiele für überwachte Algorithmen für maschinelles Lernen umfassenDecision tree, Random Forest, KNN, Logistic Regression usw.
Basierend auf den ML-Aufgaben können überwachte Lernalgorithmen in die folgenden zwei großen Klassen unterteilt werden:
Classification
Regression
Classification
Das Hauptziel klassifizierungsbasierter Aufgaben besteht darin, kategoriale Ausgabebezeichnungen oder Antworten für die angegebenen Eingabedaten vorherzusagen. Die Ausgabe basiert auf dem, was das Modell in der Trainingsphase gelernt hat. Da wir wissen, dass die kategorialen Ausgabeantworten ungeordnete und diskrete Werte bedeuten, gehört jede Ausgabeantwort zu einer bestimmten Klasse oder Kategorie. Wir werden die Klassifizierung und die zugehörigen Algorithmen auch in den kommenden Kapiteln ausführlich erörtern.
Regression
Das Hauptziel von auf Regression basierenden Aufgaben besteht darin, Ausgabekennzeichnungen oder Antworten, die weiterhin numerische Werte sind, für die angegebenen Eingabedaten vorherzusagen. Die Ausgabe basiert auf dem, was das Modell in seiner Trainingsphase gelernt hat. Grundsätzlich verwenden Regressionsmodelle die Eingabedatenmerkmale (unabhängige Variablen) und ihre entsprechenden kontinuierlichen numerischen Ausgabewerte (abhängige oder Ergebnisvariablen), um die spezifische Assoziation zwischen Eingaben und entsprechenden Ausgaben zu lernen. Wir werden die Regression und die damit verbundenen Algorithmen auch in weiteren Kapiteln ausführlich erörtern.
Unbeaufsichtigtes Lernen
Wie der Name schon sagt, ist es im Gegensatz zu überwachten ML-Methoden oder -Algorithmen, was bedeutet, dass wir bei unbeaufsichtigten Algorithmen für maschinelles Lernen keinen Supervisor haben, der irgendeine Art von Anleitung bietet. Unüberwachte Lernalgorithmen sind praktisch in dem Szenario, in dem wir nicht wie bei überwachten Lernalgorithmen die Freiheit haben, vorbeschriftete Trainingsdaten zu haben, und nützliche Muster aus Eingabedaten extrahieren möchten.
Zum Beispiel kann es wie folgt verstanden werden:
Angenommen, wir haben -
x: Input variablesDann würde es keine entsprechende Ausgabevariable geben und die Algorithmen müssen das interessante Muster in den Lerndaten ermitteln.
Beispiele für unbeaufsichtigte Algorithmen für maschinelles Lernen umfassen K-Mittel-Clustering, K-nearest neighbors usw.
Basierend auf den ML-Aufgaben können unbeaufsichtigte Lernalgorithmen in folgende breite Klassen unterteilt werden:
Clustering
Association
Reduzierung der Dimensionalität
Clustering
Clustering-Methoden sind eine der nützlichsten unbeaufsichtigten ML-Methoden. Diese Algorithmen werden verwendet, um Ähnlichkeits- und Beziehungsmuster zwischen Datenproben zu finden und diese Proben dann in Gruppen mit Ähnlichkeit basierend auf Merkmalen zu gruppieren. Das reale Beispiel für Clustering besteht darin, die Kunden nach ihrem Kaufverhalten zu gruppieren.
Association
Eine andere nützliche unbeaufsichtigte ML-Methode ist AssociationHiermit wird ein großer Datensatz analysiert, um Muster zu finden, die die interessanten Beziehungen zwischen verschiedenen Elementen darstellen. Es wird auch als bezeichnetAssociation Rule Mining oder Market basket analysis Dies wird hauptsächlich zur Analyse von Kundeneinkaufsmustern verwendet.
Dimensionality Reduction
Diese unbeaufsichtigte ML-Methode wird verwendet, um die Anzahl der Merkmalsvariablen für jede Datenprobe durch Auswahl eines Satzes von Hauptmerkmalen oder repräsentativen Merkmalen zu reduzieren. Hier stellt sich die Frage, warum wir die Dimensionalität reduzieren müssen. Der Grund dafür ist das Problem der Komplexität des Merkmalsraums, das auftritt, wenn wir mit der Analyse und Extraktion von Millionen von Merkmalen aus Datenproben beginnen. Dieses Problem bezieht sich allgemein auf "Fluch der Dimensionalität". PCA (Principal Component Analysis), K-nächste Nachbarn und Diskriminanzanalyse sind einige der gängigen Algorithmen für diesen Zweck.
Anomaly Detection
Diese unbeaufsichtigte ML-Methode wird verwendet, um das Auftreten seltener Ereignisse oder Beobachtungen herauszufinden, die im Allgemeinen nicht auftreten. Durch die Verwendung des erlernten Wissens könnten Anomalieerkennungsmethoden zwischen anomalen oder normalen Datenpunkten unterscheiden. Einige der unbeaufsichtigten Algorithmen wie Clustering, KNN können Anomalien basierend auf den Daten und ihren Merkmalen erkennen.
Halbüberwachtes Lernen
Solche Algorithmen oder Methoden werden weder vollständig überwacht noch vollständig unbeaufsichtigt. Sie liegen grundsätzlich zwischen den beiden überwachten und unbeaufsichtigten Lernmethoden. Diese Arten von Algorithmen verwenden im Allgemeinen eine kleine überwachte Lernkomponente, dh eine kleine Menge vorbeschrifteter kommentierter Daten, und eine große unbeaufsichtigte Lernkomponente, dh viele unbeschriftete Daten für das Training. Wir können einen der folgenden Ansätze zur Implementierung von halbüberwachten Lernmethoden verfolgen:
Der erste und einfache Ansatz besteht darin, das überwachte Modell basierend auf einer kleinen Menge beschrifteter und kommentierter Daten zu erstellen und dann das unbeaufsichtigte Modell zu erstellen, indem dasselbe auf die großen Mengen unbeschrifteter Daten angewendet wird, um mehr beschriftete Proben zu erhalten. Trainieren Sie nun das Modell darauf und wiederholen Sie den Vorgang.
- , p> Der zweite Ansatz erfordert einige zusätzliche Anstrengungen. Bei diesem Ansatz können wir zuerst die unbeaufsichtigten Methoden verwenden, um ähnliche Datenproben zu gruppieren, diese Gruppen mit Anmerkungen zu versehen und dann eine Kombination dieser Informationen zum Trainieren des Modells zu verwenden.
Verstärkungslernen
Diese Methoden unterscheiden sich von zuvor untersuchten Methoden und werden auch sehr selten angewendet. Bei dieser Art von Lernalgorithmen gibt es einen Agenten, den wir über einen bestimmten Zeitraum trainieren möchten, damit er mit einer bestimmten Umgebung interagieren kann. Der Agent folgt einer Reihe von Strategien für die Interaktion mit der Umgebung und ergreift nach Beobachtung der Umgebung Maßnahmen in Bezug auf den aktuellen Zustand der Umgebung. Das Folgende sind die Hauptschritte der Lernmethoden zur Verstärkung:
Step1 - Zuerst müssen wir einen Agenten mit ersten Strategien vorbereiten.
Step2 - Beobachten Sie dann die Umgebung und ihren aktuellen Zustand.
Step3 - Wählen Sie als Nächstes die optimale Richtlinie für den aktuellen Status der Umgebung aus und führen Sie wichtige Maßnahmen aus.
Step4 - Jetzt kann der Agent eine entsprechende Belohnung oder Strafe erhalten, die der Aktion entspricht, die er im vorherigen Schritt ausgeführt hat.
Step5 - Jetzt können wir die Strategien aktualisieren, wenn dies erforderlich ist.
Step6 - Wiederholen Sie zuletzt die Schritte 2 bis 5, bis der Agent die optimalen Richtlinien gelernt und übernommen hat.
Aufgaben für maschinelles Lernen
Das folgende Diagramm zeigt, welche Art von Aufgabe für verschiedene ML-Probleme geeignet ist -
Basierend auf Lernfähigkeit
Im Lernprozess sind im Folgenden einige Methoden aufgeführt, die auf der Lernfähigkeit basieren:
Batch Learning
In vielen Fällen verfügen wir über End-to-End-Systeme für maschinelles Lernen, in denen wir das Modell auf einmal unter Verwendung der gesamten verfügbaren Trainingsdaten trainieren müssen. Eine solche Art von Lernmethode oder Algorithmus wird genanntBatch or Offline learning. Es wird als Batch- oder Offline-Lernen bezeichnet, da es sich um eine einmalige Prozedur handelt und das Modell mit Daten in einem einzigen Batch trainiert wird. Im Folgenden sind die Hauptschritte der Batch-Lernmethoden aufgeführt:
Step1 - Zuerst müssen wir alle Trainingsdaten sammeln, um mit dem Training des Modells zu beginnen.
Step2 - Beginnen Sie jetzt mit dem Training des Modells, indem Sie ganze Trainingsdaten auf einmal bereitstellen.
Step3 - Beenden Sie als Nächstes den Lern- / Trainingsprozess, sobald Sie zufriedenstellende Ergebnisse / Leistungen erzielt haben.
Step4- Stellen Sie dieses geschulte Modell schließlich in der Produktion bereit. Hier wird die Ausgabe für eine neue Datenprobe vorhergesagt.
Online lernen
Es ist völlig entgegengesetzt zu den Batch- oder Offline-Lernmethoden. Bei diesen Lernmethoden werden die Trainingsdaten in mehreren inkrementellen Stapeln, die als Mini-Stapel bezeichnet werden, an den Algorithmus geliefert. Das Folgende sind die Hauptschritte der Online-Lernmethoden -
Step1 - Zuerst müssen wir alle Trainingsdaten sammeln, um mit dem Training des Modells zu beginnen.
Step2 - Beginnen Sie nun mit dem Training des Modells, indem Sie dem Algorithmus einen kleinen Stapel von Trainingsdaten bereitstellen.
Step3 - Als nächstes müssen wir dem Algorithmus die Mini-Stapel von Trainingsdaten in mehreren Schritten zur Verfügung stellen.
Step4 - Da es nicht wie das Batch-Lernen aufhört, nachdem Sie die gesamten Trainingsdaten in Mini-Batches bereitgestellt haben, stellen Sie auch neue Datenmuster bereit.
Step5 - Schließlich wird es über einen bestimmten Zeitraum basierend auf den neuen Datenstichproben weiter lernen.
Basierend auf dem Generalisierungsansatz
Im Lernprozess folgen einige Methoden, die auf Generalisierungsansätzen basieren -
Instanzbasiertes Lernen
Die instanzbasierte Lernmethode ist eine der nützlichen Methoden, mit denen die ML-Modelle durch Verallgemeinerung auf der Grundlage der Eingabedaten erstellt werden. Es ist im Gegensatz zu den zuvor untersuchten Lernmethoden dahingehend, dass diese Art des Lernens ML-Systeme sowie Methoden umfasst, die die Rohdatenpunkte selbst verwenden, um die Ergebnisse für neuere Datenstichproben zu zeichnen, ohne ein explizites Modell auf Trainingsdaten aufzubauen.
Mit einfachen Worten, instanzbasiertes Lernen beginnt im Wesentlichen damit, die Eingabedatenpunkte zu betrachten und dann mithilfe einer Ähnlichkeitsmetrik die neuen Datenpunkte zu verallgemeinern und vorherzusagen.
Modellbasiertes Lernen
Bei modellbasierten Lernmethoden findet ein iterativer Prozess für die ML-Modelle statt, die auf verschiedenen Modellparametern basieren, die als Hyperparameter bezeichnet werden und in denen Eingabedaten zum Extrahieren der Merkmale verwendet werden. Bei diesem Lernen werden Hyperparameter basierend auf verschiedenen Modellvalidierungstechniken optimiert. Aus diesem Grund können wir sagen, dass modellbasierte Lernmethoden einen traditionelleren ML-Ansatz zur Verallgemeinerung verwenden.
Angenommen, wenn Sie ein ML-Projekt starten möchten, was ist dann das erste und wichtigste, was Sie benötigen würden? Es sind die Daten, die wir laden müssen, um eines der ML-Projekte zu starten. In Bezug auf Daten ist das häufigste Datenformat für ML-Projekte CSV (durch Kommas getrennte Werte).
Grundsätzlich ist CSV ein einfaches Dateiformat, mit dem tabellarische Daten (Nummer und Text) wie eine Tabelle im Klartext gespeichert werden. In Python können wir CSV-Daten auf verschiedene Arten laden, aber bevor wir CSV-Daten laden, müssen wir einige Überlegungen berücksichtigen.
Berücksichtigung beim Laden von CSV-Daten
Das CSV-Datenformat ist das am häufigsten verwendete Format für ML-Daten. Wir müssen jedoch darauf achten, wichtige Überlegungen zu beachten, während wir diese in unsere ML-Projekte laden.
Dateikopf
In CSV-Datendateien enthält der Header die Informationen für jedes Feld. Wir müssen dasselbe Trennzeichen für die Header-Datei und für die Datendatei verwenden, da die Header-Datei angibt, wie Datenfelder interpretiert werden sollen.
Im Folgenden sind die beiden Fälle im Zusammenhang mit dem CSV-Dateikopf aufgeführt, die berücksichtigt werden müssen:
Case-I: When Data file is having a file header - Es werden automatisch die Namen jeder Datenspalte zugewiesen, wenn die Datendatei einen Dateikopf hat.
Case-II: When Data file is not having a file header - Wir müssen die Namen jeder Datenspalte manuell zuweisen, wenn die Datendatei keinen Dateikopf hat.
In beiden Fällen müssen wir explizit angeben, ob unsere CSV-Datei einen Header enthält oder nicht.
Bemerkungen
Kommentare in Datendateien haben ihre Bedeutung. In der CSV-Datendatei werden Kommentare durch einen Hash (#) am Zeilenanfang angezeigt. Beim Laden von CSV-Daten in ML-Projekte müssen Kommentare berücksichtigt werden. Wenn wir Kommentare in der Datei haben, müssen wir möglicherweise angeben, ob diese Kommentare zu erwarten sind oder nicht.
Trennzeichen
In CSV-Datendateien ist das Komma (,) das Standardtrennzeichen. Die Rolle des Trennzeichens besteht darin, die Werte in den Feldern zu trennen. Es ist wichtig, die Rolle des Trennzeichens beim Hochladen der CSV-Datei in ML-Projekte zu berücksichtigen, da wir auch ein anderes Trennzeichen verwenden können, z. B. eine Registerkarte oder einen Leerraum. Wenn Sie jedoch ein anderes Trennzeichen als das Standardtrennzeichen verwenden, müssen Sie es explizit angeben.
Zitate
In CSV-Datendateien ist das doppelte Anführungszeichen ("") das Standard-Anführungszeichen. Es ist wichtig, die Rolle von Anführungszeichen beim Hochladen der CSV-Datei in ML-Projekte zu berücksichtigen, da wir auch andere Anführungszeichen als doppelte Anführungszeichen verwenden können. Wenn Sie jedoch ein anderes Anführungszeichen als das Standardzeichen verwenden, müssen Sie es explizit angeben.
Methoden zum Laden der CSV-Datendatei
Bei der Arbeit mit ML-Projekten besteht die wichtigste Aufgabe darin, die Daten ordnungsgemäß zu laden. Das gebräuchlichste Datenformat für ML-Projekte ist CSV. Es gibt verschiedene Varianten und unterschiedliche Schwierigkeiten beim Parsen. In diesem Abschnitt werden drei gängige Ansätze in Python zum Laden von CSV-Datendateien erläutert:
Laden Sie CSV mit der Python Standard Library
Der erste und am häufigsten verwendete Ansatz zum Laden von CSV-Datendateien ist die Verwendung der Python-Standardbibliothek, die uns eine Vielzahl integrierter Module bietet, nämlich das CSV-Modul und die reader () -Funktion. Das folgende Beispiel zeigt das Laden einer CSV-Datendatei mithilfe dieser Datei:
Beispiel
In diesem Beispiel verwenden wir den Irisblumendatensatz, der in unser lokales Verzeichnis heruntergeladen werden kann. Nach dem Laden der Datendatei können wir sie in ein NumPy-Array konvertieren und für ML-Projekte verwenden. Es folgt das Python-Skript zum Laden der CSV-Datendatei:
Zuerst müssen wir das von der Python-Standardbibliothek bereitgestellte CSV-Modul wie folgt importieren:
import csv
Als nächstes müssen wir das Numpy-Modul importieren, um die geladenen Daten in ein NumPy-Array zu konvertieren.
import numpy as np
Geben Sie nun den vollständigen Pfad der Datei an, die in unserem lokalen Verzeichnis gespeichert ist und die CSV-Datendatei enthält.
path = r"c:\iris.csv"
Verwenden Sie als Nächstes die Funktion csv.reader (), um Daten aus der CSV-Datei zu lesen.
with open(path,'r') as f:
reader = csv.reader(f,delimiter = ',')
headers = next(reader)
data = list(reader)
data = np.array(data).astype(float)
Wir können die Namen der Header mit der folgenden Skriptzeile drucken -
print(headers)
In der folgenden Skriptzeile wird die Form der Daten gedruckt, dh die Anzahl der Zeilen und Spalten in der Datei.
print(data.shape)
Die nächste Skriptzeile enthält die ersten drei Zeilen der Datendatei -
print(data[:3])
Output
['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
(150, 4)
[ [5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]
[4.7 3.2 1.3 0.2]]
Laden Sie CSV mit NumPy
Ein weiterer Ansatz zum Laden der CSV-Datendatei ist die Funktion NumPy und numpy.loadtxt (). Das folgende Beispiel zeigt das Laden einer CSV-Datendatei mithilfe dieser Datei:
Beispiel
In diesem Beispiel verwenden wir den Pima-Indianer-Datensatz mit den Daten von Diabetikern. Dieser Datensatz ist ein numerischer Datensatz ohne Kopfzeile. Es kann auch in unser lokales Verzeichnis heruntergeladen werden. Nach dem Laden der Datendatei können wir sie in ein NumPy-Array konvertieren und für ML-Projekte verwenden. Das folgende ist das Python-Skript zum Laden der CSV-Datendatei -
from numpy import loadtxt
path = r"C:\pima-indians-diabetes.csv"
datapath= open(path, 'r')
data = loadtxt(datapath, delimiter=",")
print(data.shape)
print(data[:3])
Ausgabe
(768, 9)
[ [ 6. 148. 72. 35. 0. 33.6 0.627 50. 1.]
[ 1. 85. 66. 29. 0. 26.6 0.351 31. 0.]
[ 8. 183. 64. 0. 0. 23.3 0.672 32. 1.]]
Laden Sie CSV mit Pandas
Ein anderer Ansatz zum Laden der CSV-Datendatei ist die Funktion Pandas und pandas.read_csv (). Dies ist die sehr flexible Funktion, die einen pandas.DataFrame zurückgibt, der sofort zum Plotten verwendet werden kann. Das folgende Beispiel zeigt das Laden einer CSV-Datendatei mithilfe dieser Datei:
Beispiel
Hier werden wir zwei Python-Skripte implementieren, zum einen mit einem Iris-Datensatz mit Headern und zum anderen mit dem Pima Indians-Datensatz, einem numerischen Datensatz ohne Header. Beide Datensätze können in das lokale Verzeichnis heruntergeladen werden.
Script-1
Das folgende Python-Skript zum Laden der CSV-Datendatei mit Pandas on Iris-Datensatz:
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
print(data[:3])
Output:
(150, 4)
sepal_length sepal_width petal_length petal_width
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
Script-2
Das folgende Python-Skript zum Laden der CSV-Datendatei sowie zum Bereitstellen der Headernamen mithilfe von Pandas im Pima Indians Diabetes-Datensatz:
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.shape)
print(data[:3])
Output
(768, 9)
preg plas pres skin test mass pedi age class
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
Der Unterschied zwischen den oben verwendeten drei Ansätzen zum Laden der CSV-Datendatei kann anhand der angegebenen Beispiele leicht verstanden werden.
Einführung
Bei der Arbeit mit maschinellen Lernprojekten ignorieren wir normalerweise zwei wichtige Teile, die aufgerufen werden mathematics und data. Wir wissen, dass ML ein datengetriebener Ansatz ist und unser ML-Modell nur so gute oder so schlechte Ergebnisse liefert wie die Daten, die wir ihm zur Verfügung gestellt haben.
Im vorherigen Kapitel haben wir erläutert, wie wir CSV-Daten in unser ML-Projekt hochladen können. Es ist jedoch hilfreich, die Daten vor dem Hochladen zu verstehen. Wir können die Daten auf zwei Arten verstehen, mit Statistiken und mit Visualisierung.
In diesem Kapitel werden wir anhand der folgenden Python-Rezepte ML-Daten mit Statistiken verstehen.
Rohdaten betrachten
Das allererste Rezept ist das Betrachten Ihrer Rohdaten. Es ist wichtig, Rohdaten zu betrachten, da die Erkenntnisse, die wir nach der Betrachtung von Rohdaten erhalten, unsere Chancen auf eine bessere Vorverarbeitung sowie den Umgang mit Daten für ML-Projekte erhöhen.
Im Folgenden finden Sie ein Python-Skript, das mithilfe der head () - Funktion von Pandas DataFrame im Diabetes-Datensatz von Pima Indians implementiert wurde, um die ersten 50 Zeilen zu betrachten und ein besseres Verständnis zu erhalten.
Beispiel
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.head(50))
Ausgabe
preg plas pres skin test mass pedi age class
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1
5 5 116 74 0 0 25.6 0.201 30 0
6 3 78 50 32 88 31.0 0.248 26 1
7 10 115 0 0 0 35.3 0.134 29 0
8 2 197 70 45 543 30.5 0.158 53 1
9 8 125 96 0 0 0.0 0.232 54 1
10 4 110 92 0 0 37.6 0.191 30 0
11 10 168 74 0 0 38.0 0.537 34 1
12 10 139 80 0 0 27.1 1.441 57 0
13 1 189 60 23 846 30.1 0.398 59 1
14 5 166 72 19 175 25.8 0.587 51 1
15 7 100 0 0 0 30.0 0.484 32 1
16 0 118 84 47 230 45.8 0.551 31 1
17 7 107 74 0 0 29.6 0.254 31 1
18 1 103 30 38 83 43.3 0.183 33 0
19 1 115 70 30 96 34.6 0.529 32 1
20 3 126 88 41 235 39.3 0.704 27 0
21 8 99 84 0 0 35.4 0.388 50 0
22 7 196 90 0 0 39.8 0.451 41 1
23 9 119 80 35 0 29.0 0.263 29 1
24 11 143 94 33 146 36.6 0.254 51 1
25 10 125 70 26 115 31.1 0.205 41 1
26 7 147 76 0 0 39.4 0.257 43 1
27 1 97 66 15 140 23.2 0.487 22 0
28 13 145 82 19 110 22.2 0.245 57 0
29 5 117 92 0 0 34.1 0.337 38 0
30 5 109 75 26 0 36.0 0.546 60 0
31 3 158 76 36 245 31.6 0.851 28 1
32 3 88 58 11 54 24.8 0.267 22 0
33 6 92 92 0 0 19.9 0.188 28 0
34 10 122 78 31 0 27.6 0.512 45 0
35 4 103 60 33 192 24.0 0.966 33 0
36 11 138 76 0 0 33.2 0.420 35 0
37 9 102 76 37 0 32.9 0.665 46 1
38 2 90 68 42 0 38.2 0.503 27 1
39 4 111 72 47 207 37.1 1.390 56 1
40 3 180 64 25 70 34.0 0.271 26 0
41 7 133 84 0 0 40.2 0.696 37 0
42 7 106 92 18 0 22.7 0.235 48 0
43 9 171 110 24 240 45.4 0.721 54 1
44 7 159 64 0 0 27.4 0.294 40 0
45 0 180 66 39 0 42.0 1.893 25 1
46 1 146 56 0 0 29.7 0.564 29 0
47 2 71 70 27 0 28.0 0.586 22 0
48 7 103 66 32 0 39.1 0.344 31 1
49 7 105 0 0 0 0.0 0.305 24 0
Wir können anhand der obigen Ausgabe beobachten, dass die erste Spalte die Zeilennummer angibt, die für die Referenzierung einer bestimmten Beobachtung sehr nützlich sein kann.
Überprüfen der Datenabmessungen
Es ist immer eine gute Praxis zu wissen, wie viele Daten in Bezug auf Zeilen und Spalten wir für unser ML-Projekt haben. Die Gründe dafür sind -
Angenommen, wenn wir zu viele Zeilen und Spalten haben, würde es lange dauern, den Algorithmus auszuführen und das Modell zu trainieren.
Angenommen, wir haben zu wenig Zeilen und Spalten, dann hätten wir nicht genügend Daten, um das Modell gut zu trainieren.
Im Folgenden finden Sie ein Python-Skript, das durch Drucken der Shape-Eigenschaft in Pandas Data Frame implementiert wird. Wir werden es in einem Iris-Datensatz implementieren, um die Gesamtzahl der darin enthaltenen Zeilen und Spalten zu erhalten.
Beispiel
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
Ausgabe
(150, 4)
An der Ausgabe können wir leicht erkennen, dass der Iris-Datensatz, den wir verwenden werden, 150 Zeilen und 4 Spalten enthält.
Abrufen des Datentyps jedes Attributs
Es ist eine weitere gute Praxis, den Datentyp jedes Attributs zu kennen. Der Grund dafür ist, dass wir je nach Anforderung manchmal einen Datentyp in einen anderen konvertieren müssen. Beispielsweise müssen wir möglicherweise Zeichenfolgen in Gleitkomma- oder Int-Werte konvertieren, um kategoriale oder ordinale Werte darzustellen. Wir können uns anhand der Rohdaten eine Vorstellung vom Datentyp des Attributs machen. Eine andere Möglichkeit besteht darin, die Eigenschaft dtypes von Pandas DataFrame zu verwenden. Mit Hilfe der Eigenschaft dtypes können wir jeden Attributdatentyp kategorisieren. Es kann mit Hilfe des folgenden Python-Skripts verstanden werden -
Beispiel
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.dtypes)
Ausgabe
sepal_length float64
sepal_width float64
petal_length float64
petal_width float64
dtype: object
Aus der obigen Ausgabe können wir leicht die Datentypen jedes Attributs erhalten.
Statistische Zusammenfassung der Daten
Wir haben das Python-Rezept besprochen, um die Form, dh die Anzahl der Zeilen und Spalten, der Daten zu erhalten, aber oft müssen wir die Zusammenfassungen dieser Datenform überprüfen. Dies kann mit Hilfe der Funktion description () von Pandas DataFrame erfolgen, die außerdem die folgenden 8 statistischen Eigenschaften jedes Datenattributs bereitstellt:
Count
Mean
Standardabweichung
Mindestwert
Höchster Wert
25%
Median dh 50%
75%
Beispiel
from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
print(data.shape)
print(data.describe())
Ausgabe
(768, 9)
preg plas pres skin test mass pedi age class
count 768.00 768.00 768.00 768.00 768.00 768.00 768.00 768.00 768.00
mean 3.85 120.89 69.11 20.54 79.80 31.99 0.47 33.24 0.35
std 3.37 31.97 19.36 15.95 115.24 7.88 0.33 11.76 0.48
min 0.00 0.00 0.00 0.00 0.00 0.00 0.08 21.00 0.00
25% 1.00 99.00 62.00 0.00 0.00 27.30 0.24 24.00 0.00
50% 3.00 117.00 72.00 23.00 30.50 32.00 0.37 29.00 0.00
75% 6.00 140.25 80.00 32.00 127.25 36.60 0.63 41.00 1.00
max 17.00 199.00 122.00 99.00 846.00 67.10 2.42 81.00 1.00
Aus der obigen Ausgabe können wir die statistische Zusammenfassung der Daten des Pima Indian Diabetes-Datensatzes zusammen mit der Form der Daten beobachten.
Überprüfen der Klassenverteilung
Klassenverteilungsstatistiken sind nützlich bei Klassifizierungsproblemen, bei denen wir das Gleichgewicht der Klassenwerte kennen müssen. Es ist wichtig, die Klassenwertverteilung zu kennen, denn wenn wir eine stark unausgewogene Klassenverteilung haben, dh eine Klasse hat viel mehr Beobachtungen als die andere Klasse, muss sie möglicherweise in der Datenaufbereitungsphase unseres ML-Projekts speziell behandelt werden. Mit Hilfe von Pandas DataFrame können wir problemlos eine Klassenverteilung in Python erhalten.
Beispiel
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
count_class = data.groupby('class').size()
print(count_class)
Ausgabe
Class
0 500
1 268
dtype: int64
Aus der obigen Ausgabe ist klar ersichtlich, dass die Anzahl der Beobachtungen mit Klasse 0 fast doppelt so hoch ist wie die Anzahl der Beobachtungen mit Klasse 1.
Überprüfen der Korrelation zwischen Attributen
Die Beziehung zwischen zwei Variablen wird als Korrelation bezeichnet. In der Statistik ist der Pearson-Korrelationskoeffizient die häufigste Methode zur Berechnung der Korrelation. Es kann drei Werte haben:
Coefficient value = 1 - Es repräsentiert voll positive Korrelation zwischen Variablen.
Coefficient value = -1 - Es repräsentiert voll negative Korrelation zwischen Variablen.
Coefficient value = 0 - Es repräsentiert no Korrelation überhaupt zwischen Variablen.
Es ist immer gut für uns, die paarweisen Korrelationen der Attribute in unserem Datensatz zu überprüfen, bevor wir sie in das ML-Projekt verwenden, da einige Algorithmen für maschinelles Lernen wie lineare Regression und logistische Regression schlecht funktionieren, wenn wir stark korrelierte Attribute haben. In Python können wir mithilfe der Funktion corr () in Pandas DataFrame auf einfache Weise eine Korrelationsmatrix von Datensatzattributen berechnen.
Beispiel
from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
correlations = data.corr(method='pearson')
print(correlations)
Ausgabe
preg plas pres skin test mass pedi age class
preg 1.00 0.13 0.14 -0.08 -0.07 0.02 -0.03 0.54 0.22
plas 0.13 1.00 0.15 0.06 0.33 0.22 0.14 0.26 0.47
pres 0.14 0.15 1.00 0.21 0.09 0.28 0.04 0.24 0.07
skin -0.08 0.06 0.21 1.00 0.44 0.39 0.18 -0.11 0.07
test -0.07 0.33 0.09 0.44 1.00 0.20 0.19 -0.04 0.13
mass 0.02 0.22 0.28 0.39 0.20 1.00 0.14 0.04 0.29
pedi -0.03 0.14 0.04 0.18 0.19 0.14 1.00 0.03 0.17
age 0.54 0.26 0.24 -0.11 -0.04 0.04 0.03 1.00 0.24
class 0.22 0.47 0.07 0.07 0.13 0.29 0.17 0.24 1.00
Die Matrix in der obigen Ausgabe gibt die Korrelation zwischen allen Paaren des Attributs im Datensatz an.
Überprüfen des Versatzes der Attributverteilung
Die Schiefe kann als die Verteilung definiert werden, von der angenommen wird, dass sie Gaußsch ist, die jedoch verzerrt oder in die eine oder andere Richtung oder entweder nach links oder rechts verschoben erscheint. Das Überprüfen der Schiefe von Attributen ist aus folgenden Gründen eine der wichtigsten Aufgaben:
Das Vorhandensein von Schiefe in Daten erfordert die Korrektur in der Datenaufbereitungsphase, damit wir mehr Genauigkeit aus unserem Modell ziehen können.
Die meisten ML-Algorithmen gehen davon aus, dass Daten eine Gaußsche Verteilung haben, dh entweder eine Normalen der Glockenkurvendaten.
In Python können wir den Versatz jedes Attributs mithilfe der Funktion skew () in Pandas DataFrame einfach berechnen.
Beispiel
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
print(data.skew())
Ausgabe
preg 0.90
plas 0.17
pres -1.84
skin 0.11
test 2.27
mass -0.43
pedi 1.92
age 1.13
class 0.64
dtype: float64
Aus der obigen Ausgabe kann ein positiver oder negativer Versatz beobachtet werden. Wenn der Wert näher an Null liegt, zeigt er weniger Versatz.
Einführung
Im vorherigen Kapitel haben wir die Bedeutung von Daten für Algorithmen des maschinellen Lernens zusammen mit einigen Python-Rezepten erörtert, um die Daten mit Statistiken zu verstehen. Es gibt eine andere Möglichkeit namens Visualisierung, um die Daten zu verstehen.
Mithilfe der Datenvisualisierung können wir sehen, wie die Daten aussehen und welche Art von Korrelation die Datenattribute aufweisen. Dies ist der schnellste Weg, um festzustellen, ob die Funktionen der Ausgabe entsprechen. Mithilfe der folgenden Python-Rezepte können wir ML-Daten mit Statistiken verstehen.
Univariate Diagramme: Attribute unabhängig verstehen
Die einfachste Art der Visualisierung ist die Einzelvariablen- oder „univariate“ Visualisierung. Mithilfe der univariaten Visualisierung können wir jedes Attribut unseres Datensatzes unabhängig verstehen. Im Folgenden sind einige Techniken in Python aufgeführt, um eine univariate Visualisierung zu implementieren:
Histogramme
Histogramme gruppieren die Daten in Bins und sind der schnellste Weg, um sich ein Bild über die Verteilung der einzelnen Attribute im Datensatz zu machen. Im Folgenden sind einige der Merkmale von Histogrammen aufgeführt:
Es gibt uns eine Zählung der Anzahl von Beobachtungen in jedem zur Visualisierung erstellten Bin.
Anhand der Form des Behälters können wir leicht die Verteilung beobachten, dh das Wetter ist Gauß, schief oder exponentiell.
Histogramme helfen uns auch, mögliche Ausreißer zu erkennen.
Beispiel
Der unten gezeigte Code ist ein Beispiel für ein Python-Skript, das das Histogramm der Attribute des Pima Indian Diabetes-Datensatzes erstellt. Hier verwenden wir die Funktion hist () für Pandas DataFrame, um Histogramme und zu generierenmatplotlib für sie zu plotten.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.hist()
pyplot.show()
Ausgabe
Die obige Ausgabe zeigt, dass das Histogramm für jedes Attribut im Dataset erstellt wurde. Daraus können wir beobachten, dass Alter, Pedi und Testattribut möglicherweise eine exponentielle Verteilung haben, während Masse und Plas eine Gaußsche Verteilung haben.
Dichtediagramme
Eine weitere schnelle und einfache Methode zum Abrufen der Verteilung der einzelnen Attribute sind Dichtediagramme. Es ist auch wie ein Histogramm, hat jedoch eine glatte Kurve, die durch die Oberseite jedes Fachs gezogen wird. Wir können sie als abstrahierte Histogramme bezeichnen.
Beispiel
Im folgenden Beispiel generiert das Python-Skript Dichtediagramme für die Verteilung der Attribute des Pima Indian Diabetes-Datensatzes.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.show()
Ausgabe
Aus der obigen Ausgabe kann der Unterschied zwischen Dichtediagrammen und Histogrammen leicht verstanden werden.
Box- und Whisker-Plots
Box- und Whisker-Diagramme, kurz Boxplots genannt, sind eine weitere nützliche Technik, um die Verteilung der Verteilung der einzelnen Attribute zu überprüfen. Das Folgende sind die Eigenschaften dieser Technik -
Es ist univariater Natur und fasst die Verteilung jedes Attributs zusammen.
Es wird eine Linie für den Mittelwert gezogen, dh für den Median.
Es zeichnet eine Box um die 25% und 75%.
Es werden auch Whisker gezeichnet, die uns eine Vorstellung von der Verbreitung der Daten geben.
Die Punkte außerhalb der Whisker kennzeichnen die Ausreißerwerte. Ausreißerwerte wären 1,5-mal größer als die Größe der Streuung der mittleren Daten.
Beispiel
Im folgenden Beispiel generiert das Python-Skript Dichtediagramme für die Verteilung der Attribute des Pima Indian Diabetes-Datensatzes.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='box', subplots=True, layout=(3,3), sharex=False,sharey=False)
pyplot.show()
Ausgabe
Aus dem obigen Diagramm der Attributverteilung ist ersichtlich, dass Alter, Test und Haut in Richtung kleinerer Werte verzerrt erscheinen.
Multivariate Diagramme: Interaktion zwischen mehreren Variablen
Eine andere Art der Visualisierung ist die multivariable oder „multivariate“ Visualisierung. Mithilfe der multivariaten Visualisierung können wir die Interaktion zwischen mehreren Attributen unseres Datensatzes verstehen. Im Folgenden finden Sie einige Techniken in Python zur Implementierung einer multivariaten Visualisierung:
Korrelationsmatrix-Diagramm
Die Korrelation ist ein Hinweis auf die Änderungen zwischen zwei Variablen. In unseren vorherigen Kapiteln haben wir die Pearson-Korrelationskoeffizienten und die Bedeutung der Korrelation ebenfalls erörtert. Wir können eine Korrelationsmatrix zeichnen, um zu zeigen, welche Variable eine hohe oder niedrige Korrelation in Bezug auf eine andere Variable aufweist.
Beispiel
Im folgenden Beispiel generiert und zeichnet das Python-Skript eine Korrelationsmatrix für den Pima Indian Diabetes-Datensatz. Es kann mit Hilfe der Funktion corr () in Pandas DataFrame generiert und mit Hilfe von pyplot geplottet werden.
from matplotlib import pyplot
from pandas import read_csv
import numpy
Path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(Path, names=names)
correlations = data.corr()
fig = pyplot.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = numpy.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
pyplot.show()
Ausgabe
Aus der obigen Ausgabe der Korrelationsmatrix können wir erkennen, dass sie symmetrisch ist, dh, dass unten links die gleiche wie oben rechts ist. Es wird auch beobachtet, dass jede Variable positiv miteinander korreliert ist.
Streumatrix-Diagramm
Streudiagramme zeigen mit Hilfe von Punkten in zwei Dimensionen, wie stark eine Variable von einer anderen beeinflusst wird oder welche Beziehung zwischen ihnen besteht. Streudiagramme ähneln Liniendiagrammen in dem Konzept, dass sie horizontale und vertikale Achsen zum Zeichnen von Datenpunkten verwenden.
Beispiel
Im folgenden Beispiel generiert und zeichnet das Python-Skript eine Streumatrix für den Pima Indian Diabetes-Datensatz. Es kann mit Hilfe der Funktion dispers_matrix () in Pandas DataFrame generiert und mit Hilfe von pyplot geplottet werden.
from matplotlib import pyplot
from pandas import read_csv
from pandas.tools.plotting import scatter_matrix
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
scatter_matrix(data)
pyplot.show()
Ausgabe
Einführung
Algorithmen für maschinelles Lernen sind vollständig von Daten abhängig, da dies der wichtigste Aspekt ist, der das Modelltraining ermöglicht. Auf der anderen Seite ist eine Maschine unbrauchbar, wenn wir aus diesen Daten keinen Sinn machen können, bevor wir sie ML-Algorithmen zuführen. Mit einfachen Worten, wir müssen immer die richtigen Daten eingeben, dh die Daten in der richtigen Größe, im richtigen Format und mit aussagekräftigen Merkmalen für das Problem, das die Maschine lösen soll.
Dies macht die Datenaufbereitung zum wichtigsten Schritt im ML-Prozess. Die Datenaufbereitung kann als das Verfahren definiert werden, mit dem unser Datensatz für den ML-Prozess besser geeignet ist.
Warum Datenvorverarbeitung?
Nach Auswahl der Rohdaten für das ML-Training ist die Datenvorverarbeitung die wichtigste Aufgabe. Im weitesten Sinne konvertiert die Datenvorverarbeitung die ausgewählten Daten in eine Form, mit der wir arbeiten oder die wir ML-Algorithmen zuführen können. Wir müssen unsere Daten immer vorverarbeiten, damit sie den Erwartungen des Algorithmus für maschinelles Lernen entsprechen.
Datenvorverarbeitungstechniken
Wir haben die folgenden Datenvorverarbeitungstechniken, die auf einen Datensatz angewendet werden können, um Daten für ML-Algorithmen zu erzeugen:
Skalierung
Höchstwahrscheinlich besteht unser Datensatz aus Attributen mit unterschiedlichem Maßstab, aber wir können solche Daten nicht für den ML-Algorithmus bereitstellen, daher ist eine Neuskalierung erforderlich. Durch die Neuskalierung von Daten wird sichergestellt, dass die Attribute dieselbe Skalierung aufweisen. Im Allgemeinen werden Attribute in den Bereich von 0 bis 1 neu skaliert. ML-Algorithmen wie Gradientenabstieg und k-Nearest Neighbors erfordern skalierte Daten. Wir können die Daten mit Hilfe der MinMaxScaler-Klasse der Scikit-Learn-Python-Bibliothek neu skalieren.
Beispiel
In diesem Beispiel werden die Daten des Pima Indians Diabetes-Datensatzes, den wir zuvor verwendet haben, neu skaliert. Zuerst werden die CSV-Daten geladen (wie in den vorherigen Kapiteln beschrieben) und dann mit Hilfe der MinMaxScaler-Klasse im Bereich von 0 bis 1 neu skaliert.
Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.
from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Jetzt können wir die MinMaxScaler-Klasse verwenden, um die Daten im Bereich von 0 bis 1 neu zu skalieren.
data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)
Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 1 und zeigen die ersten 10 Zeilen in der Ausgabe an.
set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])
Ausgabe
Scaled data:
[[0.4 0.7 0.6 0.4 0. 0.5 0.2 0.5 1. ]
[0.1 0.4 0.5 0.3 0. 0.4 0.1 0.2 0. ]
[0.5 0.9 0.5 0. 0. 0.3 0.3 0.2 1. ]
[0.1 0.4 0.5 0.2 0.1 0.4 0. 0. 0. ]
[0. 0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
[0.3 0.6 0.6 0. 0. 0.4 0.1 0.2 0. ]
[0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
[0.6 0.6 0. 0. 0. 0.5 0. 0.1 0. ]
[0.1 1. 0.6 0.5 0.6 0.5 0. 0.5 1. ]
[0.5 0.6 0.8 0. 0. 0. 0.1 0.6 1. ]]
Aus der obigen Ausgabe wurden alle Daten in den Bereich von 0 und 1 neu skaliert.
Normalisierung
Eine weitere nützliche Datenvorverarbeitungstechnik ist die Normalisierung. Dies wird verwendet, um jede Datenzeile auf eine Länge von 1 neu zu skalieren. Dies ist hauptsächlich in Sparse-Datensätzen nützlich, in denen viele Nullen vorhanden sind. Wir können die Daten mit Hilfe der Normalizer-Klasse der Scikit-Learn-Python-Bibliothek neu skalieren.
Arten der Normalisierung
Beim maschinellen Lernen gibt es zwei Arten von Normalisierungsvorverarbeitungstechniken:
L1 Normalisierung
Es kann als Normalisierungstechnik definiert werden, die die Datensatzwerte so ändert, dass in jeder Zeile die Summe der absoluten Werte immer bis zu 1 beträgt. Sie wird auch als kleinste absolute Abweichungen bezeichnet.
Example
In diesem Beispiel verwenden wir die L1-Normalisierungstechnik, um die Daten des zuvor verwendeten Pima-Indianer-Diabetes-Datensatzes zu normalisieren. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der Normalizer-Klasse normalisiert.
Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values
Jetzt können wir die Normalizer-Klasse mit L1 verwenden, um die Daten zu normalisieren.
Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)
Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 3 Zeilen in der Ausgabe an.
set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])
Output
Normalized data:
[[0.02 0.43 0.21 0.1 0. 0.1 0. 0.14 0. ]
[0. 0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
[0.03 0.59 0.21 0. 0. 0.07 0. 0.1 0. ]]
L2 Normalisierung
Es kann als Normalisierungstechnik definiert werden, die die Datensatzwerte so ändert, dass in jeder Zeile die Summe der Quadrate immer bis zu 1 beträgt. Sie wird auch als kleinste Quadrate bezeichnet.
Example
In diesem Beispiel verwenden wir die L2-Normalisierungstechnik, um die Daten des zuvor verwendeten Pima-Indianer-Diabetes-Datensatzes zu normalisieren. Zuerst werden die CSV-Daten geladen (wie in den vorherigen Kapiteln beschrieben) und dann mit Hilfe der Normalizer-Klasse normalisiert.
Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values
Jetzt können wir die Normalizer-Klasse mit L1 verwenden, um die Daten zu normalisieren.
Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)
Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 3 Zeilen in der Ausgabe an.
set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])
Output
Normalized data:
[[0.03 0.83 0.4 0.2 0. 0.19 0. 0.28 0.01]
[0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0. ]
[0.04 0.92 0.32 0. 0. 0.12 0. 0.16 0.01]]
Binarisierung
Wie der Name schon sagt, ist dies die Technik, mit deren Hilfe wir unsere Daten binär machen können. Wir können einen binären Schwellenwert verwenden, um unsere Daten binär zu machen. Die Werte über diesem Schwellenwert werden in 1 und unter diesem Schwellenwert in 0 konvertiert. Wenn wir beispielsweise den Schwellenwert = 0,5 wählen, wird der darüber liegende Datensatzwert zu 1 und darunter zu 0. Das heißt warum wir es nennen könnenbinarizing die Daten oder thresholdingdie Daten. Diese Technik ist nützlich, wenn wir Wahrscheinlichkeiten in unserem Datensatz haben und diese in scharfe Werte konvertieren möchten.
Wir können die Daten mit Hilfe der Binarizer-Klasse der Scikit-Learn-Python-Bibliothek binarisieren.
Beispiel
In diesem Beispiel werden die Daten des Pima Indians Diabetes-Datensatzes, den wir zuvor verwendet haben, neu skaliert. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der Binarizer-Klasse in Binärwerte umgewandelt, dh 0 und 1, abhängig vom Schwellenwert. Wir nehmen 0,5 als Schwellenwert.
Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.
from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Jetzt können wir die Binarize-Klasse verwenden, um die Daten in Binärwerte umzuwandeln.
binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)
Hier zeigen wir die ersten 5 Zeilen in der Ausgabe.
print ("\nBinary data:\n", Data_binarized [0:5])
Ausgabe
Binary data:
[[1. 1. 1. 1. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 0. 1. 0. 1. 0.]
[1. 1. 1. 0. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 0. 1. 0.]
[0. 1. 1. 1. 1. 1. 1. 1. 1.]]
Standardisierung
Eine weitere nützliche Datenvorverarbeitungstechnik, die im Wesentlichen verwendet wird, um die Datenattribute mit einer Gaußschen Verteilung zu transformieren. Es unterscheidet den Mittelwert und die SD (Standardabweichung) von einer Standard-Gauß-Verteilung mit einem Mittelwert von 0 und einer SD von 1. Diese Technik ist nützlich bei ML-Algorithmen wie linearer Regression, logistischer Regression, die eine Gauß-Verteilung im Eingabedatensatz voraussetzt und besser produziert Ergebnisse mit neu skalierten Daten. Wir können die Daten (Mittelwert = 0 und SD = 1) mit Hilfe der StandardScaler-Klasse der Scikit-Learn-Python-Bibliothek standardisieren.
Beispiel
In diesem Beispiel werden die Daten des Pima Indians Diabetes-Datensatzes, den wir zuvor verwendet haben, neu skaliert. Zuerst werden die CSV-Daten geladen und dann mit Hilfe der StandardScaler-Klasse in die Gaußsche Verteilung mit Mittelwert = 0 und SD = 1 konvertiert.
Die ersten Zeilen des folgenden Skripts sind dieselben wie in den vorherigen Kapiteln beim Laden von CSV-Daten.
from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Jetzt können wir die StandardScaler-Klasse verwenden, um die Daten neu zu skalieren.
data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)
Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die ersten 5 Zeilen in der Ausgabe an.
set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])
Ausgabe
Rescaled data:
[[ 0.64 0.85 0.15 0.91 -0.69 0.2 0.47 1.43 1.37]
[-0.84 -1.12 -0.16 0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
[ 1.23 1.94 -0.26 -1.29 -0.69 -1.1 0.6 -0.11 1.37]
[-0.84 -1. -0.16 0.15 0.12 -0.49 -0.92 -1.04 -0.73]
[-1.14 0.5 -1.5 0.91 0.77 1.41 5.48 -0.02 1.37]]
Datenbeschriftung
Wir haben die Bedeutung guter Fata für ML-Algorithmen sowie einige Techniken zur Vorverarbeitung der Daten vor dem Senden an ML-Algorithmen erörtert. Ein weiterer Aspekt in dieser Hinsicht ist die Datenkennzeichnung. Es ist auch sehr wichtig, die Daten an ML-Algorithmen mit korrekter Kennzeichnung zu senden. Beispielsweise sind bei Klassifizierungsproblemen viele Beschriftungen in Form von Wörtern, Zahlen usw. auf den Daten vorhanden.
Was ist Etikettencodierung?
Die meisten sklearn-Funktionen erwarten, dass die Daten eher mit Zahlenbezeichnungen als mit Wortbezeichnungen versehen sind. Daher müssen wir solche Bezeichnungen in Zahlenbezeichnungen umwandeln. Dieser Vorgang wird als Etikettencodierung bezeichnet. Wir können die Label-Codierung von Daten mit Hilfe der LabelEncoder () -Funktion der scikit-learn Python-Bibliothek durchführen.
Beispiel
Im folgenden Beispiel führt das Python-Skript die Etikettencodierung durch.
Importieren Sie zunächst die erforderlichen Python-Bibliotheken wie folgt:
import numpy as np
from sklearn import preprocessing
Jetzt müssen wir die Eingabebeschriftungen wie folgt bereitstellen:
input_labels = ['red','black','red','green','black','yellow','white']
In der nächsten Codezeile wird der Beschriftungscodierer erstellt und trainiert.
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)
In den nächsten Skriptzeilen wird die Leistung überprüft, indem die zufällig geordnete Liste codiert wird.
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
Wir können die Liste der codierten Werte mit Hilfe des folgenden Python-Skripts erhalten -
print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))
Ausgabe
Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']
Im vorherigen Kapitel haben wir ausführlich gesehen, wie Daten für das maschinelle Lernen vorverarbeitet und vorbereitet werden. Lassen Sie uns in diesem Kapitel die Auswahl der Datenmerkmale und die damit verbundenen Aspekte im Detail verstehen.
Bedeutung der Auswahl von Datenmerkmalen
Die Leistung des maschinellen Lernmodells ist direkt proportional zu den Datenmerkmalen, die zum Trainieren verwendet werden. Die Leistung des ML-Modells wird negativ beeinflusst, wenn die ihm zur Verfügung gestellten Datenmerkmale irrelevant sind. Andererseits kann die Verwendung relevanter Datenmerkmale die Genauigkeit Ihres ML-Modells erhöhen, insbesondere die lineare und logistische Regression.
Nun stellt sich die Frage, was ist die automatische Funktionsauswahl? Es kann als der Prozess definiert werden, mit dessen Hilfe wir die Merkmale in unseren Daten auswählen, die für die Ausgabe- oder Vorhersagevariable, an der wir interessiert sind, am relevantesten sind. Dies wird auch als Attributauswahl bezeichnet.
Im Folgenden sind einige der Vorteile der automatischen Funktionsauswahl vor dem Modellieren der Daten aufgeführt:
Durch Ausführen der Feature-Auswahl vor der Datenmodellierung wird die Überanpassung verringert.
Durch Ausführen der Merkmalsauswahl vor der Datenmodellierung wird die Genauigkeit des ML-Modells erhöht.
Durch Ausführen der Funktionsauswahl vor der Datenmodellierung wird die Trainingszeit verkürzt
Techniken zur Funktionsauswahl
Im Folgenden finden Sie Techniken zur automatischen Funktionsauswahl, mit denen wir ML-Daten in Python modellieren können:
Univariate Auswahl
Diese Merkmalsauswahltechnik ist sehr nützlich bei der Auswahl dieser Merkmale mit Hilfe statistischer Tests, die eine stärkste Beziehung zu den Vorhersagevariablen haben. Wir können eine univariate Technik zur Merkmalsauswahl mit Hilfe von SelectKBest0class der scikit-learn Python-Bibliothek implementieren.
Example
In diesem Beispiel verwenden wir den Pima Indians Diabetes-Datensatz, um mithilfe eines statistischen Chi-Quadrat-Tests 4 der Attribute mit den besten Eigenschaften auszuwählen.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Als nächstes werden wir das Array in Eingabe- und Ausgabekomponenten unterteilen -
X = array[:,0:8]
Y = array[:,8]
In den folgenden Codezeilen werden die besten Funktionen aus dem Datensatz ausgewählt:
test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X,Y)
Wir können auch die Daten für die Ausgabe nach unserer Wahl zusammenfassen. Hier setzen wir die Genauigkeit auf 2 und zeigen die 4 Datenattribute mit den besten Merkmalen zusammen mit der besten Punktzahl für jedes Attribut an -
set_printoptions(precision=2)
print(fit.scores_)
featured_data = fit.transform(X)
print ("\nFeatured data:\n", featured_data[0:4])
Output
[ 111.52 1411.89 17.61 53.11 2175.57 127.67 5.39 181.3 ]
Featured data:
[[148. 0. 33.6 50. ]
[ 85. 0. 26.6 31. ]
[183. 0. 23.3 32. ]
[ 89. 94. 28.1 21. ]]
Eliminierung rekursiver Merkmale
Wie der Name schon sagt, entfernt die RFE-Feature-Auswahlmethode (Recursive Feature Elimination) die Attribute rekursiv und erstellt das Modell mit den verbleibenden Attributen. Wir können die RFE-Feature-Auswahlmethode mithilfe der RFE-Klasse der Scikit-Learn-Python-Bibliothek implementieren.
Beispiel
In diesem Beispiel verwenden wir RFE mit logistischem Regressionsalgorithmus, um die besten 3 Attribute mit den besten Merkmalen aus dem Pima Indians Diabetes-Datensatz auszuwählen.
from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Als nächstes werden wir das Array in seine Eingabe- und Ausgabekomponenten unterteilen -
X = array[:,0:8]
Y = array[:,8]
In den folgenden Codezeilen werden die besten Funktionen aus einem Datensatz ausgewählt:
model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Number of Features: %d")
print("Selected Features: %s")
print("Feature Ranking: %s")
Ausgabe
Number of Features: 3
Selected Features: [ True False False False False True True False]
Feature Ranking: [1 2 3 5 6 1 1 4]
Wir können in der obigen Ausgabe sehen, dass RFE Preg, Masse und Pedi als die ersten 3 besten Eigenschaften auswählt. Sie sind in der Ausgabe als 1 markiert.
Hauptkomponentenanalyse (PCA)
PCA, allgemein als Datenreduktionstechnik bezeichnet, ist eine sehr nützliche Methode zur Merkmalsauswahl, da sie die lineare Algebra verwendet, um den Datensatz in eine komprimierte Form umzuwandeln. Wir können die PCA-Feature-Auswahlmethode mithilfe der PCA-Klasse der Scikit-Learn-Python-Bibliothek implementieren. Wir können die Anzahl der Hauptkomponenten in der Ausgabe auswählen.
Beispiel
In diesem Beispiel verwenden wir PCA, um die besten 3 Hauptkomponenten aus dem Diabetes-Datensatz von Pima Indians auszuwählen.
from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values
Als nächstes werden wir das Array in Eingabe- und Ausgabekomponenten unterteilen -
X = array[:,0:8]
Y = array[:,8]
Die folgenden Codezeilen extrahieren Features aus dem Datensatz -
pca = PCA(n_components=3)
fit = pca.fit(X)
print("Explained Variance: %s") % fit.explained_variance_ratio_
print(fit.components_)
Ausgabe
Explained Variance: [ 0.88854663 0.06159078 0.02579012]
[[ -2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02
9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[ 2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02
-9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01]
[ -2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01
2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]
Aus der obigen Ausgabe können wir ersehen, dass 3 Hauptkomponenten wenig Ähnlichkeit mit den Quelldaten haben.
Funktionsbedeutung
Wie der Name schon sagt, wird die Technik der Merkmalsbedeutung verwendet, um die Wichtigkeitsmerkmale auszuwählen. Grundsätzlich wird ein geschulter überwachter Klassifikator verwendet, um Merkmale auszuwählen. Wir können diese Feature-Auswahl-Technik mit Hilfe der ExtraTreeClassifier-Klasse der Scikit-Learn-Python-Bibliothek implementieren.
Beispiel
In diesem Beispiel verwenden wir ExtraTreeClassifier, um Funktionen aus dem Pima Indians Diabetes-Datensatz auszuwählen.
from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
path = r'C:\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(data, names=names)
array = dataframe.values
Als nächstes werden wir das Array in Eingabe- und Ausgabekomponenten unterteilen -
X = array[:,0:8]
Y = array[:,8]
Die folgenden Codezeilen extrahieren Features aus dem Datensatz -
model = ExtraTreesClassifier()
model.fit(X, Y)
print(model.feature_importances_)
Ausgabe
[ 0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]
Anhand der Ausgabe können wir beobachten, dass es für jedes Attribut Bewertungen gibt. Je höher die Punktzahl, desto höher ist die Wichtigkeit dieses Attributs.
Einführung in die Klassifizierung
Die Klassifizierung kann als der Prozess der Vorhersage der Klasse oder Kategorie aus beobachteten Werten oder gegebenen Datenpunkten definiert werden. Die kategorisierte Ausgabe kann die Form "Schwarz" oder "Weiß" oder "Spam" oder "Kein Spam" haben.
Mathematisch gesehen ist die Klassifizierung die Aufgabe, eine Abbildungsfunktion (f) von Eingabevariablen (X) an Ausgabevariablen (Y) zu approximieren. Es gehört grundsätzlich zum überwachten maschinellen Lernen, bei dem neben dem Eingabedatensatz auch Ziele bereitgestellt werden.
Ein Beispiel für ein Klassifizierungsproblem kann die Spam-Erkennung in E-Mails sein. Es kann nur zwei Kategorien von Ausgaben geben: "Spam" und "kein Spam". Daher ist dies eine binäre Typklassifizierung.
Um diese Klassifizierung zu implementieren, müssen wir zuerst den Klassifizierer trainieren. In diesem Beispiel werden "Spam" - und "kein Spam" -E-Mails als Trainingsdaten verwendet. Nachdem der Klassifikator erfolgreich trainiert wurde, kann er zum Erkennen einer unbekannten E-Mail verwendet werden.
Arten von Lernenden in der Klassifikation
Wir haben zwei Arten von Lernenden in Bezug auf Klassifizierungsprobleme -
Faule Lernende
Wie der Name schon sagt, warten solche Lernenden darauf, dass die Testdaten nach dem Speichern der Trainingsdaten angezeigt werden. Die Klassifizierung erfolgt erst nach Erhalt der Testdaten. Sie verbringen weniger Zeit mit Training, aber mehr Zeit mit Vorhersagen. Beispiele für faule Lernende sind K-nächster Nachbar und fallbasiertes Denken.
Eifrige Lernende
Im Gegensatz zu faulen Lernenden erstellen eifrige Lernende ein Klassifizierungsmodell, ohne darauf zu warten, dass die Testdaten nach dem Speichern der Trainingsdaten angezeigt werden. Sie verbringen mehr Zeit mit Training, aber weniger Zeit mit Vorhersagen. Beispiele für eifrige Lernende sind Entscheidungsbäume, naive Bayes und künstliche neuronale Netze (ANN).
Erstellen eines Klassifikators in Python
Scikit-learn, eine Python-Bibliothek für maschinelles Lernen, kann verwendet werden, um einen Klassifikator in Python zu erstellen. Die Schritte zum Erstellen eines Klassifikators in Python lauten wie folgt:
Schritt 1: Importieren des erforderlichen Python-Pakets
Um einen Klassifikator mit scikit-learn zu erstellen, müssen wir ihn importieren. Wir können es mit folgendem Skript importieren -
import sklearn
Schritt 2: Datensatz importieren
Nach dem Import des erforderlichen Pakets benötigen wir einen Datensatz, um ein Klassifizierungsvorhersagemodell zu erstellen. Wir können es aus dem sklearn-Dataset importieren oder ein anderes gemäß unseren Anforderungen verwenden. Wir werden die Breast Cancer Wisconsin Diagnostic Database von sklearn verwenden. Wir können es mit Hilfe des folgenden Skripts importieren -
from sklearn.datasets import load_breast_cancer
Das folgende Skript lädt den Datensatz.
data = load_breast_cancer()
Wir müssen auch die Daten organisieren und dies kann mit Hilfe der folgenden Skripte erfolgen -
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Der folgende Befehl gibt den Namen der Bezeichnungen "bösartig" und "gutartig" für unsere Datenbank aus.
print(label_names)
Die Ausgabe des obigen Befehls sind die Namen der Beschriftungen -
['malignant' 'benign']
Diese Beschriftungen werden den Binärwerten 0 und 1 zugeordnet. Malignant Krebs wird durch 0 und dargestellt Benign Krebs wird durch 1 dargestellt.
Die Feature-Namen und Feature-Werte dieser Beschriftungen können mithilfe der folgenden Befehle angezeigt werden:
print(feature_names[0])
Die Ausgabe des obigen Befehls sind die Namen der Merkmale für die Bezeichnung 0, d. H. Malignant Krebs -
mean radius
In ähnlicher Weise können Namen der Merkmale für das Etikett wie folgt erzeugt werden:
print(feature_names[1])
Die Ausgabe des obigen Befehls sind die Namen der Merkmale für Label 1, d. H. Benign Krebs -
mean texture
Wir können die Funktionen für diese Etiketten mit Hilfe des folgenden Befehls drucken:
print(features[0])
Dies ergibt die folgende Ausgabe -
[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
4.601e-01 1.189e-01]
Wir können die Funktionen für diese Etiketten mit Hilfe des folgenden Befehls drucken:
print(features[1])
Dies ergibt die folgende Ausgabe -
[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01 8.902e-02]
Schritt 3: Organisieren von Daten in Trainings- und Testsätzen
Da wir unser Modell an unsichtbaren Daten testen müssen, werden wir unseren Datensatz in zwei Teile aufteilen: einen Trainingssatz und einen Testsatz. Wir können die Funktion train_test_split () des sklearn-Python-Pakets verwenden, um die Daten in Mengen aufzuteilen. Der folgende Befehl importiert die Funktion -
from sklearn.model_selection import train_test_split
Mit dem nächsten Befehl werden die Daten in Trainings- und Testdaten aufgeteilt. In diesem Beispiel verwenden wir 40 Prozent der Daten zu Testzwecken und 60 Prozent der Daten zu Schulungszwecken.
train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)
Schritt 4 - Modellbewertung
Nachdem wir die Daten in Training und Test unterteilt haben, müssen wir das Modell erstellen. Zu diesem Zweck verwenden wir den Naive Bayes-Algorithmus. Die folgenden Befehle importieren das GaussianNB-Modul -
from sklearn.naive_bayes import GaussianNB
Initialisieren Sie nun das Modell wie folgt:
gnb = GaussianNB()
Als nächstes können wir mit Hilfe des folgenden Befehls das Modell trainieren -
model = gnb.fit(train, train_labels)
Zu Bewertungszwecken müssen wir nun Vorhersagen treffen. Dies kann mithilfe der Funktion pred () wie folgt erfolgen:
preds = gnb.predict(test)
print(preds)
Dies ergibt die folgende Ausgabe -
[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
0 0 1 1 0 1]
Die obigen Reihen von Nullen und Einsen in der Ausgabe sind die vorhergesagten Werte für die Malignant und Benign Tumorklassen.
Schritt 5 - Genauigkeit finden
Wir können die Genauigkeit des im vorherigen Schritt erstellten Modells ermitteln, indem wir die beiden Arrays test_labels und preds vergleichen. Wir werden die Genauigkeit.score () -Funktion verwenden, um die Genauigkeit zu bestimmen.
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
Die obige Ausgabe zeigt, dass der NaïveBayes-Klassifikator zu 95,17% genau ist.
Bewertungsmetriken für die Klassifizierung
Die Aufgabe wird auch dann nicht erledigt, wenn Sie die Implementierung Ihrer Anwendung oder Ihres Modells für maschinelles Lernen abgeschlossen haben. Wir müssen herausfinden, wie effektiv unser Modell ist. Es kann verschiedene Bewertungsmetriken geben, aber wir müssen sie sorgfältig auswählen, da die Auswahl der Metriken Einfluss darauf hat, wie die Leistung eines Algorithmus für maschinelles Lernen gemessen und verglichen wird.
Im Folgenden finden Sie einige wichtige Bewertungsmetriken für die Klassifizierung, aus denen Sie basierend auf Ihrem Datensatz und der Art des Problems auswählen können:
Verwirrung Matrix
Dies ist der einfachste Weg, um die Leistung eines Klassifizierungsproblems zu messen, bei dem die Ausgabe aus zwei oder mehr Klassentypen bestehen kann. Eine Verwirrungsmatrix ist nichts anderes als eine Tabelle mit zwei Dimensionen, nämlich. "Ist" und "Vorausgesagt" und außerdem haben beide Dimensionen "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)", wie unten gezeigt -
True Positives (TP) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 1 ist.
True Negatives (TN) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 0 sind.
False Positives (FP) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 0 und die vorhergesagte Datenpunktklasse 1 ist.
False Negatives (FN) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 1 und die vorhergesagte Datenpunktklasse 0 ist.
Wir können die Verwirrungsmatrix mit Hilfe der Funktion confusion_matrix () von sklearn finden. Mit Hilfe des folgenden Skripts können wir die Verwirrungsmatrix des oben erstellten binären Klassifikators finden -
from sklearn.metrics import confusion_matrix
Ausgabe
[[ 73 7]
[ 4 144]]
Richtigkeit
Es kann als die Anzahl der korrekten Vorhersagen definiert werden, die von unserem ML-Modell gemacht werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$$=\frac{+}{+++}$$Für den oben erstellten binären Klassifikator ist TP + TN = 73 + 144 = 217 und TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.
Daher ist Genauigkeit = 217/228 = 0,951754385965, was dasselbe ist, das wir nach dem Erstellen unseres binären Klassifikators berechnet haben.
Präzision
Präzision, die beim Abrufen von Dokumenten verwendet wird, kann als die Anzahl der korrekten Dokumente definiert werden, die von unserem ML-Modell zurückgegeben werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$$=\frac{}{+FP}$$Für den oben erstellten binären Klassifikator ist TP = 73 und TP + FP = 73 + 7 = 80.
Daher ist Präzision = 73/80 = 0,915
Rückruf oder Empfindlichkeit
Der Rückruf kann als die Anzahl der von unserem ML-Modell zurückgegebenen Positiven definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$$=\frac{}{+FN}$$Für den oben erstellten binären Klassifikator ist TP = 73 und TP + FN = 73 + 4 = 77.
Daher ist Präzision = 73/77 = 0,94805
Spezifität
Die Spezifität kann im Gegensatz zum Rückruf als die Anzahl der von unserem ML-Modell zurückgegebenen Negative definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$$=\frac{N}{N+FP}$$Für den oben erstellten binären Klassifikator ist TN = 144 und TN + FP = 144 + 7 = 151.
Daher ist Präzision = 144/151 = 0,95364
Verschiedene ML-Klassifizierungsalgorithmen
Das Folgende sind einige wichtige ML-Klassifizierungsalgorithmen -
Logistische Regression
Support Vector Machine (SVM)
Entscheidungsbaum
Naive Bayes
Zufälliger Wald
Wir werden alle diese Klassifizierungsalgorithmen in weiteren Kapiteln ausführlich diskutieren.
Anwendungen
Einige der wichtigsten Anwendungen von Klassifizierungsalgorithmen sind:
Spracherkennung
Handschrifterkennung
Biometrische Identifizierung
Dokumentenklassifizierung
Einführung in die logistische Regression
Die logistische Regression ist ein überwachter Lernklassifizierungsalgorithmus, mit dem die Wahrscheinlichkeit einer Zielvariablen vorhergesagt wird. Die Art des Ziels oder der abhängigen Variablen ist dichotom, was bedeutet, dass es nur zwei mögliche Klassen gibt.
Mit einfachen Worten, die abhängige Variable ist binärer Natur und hat Daten, die entweder als 1 (steht für Erfolg / Ja) oder 0 (steht für Fehler / Nein) codiert sind.
Mathematisch gesehen sagt ein logistisches Regressionsmodell P (Y = 1) als Funktion von X voraus. Es ist einer der einfachsten ML-Algorithmen, die für verschiedene Klassifizierungsprobleme wie Spam-Erkennung, Diabetes-Vorhersage, Krebserkennung usw. verwendet werden können.
Arten der logistischen Regression
Im Allgemeinen bedeutet logistische Regression eine binäre logistische Regression mit binären Zielvariablen, es können jedoch zwei weitere Kategorien von Zielvariablen vorhergesagt werden. Basierend auf dieser Anzahl von Kategorien kann die logistische Regression in folgende Typen unterteilt werden:
Binär oder Binomial
Bei einer solchen Klassifizierung hat eine abhängige Variable nur zwei mögliche Typen, entweder 1 und 0. Beispielsweise können diese Variablen Erfolg oder Misserfolg darstellen, ja oder nein, Gewinn oder Verlust usw.
Multinomial
Bei einer solchen Klassifizierung kann eine abhängige Variable drei oder mehr mögliche ungeordnete Typen oder Typen ohne quantitative Signifikanz aufweisen. Diese Variablen können beispielsweise "Typ A" oder "Typ B" oder "Typ C" darstellen.
Ordinal
Bei einer solchen Klassifizierung kann eine abhängige Variable drei oder mehr mögliche geordnete Typen oder Typen mit quantitativer Bedeutung haben. Zum Beispiel können diese Variablen "schlecht" oder "gut", "sehr gut", "ausgezeichnet" darstellen und jede Kategorie kann die Werte 0,1,2,3 haben.
Annahmen zur logistischen Regression
Bevor wir uns mit der Implementierung der logistischen Regression befassen, müssen wir uns der folgenden Annahmen bewusst sein:
Bei einer binären logistischen Regression müssen die Zielvariablen immer binär sein und das gewünschte Ergebnis wird durch die Faktorstufe 1 dargestellt.
Das Modell sollte keine Multikollinearität aufweisen, dh die unabhängigen Variablen müssen unabhängig voneinander sein.
Wir müssen sinnvolle Variablen in unser Modell aufnehmen.
Wir sollten eine große Stichprobengröße für die logistische Regression wählen.
Modell der binären logistischen Regression
Die einfachste Form der logistischen Regression ist die binäre oder binomiale logistische Regression, bei der das Ziel oder die abhängige Variable nur zwei mögliche Typen haben kann, entweder 1 oder 0. Sie ermöglicht es uns, eine Beziehung zwischen mehreren Prädiktorvariablen und einer binären / binomialen Zielvariablen zu modellieren. Im Falle einer logistischen Regression wird die lineare Funktion grundsätzlich als Eingabe für eine andere Funktion verwendet, wie in der folgenden Beziehung:
$h_{\theta}{(x)}=g(\theta^{T}x)ℎ 0≤h_{\theta}≤1$Hier ist die logistische oder Sigmoid-Funktion, die wie folgt angegeben werden kann:
$g(z)= \frac{1}{1+e^{-z}}ℎ =\theta ^{T}$Die Sigmoidkurve kann mit Hilfe des folgenden Diagramms dargestellt werden. Wir können sehen, dass die Werte der y-Achse zwischen 0 und 1 liegen und die Achse bei 0,5 kreuzen.
Die Klassen können in positive oder negative unterteilt werden. Die Ausgabe fällt unter die Wahrscheinlichkeit einer positiven Klasse, wenn sie zwischen 0 und 1 liegt. Für unsere Implementierung interpretieren wir die Ausgabe der Hypothesenfunktion als positiv, wenn sie ≥ 0,5 ist, andernfalls negativ.
Wir müssen auch eine Verlustfunktion definieren, um zu messen, wie gut der Algorithmus unter Verwendung der Gewichte für Funktionen funktioniert, die wie folgt durch Theta dargestellt werden:
ℎ = ()
$J(\theta) = \frac{1}{m}.(-y^{T}log(h) - (1 -y)^Tlog(1-h))$Nachdem wir die Verlustfunktion definiert haben, besteht unser Hauptziel darin, die Verlustfunktion zu minimieren. Dies kann mit Hilfe der Anpassung der Gewichte erfolgen, dh durch Erhöhen oder Verringern der Gewichte. Mit Hilfe von Ableitungen der Verlustfunktion für jedes Gewicht könnten wir wissen, welche Parameter ein hohes Gewicht und welche ein geringeres Gewicht haben sollten.
Die folgende Gradientenabstiegsgleichung zeigt uns, wie sich der Verlust ändern würde, wenn wir die Parameter ändern würden -
$\frac{()}{\theta_{j}}=\frac{1}{m}X^{T}(()−)$Implementierung in Python
Jetzt werden wir das obige Konzept der binomialen logistischen Regression in Python implementieren. Zu diesem Zweck verwenden wir einen multivariaten Blumendatensatz mit dem Namen "Iris", der 3 Klassen mit jeweils 50 Instanzen enthält. Wir werden jedoch die ersten beiden Feature-Spalten verwenden. Jede Klasse repräsentiert eine Art Irisblume.
Zuerst müssen wir die erforderlichen Bibliotheken wie folgt importieren:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets
Laden Sie als Nächstes den Iris-Datensatz wie folgt:
iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1
Wir können unsere Trainingsdaten wie folgt zeichnen:
plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();
Als nächstes definieren wir die Sigmoidfunktion, die Verlustfunktion und den Gradientenabstieg wie folgt:
class LogisticRegression:
def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
self.lr = lr
self.num_iter = num_iter
self.fit_intercept = fit_intercept
self.verbose = verbose
def __add_intercept(self, X):
intercept = np.ones((X.shape[0], 1))
return np.concatenate((intercept, X), axis=1)
def __sigmoid(self, z):
return 1 / (1 + np.exp(-z))
def __loss(self, h, y):
return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
def fit(self, X, y):
if self.fit_intercept:
X = self.__add_intercept(X)
Initialisieren Sie nun die Gewichte wie folgt:
self.theta = np.zeros(X.shape[1])
for i in range(self.num_iter):
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
gradient = np.dot(X.T, (h - y)) / y.size
self.theta -= self.lr * gradient
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
loss = self.__loss(h, y)
if(self.verbose ==True and i % 10000 == 0):
print(f'loss: {loss} \t')
Mit Hilfe des folgenden Skripts können wir die Ausgabewahrscheinlichkeiten vorhersagen -
def predict_prob(self, X):
if self.fit_intercept:
X = self.__add_intercept(X)
return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
return self.predict_prob(X).round()
Als nächstes können wir das Modell bewerten und wie folgt darstellen:
model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()
plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');
Multinomiales logistisches Regressionsmodell
Eine andere nützliche Form der logistischen Regression ist die multinomiale logistische Regression, bei der das Ziel oder die abhängige Variable drei oder mehr mögliche ungeordnete Typen haben kann, dh die Typen ohne quantitative Signifikanz.
Implementierung in Python
Jetzt werden wir das obige Konzept der multinomialen logistischen Regression in Python implementieren. Zu diesem Zweck verwenden wir einen Datensatz von sklearn mit dem Namen digit.
Zuerst müssen wir die erforderlichen Bibliotheken wie folgt importieren:
Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split
Als nächstes müssen wir den Ziffern-Datensatz laden -
digits = datasets.load_digits()
Definieren Sie nun die Merkmalsmatrix (X) und den Antwortvektor (y) wie folgt:
X = digits.data
y = digits.target
Mit Hilfe der nächsten Codezeile können wir X und Y in Trainings- und Testsätze aufteilen -
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
Erstellen Sie nun ein Objekt der logistischen Regression wie folgt:
digreg = linear_model.LogisticRegression()
Jetzt müssen wir das Modell mithilfe der folgenden Trainingssätze trainieren:
digreg.fit(X_train, y_train)
Machen Sie als nächstes die Vorhersagen für den Testsatz wie folgt:
y_pred = digreg.predict(X_test)
Als nächstes drucken Sie die Genauigkeit des Modells wie folgt:
print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)
Ausgabe
Accuracy of Logistic Regression model is: 95.6884561891516
Aus der obigen Ausgabe können wir ersehen, dass die Genauigkeit unseres Modells bei 96 Prozent liegt.
Einführung in SVM
Support Vector Machines (SVMs) sind leistungsstarke und dennoch flexible überwachte Algorithmen für maschinelles Lernen, die sowohl zur Klassifizierung als auch zur Regression verwendet werden. Im Allgemeinen werden sie jedoch bei Klassifizierungsproblemen verwendet. In den 1960er Jahren wurden SVMs erstmals eingeführt, später jedoch 1990 weiterentwickelt. SVMs haben im Vergleich zu anderen Algorithmen für maschinelles Lernen eine einzigartige Art der Implementierung. In letzter Zeit sind sie äußerst beliebt, da sie mehrere kontinuierliche und kategoriale Variablen verarbeiten können.
Arbeiten von SVM
Ein SVM-Modell ist im Grunde eine Darstellung verschiedener Klassen in einer Hyperebene im mehrdimensionalen Raum. Die Hyperebene wird von SVM iterativ generiert, damit der Fehler minimiert werden kann. Das Ziel von SVM ist es, die Datensätze in Klassen zu unterteilen, um eine maximale marginale Hyperebene (MMH) zu finden.
Das Folgende sind wichtige Konzepte in SVM -
Support Vectors- Datenpunkte, die der Hyperebene am nächsten liegen, werden als Unterstützungsvektoren bezeichnet. Mit Hilfe dieser Datenpunkte wird eine Trennlinie definiert.
Hyperplane - Wie wir im obigen Diagramm sehen können, handelt es sich um eine Entscheidungsebene oder einen Raum, der auf eine Reihe von Objekten mit unterschiedlichen Klassen aufgeteilt ist.
Margin- Es kann als die Lücke zwischen zwei Linien auf den Schrankdatenpunkten verschiedener Klassen definiert werden. Sie kann als senkrechter Abstand von der Linie zu den Stützvektoren berechnet werden. Eine große Marge wird als gute Marge und eine kleine Marge als schlechte Marge angesehen.
Das Hauptziel von SVM besteht darin, die Datensätze in Klassen zu unterteilen, um eine maximale marginale Hyperebene (MMH) zu finden. Dies kann in den folgenden zwei Schritten erfolgen:
Zunächst generiert SVM iterativ Hyperebenen, die die Klassen optimal trennen.
Anschließend wird die Hyperebene ausgewählt, die die Klassen korrekt trennt.
Implementierung von SVM in Python
Für die Implementierung von SVM in Python beginnen wir mit dem Import der Standardbibliotheken wie folgt:
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns; sns.set()
Als Nächstes erstellen wir aus sklearn.dataset.sample_generator ein Beispieldatensatz mit linear trennbaren Daten zur Klassifizierung mithilfe von SVM -
from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=100, centers=2,
random_state=0, cluster_std=0.50)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');
Das Folgende wäre die Ausgabe nach dem Generieren eines Beispieldatensatzes mit 100 Proben und 2 Clustern -
Wir wissen, dass SVM eine diskriminierende Klassifizierung unterstützt. Es trennt die Klassen voneinander, indem es einfach eine Linie bei zwei Dimensionen oder eine Mannigfaltigkeit bei mehreren Dimensionen findet. Es wird auf dem obigen Datensatz wie folgt implementiert:
xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);
Die Ausgabe ist wie folgt -
Wir können der obigen Ausgabe entnehmen, dass es drei verschiedene Separatoren gibt, die die obigen Proben perfekt unterscheiden.
Wie bereits erwähnt, besteht das Hauptziel von SVM darin, die Datensätze in Klassen zu unterteilen, um eine maximale marginale Hyperebene (MMH) zu finden. Anstatt eine Nulllinie zwischen Klassen zu zeichnen, können wir um jede Linie einen Rand mit einer gewissen Breite bis zum nächsten Punkt zeichnen. Dies kann wie folgt erfolgen:
xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
yfit = m * xfit + b
plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);
Aus dem obigen Bild in der Ausgabe können wir leicht die "Ränder" innerhalb der diskriminierenden Klassifikatoren beobachten. SVM wählt die Linie aus, die den Rand maximiert.
Als Nächstes verwenden wir den Support-Vektor-Klassifikator von Scikit-Learn, um ein SVM-Modell für diese Daten zu trainieren. Hier verwenden wir einen linearen Kernel, um SVM wie folgt anzupassen:
from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)
Die Ausgabe ist wie folgt -
SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='linear', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)
Zum besseren Verständnis werden im Folgenden die Entscheidungsfunktionen für 2D-SVC dargestellt:
def decision_function(model, ax=None, plot_support=True):
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
Zur Bewertung des Modells müssen wir ein Raster wie folgt erstellen:
x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)
Als nächstes müssen wir Entscheidungsgrenzen und -ränder wie folgt zeichnen:
ax.contour(X, Y, P, colors='k',
levels=[-1, 0, 1], alpha=0.5,
linestyles=['--', '-', '--'])
Zeichnen Sie nun auf ähnliche Weise die Unterstützungsvektoren wie folgt:
if plot_support:
ax.scatter(model.support_vectors_[:, 0],
model.support_vectors_[:, 1],
s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)
Verwenden Sie diese Funktion nun, um unsere Modelle wie folgt anzupassen:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);
Aus der obigen Ausgabe können wir ersehen, dass ein SVM-Klassifikator mit Rändern, dh gestrichelten Linien und Unterstützungsvektoren, an die Daten passt, wobei die zentralen Elemente dieser Anpassung die gestrichelte Linie berühren. Diese Unterstützungsvektorpunkte werden wie folgt im Attribut support_vectors_ des Klassifizierers gespeichert:
model.support_vectors_
Die Ausgabe ist wie folgt -
array([[0.5323772 , 3.31338909],
[2.11114739, 3.57660449],
[1.46870582, 1.86947425]])
SVM-Kernel
In der Praxis wird der SVM-Algorithmus mit einem Kernel implementiert, der einen Eingabedatenraum in die erforderliche Form umwandelt. SVM verwendet eine Technik namens Kernel-Trick, bei der der Kernel einen niedrigdimensionalen Eingaberaum nimmt und ihn in einen höherdimensionalen Raum umwandelt. Mit einfachen Worten, der Kernel wandelt nicht trennbare Probleme in trennbare Probleme um, indem er weitere Dimensionen hinzufügt. Es macht SVM leistungsfähiger, flexibler und genauer. Im Folgenden sind einige der von SVM verwendeten Kerneltypen aufgeführt:
Linearer Kernel
Es kann als Punktprodukt zwischen zwei beliebigen Beobachtungen verwendet werden. Die Formel des linearen Kernels lautet wie folgt:
k (x, x i ) = Summe (x * x i )
Aus der obigen Formel können wir sehen, dass das Produkt zwischen zwei Vektoren & ist die Summe der Multiplikation jedes Paares von Eingabewerten.
Polynomkern
Es ist eine allgemeinere Form des linearen Kernels und unterscheidet gekrümmten oder nichtlinearen Eingaberaum. Es folgt die Formel für den Polynomkern -
K (x, xi) = 1 + Summe (x * xi) ^ d
Hier ist d der Grad des Polynoms, den wir manuell im Lernalgorithmus angeben müssen.
Kernel der Radial Basis Function (RBF)
Der RBF-Kernel, der hauptsächlich in der SVM-Klassifizierung verwendet wird, bildet den Eingaberaum in einem unbestimmten Dimensionsraum ab. Die folgende Formel erklärt es mathematisch -
K (x, xi) = exp (-gamma * sum ((x - xi ^ 2))
Hier reicht Gamma von 0 bis 1. Wir müssen es manuell im Lernalgorithmus angeben. Ein guter Standardwert für Gamma ist 0,1.
Da wir SVM für linear trennbare Daten implementiert haben, können wir es in Python für Daten implementieren, die nicht linear trennbar sind. Dies kann mithilfe von Kerneln erfolgen.
Beispiel
Im Folgenden finden Sie ein Beispiel für die Erstellung eines SVM-Klassifikators mithilfe von Kerneln. Wir werden den Iris-Datensatz von scikit-learn verwenden -
Wir werden zunächst folgende Pakete importieren:
import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt
Jetzt müssen wir die Eingabedaten laden -
iris = datasets.load_iris()
Aus diesem Datensatz nehmen wir die ersten beiden Funktionen wie folgt:
X = iris.data[:, :2]
y = iris.target
Als nächstes zeichnen wir die SVM-Grenzen mit den Originaldaten wie folgt:
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]
Nun müssen wir den Wert des Regularisierungsparameters wie folgt angeben:
C = 1.0
Als nächstes kann das SVM-Klassifikatorobjekt wie folgt erstellt werden:
Svc_classifier = svm.SVC (Kernel = 'linear', C = C) .fit (X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with linear kernel')
Ausgabe
Text(0.5, 1.0, 'Support Vector Classifier with linear kernel')
Zum Erstellen eines SVM-Klassifikators mit rbf Kernel, wir können den Kernel in ändern rbf wie folgt -
Svc_classifier = svm.SVC(kernel='rbf', gamma =‘auto’,C=C).fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with rbf kernel')
Ausgabe
Text(0.5, 1.0, 'Support Vector Classifier with rbf kernel')
Wir setzen den Wert von Gamma auf 'auto', aber Sie können auch einen Wert zwischen 0 und 1 angeben.
Vor- und Nachteile von SVM-Klassifikatoren
Vorteile von SVM-Klassifikatoren
SVM-Klassifikatoren bieten eine hohe Genauigkeit und funktionieren gut mit hochdimensionalem Raum. SVM-Klassifizierer verwenden grundsätzlich eine Teilmenge von Trainingspunkten, weshalb das Ergebnis sehr wenig Speicher benötigt.
Nachteile von SVM-Klassifikatoren
Sie haben eine hohe Trainingszeit und sind daher in der Praxis nicht für große Datenmengen geeignet. Ein weiterer Nachteil ist, dass SVM-Klassifizierer mit überlappenden Klassen nicht gut funktionieren.
Einführung in den Entscheidungsbaum
Im Allgemeinen ist die Entscheidungsbaumanalyse ein Vorhersagemodellierungswerkzeug, das in vielen Bereichen angewendet werden kann. Entscheidungsbäume können durch einen algorithmischen Ansatz erstellt werden, der den Datensatz basierend auf verschiedenen Bedingungen auf unterschiedliche Weise aufteilen kann. Entscheidungen sind die leistungsstärksten Algorithmen, die unter die Kategorie der überwachten Algorithmen fallen.
Sie können sowohl für Klassifizierungs- als auch für Regressionsaufgaben verwendet werden. Die beiden Hauptentitäten eines Baums sind Entscheidungsknoten, bei denen die Daten aufgeteilt werden und die Daten verlassen werden. Das Beispiel eines binären Baums zur Vorhersage, ob eine Person fit oder nicht fit ist und verschiedene Informationen wie Alter, Essgewohnheiten und Bewegungsgewohnheiten liefert, ist unten angegeben.
Im obigen Entscheidungsbaum sind die Fragen Entscheidungsknoten und die Endergebnisse sind Blätter. Wir haben die folgenden zwei Arten von Entscheidungsbäumen:
Classification decision trees- Bei dieser Art von Entscheidungsbäumen ist die Entscheidungsvariable kategorisch. Der obige Entscheidungsbaum ist ein Beispiel für einen Klassifizierungsentscheidungsbaum.
Regression decision trees - Bei dieser Art von Entscheidungsbäumen ist die Entscheidungsvariable kontinuierlich.
Implementieren des Entscheidungsbaumalgorithmus
Gini Index
Dies ist der Name der Kostenfunktion, die zur Auswertung der binären Teilungen im Datensatz verwendet wird und mit der kategorialen Zielvariablen „Erfolg“ oder „Fehler“ arbeitet.
Je höher der Wert des Gini-Index ist, desto höher ist die Homogenität. Ein perfekter Gini-Indexwert ist 0 und der schlechteste ist 0,5 (für 2-Klassen-Probleme). Der Gini-Index für einen Split kann mithilfe der folgenden Schritte berechnet werden:
Berechnen Sie zunächst den Gini-Index für Unterknoten mit der Formel p ^ 2 + q ^ 2, die die Summe des Wahrscheinlichkeitsquadrats für Erfolg und Misserfolg darstellt.
Berechnen Sie als Nächstes den Gini-Index für die Aufteilung unter Verwendung der gewichteten Gini-Bewertung jedes Knotens dieser Aufteilung.
Der CART-Algorithmus (Classification and Regression Tree) verwendet die Gini-Methode, um binäre Teilungen zu generieren.
Geteilte Schöpfung
Ein Split enthält im Wesentlichen ein Attribut im Dataset und einen Wert. Mit Hilfe der folgenden drei Teile können wir eine Aufteilung des Datensatzes erstellen:
Part1 - Berechnung des Gini-Scores: Wir haben diesen Teil gerade im vorherigen Abschnitt besprochen.
Part2- Aufteilen eines Datasets: Es kann definiert werden, dass ein Dataset in zwei Zeilenlisten mit dem Index eines Attributs und einem Aufteilungswert dieses Attributs aufgeteilt wird. Nachdem wir die beiden Gruppen - rechts und links - aus dem Datensatz erhalten haben, können wir den Wert der Aufteilung mithilfe des im ersten Teil berechneten Gini-Scores berechnen. Der geteilte Wert entscheidet, in welcher Gruppe sich das Attribut befindet.
Part3- Bewertung aller Teilungen: Der nächste Teil nach dem Auffinden des Gini-Scores und des Aufteilungsdatensatzes ist die Bewertung aller Teilungen. Zu diesem Zweck müssen wir zunächst jeden Wert überprüfen, der jedem Attribut als Kandidatensplit zugeordnet ist. Dann müssen wir die bestmögliche Aufteilung finden, indem wir die Kosten der Aufteilung bewerten. Die beste Aufteilung wird als Knoten im Entscheidungsbaum verwendet.
Einen Baum bauen
Wie wir wissen, hat ein Baum Wurzelknoten und Endknoten. Nach dem Erstellen des Stammknotens können wir den Baum erstellen, indem wir zwei Teilen folgen:
Teil 1: Erstellung des Terminalknotens
Beim Erstellen von Endknoten des Entscheidungsbaums ist es wichtig zu entscheiden, wann der wachsende Baum gestoppt oder weitere Endknoten erstellt werden sollen. Dies kann unter Verwendung von zwei Kriterien erfolgen, nämlich maximaler Baumtiefe und minimaler Knotendatensätze wie folgt:
Maximum Tree Depth- Wie der Name schon sagt, ist dies die maximale Anzahl der Knoten in einem Baum nach dem Wurzelknoten. Wir müssen aufhören, Endknoten hinzuzufügen, sobald ein Baum die maximale Tiefe erreicht hat, dh sobald ein Baum die maximale Anzahl von Endknoten erreicht hat.
Minimum Node Records- Es kann als die Mindestanzahl von Trainingsmustern definiert werden, für die ein bestimmter Knoten verantwortlich ist. Wir müssen aufhören, Endknoten hinzuzufügen, sobald der Baum diese Mindestknotendatensätze erreicht hat oder unter diesem Mindestwert liegt.
Der Endknoten wird verwendet, um eine endgültige Vorhersage zu treffen.
Teil 2: Rekursive Aufteilung
Nachdem wir verstanden haben, wann Endknoten erstellt werden müssen, können wir jetzt mit dem Erstellen unseres Baums beginnen. Rekursives Teilen ist eine Methode zum Erstellen des Baums. Bei dieser Methode können wir nach dem Erstellen eines Knotens die untergeordneten Knoten (Knoten, die einem vorhandenen Knoten hinzugefügt wurden) rekursiv für jede Datengruppe erstellen, die durch Aufteilen des Datasets generiert wird, indem dieselbe Funktion immer wieder aufgerufen wird.
Prognose
Nachdem wir einen Entscheidungsbaum erstellt haben, müssen wir eine Vorhersage darüber machen. Grundsätzlich beinhaltet die Vorhersage das Navigieren im Entscheidungsbaum mit der speziell bereitgestellten Datenzeile.
Wir können eine Vorhersage mit Hilfe der rekursiven Funktion machen, wie oben beschrieben. Dieselbe Vorhersageroutine wird erneut mit dem linken oder dem untergeordneten rechten Knoten aufgerufen.
Annahmen
Im Folgenden sind einige der Annahmen aufgeführt, die wir beim Erstellen des Entscheidungsbaums treffen:
Während der Vorbereitung von Entscheidungsbäumen dient der Trainingssatz als Wurzelknoten.
Der Entscheidungsbaumklassifizierer bevorzugt, dass die Merkmalswerte kategorisch sind. Wenn Sie fortlaufende Werte verwenden möchten, müssen diese vor der Modellbildung diskretisiert werden.
Basierend auf den Werten des Attributs werden die Datensätze rekursiv verteilt.
Der statistische Ansatz wird verwendet, um Attribute an einer beliebigen Knotenposition zu platzieren, z. B. an einem Wurzelknoten oder einem internen Knoten.
Implementierung in Python
Beispiel
Im folgenden Beispiel implementieren wir den Decision Tree-Klassifikator für Pima Indian Diabetes -
Beginnen Sie zunächst mit dem Importieren der erforderlichen Python-Pakete.
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
Laden Sie als Nächstes den Iris-Datensatz wie folgt von seinem Weblink herunter:
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()
pregnant glucose bp skin insulin bmi pedigree age label
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1
Teilen Sie nun den Datensatz wie folgt in Features und Zielvariable auf:
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable
Als nächstes werden wir die Daten in Zug- und Testaufteilung aufteilen. Der folgende Code teilt den Datensatz in 70% Trainingsdaten und 30% Testdaten auf -
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
Als nächstes trainieren Sie das Modell mit Hilfe der DecisionTreeClassifier-Klasse von sklearn wie folgt:
clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)
Endlich müssen wir Vorhersagen treffen. Dies kann mit Hilfe des folgenden Skripts erfolgen:
y_pred = clf.predict(X_test)
Als nächstes können wir die Genauigkeitsbewertung, die Verwirrungsmatrix und den Klassifizierungsbericht wie folgt erhalten:
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)
Ausgabe
Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
precision recall f1-score support
0 0.72 0.79 0.75 146
1 0.57 0.46 0.51 85
micro avg 0.67 0.67 0.67 231
macro avg 0.64 0.63 0.63 231
weighted avg 0.66 0.67 0.66 231
Accuracy: 0.670995670995671
Entscheidungsbaum visualisieren
Der obige Entscheidungsbaum kann mit Hilfe des folgenden Codes visualisiert werden:
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('Pima_diabetes_Tree.png')
Image(graph.create_png())
Einführung in den Naive Bayes-Algorithmus
Naive Bayes-Algorithmen sind eine Klassifikationstechnik, die auf der Anwendung des Bayes-Theorems mit der starken Annahme basiert, dass alle Prädiktoren unabhängig voneinander sind. Mit einfachen Worten wird davon ausgegangen, dass das Vorhandensein eines Features in einer Klasse unabhängig vom Vorhandensein eines anderen Features in derselben Klasse ist. Beispielsweise kann ein Telefon als intelligent angesehen werden, wenn es über einen Touchscreen, eine Interneteinrichtung, eine gute Kamera usw. verfügt. Obwohl alle diese Funktionen voneinander abhängig sind, tragen sie unabhängig voneinander zur Wahrscheinlichkeit bei, dass es sich bei dem Telefon um ein Smartphone handelt.
Bei der Bayes'schen Klassifikation besteht das Hauptinteresse darin, die posterioren Wahrscheinlichkeiten zu ermitteln, dh die Wahrscheinlichkeit einer Markierung bei bestimmten beobachteten Merkmalen (|). Mit Hilfe des Bayes-Theorems können wir dies in quantitativer Form wie folgt ausdrücken:
$P(L |features)= \frac{P(L)P(features |L)}{()}$Hier ist (|) die hintere Wahrscheinlichkeit der Klasse.
() ist die vorherige Klassenwahrscheinlichkeit.
(|) ist die Wahrscheinlichkeit, die die Wahrscheinlichkeit eines Prädiktors für eine bestimmte Klasse ist.
() ist die vorherige Wahrscheinlichkeit eines Prädiktors.
Modell erstellen mit Naive Bayes in Python
Die Python-Bibliothek Scikit learn ist die nützlichste Bibliothek, mit der wir ein Naive Bayes-Modell in Python erstellen können. Wir haben die folgenden drei Arten von Naive Bayes-Modellen unter Scikit Learn Python Library:
Gaußsche naive Bayes
Es ist der einfachste Naive Bayes-Klassifikator mit der Annahme, dass die Daten von jedem Etikett aus einer einfachen Gaußschen Verteilung stammen.
Multinomial Naive Bayes
Ein weiterer nützlicher Naive Bayes-Klassifikator ist Multinomial Naive Bayes, bei dem angenommen wird, dass die Merkmale aus einer einfachen Multinomialverteilung stammen. Solche naiven Bayes eignen sich am besten für die Merkmale, die diskrete Zählungen darstellen.
Bernoulli Naive Bayes
Ein weiteres wichtiges Modell ist Bernoulli Naïve Bayes, bei dem Merkmale als binär angenommen werden (0s und 1s). Die Textklassifizierung mit dem Modell "Bag of Words" kann eine Anwendung von Bernoulli Naïve Bayes sein.
Beispiel
Abhängig von unserem Datensatz können wir jedes der oben erläuterten Naive Bayes-Modelle auswählen. Hier implementieren wir das Gaußsche Naive Bayes-Modell in Python -
Wir werden mit den erforderlichen Importen wie folgt beginnen:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
Mit der Funktion make_blobs () von Scikit learn können wir nun Punkteblobs mit Gaußscher Verteilung wie folgt generieren:
from sklearn.datasets import make_blobs
X, y = make_blobs(300, 2, centers=2, random_state=2, cluster_std=1.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');
Als nächstes müssen wir für die Verwendung des Gaußschen NB-Modells das Objekt wie folgt importieren und erstellen:
from sklearn.naive_bayes import GaussianNB
model_GBN = GaussianNB()
model_GNB.fit(X, y);
Jetzt müssen wir Vorhersagen treffen. Dies kann nach dem Generieren einiger neuer Daten wie folgt erfolgen:
rng = np.random.RandomState(0)
Xnew = [-6, -14] + [14, 18] * rng.rand(2000, 2)
ynew = model_GNB.predict(Xnew)
Als nächstes zeichnen wir neue Daten, um ihre Grenzen zu finden -
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='summer', alpha=0.1)
plt.axis(lim);
Mit Hilfe der folgenden Codezeile können wir nun die hinteren Wahrscheinlichkeiten des ersten und zweiten Labels finden -
yprob = model_GNB.predict_proba(Xnew)
yprob[-10:].round(3)
Ausgabe
array([[0.998, 0.002],
[1. , 0. ],
[0.987, 0.013],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[0. , 1. ],
[0.986, 0.014]])
Für und Wider
Vorteile
Das Folgende sind einige Vorteile der Verwendung von Naive Bayes-Klassifikatoren -
Die naive Bayes-Klassifizierung ist einfach zu implementieren und schnell.
Es konvergiert schneller als diskriminierende Modelle wie die logistische Regression.
Es erfordert weniger Trainingsdaten.
Es ist von Natur aus hoch skalierbar oder sie skalieren linear mit der Anzahl der Prädiktoren und Datenpunkte.
Es kann probabilistische Vorhersagen treffen und sowohl kontinuierliche als auch diskrete Daten verarbeiten.
Der Naive Bayes-Klassifizierungsalgorithmus kann sowohl für binäre als auch für Mehrklassenklassifizierungsprobleme verwendet werden.
Nachteile
Das Folgende sind einige Nachteile der Verwendung von Naive Bayes-Klassifikatoren -
Einer der wichtigsten Nachteile der Klassifizierung von Naive Bayes ist die starke Unabhängigkeit von Merkmalen, da es im wirklichen Leben fast unmöglich ist, eine Reihe von Merkmalen zu haben, die völlig unabhängig voneinander sind.
Ein weiteres Problem bei der Naive Bayes-Klassifizierung ist die Nullfrequenz. Wenn eine kategoriale Variable eine Kategorie hat, aber im Trainingsdatensatz nicht beobachtet wird, weist das Naive Bayes-Modell ihr eine Nullwahrscheinlichkeit zu und kann keine a erstellen Prognose.
Anwendungen der naiven Bayes-Klassifikation
Im Folgenden sind einige häufige Anwendungen der Naive Bayes-Klassifizierung aufgeführt:
Real-time prediction - Aufgrund seiner einfachen Implementierung und schnellen Berechnung kann die Vorhersage in Echtzeit durchgeführt werden.
Multi-class prediction - Der Naive Bayes-Klassifizierungsalgorithmus kann verwendet werden, um die hintere Wahrscheinlichkeit mehrerer Klassen von Zielvariablen vorherzusagen.
Text classification- Aufgrund der Funktion der Mehrklassenvorhersage eignen sich Naïve Bayes-Klassifizierungsalgorithmen gut für die Textklassifizierung. Aus diesem Grund wird es auch zur Lösung von Problemen wie Spam-Filterung und Stimmungsanalyse verwendet.
Recommendation system - Neben den Algorithmen wie der kollaborativen Filterung erstellt Naïve Bayes ein Empfehlungssystem, mit dem unsichtbare Informationen gefiltert und das Wetter vorhergesagt werden kann, ob ein Benutzer die angegebene Ressource haben möchte oder nicht.
Einführung
Random Forest ist ein überwachter Lernalgorithmus, der sowohl für die Klassifizierung als auch für die Regression verwendet wird. Es wird jedoch hauptsächlich für Klassifizierungsprobleme verwendet. Da wir wissen, dass ein Wald aus Bäumen besteht und mehr Bäume einen robusteren Wald bedeuten. In ähnlicher Weise erstellt der Zufallswaldalgorithmus Entscheidungsbäume für Datenproben und erhält dann die Vorhersage von jedem von ihnen und wählt schließlich die beste Lösung durch Abstimmung aus. Es handelt sich um eine Ensemble-Methode, die besser ist als ein einzelner Entscheidungsbaum, da sie die Überanpassung durch Mittelung des Ergebnisses verringert.
Arbeiten mit dem Random Forest-Algorithmus
Wir können die Funktionsweise des Random Forest-Algorithmus anhand der folgenden Schritte verstehen:
Step1 - Beginnen Sie zunächst mit der Auswahl von Zufallsstichproben aus einem bestimmten Datensatz.
Step2- Als nächstes erstellt dieser Algorithmus für jede Stichprobe einen Entscheidungsbaum. Dann erhält es das Vorhersageergebnis von jedem Entscheidungsbaum.
Step3 - In diesem Schritt wird für jedes vorhergesagte Ergebnis abgestimmt.
Step4 - Wählen Sie zuletzt das am häufigsten gewählte Vorhersageergebnis als endgültiges Vorhersageergebnis aus.
Das folgende Diagramm zeigt die Funktionsweise -
Implementierung in Python
Beginnen Sie zunächst mit dem Importieren der erforderlichen Python-Pakete.
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
Laden Sie als Nächstes den Iris-Datensatz wie folgt von seinem Weblink herunter:
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
Als Nächstes müssen wir dem Datensatz Spaltennamen wie folgt zuweisen:
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
Jetzt müssen wir den Datensatz des Pandas-Datenrahmens wie folgt lesen:
dataset = pd.read_csv(path, names=headernames)
dataset.head()
Kelchblattlänge |
Kelchblattbreite |
Blütenblattlänge |
Blütenblattbreite |
Klasse |
|
---|---|---|---|---|---|
0 |
5.1 |
3.5 |
1.4 |
0,2 |
Iris-Setosa |
1 |
4.9 |
3.0 |
1.4 |
0,2 |
Iris-Setosa |
2 |
4.7 |
3.2 |
1.3 |
0,2 |
Iris-Setosa |
3 |
4.6 |
3.1 |
1.5 |
0,2 |
Iris-Setosa |
4 |
5.0 |
3.6 |
1.4 |
0,2 |
Iris-Setosa |
Die Datenvorverarbeitung erfolgt mithilfe der folgenden Skriptzeilen:
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
Als nächstes werden wir die Daten in Zug- und Testaufteilung aufteilen. Der folgende Code teilt den Datensatz in 70% Trainingsdaten und 30% Testdaten auf -
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)
Als nächstes trainieren Sie das Modell mit Hilfe der RandomForestClassifier-Klasse von sklearn wie folgt:
from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=50)
classifier.fit(X_train, y_train)
Endlich müssen wir Vorhersagen treffen. Dies kann mit Hilfe des folgenden Skripts erfolgen:
y_pred = classifier.predict(X_test)
Drucken Sie als Nächstes die Ergebnisse wie folgt aus:
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)
Ausgabe
Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 14
Iris-versicolor 1.00 0.95 0.97 19
Iris-virginica 0.92 1.00 0.96 12
micro avg 0.98 0.98 0.98 45
macro avg 0.97 0.98 0.98 45
weighted avg 0.98 0.98 0.98 45
Accuracy: 0.9777777777777777
Vor- und Nachteile von Random Forest
Vorteile
Das Folgende sind die Vorteile des Random Forest-Algorithmus:
Es überwindet das Problem der Überanpassung, indem die Ergebnisse verschiedener Entscheidungsbäume gemittelt oder kombiniert werden.
Zufällige Gesamtstrukturen eignen sich für eine Vielzahl von Datenelementen besser als ein einzelner Entscheidungsbaum.
Zufällige Gesamtstrukturen weisen eine geringere Varianz auf als einzelne Entscheidungsbäume.
Zufällige Wälder sind sehr flexibel und besitzen eine sehr hohe Genauigkeit.
Die Skalierung von Daten erfordert keinen zufälligen Gesamtstrukturalgorithmus. Die Genauigkeit bleibt auch nach der Bereitstellung von Daten ohne Skalierung erhalten.
Die Skalierung von Daten erfordert keinen zufälligen Gesamtstrukturalgorithmus. Die Genauigkeit bleibt auch nach der Bereitstellung von Daten ohne Skalierung erhalten.
Nachteile
Das Folgende sind die Nachteile des Random Forest-Algorithmus:
Komplexität ist der Hauptnachteil von Random Forest-Algorithmen.
Der Bau zufälliger Wälder ist viel schwieriger und zeitaufwändiger als der von Entscheidungsbäumen.
Für die Implementierung des Random Forest-Algorithmus sind mehr Rechenressourcen erforderlich.
Es ist weniger intuitiv, wenn wir eine große Sammlung von Entscheidungsbäumen haben.
Der Vorhersageprozess unter Verwendung zufälliger Gesamtstrukturen ist im Vergleich zu anderen Algorithmen sehr zeitaufwändig.
Einführung in die Regression
Regression ist ein weiteres wichtiges und weit verbreitetes statistisches und maschinelles Lerninstrument. Das Hauptziel von auf Regression basierenden Aufgaben besteht darin, Ausgabekennzeichnungen oder Antworten, die weiterhin numerische Werte sind, für die angegebenen Eingabedaten vorherzusagen. Die Ausgabe basiert auf dem, was das Modell in der Trainingsphase gelernt hat. Grundsätzlich verwenden Regressionsmodelle die Eingabedatenmerkmale (unabhängige Variablen) und ihre entsprechenden kontinuierlichen numerischen Ausgabewerte (abhängige oder Ergebnisvariablen), um die spezifische Assoziation zwischen Eingaben und entsprechenden Ausgaben zu lernen.
Arten von Regressionsmodellen
Es gibt zwei Arten von Regressionsmodellen:
Simple regression model - Dies ist das grundlegendste Regressionsmodell, bei dem Vorhersagen aus einem einzelnen, univariaten Merkmal der Daten gebildet werden.
Multiple regression model - Wie der Name schon sagt, werden in diesem Regressionsmodell die Vorhersagen aus mehreren Merkmalen der Daten gebildet.
Erstellen eines Regressors in Python
Das Regressor-Modell in Python kann genauso wie der Klassifikator erstellt werden. Scikit-learn, eine Python-Bibliothek für maschinelles Lernen, kann auch zum Erstellen eines Regressors in Python verwendet werden.
Im folgenden Beispiel erstellen wir ein grundlegendes Regressionsmodell, das eine Linie an die Daten anpasst, dh einen linearen Regressor. Die notwendigen Schritte zum Erstellen eines Regressors in Python sind wie folgt:
Schritt 1: Importieren des erforderlichen Python-Pakets
Um einen Regressor mit scikit-learn zu erstellen, müssen wir ihn zusammen mit anderen erforderlichen Paketen importieren. Wir können das mit folgendem Skript importieren -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
Schritt 2: Datensatz importieren
Nach dem Importieren des erforderlichen Pakets benötigen wir einen Datensatz, um ein Regressionsvorhersagemodell zu erstellen. Wir können es aus dem sklearn-Dataset importieren oder ein anderes gemäß unseren Anforderungen verwenden. Wir werden unsere gespeicherten Eingabedaten verwenden. Wir können es mit Hilfe des folgenden Skripts importieren -
input = r'C:\linear.txt'
Als nächstes müssen wir diese Daten laden. Wir verwenden die Funktion np.loadtxt, um sie zu laden.
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
Schritt 3: Organisieren von Daten in Trainings- und Testsätzen
Da wir unser Modell daher an unsichtbaren Daten testen müssen, werden wir unseren Datensatz in zwei Teile aufteilen: einen Trainingssatz und einen Testsatz. Der folgende Befehl führt es aus -
training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training
X_train, y_train = X[:training_samples], y[:training_samples]
X_test, y_test = X[training_samples:], y[training_samples:]
Schritt 4 - Modellbewertung und -vorhersage
Nachdem wir die Daten in Training und Test unterteilt haben, müssen wir das Modell erstellen. Zu diesem Zweck verwenden wir die LineaRegression () - Funktion von Scikit-learn. Der folgende Befehl erstellt ein lineares Regressorobjekt.
reg_linear= linear_model.LinearRegression()
Als nächstes trainieren Sie dieses Modell mit den Trainingsmustern wie folgt:
reg_linear.fit(X_train, y_train)
Jetzt müssen wir endlich die Vorhersage mit den Testdaten machen.
y_test_pred = reg_linear.predict(X_test)
Schritt 5 - Plot & Visualisierung
Nach der Vorhersage können wir es mit Hilfe des folgenden Skripts zeichnen und visualisieren -
plt.scatter(X_test, y_test, color='red')
plt.plot(X_test, y_test_pred, color='black', linewidth=2)
plt.xticks(())
plt.yticks(())
plt.show()
Ausgabe
In der obigen Ausgabe sehen wir die Regressionslinie zwischen den Datenpunkten.
Step6- Performance computation - Wir können die Leistung unseres Regressionsmodells auch mithilfe verschiedener Leistungsmetriken wie folgt berechnen: -
print("Regressor model performance:")
print("Mean absolute error(MAE) =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error(MSE) =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))
Ausgabe
Regressor model performance:
Mean absolute error(MAE) = 1.78
Mean squared error(MSE) = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09
Arten von ML-Regressionsalgorithmen
Der nützlichste und beliebteste ML-Regressionsalgorithmus ist der lineare Regressionsalgorithmus, der weiter in zwei Typen unterteilt ist, nämlich -
Einfacher linearer Regressionsalgorithmus
Algorithmus für multiple lineare Regression.
Wir werden darüber diskutieren und es im nächsten Kapitel in Python implementieren.
Anwendungen
Die Anwendungen von ML-Regressionsalgorithmen sind wie folgt:
Forecasting or Predictive analysis- Eine der wichtigsten Anwendungen der Regression ist die Vorhersage oder prädiktive Analyse. Zum Beispiel können wir das BIP, die Ölpreise oder in einfachen Worten die quantitativen Daten prognostizieren, die sich im Laufe der Zeit ändern.
Optimization- Mit Hilfe der Regression können wir Geschäftsprozesse optimieren. Beispielsweise kann ein Filialleiter ein statistisches Modell erstellen, um die Peek-Time des Kommens von Kunden zu verstehen.
Error correction- Im Geschäftsleben ist die richtige Entscheidung ebenso wichtig wie die Optimierung des Geschäftsprozesses. Regression kann uns helfen, die richtige Entscheidung zu treffen und die bereits umgesetzte Entscheidung zu korrigieren.
Economics- Es ist das am häufigsten verwendete Werkzeug in der Wirtschaft. Wir können die Regression verwenden, um Angebot, Nachfrage, Verbrauch, Lagerinvestitionen usw. vorherzusagen.
Finance- Ein Finanzunternehmen ist immer daran interessiert, das Risikoportfolio zu minimieren, und möchte wissen, welche Faktoren die Kunden beeinflussen. All dies kann mit Hilfe des Regressionsmodells vorhergesagt werden.
Einführung in die lineare Regression
Die lineare Regression kann als das statistische Modell definiert werden, das die lineare Beziehung zwischen einer abhängigen Variablen und einem gegebenen Satz unabhängiger Variablen analysiert. Eine lineare Beziehung zwischen Variablen bedeutet, dass sich der Wert einer abhängigen Variablen entsprechend ändert (erhöht oder verringert), wenn sich der Wert einer oder mehrerer unabhängiger Variablen ändert (erhöht oder verringert).
Mathematisch kann die Beziehung mit Hilfe der folgenden Gleichung dargestellt werden:
Y = mX + b
Hier ist Y die abhängige Variable, die wir vorhersagen wollen
X ist die abhängige Variable, mit der wir Vorhersagen treffen.
m ist die Steigung der Regressionslinie, die den Effekt darstellt, den X auf Y hat
b ist eine Konstante, die als Y-Achsenabschnitt bekannt ist. Wenn X = 0 wäre, wäre Y gleich b.
Darüber hinaus kann die lineare Beziehung positiver oder negativer Natur sein, wie nachstehend erläutert -
Positive lineare Beziehung
Eine lineare Beziehung wird als positiv bezeichnet, wenn sowohl die unabhängige als auch die abhängige Variable zunimmt. Es kann mit Hilfe der folgenden Grafik verstanden werden -
Negative lineare Beziehung
Eine lineare Beziehung wird als positiv bezeichnet, wenn unabhängige Erhöhungen und abhängige Variablen abnehmen. Es kann mit Hilfe der folgenden Grafik verstanden werden -
Arten der linearen Regression
Es gibt zwei Arten der linearen Regression:
Einfache lineare Regression
Multiple lineare Regression
Einfache lineare Regression (SLR)
Es ist die grundlegendste Version der linearen Regression, die eine Antwort unter Verwendung eines einzelnen Features vorhersagt. Die Annahme in SLR ist, dass die beiden Variablen linear zusammenhängen.
Python-Implementierung
Wir können SLR in Python auf zwei Arten implementieren: Zum einen müssen Sie Ihr eigenes Dataset bereitstellen und zum anderen können Sie das Dataset aus der Python-Bibliothek scikit-learn verwenden.
Example1 - Im folgenden Python-Implementierungsbeispiel verwenden wir unseren eigenen Datensatz.
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
Definieren Sie als Nächstes eine Funktion, die die wichtigen Werte für SLR berechnet -
def coef_estimation(x, y):
Die folgende Skriptzeile gibt die Anzahl der Beobachtungen n - an.
n = np.size(x)
Der Mittelwert des x- und y-Vektors kann wie folgt berechnet werden:
m_x, m_y = np.mean(x), np.mean(y)
Wir können Kreuzabweichung und Abweichung um x wie folgt finden -
SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x
Als nächstes können Regressionskoeffizienten, dh b, wie folgt berechnet werden:
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)
Als nächstes müssen wir eine Funktion definieren, die die Regressionslinie darstellt und den Antwortvektor vorhersagt -
def plot_regression_line(x, y, b):
In der folgenden Skriptzeile werden die tatsächlichen Punkte als Streudiagramm dargestellt.
plt.scatter(x, y, color = "m", marker = "o", s = 30)
Die folgende Skriptzeile sagt den Antwortvektor voraus -
y_pred = b[0] + b[1]*x
Die folgenden Skriptzeilen zeichnen die Regressionslinie und setzen die Beschriftungen darauf -
plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()
Zuletzt müssen wir die Funktion main () definieren, um einen Datensatz bereitzustellen und die oben definierte Funktion aufzurufen.
def main():
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
b = coef_estimation(x, y)
print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
plot_regression_line(x, y, b)
if __name__ == "__main__":
main()
Ausgabe
Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788
Example2 - Im folgenden Python-Implementierungsbeispiel verwenden wir den Diabetes-Datensatz von scikit-learn.
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score
Als nächstes laden wir den Diabetes-Datensatz und erstellen sein Objekt -
diabetes = datasets.load_diabetes()
Während wir SLR implementieren, werden wir nur eine Funktion wie folgt verwenden:
X = diabetes.data[:, np.newaxis, 2]
Als nächstes müssen wir die Daten wie folgt in Trainings- und Testsätze aufteilen:
X_train = X[:-30]
X_test = X[-30:]
Als nächstes müssen wir das Ziel wie folgt in Trainings- und Testsätze aufteilen:
y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]
Um das Modell zu trainieren, müssen wir nun ein lineares Regressionsobjekt wie folgt erstellen:
regr = linear_model.LinearRegression()
Als nächstes trainieren Sie das Modell mit den Trainingssätzen wie folgt:
regr.fit(X_train, y_train)
Machen Sie als Nächstes Vorhersagen mit dem Testsatz wie folgt:
y_pred = regr.predict(X_test)
Als nächstes werden wir einige Koeffizienten wie MSE, Varianzbewertung usw. wie folgt drucken:
print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f"
% mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))
Zeichnen Sie nun die Ausgaben wie folgt:
plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()
Ausgabe
Coefficients:
[941.43097333]
Mean squared error: 3035.06
Variance score: 0.41
Multiple lineare Regression (MLR)
Es ist die Erweiterung der einfachen linearen Regression, die eine Antwort unter Verwendung von zwei oder mehr Merkmalen vorhersagt. Mathematisch können wir es wie folgt erklären:
Betrachten Sie einen Datensatz mit n Beobachtungen, p Merkmalen, dh unabhängigen Variablen, und y als eine Antwort, dh abhängige Variable. Die Regressionslinie für p Merkmale kann wie folgt berechnet werden:
$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}$Hier ist h (x i ) der vorhergesagte Antwortwert und b 0 , b 1 , b 2 ... , b p sind die Regressionskoeffizienten.
Modelle mit mehreren linearen Regressionen enthalten immer die Fehler in den Daten, die als Restfehler bezeichnet werden und die Berechnung wie folgt ändern:
$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}+e_{i}$Wir können die obige Gleichung auch wie folgt schreiben:
$y_{i}=h(x_{i})+e_{i}$ $e_{i}= y_{i} - h(x_{i})$Python-Implementierung
In diesem Beispiel verwenden wir den Boston Housing-Datensatz von scikit learn -
Zunächst importieren wir die erforderlichen Pakete wie folgt:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics
Laden Sie als Nächstes den Datensatz wie folgt:
boston = datasets.load_boston(return_X_y=False)
Die folgenden Skriptzeilen definieren die Merkmalsmatrix X und den Antwortvektor Y -
X = boston.data
y = boston.target
Teilen Sie den Datensatz anschließend wie folgt in Trainings- und Testsätze auf:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)
Erstellen Sie nun ein lineares Regressionsobjekt und trainieren Sie das Modell wie folgt:
reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()
Ausgabe
Coefficients:
[-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01]
Variance score: 0.709454060230326
Annahmen
Im Folgenden sind einige Annahmen zum Datensatz aufgeführt, die vom linearen Regressionsmodell erstellt wurden:
Multi-collinearity- Das lineare Regressionsmodell geht davon aus, dass die Daten nur sehr wenig oder gar keine Multikollinearität aufweisen. Grundsätzlich tritt Multikollinearität auf, wenn die unabhängigen Variablen oder Merkmale von ihnen abhängig sind.
Auto-correlation- Eine andere Annahme Das lineare Regressionsmodell geht davon aus, dass die Daten nur sehr wenig oder gar nicht automatisch korrelieren. Grundsätzlich tritt eine Autokorrelation auf, wenn eine Abhängigkeit zwischen Restfehlern besteht.
Relationship between variables - Das lineare Regressionsmodell geht davon aus, dass die Beziehung zwischen Antwort- und Merkmalsvariablen linear sein muss.
Einführung in das Clustering
Clustering-Methoden sind eine der nützlichsten unbeaufsichtigten ML-Methoden. Diese Methoden werden verwendet, um Ähnlichkeit sowie die Beziehungsmuster zwischen Datenproben zu finden und diese Proben dann in Gruppen mit Ähnlichkeit basierend auf Merkmalen zu gruppieren.
Clustering ist wichtig, da es die intrinsische Gruppierung unter den vorhandenen unbeschrifteten Daten bestimmt. Sie machen im Grunde genommen einige Annahmen über Datenpunkte, um ihre Ähnlichkeit zu begründen. Jede Annahme erstellt unterschiedliche, aber gleichermaßen gültige Cluster.
Das folgende Diagramm zeigt beispielsweise das Clustering-System, das ähnliche Daten in verschiedenen Clustern zusammengefasst hat.
Methoden zur Clusterbildung
Es ist nicht notwendig, dass Cluster in sphärischer Form gebildet werden. Es folgen einige andere Methoden zur Clusterbildung -
Dichtebasiert
Bei diesen Verfahren werden die Cluster als dichte Region gebildet. Der Vorteil dieser Methoden besteht darin, dass sie eine gute Genauigkeit sowie eine gute Fähigkeit zum Zusammenführen von zwei Clustern aufweisen. Ex. Dichtebasiertes räumliches Clustering von Anwendungen mit Rauschen (DBSCAN), Bestellpunkte zur Identifizierung der Clusterstruktur (OPTICS) usw.
Hierarchisch
Bei diesen Methoden werden die Cluster als Baumtypstruktur basierend auf der Hierarchie gebildet. Sie haben zwei Kategorien, nämlich Agglomerativ (Bottom-up-Ansatz) und Divisiv (Top-down-Ansatz). Ex. Clustering mit Repräsentanten (CURE), Balanced iterative Reduzieren von Clustering mit Hierarchien (BIRCH) usw.
Partitionierung
Bei diesen Verfahren werden die Cluster gebildet, indem die Objekte in k Cluster aufgeteilt werden. Die Anzahl der Cluster entspricht der Anzahl der Partitionen. Ex. K-means, Clustering großer Anwendungen basierend auf randomisierter Suche (CLARANS).
Gitter
Bei diesen Methoden werden die Cluster als gitterartige Struktur gebildet. Der Vorteil dieser Methoden besteht darin, dass alle in diesen Gittern ausgeführten Clustering-Vorgänge schnell und unabhängig von der Anzahl der Datenobjekte sind. Ex. Statistisches Informationsraster (STING), Clustering in Quest (CLIQUE).
Messen der Clusterleistung
Eine der wichtigsten Überlegungen zum ML-Modell ist die Bewertung seiner Leistung, oder Sie können die Qualität des Modells sagen. Bei überwachten Lernalgorithmen ist die Beurteilung der Qualität unseres Modells einfach, da wir bereits für jedes Beispiel Beschriftungen haben.
Auf der anderen Seite sind wir bei unbeaufsichtigten Lernalgorithmen nicht so gesegnet, weil wir mit unbeschrifteten Daten arbeiten. Dennoch haben wir einige Metriken, die dem Praktiker einen Einblick in das Auftreten von Änderungen in Clustern in Abhängigkeit vom Algorithmus geben.
Bevor wir uns eingehend mit solchen Metriken befassen, müssen wir verstehen, dass diese Metriken nur die Vergleichsleistung von Modellen gegeneinander bewerten, anstatt die Gültigkeit der Modellvorhersage zu messen. Im Folgenden sind einige der Metriken aufgeführt, die wir für Clustering-Algorithmen bereitstellen können, um die Qualität des Modells zu messen.
Silhouette-Analyse
Silhouette-Analyse zur Überprüfung der Qualität des Clustering-Modells durch Messung des Abstands zwischen den Clustern. Grundsätzlich bietet es uns die Möglichkeit, die Parameter wie die Anzahl der Cluster mithilfe von zu bewertenSilhouette score. Diese Punktzahl misst, wie nahe jeder Punkt in einem Cluster an Punkten in den benachbarten Clustern liegt.
Analyse des Silhouette Score
Der Bereich der Silhouette-Punktzahl beträgt [-1, 1]. Seine Analyse ist wie folgt -
+1 Score - In der Nähe von +1 Silhouette score zeigt an, dass die Stichprobe weit von ihrem benachbarten Cluster entfernt ist.
0 Score - 0 Silhouette score zeigt an, dass sich die Stichprobe an oder sehr nahe an der Entscheidungsgrenze befindet, die zwei benachbarte Cluster trennt.
-1 Score & minusl -1 Silhouette score zeigt an, dass die Stichproben den falschen Clustern zugewiesen wurden.
Die Berechnung der Silhouette-Punktzahl kann unter Verwendung der folgenden Formel erfolgen:
= (-) / (,)
Hier = mittlere Entfernung zu den Punkten im nächsten Cluster
Und = mittlere Entfernung innerhalb des Clusters zu allen Punkten.
Davis-Bouldin-Index
Der DB-Index ist eine weitere gute Metrik für die Analyse von Clustering-Algorithmen. Mithilfe des DB-Index können wir die folgenden Punkte zum Clustering-Modell verstehen:
Ob die Cluster gut voneinander entfernt sind oder nicht?
Wie dicht sind die Cluster?
Wir können den DB-Index mit Hilfe der folgenden Formel berechnen:
$DB=\frac{1}{n}\displaystyle\sum\limits_{i=1}^n max_{j\neq{i}}\left(\frac{\sigma_{i}+\sigma_{j}}{d(c_{i},c_{j})}\right)$Hier = Anzahl der Cluster
σ i = durchschnittliche Entfernung aller Punkte im Cluster vom Clusterschwerpunkt.
Weniger der DB-Index, desto besser ist das Clustering-Modell.
Dunn Index
Es funktioniert genauso wie der DB-Index, aber es gibt folgende Punkte, in denen sich beide unterscheiden:
Der Dunn-Index berücksichtigt nur den schlimmsten Fall, dh die Cluster, die nahe beieinander liegen, während der DB-Index die Streuung und Trennung aller Cluster im Clustering-Modell berücksichtigt.
Der Dunn-Index steigt mit zunehmender Leistung, während der DB-Index besser wird, wenn die Cluster gut verteilt und dicht sind.
Wir können den Dunn-Index mit Hilfe der folgenden Formel berechnen:
$D=\frac{min_{1\leq i <{j}\leq{n}}P(i,j)}{mix_{1\leq i < k \leq n}q(k)}$Hier ist ,, = jeder Index für Cluster
= Abstand zwischen den Clustern
q = Clusterinterner Abstand
Arten von ML-Clustering-Algorithmen
Im Folgenden sind die wichtigsten und nützlichsten ML-Clustering-Algorithmen aufgeführt:
K-bedeutet Clustering
Dieser Clustering-Algorithmus berechnet die Schwerpunkte und iteriert, bis der optimale Schwerpunkt gefunden ist. Es wird davon ausgegangen, dass die Anzahl der Cluster bereits bekannt ist. Es wird auch als Flat-Clustering-Algorithmus bezeichnet. Die Anzahl von Clustern, die durch einen Algorithmus aus Daten identifiziert wurden, wird in K-Mitteln durch 'K' dargestellt.
Mean-Shift-Algorithmus
Es ist ein weiterer leistungsstarker Clustering-Algorithmus, der beim unbeaufsichtigten Lernen verwendet wird. Im Gegensatz zum K-Mittel-Clustering werden keine Annahmen getroffen, daher handelt es sich um einen nicht parametrischen Algorithmus.
Hierarchisches Clustering
Es ist ein weiterer unbeaufsichtigter Lernalgorithmus, der verwendet wird, um die unbeschrifteten Datenpunkte mit ähnlichen Eigenschaften zu gruppieren.
Wir werden all diese Algorithmen in den kommenden Kapiteln ausführlich diskutieren.
Anwendungen des Clustering
Clustering ist in den folgenden Bereichen hilfreich:
Data summarization and compression- Clustering wird häufig in den Bereichen eingesetzt, in denen Daten zusammengefasst, komprimiert und reduziert werden müssen. Die Beispiele sind Bildverarbeitung und Vektorquantisierung.
Collaborative systems and customer segmentation - Da Clustering verwendet werden kann, um ähnliche Produkte oder die gleiche Art von Benutzern zu finden, kann es im Bereich kollaborativer Systeme und Kundensegmentierung verwendet werden.
Serve as a key intermediate step for other data mining tasks- Die Clusteranalyse kann eine kompakte Zusammenfassung von Daten zur Klassifizierung, Prüfung und Erstellung von Hypothesen erstellen. Daher dient es auch als wichtiger Zwischenschritt für andere Data Mining-Aufgaben.
Trend detection in dynamic data - Clustering kann auch zur Trenderkennung in dynamischen Daten verwendet werden, indem verschiedene Cluster mit ähnlichen Trends erstellt werden.
Social network analysis- Clustering kann in der Analyse sozialer Netzwerke verwendet werden. Die Beispiele generieren Sequenzen in Bildern, Videos oder Audios.
Biological data analysis - Clustering kann auch verwendet werden, um Cluster von Bildern und Videos zu erstellen, sodass es erfolgreich bei der Analyse biologischer Daten verwendet werden kann.
Einführung in den K-Means-Algorithmus
Der K-Mittel-Clustering-Algorithmus berechnet die Schwerpunkte und iteriert, bis der optimale Schwerpunkt gefunden ist. Es wird davon ausgegangen, dass die Anzahl der Cluster bereits bekannt ist. Es wird auch genanntflat clusteringAlgorithmus. Die Anzahl von Clustern, die durch Algorithmus aus Daten identifiziert wurden, wird in K-Mitteln durch 'K' dargestellt.
Bei diesem Algorithmus werden die Datenpunkte einem Cluster so zugewiesen, dass die Summe des quadratischen Abstands zwischen den Datenpunkten und dem Schwerpunkt minimal wäre. Es versteht sich, dass eine geringere Variation innerhalb der Cluster zu ähnlicheren Datenpunkten innerhalb desselben Clusters führt.
Arbeitsweise des K-Means-Algorithmus
Wir können die Funktionsweise des K-Means-Clustering-Algorithmus mithilfe der folgenden Schritte verstehen:
Step1 - Zuerst müssen wir die Anzahl der Cluster K angeben, die von diesem Algorithmus generiert werden müssen.
Step2- Wählen Sie als Nächstes zufällig K Datenpunkte aus und weisen Sie jeden Datenpunkt einem Cluster zu. Klassifizieren Sie die Daten in einfachen Worten anhand der Anzahl der Datenpunkte.
Step3 - Jetzt werden die Cluster-Schwerpunkte berechnet.
Step4 - Als nächstes wiederholen Sie Folgendes, bis wir den optimalen Schwerpunkt gefunden haben, bei dem es sich um die Zuordnung von Datenpunkten zu den Clustern handelt, die sich nicht mehr ändern. -
4.1 - Zunächst wird die Summe der quadratischen Abstände zwischen Datenpunkten und Schwerpunkten berechnet.
4.2 - Jetzt müssen wir jeden Datenpunkt dem Cluster zuweisen, der näher als der andere Cluster (Schwerpunkt) liegt.
4.3 - Berechnen Sie zuletzt die Schwerpunkte für die Cluster, indem Sie den Durchschnitt aller Datenpunkte dieses Clusters berechnen.
K-Mittel folgt Expectation-MaximizationAnsatz zur Lösung des Problems. Der Erwartungsschritt wird verwendet, um die Datenpunkte dem nächstgelegenen Cluster zuzuweisen, und der Maximierungsschritt wird verwendet, um den Schwerpunkt jedes Clusters zu berechnen.
Während wir mit dem K-Means-Algorithmus arbeiten, müssen wir uns um folgende Dinge kümmern:
Bei der Arbeit mit Clustering-Algorithmen einschließlich K-Means wird empfohlen, die Daten zu standardisieren, da solche Algorithmen entfernungsbasierte Messungen verwenden, um die Ähnlichkeit zwischen Datenpunkten zu bestimmen.
Aufgrund der iterativen Natur von K-Means und der zufälligen Initialisierung von Zentroiden können K-Means in einem lokalen Optimum bleiben und möglicherweise nicht zum globalen Optimum konvergieren. Aus diesem Grund wird empfohlen, unterschiedliche Initialisierungen von Zentroiden zu verwenden.
Implementierung in Python
Die folgenden zwei Beispiele für die Implementierung des K-Means-Clustering-Algorithmus helfen uns beim besseren Verständnis:
Beispiel 1
Es ist ein einfaches Beispiel, um zu verstehen, wie k-means funktioniert. In diesem Beispiel werden wir zuerst einen 2D-Datensatz mit 4 verschiedenen Blobs generieren und danach den k-means-Algorithmus anwenden, um das Ergebnis zu sehen.
Zunächst importieren wir die erforderlichen Pakete -
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
Der folgende Code generiert die 2D-Datei mit vier Blobs:
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)
Als nächstes hilft uns der folgende Code bei der Visualisierung des Datensatzes -
plt.scatter(X[:, 0], X[:, 1], s=20);
plt.show()
Erstellen Sie als Nächstes ein Objekt aus KMeans und geben Sie die Anzahl der Cluster an, trainieren Sie das Modell und führen Sie die Vorhersage wie folgt durch:
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
Mit Hilfe des folgenden Codes können wir nun die vom Python-Schätzer k-means ausgewählten Cluster-Zentren zeichnen und visualisieren.
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()
Beispiel 2
Gehen wir zu einem anderen Beispiel über, in dem wir K-Means-Clustering auf einfache Ziffern anwenden. K-means versucht, ähnliche Ziffern zu identifizieren, ohne die ursprünglichen Etiketteninformationen zu verwenden.
Zunächst importieren wir die erforderlichen Pakete -
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
Laden Sie als Nächstes das Ziffern-Dataset von sklearn und erstellen Sie ein Objekt daraus. Wir können die Anzahl der Zeilen und Spalten in diesem Datensatz auch wie folgt ermitteln:
from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape
Ausgabe
(1797, 64)
Die obige Ausgabe zeigt, dass dieser Datensatz 1797 Beispiele mit 64 Funktionen enthält.
Wir können das Clustering wie in Beispiel 1 oben durchführen -
kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape
Ausgabe
(10, 64)
Die obige Ausgabe zeigt, dass K-means 10 Cluster mit 64 Merkmalen erstellt hat.
fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks=[], yticks=[])
axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)
Ausgabe
Als Ausgabe erhalten wir das folgende Bild, das Cluster-Zentren zeigt, die mit k-Mitteln gelernt wurden.
In den folgenden Codezeilen werden die gelernten Cluster-Labels mit den darin enthaltenen True-Labels abgeglichen.
from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
mask = (clusters == i)
labels[mask] = mode(digits.target[mask])[0]
Als nächstes können wir die Genauigkeit wie folgt überprüfen:
from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)
Ausgabe
0.7935447968836951
Die obige Ausgabe zeigt, dass die Genauigkeit bei etwa 80% liegt.
Vorteile und Nachteile
Vorteile
Im Folgenden sind einige Vorteile von K-Means-Clustering-Algorithmen aufgeführt:
Es ist sehr einfach zu verstehen und umzusetzen.
Wenn wir dann eine große Anzahl von Variablen haben, wäre K-means schneller als hierarchisches Clustering.
Bei der Neuberechnung von Zentroiden kann eine Instanz den Cluster ändern.
Engere Cluster werden mit K-Mitteln im Vergleich zu hierarchischen Clustern gebildet.
Nachteile
Im Folgenden sind einige Nachteile von K-Means-Clustering-Algorithmen aufgeführt:
Es ist etwas schwierig, die Anzahl der Cluster vorherzusagen, dh den Wert von k.
Die Ausgabe wird stark von anfänglichen Eingaben wie der Anzahl der Cluster (Wert von k) beeinflusst.
Die Reihenfolge der Daten hat starken Einfluss auf die endgültige Ausgabe.
Es ist sehr empfindlich gegen Neuskalierungen. Wenn wir unsere Daten durch Normalisierung oder Standardisierung neu skalieren, ändert sich die Ausgabe vollständig.
Es ist nicht gut, Clusterarbeit zu leisten, wenn die Cluster eine komplizierte geometrische Form haben.
Anwendungen des K-Means-Clustering-Algorithmus
Die Hauptziele der Clusteranalyse sind:
Um eine aussagekräftige Intuition aus den Daten zu erhalten, mit denen wir arbeiten.
Cluster-dann-vorhersagen, wo verschiedene Modelle für verschiedene Untergruppen erstellt werden.
Um die oben genannten Ziele zu erreichen, funktioniert K-means Clustering gut genug. Es kann in folgenden Anwendungen verwendet werden -
Marktsegmentierung
Dokumentenclustering
Bildsegmentierung
Bildkompression
Kundensegmentierung
Analyse des Trends bei dynamischen Daten
Einführung in den Mean-Shift-Algorithmus
Wie bereits erwähnt, handelt es sich um einen weiteren leistungsstarken Clustering-Algorithmus, der beim unbeaufsichtigten Lernen verwendet wird. Im Gegensatz zu K-Means-Clustering werden keine Annahmen getroffen. Daher ist es ein nicht parametrischer Algorithmus.
Der Mean-Shift-Algorithmus weist den Clustern die Datenpunkte grundsätzlich iterativ zu, indem er Punkte in Richtung der höchsten Dichte von Datenpunkten, dh des Cluster-Schwerpunkts, verschiebt.
Der Unterschied zwischen dem K-Means-Algorithmus und der Mittelwertverschiebung besteht darin, dass später die Anzahl der Cluster nicht im Voraus angegeben werden muss, da die Anzahl der Cluster durch den Algorithmus für die Daten bestimmt wird.
Funktionsweise des Mean-Shift-Algorithmus
Wir können die Funktionsweise des Mean-Shift-Clustering-Algorithmus mithilfe der folgenden Schritte verstehen:
Step1 - Beginnen Sie zunächst mit den Datenpunkten, die einem eigenen Cluster zugewiesen sind.
Step2 - Als nächstes berechnet dieser Algorithmus die Schwerpunkte.
Step3 - In diesem Schritt wird die Position neuer Zentroide aktualisiert.
Step4 - Jetzt wird der Prozess iteriert und in den Bereich mit höherer Dichte verschoben.
Step5 - Endlich wird es gestoppt, sobald die Zentroide eine Position erreichen, von der aus sie sich nicht weiter bewegen können.
Implementierung in Python
Es ist ein einfaches Beispiel, um zu verstehen, wie der Mean-Shift-Algorithmus funktioniert. In diesem Beispiel wird zunächst ein 2D-Datensatz mit 4 verschiedenen Blobs generiert und anschließend der Mean-Shift-Algorithmus angewendet, um das Ergebnis anzuzeigen.
%matplotlib inline
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.datasets.samples_generator import make_blobs
centers = [[3,3,3],[4,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 700, centers = centers, cluster_std = 0.5)
plt.scatter(X[:,0],X[:,1])
plt.show()
ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 3)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
marker=".",color='k', s=20, linewidths = 5, zorder=10)
plt.show()
Ausgabe
[[ 2.98462798 9.9733794 10.02629344]
[ 3.94758484 4.99122771 4.99349433]
[ 3.00788996 3.03851268 2.99183033]]
Estimated clusters: 3
Vorteile und Nachteile
Vorteile
Im Folgenden sind einige Vorteile des Mean-Shift-Clustering-Algorithmus aufgeführt:
Es muss keine Modellannahme wie bei K-Mitteln oder Gaußschen Gemischen gemacht werden.
Es kann auch die komplexen Cluster modellieren, die eine nicht konvexe Form haben.
Es wird nur ein Parameter namens Bandbreite benötigt, der automatisch die Anzahl der Cluster bestimmt.
Es gibt kein Problem mit lokalen Minima wie bei K-means.
Kein Problem durch Ausreißer.
Nachteile
Im Folgenden sind einige Nachteile des Mean-Shift-Clustering-Algorithmus aufgeführt:
Der Mean-Shift-Algorithmus funktioniert nicht gut bei hohen Dimensionen, bei denen sich die Anzahl der Cluster abrupt ändert.
Wir haben keine direkte Kontrolle über die Anzahl der Cluster, aber in einigen Anwendungen benötigen wir eine bestimmte Anzahl von Clustern.
Es kann nicht zwischen sinnvollen und bedeutungslosen Modi unterscheiden.
Einführung in das hierarchische Clustering
Hierarchisches Clustering ist ein weiterer unbeaufsichtigter Lernalgorithmus, mit dem die unbeschrifteten Datenpunkte mit ähnlichen Eigenschaften zusammengefasst werden. Hierarchische Clustering-Algorithmen lassen sich in die folgenden zwei Kategorien einteilen:
Agglomerative hierarchical algorithms- In agglomerativen hierarchischen Algorithmen wird jeder Datenpunkt als einzelner Cluster behandelt und anschließend die Clusterpaare nacheinander zusammengeführt oder agglomeriert (Bottom-up-Ansatz). Die Hierarchie der Cluster wird als Dendrogramm oder Baumstruktur dargestellt.
Divisive hierarchical algorithms - Andererseits werden in divisiven hierarchischen Algorithmen alle Datenpunkte als ein großer Cluster behandelt, und beim Clustering wird der eine große Cluster in verschiedene kleine Cluster aufgeteilt (Top-down-Ansatz).
Schritte zum Durchführen eines agglomerativen hierarchischen Clusters
Wir werden das am häufigsten verwendete und wichtigste hierarchische Clustering erklären, dh das Agglomerativ. Die Schritte, um dasselbe auszuführen, sind wie folgt:
Step1- Behandeln Sie jeden Datenpunkt als einzelnen Cluster. Daher werden wir zu Beginn beispielsweise K-Cluster haben. Die Anzahl der Datenpunkte beträgt zu Beginn ebenfalls K.
Step2- In diesem Schritt müssen wir nun einen großen Cluster bilden, indem wir zwei Schrankdatenpunkte verbinden. Dies führt zu insgesamt K-1-Clustern.
Step3- Um mehr Cluster zu bilden, müssen wir zwei Closet-Cluster verbinden. Dies führt zu insgesamt K-2-Clustern.
Step4 - Um nun einen großen Cluster zu bilden, wiederholen Sie die obigen drei Schritte, bis K 0 wird, dh keine Datenpunkte mehr zum Verbinden übrig sind.
Step5 - Nach der Erstellung eines einzelnen großen Clusters werden Dendrogramme verwendet, um je nach Problem in mehrere Cluster zu unterteilen.
Rolle von Dendrogrammen bei der agglomerativen hierarchischen Clusterbildung
Wie wir im letzten Schritt besprochen haben, beginnt die Rolle des Dendrogramms, sobald sich der große Cluster gebildet hat. Das Dendrogramm wird verwendet, um die Cluster abhängig von unserem Problem in mehrere Cluster verwandter Datenpunkte aufzuteilen. Es kann anhand des folgenden Beispiels verstanden werden:
Beispiel 1
Um dies zu verstehen, beginnen wir mit dem Importieren der erforderlichen Bibliotheken wie folgt:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
Als nächstes zeichnen wir die Datenpunkte, die wir für dieses Beispiel genommen haben -
X = np.array([[7,8],[12,20],[17,19],[26,15],[32,37],[87,75],[73,85], [62,80],[73,60],[87,96],])
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
plt.annotate(label,xy=(x, y), xytext=(-3, 3),textcoords='offset points', ha='right', va='bottom')
plt.show()
Aus dem obigen Diagramm ist sehr leicht ersichtlich, dass wir zwei Cluster in unseren Datenpunkten haben, aber in den Daten der realen Welt können Tausende von Clustern vorhanden sein. Als nächstes zeichnen wir die Dendrogramme unserer Datenpunkte mithilfe der Scipy-Bibliothek -
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked, orientation='top',labels=labelList, distance_sort='descending',show_leaf_counts=True)
plt.show()
Sobald der große Cluster gebildet ist, wird der längste vertikale Abstand ausgewählt. Eine vertikale Linie wird dann durch sie gezogen, wie in der folgenden Abbildung gezeigt. Wenn die horizontale Linie an zwei Punkten die blaue Linie kreuzt, beträgt die Anzahl der Cluster zwei.
Als Nächstes müssen wir die Klasse für das Clustering importieren und ihre Methode fit_predict aufrufen, um den Cluster vorherzusagen. Wir importieren die AgglomerativeClustering-Klasse der sklearn.cluster-Bibliothek -
from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
cluster.fit_predict(X)
Zeichnen Sie als Nächstes den Cluster mithilfe des folgenden Codes:
plt.scatter(X[:,0],X[:,1], c=cluster.labels_, cmap='rainbow')
Das obige Diagramm zeigt die beiden Cluster aus unseren Datenpunkten.
Beispiel2
Nachdem wir das Konzept der Dendrogramme aus dem oben diskutierten einfachen Beispiel verstanden haben, gehen wir zu einem anderen Beispiel über, in dem wir Cluster des Datenpunkts im Pima Indian Diabetes Dataset mithilfe hierarchischer Cluster erstellen.
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
data.shape
(768, 9)
data.head()
Sl. Nein. | preg | Plas | Pres | Haut | Prüfung | Masse | pedi | Alter | Klasse |
---|---|---|---|---|---|---|---|---|---|
0 | 6 | 148 | 72 | 35 | 0 | 33.6 | 0,627 | 50 | 1 |
1 | 1 | 85 | 66 | 29 | 0 | 26.6 | 0,351 | 31 | 0 |
2 | 8 | 183 | 64 | 0 | 0 | 23.3 | 0,672 | 32 | 1 |
3 | 1 | 89 | 66 | 23 | 94 | 28.1 | 0,167 | 21 | 0 |
4 | 0 | 137 | 40 | 35 | 168 | 43.1 | 2.288 | 33 | 1 |
patient_data = data.iloc[:, 3:5].values
import scipy.cluster.hierarchy as shc
plt.figure(figsize=(10, 7))
plt.title("Patient Dendograms")
dend = shc.dendrogram(shc.linkage(data, method='ward'))
from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
cluster.fit_predict(patient_data)
plt.figure(figsize=(10, 7))
plt.scatter(patient_data[:,0], patient_data[:,1], c=cluster.labels_, cmap='rainbow')
Einführung
Der K-Nearest Neighbours (KNN) -Algorithmus ist eine Art von überwachtem ML-Algorithmus, der sowohl für Klassifizierungs- als auch für Regressionsvorhersageprobleme verwendet werden kann. Es wird jedoch hauptsächlich zur Klassifizierung von Vorhersageproblemen in der Industrie verwendet. Die folgenden zwei Eigenschaften würden KNN gut definieren -
Lazy learning algorithm - KNN ist ein fauler Lernalgorithmus, da er keine spezielle Trainingsphase hat und alle Daten für das Training während der Klassifizierung verwendet.
Non-parametric learning algorithm - KNN ist auch ein nicht parametrischer Lernalgorithmus, da er nichts über die zugrunde liegenden Daten annimmt.
Arbeitsweise des KNN-Algorithmus
Der KNN-Algorithmus (K-Nearest Neighbours) verwendet die Merkmalsähnlichkeit, um die Werte neuer Datenpunkte vorherzusagen. Dies bedeutet ferner, dass dem neuen Datenpunkt ein Wert zugewiesen wird, der darauf basiert, wie genau er mit den Punkten im Trainingssatz übereinstimmt. Wir können seine Arbeitsweise anhand der folgenden Schritte verstehen:
Step1- Für die Implementierung eines Algorithmus benötigen wir einen Datensatz. Während des ersten Schritts von KNN müssen wir also sowohl die Trainings- als auch die Testdaten laden.
Step2- Als nächstes müssen wir den Wert von K wählen, dh die nächsten Datenpunkte. K kann eine beliebige ganze Zahl sein.
Step3 - Führen Sie für jeden Punkt in den Testdaten Folgendes aus:
3.1- Berechnen Sie den Abstand zwischen den Testdaten und jeder Zeile der Trainingsdaten mit Hilfe einer der folgenden Methoden: Euklidische, Manhattan- oder Hamming-Entfernung. Die am häufigsten verwendete Methode zur Berechnung der Entfernung ist die euklidische.
3.2 - Sortieren Sie sie nun basierend auf dem Entfernungswert in aufsteigender Reihenfolge.
3.3 - Als nächstes werden die obersten K Zeilen aus dem sortierten Array ausgewählt.
3.4 - Jetzt wird dem Testpunkt eine Klasse zugewiesen, die auf der häufigsten Klasse dieser Zeilen basiert.
Step4 - Ende
Beispiel
Das Folgende ist ein Beispiel, um das Konzept von K und die Funktionsweise des KNN-Algorithmus zu verstehen:
Angenommen, wir haben einen Datensatz, der wie folgt dargestellt werden kann:
Jetzt müssen wir einen neuen Datenpunkt mit einem schwarzen Punkt (bei Punkt 60, 60) in eine blaue oder rote Klasse klassifizieren. Wir gehen von K = 3 aus, dh es würden drei nächstgelegene Datenpunkte gefunden. Es ist im nächsten Diagramm dargestellt -
Im obigen Diagramm sehen wir die drei nächsten Nachbarn des Datenpunkts mit einem schwarzen Punkt. Unter diesen drei liegen zwei in der roten Klasse, daher wird der schwarze Punkt auch in der roten Klasse zugeordnet.
Implementierung in Python
Wie wir wissen, kann der KNN-Algorithmus (K-Nearest Neighbours) sowohl für die Klassifizierung als auch für die Regression verwendet werden. Das Folgende sind die Rezepte in Python, um KNN sowohl als Klassifikator als auch als Regressor zu verwenden -
KNN als Klassifikator
Beginnen Sie zunächst mit dem Importieren der erforderlichen Python-Pakete.
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
Laden Sie als Nächstes den Iris-Datensatz wie folgt von seinem Weblink herunter:
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
Als Nächstes müssen wir dem Datensatz Spaltennamen wie folgt zuweisen:
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
Jetzt müssen wir den Datensatz des Pandas-Datenrahmens wie folgt lesen:
dataset = pd.read_csv(path, names=headernames)
dataset.head()
Sl. Nein. | Kelchblattlänge | Kelchblattbreite | Blütenblattlänge | Blütenblattbreite | Klasse |
---|---|---|---|---|---|
0 | 5.1 | 3.5 | 1.4 | 0,2 | Iris-Setosa |
1 | 4.9 | 3.0 | 1.4 | 0,2 | Iris-Setosa |
2 | 4.7 | 3.2 | 1.3 | 0,2 | Iris-Setosa |
3 | 4.6 | 3.1 | 1.5 | 0,2 | Iris-Setosa |
4 | 5.0 | 3.6 | 1.4 | 0,2 | Iris-Setosa |
Die Datenvorverarbeitung erfolgt mithilfe der folgenden Skriptzeilen:
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
Als nächstes werden wir die Daten in Zug- und Testaufteilung aufteilen. Der folgende Code teilt den Datensatz in 60% Trainingsdaten und 40% Testdaten auf -
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)
Als nächstes wird die Datenskalierung wie folgt durchgeführt:
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
Als nächstes trainieren Sie das Modell mit Hilfe der KNeighborsClassifier-Klasse von sklearn wie folgt:
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=8)
classifier.fit(X_train, y_train)
Endlich müssen wir Vorhersagen treffen. Dies kann mit Hilfe des folgenden Skripts erfolgen:
y_pred = classifier.predict(X_test)
Drucken Sie als Nächstes die Ergebnisse wie folgt aus:
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)
Ausgabe
Confusion Matrix:
[[21 0 0]
[ 0 16 0]
[ 0 7 16]]
Classification Report:
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 21
Iris-versicolor 0.70 1.00 0.82 16
Iris-virginica 1.00 0.70 0.82 23
micro avg 0.88 0.88 0.88 60
macro avg 0.90 0.90 0.88 60
weighted avg 0.92 0.88 0.88 60
Accuracy: 0.8833333333333333
KNN als Regressor
Beginnen Sie zunächst mit dem Importieren der erforderlichen Python-Pakete.
import numpy as np
import pandas as pd
Laden Sie als Nächstes den Iris-Datensatz wie folgt von seinem Weblink herunter:
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
Als Nächstes müssen wir dem Datensatz Spaltennamen wie folgt zuweisen:
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
Jetzt müssen wir den Datensatz des Pandas-Datenrahmens wie folgt lesen:
data = pd.read_csv(url, names=headernames)
array = data.values
X = array[:,:2]
Y = array[:,2]
data.shape
output:(150, 5)
Als nächstes importieren Sie KNeighborsRegressor aus sklearn, um es an das Modell anzupassen -
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=10)
knnr.fit(X, y)
Endlich können wir die MSE wie folgt finden -
print ("The MSE is:",format(np.power(y-knnr.predict(X),2).mean()))
Ausgabe
The MSE is: 0.12226666666666669
Vor- und Nachteile von KNN
Vorteile
Es ist sehr einfach, Algorithmen zu verstehen und zu interpretieren.
Dies ist sehr nützlich für nichtlineare Daten, da in diesem Algorithmus keine Datenannahme vorliegt.
Es ist ein vielseitiger Algorithmus, da wir ihn sowohl zur Klassifizierung als auch zur Regression verwenden können.
Es hat eine relativ hohe Genauigkeit, aber es gibt viel besser überwachte Lernmodelle als KNN.
Nachteile
Es ist ein rechenintensiver Algorithmus, da alle Trainingsdaten gespeichert werden.
Im Vergleich zu anderen überwachten Lernalgorithmen ist ein hoher Speicherbedarf erforderlich.
Die Vorhersage ist bei großen N langsam.
Es ist sehr empfindlich gegenüber dem Umfang der Daten sowie irrelevanten Merkmalen.
Anwendungen von KNN
Im Folgenden sind einige Bereiche aufgeführt, in denen KNN erfolgreich angewendet werden kann:
Bankensystem
KNN kann im Bankensystem verwendet werden, um vorherzusagen, ob eine Person für die Kreditgenehmigung geeignet ist? Hat diese Person ähnliche Eigenschaften wie die Säumigen?
Berechnung der Bonität
KNN-Algorithmen können verwendet werden, um die Bonität einer Person durch Vergleich mit Personen mit ähnlichen Merkmalen zu ermitteln.
Politik
Mit Hilfe von KNN-Algorithmen können wir einen potenziellen Wähler in verschiedene Klassen wie "Will Vote", "Will not Vote", "Will Vote to Party 'Congress" und "Will Vote to Party' BJP" einteilen.
Andere Bereiche, in denen der KNN-Algorithmus verwendet werden kann, sind Spracherkennung, Handschrifterkennung, Bilderkennung und Videoerkennung.
Es gibt verschiedene Metriken, mit denen wir die Leistung von ML-Algorithmen, Klassifizierungs- und Regressionsalgorithmen bewerten können. Wir müssen die Metriken zur Bewertung der ML-Leistung sorgfältig auswählen, weil -
Wie die Leistung von ML-Algorithmen gemessen und verglichen wird, hängt vollständig von der von Ihnen gewählten Metrik ab.
Wie Sie die Wichtigkeit verschiedener Merkmale im Ergebnis gewichten, wird vollständig von der von Ihnen gewählten Metrik beeinflusst.
Leistungsmetriken für Klassifizierungsprobleme
Wir haben die Klassifizierung und ihre Algorithmen in den vorherigen Kapiteln erörtert. Hier werden verschiedene Leistungsmetriken erörtert, mit denen Vorhersagen für Klassifizierungsprobleme bewertet werden können.
Verwirrung Matrix
Dies ist der einfachste Weg, um die Leistung eines Klassifizierungsproblems zu messen, bei dem die Ausgabe aus zwei oder mehr Klassentypen bestehen kann. Eine Verwirrungsmatrix ist nichts anderes als eine Tabelle mit zwei Dimensionen, nämlich. "Ist" und "Vorausgesagt" und außerdem haben beide Dimensionen "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)", wie unten gezeigt -
Die mit der Verwirrungsmatrix verbundenen Begriffe werden wie folgt erläutert:
True Positives (TP) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 1 ist.
True Negatives (TN) - Dies ist der Fall, wenn sowohl die tatsächliche Klasse als auch die vorhergesagte Klasse des Datenpunkts 0 sind.
False Positives (FP) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 0 und die vorhergesagte Datenpunktklasse 1 ist.
False Negatives (FN) - Dies ist der Fall, wenn die tatsächliche Datenpunktklasse 1 und die vorhergesagte Datenpunktklasse 0 ist.
Wir können die Confusion_matrix-Funktion von sklearn.metrics verwenden, um die Confusion Matrix unseres Klassifizierungsmodells zu berechnen.
Klassifizierungsgenauigkeit
Es ist die häufigste Leistungsmetrik für Klassifizierungsalgorithmen. Es kann als die Anzahl der korrekten Vorhersagen definiert werden, die als Verhältnis aller gemachten Vorhersagen gemacht werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$Accuracy =\frac{TP+TN}{+++}$Wir können die Genauigkeit_score-Funktion von sklearn.metrics verwenden, um die Genauigkeit unseres Klassifizierungsmodells zu berechnen.
Klassifizierungsbericht
Dieser Bericht besteht aus den Bewertungen Precisions, Recall, F1 und Support. Sie werden wie folgt erklärt -
Präzision
Präzision, die beim Abrufen von Dokumenten verwendet wird, kann als die Anzahl der korrekten Dokumente definiert werden, die von unserem ML-Modell zurückgegeben werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$Precision=\frac{TP}{TP+FP}$Rückruf oder Empfindlichkeit
Der Rückruf kann als die Anzahl der von unserem ML-Modell zurückgegebenen Positiven definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$Recall =\frac{TP}{TP+FN}$Spezifität
Die Spezifität kann im Gegensatz zum Rückruf als die Anzahl der von unserem ML-Modell zurückgegebenen Negative definiert werden. Wir können es leicht durch Verwirrungsmatrix mit Hilfe der folgenden Formel berechnen -
$Specificity =\frac{TN}{TN+FP}$Unterstützung
Unterstützung kann als die Anzahl der Stichproben der tatsächlichen Antwort definiert werden, die in jeder Klasse von Zielwerten liegt.
F1-Punktzahl
Diese Punktzahl gibt uns das harmonische Mittel für Präzision und Erinnerung. Mathematisch gesehen ist die F1-Punktzahl der gewichtete Durchschnitt der Präzision und des Rückrufs. Der beste Wert von F1 wäre 1 und der schlechteste wäre 0. Wir können den F1-Wert mit Hilfe der folgenden Formel berechnen:
= ∗ (∗) / (+)
Die F1-Punktzahl hat den gleichen relativen Beitrag von Präzision und Rückruf.
Wir können die Klassifizierungsfunktion von sklearn.metrics verwenden, um den Klassifizierungsbericht unseres Klassifizierungsmodells abzurufen.
AUC (Area Under ROC-Kurve)
AUC (Area Under Curve) -ROC (Receiver Operating Characteristic) ist eine Leistungsmetrik, die auf variierenden Schwellenwerten für Klassifizierungsprobleme basiert. Wie der Name schon sagt, ist ROC eine Wahrscheinlichkeitskurve und AUC misst die Trennbarkeit. In einfachen Worten sagt uns die AUC-ROC-Metrik über die Fähigkeit des Modells, die Klassen zu unterscheiden. Je höher die AUC, desto besser das Modell.
Mathematisch kann es durch Auftragen von TPR (True Positive Rate), dh Empfindlichkeit oder Rückruf, gegen FPR (False Positive Rate), dh 1-Spezifität, bei verschiedenen Schwellenwerten erstellt werden. Das folgende Diagramm zeigt ROC, AUC mit TPR auf der y-Achse und FPR auf der x-Achse -
Wir können die Funktion roc_auc_score von sklearn.metrics verwenden, um AUC-ROC zu berechnen.
LOGLOSS (logarithmischer Verlust)
Es wird auch als logistischer Regressionsverlust oder Kreuzentropieverlust bezeichnet. Es wird im Wesentlichen anhand von Wahrscheinlichkeitsschätzungen definiert und misst die Leistung eines Klassifizierungsmodells, bei dem die Eingabe ein Wahrscheinlichkeitswert zwischen 0 und 1 ist. Es kann klarer verstanden werden, indem es mit Genauigkeit unterschieden wird. Wie wir wissen, ist Genauigkeit die Anzahl der Vorhersagen (vorhergesagter Wert = tatsächlicher Wert) in unserem Modell, während Log Loss die Unsicherheit unserer Vorhersage ist, basierend darauf, wie stark sie vom tatsächlichen Etikett abweicht. Mithilfe des Log Loss-Werts können wir die Leistung unseres Modells genauer anzeigen. Wir können die log_loss-Funktion von sklearn.metrics verwenden, um den Protokollverlust zu berechnen.
Beispiel
Das Folgende ist ein einfaches Rezept in Python, das uns einen Einblick gibt, wie wir die oben erläuterten Leistungsmetriken für das binäre Klassifizierungsmodell verwenden können -
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import log_loss
X_actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
Y_predic = [1, 0, 1, 1, 1, 0, 1, 1, 0, 0]
results = confusion_matrix(X_actual, Y_predic)
print ('Confusion Matrix :')
print(results)
print ('Accuracy Score is',accuracy_score(X_actual, Y_predic))
print ('Classification Report : ')
print (classification_report(X_actual, Y_predic))
print('AUC-ROC:',roc_auc_score(X_actual, Y_predic))
print('LOGLOSS Value is',log_loss(X_actual, Y_predic))
Ausgabe
Confusion Matrix :
[[3 3]
[1 3]]
Accuracy Score is 0.6
Classification Report :
precision recall f1-score support
0 0.75 0.50 0.60 6
1 0.50 0.75 0.60 4
micro avg 0.60 0.60 0.60 10
macro avg 0.62 0.62 0.60 10
weighted avg 0.65 0.60 0.60 10
AUC-ROC: 0.625
LOGLOSS Value is 13.815750437193334
Leistungsmetriken für Regressionsprobleme
Wir haben die Regression und ihre Algorithmen in früheren Kapiteln erörtert. Hier werden verschiedene Leistungsmetriken diskutiert, mit denen Vorhersagen für Regressionsprobleme bewertet werden können.
Mittlerer absoluter Fehler (MAE)
Dies ist die einfachste Fehlermetrik, die bei Regressionsproblemen verwendet wird. Es ist im Grunde die Summe des Durchschnitts der absoluten Differenz zwischen den vorhergesagten und den tatsächlichen Werten. Mit MAE können wir in einfachen Worten eine Vorstellung davon bekommen, wie falsch die Vorhersagen waren. MAE gibt nicht die Richtung des Modells an, dh keine Angabe über eine Underperformance oder Überperformance des Modells. Das Folgende ist die Formel zur Berechnung von MAE -
$MAE = \frac{1}{n}\sum|Y -\hat{Y}|$Hier = Ist-Ausgabewerte
Und $\hat{Y}$= Voraussichtliche Ausgabewerte.
Wir können die Funktion mean_absolute_error von sklearn.metrics verwenden, um MAE zu berechnen.
Mittlerer quadratischer Fehler (MSE)
MSE ist wie die MAE, aber der einzige Unterschied besteht darin, dass die Differenz zwischen tatsächlichen und vorhergesagten Ausgabewerten quadriert wird, bevor sie alle summiert werden, anstatt den absoluten Wert zu verwenden. Der Unterschied kann in der folgenden Gleichung festgestellt werden -
$MSE = \frac{1}{n}\sum(Y -\hat{Y})$Hier = Ist-Ausgabewerte
Und $\hat{Y}$ = Voraussichtliche Ausgabewerte.
Wir können die Funktion mean_squared_error von sklearn.metrics verwenden, um MSE zu berechnen.
R im Quadrat (R 2 )
R Die quadratische Metrik wird im Allgemeinen zu Erklärungszwecken verwendet und gibt einen Hinweis auf die Güte oder Anpassung eines Satzes vorhergesagter Ausgabewerte an die tatsächlichen Ausgabewerte. Die folgende Formel hilft uns, es zu verstehen -
$R^{2} = 1 -\frac{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\hat{Y_{i}})^2}{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\bar{Y_i)^2}}$In der obigen Gleichung ist der Zähler MSE und der Nenner ist die Varianz der Werte.
Wir können die Funktion r2_score von sklearn.metrics verwenden, um den R-Quadrat-Wert zu berechnen.
Beispiel
Das Folgende ist ein einfaches Rezept in Python, das uns einen Einblick gibt, wie wir die oben erläuterten Leistungsmetriken für das Regressionsmodell verwenden können -
from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
X_actual = [5, -1, 2, 10]
Y_predic = [3.5, -0.9, 2, 9.9]
print ('R Squared =',r2_score(X_actual, Y_predic))
print ('MAE =',mean_absolute_error(X_actual, Y_predic))
print ('MSE =',mean_squared_error(X_actual, Y_predic))
Ausgabe
R Squared = 0.9656060606060606
MAE = 0.42499999999999993
MSE = 0.5674999999999999
Einführung
Um Ergebnisse erfolgreich auszuführen und zu produzieren, muss ein maschinelles Lernmodell einige Standardworkflows automatisieren. Der Prozess der Automatisierung dieser Standardworkflows kann mithilfe von Scikit-Learn-Pipelines durchgeführt werden. Aus Sicht eines Datenwissenschaftlers ist Pipeline ein verallgemeinertes, aber sehr wichtiges Konzept. Grundsätzlich ermöglicht es den Datenfluss von seinem Rohformat zu einigen nützlichen Informationen. Die Funktionsweise von Pipelines kann anhand des folgenden Diagramms verstanden werden:
Die Blöcke von ML-Pipelines sind wie folgt:
Data ingestion- Wie der Name schon sagt, werden die Daten zur Verwendung in ML-Projekten importiert. Die Daten können in Echtzeit oder in Stapeln aus einzelnen oder mehreren Systemen extrahiert werden. Dies ist einer der schwierigsten Schritte, da die Qualität der Daten das gesamte ML-Modell beeinflussen kann.
Data Preparation- Nach dem Import der Daten müssen wir Daten vorbereiten, die für unser ML-Modell verwendet werden sollen. Die Datenvorverarbeitung ist eine der wichtigsten Techniken zur Datenaufbereitung.
ML Model Training- Der nächste Schritt ist das Training unseres ML-Modells. Wir haben verschiedene ML-Algorithmen wie überwachte, unbeaufsichtigte Verstärkung, um die Merkmale aus Daten zu extrahieren und Vorhersagen zu treffen.
Model Evaluation- Als nächstes müssen wir das ML-Modell bewerten. Im Falle einer AutoML-Pipeline kann das ML-Modell mithilfe verschiedener statistischer Methoden und Geschäftsregeln ausgewertet werden.
ML Model retraining- Bei einer AutoML-Pipeline ist es nicht erforderlich, dass das erste Modell das beste ist. Das erste Modell wird als Basismodell betrachtet und wir können es wiederholt trainieren, um die Genauigkeit des Modells zu erhöhen.
Deployment- Endlich müssen wir das Modell bereitstellen. Dieser Schritt umfasst das Anwenden und Migrieren des Modells auf Geschäftsvorgänge zur Verwendung.
Herausforderungen bei ML-Pipelines
Um ML-Pipelines zu erstellen, stehen Datenwissenschaftler vor vielen Herausforderungen. Diese Herausforderungen fallen in die folgenden drei Kategorien:
Datenqualität
Der Erfolg eines ML-Modells hängt stark von der Datenqualität ab. Wenn die Daten, die wir dem ML-Modell zur Verfügung stellen, nicht genau, zuverlässig und robust sind, werden wir mit falschen oder irreführenden Ausgaben enden.
Datenzuverlässigkeit
Eine weitere Herausforderung im Zusammenhang mit ML-Pipelines ist die Zuverlässigkeit der Daten, die wir dem ML-Modell zur Verfügung stellen. Wie wir wissen, kann es verschiedene Quellen geben, aus denen Datenwissenschaftler Daten erfassen können. Um jedoch die besten Ergebnisse zu erzielen, muss sichergestellt sein, dass die Datenquellen zuverlässig und vertrauenswürdig sind.
Datenzugriff
Um die besten Ergebnisse aus ML-Pipelines zu erzielen, müssen die Daten selbst zugänglich sein, was eine Konsolidierung, Bereinigung und Kuratierung der Daten erfordert. Aufgrund der Datenzugriffseigenschaft werden Metadaten mit neuen Tags aktualisiert.
Modellierung der ML-Pipeline und Datenvorbereitung
Datenlecks, die vom Trainingsdatensatz bis zum Testdatensatz auftreten, sind ein wichtiges Thema, mit dem sich Datenwissenschaftler bei der Vorbereitung von Daten für das ML-Modell befassen müssen. Im Allgemeinen verwendet der Datenwissenschaftler zum Zeitpunkt der Datenaufbereitung Techniken wie Standardisierung oder Normalisierung für den gesamten Datensatz, bevor er lernt. Diese Techniken können uns jedoch nicht dabei helfen, Daten zu verlieren, da der Trainingsdatensatz durch den Umfang der Daten im Testdatensatz beeinflusst worden wäre.
Durch die Verwendung von ML-Pipelines können wir diesen Datenverlust verhindern, da Pipelines sicherstellen, dass die Datenaufbereitung wie die Standardisierung auf jede Falte unseres Kreuzvalidierungsverfahrens beschränkt ist.
Beispiel
Das folgende Beispiel in Python zeigt den Workflow für die Datenvorbereitung und Modellbewertung. Zu diesem Zweck verwenden wir den Pima Indian Diabetes-Datensatz von Sklearn. Zunächst erstellen wir eine Pipeline, die die Daten standardisiert. Anschließend wird ein lineares diskriminatives Analysemodell erstellt und schließlich die Pipeline mithilfe einer 10-fachen Kreuzvalidierung bewertet.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
Als nächstes erstellen wir eine Pipeline mit Hilfe des folgenden Codes:
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('lda', LinearDiscriminantAnalysis()))
model = Pipeline(estimators)
Zuletzt werden wir diese Pipeline bewerten und ihre Genauigkeit wie folgt ausgeben:
kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7790148448043184
Die obige Ausgabe ist die Zusammenfassung der Genauigkeit des Setups im Datensatz.
Modellierung der ML-Pipeline und Merkmalsextraktion
Datenverlust kann auch beim Merkmalsextraktionsschritt des ML-Modells auftreten. Aus diesem Grund sollten die Verfahren zur Merkmalsextraktion auch eingeschränkt werden, um Datenlecks in unserem Trainingsdatensatz zu verhindern. Wie bei der Datenaufbereitung können wir durch die Verwendung von ML-Pipelines auch diesen Datenverlust verhindern. Zu diesem Zweck kann FeatureUnion verwendet werden, ein von ML-Pipelines bereitgestelltes Tool.
Beispiel
Das folgende Beispiel in Python zeigt den Workflow zur Merkmalsextraktion und Modellbewertung. Zu diesem Zweck verwenden wir den Pima Indian Diabetes-Datensatz von Sklearn.
Zunächst werden 3 Merkmale mit PCA (Principal Component Analysis) extrahiert. Anschließend werden 6 Merkmale mit der statistischen Analyse extrahiert. Nach der Merkmalsextraktion werden die Ergebnisse mehrerer Merkmalsauswahl- und Extraktionsverfahren mithilfe von kombiniert
FeatureUnion-Tool. Zuletzt wird ein logistisches Regressionsmodell erstellt und die Pipeline mithilfe einer 10-fachen Kreuzvalidierung bewertet.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
Als Nächstes wird die Feature-Union wie folgt erstellt:
features = []
features.append(('pca', PCA(n_components=3)))
features.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(features)
Als Nächstes wird die Pipeline mithilfe der folgenden Skriptzeilen erstellt:
estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)
Zuletzt werden wir diese Pipeline bewerten und ihre Genauigkeit wie folgt ausgeben:
kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7789811066126855
Die obige Ausgabe ist die Zusammenfassung der Genauigkeit des Setups im Datensatz.
Leistungsverbesserung mit Ensembles
Ensembles können das Ergebnis des maschinellen Lernens verbessern, indem sie mehrere Modelle kombinieren. Grundsätzlich bestehen Ensemblemodelle aus mehreren individuell trainierten überwachten Lernmodellen, und ihre Ergebnisse werden auf verschiedene Weise zusammengeführt, um eine bessere Vorhersageleistung im Vergleich zu einem einzelnen Modell zu erzielen. Ensemble-Methoden können in folgende zwei Gruppen unterteilt werden:
Sequentielle Ensemble-Methoden
Wie der Name schon sagt, werden bei solchen Ensemble-Methoden die Basislerner nacheinander generiert. Die Motivation solcher Methoden besteht darin, die Abhängigkeit zwischen Basislernenden auszunutzen.
Parallele Ensemblemethoden
Wie der Name schon sagt, werden bei solchen Ensemble-Methoden die Basislerner parallel generiert. Die Motivation solcher Methoden besteht darin, die Unabhängigkeit unter den Basislernenden auszunutzen.
Ensemble-Lernmethoden
Das Folgende sind die beliebtesten Ensemble-Lernmethoden, dh die Methoden zum Kombinieren der Vorhersagen aus verschiedenen Modellen -
Absacken
Der Begriff Bagging wird auch als Bootstrap-Aggregation bezeichnet. Bei Absackmethoden versucht das Ensemble-Modell, die Vorhersagegenauigkeit zu verbessern und die Modellvarianz zu verringern, indem Vorhersagen einzelner Modelle kombiniert werden, die über zufällig generierte Trainingsmuster trainiert wurden. Die endgültige Vorhersage des Ensemblemodells erfolgt durch Berechnung des Durchschnitts aller Vorhersagen aus den einzelnen Schätzern. Eines der besten Beispiele für Absackmethoden sind zufällige Wälder.
Erhöhen
Bei der Boosting-Methode besteht das Hauptprinzip beim Erstellen eines Ensemble-Modells darin, es schrittweise zu erstellen, indem jeder Basismodellschätzer nacheinander trainiert wird. Wie der Name schon sagt, werden im Grunde mehrere Wochenbasis-Lerner kombiniert, die nacheinander über mehrere Iterationen von Trainingsdaten trainiert werden, um ein leistungsstarkes Ensemble aufzubauen. Während des Trainings von Wochenbasislernern werden den zuvor falsch klassifizierten Lernenden höhere Gewichte zugewiesen. Das Beispiel für eine Boosting-Methode ist AdaBoost.
Wählen
In diesem Ensemble-Lernmodell werden mehrere Modelle unterschiedlicher Typen erstellt und einige einfache Statistiken wie die Berechnung des Mittelwerts oder Medians usw. verwendet, um die Vorhersagen zu kombinieren. Diese Vorhersage dient als zusätzliche Eingabe für das Training, um die endgültige Vorhersage zu treffen.
Bagging Ensemble-Algorithmen
Das Folgende sind drei Bagging-Ensemble-Algorithmen -
Eingesackter Entscheidungsbaum
Wie wir wissen, funktionieren Bagging-Ensemble-Methoden gut mit Algorithmen mit hoher Varianz, und in diesem Zusammenhang ist der Entscheidungsbaum-Algorithmus der beste. Im folgenden Python-Rezept werden wir ein Bagged Decision Tree Ensemble-Modell erstellen, indem wir die BaggingClassifier-Funktion von sklearn mit DecisionTreeClasifier (einem Klassifizierungs- und Regressionsbaum-Algorithmus) für den Diabetes-Datensatz von Pima Indians verwenden.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()
Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume -
num_trees = 150
Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:
model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)
Berechnen und drucken Sie das Ergebnis wie folgt:
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7733766233766234
Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 77% unseres Bagged Decision Tree Classifier-Modells erhalten haben.
Zufälliger Wald
Es ist eine Erweiterung von eingesackten Entscheidungsbäumen. Für einzelne Klassifikatoren werden die Stichproben des Trainingsdatensatzes mit Ersatz entnommen, aber die Bäume sind so konstruiert, dass die Korrelation zwischen ihnen verringert wird. Außerdem wird eine zufällige Teilmenge von Merkmalen berücksichtigt, um jeden Teilungspunkt auszuwählen, anstatt gierig den besten Teilungspunkt bei der Konstruktion jedes Baums auszuwählen.
Im folgenden Python-Rezept werden wir ein Modell eines zufälligen Waldensembles in Säcken erstellen, indem wir die RandomForestClassifier-Klasse von sklearn für den Diabetes-Datensatz der Pima-Indianer verwenden.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -
num_trees = 150
max_features = 5
Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:
model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)
Berechnen und drucken Sie das Ergebnis wie folgt:
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7629357484620642
Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 76% unseres eingesackten zufälligen Waldklassifikatormodells erhalten haben.
Zusätzliche Bäume
Es ist eine weitere Erweiterung der Methode des Bagged Decision Tree Ensembles. Bei dieser Methode werden die Zufallsbäume aus den Stichproben des Trainingsdatensatzes erstellt.
Im folgenden Python-Rezept werden wir ein zusätzliches Baumensemble-Modell erstellen, indem wir die ExtraTreesClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians verwenden.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -
num_trees = 150
max_features = 5
Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:
model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)
Berechnen und drucken Sie das Ergebnis wie folgt:
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7551435406698566
Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 75,5% für unser klassifiziertes Modell mit zusätzlichen Bäumen erhalten haben.
Boosten von Ensemble-Algorithmen
Das Folgende sind die beiden am häufigsten verwendeten Boosting-Ensemble-Algorithmen:
AdaBoost
Es ist einer der erfolgreichsten Boosting-Ensemble-Algorithmen. Der Hauptschlüssel dieses Algorithmus liegt in der Art und Weise, wie die Instanzen im Datensatz gewichtet werden. Aus diesem Grund muss der Algorithmus beim Erstellen nachfolgender Modelle den Instanzen weniger Aufmerksamkeit schenken.
Im folgenden Python-Rezept erstellen wir ein Ada Boost-Ensemble-Modell für die Klassifizierung unter Verwendung der AdaBoostClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
seed = 5
kfold = KFold(n_splits=10, random_state=seed)
Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -
num_trees = 50
Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:
model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)
Berechnen und drucken Sie das Ergebnis wie folgt:
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7539473684210527
Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 75% unseres AdaBoost-Klassifikator-Ensemble-Modells erhalten haben.
Stochastische Gradientenverstärkung
Es wird auch als Gradientenverstärkungsmaschine bezeichnet. Im folgenden Python-Rezept erstellen wir ein stochastisches Gradienten-Boostingensemble-Modell für die Klassifizierung unter Verwendung der GradientBoostingClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima-Indianern.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
seed = 5
kfold = KFold(n_splits=10, random_state=seed)
Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -
num_trees = 50
Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:
model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)
Berechnen und drucken Sie das Ergebnis wie folgt:
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7746582365003418
Die obige Ausgabe zeigt, dass wir bei unserem Gradient Boosting-Klassifikator-Ensemble-Modell eine Genauigkeit von ca. 77,5% erreicht haben.
Voting Ensemble-Algorithmen
Wie bereits erwähnt, werden bei der Abstimmung zunächst zwei oder mehr eigenständige Modelle aus dem Trainingsdatensatz erstellt. Anschließend wird das Modell von einem Abstimmungsklassifizierer umschlossen und der Durchschnitt der Vorhersagen des Untermodells ermittelt, wann immer neue Daten benötigt werden.
Im folgenden Python-Rezept erstellen wir ein Voting-Ensemble-Modell für die Klassifizierung unter Verwendung der VotingClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians. Wir kombinieren die Vorhersagen der logistischen Regression, des Entscheidungsbaumklassifikators und der SVM für ein Klassifizierungsproblem wie folgt:
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:
kfold = KFold(n_splits=10, random_state=7)
Als nächstes müssen wir Untermodelle wie folgt erstellen:
estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))
Erstellen Sie nun das Voting-Ensemble-Modell, indem Sie die Vorhersagen der oben erstellten Untermodelle kombinieren.
ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())
Ausgabe
0.7382262474367738
Die obige Ausgabe zeigt, dass wir eine Genauigkeit von rund 74% unseres Voting-Klassifikator-Ensemble-Modells erhalten haben.
Leistungsverbesserung durch Algorithmus-Tuning
Wie wir wissen, sind ML-Modelle so parametrisiert, dass ihr Verhalten an ein bestimmtes Problem angepasst werden kann. Algorithmus-Tuning bedeutet, die beste Kombination dieser Parameter zu finden, damit die Leistung des ML-Modells verbessert werden kann. Dieser Prozess wird manchmal als Hyperparameteroptimierung bezeichnet, und die Parameter des Algorithmus selbst werden als Hyperparameter bezeichnet, und die vom ML-Algorithmus gefundenen Koeffizienten werden als Parameter bezeichnet.
Hier werden wir einige Methoden zur Optimierung von Algorithmusparametern diskutieren, die von Python Scikit-learn bereitgestellt werden.
Optimierung der Rastersuchparameter
Dies ist ein Ansatz zur Parametereinstellung. Der entscheidende Punkt bei der Arbeit dieser Methode ist, dass sie das Modell für jede mögliche Kombination von in einem Raster angegebenen Algorithmusparametern methodisch erstellt und bewertet. Daher können wir sagen, dass dieser Algorithmus Suchcharakter hat.
Beispiel
Im folgenden Python-Rezept führen wir eine Rastersuche durch, indem wir die GridSearchCV-Klasse von sklearn verwenden, um verschiedene Alpha-Werte für den Ridge Regression-Algorithmus für den Diabetes-Datensatz von Pima Indians zu bewerten.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
import numpy
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Bewerten Sie als Nächstes die verschiedenen Alpha-Werte wie folgt:
alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)
Jetzt müssen wir die Rastersuche auf unser Modell anwenden -
model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)
Drucken Sie das Ergebnis mit der folgenden Skriptzeile aus:
print(grid.best_score_)
print(grid.best_estimator_.alpha)
Ausgabe
0.2796175593129722
1.0
Die obige Ausgabe gibt uns die optimale Punktzahl und den Satz von Parametern im Raster, die diese Punktzahl erreicht haben. Der Alpha-Wert beträgt in diesem Fall 1,0.
Optimierung der Zufallssuchparameter
Dies ist ein Ansatz zur Parametereinstellung. Der entscheidende Punkt bei der Arbeit dieser Methode ist, dass sie die Algorithmusparameter aus einer zufälligen Verteilung für eine feste Anzahl von Iterationen abtastet.
Beispiel
Im folgenden Python-Rezept führen wir eine Zufallssuche durch, indem wir die RandomizedSearchCV-Klasse von sklearn verwenden, um verschiedene Alpha-Werte zwischen 0 und 1 für den Ridge Regression-Algorithmus für den Diabetes-Datensatz von Pima Indians zu bewerten.
Importieren Sie zunächst die erforderlichen Pakete wie folgt:
import numpy
from pandas import read_csv
from scipy.stats import uniform
from sklearn.linear_model import Ridge
from sklearn.model_selection import RandomizedSearchCV
Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
Bewerten Sie als Nächstes die verschiedenen Alpha-Werte des Ridge-Regressionsalgorithmus wie folgt:
param_grid = {'alpha': uniform()}
model = Ridge()
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=50,
random_state=7)
random_search.fit(X, Y)
Drucken Sie das Ergebnis mit der folgenden Skriptzeile aus:
print(random_search.best_score_)
print(random_search.best_estimator_.alpha)
Ausgabe
0.27961712703051084
0.9779895119966027
0.9779895119966027
Die obige Ausgabe gibt uns die optimale Punktzahl, ähnlich wie bei der Rastersuche.