True ML Talks #23 - Applications MLOps et LLMS @ GitLab

Nous sommes de retour avec un autre épisode de True ML Talks. Dans ce cadre, nous approfondissons à nouveau les applications MLOps et LLMS chez GitLab et nous discutons avec Rayon de Monmayuri.

Monmayuri dirige le secteur de la recherche sur l'IA chez GitLab en mettant l'accent sur les LLM au cours de la dernière année. Auparavant, elle était responsable de l'ingénierie au sein de la division ModelOps de GitLab. Elle a également travaillé avec d'autres entreprises comme Microsoft, eBay.

📌

Nos conversations avec Monmayuri porteront sur les aspects suivants :
- Cas d'utilisation du ML et du LLM sur GitLab
- Évolution de l'infrastructure ML de GitLab pour prendre en charge les grands modèles de langage (LLM)
- Le parcours de GitLab avec les LLM : de l'open source à la mise au point
- Formation de grands modèles de langage à GitLab
- Triton contre PyTorch, GPU assemblés et traitement par lots dynamique pour l'inférence LLM
- Défis et recherches liés à l'évaluation des LLM chez GitLab
- L'architecture LLM de GitLab et l'avenir des LLM

Regardez l'épisode complet ci-dessous :

Cas d'utilisation du ML et du LLM @ GitLab

L'apprentissage automatique (ML) transforme le cycle de vie du développement logiciel, et GitLab est à la pointe de cette innovation. GitLab utilise le machine learning pour responsabiliser les développeurs tout au long de leur parcours, qu'il s'agisse de créer des problèmes, de fusionner des demandes ou de déployer des applications.

L'un des cas d'utilisation les plus intéressants du ML chez GitLab concerne les grands modèles de langage (LLM). GitLab utilise LLMS et GenAI pour développer de nouvelles fonctionnalités pour ses produits, telles que la complétion de code et la synthèse des problèmes.

Avantages du ML pour les utilisateurs de GitLab

1. Productivité accrue : Le machine learning peut aider les développeurs à être plus productifs en automatisant des tâches telles que l'achèvement du code et la synthèse des problèmes.
2. Qualité de code améliorée : Le machine learning peut aider les développeurs à écrire un meilleur code en identifiant les erreurs potentielles et en suggérant des améliorations.
3. Temps de développement réduit : Le machine learning peut aider les développeurs à réduire le temps nécessaire au développement de logiciels en automatisant les tâches et en les aidant à identifier et à résoudre les problèmes plus rapidement.
4. Expérience améliorée pour les développeurs : Le ML peut contribuer à améliorer l'expérience des développeurs en facilitant l'utilisation des produits GitLab et en fournissant une assistance et des conseils.

Comment l'infrastructure de machine learning de GitLab a évolué pour prendre en charge les grands modèles de langage (LLM)

GitLab a joué un rôle de premier plan dans l'utilisation de grands modèles de langage (LLM) pour responsabiliser les développeurs. GitLab a donc dû faire évoluer son infrastructure de machine learning pour prendre en charge ces modèles complexes.

Difficultés

1. Taille et complexité : Les LLM sont beaucoup plus volumineux et complexes que les modèles de machine learning traditionnels, ce qui signifie qu'ils nécessitent du matériel et des logiciels plus puissants pour leur formation et leur déploiement.
2. Intégration : Les produits de GitLab sont écrits en Ruby on Rails et en JavaScript. Cela signifie que GitLab a dû trouver des moyens d'intégrer son infrastructure de machine learning à ces technologies.
3. Infrastructure distribuée : L'infrastructure ML de GitLab est distribuée entre plusieurs fournisseurs de cloud différents. Cela signifie que GitLab a dû développer des moyens de gérer son infrastructure de machine learning de manière cohérente et efficace.

Des solutions

Pour relever les défis mentionnés ci-dessus, GitLab a apporté un certain nombre de modifications à son infrastructure de machine learning. Ces changements peuvent être classés dans les domaines suivants :

1. Matériel : GitLab a investi dans de nouveaux matériels, tels que des GPU et des TPU, pour soutenir la formation et le déploiement des LLM.
2. Logiciel : GitLab a développé de nouveaux pipelines de formation et de déploiement pour les LLM. GitLab a également développé un certain nombre de solutions d'intégration pour permettre à son infrastructure ML de fonctionner avec ses applications Ruby on Rails et JavaScript.
3. Gestion : GitLab a développé un certain nombre d'outils et de processus pour aider à gérer son infrastructure de machine learning distribuée.

Le parcours de GitLab avec les LLM : de l'open source à l'optimisation

GitLab a joué un rôle de premier plan dans l'utilisation de grands modèles de langage (LLM) pour responsabiliser les développeurs. Au début, GitLab a commencé par utiliser LLM open source, comme Salesforce code gen. Cependant, à mesure que le paysage a changé et que les LLM sont devenus plus puissants, GitLab a décidé d'affiner ses propres LLM pour des cas d'utilisation spécifiques, tels que la génération de code.

La mise au point des LLM nécessite un investissement important dans l'infrastructure, car ces modèles sont très volumineux et complexes. GitLab a dû développer de nouveaux pipelines de formation et de déploiement pour les LLM, ainsi que de nouvelles méthodes de gestion de son infrastructure ML dans un environnement distribué.

L'un des principaux défis auxquels GitLab a été confronté pour peaufiner les LLM est de trouver le juste équilibre entre coût et latence. Les LLM peuvent être très coûteux à former et à déployer, et ils peuvent également être lents à générer des résultats. GitLab a dû expérimenter différentes tailles de clusters, configurations de GPU et techniques de traitement par lots pour trouver le bon équilibre pour ses besoins.

Un autre défi auquel GitLab a été confronté est de garantir la précision et la fiabilité de ses LLM. Les LLM peuvent être entraînés sur des ensembles de données volumineux de texte et de code, mais ces ensembles de données peuvent également contenir des erreurs et des biais. GitLab a dû développer de nouvelles techniques pour évaluer et débiaiser ses LLM.

Malgré les défis, GitLab a réalisé des progrès significatifs dans l'utilisation des LLM pour responsabiliser les développeurs. GitLab est désormais en mesure de former et de déployer des LLM à grande échelle, et utilise ces modèles pour développer de nouvelles fonctionnalités et de nouveaux produits qui rendront le processus de développement logiciel plus efficace et plus agréable.

Formation de grands modèles de langage à GitLab

La formation de grands modèles linguistiques (LLM) est une tâche difficile qui nécessite un investissement important dans l'infrastructure et les ressources. GitLab a joué un rôle de premier plan dans l'utilisation des LLM pour responsabiliser les développeurs, et l'entreprise a beaucoup appris en cours de route.

Voici quelques idées et leçons tirées de l'expérience de GitLab en matière de formation des LLM :

1. Commencez petit et passez à l'échelle supérieure. Lorsque vous estimez la quantité de ressources GPU nécessaires à l'entraînement, il est préférable de commencer petit et d'augmenter progressivement. Cela vous aidera à éviter le gaspillage de ressources et à identifier rapidement les éventuels goulots d'étranglement.
2. Utilisez le traitement par lots dynamique. Le traitement par lots dynamique peut vous aider à optimiser votre processus d'entraînement en regroupant des entrées similaires. Cela peut entraîner une amélioration significative des performances, en particulier pour les grands ensembles de données.
3. Choisissez les bons paramètres pour lesquels vous souhaitez optimiser. Il n'existe pas d'approche universelle pour choisir les bons paramètres à optimiser lors du réglage précis des LLM. Les meilleurs paramètres varieront en fonction du LLM spécifique, des données d'entraînement et des résultats souhaités. Cependant, il est important d'expérimenter différents paramètres pour trouver la meilleure combinaison pour vos besoins spécifiques.
4. Envisagez de recourir à la formation distribuée. La formation distribuée peut vous aider à accélérer le processus de formation en répartissant la charge de travail entre plusieurs GPU ou machines. Cela peut être particulièrement bénéfique pour la formation de grands LLM sur de grands ensembles de données.
5. Testez le mode d'adaptation de rang inférieur. Le mode d'adaptation de rang inférieur est une technique qui peut être utilisée pour affiner les LLM avec un plus petit nombre de paramètres. Cela peut être utile dans les cas où vous ne disposez pas de suffisamment de ressources pour affiner l'ensemble du modèle.

Outre les informations ci-dessus, GitLab a également tiré un certain nombre de leçons précieuses sur l'importance d'une bonne compréhension du modèle de base et des données d'entraînement. Par exemple, GitLab a découvert qu'il était important de connaître la construction du modèle de base et de savoir comment organiser les données d'entraînement afin de les optimiser pour le cas d'utilisation souhaité.

Triton contre PyTorch, GPU assemblés et traitement par lots dynamique pour l'inférence LLM

GitLab utilise Triton pour l'inférence LLM car il est mieux adapté à l'adaptation au volume élevé de requêtes que GitLab reçoit. Triton est également plus facile à encapsuler et à dimensionner que d'autres serveurs modèles, tels que les serveurs PyTorch.

GitLab n'a pas encore expérimenté les serveurs modèles TGI ou VLLM de Hugging Face, car ceux-ci en étaient encore aux premiers stades de développement lorsque GitLab a déployé pour la première fois son pipeline d'inférence LLM.

En matière de traitement par lots dynamique, la stratégie de GitLab consiste à optimiser en fonction du cas d'utilisation spécifique, de la charge, du niveau de requête, du volume et du nombre de GPU disponibles. Par exemple, si GitLab possède 500 GPU pour un modèle 7B, il peut utiliser une stratégie de traitement par lots différente de celle s'il ne dispose que de quelques GPU pour un modèle plus petit.

GitLab utilise également un ensemble de GPU pour gérer les requêtes. Cela signifie que GitLab utilise un mélange de différents types de GPU, y compris des GPU hautes performances et des GPU moins performants. GitLab équilibre la charge des requêtes sur l'ensemble des GPU afin d'optimiser les performances et les coûts.

Voici quelques conseils pour concevoir une architecture permettant d'organiser des GPU et d'optimiser l'équilibrage de charge :

1. Comprenez vos habitudes de trafic. Quelles sont les heures de pointe de votre trafic ? Quels types de demandes recevez-vous le plus souvent ?
2. Utilisez les tests A/B pour tester différentes configurations de GPU et différentes stratégies d'équilibrage de charge.
3. Surveillez vos performances et votre latence pour vous assurer que votre architecture répond à vos besoins.

Voici quelques exemples spécifiques de la manière dont GitLab a optimisé son architecture pour les GPU assemblés et le traitement par lots dynamique :

1. GitLab utilise un système d'orchestration dynamique pour attribuer des requêtes aux GPU en fonction de leur type, de leurs performances et de leur disponibilité.
2. GitLab utilise une technique appelée « échauffement du GPU » pour s'assurer que les GPU sont prêts à traiter les demandes en cas de besoin.
3. GitLab utilise la quantification pour réduire la taille de ses modèles sans sacrifier la précision.

En suivant ces conseils, vous pouvez concevoir une architecture capable de gérer efficacement de grands volumes de demandes d'inférence LLM.

Nous avons également essayé le streaming, et je pense que nous étudions également le streaming pour nos tiers - Monmayuri

Défis et recherches liés à l'évaluation des LLM chez GitLab

L'évaluation des performances des grands modèles de langage (LLM) est une tâche difficile. GitLab a travaillé sur ce problème et a dû faire face à plusieurs défis, notamment :

1. Les différents cas d'utilisation ont des besoins différents. Les différents cas d'utilisation du LLM, tels que le chat, la suggestion de code et l'explication des vulnérabilités, ont des besoins différents et nécessitent des mesures d'évaluation différentes.
2. Il est difficile de savoir quel modèle fonctionne le mieux pour une requête donnée. Il est difficile de déterminer quel LLM fonctionnera le mieux sur une requête donnée, en particulier en production.
3. Il est difficile de trouver un équilibre entre précision et taux d'acceptation. Il est important de trouver un équilibre entre la précision des résultats du LLM et le taux d'acceptation de ces résultats par les utilisateurs.

GitLab répond à ces défis en :

1. Création d'un bon ensemble de données pour chaque cas d'utilisation. GitLab organise un ensemble de données pour chaque cas d'utilisation de LLM qui est représentatif des types de requêtes que les utilisateurs soumettront en production.
2. Analyse des données historiques. GitLab analyse les données historiques pour comprendre comment les LLM se sont comportés sur différents types de requêtes par le passé.
3. Élaboration de nouveaux paramètres d'évaluation. GitLab développe de nouvelles métriques d'évaluation adaptées à des cas d'utilisation spécifiques du LLM.
4. Utiliser les données pour orienter la prise de décisions. GitLab utilise les données pour prendre des décisions concernant les LLM à utiliser pour différents cas d'utilisation et la manière de régler les paramètres de ces LLM.

L'objectif de GitLab est de développer une approche évolutive et basée sur les données pour évaluer les LLM. Cette approche aidera GitLab à s'assurer que ses LLM fonctionnent bien en production et répondent aux besoins de ses utilisateurs.

Orientations de recherche

GitLab mène également des recherches sur de nouvelles méthodes d'évaluation des LLM. Parmi les axes de recherche explorés par GitLab, citons :

1. Utilisation des données d'interaction homme-machine (HCI) pour évaluer les LLM. Les données HCI peuvent fournir des informations sur la façon dont les utilisateurs interagissent avec les LLM et sur la façon dont ils perçoivent les résultats de ces interactions. Ces données peuvent être utilisées pour développer de nouvelles mesures d'évaluation pour les LLM.
2. Utiliser des méthodes contradictoires pour évaluer les LLM. Des méthodes contradictoires peuvent être utilisées pour générer des entrées conçues pour inciter les LLM à commettre des erreurs. Ces données peuvent être utilisées pour évaluer la robustesse des LLM à différents types d'erreurs.
3. Utiliser l'apprentissage par transfert pour évaluer les LLM. L'apprentissage par transfert peut être utilisé pour évaluer les LLM sur de nouvelles tâches sans avoir à collecter un nouvel ensemble de données pour chaque tâche. Cela peut être utile pour évaluer les LLM sur des tâches pour lesquelles la collecte de données est difficile ou coûteuse.

Les recherches de GitLab sur l'évaluation des LLM sont en cours. GitLab s'engage à développer de nouvelles méthodes innovantes pour évaluer les LLM afin de s'assurer que ses LLM répondent aux besoins de ses utilisateurs.

L'architecture LLM de GitLab et l'avenir des LLM

L'architecture LLM de GitLab est une approche complète de la formation, de l'évaluation et déploiement de LLM. L'architecture est conçue pour être flexible et évolutive, afin que GitLab puisse facilement adopter de nouvelles technologies et répondre aux besoins de ses utilisateurs.

L'architecture comprend plusieurs éléments clés :

1. Prétraitement des données et tokenisation : L'architecture LLM de GitLab commence par le prétraitement et la tokenisation des données qui seront utilisées pour former le LLM. Ce processus implique le nettoyage des données, la suppression du bruit et la conversion du texte dans un format compréhensible par le LLM.
2. Échantillonnage et raccourcissement : Une fois les données prétraitées et tokenisées, l'architecture LLM de GitLab échantillonne et raccourcit les données. Ceci est fait pour réduire le coût de calcul de la formation du LLM.
3. Suites de processeurs graphiques : L'architecture LLM de GitLab utilise des suites de GPU pour entraîner le LLM. Les GPU sont des processeurs spécialisés parfaitement adaptés à la formation des LLM.
4. Suite d'évaluation : L'architecture LLM de GitLab comprend une suite d'évaluation pour évaluer les performances du LLM. La suite d'évaluation comprend une variété de paramètres, tels que la précision, la fluidité et la cohérence.
5. Points de contrôle modèles : L'architecture LLM de GitLab stocke les points de contrôle des modèles à intervalles réguliers. Cela permet à GitLab de reprendre la formation à partir d'un point précédent en cas de problème.
6. Bibliothèque rapide : L'architecture LLM de GitLab inclut une bibliothèque d'invites, qui est une collection d'invites pouvant être utilisées pour générer différents types de texte à partir du LLM.
7. Registre des modèles : L'architecture LLM de GitLab comprend un registre de modèles, qui est un référentiel central pour tous les modèles LLM de GitLab.
8. Moteur de déploiement : L'architecture LLM de GitLab inclut un moteur de déploiement qui déploie le LLM en production. Le moteur de déploiement comprend un équilibreur de charge pour répartir le trafic entre plusieurs instances du LLM.

L'architecture LLM de GitLab est un outil puissant qui permet à GitLab de former, d'évaluer et de déployer des LLM à grande échelle. L'architecture est conçue pour être flexible et évolutive, afin que GitLab puisse facilement adopter les nouvelles technologies et répondre aux besoins de ses utilisateurs.

L'avenir des LLM

Les LLM sont encore une technologie relativement nouvelle, mais ils ont le potentiel de révolutionner de nombreux secteurs. GitLab estime que les LLM auront un impact significatif sur l'industrie du développement de logiciels.

GitLab utilise déjà les LLM pour améliorer ses produits et services. Par exemple, GitLab utilise des LLM pour générer des suggestions de code, expliquer les vulnérabilités et améliorer l'expérience utilisateur de ses produits.

GitLab estime que d'autres organisations devraient également investir dans les LLM. Les LLM ont le potentiel d'améliorer la productivité, l'efficacité et la qualité dans de nombreux secteurs.

Les domaines dans lesquels investir

GitLab recommande aux organisations d'investir dans les domaines suivants pour garder une longueur d'avance dans le domaine du LLM :

1. Infrastructures : Les LLM nécessitent un investissement important dans les infrastructures. Les entreprises doivent investir dans les GPU, le stockage et la mise en réseau pour prendre en charge les LLM.
2. Outils et technologies : Il existe un certain nombre d'outils et de technologies qui peuvent aider les organisations à former, évaluer et déployer des LLM. Les organisations devraient investir dans les outils et les technologies qui répondent le mieux à leurs besoins.
3. Talent : Les LLM sont une technologie complexe. Les organisations doivent investir dans des talents dotés des compétences et des connaissances nécessaires pour former, évaluer et déployer des LLM.

En investissant dans ces domaines, les organisations peuvent garder une longueur d'avance dans le domaine du LLM et bénéficier des avantages de cette puissante technologie.

Lisez nos précédents articles de la série True ML Talks :

‍

True ML Talks #21 -LLM, Machine Learning Platform @ Voiceflow

In this blog, we dive deep into Machine Learning Platform at Voiceflow. Understand their ML architecture, and how Generative AI and LLM’s are used at Voiceflow.

TrueFoundry Blog TrueFoundry

‍

Continuez à regarder le TrueML série youtube et en lisant le TrueML série de blogs.

True Foundry est un PaaS de déploiement de machine learning sur Kubernetes destiné à accélérer les flux de travail des développeurs tout en leur offrant une flexibilité totale dans les tests et le déploiement de modèles, tout en garantissant une sécurité et un contrôle complets à l'équipe Infra. Grâce à notre plateforme, nous permettons aux équipes de machine learning de déployer et surveiller des modèles en 15 minutes avec une fiabilité à 100 %, une évolutivité et la possibilité de revenir en arrière en quelques secondes, ce qui leur permet de réduire les coûts et de mettre les modèles en production plus rapidement, ce qui permet de réaliser une véritable valeur commerciale.