Clude-ception : Enseigner à Claude à s'ingénieurer avec LangChain

Name

Jennie Rose

Published on 30/04/2024

Introduction

Claude, le puissant assistant IA d'Anthropic, a démontré des capacités remarquables de compréhension et de génération de langage. Le modèle Claude 3 récemment publié, en particulier la variante Opus, excelle dans l'ingénierie des invites - l'art de concevoir des invites efficaces pour obtenir des sorties de haute qualité à partir de modèles de langage.

Cela ouvre une possibilité passionnante : que se passerait-il si nous pouvions exploiter l'expertise de Claude en matière d'ingénierie de invites pour améliorer itérativement ses propres invites ? En analysant la qualité des sorties générées à partir d'une invite initiale et en suggérant des améliorations, nous pourrions créer une boucle de rétroaction automatisée pour optimiser les invites pour une tâche donnée.

Dans cet article, nous verrons comment mettre en œuvre cette stratégie d'invite auto-améliorante en utilisant Claude 3 Opus et LangChain, un framework populaire pour la création d'applications avec des modèles de langage. Nous l'appliquerons à la tâche de résumer des articles académiques dans le style engageant du chercheur en IA Elvis Saravia (@omarsar0 (opens in a new tab) sur Twitter).

Le flux de travail d'ingénierie des invites

Alex Albert (@alexalbert__ (opens in a new tab) sur Twitter) a récemment partagé un flux de travail efficace pour l'ingénierie des invites avec Claude 3 Opus :

1. Écrire une invite initiale pour la tâche
2. Générer un ensemble de tests d'entrée pour évaluer l'invite
3. Exécuter l'invite sur les cas de test
4. Examiner et noter manuellement les sorties
5. Alimenter les exemples notés dans Claude 3 Opus et lui demander de réviser l'invite
6. Répéter

Will Hinthorn (@WHinthorn (opens in a new tab)) et Ross Lance Martin (@rlancemartin (opens in a new tab)) montrent comment simplifier ce processus en utilisant LangSmith :

1. Créer un ensemble de tests
2. Annoter les sorties générées avec des commentaires
3. Transmettre les commentaires à Claude 3 Opus pour réécrire l'invite
4. Exécuter cela comme une boucle d'amélioration itérative

Voyons comment mettre en œuvre cette approche pour la tâche de résumer des articles académiques dans le style des fils Twitter excellents d'Elvis Saravia.

Étape 1 : Charger les articles dans un ensemble de données

Tout d'abord, nous sélectionnons quelques articles dont Elvis a tweeté et les chargeons en utilisant ArxivLoader de LangChain :

from langchain_community.document_loaders import ArxivLoader
 
ids = ["2403.05313", "2403.04121", "2402.15809"] 
 
docs = []
for paper_id in ids:
    doc = ArxivLoader(query=paper_id, load_max_docs=1).load() 
    docs.extend(doc)

Nous ajoutons ensuite le texte de l'article à un ensemble de données LangSmith :

from langsmith import Client
 
client = Client()
 
nom_ensemble = "Générateur de tweets"  
ensemble = client.create_dataset(dataset_name=nom_ensemble)
client.create_examples(
    inputs=[{"article": doc.page_content} for doc in docs], dataset_id=ensemble.id
)

Étape 2 : Tester avec une invite initiale

Ensuite, nous écrivons une invite de départ raisonnable pour que Claude 3 Opus génère des résumés d'articles sous forme de tweets :

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
 
chat = ChatAnthropic(temperature=0, model_name="claude-3-opus-20240229")
 
system = (
    "<role> Vous êtes un assistant qui génère des tweets pour condenser / résumer"
    " un article académique ou un projet open source. Il doit être" 
    " bien rédigé mais éviter les gadgets ou une surdépendance aux buzzwords. </role>"
)
human = "Voici un article à convertir en tweet : <article> {article} </article>"
invite_actuelle = system + human
invite = ChatPromptTemplate.from_messages([("system", system), ("human", human)])
 
generateur_tweets = invite | chat

Nous pouvons le tester sur un exemple d'article :

exemple_tweet = generateur_tweets.invoke({"article": docs[0].page_content})
print(exemple_tweet)

Cela génère un résumé de tweet initial correct de l'article.

Étape 3 : Exécution sur l'ensemble de données

Pour évaluer l'invite de manière plus approfondie, nous l'exécutons sur notre ensemble complet d'articles :

res = client.run_on_dataset(
    dataset_name=nom_ensemble, 
    llm_or_chain_factory=generateur_tweets,
)

Étape 4 : Évaluer manuellement les sorties

Nous pouvons utiliser la fonction de file d'annotation de LangSmith pour examiner manuellement et fournir des commentaires sur les tweets générés :

q = client.create_annotation_queue(name="Générateur de tweets")
client.add_runs_to_annotation_queue(
    q.id,
    run_ids=[
        r.id 
        for r in client.list_runs(project_name=res["project_name"], execution_order=1)
    ],  
)

Pour guider l'évaluation, nous pouvons nous référer à certains tweets réels de synthèse d'articles d'Elvis en tant qu'exemples du style et du contenu cibles.

Étape 5 : Améliorer l'invite

Après avoir annoté les sorties, nous intégrons les commentaires structurés :

formatted_feedback = get_formatted_feedback(res["project_name"])

Nous les transmettons ensuite à Claude 3 Opus en utilisant un modèle d'optimisation de invite provenant de LangChain Hub :

from langchain import hub
from langchain_core.output_parsers import StrOutputParser
 
invite_optimiseur = hub.pull("rlm/prompt-optimizer-tweet-drafts") 
optimiseur = invite_optimiseur | chat | StrOutputParser() | extract_new_prompt
nouvelle_invite = optimiseur.invoke(
    {
        "invite_actuelle": invite_actuelle,
        "prédictions_annotées": "\n\n".join(formatted_feedback).strip(),  
    }
)

Ce fichier génère un prompt amélioré qui intègre les retours d'Elvis pour mieux correspondre à son style d'écriture et à la structure des fils de discussion.

Étape 6 : Évaluer le nouveau prompt

Enfin, nous pouvons exécuter à nouveau le prompt mis à jour sur notre ensemble de données pour vérifier les améliorations :

new_prompt = ChatPromptTemplate.from_messages([("user", new_prompt_str)])
tweet_generator_v2 = new_prompt | chat
 
updated_results = client.run_on_dataset(
    dataset_name=ds_name,
    llm_or_chain_factory=tweet_generator_v2, 
)

La comparaison des résultats des prompts originaux et révisés montre que la boucle de rétroaction avec Claude 3 Opus a permis d'ajuster le prompt pour produire des résumés de documents plus engageants dans le style d'Elvis.

Par exemple, voici des tweets générés par les prompts initial et amélioré pour un nouvel article de test :

Prompt initial :

Nouvelle enquête sur l'utilisation de grands modèles linguistiques (LLMs) pour des tâches de données tabulaires telles que la prédiction, la génération et les réponses aux questions. Couvre des techniques clés telles que la sérialisation, l'ingénierie de prompt et les benchmarks. Identifie des opportunités et des défis.

Prompt amélioré :

Exploiter le potentiel des LLMs pour les données tabulaires 🔑

Cette enquête approfondie explore comment les grands modèles linguistiques peuvent être appliqués aux données tabulaires pour des tâches telles que la prédiction, la génération et la compréhension.

Techniques clés abordées :

• Serialization des tableaux dans des formats lisibles par les LLMs
• Manipulations de tableaux pour s'adapter à la longueur du contexte
• Astuces d'ingénierie de prompt
• Construction de systèmes de bout en bout

L'article propose une taxonomie des ensembles de données, des métriques et des méthodes pour chaque domaine d'application. Il discute également des limites actuelles et des orientations futures de la recherche.

Les LLMs montrent un grand potentiel pour travailler avec des données structurées lorsqu'ils sont combinés avec les bonnes étapes de prétraitement et les stratégies de prompt. Cela ouvre des possibilités passionnantes pour des systèmes plus intelligents et automatisés d'analyse des données tabulaires.

Quelles autres applications innovantes des LLMs aux données structurées prévoyez-vous ? 🤔

Le tweet révisé fait un meilleur travail pour décomposer les points clés, ajoute des emojis pour un intérêt visuel, et se termine par une question stimulante pour encourager l'audience à s'engager - tous des éléments caractéristiques du style d'Elvis.

Conclusion

En combinant les capacités d'ingénierie de prompt de Claude 3 Opus avec les frameworks LangChain et LangSmith, nous avons pu créer une boucle de rétroaction automatisée pour optimiser progressivement un prompt pour résumer des articles dans un style d'écriture particulier.

Cela démontre une approche générale puissante pour ajuster les modèles linguistiques afin d'accomplir une tâche selon certaines spécifications ou pour émuler un style cible. La même technique pourrait être appliquée pour améliorer automatiquement les prompts pour une grande variété d'autres tâches de génération de texte.

À mesure que les modèles linguistiques continuent de progresser, nous pouvons nous attendre à voir des outils et des workflows d'ingénierie de prompt plus sophistiqués pour maximiser leur potentiel. Les frameworks tels que LangChain joueront un rôle clé pour rendre cela accessible à un plus large éventail de développeurs et ouvrir de nouvelles applications passionnantes.