Maschinelles Lernen und neuronale Netze - Seite 68
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
4.6 NumPy-Zufallszahlengeneratoren (L04: Wissenschaftliches Rechnen in Python)
4.6 NumPy-Zufallszahlengeneratoren (L04: Wissenschaftliches Rechnen in Python)
In diesem Video geben wir einen kurzen Überblick über Zufallszahlengeneratoren in NumPy. Wir werden zwar nicht alle verschiedenen Methoden zum Generieren von Zufallszahlen in NumPy behandeln, unser Fokus liegt jedoch auf dem Verständnis von Zufallszahlengeneratoren und ihrem praktischen Nutzen.
Beginnen wir mit einem einfachen Beispiel. Wir beginnen mit dem Import von NumPy, der Bibliothek, die wir für die Zufallszahlengenerierung verwenden werden. NumPy verfügt über ein Zufallsmodul, das verschiedene Funktionen zum Zeichnen von Zufallszahlen enthält. Obwohl die Dokumentation, auf die wir verweisen, etwas veraltet ist, bietet sie eine hilfreiche Liste verschiedener Funktionen und deren Beschreibungen.
Eine häufig verwendete Funktion ist random.rand, die Zufallsstichproben aus einer gleichmäßigen Verteilung generiert. Durch Angabe der Form des gewünschten Arrays (z. B. 2x3) erzeugt diese Funktion ein zweidimensionales Array, das mit Zufallszahlen aus einer gleichmäßigen Verteilung gefüllt ist.
NumPy bietet auch andere Funktionen, wie zum Beispiel random.random, das zufällige Floats im halboffenen Intervall [0, 1) generiert. Mit der Funktion random.randn können Sie auch Zufallsstichproben aus verschiedenen Verteilungen ziehen, beispielsweise aus der Standardnormalverteilung.
Manchmal möchten wir möglicherweise sicherstellen, dass unser Code bei jeder Ausführung dieselben zufälligen Ergebnisse liefert. Dies ist für die Reproduzierbarkeit nützlich, insbesondere beim Teilen von Code oder beim Vergleich verschiedener Methoden. Um dies zu erreichen, können wir am Anfang unseres Codes oder Notizbuchs einen zufälligen Startwert festlegen. Der Startwert ist eine beliebige Zahl, die sicherstellt, dass jedes Mal die gleiche Folge von Zufallszahlen generiert wird.
Durch das Festlegen eines Zufallsstartwerts bleiben die generierten Zufallszahlen während mehrerer Codedurchläufe konstant. Es ist jedoch wichtig zu beachten, dass die Ergebnisse abweichen, wenn wir eine weitere Zufallsstichprobe ziehen, da es sich immer noch um einen Zufallsprozess handelt.
Konsistente Ergebnisse können besonders bei Anwendungen des maschinellen Lernens nützlich sein, beispielsweise beim Mischen von Daten oder beim Testen von Implementierungen. Wenn Sie beispielsweise einen Datensatz aufteilen, stellen Sie durch Festlegen eines zufälligen Startwerts sicher, dass die Aufteilung jedes Mal gleich ist. Dies ermöglicht einen genauen Vergleich und eine Bewertung verschiedener Methoden.
Um die Zufälligkeit detaillierter zu verwalten, können wir in NumPy ein Zufallszustandsobjekt verwenden. Das Zufallszustandsobjekt verfügt über einen eigenen Zufallszahlengenerator, der eine differenzierte Kontrolle darüber ermöglicht, wo die Zufälligkeit angewendet wird. Durch die Erstellung mehrerer Zufallszustandsobjekte können wir unterschiedliche Zufälligkeitsquellen in unserem Code haben. Dies ist besonders vorteilhaft, wenn wir möchten, dass bestimmte Teile des Codes konsistente Ergebnisse liefern, während andere Teile unterschiedliche Zufallszahlen generieren.
Während die alte Klasse random_state immer noch weit verbreitet ist, empfiehlt die NumPy-Community jetzt die Verwendung des neuen Zufallsgenerators. Dieser neue Generator verwendet eine andere Methode zum Generieren von Zufallszahlen, aber für die meisten einfachen Anwendungen macht die Wahl zwischen den beiden keinen spürbaren Unterschied. Am wichtigsten ist die Festlegung eines zufälligen Startwerts zur Reproduzierbarkeit.
Es ist wichtig, sich daran zu erinnern, dass Zufallszahlengeneratoren im Code nicht wirklich zufällig, sondern pseudozufällig sind. Sie verwenden Algorithmen, um Zahlenfolgen zu erzeugen, die den Zufall nachahmen. In unserem Kontext liegt der Schwerpunkt eher auf Konsistenz und Reproduzierbarkeit als auf dem spezifischen Algorithmus, der für die Zufallszahlengenerierung verwendet wird.
Zusammenfassend lässt sich sagen, dass bei der Arbeit mit Zufallszahlengeneratoren in NumPy die Wahl des Generators selbst nicht kritisch ist. Entscheidend ist die Festlegung eines zufälligen Startwerts, um konsistente und reproduzierbare Ergebnisse sicherzustellen. Dies ist besonders wertvoll, wenn Sie Code teilen, Aufgaben einreichen oder verschiedene Methoden vergleichen.
4.7 NumPy-Arrays umformen (L04: Wissenschaftliches Rechnen in Python)
4.7 NumPy-Arrays umformen (L04: Wissenschaftliches Rechnen in Python)
Endlich nähern wir uns dem Abschluss der NumPy-Reihe. Da nur noch drei Videos übrig sind, sind wir bei einem wichtigen Thema angelangt: der Umgestaltung von NumPy-Arrays. Das Umformen von Arrays ist von entscheidender Bedeutung, wenn wir unsere Daten in die gewünschte Form umwandeln müssen, beispielsweise eine Matrix in einen Vektor umwandeln oder umgekehrt. Ich habe dieses Konzept in der Einführungsvorlesung kurz erwähnt, in der ich über MNIST gesprochen habe. Um diesen Prozess zu veranschaulichen, betrachten wir ein vereinfachtes Beispiel.
Stellen Sie sich vor, wir haben ein Array mit den Abmessungen 28 x 28, das ein Bild darstellt. Normalerweise würde jedes Element im Array einem Pixelwert entsprechen. Der Einfachheit halber gehen wir jedoch davon aus, dass jedes Element nur eine einzelne Ziffer ist. Wir haben also ein 28 x 28 großes Array, das ein Ziffernbild darstellt. Wenn wir dieses Array jedoch als Merkmalsvektor für einen Klassifikator verwenden möchten, müssen wir es in einen einzelnen langen Vektor mit 784 Elementen (28 * 28) umformen. Jedes Trainingsbeispiel ist ein Bild und jedes Bild verfügt über 784 Funktionen.
Das Umformen eines Arrays kann mit der Reshape-Funktion in NumPy erfolgen. Zum Beispiel können wir einen Vektor 1, 2, 3, 4, 5, 6 in eine 2 x 3-Matrix umformen:
Beim Umformen eines Arrays wird eine Speicheransicht und kein neues Array erstellt. Diese Speicheransicht ermöglicht es uns, das umgeformte Array zu manipulieren, ohne die Daten zu duplizieren. Um dies zu überprüfen, können wir die Funktion np.may_share_memory verwenden, obwohl diese möglicherweise nicht immer ein 100 % genaues Ergebnis liefert.
Die Verwendung von -1 als Dimension beim Umformen ist eine praktische Funktion in NumPy. Es fungiert als Platzhalter und ermöglicht es der Methode, die geeignete Dimension basierend auf der Gesamtzahl der Elemente zu bestimmen. Wenn wir beispielsweise einen Vektor mit sechs Elementen haben und ihn mit -1, 2 umformen, wird -1 durch 3 ersetzt, da es nur eine Möglichkeit gibt, drei Zeilen mit zwei Spalten anzuordnen, um sechs Elemente zu erhalten. Dieses Platzhalterkonzept funktioniert mit beliebig vielen Dimensionen.
Darüber hinaus können wir die Reshape-Funktion verwenden, um ein Array zu reduzieren. Indem wir einen einzelnen Wert als Dimension angeben (z. B. reshape(6)), können wir das Array in einen eindimensionalen Vektor umwandeln. In der Praxis ist die Verwendung von -1 praktischer, da dadurch die Notwendigkeit entfällt, sich die Größe zu merken. Beispielsweise erzielt reshape(-1) das gleiche Ergebnis wie reshape(6) für ein Array mit sechs Elementen.
Es gibt mehrere Möglichkeiten, ein Array in NumPy zu reduzieren. Die Reshape-Funktion mit -1 erstellt eine Speicheransicht, während die Flatten-Funktion ebenfalls ein Array flacht, aber eine Kopie erstellt. Eine andere Funktion, ravel, wird ebenfalls zum Reduzieren von Arrays verwendet. Die Bestimmung der Unterschiede zwischen diesen Funktionen wäre ein gutes Quiz zur Selbsteinschätzung.
Schließlich können wir Arrays in NumPy verketten und sie entlang bestimmter Achsen kombinieren. Beim Verketten von Arrays entlang der ersten Achse ähnelt es dem Anhängen von Elementen in Python-Listen. Wenn wir beispielsweise zwei Arrays mit einer Achse haben, werden sie durch die Verkettung entlang dieser Achse untereinander gestapelt.
Das Umformen von NumPy-Arrays ist wichtig, um Daten in die gewünschte Form zu bringen. Das Verständnis der verschiedenen Methoden, Platzhalter und Verkettungstechniken ermöglicht es uns, effektiv mit Arrays zu arbeiten und unseren Code zu optimieren. Im nächsten Video werde ich NumPy-Vergleichsoperatoren und -Masken besprechen, die in Kombination mit Umformen leistungsstarke Werkzeuge sind.
4.8 NumPy-Vergleichsoperatoren und -masken (L04: Wissenschaftliches Rechnen in Python)
4.8 NumPy-Vergleichsoperatoren und -masken (L04: Wissenschaftliches Rechnen in Python)
In NumPy bieten Vergleichsoperatoren und Auswahlmasken viel Flexibilität und die Arbeit damit kann sehr angenehm sein. In einem früheren Video haben wir Masken und Vergleichsoperatoren vorgestellt. Jetzt wollen wir uns einige zusätzliche Tricks ansehen, die Sie bei der Arbeit mit ihnen anwenden können.
Beginnen wir mit einem einfachen Beispiel. Angenommen, wir haben der Einfachheit halber ein NumPy-Array [1, 2, 3, 4]. Wir können eine Maske definieren, um bestimmte Werte aus dem Array auszuwählen. Diese Maske ist ein boolesches Array, das heißt, sie enthält Wahr- oder Falschwerte. Wir können die Maske erstellen, indem wir eine Bedingung angeben, z. B. die Auswahl von Werten, die größer als zwei sind. Das resultierende Maskenarray hat die gleiche Form wie das ursprüngliche Array, wobei True-Werte die Positionen angeben, an denen die Bedingung wahr ist, und False-Werte die Positionen angeben, an denen die Bedingung falsch ist.
In Python gibt es eine praktische Beziehung zwischen booleschen Werten und ganzen Zahlen: True entspricht 1 und False entspricht 0. Diese Beziehung ermöglicht es uns, interessante Operationen durchzuführen. Beispielsweise können wir die if-Anweisung verwenden, um zu überprüfen, ob eine Bedingung wahr ist, indem wir einfach if condition: schreiben. Wir können den Not-Operator auch verwenden, um zu überprüfen, ob eine Bedingung falsch ist, indem wir if not condition: schreiben. Diese Ansätze bieten besser lesbaren Code als der explizite Vergleich der Bedingung mit „True“ oder „False“.
Eine weitere nützliche Funktion ist die Möglichkeit, die Anzahl der Elemente in einem Array zu zählen, die einer bestimmten Bedingung entsprechen. Indem wir den Summenoperator auf eine Maske anwenden, können wir die Anzahl der wahren Werte in der Maske zählen. Wenn wir beispielsweise eine Maske haben, die Werte größer als zwei auswählt, können wir die Anzahl solcher Werte zählen, indem wir sum(mask) aufrufen. Ebenso können wir die Anzahl der False-Werte zählen, indem wir die Summe von der Gesamtzahl der Elemente im Array subtrahieren.
Um die Anzahl der negativen Werte in einem Array zu zählen, können wir die NumPy-Invertierungsfunktion verwenden, die die booleschen Werte in der Maske umdreht. Indem wir „invert“ auf eine Maske anwenden und dann „sum“ aufrufen, können wir die Anzahl der False-Werte zählen (die nun die negativen Werte darstellen).
Ein Array zu binärisieren, also in eine binäre Darstellung umzuwandeln, ist ein weiterer häufiger Vorgang. Dies können wir erreichen, indem wir den Positionen, an denen eine Bedingung wahr ist, einen bestimmten Wert und den Positionen, an denen die Bedingung falsch ist, einen anderen Wert zuweisen. Allerdings kann es mühsam sein, den gesamten Vorgang abzutippen. Glücklicherweise bietet NumPy die Where-Funktion, die diesen Prozess vereinfacht. Die Where-Funktion nimmt eine Bedingung entgegen und weist den Positionen, an denen die Bedingung wahr ist, den ersten Wert zu, und den Positionen, an denen die Bedingung falsch ist, den zweiten Wert. Mit where können wir ein Array ganz einfach mit nur einer Codezeile binarisieren.
Neben Vergleichsoperatoren bietet NumPy logische Operatoren wie and, or, xor und not. Diese Operatoren können mit Masken kombiniert werden, um komplexere Bedingungen zu erstellen. Mit dem Operator „or“ können wir beispielsweise Werte auswählen, die größer als drei oder kleiner als zwei sind. Durch die Kombination mehrerer Bedingungen mithilfe logischer Operatoren können wir komplexe Auswahlmasken erstellen, die unseren Anforderungen entsprechen.
Diese booleschen Masken, logischen Operatoren und Vergleichsoperatoren in NumPy sind unglaublich nützlich, wenn Sie mit Datensätzen arbeiten und Entscheidungsbaumregeln implementieren. Wir werden diese Konzepte in den kommenden Videos weiter untersuchen. Im nächsten Video werden wir uns mit den grundlegenden Konzepten der linearen Algebra in NumPy befassen. Bleiben Sie dran!
4.9 Grundlagen der linearen NumPy-Algebra (L04: Wissenschaftliches Rechnen in Python)
4.9 Grundlagen der linearen NumPy-Algebra (L04: Wissenschaftliches Rechnen in Python)
In diesem Video möchte ich mich mit einigen grundlegenden Konzepten der linearen Algebra befassen, insbesondere im Kontext von NumPy. Obwohl wir in diesem Kurs die lineare Algebra nicht ausführlich nutzen werden, ist es wichtig, grundlegende Operationen wie Vektorskalarprodukte und Matrixmultiplikation zu beherrschen. Wie ich bereits erwähnt habe, ermöglicht uns die Verwendung der linearen Algebra-Notation, Code zu schreiben, der effizienter und prägnanter ist.
Betrachten wir zunächst ein eindimensionales Array als Zeilenvektor. Alternativ können wir es als einen Vektor definieren, der aus einer einzelnen Zeile mit mehreren Elementen besteht. Andererseits kann ein Spaltenvektor erstellt werden, indem der Zeilenvektor so umgeformt wird, dass er eine Spalte und mehrere Elemente enthält. Im Wesentlichen stellt es die Spaltenvektordarstellung dar. Insbesondere ist die Verwendung eckiger Klammern in diesem Zusammenhang unnötig.
Anstatt den Vektor explizit umzuformen, können wir das gleiche Ergebnis erzielen, indem wir mit der Funktion newaxis von NumPy eine neue Achse hinzufügen. Durch das Hinzufügen zweier neuer Achsen können wir sogar einen 3D-Tensor erstellen. Ein anderer Ansatz besteht darin, das Schlüsselwort None zu verwenden, das denselben Zweck erfüllt wie newaxis. Diese drei Methoden, nämlich Reshaping, Newaxis und None, erreichen alle das Ziel, bei Bedarf eine zusätzliche Achse hinzuzufügen.
Im weiteren Verlauf begegnen wir der grundlegenden linearen Algebra-Notation für die Matrixmultiplikation. In der linearen Algebra entspricht die Matrixmultiplikation der Berechnung mehrerer Skalarprodukte. Wenn wir zum Beispiel die Vektoren [1, 2, 3] und [1, 2, 3] haben, ergibt ihr Skalarprodukt 14. Ebenso ist das Skalarprodukt von [4, 5, 6] und [1, 2, 3] ergibt 32. In NumPy können wir eine Matrixmultiplikation mit der Funktion matmul durchführen. Alternativ kann der Einfachheit halber auch der @-Operator verwendet werden. Es ist jedoch wichtig zu beachten, dass wir in der linearen Algebra Matrizen und Vektoren nicht direkt multiplizieren können. Dennoch können wir einen Spaltenvektor als Matrix betrachten, insbesondere als 3x1-Matrix. Dieser Ansatz ermöglicht es uns, eine Matrix mit einem Vektor zu multiplizieren, was in der strengen linearen Algebra nicht möglich ist. Somit bietet NumPy im Vergleich zur herkömmlichen linearen Algebra mehr Flexibilität.
Darüber hinaus bietet NumPy die Punktfunktion für die Matrixmultiplikation, die aufgrund ihrer effizienten Implementierung auf den meisten Maschinen allgemein empfohlen wird. Mit dieser Funktion können wir Code bequemer schreiben, insbesondere beim Umgang mit Zeilenvektoren. Es dient als Abkürzung oder Operatorüberladung für die Matrixmultiplikation in NumPy. Es ist erwähnenswert, dass die Punktfunktion verschiedene Kombinationen von Matrizen und Vektoren verarbeiten kann und basierend auf den Eingabeformen entweder Punktprodukte oder eine Matrixmultiplikation durchführt.
In Bezug auf die Leistung weisen sowohl die Matmul- als auch die Punktfunktion eine ähnliche Geschwindigkeit auf. Die Wahl zwischen ihnen kann von der jeweiligen Maschine abhängen. Dennoch wird in der Praxis im Allgemeinen die Punktfunktion bevorzugt. Darüber hinaus spielt die Transponierungsoperation eine ähnliche Rolle wie die Transponierungsoperation in der linearen Algebra, indem sie die Matrix effektiv umdreht. Anstatt die Transpositionsfunktion explizit zu verwenden, können wir der Kürze halber das T-Attribut verwenden.
Obwohl NumPy einen Matrixtyp für zweidimensionale Arrays enthält, wird dieser in der NumPy-Community nicht häufig verwendet. Regelmäßige mehrdimensionale Arrays erfüllen in den meisten Fällen den Zweck. Der Matrixtyp ist auf zwei Dimensionen beschränkt und führt zu unnötiger Komplexität. Es wird empfohlen, die Verwendung zu vermeiden, es sei denn, dies ist ausdrücklich erforderlich.
Abschließend gehen wir kurz auf SciPy ein, eine beeindruckende Bibliothek, die über NumPy hinaus eine Vielzahl zusätzlicher Funktionen umfasst. Diese Bibliothek enthält zahlreiche spezialisierte Algorithmen für das wissenschaftliche Rechnen, wie z. B. lineare Algebraoperationen, Fourier-Transformationen, Interpolationstechniken, Optimierungsalgorithmen, statistische Funktionen und mehr. Während es auf NumPy basiert, dient SciPy als Erweiterung und stellt spezielle Tools für verschiedene wissenschaftliche Berechnungen bereit. In diesem Kurs werden wir bei Bedarf spezifische Algorithmen in SciPy untersuchen. Sie müssen sich nicht alle Details merken; Ich werde relevante Algorithmen vorstellen und erklären, sobald wir ihnen begegnen.
Damit schließen wir unsere Diskussion über NumPy und SciPy für wissenschaftliches Rechnen in Python ab. Im nächsten Video werden wir unsere wissenschaftliche Computerreise fortsetzen, indem wir matplotlib, eine leistungsstarke Plotbibliothek, erkunden.
4.10 Matplotlib (L04: Wissenschaftliches Rechnen in Python)
4.10 Matplotlib (L04: Wissenschaftliches Rechnen in Python)
Endlich sind wir am Ende der vierten Vorlesung angelangt, die recht langwierig war. Ich hoffe jedoch, dass die über NumPy besprochenen Konzepte für Sie wertvoll waren. In Zukunft werden wir NumPy in unseren Hausaufgaben zur Implementierung von Algorithmen für maschinelles Lernen ausgiebig nutzen. Daher ist es für Sie an dieser Stelle von entscheidender Bedeutung, sich mit NumPy vertraut zu machen.
Als Nächstes wenden wir uns dem letzten Thema der vierten Vorlesung zu und beschäftigen uns mit matplotlib, einer beliebten Plotbibliothek für Python. Obwohl heutzutage mehrere Plotbibliotheken verfügbar sind, bleibt matplotlib die am weitesten verbreitete. Persönlich ist es auch meine Lieblings-Plotbibliothek, und ihr Name ist von Metalab inspiriert. Die Syntax von Matplotlib ist der von MATLAB sehr ähnlich, was manche Leute zu schätzen wissen, andere nicht. Während meines Studiums mochte ich beispielsweise MATLAB nicht, aber ich finde, dass Matplotlib ein großartiges Werkzeug ist.
Auch wenn Sie kein MATLAB-Fan sind, glaube ich, dass Matplotlib relativ einfach zu verwenden ist. Darüber hinaus lässt es sich reibungslos in NumPy integrieren, was ein zusätzlicher Vorteil ist. Beginnen wir also mit Matplotlib. Ich persönlich sollte erwähnen, dass ich mir nicht alle besonderen Möglichkeiten zum Erledigen von Aufgaben in matplotlib merke, da es sich um eine Low-Level-Bibliothek handelt. Das bedeutet, dass es ein hohes Maß an Anpassungsmöglichkeiten bietet, aber nicht alle davon sind intuitiv. Deshalb schaue ich oft nach. Wenn ich etwas Bestimmtes tun muss, besuche ich die Matplotlib-Galerie, die verschiedene Beispiele zeigt. Wenn ich beispielsweise ein Stammdiagramm erstellen möchte, suche ich einfach in der Galerie danach, finde das Beispiel und passe es an meine Daten an. Für meine Bedürfnisse ist dieser Ansatz in der Regel ausreichend. Wenn Sie jedoch detailliertere Tutorials bevorzugen, können Sie auch die Website matplotlib.org erkunden, die erklärende Tutorials zu verschiedenen Aspekten von Matplotlib bietet.
Wenn Sie mit matplotlib in Jupyter Lab oder Jupyter Notebooks arbeiten, können Sie zunächst die Inline-Funktion verwenden, um Diagramme im Notebook selbst anzuzeigen. Dies bedeutet, dass die Diagramme direkt im Notizbuch angezeigt werden, sodass kein separates Fenster erforderlich ist. Obwohl es alternative Möglichkeiten gibt, dies zu erreichen, empfehle ich persönlich die Verwendung des Inline-Ansatzes, da dieser auf verschiedenen Computern zuverlässiger ist. Um den Inline-Modus zu aktivieren, können Sie den folgenden magischen Befehl verwenden: %matplotlib inline. Alternativ können Sie am Ende Ihrer Plotanweisungen ein Semikolon hinzufügen, was normalerweise zum gleichen Ergebnis führt. Es empfiehlt sich jedoch, plt.show() zum Anzeigen der Diagramme zu verwenden, da der Semikolon-Trick auf bestimmten Computern möglicherweise nicht gut funktioniert.
Lassen Sie uns nun in die Erstellung einiger einfacher Diagramme mit matplotlib eintauchen. Beispielsweise können wir damit beginnen, eine Sinuskurve zu zeichnen. Dazu können wir die Funktion np.linspace verwenden, um 100 Werte im Bereich von null bis zehn zu generieren, und diese Werte dann gegen np.sin, die Sinusfunktion, grafisch darstellen. Der einfachste Weg, einen Plot zu erstellen, ist die Verwendung der Funktion plt.plot, wobei plt die Abkürzung für matplotlib.pyplot ist. Wir können die Achsenbereiche des Diagramms mithilfe der Funktionen plt.xlim und plt.ylim anpassen, um die Grenzen für die x- bzw. y-Achse festzulegen. Darüber hinaus können wir mit den Funktionen plt.xlabel und plt.ylabel Beschriftungen zur x- und y-Achse hinzufügen. Um den Plot schließlich anzuzeigen, können wir die Funktion plt.show() verwenden oder am Ende der Plotanweisungen ein Semikolon hinzufügen, um unerwünschte Ausgaben zu unterdrücken.
Zusätzlich zu einem einzelnen Plot können wir auch mehrere Plots innerhalb derselben Figur erstellen. Beispielsweise können wir sowohl eine Sinuskurve als auch eine Kosinuskurve in separaten Unterdiagrammen darstellen. Um dies zu erreichen, können wir mit der Funktion plt.subplots zwei Figuren erstellen und dann in jedem Unterplot die jeweiligen Sinus- und Cosinuskurven zeichnen. Die Funktion plt.subplots gibt ein Figurenobjekt und ein Array von Achsenobjekten zurück, mit denen wir jeden Unterplot individuell anpassen können.
Hier ist ein Beispiel-Codeausschnitt, der die Erstellung mehrerer Unterhandlungen demonstriert:
In diesem Beispiel verwenden wir die Funktion plt.subplots, um eine Figur mit zwei vertikal angeordneten Unterplots (2, 1) zu erstellen. Die Funktion gibt ein Figurenobjekt fig und ein Array von Achsenobjekten axs zurück, deren Abmessungen dem angegebenen Unterplot-Layout entsprechen. Wir können auf jede Unterhandlung zugreifen, indem wir das Axs-Array indizieren.In den unterplotspezifischen Codeblöcken verwenden wir die Plot-Funktion, um die jeweiligen Kurven zu zeichnen, und passen dann den Titel, die x-Achsen-Beschriftung und die y-Achsen-Beschriftung jedes Unterplots mithilfe der Funktionen set_title, set_xlabel bzw. set_ylabel an.
Die Funktion „tight_layout“ wird aufgerufen, um den Abstand zwischen Unterplots anzupassen und so eine bessere Lesbarkeit zu gewährleisten. Schließlich verwenden wir plt.show(), um die Abbildung mit den Nebenhandlungen anzuzeigen.
Sie können versuchen, diesen Code in Ihrer Jupyter Notebook- oder Jupyter Lab-Umgebung auszuführen, um die resultierende Figur mit den Sinus- und Kosinuskurven in separaten Unterdiagrammen anzuzeigen.
Dies ist nur ein einfaches Beispiel für die Erstellung von Nebenhandlungen. In matplotlib stehen noch viele weitere Anpassungsoptionen zur Verfügung, um Ihre Handlungen informativer und optisch ansprechender zu gestalten. Weitere Beispiele und detaillierte Erklärungen finden Sie in der Matplotlib-Dokumentation und -Galerie.
5.1 Lesen eines Datensatzes aus einer tabellarischen Textdatei (L05: Maschinelles Lernen mit Scikit-Learn)
5.1 Lesen eines Datensatzes aus einer tabellarischen Textdatei (L05: Maschinelles Lernen mit Scikit-Learn)
Hallo an alle! Ich hoffe, Sie hatten alle eine tolle Woche und hatten die Gelegenheit, das gesamte NumPy-Material durchzuarbeiten. Diese Woche konzentrieren wir uns auf Datenverarbeitung und maschinelles Lernen mit scikit-learn, daher ist es wichtig, ein gutes Verständnis von NumPy zu haben. Ich glaube, dass es unglaublich nützlich ist, das Codieren zu üben und die Konzepte, die wir lernen, in Beispielen aus dem wirklichen Leben anzuwenden, weshalb wir uns in dieser Vorlesung im Vorfeld mit dem Codieren befassen werden. Es wird uns später im Unterricht von Nutzen sein, wenn wir diese Werkzeuge ausgiebig nutzen. Apropos, dieser Vorlesung gibt es nicht viel hinzuzufügen, außer dass ich die erste große Hausaufgabe hochgeladen habe, die Sie anhand der Konzepte testen wird, die wir in früheren Vorlesungen behandelt haben, einschließlich überwachtem Lernen und Codebeispielen mit NumPy. Es ist eine großartige Gelegenheit, praktische Erfahrungen mit dem K-Nearest-Neighbor-Algorithmus zu sammeln und NumPy und scikit-learn weiter zu erkunden.
Während Sie nun in die Videos eintauchen, die Hausaufgaben erledigen und am Quiz zur Selbsteinschätzung teilnehmen, möchte ich Sie daran erinnern, etwas Spaß zu haben und sich zu amüsieren. Der Herbst, meine Lieblingsjahreszeit, hat hier in Wisconsin gerade erst begonnen und ich liebe das kältere Wetter und die wunderschönen Farben der wechselnden Blätter. Ich bin übrigens wirklich aufgeregt, denn ich war letztes Wochenende bereits auf einem Kürbisbeet und habe mir ein paar Kürbisse besorgt, die ich unbedingt für Halloween schnitzen möchte. Beginnen wir also mit der Vorlesung, damit ich mich wieder meinen kleinen Kürbissen widmen und sie für Halloween vorbereiten kann.
Okay, wir sind jetzt bei Teil drei der Vorlesungen zu den Grundlagen der Informatik angelangt. In dieser Vorlesung werden wir mehrere Themen behandeln, beginnend mit dem Einlesen eines Datensatzes aus einer tabellarischen Textdatei, beispielsweise einer CSV-Datei, dem gängigsten Dateiformat für herkömmliche maschinelle Lernaufgaben. Anschließend besprechen wir grundlegende Datenverarbeitungstechniken, einschließlich der Formung der Daten für Algorithmen und Trainingsverfahren für maschinelles Lernen.
Danach tauchen wir mit scikit-learn in das maschinelle Lernen ein. Aber bevor wir das tun, möchte ich kurz auf die Python-Klassen und die objektorientierte Programmierung eingehen. In früheren Übungen habe ich Sie gebeten, sich auf Python vorzubereiten oder seine Konzepte besser zu verstehen. Es ist wichtig, gute Kenntnisse der objektorientierten Programmierung zu haben, da scikit-learn stark darauf angewiesen ist. Daher ist es notwendig, die objektorientierte Programmierung zu verstehen, um zu verstehen, wie Scikit-Learn funktioniert.
Im Folgenden besprechen wir die Vorbereitung von Trainingsdaten mithilfe der Scikit-Learn-Transformer-API. Wir werden uns auch mit der Definition von Scikit-Learn-Pipelines befassen, die uns dabei helfen, verschiedene Vorgänge wie die Vorbereitung von Datensätzen, die Skalierung, die Normalisierung, die Dimensionsreduzierung und den Klassifikator selbst zu verketten. Durch den Einsatz von Pipelines können wir effiziente Trainingsworkflows erstellen, die verschiedene Aspekte des maschinellen Lernprozesses verbinden und so die Arbeit komfortabler machen. Dies ist eine der wesentlichen Stärken von scikit-learn.
Für diese Vorlesung habe ich mich entschieden, wieder Folien zu verwenden. Obwohl Jupiter Lab ein fantastisches Tool ist, finde ich es einfacher, bestimmte Konzepte zu erklären, indem ich Codebeispiele mit einem Kugelschreiber oder Bleistift annotiere. Auf diesen Folien habe ich Screenshots von Jupiter Lab und Jupiter Notebook aufgenommen, die ich während der Vorlesung kommentieren werde. Ich habe jedoch auch das gesamte Code-Notizbuch auf GitHub hochgeladen, wo Sie zusätzliche Erklärungen finden. Betrachten Sie dieses Dokument als optionales Kurs- oder Vorlesungsskript zu Ihrer Referenz.
Lassen Sie uns kurz zusammenfassen, wo wir uns in diesem Kurs befinden. Wir begannen mit einer Einführung in maschinelles Lernen, behandelten die Grundlagen und untersuchten, wie Scikit-Learn funktioniert. Anschließend beschäftigten wir uns mit Python und lernten etwas über NumPy und wissenschaftliches Rechnen. Jetzt betreten wir mit scikit-learn die Phase der Datenverarbeitung und des maschinellen Lernens. In der nächsten Vorlesung werden wir auf Kernkonzepte des maschinellen Lernens wie Entscheidungsbäume, Ensemble-Methoden und Modellevaluierung zurückkommen. Obwohl dies der letzte Teil der Vorlesung zu den Grundlagen der Informatik ist, bedeutet dies nicht, dass es das Ende des Kurses ist. Nach Abschluss der Vorlesungen über Computergrundlagen werden wir uns weiterführenden Themen des maschinellen Lernens zuwenden, darunter Deep Learning und neuronale Netze.
Kommen wir nun zum ersten Thema dieser Vorlesung: dem Einlesen eines Datensatzes aus einer tabellarischen Textdatei. Bei der Arbeit mit maschinellem Lernen werden Daten häufig in Tabellenformaten wie CSV-Dateien (Comma-Separated Values) gespeichert. Diese Dateien enthalten Zeilen und Spalten mit Daten, wobei jede Zeile eine Stichprobe oder Instanz und jede Spalte ein Merkmal oder Attribut darstellt.
Um eine CSV-Datei in Python einzulesen, können wir die Pandas-Bibliothek verwenden. Pandas bietet leistungsstarke Tools zur Datenbearbeitung und -analyse und ist daher eine beliebte Wahl für die Arbeit mit Tabellendaten in Python. Schauen wir uns ein Beispiel an:
In diesem Beispiel importieren wir zunächst die Pandas-Bibliothek und nennen sie der Einfachheit halber pd. Anschließend verwenden wir die Funktion read_csv(), um die CSV-Datei data.csv in einen DataFrame einzulesen, bei dem es sich um eine zweidimensionale tabellarische Datenstruktur handelt, die von Pandas bereitgestellt wird. Der DataFrame wird in den variablen Daten gespeichert.
Nachdem wir die Daten gelesen haben, können wir die Funktion head() verwenden, um die ersten paar Zeilen des DataFrame anzuzeigen. Dadurch können wir die Daten schnell überprüfen und überprüfen, ob sie korrekt gelesen wurden.
Pandas bietet eine breite Palette an Funktionen und Methoden zur Bearbeitung und Analyse von Daten. Wir können verschiedene Vorgänge durchführen, z. B. Zeilen filtern, Spalten auswählen, Daten aggregieren und vieles mehr. Wenn Sie neu bei Pandas sind, empfehle ich Ihnen, die Dokumentation zu erkunden und selbst mit verschiedenen Vorgängen zu experimentieren.
Nachdem wir nun wissen, wie man Daten einliest, gehen wir zum nächsten Thema über: grundlegende Techniken zur Datenverarbeitung. Bei der Arbeit mit Daten für maschinelles Lernen ist es wichtig, die Daten entsprechend vorzuverarbeiten und aufzubereiten. Dazu gehören Aufgaben wie der Umgang mit fehlenden Werten, die Kodierung kategorialer Variablen, die Skalierung numerischer Merkmale und die Aufteilung der Daten in Trainings- und Testsätze.
Ein häufiger Vorverarbeitungsschritt ist die Behandlung fehlender Werte. Fehlende Werte werden in den Daten häufig als NaN-Werte (Not a Number) oder NULL-Werte dargestellt. Diese fehlenden Werte können beim Training von Modellen für maschinelles Lernen zu Problemen führen, daher müssen wir angemessen damit umgehen. Pandas bietet mehrere Funktionen zum Umgang mit fehlenden Werten, z. B. isna() zum Überprüfen auf fehlende Werte, fillna() zum Füllen fehlender Werte mit einem angegebenen Wert und dropna() zum Entfernen von Zeilen oder Spalten mit fehlenden Werten.
Die Kodierung kategorialer Variablen ist ein weiterer wichtiger Schritt. Modelle für maschinelles Lernen arbeiten normalerweise mit numerischen Daten, daher müssen wir kategoriale Variablen in eine numerische Darstellung umwandeln. Eine gängige Codierungstechnik ist die One-Hot-Codierung, bei der wir für jede Kategorie binäre Spalten erstellen und das Vorhandensein oder Fehlen einer Kategorie mit einer 1 bzw. 0 angeben.
Das Skalieren numerischer Merkmale ist ein weiterer häufiger Vorverarbeitungsschritt. Viele Algorithmen für maschinelles Lernen reagieren empfindlich auf den Umfang der Funktionen. Wenn die Features unterschiedliche Maßstäbe haben, kann dies Auswirkungen auf die Leistung des Modells haben. Um dies zu beheben, können wir die Features auf einen Standardbereich skalieren, z. B. 0 zu 1 oder -1 zu 1. Pandas stellt die Klassen MinMaxScaler und StandardScaler im Modul sklearn.preprocessing bereit, um die Feature-Skalierung durchzuführen.
Schließlich ist die Aufteilung der Daten in Trainings- und Testsätze von entscheidender Bedeutung für die Bewertung der Leistung von Modellen für maschinelles Lernen. Normalerweise teilen wir die Daten in zwei Sätze auf: einen Trainingssatz, der zum Trainieren des Modells verwendet wird, und einen Testsatz, der zur Bewertung seiner Leistung verwendet wird. Pandas stellt die Funktion train_test_split() im Modul sklearn.model_selection bereit, um die Daten in Trainings- und Testsätze aufzuteilen.
Als nächstes verwenden wir die Funktion train_test_split(), um die Daten in Trainings- und Testsätze aufzuteilen. Wir übergeben die Merkmale
Nach der Aufteilung der Daten können wir den Trainingssatz (X_train und y_train) verwenden, um unser Modell für maschinelles Lernen zu trainieren und seine Leistung anhand des Testsatzes (X_test und y_test) zu bewerten.
Dies sind einige grundlegende Datenverarbeitungstechniken beim maschinellen Lernen mithilfe der Pandas-Bibliothek in Python. Denken Sie daran, dass die Datenvorverarbeitung und -aufbereitung wesentliche Schritte in der Machine-Learning-Pipeline sind und je nach den spezifischen Anforderungen Ihres Projekts noch viele weitere Techniken und Tools verfügbar sind.
5.2 Grundlegende Datenverarbeitung (L05: Maschinelles Lernen mit Scikit-Learn)
5.2 Grundlegende Datenverarbeitung (L05: Maschinelles Lernen mit Scikit-Learn)
Im vorherigen Video haben wir besprochen, wie man eine tabellarische Textdatei als Datensatz liest. Konkret haben wir uns auf die Arbeit mit einer CSV-Datei und insbesondere dem Iris-Datensatz konzentriert. Wir haben den Iris-Datensatz aus einer CSV-Datei in einen Pandas DataFrame importiert.
In diesem Video befassen wir uns intensiv mit der Aufbereitung der Daten im geeigneten Format für maschinelles Lernen mit scikit-learn. Wir werden grundlegende Datenverarbeitungstechniken mit Pandas und NumPy untersuchen, um die Daten in ein geeignetes Format für maschinelles Lernen umzuwandeln. Aber bevor wir fortfahren, lassen Sie uns kurz das Konzept der Python-Funktionen zusammenfassen, da es nützlich sein wird, wenn wir die Transformation von Werten in einem Pandas DataFrame diskutieren.
Hier haben wir eine einfache Python-Funktion namens „some_func“. Es nimmt ein einzelnes Eingabeargument, „x“, und wandelt es in eine Zeichenfolge um. Anschließend wird der konvertierte Wert mit der festen Zeichenfolge „Hallo Welt“ verkettet. Wenn wir als Eingabe eine Ganzzahl wie 123 bereitstellen, wird diese in eine Zeichenfolge („123“) konvertiert und mit „Hallo Welt“ verkettet, was zur endgültigen Zeichenfolge führt. Dies ist ein grundlegender Überblick über die Funktionsweise von Python-Funktionen, wobei ein Doppelpunkt den Hauptteil der Funktion angibt und eine Return-Anweisung die Ausgabe angibt. Obwohl die Funktion mehrere Codezeilen enthalten kann, markiert die Return-Anweisung das Ende.
Ein weiteres erwähnenswertes Konzept sind Lambda-Funktionen. Lambda-Funktionen sind eine Kurzform zur Definition kleiner Funktionen, ohne sie explizit zu benennen. Sie werden häufig verwendet, wenn Codezeilen gespeichert und Funktionen schnell geschrieben werden müssen. Im Rahmen von Datentransformationen in Pandas-Spalten werden häufig Lambda-Funktionen verwendet. Obwohl Lambda-Funktionen eine prägnantere Syntax bieten, führen sie im Wesentlichen dieselben Operationen aus wie reguläre Funktionen. Sie sind besonders nützlich, wenn sie mit der Apply-Methode für eine Pandas DataFrame-Spalte kombiniert werden.
In der vorherigen Vorlesung haben wir den Iris-Datensatz aus der CSV-Datei in einen Pandas DataFrame eingelesen. Der Iris-Datensatz besteht aus 150 Zeilen, der Kürze halber zeigen wir jedoch nur die ersten fünf Zeilen an. Der Datensatz enthält eine ID-Spalte, die nicht unbedingt erforderlich ist, gefolgt von den durch die Designmatrix X dargestellten Features. Wir haben auch die Klassenbezeichnungen, die normalerweise als y bezeichnet werden. Traditionell behandelten scikit-learn und andere Bibliotheken String-Variablen nicht als Klassenbezeichnungen, daher war es üblich, sie in Ganzzahlen umzuwandeln. Beispielsweise würde „Iris setosa“ in die Ganzzahl 0, „Iris versicolor“ in 1 und „Iris virginica“ in 2 konvertiert. Diese Konvertierung war notwendig, da viele Algorithmen für die Arbeit mit ganzzahligen Klassenbezeichnungen statt mit Zeichenfolgenbezeichnungen konzipiert waren.
Allerdings unterstützt scikit-learn jetzt in den meisten Funktionen Zeichenfolgenklassenbezeichnungen, sodass keine explizite Konvertierung erforderlich ist. Intern erfolgt die Konvertierung automatisch. Dennoch verarbeiten einige Tools Zeichenfolgendaten möglicherweise nicht korrekt. Daher wird dennoch empfohlen, Klassenbezeichnungen in Ganzzahlen umzuwandeln. Dadurch stellen Sie die Kompatibilität mit verschiedenen Tools sicher und verringern die Wahrscheinlichkeit von Fehlern.
Um den Konvertierungsprozess zu veranschaulichen, verwenden wir die Lambda-Funktion in Verbindung mit der Apply-Methode. Durch Anwenden einer Lambda-Funktion auf die Species-Spalte des DataFrame können wir die String-Klassenbeschriftungen in Ganzzahlbeschriftungen umwandeln. Es ist jedoch erwähnenswert, dass die Verwendung eines Mapping-Wörterbuchs häufig der bessere Ansatz ist. Es bietet eine bessere Lesbarkeit und ermöglicht eine einfachere Interpretation der Klassenbeschriftungstransformationen. Darüber hinaus können Sie, wenn Sie die ursprünglichen Klassenbezeichnungen später abrufen müssen, ein umgekehrtes Wörterbuch definieren und es verwenden, um die ganzzahligen Bezeichnungen wieder ihren ursprünglichen Zeichenfolgendarstellungen zuzuordnen.
Um die Konvertierung zu demonstrieren, laden wir den Datensatz in seinen ursprünglichen Zustand zurück. Anstatt „Apply“ zu verwenden, verwenden wir dann die Map-Funktion, um die Zeichenfolgenbeschriftungen mithilfe des Mapping-Wörterbuchs in Ganzzahlen umzuwandeln. Wir demonstrieren auch die Verwendung des Values-Attributs, das auf das zugrunde liegende NumPy-Array zugreift. Arbeiten mit NumPy-Arrays.
Die Arbeit mit NumPy-Arrays kann aus mehreren Gründen von Vorteil sein. NumPy-Arrays sind im Vergleich zu Pandas DataFrames speichereffizienter und eignen sich daher ideal für große Datensätze. Darüber hinaus erwarten viele Algorithmen für maschinelles Lernen in scikit-learn, dass Eingabedaten in Form von NumPy-Arrays vorliegen.
Um unseren Pandas DataFrame in NumPy-Arrays zu konvertieren, können wir einfach auf das Values-Attribut des DataFrame zugreifen. Sehen wir uns ein Beispiel an:
In ähnlicher Weise greifen wir mit dem Indexierungsoperator [] auf die Spalte „species“ des DataFrame zu, konvertieren sie in ein NumPy-Array und weisen es der Variablen y zu.
Jetzt enthält die X-Variable die Merkmalsmatrix als NumPy-Array und die Y-Variable enthält die Klassenbezeichnungen als NumPy-Array. Wir können diese Arrays als Eingaben für verschiedene Algorithmen für maschinelles Lernen verwenden.
Nehmen wir an, wir möchten unseren Datensatz zur Modellbewertung in Trainings- und Testsätze aufteilen. Scikit-learn bietet eine Hilfsfunktion namens train_test_split, die diese Aufgabe vereinfacht. Hier ist ein Beispiel:
Nach dem Aufruf von train_test_split erhalten wir vier Arrays: X_train und y_train enthalten die Trainingsdaten, während X_test und y_test die Testdaten enthalten.
Jetzt können Sie die Arrays X_train und y_train verwenden, um Ihr Modell für maschinelles Lernen zu trainieren und seine Leistung mithilfe der Arrays X_test und y_test zu bewerten.
Zusammenfassend lässt sich sagen, dass wir durch die Konvertierung des Pandas DataFrame in NumPy-Arrays die Vorteile von NumPy nutzen können, wie z. B. Speichereffizienz und Kompatibilität mit Algorithmen für maschinelles Lernen. Darüber hinaus bietet scikit-learn praktische Funktionen wie train_test_split zum Aufteilen der Daten in Trainings- und Testsätze.
5.3 Objektorientierte Programmierung und Python-Klassen (L05: Maschinelles Lernen mit Scikit-Learn)
5.3 Objektorientierte Programmierung und Python-Klassen (L05: Maschinelles Lernen mit Scikit-Learn)
Bevor wir uns in der nächsten Vorlesung mit dem Thema maschinelles Lernen mit scikit-learn befassen, nehmen wir uns einen Moment Zeit, um die objektorientierte Programmierung, insbesondere Python-Klassen, zu besprechen. Das Verständnis von Klassen wird von großer Bedeutung sein, da scikit-learn stark auf objektorientierten Programmierkonzepten basiert. Gegen Ende dieses Videos werde ich die Implementierung von K-Nearest Neighbors mithilfe der Scikit-Learn-API demonstrieren. Dabei handelt es sich um den Ansatz, den Scikit-Learn für die Implementierung von Schätzern wie Klassifikatoren verwendet.
Beginnen wir also mit der Diskussion der Python-Klassen. Um die Scikit-Learn-API besser zu verstehen, ist es wichtig, die Grundlagen von Klassen zu verstehen. Vereinfacht ausgedrückt kann man sich eine Klasse als Blaupause zum Erstellen von Objekten vorstellen. Objekte sind Instanzen einer Klasse und können als verschiedene Variationen derselben Ausstecherform dargestellt werden, die zur Herstellung von Keksen verwendet wird. Die Klasse selbst fungiert als Ausstechervorlage, während die Cookies die aus der Klasse erstellten Objekte darstellen.
In Python definieren wir eine Klasse mit dem Schlüsselwort class, gefolgt vom Klassennamen. Innerhalb der Klasse definieren wir verschiedene Klassenmethoden. Klassenmethoden ähneln Funktionen, verfügen jedoch über ein obligatorisches erstes Argument namens self, das sich auf das Objekt selbst bezieht. Dieses Selbstargument ermöglicht uns den Zugriff auf die Attribute und Methoden des Objekts. Mit anderen Worten: Es ermöglicht uns, mit den Daten und dem Verhalten des Objekts zu interagieren.
Betrachten wir im Kontext des Fahrzeugbeispiels eine einfache naive Fahrzeugklasse. Diese Klasse repräsentiert verschiedene Fahrzeugtypen wie Autos, Motorräder oder Lastwagen. Die Klasse verfügt über verschiedene Methoden, um ihr Verhalten zu definieren. Die erste Methode ist die __init__-Methode, auch Konstruktor genannt. Diese Methode wird automatisch ausgeführt, wenn aus der Klasse ein neues Objekt erstellt wird. Es akzeptiert das Argument self und alle zusätzlichen Argumente, die zum Initialisieren des Objekts erforderlich sind.
In der Methode __init__ definieren wir ein Attribut namens „Horsepower“, dem der als Argument bereitgestellte Wert zugewiesen wird. Dieses Attribut stellt die Leistung des Fahrzeugs dar. Wenn ein neues Objekt erstellt wird, verfügt es über ein Pferdestärken-Attribut, auf das zugegriffen werden kann, um den Pferdestärkenwert abzurufen.
Zusätzlich zur Methode __init__ können wir andere Methoden definieren, die die Attribute des Objekts ändern. Beispielsweise verdoppelt die Methode „tune_motor“ die PS-Werte des Fahrzeugs und simuliert so eine Motoroptimierung. Durch den Aufruf dieser Methode für das Fahrzeugobjekt wird dessen PS-Attribut entsprechend geändert.
Darüber hinaus können wir Methoden definieren, die Werte basierend auf den Attributen des Objekts zurückgeben. Im Beispiel berechnet die Methode horsepower_to_torque den Drehmomentwert basierend auf der Pferdestärke des Objekts und einem bereitgestellten Drehzahlwert. Diese Methode zeigt, wie die Attribute des Objekts genutzt werden können, um Berechnungen durchzuführen und nützliche Ergebnisse zurückzugeben.
Es ist erwähnenswert, dass es in Python Konventionen zur Angabe der Sichtbarkeit von Methoden gibt. Methoden mit einem einzelnen Unterstrich-Präfix, wie z. B. _private_method, gelten als privat und sind nicht für die direkte Verwendung durch Benutzer der Klasse vorgesehen. Benutzer können jedoch weiterhin auf diese Methoden zugreifen und sie aufrufen, auch wenn davon generell abgeraten wird. Methoden mit einem doppelten Unterstrich-Präfix, wie z. B. __very_private_method, sind noch stärker eingeschränkt und erfordern eine bestimmte Syntax für den Zugriff.
Darüber hinaus unterstützt Python die Klassenvererbung, sodass wir untergeordnete Klassen erstellen können, die Eigenschaften und Methoden von einer übergeordneten Klasse erben. Dieses Konzept ermöglicht es uns, spezialisierte Klassen mit zusätzlichen Attributen und Verhaltensweisen zu erstellen und gleichzeitig die vorhandene, in der übergeordneten Klasse definierte Funktionalität zu nutzen. Beispielsweise könnten wir eine spezielle Car-Klasse erstellen, die von der Vehicle-Klasse erbt und ein Attribut „number_of_wheels“ speziell für Autos hinzufügt.
Zur Veranschaulichung der besprochenen Konzepte wird ein Beispiel eines K-Klassifikators für die nächsten Nachbarn bereitgestellt. Diese Implementierung folgt den API-Konventionen von scikit-learn und demonstriert die Verwendung einer Schätzerklasse in scikit-learn. Hier ist eine vereinfachte Implementierung:
In diesem Beispiel ist KNNClassifier eine Klasse, die einen K-Nearest-Neighbors-Klassifikator darstellt. Der Konstruktor benötigt einen Parameter k, der die Anzahl der zu berücksichtigenden nächsten Nachbarn angibt.
Zum Trainieren des Klassifikators wird die Fit-Methode verwendet. Es benötigt zwei Argumente: X_train (die Trainingsdaten) und y_train (die entsprechenden Beschriftungen). Die Methode speichert einfach die Trainingsdaten und Beschriftungen zur späteren Verwendung in den Attributen des Objekts.
Die Vorhersagemethode wird verwendet, um Vorhersagen zu neuen Daten zu treffen. Es verwendet X_test (die Testdaten) als Argument und gibt die vorhergesagten Bezeichnungen für die Testdaten zurück. Für jeden Datenpunkt in X_test berechnet die Methode die Abstände zu allen Datenpunkten im Trainingssatz mithilfe der Methode _calculate_distance. Anschließend wählt es die k nächsten Nachbarn aus und bestimmt die Mehrheitsklasse mithilfe der Methode _majority_vote. Die vorhergesagte Bezeichnung wird an die Vorhersageliste angehängt.
Die Methode _calculate_distance ist eine private Methode (gekennzeichnet durch den führenden Unterstrich), die den Abstand zwischen zwei Datenpunkten berechnet. Dies könnte die euklidische Distanz oder jede andere für das Problem geeignete Distanzmetrik sein.
Die Methode _majority_vote ist eine weitere private Methode, die die Mehrheitsklasse unter einer Menge von Nachbarn bestimmt. Dies kann erreicht werden, indem die Vorkommen jedes Klassenlabels gezählt werden und das Label mit der höchsten Anzahl ausgewählt wird.
Dieses Beispiel demonstriert die Grundstruktur einer Schätzerklasse in scikit-learn. Natürlich bietet scikit-learn eine ausgefeiltere und optimierte Implementierung von K-nächsten Nachbarn in der KNeighborsClassifier-Klasse, aber diese vereinfachte Version veranschaulicht die zugrunde liegenden Prinzipien.
5.4 Einführung in Scikit-Learn (L05: Maschinelles Lernen mit Scikit-Learn)
5.4 Einführung in Scikit-Learn (L05: Maschinelles Lernen mit Scikit-Learn)
In diesem relativ kurzen Video besteht das Ziel darin, maschinelles Lernen mit scikit-learn einzuführen. Scikit-learn ist eine weit verbreitete Bibliothek für maschinelles Lernen in Python, die einen umfassenden Satz an Tools und Algorithmen für verschiedene Aufgaben des maschinellen Lernens bereitstellt. Während Sie Scikit-Learn vielleicht schon einmal im Zusammenhang mit KNN-Vorlesungen (K-Nearest Neighbor) gesehen haben, soll dieses Video einen Schritt zurücktreten und die Bibliothek richtig vorstellen.
Nach diesem kurzen Video wird es ein längeres Video geben, das tiefer in die Vorbereitung des Trainingsdatensatzes mit scikit-learn eintaucht. Dabei werden Techniken und Tools behandelt, die die Datenaufbereitung im Vergleich zu herkömmlichen Ansätzen komfortabler und effizienter machen.
Im folgenden Video werden wir einige der coolen Konzepte von Scikit-Learn untersuchen, wie z. B. die Kombination von Vorverarbeitungstechniken, die Anpassung von Klassifikatoren für maschinelles Lernen und das Training mithilfe von Scikit-Learn-Pipelines. Dies ermöglicht einen schlankeren und effizienteren Arbeitsablauf.
Lassen Sie uns nun das maschinelle Lernen mit scikit-learn genauer besprechen. Scikit-learn gilt aufgrund seines guten Rufs, seiner großen Benutzerbasis und seiner Benutzerfreundlichkeit allgemein als die wichtigste Bibliothek für maschinelles Lernen für Python. Es handelt sich um eine gut gestaltete Bibliothek, die eine konsistente und intuitive API bietet. Scikit-learn wird außerdem aktiv gepflegt und regelmäßig aktualisiert. Zahlreiche Mitwirkende machen es zu einer robusten und zuverlässigen Wahl für maschinelle Lernaufgaben.
Es ist wichtig zu beachten, dass sich Scikit-Learn in erster Linie auf traditionelle Techniken des maschinellen Lernens konzentriert und nicht für Deep Learning gedacht ist. Deep Learning ist ein eigenständiger Bereich mit eigenen Spezialbibliotheken. Für Deep Learning werden typischerweise andere Bibliotheken wie TensorFlow oder PyTorch verwendet. Für herkömmliche maschinelle Lernaufgaben ist scikit-learn jedoch häufig die Bibliothek der Wahl.
Scikit-learn gibt es schon seit einiger Zeit, die erste Veröffentlichung geht auf das Jahr 2007 zurück. Trotz ihres Alters ist sie nach wie vor eine beliebte und aktiv gepflegte Bibliothek. Es begann als Google Summer of Code-Projekt von David Cournapeau und erhielt im Laufe der Zeit Beiträge von vielen anderen Entwicklern. Mit mehr als 1.875 Mitwirkenden auf GitHub und fast 150.000 Benutzern ist es offensichtlich, dass scikit-learn eine hoch angesehene Bibliothek mit erheblicher Community-Unterstützung ist.
Sie finden die offizielle Website von scikit-learn, die Dokumentation, Tutorials und andere hilfreiche Ressourcen enthält. Wenn Sie scikit-learn in Ihren Forschungsprojekten verwenden, empfiehlt es sich, die Bibliothek als Referenz zu nennen und die in ihre Entwicklung investierten Anstrengungen zu würdigen.
Um die Estimator-API von scikit-learn zu verstehen, werfen wir einen Blick auf ihre Hauptkomponenten. Die Estimator-API wird für überwachte Lernaufgaben verwendet und umfasst Regressoren für die Regressionsanalyse und Klassifikatoren für Klassifizierungsaufgaben. Wenn Sie scikit-learn verwenden, initialisieren Sie normalerweise einen Schätzer mit bestimmten Hyperparametern, die im Konstruktor der Klasse festgelegt werden.
Der Anpassungsprozess ist für einen Schätzer von entscheidender Bedeutung. Nach der Initialisierung müssen Sie die Fit-Methode aufrufen und dabei die Trainingsdaten (Features) und die entsprechenden Bezeichnungen bereitstellen. Die Fit-Methode trainiert den Schätzer anhand der gegebenen Daten und ermöglicht ihm so, später Vorhersagen zu treffen. Während des Anpassungsprozesses werden dem Schätzer bestimmte Attribute zugewiesen, die durch einen abschließenden Unterstrich gekennzeichnet sind, was darauf hinweist, dass sie während der Modellanpassung erstellt werden.
Sobald das Modell angepasst ist, können Sie mit der Vorhersagemethode Vorhersagen für neue Daten treffen. Die Vorhersagemethode verwendet die Testdaten (mit denselben Merkmalen wie die Trainingsdaten) als Eingabe und gibt die vorhergesagten Bezeichnungen zurück.
Darüber hinaus bietet scikit-learn eine Bewertungsmethode, die die Leistung des Modells berechnet. Bei Klassifikatoren stellt es häufig die Genauigkeit dar, während es bei Regressoren typischerweise das Bestimmtheitsmaß (R^2-Score) berechnet. Diese Methode dient als bequeme Möglichkeit, die Leistung des Modells zu bewerten.
Zusätzlich zu diesen Kernkomponenten bietet scikit-learn auch eine breite Palette an Vorverarbeitungstechniken und Dienstprogrammen, um Ihren maschinellen Lernworkflow zu verbessern.
Ein wichtiger Aspekt des maschinellen Lernens ist die Datenvorverarbeitung, bei der Rohdaten in ein geeignetes Format zum Trainieren eines Modells umgewandelt werden. Scikit-learn bietet verschiedene Vorverarbeitungsmodule, die Aufgaben wie Feature-Skalierung, Behandlung fehlender Werte, Kodierung kategorialer Variablen und mehr bewältigen können.
Die StandardScaler-Klasse kann beispielsweise zum Standardisieren von Features verwendet werden, indem der Mittelwert subtrahiert und auf die Einheitsvarianz skaliert wird. Dies ist wichtig, wenn Sie mit Features mit unterschiedlichen Maßstäben arbeiten, da es den Algorithmen hilft, schneller zu konvergieren und genauere Ergebnisse zu liefern.
Eine weitere nützliche Vorverarbeitungstechnik ist die Behandlung fehlender Werte. Die SimpleImputer-Klasse bietet Strategien zum Ersetzen fehlender Werte durch geeignete Alternativen, z. B. die Verwendung des Mittelwerts, des Medians oder der häufigsten Werte der entsprechenden Features.
Für den Umgang mit kategorialen Variablen bietet scikit-learn die Klassen OneHotEncoder und LabelEncoder an. Der LabelEncoder wandelt kategoriale Beschriftungen in numerische Werte um, während der OneHotEncoder kategoriale Merkmale in eine binäre Vektordarstellung umwandelt, sodass Algorithmen effektiv mit kategorialen Daten arbeiten können.
Um Ihren Workflow für maschinelles Lernen zu optimieren, bietet scikit-learn ein leistungsstarkes Tool namens Pipelines. Eine Pipeline kombiniert mehrere Vorverarbeitungsschritte und ein Modell für maschinelles Lernen in einem einzigen Objekt und erleichtert so die Verwaltung und konsistente Anwendung des gesamten Workflows.
Pipelines stellen sicher, dass die gleichen Vorverarbeitungsschritte konsistent sowohl auf die Trainings- als auch auf die Testdatensätze angewendet werden, wodurch Datenlecks und potenzielle Fehler vermieden werden. Sie vereinfachen auch den Bereitstellungsprozess, da Sie das gesamte Pipeline-Objekt speichern und für neue Daten wiederverwenden können, ohne sich um einzelne Vorverarbeitungsschritte kümmern zu müssen.
Mithilfe der Pipeline-Funktionalität von scikit-learn können Sie mehrere Vorverarbeitungstechniken wie Skalierung, Imputation fehlender Werte und Kodierung kategorialer Variablen mit Ihrem gewünschten Modell für maschinelles Lernen verketten. Dies führt zu einem schlankeren und effizienteren Arbeitsablauf, sodass Sie sich auf die Kernaspekte Ihres maschinellen Lernprojekts konzentrieren können.
Scikit-learn unterstützt eine breite Palette von Algorithmen für maschinelles Lernen, darunter lineare Regression, logistische Regression, Support-Vektor-Maschinen, Entscheidungsbäume, Random Forests, Gradient Boosting und viele mehr. Jeder Algorithmus wird als Schätzerklasse mit konsistenten Methoden wie Anpassung, Vorhersage und Bewertung implementiert.
Um den passenden Algorithmus für Ihre Aufgabe auszuwählen, stellt scikit-learn verschiedene Tools zur Modellauswahl und -bewertung zur Verfügung. Dazu gehören Techniken zur Kreuzvalidierung, Hyperparameter-Optimierung und Modellbewertungsmetriken. Die Kreuzvalidierung hilft bei der Beurteilung der Leistung Ihres Modells, indem die Daten in mehrere Zugtestaufteilungen aufgeteilt werden und das Modell anhand verschiedener Teilmengen der Daten trainiert und bewertet wird.
Beim Hyperparameter-Tuning geht es darum, die optimalen Werte für die Hyperparameter eines Modells zu finden. Hierbei handelt es sich um Parameter, die nicht aus den Daten gelernt, sondern vor dem Training festgelegt werden. Scikit-learn bietet Methoden wie Rastersuche und Zufallssuche, um den Prozess der Suche nach den besten Hyperparameterwerten zu automatisieren.
Modellbewertungsmetriken wie Genauigkeit, Präzision, Rückruf, F1-Score und Fläche unter der ROC-Kurve sind entscheidend für die Beurteilung der Leistung Ihres Modells bei verschiedenen Aufgaben. Scikit-learn bietet eine breite Palette solcher Metriken, die leicht berechnet und verglichen werden können.
Scikit-learn ist eine leistungsstarke und beliebte Bibliothek für maschinelles Lernen in Python, die eine breite Palette von Tools und Algorithmen für verschiedene Aufgaben des maschinellen Lernens bereitstellt. Seine benutzerfreundliche API, umfangreiche Dokumentation und aktive Community machen es zu einer ausgezeichneten Wahl sowohl für Anfänger als auch für erfahrene Praktiker. Unabhängig davon, ob Sie Ihre Daten vorverarbeiten, Pipelines erstellen, Modelle auswählen oder die Leistung bewerten müssen, verfügt scikit-learn über die Tools, die Sie benötigen, um Ihre Arbeit effizient und effektiv zu erledigen.
5.5 Scikit-learn Transformer API (L05: Maschinelles Lernen mit Scikit-Learn)
5.5 Scikit-learn Transformer API (L05: Maschinelles Lernen mit Scikit-Learn)
Im Video befasst sich der Moderator mit dem Prozess der Vorbereitung eines Trainingsdatensatzes mithilfe von Dienstprogrammen von scikit-learn und stellt die Transformer-API vor, die eng mit der in einem früheren Video besprochenen Schätzer-API verwandt ist. Die Schätzer-API wird hauptsächlich für überwachte Lernmodelle wie Klassifikatoren und Regressionsanalysemodelle verwendet, während die Transformator-API für Datentransformationen konzipiert ist.
Der Vortragende befasst sich zunächst mit den Problemen im Zusammenhang mit der Zufallsstichprobe, bei der ein Datensatz in zwei Teilmengen aufgeteilt wird, typischerweise ein Trainingssatz und ein Testsatz. Sie erklären, dass eine zufällige Aufteilung des Datensatzes zu Änderungen in der Verteilung der Klassenbezeichnungen führen kann, was zu einer falschen Darstellung der Klassen sowohl im Trainings- als auch im Testsatz führt. Um diese Herausforderung zu meistern, schlägt der Vortragende die Verwendung einer geschichteten Aufteilung vor, die sicherstellt, dass die Klassenverteilung oder -proportionen in den Teilmengen beibehalten wird. Anschließend demonstrieren sie, wie man mit der Funktion train_test_split aus dem Untermodul model_selection von scikit-learn eine geschichtete Aufteilung erreicht.
Anschließend befasst sich der Moderator mit dem Konzept der Datennormalisierung, wobei der Schwerpunkt auf zwei Techniken liegt: Min-Max-Skalierung und Standardisierung. Bei der Min-Max-Skalierung wird ein Feature so skaliert, dass alle seine Werte im Bereich von 0 bis 1 liegen. Der Präsentator stellt die Formel für die Min-Max-Skalierung bereit, bei der jeder Wert in der Feature-Spalte durch den minimalen Feature-Wert subtrahiert und anschließend dividiert wird es durch die Differenz zwischen den maximalen und minimalen Merkmalswerten.
Im Gegensatz dazu beinhaltet die Standardisierung die Transformation eines Merkmals so, dass es einen Mittelwert von Null und eine Standardabweichung von Eins hat. Der Moderator erklärt die Formel für die Standardisierung, die darin besteht, jeden Wert in der Merkmalsspalte vom Mittelwert des Merkmals zu subtrahieren und ihn dann durch die Standardabweichung des Merkmals zu dividieren. Sie erwähnen, dass Standardisierung häufiger beim maschinellen Lernen eingesetzt wird und besonders für bestimmte Optimierungsalgorithmen nützlich ist.
Um die praktische Anwendung der Min-Max-Skalierung und Standardisierung zu veranschaulichen, stellt der Moderator Beispiele anhand von Spielzeug-Feature-Spalten vor. Sie betonen, dass die Wahl zwischen der Verwendung der Stichproben- oder Populationsstandardabweichung keinen wesentlichen Einfluss auf die Ergebnisse des maschinellen Lernens hat, solange die Merkmale zentriert sind und eine Varianz von ungefähr einer Einheit aufweisen. Darüber hinaus betonen sie, wie wichtig es ist, die aus dem Trainingssatz berechneten Parameter (Mittelwert und Standardabweichung) zur Skalierung der Validierungs- und Testsätze zu verwenden, da die Validierungs- und Testsätze unsichtbare Daten darstellen.
Im Video werden dann verschiedene Techniken zur Datentransformation und -verarbeitung beim maschinellen Lernen untersucht. Es wird anerkannt, dass es bei einfachen Verfahren wie der Standardisierung möglich ist, die Transformationen manuell durchzuführen, ohne auf separate Bibliotheken oder fortgeschrittene Techniken angewiesen zu sein. Bei komplexeren Transformationen wie Feature-Auswahl, Feature-Dimensionalitätsreduzierung und Feature-Extraktion kann die Verwendung von Tools wie der Transformer-API jedoch mehr Komfort und Effizienz bieten.
Als nächstes konzentriert sich der Vortragende auf den Umgang mit kategorialen Daten. Sie stellen einen Spielzeugdatensatz vor, der aus drei Merkmalsspalten und einer Beschriftungsspalte besteht, und betonen, dass kategoriale Variablen in zwei Typen eingeteilt werden können: ordinale und nominale. Ordinale Variablen besitzen eine bestimmte Reihenfolge oder Hierarchie, nominale Variablen dagegen nicht. Zur Veranschaulichung heben sie die Spalte „Größe“ als Ordinalvariable hervor, in der T-Shirt-Größen wie M, L und XXL eine klare Reihenfolge aufweisen. Für den Umgang mit ordinalen Variablen empfiehlt das Video die Verwendung eines Zuordnungswörterbuchs, um die Werte in numerische Darstellungen umzuwandeln.
Andererseits stellt das Video Klassenbezeichnungen als Beispiel für nominale kategoriale Daten vor. Da es keine inhärente Reihenfolge zwischen den Klassenbezeichnungen gibt, schlägt der Vortragende vor, den Bezeichnungsencoder zu verwenden, um jeder Bezeichnung eindeutige Ganzzahlwerte zuzuweisen. Der Label-Encoder wird in die Klassenlabel-Spalte eingepasst, um ein Zuordnungswörterbuch zu erstellen, das dann verwendet wird, um die String-Labels in Ganzzahl-Labels umzuwandeln.
Bei nominalen Merkmalsspalten wie „Farbe“, bei denen keine Reihenfolge impliziert ist, kann die Verwendung des Label-Encoders zu irreführenden Informationen führen. In solchen Fällen führt das Video One-Hot-Codierung als geeignete Alternative ein. Bei dieser Technik wird für jeden einzelnen Wert in der nominalen Merkmalsspalte eine neue Merkmalsspalte erstellt und Nullen und Einsen zugewiesen, um das Vorhandensein oder Fehlen eines bestimmten Werts anzuzeigen. Es wird erwähnt, dass das Weglassen einer der resultierenden Feature-Spalten Redundanz beseitigen kann, ohne dass wesentliche Informationen verloren gehen.
Das Video geht kurz auf fehlende Daten ein und schlägt einige grundlegende Ansätze für den Umgang damit vor. Eine Strategie besteht darin, Zeilen oder Spalten mit fehlenden Werten zu löschen, wenn diese zufällig auftreten und nicht auf ein systematisches Problem hinweisen. Dies kann mit der Methode dropna() in der Pandas-Bibliothek erreicht werden. Ein anderer Ansatz besteht darin, fehlende Daten zu imputieren, indem die Lücken mit statistischen Maßen wie dem Mittelwert oder dem Median gefüllt werden, wobei Tools wie der SimpleImputer-Transformer zum Einsatz kommen. Das Video weist jedoch darauf hin, dass die Anrechnung sorgfältig abgewogen werden sollte, da sie zu unbeabsichtigten Verzerrungen führen kann.
Darüber hinaus wird im Video die Möglichkeit erwähnt, fehlende Werte vorherzusagen, indem das Problem als überwachte Lernaufgabe behandelt wird. In diesem Szenario kann die fehlende Feature-Spalte als Zielvariable betrachtet werden und die Zeilen ohne fehlende Daten können als Trainingsdaten zur Anpassung an ein Regressionsmodell verwendet werden.
Das Video bietet einen umfassenden Überblick über Datentransformationstechniken, einschließlich der Bedeutung der Vorbereitung eines Trainingsdatensatzes, der Anwendung der geschichteten Aufteilung und der Normalisierung von Daten mithilfe der Min-Max-Skalierung und Standardisierung. Darüber hinaus behandelt es den Umgang mit kategorialen Daten, die Unterscheidung zwischen Ordinal- und Nominalvariablen und stellt Techniken wie Mapping-Wörterbücher, Label-Encoder und One-Hot-Codierung vor. Darüber hinaus geht das Video kurz auf fehlende Daten ein und skizziert Ansätze wie das Löschen oder Imputieren fehlender Werte. Außerdem wird die Möglichkeit erwähnt, fehlende Werte durch überwachtes Lernen vorherzusagen.