Comment créer un chatbot à l'aide de Streamlit et Llama 2

Llama 2 est un grand modèle de langage (LLM) open source développé par Meta. Il s'agit d'un grand modèle de langage open source compétent, sans doute meilleur que certains modèles fermés comme GPT-3.5 et PaLM 2. Il se compose de trois tailles de modèles de texte génératifs pré-entraînés et affinés, dont les modèles de paramètres de 7 milliards, 13 milliards et 70 milliards.

Vous explorerez les capacités conversationnelles de Llama 2 en créant un chatbot à l'aide de Streamlit et de Llama 2.

Comprendre Llama 2: caractéristiques et avantages

À quel point Llama 2 est-il différent de son prédécesseur grand modèle de langage, Lama 1 ?

• Taille du modèle plus grand : Le modèle est plus grand, avec jusqu'à 70 milliards de paramètres. Cela lui permet d'apprendre des associations plus complexes entre les mots et les phrases.
• Capacités de conversation améliorées: L'apprentissage par renforcement à partir de la rétroaction humaine (RLHF) améliore les capacités d'application conversationnelle. Cela permet au modèle de générer un contenu de type humain, même dans des interactions alambiquées.
  instagram viewer
• Inférence plus rapide: Il introduit une nouvelle méthode appelée attention aux requêtes groupées pour accélérer l'inférence. Cela se traduit par sa capacité à créer des applications plus utiles telles que des chatbots et des assistants virtuels.
• Plus efficace: Il est plus efficace en termes de mémoire et de ressources de calcul que son prédécesseur.
• Licence open source et non commerciale : C'est open source. Les chercheurs et les développeurs peuvent utiliser et modifier Llama 2 sans restrictions.

Llama 2 surpasse considérablement son prédécesseur à tous égards. Ces caractéristiques en font un outil puissant pour de nombreuses applications, telles que les chatbots, les assistants virtuels et la compréhension du langage naturel.

Configuration d'un environnement rationalisé pour le développement de chatbot

Pour commencer à créer votre application, vous devez configurer un environnement de développement. Il s'agit d'isoler votre projet des projets existants sur votre machine.

Tout d'abord, commencez par créer un environnement virtuel en utilisant le Pipenv bibliothèque comme suit :

pipenv shell

Ensuite, installez les bibliothèques nécessaires pour créer le chatbot.

pipenv install streamlit replicate

Rationalisé: Il s'agit d'un framework d'applications Web open source qui permet de restituer rapidement des applications d'apprentissage automatique et de science des données.

Reproduire: Il s'agit d'une plate-forme cloud qui donne accès à de grands modèles d'apprentissage automatique open source pour le déploiement.

Obtenez votre jeton API Llama 2 à partir de la réplication

Pour obtenir une clé de jeton de réplication, vous devez d'abord créer un compte sur Reproduire en utilisant votre compte GitHub.

La réplication autorise uniquement la connexion via un Compte GitHub.

Une fois que vous avez accédé au tableau de bord, accédez au Explorer et recherchez le chat Llama 2 pour voir le lama-2–70b-chat modèle.

Clique sur le lama-2–70b-chat modèle pour afficher les points de terminaison de l’API Llama 2. Clique le API bouton sur le lama-2–70b-chat la barre de navigation du modèle. Sur le côté droit de la page, cliquez sur le Python bouton. Cela vous donnera accès au jeton API pour les applications Python.

Copiez le REPLICATE_API_TOKEN et conservez-le en toute sécurité pour une utilisation ultérieure.

Le code source complet est disponible dans ce Dépôt GitHub.

Construire le chatbot

Tout d'abord, créez un fichier Python appelé lama_chatbot.py et un fichier env (.env). Vous écrirez votre code dans llama_chatbot.py et stockerez vos clés secrètes et jetons API dans le fichier .env.

Sur le fichier llama_chatbot.py, importez les bibliothèques comme suit.

import streamlit as st 
import os 
import replicate

Ensuite, définissez les variables globales du lama-2–70b-chat modèle.

# Global variables
REPLICATE_API_TOKEN = os.environ.get('REPLICATE_API_TOKEN', default='') 
# Define model endpoints as independent variables
LLaMA2_7B_ENDPOINT = os.environ.get('MODEL_ENDPOINT7B', default='')
LLaMA2_13B_ENDPOINT = os.environ.get('MODEL_ENDPOINT13B', default='')
LLaMA2_70B_ENDPOINT = os.environ.get('MODEL_ENDPOINT70B', default='')

Sur le fichier .env, ajoutez le jeton de réplication et les points de terminaison du modèle au format suivant :

REPLICATE_API_TOKEN='Paste_Your_Replicate_Token'
MODEL_ENDPOINT7B='a16z-infra/llama7b-v2-chat: 4f0a4744c7295c024a1de15e1a63c880d3da035fa1f49bfd344fe076074c8eea'
MODEL_ENDPOINT13B='a16z-infra/llama13b-v2-chat: df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5'
MODEL_ENDPOINT70B='replicate/llama70b-v2-chat: e951f18578850b652510200860fc4ea62b3b16fac280f83ff32282f87bbd2e48'

Collez votre jeton de réplication et enregistrez le fichier .env.

Concevoir le flux conversationnel du chatbot

Créez une invite préalable pour démarrer le modèle Llama 2 en fonction de la tâche que vous souhaitez qu'il effectue. Dans ce cas, vous souhaitez que le modèle agisse comme un assistant.

# Set Pre-propmt 
PRE_PROMPT = "You are a helpful assistant. You do not respond as " \
"'User' or pretend to be 'User'." \
" You only respond once as Assistant."

Configurez la configuration de la page pour votre chatbot comme suit :

# Set initial page configuration
st.set_page_config(
 page_title="LLaMA2Chat",
 page_icon=":volleyball:",
 layout="wide"
)

Écrivez une fonction qui initialise et configure les variables d'état de session.

# Constants
LLaMA2_MODELS = {
'LLaMA2-7B': LLaMA2_7B_ENDPOINT,
'LLaMA2-13B': LLaMA2_13B_ENDPOINT,
'LLaMA2-70B': LLaMA2_70B_ENDPOINT,
}
# Session State Variables
DEFAULT_TEMPERATURE = 0.1
DEFAULT_TOP_P = 0.9
DEFAULT_MAX_SEQ_LEN = 512
DEFAULT_PRE_PROMPT = PRE_PROMPT
defsetup_session_state():
 st.session_state.setdefault('chat_dialogue', [])
 selected_model = st.sidebar.selectbox(
'Choose a LLaMA2 model:', list(LLaMA2_MODELS.keys()), key='model')
 st.session_state.setdefault(
'llm', LLaMA2_MODELS.get(selected_model, LLaMA2_70B_ENDPOINT))
 st.session_state.setdefault('temperature', DEFAULT_TEMPERATURE)
 st.session_state.setdefault('top_p', DEFAULT_TOP_P)
 st.session_state.setdefault('max_seq_len', DEFAULT_MAX_SEQ_LEN)
 st.session_state.setdefault('pre_prompt', DEFAULT_PRE_PROMPT)

La fonction définit les variables essentielles comme chat_dialogue, pré_prompt, llm, top_p, max_seq_len, et température dans l'état de session. Il gère également la sélection du modèle Llama 2 en fonction du choix de l'utilisateur.

Écrivez une fonction pour afficher le contenu de la barre latérale de l'application Streamlit.

defrender_sidebar():
 st.sidebar.header("LLaMA2 Chatbot")
 st.session_state['temperature'] = st.sidebar.slider('Temperature:',
 min_value=0.01, max_value=5.0, value=DEFAULT_TEMPERATURE, step=0.01)
 st.session_state['top_p'] = st.sidebar.slider('Top P:', min_value=0.01,
 max_value=1.0, value=DEFAULT_TOP_P, step=0.01)
 st.session_state['max_seq_len'] = st.sidebar.slider('Max Sequence Length:',
 min_value=64, max_value=4096, value=DEFAULT_MAX_SEQ_LEN, step=8)
 new_prompt = st.sidebar.text_area(
'Prompt before the chat starts. Edit here if desired:', 
 DEFAULT_PRE_PROMPT, height=60)
if new_prompt != DEFAULT_PRE_PROMPT and new_prompt != ""and
new_prompt isnotNone:
 st.session_state['pre_prompt'] = new_prompt + "\n"
else:
 st.session_state['pre_prompt'] = DEFAULT_PRE_PROMPT

La fonction affiche l'en-tête et les variables de réglage du chatbot Llama 2 pour les ajustements.

Écrivez la fonction qui restitue l'historique des discussions dans la zone de contenu principale de l'application Streamlit.

defrender_chat_history():
 response_container = st.container()
for message in st.session_state.chat_dialogue:
with st.chat_message(message["role"]):
 st.markdown(message["content"])

La fonction parcourt le chat_dialogue enregistré dans l'état de session, affichant chaque message avec le rôle correspondant (utilisateur ou assistant).

Gérez la saisie de l'utilisateur à l'aide de la fonction ci-dessous.

defhandle_user_input():
 user_input = st.chat_input(
"Type your question here to talk to LLaMA2"
)
if user_input:
 st.session_state.chat_dialogue.append(
{"role": "user", "content": user_input}
)
with st.chat_message("user"):
 st.markdown(user_input)

Cette fonction présente le utilisateur avec un champ de saisie où ils peuvent saisir leurs messages et questions. Le message est ajouté au chat_dialogue dans l'état de session avec le utilisateur rôle une fois que l’utilisateur soumet le message.

Écrivez une fonction qui génère des réponses à partir du modèle Llama 2 et les affiche dans la zone de discussion.

defgenerate_assistant_response():
 message_placeholder = st.empty()
 full_response = ""
 string_dialogue = st.session_state['pre_prompt']

for dict_message in st.session_state.chat_dialogue:
 speaker = "User"if dict_message["role"] == "user"else"Assistant"
 string_dialogue += f"{speaker}: {dict_message['content']}\n"

 output = debounce_replicate_run(
 st.session_state['llm'],
 string_dialogue + "Assistant: ",
 st.session_state['max_seq_len'],
 st.session_state['temperature'],
 st.session_state['top_p'],
 REPLICATE_API_TOKEN
 )

for item in output:
 full_response += item
 message_placeholder.markdown(full_response + "▌")

 message_placeholder.markdown(full_response)
 st.session_state.chat_dialogue.append({"role": "assistant",
"content": full_response})

La fonction crée une chaîne d'historique de conversation qui inclut les messages de l'utilisateur et de l'assistant avant d'appeler le debounce_replicate_run fonction pour obtenir la réponse de l'assistant. Il modifie continuellement la réponse dans l'interface utilisateur pour offrir une expérience de chat en temps réel.

Écrivez la fonction principale responsable du rendu de l'intégralité de l'application Streamlit.

defrender_app():
 setup_session_state()
 render_sidebar()
 render_chat_history()
 handle_user_input()
 generate_assistant_response()

Il appelle toutes les fonctions définies pour configurer l'état de la session, afficher la barre latérale, l'historique des discussions, gérer les entrées de l'utilisateur et générer les réponses de l'assistant dans un ordre logique.

Écrivez une fonction pour invoquer le rendu_app fonction et démarrez l’application lorsque le script est exécuté.

defmain():
 render_app()
if __name__ == "__main__":
 main()

Votre application devrait maintenant être prête à être exécutée.

Gestion des requêtes API

Créer un utils.py fichier dans le répertoire de votre projet et ajoutez la fonction ci-dessous :

import replicate
import time
# Initialize debounce variables
last_call_time = 0
debounce_interval = 2# Set the debounce interval (in seconds)
defdebounce_replicate_run(llm, prompt, max_len, temperature, top_p,
 API_TOKEN):
global last_call_time
 print("last call time: ", last_call_time)
 current_time = time.time()
 elapsed_time = current_time - last_call_time
if elapsed_time < debounce_interval:
 print("Debouncing")
return"Hello! Your requests are too fast. Please wait a few" \
" seconds before sending another request."
 last_call_time = time.time()
 output = replicate.run(llm, input={"prompt": prompt + "Assistant: ",
"max_length": max_len, "temperature": 
 temperature, "top_p": top_p,
"repetition_penalty": 1}, api_token=API_TOKEN)
return output

La fonction exécute un mécanisme anti-rebond pour empêcher les requêtes API fréquentes et excessives provenant de l’entrée d’un utilisateur.

Ensuite, importez la fonction de réponse anti-rebond dans votre lama_chatbot.py déposer comme suit :

from utils import debounce_replicate_run

Exécutez maintenant l'application :

streamlit run llama_chatbot.py

Production attendue:

Le résultat montre une conversation entre le modèle et un humain.

Applications réelles des chatbots Streamlit et Llama 2

Voici quelques exemples concrets d'applications de Llama 2 :

• Chatbots: Son utilisation s'applique à la création chatbots à réponse humaine qui peut tenir des conversations en temps réel sur plusieurs sujets.
• Assistants virtuels: Son utilisation s'applique à la création d'assistants virtuels qui comprennent et répondent aux requêtes du langage humain.
• La traduction de la langue: Son utilisation s'applique aux tâches de traduction linguistique.
• Résumé du texte: Son utilisation est applicable pour résumer des textes volumineux en textes courts pour une compréhension facile.
• Recherche: Vous pouvez appliquer Llama 2 à des fins de recherche en répondant à des questions sur une gamme de sujets.

L'avenir de l'IA

Avec des modèles fermés comme GPT-3.5 et GPT-4, il est assez difficile pour les petits acteurs de créer quoi que ce soit de substantiel à l'aide de LLM, car l'accès à l'API du modèle GPT peut être assez coûteux.

L'ouverture de grands modèles de langage avancés comme Llama 2 à la communauté des développeurs n'est que le début d'une nouvelle ère de l'IA. Cela conduira à une mise en œuvre plus créative et innovante des modèles dans des applications du monde réel, conduisant à une course accélérée vers la super intelligence artificielle (ASI).