Un réseau neuronal en Rust et Python implémenté sans utiliser de cadriciels ML/AI.

Contexte

J’ai récemment voulu revenir à l’IA et comme j’aime le langage de programmation Rust, j’ai pensé à en apprendre plus sur l’IA tout en approfondissant mes connaissances avec Rust.

J’ai construit quelques modèles d’IA dans le passé et j’ai suivi quelques cours d’IA (à l’université et en ligne), mais j’avais oublié beaucoup de détails sur les réseaux neuronaux.

Implémentation

J’ai commencé par suivre ce tutoriel :

https://towardsdatascience.com/math-neural-network-from-scratch-in-python-d6da9f29ce65

J’ai commencé par implémenter le réseau neuronal en Rust, puis j’ai rencontré des problèmes que je n’ai pas pu résoudre initialement. J’ai alors décidé de l’implémenter en Python, ce que j’ai réussi à faire.

L’implémentation en Python ressemble beaucoup au code de l’article, mais j’ai essayé de le rendre plus modulaire et plus facile à comprendre pour l’implémentation en Rust.

Performance

Les deux ont des performances comparables car elles sont très similaires. L’implémentation Rust est légèrement plus rapide pour l’exemple XOR, mais l’exemple MNIST est légèrement plus rapide en Python. Je suppose que numpy est plus optimisé que mon implémentation Rust et répartit la charge de travail sur plusieurs threads.

De plus, les deux implémentations sont simples et naïves - elles ne contiennent pas de batching ou d’autres méthodes pour accélérer le processus d’apprentissage.

XOR

L’exemple XOR est un réseau neuronal très simple qui apprend la fonction XOR. Il comporte 2 entrées, 2 couches et 1 sortie. Il est formé à partir de 4 exemples. L’apprentissage est très rapide et la précision est proche de 100 %.

Les implémentations ont des résultats/précisions similaires. J’ai pris le time d’entraîner et d’exécuter sur mon Mac M1 Max où l’implémentation Rust est beaucoup plus rapide que l’implémentation Python :

MNIST

L’exemple MNIST est un réseau neuronal plus complexe qui apprend à reconnaître des chiffres manuscrits. Il comporte 784 entrées (28 x 28), 3 couches et 10 sorties. Il est formé avec 1 000 exemples, car la formation est extrêmement lente - il pourrait être formé avec 60 000 exemples. La précision est d’environ 90 %.

Les implémentations ont à nouveau des résultats/précisions similaires. J’ai pris le time d’entraîner et d’exécuter sur mon Mac M1 Max où l’implémentation Python est beaucoup plus rapide que l’implémentation Rust :

Dans l’ensemble, ce fut une expérience amusante et j’ai beaucoup appris sur les réseaux neuronaux et sur Rust. J’ai hâte d’en apprendre plus sur l’IA et Rust. J’espère pouvoir aborder des sujets plus récents comme les GAN, les Transformers, les LLM, les RAG, etc.