ML-From-Scratch Detaillierte Projektbeschreibung

Projektübersicht

ML-From-Scratch ist ein Projekt, das grundlegende Modelle und Algorithmen des maschinellen Lernens von Grund auf in Python implementiert. Ziel dieses Projekts ist es nicht, die optimiertesten und recheneffizientesten Algorithmen zu erstellen, sondern die interne Funktionsweise der Algorithmen auf transparente und leicht verständliche Weise zu demonstrieren.

Projekt-Autor

Der Autor des Projekts, Erik Linder-Norén, ist ein Machine Learning Engineer bei Apple und hat eine Leidenschaft für maschinelles Lernen, Basketball und das Erschaffen von Dingen.

Projektmerkmale

1. Bildungsorientiert

• Fokus auf die transparente Darstellung der internen Funktionsweise von Algorithmen
• Klare und leicht verständliche Code-Implementierung, die das Lernen und Verstehen erleichtert
• Bietet zahlreiche Beispiele und Visualisierungsergebnisse

2. Technologiestack

• Hauptsprache: Python
• Kernabhängigkeiten: NumPy (für numerische Berechnungen)
• Visualisierung: Matplotlib (zum Plotten)

3. Umfassende Abdeckung

Deckt alle wichtigen Bereiche des maschinellen Lernens ab, von der linearen Regression bis zum Deep Learning.

Installation und Nutzung

Installationsschritte

$ git clone https://github.com/eriklindernoren/ML-From-Scratch
$ cd ML-From-Scratch
$ python setup.py install

Beispiele ausführen

# Beispiel für Polynomregression
$ python mlfromscratch/examples/polynomial_regression.py

# Beispiel für Convolutional Neural Network
$ python mlfromscratch/examples/convolutional_neural_network.py

# Beispiel für DBSCAN-Clustering
$ python mlfromscratch/examples/dbscan.py

Implementierte Algorithmuskategorien

Überwachte Lernalgorithmen

• Adaboost: Adaptiver Boosting-Algorithmus
• Bayesian Regression: Bayes'sche Regression
• Decision Tree: Entscheidungsbaum
• Elastic Net: Elastic Net
• Gradient Boosting: Gradient Boosting
• K Nearest Neighbors: K-Nächste-Nachbarn-Algorithmus
• Lasso Regression: Lasso-Regression
• Linear Discriminant Analysis: Lineare Diskriminanzanalyse
• Linear Regression: Lineare Regression
• Logistic Regression: Logistische Regression
• Multi-class Linear Discriminant Analysis: Mehrklassen-Lineare Diskriminanzanalyse
• Multilayer Perceptron: Mehrschichtiges Perzeptron
• Naive Bayes: Naiver Bayes-Klassifikator
• Neuroevolution: Neuroevolution
• Particle Swarm Optimization of Neural Network: Partikelschwarmoptimierung von neuronalen Netzen
• Perceptron: Perzeptron
• Polynomial Regression: Polynomregression
• Random Forest: Random Forest
• Ridge Regression: Ridge-Regression
• Support Vector Machine: Support Vector Machine
• XGBoost: Extremes Gradient Boosting

Unüberwachte Lernalgorithmen

• Apriori: Assoziationsregel-Mining
• Autoencoder: Autoencoder
• DBSCAN: Dichte-basierter Clustering-Algorithmus
• FP-Growth: Häufiges Musterwachstum
• Gaussian Mixture Model: Gaußsches Mischmodell
• Generative Adversarial Network: Generatives Adversarial Network
• Genetic Algorithm: Genetischer Algorithmus
• K-Means: K-Means-Clustering
• Partitioning Around Medoids: Partitionierung um Medoide
• Principal Component Analysis: Hauptkomponentenanalyse
• Restricted Boltzmann Machine: Restricted Boltzmann Machine

Deep Learning Komponenten

• Neural Network: Neuronales Netzwerk-Framework
• Verschiedene Schichttypen:
  • Activation Layer (Aktivierungsschicht)
  • Average Pooling Layer (Durchschnittliche Pooling-Schicht)
  • Batch Normalization Layer (Batch-Normalisierungsschicht)
  • Constant Padding Layer (Konstante Padding-Schicht)
  • Convolutional Layer (Faltungsschicht)
  • Dropout Layer (Dropout-Schicht)
  • Flatten Layer (Abflachungsschicht)
  • Fully-Connected (Dense) Layer (Vollständig verbundene (Dense) Schicht)
  • Fully-Connected RNN Layer (Vollständig verbundene RNN-Schicht)
  • Max Pooling Layer (Maximale Pooling-Schicht)
  • Reshape Layer (Umformungsschicht)
  • Up Sampling Layer (Upsampling-Schicht)
  • Zero Padding Layer (Null-Padding-Schicht)

Beispiel-Laufzeitergebnisse

1. Beispiel: Convolutional Neural Network

+---------+
| ConvNet |
+---------+
Input Shape: (1, 8, 8)
+----------------------+------------+--------------+
| Layer Type           | Parameters | Output Shape |
+----------------------+------------+--------------+
| Conv2D              | 160        | (16, 8, 8)   |
| Activation (ReLU)   | 0          | (16, 8, 8)   |
| Dropout             | 0          | (16, 8, 8)   |
| BatchNormalization  | 2048       | (16, 8, 8)   |
| Conv2D              | 4640       | (32, 8, 8)   |
| Activation (ReLU)   | 0          | (32, 8, 8)   |
| Dropout             | 0          | (32, 8, 8)   |
| BatchNormalization  | 4096       | (32, 8, 8)   |
| Flatten             | 0          | (2048,)      |
| Dense               | 524544     | (256,)       |
| Activation (ReLU)   | 0          | (256,)       |
| Dropout             | 0          | (256,)       |
| BatchNormalization  | 512        | (256,)       |
| Dense               | 2570       | (10,)        |
| Activation (Softmax)| 0          | (10,)        |
+----------------------+------------+--------------+
Total Parameters: 538570

Training: 100% [------------------------------------------------------------------------] Time: 0:01:55
Accuracy: 0.987465181058

2. Beispiel: Deep Q-Network

+----------------+
| Deep Q-Network |
+----------------+
Input Shape: (4,)
+-------------------+------------+--------------+
| Layer Type        | Parameters | Output Shape |
+-------------------+------------+--------------+
| Dense             | 320        | (64,)        |
| Activation (ReLU) | 0          | (64,)        |
| Dense             | 130        | (2,)         |
+-------------------+------------+--------------+
Total Parameters: 450

3. Beispiel: Neuroevolution

+---------------+
| Model Summary |
+---------------+
Input Shape: (64,)
+----------------------+------------+--------------+
| Layer Type           | Parameters | Output Shape |
+----------------------+------------+--------------+
| Dense                | 1040       | (16,)        |
| Activation (ReLU)    | 0          | (16,)        |
| Dense                | 170        | (10,)        |
| Activation (Softmax) | 0          | (10,)        |
+----------------------+------------+--------------+
Total Parameters: 1210

Population Size: 100
Generations: 3000
Mutation Rate: 0.01
[0 Best Individual - Fitness: 3.08301, Accuracy: 10.5%]
[1 Best Individual - Fitness: 3.08746, Accuracy: 12.0%]
...
[2999 Best Individual - Fitness: 94.08513, Accuracy: 98.5%]
Test set accuracy: 96.7%

Lernwert

1. Tiefes Verständnis der Algorithmusprinzipien

• Durch die Implementierung von Grund auf kann man die Kernideen jedes Algorithmus tiefgreifend verstehen.
• Die klare Code-Struktur hilft, die spezifischen Implementierungsdetails der Algorithmen zu verstehen.

2. Praktische Programmierkenntnisse

• Verbessert die Fähigkeiten im Umgang mit wissenschaftlichen Bibliotheken wie NumPy.
• Lernt, wie man mathematische Theorien in Code-Implementierungen umsetzt.

3. Grundlage für Forschung und Entwicklung

• Bietet eine Grundlage für weitere Algorithmusforschung und -verbesserung.
• Hilft, die zugrunde liegenden Implementierungen bestehender Machine-Learning-Frameworks zu verstehen.

Zielgruppe

• Anfänger und fortgeschrittene Lernende im Bereich maschinelles Lernen
• Forscher, die ein tiefes Verständnis der internen Mechanismen von Algorithmen erlangen möchten
• Entwickler, die ihre Programmierkenntnisse verbessern möchten
• Studenten in Studiengängen mit Bezug zum maschinellen Lernen

Projektvorteile

1. Hoher Bildungswert: Der Code ist klar und leicht verständlich, mit Fokus auf den Lehrwert.
2. Breite Abdeckung: Von grundlegenden bis zu fortgeschrittenen Algorithmen ist alles enthalten.
3. Hoher praktischer Nutzen: Bietet vollständige, lauffähige Beispiele.
4. Kontinuierliche Aktualisierung: Das Projekt ist aktiv und es werden ständig neue Algorithmusimplementierungen hinzugefügt.

Hinweise

• Dieses Projekt ist hauptsächlich für Lehr- und Lernzwecke gedacht und nicht für den Einsatz in Produktionsumgebungen geeignet.
• Die Algorithmusimplementierungen legen Wert auf Lesbarkeit und nicht auf Leistungsoptimierung.
• Es wird empfohlen, es in Kombination mit theoretischem Lernen zu verwenden, um bessere Ergebnisse zu erzielen.