Analyser les bugs dans les frameworks de deep learning

Les frameworks de deep learning (DLFs) sont des outils qui aident les devs à créer des applis d'intelligence artificielle (IA). Ils sont super importants parce qu'ils permettent aux utilisateurs de concevoir, former et tester des modèles qui apprennent à partir des données. Avec leur popularité grandissante, ces frameworks se retrouvent dans plein d'applis différentes.

Un des défis auxquels les devs font face, c'est que la plupart des DLFs utilisent plusieurs langages de programmation (PLs). Par exemple, des frameworks comme TensorFlow utilisent souvent à la fois Python et C++. Quand il y a plusieurs langages, des Bugs peuvent apparaître, et c'est pas toujours facile de les débusquer. Comprendre ces bugs, surtout ceux liés à l'utilisation de plusieurs langages, est essentiel pour développer de meilleurs frameworks.

Dans cette étude, nous avons analysé de près 1 497 bugs trouvés dans trois DLFs : MXNet, PyTorch, et TensorFlow. En examinant ces bugs, on les a classés en différents types, on a regardé leur impact sur le développement, et on a exploré comment les bugs impliquant plusieurs langages diffèrent de ceux qui n'en impliquent pas.

#L'Importance des DLFs

Les DLFs jouent un rôle majeur dans le développement d'applis IA. Ils fournissent des blocs de construction essentiels pour travailler avec des modèles de deep learning. À mesure que l'usage de l'IA augmente, le besoin de DLFs fiables et efficaces devient encore plus crucial. Les bugs dans ces frameworks peuvent créer des soucis qui affectent leur fiabilité, ce qui peut, à son tour, impacter la qualité et la performance globale des applis IA.

Pour qu'un framework soit fiable, c'est nécessaire de comprendre la nature des bugs qui surgissent. Les études précédentes sur les bugs des DLFs peuvent être catégorisées en deux groupes :

1. Bugs dans le framework lui-même, comme des défauts de conception ou des erreurs de codage.
2. Bugs résultant de la manière dont les utilisateurs interagissent avec le framework, comme des problèmes de performance.

Les deux catégories sont importantes à traiter pour créer des DLFs robustes.

#Classification des Bugs dans les DLFs

Dans notre enquête, on a classé 1 497 bugs de MXNet, PyTorch et TensorFlow en 12 types distincts. Ces types aident à mieux comprendre d'où viennent les problèmes et ce qui doit être corrigé.

1. Bugs de Conception d'Algorithme : Problèmes liés à des erreurs dans la formulation des algorithmes dans le framework.
2. Bugs de Build : Problèmes qui apparaissent lors de la compilation ou de la préparation du framework pour utilisation.
3. Bugs de Code : Erreurs de logique ou fautes dans le code écrit qui peuvent entraîner un comportement inattendu.
4. Bugs de Données : Problèmes qui surviennent lors du traitement des données avant de les introduire dans un modèle.
5. Bugs de Déploiement : Problèmes qui surgissent lors du déplacement ou du partage d'un modèle entraîné entre différents environnements.
6. Bugs de Documentation : Fautes ou omissions dans la documentation du framework qui peuvent embrouiller les utilisateurs.
7. Bugs de Mémoire : Erreurs liées à l'utilisation de la mémoire par le framework, souvent entraînant des crashs ou des ralentissements.
8. Bugs de Performance : Problèmes qui entraînent une vitesse ou une efficacité insatisfaisante dans les opérations du framework.
9. Bugs de Processeur : Problèmes qui se produisent lorsque le modèle fonctionne sur certains processeurs ou configurations matérielles.
10. Bugs de Test : Échecs dans le processus de test, comme des cas de test manquants ou des erreurs dans le code d'exemple.
11. Bugs de Compatibilité de Version : Problèmes qui surviennent à cause de changements dans la version du framework entraînant des soucis de compatibilité.
12. Bugs de Visualisation : Erreurs qui apparaissent lors de la tentative de visualisation des résultats de modèles construits avec le framework.

En classant les bugs, les devs peuvent identifier les types les plus courants et prioriser leur correction.

#Impacts des Bugs sur le Développement

On a découvert que différents types de bugs ont divers impacts sur le développement des DLFs. Pour mesurer ces impacts, on a regardé dans trois domaines principaux : la durée pendant laquelle les bugs restent ouverts avant d'être corrigés, la complexité des changements de code nécessaires pour corriger les bugs, et le niveau de communication requis entre les devs pendant la correction.

#Durée d'Ouverture des Bugs

La durée d'ouverture fait référence à la durée pendant laquelle un bug existe avant d'être résolu. Les bugs peuvent prendre du temps à être corrigés selon leur complexité. Par exemple, les bugs de déploiement prennent souvent plus de temps à être réglés par rapport aux bugs de build. D'après notre analyse, les bugs de déploiement, de documentation et de mémoire ont tendance à rester ouverts le plus longtemps, tandis que les bugs de build sont généralement résolus plus rapidement.

#Complexité des Changements de Code

La complexité des changements de code reflète combien il est difficile pour les devs d'implémenter des corrections. On a examiné trois indicateurs de complexité :

• Lignes de Code Modifiées (LOCM) : Combien de lignes dans le code doivent être changées pour corriger un bug.
• Nombre de Fichiers Modifiés (NOFM) : Le nombre total de fichiers différents affectés par la correction du bug.
• Entropie : Une mesure d'incertitude ou de confusion dans le processus de correction des bugs.

Les bugs de mémoire, de conception d'algorithme, et de déploiement nécessitaient le plus de lignes de code à changer dans les trois frameworks. En revanche, les bugs de performance nécessitaient généralement moins de modifications.

#Complexité de Communication

La complexité de communication examine combien de devs sont impliqués et combien de discussions sont nécessaires pour résoudre les bugs. Les bugs de mémoire, de déploiement, et de processeur ont été identifiés comme ayant la plus haute complexité en termes de communication. Cela signifie que ces bugs nécessitent souvent l'avis de plusieurs membres de l'équipe pour être corrigés.

#Bugs Multi-Langages de Programmation

On s'est spécifiquement penchés sur les bugs qui impliquent l'utilisation de plusieurs langages de programmation, que l'on a appelés bugs multi-langages de programmation (MPL). Ces bugs peuvent être plus difficiles à traiter que les bugs à langage unique (SPL).

D'après notre analyse :

• 28,6% des bugs dans MXNet étaient des bugs MPL.
• 31,4% des bugs dans PyTorch étaient des bugs MPL.
• 16,0% des bugs dans TensorFlow étaient des bugs MPL.

La combinaison de Python et C/C++ était la plus courante pour corriger ces bugs. Ce duo est populaire parmi les devs car il permet de profiter des fonctionnalités conviviales de Python tout en tirant parti des performances de C/C++.

#Comparaison des Bugs MPL et SPL

En comparant les bugs MPL et SPL, on a constaté que corriger les bugs MPL nécessite souvent plus de changements de code que les bugs SPL. De plus, aucun indicateur ne montrait que les bugs MPL étaient plus faciles à corriger. En fait, ils prenaient généralement plus de temps à résoudre et nécessitaient plus de discussions en équipe, surtout dans PyTorch.

#Conclusion et Directions Futures

Dans cette étude, on a examiné les bugs dans trois grands frameworks de deep learning-MXNet, PyTorch, et TensorFlow. En classant 1 497 bugs en 12 types, on a fourni des informations précieuses sur leur impact sur le développement et les défis posés par l'utilisation de plusieurs langages de programmation.

1. Classification des Bugs : L'étude a identifié avec succès 12 types différents de bugs, mettant en avant les bugs de données comme les plus courants dans tous les DLFs.
2. Impact sur le Développement : Les bugs de déploiement et de mémoire sont particulièrement problématiques, nécessitant souvent plus de temps et d'efforts pour être corrigés.
3. Bugs MPL : Une portion significative des bugs concernait plusieurs langages de programmation, ce qui complique le processus de correction.

Pour l'avenir, on vise à élargir nos recherches en rassemblant plus de données sur les bugs et en créant des modèles pour prédire leur apparition. On est aussi intéressés à étudier les bugs MPL dans d'autres domaines logiciels pour développer des conclusions plus généralisées.

En comprenant et en traitant ces bugs efficacement, les devs peuvent améliorer la qualité des frameworks de deep learning et, finalement, des applis IA qui en dépendent.