Pile de lamas : Un guide avec des exemples pratiques

Qu'est-ce que le Llama Stack ?

Llama Stack est un cadre conçu pour rationaliser le développement et le déploiement d'applications d'IA générative basées sur les modèles Llama de Meta. modèles Llama de Meta. Il y parvient en fournissant une collection d'API et de composants normalisés pour des tâches telles que l'inférence, la sécurité, la gestion de la mémoire et les capacités des agents.

Voici ses objectifs et ses avantages :

• Normalisation: L'ensemble des API offre une interface et un environnement de travail cohérents aux développeurs, qui peuvent ainsi adapter rapidement leurs applications lorsque de nouveaux modèles sont disponibles.
• Synergie: En abstrayant les fonctionnalités complexes dans des API, il permet la collaboration entre divers outils et composants, en faveur de la modularité et de la flexibilité.
• Développement harmonieux: Llama Stack offre des péages pour un cycle de développement simplifié en prédéfinissant les fonctionnalités de base et en accélérant le déploiement.

Source : Meta AI

Composants et API de la pile Llama

Llama Stack est livré avec plusieurs API, chacune ciblant un ensemble spécifique de tâches dans la construction d'une application d'IA générative.

API d'inférence

L'API Inférence gère la génération de texte ou d'invites multimodale variations du lama. Ses principales caractéristiques sont les suivantes :

• Il prend en charge diverses stratégies de décodage telles que l'échantillonnage top-k.
• Il gère les demandes par lots et les réponses en flux, ce qui est utile pour les applications à grande échelle.

L'API définit diverses configurations permettant aux développeurs de contrôler le comportement du modèle (par exemple, FP8 ou BF16 quantification) en fonction des exigences de leur application.

Sécurité API

L'API de sécurité est conçue pour un déploiement responsable des modèles d'IA en modérant le contenu et en filtrant les résultats nuisibles ou potentiellement biaisés. Il peut être configuré pour définir des niveaux de violation (par exemple, INFO, WARN, ERROR) et pour renvoyer des messages exploitables aux utilisateurs.

API Mémoire

L'API Mémoire permet de conserver les interactions passées et d'y faire référence, et de créer des conversations plus cohérentes qui tiennent compte du contexte. La variété des configurations de mémoire permet aux développeurs de choisir les types de stockage en fonction des besoins de l'application. Ses principales caractéristiques sont les suivantes :

• Il permet un stockage flexible de la mémoire en offrant de multiples configurations telles que vecteur, clé-valeur, mot-clé et graphe, qui sont essentiellement des méthodes de stockage de mémoires de conversation.
• Permet l'insertion, l'interrogation, la mise à jour et la suppression de documents dans les banques de mémoire. Les résultats des requêtes sont renvoyés sous forme de morceaux avec des scores de pertinence.

API agentique

L'API Agentic permet aux LLM d'utiliser des outils et des fonctions externes, ce qui leur permet d'effectuer des tâches telles que la recherche sur le web, l'exécution de code ou la récupération de mémoire. L'API permet aux développeurs de configurer agents avec des outils et des objectifs spécifiques. Il prend en charge les interactions à tours multiples où chaque tour se compose de plusieurs étapes. Ses principales caractéristiques sont les suivantes :

• Il est livré avec des outils intégrés tels que brave_search, wolfram_alpha, photogen, et code_interpreter. Nous pouvons utiliser ces outils pour traiter des requêtes ou exécuter du code dans le contexte du modèle.
• Il fonctionne avec l'API Mémoire pour récupérer des informations pertinentes afin d'améliorer le contexte à long terme.
• Les modèles peuvent exécuter des tâches en plusieurs étapes, telles que l'inférence, l'exécution de l'outil, la récupération de la mémoire et les contrôles de sécurité.

Autres API

Voici les autres API que Llama Stack propose : 

• API d'évaluation: Utilisé pour l'évaluation de la performance des modèles.
• API post-formation: Aide à affiner les modèles pour des tâches ou des données spécifiques, avec des méthodes telles que LORADORA, etc.
• API de génération de données synthétiques: Aide à la génération d'ensembles de données ensembles de données synthétiques pour l'entraînement des modèles.
• Notation des récompenses API: Utile pour apprentissage par renforcement pour attribuer des scores de récompense aux actions ou décisions prises par le modèle.

Comment installer et configurer Llama Stack

Nous mettrons en œuvre un exemple de projet sur Llama Stack afin de nous familiariser avec l'idée générale et les capacités de ce cadre.

Avant de commencer, sachez que

1. Llama Stack évolue rapidement et il faut s'attendre à voir des bugs lors de l'implémentation de votre client, il est donc important de se référer à la documentation du référentiel et de rapporter tout problème éventuel. À la date de rédaction de cet article, par exemple, je n'ai pas été en mesure d'exécuter le conteneur Llama Stack sous Windows en raison de problèmes spécifiques au système d'exploitation, sur lesquels l'équipe de développeurs va se pencher.
2. Vous ne pouvez pas utiliser Llama Stack sur Google Colab, car la version gratuite de la plateforme ne prend pas en charge la construction de conteneurs Docker.

Commençons par configurer l'interface de ligne de commande (CLI) de Llama.

1. Llama CLI

La pile Llama fournit une interface en ligne de commande (CLI) pour gérer les distributions, installer les modèles et configurer les environnements. Voici les étapes d'installation à suivre :

a. Créer et activer un environnement virtuel :

conda create -n llama_stack python=3.10
conda activate llama_stack

b. Clonez le dépôt Llama Stack :

git clone <https://github.com/meta-llama/llama-stack.git>
cd llama-stack

c. Installez les dépendances nécessaires :

pip install llama-stack
pip install -r requirements.txt

2. Utiliser les conteneurs Docker

Les conteneurs Docker simplifient le déploiement du serveur Llama Stack et des fournisseurs d'API d'agents. Des images Docker préconstruites sont disponibles pour faciliter l'installation :

docker pull llamastack/llamastack-local-gpu
llama stack build
llama stack configure llamastack-local-gpu

Ces commandes extraient l'image Docker, la construisent et configurent la pile.

Comment construire une application avec les API de Llama Stack

Construisons un chatbot de base en utilisant les API de la Pile à Llamas. Voici les étapes à suivre :

1. Démarrez le serveur Llama Stack

Nous exécuterons le serveur sur le port 5000. Assurez-vous que le serveur fonctionne avant d'utiliser les API :

llama stack run local-gpu --port 5000

2. Utiliser l'API d'inférence

Après avoir installé la pile Llama, vous pouvez utiliser du code client pour interagir avec ses API. Utilisez l'API Inference pour générer des réponses basées sur les données de l'utilisateur :

from llama_stack_client import LlamaStackClient
client = LlamaStackClient(base_url="<http://localhost:5000>")
user_input = "Hello! How are you?"
response = client.inference.chat_completion(
    model="Llama3.1-8B-Instruct",
    messages=[{"role": "user", "content": user_input}],
    stream=False
)
print("Bot:", response.text)

Note : Remplacez "Llama3.1-8B-Instruct" par le nom du modèle disponible dans votre installation.

3. Intégrer l'API de sécurité

Mettez en œuvre l'API de sécurité pour modérer les réponses et vous assurer qu'elles sont appropriées :

safety_response = client.safety.run_shield(
    messages=[{"role": "assistant", "content": response.text}],
    shield_type="llama_guard",
    params={}
)
if safety_response.violation:
    print("Unsafe content detected.")
else:
    print("Bot:", response.text)

4. Ajoutez de la mémoire avec l'API Mémoire

Créez la conscience du contexte du chatbot en stockant et en récupérant l'historique des conversations :

### building a memory bank that can be used to store and retrieve context.
bank = client.memory.create_memory_bank(
    name="chat_memory",
    config=VectorMemoryBankConfig(
        type="vector",
        embedding_model="all-MiniLM-L6-v2",
        chunk_size_in_tokens=512,
        overlap_size_in_tokens=64,
    )
)

5. Enchaîner les composants

Nous pouvons ensuite combiner les API pour créer un chatbot robuste :

• API d'inférence: Génère des réponses.
• Sécurité API: Filtre les contenus inappropriés.
• API Mémoire: Maintient le contexte de la conversation.

Exemple complet

Voici le code complet après avoir suivi toutes les étapes :

import uuid
client = LlamaStackClient(base_url="<http://localhost:5000>")
### create a memory bank at the start
bank = client.memory.create_memory_bank(
    name="chat_memory",
    config=VectorMemoryBankConfig(
        type="vector",
        embedding_model="all-MiniLM-L6-v2",
        chunk_size_in_tokens=512,
        overlap_size_in_tokens=64,
    )
)
def get_bot_response(user_input):
    ### retrieving conversation history
    query_response = client.memory.query_documents(
        bank_id=bank.bank_id,
        query=[user_input],
        params={"max_chunks": 10}
    )
    history = [chunk.content for chunk in query_response.chunks]
    ### preparing messages with history
    messages = [{"role": "user", "content": user_input}]
    if history:
        messages.insert(0, {"role": "system", "content": "\\n".join(history)})
       
    ### generate response
    response = client.inference.chat_completion(
        model="llama-2-7b-chat",
        messages=messages,
        stream=False
    )
    bot_response = response.text
    ### safety check
    safety_response = client.safety.run_shield(
        messages=[{"role": "assistant", "content": bot_response}],
        shield_type="llama_guard",
        params={}
    )
    if safety_response.violation:
        return "I'm sorry, but I can't assist with that request."
    ### memory storing
    documents = [
        MemoryBankDocument(
            document_id=str(uuid.uuid4()),
            content=user_input,
            mime_type="text/plain"
        ),
        MemoryBankDocument(
            document_id=str(uuid.uuid4()),
            content=bot_response,
            mime_type="text/plain"
        )
    ]
    client.memory.insert_documents(
        bank_id=bank.bank_id,
        documents=documents
    )
    return bot_response
### putting all together
while True:
    user_input = input("You: ")
    if user_input.lower() == "bye":
        break
    bot_response = get_bot_response(user_input)
    print("Bot:", bot_response)

Exemples et contributions de la pile Llama

Pour voir quelques exemples et démarrer votre mise en œuvre d'applications utilisant Llama Stack, Meta a fourni le fichier llama-stack-apps dans lequel vous pouvez consulter des exemples d'applications. N'hésitez pas à consulter le cadre et à vous familiariser avec lui.

En tant que projet open-source, Llama Stack vit des contributions de la communauté. Les API évoluent rapidement et le projet est ouvert aux commentaires et à la participation des développeurs, ce qui contribuera à façonner l'avenir de la plateforme. Si vous testez Llama Stack, cela peut aider d'autres développeurs si vous partagez votre projet en tant qu'exemple, ou si vous contribuez à la documentation.

Conclusion

Tout au long de cet article, nous avons exploré comment démarrer avec Llama Stack à l'aide d'instructions pas à pas.

Au fur et à mesure que vous avancez dans le déploiement de vos applications d'IA, n'oubliez pas de garder un œil sur le dépôt de dépôt de Llama Stack pour obtenir les dernières mises à jour et améliorations.

Pour en savoir plus sur l'écosystème des lamas, consultez les ressources suivantes :

• Travailler avec des lamas 3 cours
• Mise au point de Llama 3.2 et utilisation locale
• RAG avec le lama 3.1 8B, Ollama et Langchain