Un guide du débutant sur LLMOps pour l’ingénierie de l’apprentissage automatique

Un guide complet pour les débutants sur LLMOps dans le domaine de l'ingénierie de l'apprentissage automatique

Introduction

La sortie du ChatGPT d’OpenAI a suscité beaucoup d’intérêt pour les grands modèles linguistiques (LLM) et tout le monde parle maintenant d’intelligence artificielle. Mais ce ne sont pas seulement des conversations amicales ; la communauté de l’apprentissage automatique (ML) a introduit un nouveau terme appelé LLMOps. Nous avons tous entendu parler de MLOps, mais qu’est-ce que LLMOps ? Eh bien, il s’agit de la façon dont nous traitons et gérons ces puissants modèles linguistiques tout au long de leur cycle de vie.

Les LLM transforment la façon dont nous créons et entretenons des produits animés par l’IA, et ce changement nécessite de nouveaux outils et de meilleures pratiques. Dans cet article, nous allons décortiquer LLMOps et son contexte. Nous examinerons également les différences entre la création de produits d’IA avec des LLM et les modèles ML traditionnels. De plus, nous examinerons les différences entre MLOps (opérations d’apprentissage automatique) et LLMOps en raison de ces différences. Enfin, nous discuterons des développements passionnants à venir dans le monde de LLMOps.

Objectifs d’apprentissage :

• Acquérir une compréhension solide de LLMOps et de son développement.
• Apprendre à construire un modèle en utilisant LLMOps à travers des exemples.
• Connaître les différences entre LLMOps et MLOps.
• Avoir un aperçu du futur de LLMOps.

Cet article a été publié dans le cadre du Blogathon des Sciences de données.

• Luda, une entreprise innovante spécialisée dans l’IA, révèle un système révolutionnaire d’apprentissage par renforcement en temps réel.
• L’IA générative dans la finance FinGPT, BloombergGPT et au-delà
• Applications de conversation avec de grands modèles linguistiques comprenant la séquence des entrées utilisateur, des instructions et des réponses

Qu’est-ce que LLMOps ?

LLMOps signifie Large Language Model Operations, similaire à MLOps mais spécifiquement conçu pour les grands modèles linguistiques (LLM). Cela nécessite l’utilisation de nouveaux outils et de meilleures pratiques pour gérer tout ce qui est lié aux applications alimentées par les LLM, du développement au déploiement et à la maintenance continue.

Pour mieux comprendre cela, analysons ce que signifient LLM et MLOps :

• Les LLM sont de grands modèles linguistiques capables de générer des langues humaines. Ils possèdent des milliards de paramètres et sont entraînés sur des milliards de données textuelles.
• MLOps (opérations d’apprentissage automatique) est un ensemble d’outils et de pratiques utilisés pour gérer le cycle de vie des applications alimentées par l’apprentissage automatique.

Maintenant que nous avons expliqué les bases, plongeons plus profondément dans ce sujet.

Pourquoi tout ce battage autour de LLMOps ?

Tout d’abord, des LLM comme BERT et GPT-2 existent depuis 2018. Pourtant, c’est maintenant, près de cinq ans plus tard, que nous assistons à une montée en flèche de l’idée de LLMOps. La principale raison en est que les LLM ont attiré beaucoup l’attention des médias avec la sortie du ChatGPT en décembre 2022.

Depuis lors, nous avons vu de nombreux types d’applications différentes exploitant la puissance des LLM. Cela comprend des chatbots allant d’exemples familiers tels que ChatGPT, à des assistants personnels d’écriture pour l’édition ou la résumé (par exemple, Notion AI) et des assistants talentueux pour la rédaction de textes (par exemple, Jasper et copy.ai). Cela comprend également des assistants de programmation pour l’écriture et le débogage de code (par exemple, GitHub Copilot), le test du code (par exemple, Codium AI), et l’identification des problèmes de sécurité (par exemple, Socket AI).

Avec de nombreuses personnes développant et mettant en production des applications alimentées par les LLM, les gens apportent leurs expériences.

“Il est facile de faire quelque chose de cool avec les LLM, mais très difficile de créer quelque chose de prêt pour la production avec eux.” – Chip Huyen

Il est clair que la création d’applications prêtes pour la production alimentées par des LLM présente son propre ensemble de difficultés, distinct de la création de produits d’IA avec des modèles ML classiques. Nous devons développer de nouveaux outils et de meilleures pratiques pour faire face à ces défis afin de gérer le cycle de vie de l’application LLM. Ainsi, nous constatons une utilisation étendue du terme “LLMOps”.

Quelles sont les étapes impliquées dans LLMOps?

Les étapes impliquées dans LLMOps sont au moins similaires à MLOps. Cependant, les étapes de construction d’une application alimentée par LLM sont différentes en raison du commencement des modèles de base. Au lieu de former des LLM à partir de zéro, l’accent est mis sur la domestication des LLM pré-entraînés pour les tâches suivantes.

Déjà il y a plus d’un an, Andrej Karpathy a expliqué comment le processus de construction de produits d’IA évoluera à l’avenir:

“Mais la tendance la plus importante est que le processus de formation d’un réseau neuronal à partir de zéro pour une tâche cible devient rapidement obsolète en raison du fine-tuning, en particulier avec l’émergence de modèles de base comme GPT. Ces modèles de base sont formés par seulement quelques institutions disposant de ressources informatiques substantielles, et la plupart des applications sont réalisées via un fine-tuning léger d’une partie du réseau, du génie de prompt, ou d’une étape facultative de traitement des données ou du modèle en réseaux d’inférence plus petits et spécialisés.” – Andrej Karpathy.

Cette citation peut être époustouflante la première fois que vous la lisez. Mais elle résume exactement tout ce qui se passe ces derniers temps, nous allons donc le décrire étape par étape dans les sous-sections suivantes.

Étape 1: Sélection d’un modèle de base

Les modèles de base sont des LLM pré-entraînés sur de grandes quantités de données et peuvent être utilisés pour une large gamme de tâches. Parce que l’entraînement d’un modèle de base à partir de zéro est difficile, long et extrêmement coûteux, seules quelques institutions disposent des ressources de formation requises.

Pour mettre les choses en perspective, selon une étude de Lambda Labs en 2020, la formation de GPT-3 de OpenAI (avec 175 milliards de paramètres) nécessiterait 355 ans et 4,6 millions de dollars en utilisant une instance cloud Tesla V100.

L’IA traverse actuellement ce que la communauté appelle son “moment Linux”. Actuellement, les développeurs doivent choisir entre deux types de modèles de base en fonction d’un équilibre entre performance, coût, facilité d’utilisation et flexibilité des modèles propriétaires ou des modèles open-source.

Les modèles exclusifs ou propriétaires sont des modèles de base fermés possédés par des entreprises disposant d’équipes d’experts et de budgets importants en IA. Ils sont généralement plus grands que les modèles open-source et offrent de meilleures performances. Ils sont également achetés et généralement assez faciles à utiliser. Le principal inconvénient des modèles propriétaires est leur coûteuse interface de programmation (API). De plus, les modèles de base de sources fermées offrent moins ou aucune flexibilité d’adaptation pour les développeurs.

Des exemples de fournisseurs de modèles propriétaires sont:

• OpenAI (GPT-3, GPT-4)
• co:here
• Anthropic (Claude)
• AI21 Labs (Jurassic-2)

Les modèles open-source sont fréquemment organisés et hébergés sur HuggingFace en tant que plateforme communautaire. En général, ce sont des modèles plus petits avec des capacités moins élevées que les modèles propriétaires. Mais, d’un autre côté, ils sont moins chers que les modèles propriétaires et offrent plus de flexibilité aux développeurs.

Des exemples de modèles open-source sont:

• Stable Diffusion par Stability AI
• BLOOM par BigScience
• LLaMA ou OPT par Meta AI
• Flan-T5 par Google

Code:

Cette étape consiste à importer toutes les bibliothèques requises.

from transformers import GPT2LMHeadModel, GPT2Tokenizer# Can you load pre-trained GPT-3 model and tokenizermodel = GPT2LMHeadModel.from_pretrained("gpt2")tokenizer = GPT2Tokenizer.from_pretrained("gpt2")

Résultat du code ci-dessus:

Étape 2: Adapter aux tâches suivantes

Une fois que vous avez choisi votre modèle de base, vous pouvez accéder à LLM via son API. Si vous travaillez habituellement avec d’autres API, travailler avec les API de LLM vous semblera principalement un peu étrange car il n’est pas toujours clair quelles entrées entraîneront quelles sorties. En fonction de la requête textuelle, l’API renvoie une complétion textuelle en essayant de correspondre à votre modèle.

Voici un exemple de l’utilisation de l’API OpenAI. Vous fournissez l’entrée API sous la forme d’une invitation, par exemple, invitation = “Corrigez cela en anglais standard:\n\nHe no went to the market.”

import openaiopenai.api_key = ...response = openai.Completion.create(engine = "text-davinci-003", prompt = "Corrigez cela en anglais standard:\n\nHe no went to the market.", # ...)

L’API renverra une réponse contenant la réponse complétée [‘choices’] [0] [‘text’] = “He did not go to the market.”

Le principal défi est que les LLM ne sont pas puissants malgré leur puissance, et donc, la question clé est: comment obtenez-vous un LLM pour obtenir la sortie souhaitée?

Une préoccupation mentionnée dans l’enquête en production sur les LLM était l’exactitude du modèle et l’hallucination. Cela signifie que l’obtention de la sortie de l’API LLM dans le format souhaité peut nécessiter quelques itérations, et aussi, les LLM peuvent halluciner s’ils n’ont pas les connaissances spécifiques requises. Pour faire face à ces préoccupations, vous pouvez adapter les modèles de base aux tâches suivantes de la manière suivante:

• Le génie des invitations est une technique permettant d’améliorer la source afin que la sortie corresponde à vos attentes. Vous pouvez utiliser différentes astuces pour améliorer votre invitation (voir OpenAI Cookbook). Une méthode consiste à fournir quelques exemples du format de sortie attendu. Cela ressemble à un apprentissage sans étiquette ou à un apprentissage à quelques étiquettes. Des outils tels que LangChain ou HoneyHive sont déjà disponibles pour vous aider à gérer et à versionner vos modèles d’invitation.

• Le fine-tuning des modèles pré-entraînés est une technique courante en apprentissage automatique. Cela peut aider à améliorer les performances et la précision de votre modèle pour votre tâche spécifique. Bien que cela augmente les efforts d’entraînement, cela peut réduire le coût de l’inférence. Le coût des API LLM dépend de la longueur de la séquence d’entrée et de sortie. Ainsi, en réduisant le nombre de jetons d’entrée, vous réduisez les coûts des API car vous n’avez plus besoin de fournir d’exemples dans l’invitation.

• Données externes: Les modèles de base manquent souvent d’informations contextuelles (par exemple, l’accès à certains documents spécifiques) et peuvent rapidement devenir obsolètes. Par exemple, GPT-4 a été formé sur des données jusqu’en septembre 2021. Étant donné que les LLM peuvent imaginer des choses s’ils n’ont pas suffisamment d’informations, nous devons pouvoir leur donner accès à des données externes importantes.
• Embeddings: Une méthode légèrement plus complexe consiste à extraire des informations sous forme d’embeddings à partir des API LLM (par exemple, des descriptions de produits) et à construire des applications dessus (par exemple, recherche, comparaison, recommandations).

li>Alternatives: Comme ce domaine évolue rapidement, il existe de nombreuses autres applications de LLM dans les produits d’IA. Quelques exemples sont l’affinage des invitations/tâches et l’affinage des modèles.

Code:

from transformers import GPT2LMHeadModel, GPT2Tokenizer, TextDataset, Trainer, TrainingArguments# Load your datasetdataset = TextDataset(tokenizer=tokenizer, file_path="your_dataset.txt")# Fine-tune the modeltraining_args = TrainingArguments(output_dir="./your_fine_tuned_model", overwrite_output_dir=True, num_train_epochs=3, per_device_train_batch_size=4,)trainer = Trainer(model=model, args=training_args, data_collator=data_collator, train_dataset=dataset,)trainer.train()trainer.save_model()

Étape 3: Évaluation du modèle

Dans le cadre de la MLOps classique, les modèles ML sont démontrés sur un ensemble de validation détenu avec une métrique qui indique les performances des modèles. Mais comment évaluez-vous l’exécution d’un LLM? Comment décidez-vous si une sortie est bonne ou mauvaise? Actuellement, il semble que les organisations testent leurs modèles en A/B.

Pour aider à évaluer les LLM, des outils tels que HoneyHive ou HumanLoop ont été développés.

Code:

from transformers import pipeline# Créez un pipeline de génération de texte
generator = pipeline("text-generation", model="your_fine_tuned_model")# Générer du texte et évaluer
generated_text = generator("Texte d'indication")print(generated_text)

Étape 4 : Déploiement et surveillance

La performance des LLMs peut varier considérablement entre les versions. Par exemple, OpenAI a mis à jour ses modèles pour lutter contre la génération de contenu inapproprié, tel que les discours de haine. En conséquence, la recherche de la phrase “en tant que modèle de langue IA” sur Twitter révèle désormais de nombreux bots.

Des outils de surveillance des LLMs commencent déjà à apparaître, tels que Whylabs ou HumanLoop.

Code :

# Importez les bibliothèques nécessaires
from flask import Flask, request, jsonify
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import logging
# Initialiser l'application Flask
app = Flask(__name__)
# Vous pouvez charger le modèle GPT-2 et le tokenizer pré-entraînés
model = GPT2LMHeadModel.from_pretrained("./your_fine_tuned_model")
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
# Configurer le logging
logging.basicConfig(filename='app.log', level=logging.INFO)
# Définir une route pour la génération de texte
@app.route('/generate_text', methods=['POST'])
def generate_text():
    try:
        data = request.get_json()
        prompt = data['prompt']
        # Générer du texte
        generated_text = model.generate(
            tokenizer.encode(prompt, return_tensors='pt'),
            max_length=100,  # Ajuster la longueur maximale selon les besoins
            num_return_sequences=1,
            no_repeat_ngram_size=2,
            top_k=50,
            top_p=0.95,
        )[0]
        generated_text = tokenizer.decode(generated_text, skip_special_tokens=True)
        # Enregistrer la requête et la réponse
        logging.info(f"Texte généré pour l'indication : {prompt}")
        logging.info(f"Texte généré : {generated_text}")
        return jsonify({'generated_text': generated_text})
    except Exception as e:
        # Enregistrer les exceptions
        logging.error(f"Erreur : {str(e)}")
        return jsonify({'error': 'Une erreur s\'est produite'}), 500
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Fonctionnement du code ci-dessus :

1. Importer les bibliothèques nécessaires : Cela signifie importer les bibliothèques et modules requis. Flask est utilisé pour construire des applications web, transformers est utilisé pour manipuler le modèle GPT-2, et logging est utilisé pour enregistrer les informations.
2. Initialiser l’application Flask.
3. Charger le modèle : Vous pouvez charger le modèle GPT-2 pré-entraîné et le tokenizer correspondant. Vous pouvez les remplacer ./your_fine_tuned_model par le chemin vers votre modèle GPT-2 réellement finement ajusté.
4. Configurer le logging : Cela enregistre les informations dans l’application. Il définit le nom du fichier de log sur app.log et définit le niveau de logging sur INFO.
5. Configurer une route en utilisant Flask : Cela spécifie qu’une requête POST vers l’endpoint /generate_text doit appeler la fonction generate_text.
6. Génération de texte : Ce code extrait les données JSON de la requête POST entrante. Il suppose que les données JSON incluent un champ “prompt”, qui est le texte qui sera utilisé pour générer du texte additionnel.
7. Génération de texte en utilisant GPT-2 : Cette section utilise le modèle GPT-2 chargé et le tokenizer pour générer du texte en fonction de l’indication fournie. Elle définit différents paramètres de génération, tels que la longueur maximale du texte généré, le nombre de séquences à générer et les paramètres d’échantillonnage.
8. Décoder et renvoyer le texte généré : Après avoir généré le texte, il décode les séquences générées et supprime les jetons spéciaux. Ensuite, il renvoie le texte généré sous forme de réponse JSON.
9. Enregistrer la requête et la réponse : Il enregistre l’indication de la requête et le texte généré dans le fichier de log.
10. Gérer les exceptions : Si des exceptions surviennent pendant le processus de génération de texte, elles sont capturées et enregistrées en tant qu’erreurs. Une sortie JSON avec un message d’erreur est renvoyée avec un code d’état 500 pour indiquer une erreur du serveur.
11. Exécution de l’application Flask : Cela garantit que l’application Flask est exécutée uniquement lorsque le script est exécuté directement. Elle exécute l’application sur l’hôte ‘0.0.0.0’ et le port 5000, ce qui la rend accessible depuis n’importe quelle adresse IP.

Résultat du code ci-dessus:

Invite de saisie:

#{    "prompt": "Il était une fois"}Invite de sortie:{    "generated_text": "Il était une fois, dans un pays lointain, vivait un..."}import csv

Comment LLMOps diffère de MLOps ?

Les différences entre MLOps et LLMOps découlent des différences dans la façon dont nous développons des produits d’IA avec des modèles d’apprentissage automatique classiques par rapport aux LLMs. Les différences affectent principalement la gestion des données, l’expérimentation, l’évaluation, le coût et la latence.

Gestion des données

Dans les MLOps classiques, nous sommes habitués aux modèles d’apprentissage automatique avides de données. Former un réseau neuronal à partir de zéro nécessite beaucoup de données labellisées, et même affiner un modèle pré-entraîné nécessite au moins quelques centaines d’échantillons. Cependant, le nettoyage des données est essentiel au processus de développement de l’apprentissage automatique, car nous savons et acceptons que les grands ensembles de données présentent des défauts.

Dans les LLMOps, l’affinage est similaire aux MLOps. Mais l’ingénierie des invites est une circonstance d’apprentissage sans prise de vue ou à quelques prises de vue. Cela signifie que nous disposons de peu d’échantillons, mais soigneusement choisis.

Expérimentation

Dans les MLOps, l’investigation ressemble à celle que vous entraîniez un modèle à partir de zéro ou à celle que vous affiniez un modèle pré-entraîné. Dans les deux cas, vous dirigerez les entrées, telles que l’architecture du modèle, les hyperparamètres et les augmentations de données, ainsi que les sorties, telles que les métriques.

Mais dans les LLMOps, la question est de savoir s’il faut concevoir des invites ou les affiner. Cependant, l’affinage ressemblera aux MLOps dans les LLMOps, tandis que l’ingénierie des invites implique une configuration d’expérimentation différente impliquant la gestion des invites.

Évaluation

Dans les MLOps classiques, un ensemble de validation avec une métrique d’évaluation évalue les performances d’un modèle. Étant donné qu’il est plus difficile d’évaluer les performances des LLMs, actuellement, les organisations semblent utiliser des tests A/B.

Coût

Alors que le coût des MLOps traditionnels réside généralement dans la collecte des données et la formation des modèles, le coût des LLMOps réside dans l’inférence. Bien que nous puissions nous attendre à certains coûts liés à l’utilisation d’API coûteuses pendant l’expérimentation, Chip Huyen montre que le coût des invites longues réside dans l’inférence.

Vitesse

Une autre préoccupation mentionnée dans l’enquête sur les LLM en production était la latence. La longueur de complétion d’un LLM affecte considérablement la latence. Bien que les préoccupations concernant la latence existent également dans les MLOps, elles sont beaucoup plus importantes dans les LLMOps car il s’agit d’un problème majeur pour la vélocité de l’expérimentation pendant le développement et l’expérience utilisateur en production.

L’avenir des LLMOps

Les LLMOps sont un domaine émergent. Avec la vitesse à laquelle cet espace évolue, il est difficile de faire des prédictions. Il est même douteux que le terme “LLMOps” soit là pour rester. Nous sommes seulement certains que nous verrons de nombreux nouveaux cas d’utilisation des LLMs et des outils ainsi que les meilleures tentatives pour gérer le cycle de vie des LLMs.

Le domaine de l’IA est en pleine croissance, ce qui rend potentiellement tout ce que nous écrivons maintenant obsolète dans un mois. Nous en sommes encore aux premiers stades du transport des applications alimentées par des LLMs vers la production. Il y a beaucoup de questions auxquelles nous n’avons pas les réponses, et seul le temps dira comment les choses se dérouleront:

• Le terme “LLMOps” va-t-il rester ?
• Comment LLMOps évoluera-t-il par rapport à MLOps ? Se transformeront-ils ensemble, ou deviendront-ils des ensembles d’opérations séparés ?
• Comment va se dérouler le “moment Linux” de l’IA ?

Nous pouvons affirmer avec certitude que nous verrons bientôt de nombreux développements, de nouveaux outils et des meilleures pratiques. De plus, nous observons déjà des efforts visant à réduire les coûts et la latence des modèles de base. Ce sont des moments intéressants sans aucun doute !

Conclusion

Depuis la sortie du ChatGPT d’OpenAI, les LLMs sont devenus un sujet brûlant dans le domaine de l’IA. Ces modèles d’apprentissage profond peuvent générer des sorties en langage humain, ce qui en fait un outil puissant pour des tâches telles que l’IA conversationnelle, les assistants de programmation et les assistants d’écriture.

Cependant, le déploiement d’applications alimentées par des LLMs présente ses propres défis, ce qui a conduit à l’apparition d’un nouveau terme, “LLMOps”. Il fait référence à l’ensemble d’outils et de meilleures pratiques utilisés pour gérer le cycle de vie des applications alimentées par des LLMs, y compris le développement, le déploiement et la maintenance.

LLMOps peut être considéré comme une sous-catégorie de MLOps. Cependant, les étapes impliquées dans la création d’une application alimentée par un LLM sont différentes de celles nécessaires à la création d’applications avec des modèles ML de base. Au lieu de former un LLM à partir de zéro, l’accent est mis sur l’adaptation de LLM pré-entraînés aux tâches suivantes. Cela implique de choisir un modèle de base, d’utiliser LLM dans les tâches suivantes, de les évaluer, et de déployer et surveiller le modèle. Bien que LLMOps soit encore un domaine relativement nouveau, il est sûr de continuer à se développer et à évoluer à mesure que les LLM deviennent plus populaires dans l’industrie de l’IA.

Points clés :

• LLMOps (opérations de modèles de langage volumineux) est un domaine scientifique qui se concentre sur la gestion du cycle de vie des puissants modèles de langage tels que ChatGPT, transformant ainsi la création et la maintenance de produits basés sur l’IA.
• L’augmentation des applications utilisant des modèles de langage volumineux (LLM) tels que GPT-3, GPT-3.5 et GPT-4 a conduit à la montée de LLMOps.
• Le processus de LLMOps comprend la sélection d’un modèle de base, son adaptation à des tâches particulières, l’évaluation des performances du modèle grâce aux tests A/B, et la prise en compte des coûts et de l’anxiété liés à l’inférence dans les applications alimentées par LLM.
• LLMOps se distingue du MLOps traditionnel en termes de gestion des données (apprentissage à quelques exemples), d’examen (ingénierie de la requête), d’évaluation (tests A/B), de coûts (coûts liés à l’inférence) et de vitesse (latence).

En résumé, l’essor des LLM et des LLMOps marque un changement significatif dans la création et la maintenance de produits alimentés par l’IA. J’espère que vous avez aimé cet article. Vous pouvez me contacter ici sur LinkedIn.

Questions fréquemment posées

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!