Présentation détaillée du projet ML-From-Scratch

Vue d'ensemble du projet

ML-From-Scratch est un projet qui implémente des modèles et algorithmes fondamentaux d'apprentissage automatique (Machine Learning) en Python, à partir de zéro. L'objectif de ce projet n'est pas de produire les algorithmes les plus optimisés ou les plus efficaces en termes de calcul, mais plutôt de démontrer le fonctionnement interne des algorithmes de manière transparente et facile à comprendre.

Auteur du projet

Erik Linder-Norén, l'auteur du projet, est un ingénieur en apprentissage automatique chez Apple, passionné par le Machine Learning, le basketball et la création de choses.

Caractéristiques du projet

1. À vocation pédagogique

• Met l'accent sur la démonstration transparente du fonctionnement interne des algorithmes
• Implémentation du code claire et facile à comprendre, facilitant l'apprentissage et la compréhension
• Fournit de nombreux exemples et des résultats visualisés

2. Pile technologique

• Langage principal: Python
• Dépendances clés: NumPy (pour les calculs numériques)
• Visualisation: Matplotlib (pour les représentations graphiques)

3. Champ d'application étendu

Couvre tous les domaines importants de l'apprentissage automatique, de la régression linéaire au Deep Learning.

Installation et utilisation

Étapes d'installation

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

Exécution des exemples

# Exemple de régression polynomiale
$ python mlfromscratch/examples/polynomial_regression.py

# Exemple de réseau neuronal convolutif
$ python mlfromscratch/examples/convolutional_neural_network.py

# Exemple de clustering DBSCAN
$ python mlfromscratch/examples/dbscan.py

Catégories d'algorithmes implémentés

Algorithmes d'apprentissage supervisé

• Adaboost: Algorithme d'amplification adaptative
• Bayesian Regression: Régression bayésienne
• Decision Tree: Arbre de décision
• Elastic Net: Régression Elastic Net
• Gradient Boosting: Gradient Boosting
• K Nearest Neighbors: Algorithme des K plus proches voisins
• Lasso Regression: Régression Lasso
• Linear Discriminant Analysis: Analyse discriminante linéaire
• Linear Regression: Régression linéaire
• Logistic Regression: Régression logistique
• Multi-class Linear Discriminant Analysis: Analyse discriminante linéaire multi-classes
• Multilayer Perceptron: Perceptron multi-couches
• Naive Bayes: Naive Bayes
• Neuroevolution: Neuroévolution
• Particle Swarm Optimization of Neural Network: Optimisation par essaim de particules de réseau neuronal
• Perceptron: Perceptron
• Polynomial Regression: Régression polynomiale
• Random Forest: Forêt aléatoire
• Ridge Regression: Régression Ridge
• Support Vector Machine: Machine à vecteurs de support
• XGBoost: XGBoost

Algorithmes d'apprentissage non supervisé

• Apriori: Extraction de règles d'association
• Autoencoder: Auto-encodeur
• DBSCAN: Algorithme de clustering basé sur la densité
• FP-Growth: Algorithme de croissance de motifs fréquents
• Gaussian Mixture Model: Modèle de mélange gaussien
• Generative Adversarial Network: Réseau antagoniste génératif
• Genetic Algorithm: Algorithme génétique
• K-Means: K-Means
• Partitioning Around Medoids: Partitionnement autour des médoïdes
• Principal Component Analysis: Analyse en composantes principales
• Restricted Boltzmann Machine: Machine de Boltzmann restreinte

Composants de Deep Learning

• Neural Network: Cadre de réseau neuronal
• Divers types de couches:
  • Activation Layer (Couche d'activation)
  • Average Pooling Layer (Couche de pooling moyen)
  • Batch Normalization Layer (Couche de normalisation par lots)
  • Constant Padding Layer (Couche de remplissage constant)
  • Convolutional Layer (Couche de convolution)
  • Dropout Layer (Couche Dropout)
  • Flatten Layer (Couche d'aplatissement)
  • Fully-Connected (Dense) Layer (Couche entièrement connectée (Dense))
  • Fully-Connected RNN Layer (Couche RNN entièrement connectée)
  • Max Pooling Layer (Couche de pooling maximal)
  • Reshape Layer (Couche de remodelage)
  • Up Sampling Layer (Couche d'upsampling)
  • Zero Padding Layer (Couche de remplissage par zéros)

Exemples de résultats d'exécution

1. Exemple de réseau neuronal convolutif

+---------+
| 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

Entraînement: 100% [------------------------------------------------------------------------] Temps: 0:01:55
Précision: 0.987465181058

2. Exemple de réseau Q profond

+----------------+
| 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. Exemple de neuroévolution

+---------------+
| 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

Taille de la population: 100
Générations: 3000
Taux de mutation: 0.01
[0 Meilleur individu - Fitness: 3.08301, Précision: 10.5%]
[1 Meilleur individu - Fitness: 3.08746, Précision: 12.0%]
...
[2999 Meilleur individu - Fitness: 94.08513, Précision: 98.5%]
Précision sur l'ensemble de test: 96.7%

Valeur pédagogique

1. Compréhension approfondie des principes algorithmiques

• En implémentant à partir de zéro, on peut comprendre en profondeur l'idée centrale de chaque algorithme
• La structure du code est claire, ce qui aide à comprendre les détails d'implémentation spécifiques de l'algorithme

2. Pratique des compétences en programmation

• Améliore les compétences d'utilisation des bibliothèques de calcul scientifique comme NumPy
• Apprend à transformer la théorie mathématique en implémentation de code

3. Base pour la recherche et le développement

• Fournit une base pour la recherche et l'amélioration ultérieures des algorithmes
• Aide à comprendre l'implémentation sous-jacente des frameworks d'apprentissage automatique existants

Public cible

• Débutants et apprenants intermédiaires en Machine Learning
• Chercheurs souhaitant comprendre en profondeur les mécanismes internes des algorithmes
• Développeurs désireux d'améliorer leurs compétences en implémentation de code
• Étudiants en filières liées au Machine Learning

Avantages du projet

1. Très pédagogique: Code clair et facile à comprendre, axé sur la valeur d'enseignement
2. Large couverture: Des algorithmes de base aux algorithmes avancés, tout y est
3. Très pratique: Fournit des exemples complets et exécutables
4. Mises à jour continues: Projet actif, ajout constant de nouvelles implémentations d'algorithmes

Points à noter

• Ce projet est principalement destiné à l'enseignement et à l'apprentissage, et ne convient pas à une utilisation en environnement de production.
• L'implémentation des algorithmes privilégie la lisibilité plutôt que l'optimisation des performances.
• Il est recommandé de l'utiliser en conjonction avec l'étude théorique pour de meilleurs résultats.