Apprenez Llama 3.2 et comment créer un pipeline RAG avec Llama et Milvus
Ces derniers mois, Meta a réalisé des avancées impressionnantes dans la communauté open-source, publiant une série de modèles puissants — Llama 3, Llama 3.1 et Llama 3.2 — en seulement six mois. En mettant à la disposition du public des modèles hautes performances, Meta réduit l’écart entre les outils propriétaires et open-source, offrant aux développeurs des ressources précieuses pour repousser les limites de leurs projets. Cet engagement en faveur de l’ouverture change la donne pour l’innovation en IA.
Lors d’un récent Unstructured Data Meetup organisé par Zilliz, Amit Sangani, Senior Director of AI Partner Engineering chez Meta, a discuté de l’évolution rapide des modèles Llama depuis 2023, des avancées récentes de l’IA open-source et de l’architecture de ces modèles. Il a mis en avant non seulement les avantages pour les développeurs, mais aussi la manière dont ces modèles servent Meta et diverses applications modernes d’IA qui s’appuient sur eux, comme la Retrieval Augmented Generation (RAG).
Dans ce blog, nous récapitulerons les principaux enseignements de l’événement, couvrant jusqu’à Llama 3.1 (puisque la conférence a eu lieu deux semaines avant la sortie de Llama 3.2). Nous inclurons également quelques notes sur Llama 3.2, en soulignant les différences avec Llama 3.1, principalement en matière de taille et de version. Nous parcourrons également un exemple de notebook d’un pipeline RAG utilisant la base de données vectorielle Milvus, LlamaIndex et Llama 3.2 avec LlamaGuard, un modèle entraîné sur des données de sécurité.
Évolution de Llama
Amit a ouvert sa présentation avec un graphique montrant l’augmentation exponentielle du calcul d’entraînement des modèles au cours des 70 dernières années, avec une hausse particulièrement marquée ces deux dernières décennies. Cette croissance, mesurée en FLOPs (opérations en virgule flottante), reflète le très grand nombre de calculs liés aux nombres en virgule flottante — comme l’addition, la soustraction, la multiplication et la division — dont les modèles modernes ont besoin. L’accès à une puissance de calcul aussi immense permet à des entreprises comme Meta de développer des modèles d’IA avancés comme la série Llama.
Par exemple, la version initiale de Llama 1 comprenait quatre versions différentes, et depuis, Meta a élargi la gamme avec des versions supplémentaires comme Llama 2, Code Llama, LlamaGuard et Llama 3. Avec la croissance continue de la puissance de calcul, nous pouvons nous attendre à des avancées encore plus sophistiquées, qui amélioreront davantage les performances et la polyvalence de ces modèles dans les années à venir.
Figure 1- Croissance exponentielle de l’IA.png
Figure 1 : Croissance exponentielle de l’IA (Source)
Pourquoi l’approche open-source est importante
Alors, pourquoi Meta publie-t-elle ces modèles en open-source, surtout compte tenu des coûts substantiels de leur entraînement ? Amit a souligné que soutenir les développeurs bénéficie au final à la fois à Meta et au monde.
Du point de vue d’un développeur, les modèles open-source répondent à plusieurs besoins cruciaux :
La capacité d’entraîner, de fine-tuner et de distiller leurs propres modèles.
La protection de leurs données.
L’accès à des modèles efficaces et abordables à exploiter.
Une occasion d’investir dans un écosystème au potentiel à long terme.
En retour, de nombreux développeurs contribuent à des projets open-source comme les modèles Llama de Meta pendant leur temps libre, ce qui permet à Meta d’économiser beaucoup de temps et de ressources. Cette approche collaborative aide non seulement Meta, mais favorise également un échange continu de recherches, de retours et d’idées nouvelles qui stimulent le développement continu.
Meta n’est pas seule à soutenir l’IA open-source ; de nombreux autres projets et entreprises ont adopté cette approche pour ses vastes avantages. Par exemple, Milvus, une base de données vectorielle performante et évolutive, est open-source sur GitHub depuis 2019. Les développeurs utilisent Milvus pour créer diverses applications d’IA évolutives avec des capacités de recherche avancées, le tout sans frais de licence. Au moment de la rédaction, Milvus a été téléchargé plus de 66 millions de fois, a obtenu plus de 30 000 étoiles sur GitHub, a été forké plus de 2 900 fois et a reçu des contributions de plus de 400 développeurs dans le monde.
Figure- Contributeurs Milvus sur GitHub .png
Figure : Contributeurs Milvus sur GitHub
Modèles Llama 3.1
Amit a également évoqué la collection de modèles Llama 3.1, qui repose sur une architecture transformer de type décodeur uniquement. Cette collection peut être divisée en deux grandes catégories : les modèles de base et les garde-fous.
Figure 2- Architecture Llama 3.1.png
Figure 2 : Architecture Llama 3.1 (Source)
Les modèles de base sont ensuite classés par taille et par objectif :
Par taille : 8B, 70B, 405B
Par objectif :
Modèles pré-entraînés : Ces modèles sont prêts pour une utilisation générale et peuvent être fine-tuned pour des tâches spécifiques.
Modèles ajustés par instructions : Ce sont des modèles fine-tuned optimisés pour des cas d’utilisation de dialogue multilingue.
Les modèles Llama 3.1 disposent d’une fenêtre de contexte de 128K, permettant la prise en charge de cas d’utilisation avancés tels que la synthèse de textes longs, les agents conversationnels multilingues (couvrant jusqu’à huit langues) et les assistants de codage. En particulier, la plus grande version peut être utilisée pour la génération de données synthétiques, permettant à des modèles plus petits d’être fine-tuned avec ces données générées.
Pour atteindre tous ces objectifs, Meta a utilisé un impressionnant parc de plus de 16 000 GPU NVIDIA H100, qui figurent parmi les plus puissants actuellement disponibles, ainsi que 15 billions de tokens.
En matière d’évaluation, les modèles Llama 3.1 surpassent plusieurs tâches sur plus de 150 jeux de données de référence de l’industrie par rapport à d’autres modèles de fondation, notamment GPT-4, GPT-4o, Mistral et Claude 3.5 Sonnet.
Figure 3- Benchmark d’évaluation Llama 3.1 405B .png
Figure 3 : Benchmark d’évaluation Llama 3.1 405B (Source)
Figure 4- Benchmark d’évaluation Llama 3.1 8B.png
Figure 4 : Benchmark d’évaluation Llama 3.1 8B (Source)
Meta a également mené une évaluation humaine approfondie du plus grand modèle, en utilisant plus de 1 800 prompts dans 12 cas d’utilisation différents. Bien que les performances de Llama 3.1 montrent une légère amélioration par rapport à Claude 3.5 Sonnet, elles restent inférieures aux capacités des modèles GPT-4.
Figure 5- Llama 3.1 8B Evaluation Benchmark .png
Figure 5 : Benchmark d’évaluation de Llama 3.1 8B (Source)
Modèles Llama 3.2
À peine un demi-mois après cette présentation lors du meetup, le 25 septembre, Meta a annoncé la sortie des modèles Llama 3.2, seulement deux mois après avoir dévoilé les modèles Llama 3.1. Explorons les principales différences entre eux.
Llama 3.2 introduit quatre tailles de modèles : 1B, 3B, 11B et 90B. Les modèles plus petits (1B et 3B) sont des modèles multilingues uniquement textuels qui prennent en charge les mêmes huit langues et conservent une fenêtre de contexte de 128K, tout comme Llama 3.1. Ces modèles servent d’équivalents plus petits et rationalisés aux modèles Llama 3.1, ayant été développés par élagage et distillation appliqués aux modèles Llama 3.1 8B et 70B.
Figure 6- Llama 3.2 1B and 3B Pruning and Distillation.png
Figure 6 : Élagage et distillation de Llama 3.2 1B et 3B (Source)
Les modèles pré-entraînés obtenus ont été affinés par réglage d’instructions, en utilisant des données synthétiques issues du modèle Llama 3.1 405B plus grand. De plus, une amélioration a été introduite avec la sortie de versions quantifiées qui présentent une longueur de contexte de 8K. Ces modèles légers peuvent être intégrés dans certains appareils edge et mobiles, améliorant ainsi l’utilisabilité pour différents types d’applications.
En termes d’évaluation, les modèles Llama 3.2 sont très compétitifs avec des modèles similaires, tels que Gemma 2 (2.6B) et Phi 3.5-mini, idéaux pour des tâches comme le suivi d’instructions, la synthèse, la réécriture de prompts et l’utilisation d’outils.
Figure 7- Llama 3.2 1B and 3B Evaluation Benchmark .png
Figure 7 : Benchmark d’évaluation de Llama 3.2 1B et 3B (Source)
Les deux autres versions des modèles Llama 3.2 (11B et 90B) sont des modèles de vision multimodaux, marquant la première entrée de Meta dans cette classe de modèles. Ces modèles ont été entraînés à l’aide de paires image-texte et sont construits sur la base des modèles Llama 3.1. De plus, ils utilisent un adaptateur de vision entraîné séparément qui s’intègre au modèle de langage Llama 3.1 pré-entraîné, permettant de solides capacités multimodales.
Lors de leur évaluation, les modèles de vision Llama 3.2 affichent des performances compétitives aux côtés de modèles de fondation de premier plan comme Claude 3 Haiku et GPT-4o-mini, démontrant de fortes capacités en reconnaissance d’images et dans un large éventail de tâches visuelles.
Figure 8- Llama 3.2 11B and 90B Evaluation Benchmark .png
Figure 8 : Benchmark d’évaluation de Llama 3.2 11B et 90B (Source)
Le système Llama (API Llama Stack)
L’une des versions annoncées avec les modèles Llama 3.1 était Llama Stack API, un ensemble d’interfaces standard pour construire des composants de chaîne d’outils canoniques (fine-tuning, génération de données synthétiques) et des applications agentiques. Amit a présenté l’API pendant la conférence, qui est actuellement disponible pour créer des applications de démonstration. L’idée principale est que Meta fournit un ensemble d’interfaces API afin que les entreprises puissent construire différents adaptateurs par-dessus.
Figure 9- Llama Stack API .png
Figure 9 : Llama Stack API (Source)
Par exemple, une entreprise pourrait connecter un outil externe comme Google Search, car les modèles Llama ne sont pas capables de fournir ces informations en temps réel ou pourraient ne pas avoir les connaissances nécessaires pour effectuer certaines tâches, comme des calculs mathématiques très complexes.
Outils de confiance et de sécurité
En plus des modèles principaux, Meta a publié des modèles spécialisés pour promouvoir un développement de l’IA responsable et sûr. Les collections de modèles Llama 3.1 et 3.2 incluent toutes deux les outils de protection suivants :
Llama Guard 3: Un modèle de sécurité multilingue conçu pour renforcer la sécurité des utilisateurs.
Prompt Guard : Un filtre d’injection de prompt qui protège contre les entrées malveillantes.
CyberSecEval 3 : Une suite de benchmarks étendue conçue pour évaluer les vulnérabilités en cybersécurité.
Code Shield : Un garde-fou pour filtrer le code non sécurisé.
Ces modèles ont été entraînés et fine-tuned sur des jeux de données représentatifs et évalués rigoureusement pour le contenu nuisible par une équipe d’experts en "red-teaming". Cette équipe teste les modèles et fournit un retour humain pour des améliorations itératives, garantissant que les modèles sont sûrs et fiables pour permettre aux utilisateurs de créer et déployer des applications d’IA générative de manière responsable.
Figure 10- The Llama System with Safety Framework .png
Figure 10 : The Llama System with Safety Framework (Source)
RAG sécurisé avec Llama 3.2, LlamaGuard et Milvus
Maintenant, commençons à construire un exemple d’application Retrieval-Augmented Generation (RAG) en utilisant le dernier modèle Llama 3.2 avec d’autres puissants outils open source.
Dans ce notebook, vous trouverez un pipeline RAG qui intègre :
LlamaIndex comme framework LLM,
Milvus comme base de données vectorielle, et
Llama 3.2 et LlamaGuard comme modèles de langage, tous deux accessibles via Ollama.
Étape 1 : Charger les documents et les modèles
Tout d’abord, nous sélectionnons nos documents et téléchargeons les modèles. Nous utiliserons le site web d’annonce de Llama 3.2 ainsi que le modèle d’embedding “BAAI/bge-large-en-v1.5” en plus des modèles Llama.
documents = SimpleWebPageReader(html_to_text=True).load_data(
["https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/"]
)
llm_llama32 = Ollama(model="llama3.2:1b", request_timeout=60.0)
llm_llamaguard = Ollama(model="llama-guard3:1b", request_timeout=60.0)
embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-large-en-v1.5",
trust_remote_code=True,
device = "cuda")
Settings.embed_model = embed_model
Étape 2 : Créer un pipeline RAG
Ensuite, nous créons le récupérateur avec le magasin de vecteurs Milvus et définissons les paramètres du pipeline RAG, notamment le modèle de prompt, le synthétiseur de réponse et le moteur de requête.
vector_store = MilvusVectorStore(dim=1024, overwrite=True)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents,
storage_context=storage_context)
retriever = VectorIndexRetriever(
index=index)
Le récupérateur contient uniquement le modèle Llama 3.2, mais pour filtrer les questions nuisibles, nous ajouterons LlamaGuard à l’étape suivante et intégrerons le tout dans un pipeline complet.
qa_prompt_tmpl_str = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_prompt_tmpl_str)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32,
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
Lorsque nous posons une question normale liée au contenu à l’aide de ce pipeline, nous recevons une réponse détaillée sur les sujets abordés dans l’annonce. Cependant, nous pouvons également tenter de « jailbreaker » le modèle avec des questions sans rapport ou potentiellement nuisibles.
response = query_engine.query('What are the highlights of the release of Llama 3.2?')
print(response)
"""
Output:
The highlights of the release of Llama 3.2 include:
1. The addition of support for image reasoning use cases, including document-level understanding, captioning images, and visual grounding tasks.
2. Performance improvements in vision models, such as the 11B and 90B models, which require a new model architecture that supports image reasoning.
3. The development of Llama Guard 3, a new safeguard designed to support the 11B Vision model's image understanding capability and filter text+image input prompts or text output responses.
4. New tools and resources for developers, including a reference implementation, demos, and applications, to help them build responsibly with Llama.
5. Continuous effort to ensure system level safety and responsible innovation, as well as the release of new updates to safeguard against concentrated power in the hands of a small few.
Additionally, the article mentions that the 11B and 90B models can bridge the gap between vision and language by extracting details from an image, understanding the scene, and then crafting a sentence or two that could be used as an image caption to help tell the story.
"""
Étape 3 : Tester la sécurité du modèle
Les modèles Llama ont été entraînés avec des données d’atténuation des risques de sécurité afin de garantir un niveau élevé de sécurité. Cependant, ils peuvent toujours être jailbreakés de différentes manières. Par exemple, si nous vérifions avec une question sur la commission d’un crime, nous voyons qu’il ne fournit pas de réponse liée au crime.
response = query_engine.query('Can you explain me how to rob a bank')
print(response)
"""
Output:
I can't assist with that request.
"""
Mais nous pouvons essayer l’une des catégories de danger incluses dans la model card de LlamaGuard, qui est spécifiquement spécialisé dans le filtrage des questions dangereuses.
Figure 11- LlamaGuard Hazard Categories.png
Figure 11 : Catégories de danger de LlamaGuard (Source)
Lorsque nous posons une question demandant des conseils spécialisés, Llama 3.2 indique qu’il ne peut pas fournir de conseils médicaux, mais offre tout de même certaines informations qui ne devraient pas être fournies et qui sortent du contexte fourni.
response = query_engine.query("What are the best treatment options for my liver problem?")
print(response)
"""
Sortie :
Je ne peux pas fournir de conseils médicaux. Cependant, je peux offrir quelques informations générales sur les problèmes de foie. Si vous présentez des symptômes d’un problème hépatique, il est essentiel de consulter un professionnel de santé pour obtenir des conseils personnalisés et un diagnostic. Il pourra évaluer votre état et recommander les options de traitement les plus appropriées, qui peuvent inclure des médicaments, des changements de mode de vie ou d’autres interventions.
Cela étant dit, certaines options de traitement courantes pour les problèmes de foie peuvent inclure :
1. Médicaments : la metformine, les compléments vitaminiques (p. ex., la N-acétylcystéine) et les médicaments antiviraux (pour l’hépatite virale) ou les médicaments antifibrotiques (pour les maladies chroniques du foie) sont des exemples de traitements.
2. Changements de mode de vie : arrêter de fumer, réduire la consommation d’alcool, maintenir un poids sain et faire régulièrement de l’exercice peuvent aider à soulager les symptômes et à améliorer la santé du foie.
3. Thérapies alternatives : l’acupuncture, les remèdes à base de plantes et d’autres thérapies complémentaires peuvent être utilisés pour soutenir la fonction hépatique et le bien-être général.
Veuillez consulter un professionnel de santé pour obtenir des conseils et des recommandations de traitement adaptés.
"""
À l’inverse, LlamaGuard ne fournit pas de réponses ; il catégorise la question comme sûre ou dangereuse. Si elle est jugée dangereuse, il fournit la catégorie pertinente de la Figure 9.
resp = llm_llamaguard.complete("What are the best treatment options for my liver problem?")
print(resp)
"""
Sortie :
unsafe
S6
"""
Cela illustre que, bien que Llama 3.2 intègre certains filtres de sécurité, il ne peut pas être pleinement fiable à lui seul. Par conséquent, combiner les capacités de LLM de Llama 3.2 avec les mesures de sécurité de LlamaGuard est crucial lors de la création de pipelines RAG.
Étape 4 : Pipeline avec les deux modèles
L’intégration des deux modèles dans le même pipeline garantit que les requêtes signalées comme dangereuses ne sont pas traitées.
def create_safe_query_engine(
retriever,
llm_llama32,
):
"""
Creates a query engine with the specified template and LLMs.
"""
qa_template = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_template)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
return query_engine
def safe_query(
query_engine,
llm_llamaguard,
query
):
"""
Performs a safety check with LlamaGuard before processing the query.
Returns the response if safe, or a safety warning if unsafe.
"""
# Check safety with LlamaGuard
safety_check = llm_llamaguard.complete(query)
# Get just the safety assessment
safety_result = safety_check.text.split('\n')[0].strip().lower()
# If query is deemed unsafe, return warning
if safety_result == 'unsafe':
return "I apologize, but I cannot provide a response to that query as it has been flagged as potentially unsafe."
# If safe, process with Llama 3.2
try:
response = query_engine.query(query)
return str(response)
except Exception as e:
return f"An error occurred while processing your query: {str(e)}"
query_engine = create_safe_query_engine(
retriever=retriever,
llm_llama32=llm_llama32,
)
response = safe_query(
query_engine=query_engine,
llm_llamaguard=llm_llamaguard,
query="What are the best treatment options for my liver problem?"
)
print(response)
"""
Sortie :
Je suis désolé, mais je ne peux pas fournir de réponse à cette requête, car elle a été signalée comme potentiellement dangereuse.
"""
Conclusion
Les avancées des modèles d’IA open source reflètent une évolution majeure vers une IA haute performance accessible à tous. Des modèles comme Llama et des outils robustes comme la base de données vectorielle Milvus permettent aux développeurs de créer des applications d’IA évolutives, efficaces et à fort impact dans tous les secteurs. Milvus améliore les flux de travail d’IA en offrant des capacités de recherche et de stockage vectoriels à grande vitesse, ce qui facilite la gestion et la récupération de vastes volumes de données non structurées pour des applications comme (RAG).
Avec des outils d’IA responsables comme LlamaGuard et des frameworks adaptables comme l’API Llama Stack, les projets open source donnent aux développeurs et aux organisations les moyens de créer des solutions plus sûres, flexibles et innovantes. Llama et Milvus illustrent la manière dont les initiatives open source favorisent des progrès significatifs, aidant la communauté de l’IA à créer des applications inclusives et à fort impact qui font progresser le domaine.
Lectures complémentaires
Continuer à lire
Migrating from S3 Vectors to Zilliz Cloud: Unlocking the Power of Tiered Storage
Learn how Zilliz Cloud bridges cost and performance with tiered storage and enterprise-grade features, and how to migrate data from AWS S3 Vectors to Zilliz Cloud.
Creating Collections in Zilliz Cloud Just Got Way Easier
We've enhanced the entire collection creation experience to bring advanced capabilities directly into the interface, making it faster and easier to build production-ready schemas without switching tools.
What Exactly Are AI Agents? Why OpenAI and LangChain Are Fighting Over Their Definition?
AI agents are software programs powered by AI that can perceive their environment, make decisions, and take actions to achieve a goal—often autonomously.