Come costruire un chatbot utilizzando Streamlit e Llama 2

Llama 2 è un modello di linguaggio di grandi dimensioni (LLM) open source sviluppato da Meta. Si tratta di un modello linguistico di grandi dimensioni open source competente, probabilmente migliore di alcuni modelli chiusi come GPT-3.5 e PaLM 2. È costituito da tre dimensioni di modelli di testo generativi preaddestrati e ottimizzati, inclusi i modelli di parametri da 7 miliardi, 13 miliardi e 70 miliardi.

Esplorerai le capacità di conversazione di Llama 2 costruendo un chatbot utilizzando Streamlit e Llama 2.

Comprendere Llama 2: caratteristiche e vantaggi

Quanto è diverso Llama 2 dal suo predecessore modello linguistico di grandi dimensioni, Lama 1?

• Dimensioni del modello più grande: Il modello è più grande, con un massimo di 70 miliardi di parametri. Ciò gli consente di apprendere associazioni più complesse tra parole e frasi.
• Capacità di conversazione migliorate: L'apprendimento per rinforzo dal feedback umano (RLHF) migliora le capacità applicative conversazionali. Ciò consente al modello di generare contenuti simili a quelli umani anche in interazioni contorte.
  instagram viewer
• Inferenza più rapida: Introduce un nuovo metodo chiamato attenzione alle query raggruppate per accelerare l'inferenza. Ciò si traduce nella sua capacità di creare applicazioni più utili come chatbot e assistenti virtuali.
• Più efficiente: È più efficiente in termini di memoria e risorse computazionali rispetto al suo predecessore.
• Licenza open source e non commerciale: È open source. Ricercatori e sviluppatori possono utilizzare e modificare Llama 2 senza restrizioni.

Llama 2 supera significativamente il suo predecessore sotto tutti gli aspetti. Queste caratteristiche lo rendono uno strumento potente per molte applicazioni, come chatbot, assistenti virtuali e comprensione del linguaggio naturale.

Configurazione di un ambiente ottimizzato per lo sviluppo di chatbot

Per iniziare a creare la tua applicazione, devi configurare un ambiente di sviluppo. Questo serve per isolare il tuo progetto dai progetti esistenti sul tuo computer.

Innanzitutto, inizia da creando un ambiente virtuale usando il Pipenv biblioteca come segue:

pipenv shell

Successivamente, installa le librerie necessarie per creare il chatbot.

pipenv install streamlit replicate

Illuminato: si tratta di un framework per app Web open source che esegue rapidamente il rendering delle applicazioni di machine learning e data science.

Replicare: è una piattaforma cloud che fornisce l'accesso a grandi modelli di machine learning open source per la distribuzione.

Ottieni il tuo token API Llama 2 da Replicate

Per ottenere una chiave token di replica, devi prima registrare un account su Replicare utilizzando il tuo account GitHub.

Replica consente solo l'accesso tramite a Conto GitHub.

Una volta effettuato l'accesso alla dashboard, vai al Esplorare pulsante e cerca la chat di Llama 2 per vedere il file lama-2–70b-chat modello.

Clicca sul lama-2–70b-chat modello per visualizzare gli endpoint API Llama 2. Clicca il API pulsante sul lama-2–70b-chat barra di navigazione del modello. Sul lato destro della pagina, fare clic su Pitone pulsante. Ciò ti fornirà l'accesso al token API per le applicazioni Python.

Copia il REPLICATE_API_TOKEN e conservarlo in un luogo sicuro per un uso futuro.

Il codice sorgente completo è disponibile in questo Repositorio GitHub.

Costruire il Chatbot

Innanzitutto, crea un file Python chiamato lama_chatbot.py e un file env (.env). Scriverai il tuo codice in llama_chatbot.py e memorizzerai le tue chiavi segrete e i token API nel file .env.

Nel file llama_chatbot.py, importa le librerie come segue.

import streamlit as st 
import os 
import replicate

Successivamente, imposta le variabili globali di lama-2–70b-chat modello.

# 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='')

Nel file .env, aggiungi il token Replica e gli endpoint del modello nel seguente formato:

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'

Incolla il tuo token Replica e salva il file .env.

Progettare il flusso conversazionale del Chatbot

Crea una richiesta preliminare per avviare il modello Llama 2 a seconda dell'attività che desideri che svolga. In questo caso, vuoi che la modella funga da assistente.

# 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."

Imposta la configurazione della pagina per il tuo chatbot come segue:

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

Scrivere una funzione che inizializzi e imposti le variabili di stato della sessione.

# 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 funzione imposta le variabili essenziali come chat_dialogo, pre_prompt, llm, in alto_p, max_seq_len, E temperatura nello stato di sessione. Gestisce anche la selezione del modello Llama 2 in base alla scelta dell'utente.

Scrivi una funzione per eseguire il rendering del contenuto della barra laterale dell'app 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 funzione visualizza l'intestazione e le variabili di impostazione del chatbot Llama 2 per le modifiche.

Scrivi la funzione che esegue il rendering della cronologia chat nell'area del contenuto principale dell'app 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 funzione scorre il chat_dialogue salvato nello stato della sessione, visualizzando ogni messaggio con il ruolo corrispondente (utente o assistente).

Gestisci l'input dell'utente utilizzando la funzione seguente.

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)

Questa funzione presenta il utente con un campo di input in cui possono inserire i loro messaggi e domande. Il messaggio viene aggiunto al chat_dialogo nello stato di sessione con il utente ruolo una volta che l'utente ha inviato il messaggio.

Scrivi una funzione che generi risposte dal modello Llama 2 e le visualizzi nell'area chat.

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 funzione crea una stringa della cronologia delle conversazioni che include sia i messaggi dell'utente che quelli dell'assistente prima di chiamare il debounce_replicate_run funzione per ottenere la risposta dell'assistente. Modifica continuamente la risposta nell'interfaccia utente per offrire un'esperienza di chat in tempo reale.

Scrivi la funzione principale responsabile del rendering dell'intera app Streamlit.

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

Richiama tutte le funzioni definite per impostare lo stato della sessione, eseguire il rendering della barra laterale, la cronologia della chat, gestire l'input dell'utente e generare risposte dell'assistente in ordine logico.

Scrivi una funzione per invocare il render_app funzione e avviare l'applicazione quando lo script viene eseguito.

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

Ora la tua applicazione dovrebbe essere pronta per l'esecuzione.

Gestione delle richieste API

Creare un utils.py file nella directory del progetto e aggiungi la funzione seguente:

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 funzione esegue un meccanismo di antirimbalzo per impedire query API frequenti ed eccessive dall'input di un utente.

Successivamente, importa la funzione di risposta al rimbalzo nel tuo file lama_chatbot.py archiviare come segue:

from utils import debounce_replicate_run

Ora esegui l'applicazione:

streamlit run llama_chatbot.py

Risultato previsto:

L'output mostra una conversazione tra il modello e un essere umano.

Applicazioni reali dei chatbot Streamlit e Llama 2

Alcuni esempi reali di applicazioni di Llama 2 includono:

• Chatbot: Il suo utilizzo si applica alla creazione chatbot a risposta umana che può sostenere conversazioni in tempo reale su diversi argomenti.
• Assistenti virtuali: Il suo utilizzo si applica alla creazione di assistenti virtuali che comprendono e rispondono alle domande del linguaggio umano.
• Traduzione linguistica: Il suo utilizzo si applica alle attività di traduzione linguistica.
• Riepilogo del testo: Il suo utilizzo è applicabile nel riassumere testi di grandi dimensioni in testi brevi per una facile comprensione.
• Ricerca: puoi applicare Llama 2 per scopi di ricerca rispondendo a domande su una vasta gamma di argomenti.

Il futuro dell'intelligenza artificiale

Con modelli chiusi come GPT-3.5 e GPT-4, è piuttosto difficile per i piccoli operatori creare qualcosa di sostanziale utilizzando LLM poiché l'accesso all'API del modello GPT può essere piuttosto costoso.

L’apertura di modelli linguistici avanzati di grandi dimensioni come Llama 2 alla comunità degli sviluppatori è solo l’inizio di una nuova era dell’intelligenza artificiale. Porterà a un’implementazione più creativa e innovativa dei modelli nelle applicazioni del mondo reale, portando a una corsa accelerata verso il raggiungimento della Super Intelligenza Artificiale (ASI).