Een chatbot bouwen met Streamlit en Llama 2

Llama 2 is een open-source groottaalmodel (LLM), ontwikkeld door Meta. Het is een competent open-source groottaalmodel, aantoonbaar beter dan sommige gesloten modellen zoals GPT-3.5 en PaLM 2. Het bestaat uit drie vooraf getrainde en verfijnde generatieve tekstmodelgroottes, waaronder de 7 miljard, 13 miljard en 70 miljard parametermodellen.

Je ontdekt de gespreksmogelijkheden van Llama 2 door een chatbot te bouwen met behulp van Streamlit en Llama 2.

Lama 2 begrijpen: kenmerken en voordelen

Hoe anders is Llama 2 van zijn voorganger groot taalmodel, Lama 1?

• Grotere modelgrootte: Het model is groter, met maximaal 70 miljard parameters. Hierdoor kan het ingewikkeldere associaties tussen woorden en zinnen leren.
• Verbeterde gespreksmogelijkheden: Versterkend leren van menselijke feedback (RLHF) verbetert de toepassingsmogelijkheden van gesprekken. Hierdoor kan het model menselijke inhoud genereren, zelfs in ingewikkelde interacties.
instagram viewer
• Snellere gevolgtrekking: Het introduceert een nieuwe methode genaamd gegroepeerde query-aandacht om de gevolgtrekking te versnellen. Dit resulteert in de mogelijkheid om nuttiger applicaties te bouwen, zoals chatbots en virtuele assistenten.
• Efficiënter: Het is efficiënter met geheugen en rekenbronnen dan zijn voorganger.
• Open-source en niet-commerciële licentie: Het is open source. Onderzoekers en ontwikkelaars kunnen Llama 2 zonder beperkingen gebruiken en aanpassen.

Llama 2 presteert in alle opzichten aanzienlijk beter dan zijn voorganger. Deze kenmerken maken het een krachtig hulpmiddel voor veel toepassingen, zoals chatbots, virtuele assistenten en het begrijpen van natuurlijke taal.

Een gestroomlijnde omgeving opzetten voor de ontwikkeling van chatbots

Om te beginnen met het bouwen van uw applicatie, moet u een ontwikkelomgeving opzetten. Dit is om uw project te isoleren van de bestaande projecten op uw computer.

Begin eerst eens met het creëren van een virtuele omgeving de... gebruiken Pijpenv bibliotheek als volgt:

pipenv shell

Installeer vervolgens de benodigde bibliotheken om de chatbot te bouwen.

pipenv install streamlit replicate

Gestroomlijnd: Het is een open-source webapp-framework dat toepassingen voor machinaal leren en datawetenschap snel weergeeft.

Repliceren: Het is een cloudplatform dat toegang biedt tot grote open-source machine-learning-modellen voor implementatie.

Haal uw Llama 2 API-token van Replicate

Om een ​​Replicate-tokensleutel te krijgen, moet u eerst een account registreren op Repliceren met behulp van uw GitHub-account.

Met repliceren is aanmelden alleen mogelijk via een GitHub-account.

Nadat u het dashboard heeft geopend, navigeert u naar de Ontdekken knop en zoek naar Llama 2-chat om de lama-2–70b-chat model.

Klik op de lama-2–70b-chat model om de Llama 2 API-eindpunten te bekijken. Klik op de API knop op de lama-2–70b-chat navigatiebalk van het model. Klik aan de rechterkant van de pagina op de Python knop. Hiermee krijgt u toegang tot het API-token voor Python-applicaties.

Kopieer de REPLICATE_API_TOKEN en bewaar deze veilig voor toekomstig gebruik.

Hierin is de volledige broncode beschikbaar GitHub-opslagplaats.

Het bouwen van de chatbot

Maak eerst een Python-bestand met de naam lama_chatbot.py en een env-bestand (.env). U schrijft uw code in llama_chatbot.py en slaat uw geheime sleutels en API-tokens op in het .env-bestand.

Importeer de bibliotheken in het bestand llama_chatbot.py als volgt.

import streamlit as st 
import os 
import replicate

Stel vervolgens de globale variabelen van de lama-2–70b-chat model.

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

Voeg aan het .env-bestand het repliceertoken en modeleindpunten toe in de volgende indeling:

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'

Plak uw replicatietoken en sla het .env-bestand op.

Het ontwerpen van de gespreksstroom van de chatbot

Maak een pre-prompt om het Llama 2-model te starten, afhankelijk van de taak die u wilt uitvoeren. In dit geval wilt u dat het model als assistent fungeert.

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

Stel de paginaconfiguratie voor uw chatbot als volgt in:

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

Schrijf een functie die sessiestatusvariabelen initialiseert en instelt.

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

De functie stelt de essentiële variabelen in, zoals chat_dialoog, pre_prompt, llm, top_p, max_seq_len, En temperatuur in de sessiestatus. Het regelt ook de selectie van het Llama 2-model op basis van de keuze van de gebruiker.

Schrijf een functie om de zijbalkinhoud van de Streamlit-app weer te geven.

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

De functie toont de header en de instellingsvariabelen van de Llama 2-chatbot voor aanpassingen.

Schrijf de functie die de chatgeschiedenis weergeeft in het hoofdinhoudsgebied van de Streamlit-app.

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"])

De functie doorloopt de chat_dialogue die is opgeslagen in de sessiestatus, waarbij elk bericht wordt weergegeven met de bijbehorende rol (gebruiker of assistent).

Behandel de invoer van de gebruiker met behulp van de onderstaande functie.

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)

Deze functie presenteert de gebruiker met een invoerveld waar ze hun berichten en vragen kunnen invoeren. Het bericht wordt toegevoegd aan de chat_dialoog in de sessiestatus met de gebruiker rol zodra de gebruiker het bericht verzendt.

Schrijf een functie die reacties genereert uit het Llama 2-model en deze weergeeft in het chatgedeelte.

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})

De functie creëert een gespreksgeschiedenisreeks die zowel gebruikers- als assistentberichten bevat voordat de debounce_replicaat_run functie om het antwoord van de assistent te verkrijgen. Het past voortdurend de reactie in de gebruikersinterface aan om een ​​realtime chatervaring te bieden.

Schrijf de hoofdfunctie die verantwoordelijk is voor het renderen van de gehele Streamlit-app.

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

Het roept alle gedefinieerde functies op om de sessiestatus in te stellen, de zijbalk weer te geven, de chatgeschiedenis weer te geven, gebruikersinvoer af te handelen en assistent-reacties in een logische volgorde te genereren.

Schrijf een functie om de render_app functie en start de applicatie wanneer het script wordt uitgevoerd.

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

Nu zou uw applicatie klaar moeten zijn voor uitvoering.

Het afhandelen van API-aanvragen

Maak een utils.py bestand in uw projectmap en voeg de onderstaande functie toe:

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

De functie voert een debounce-mechanisme uit om frequente en buitensporige API-query's op basis van de invoer van een gebruiker te voorkomen.

Importeer vervolgens de debounce-reactiefunctie in uw lama_chatbot.py bestand als volgt:

from utils import debounce_replicate_run

Voer nu de applicatie uit:

streamlit run llama_chatbot.py

Verwachte resultaten:

De uitvoer toont een gesprek tussen het model en een mens.

Real-world toepassingen van Streamlit en Llama 2 chatbots

Enkele praktijkvoorbeelden van Llama 2-toepassingen zijn onder meer:

• Chatbots: Het gebruik ervan is van toepassing op creëren chatbots met menselijke respons die realtime gesprekken over verschillende onderwerpen kunnen voeren.
• Virtuele assistenten: Het gebruik ervan is van toepassing op het creëren van virtuele assistenten die vragen in menselijke taal begrijpen en erop reageren.
• Taal vertaling: Het gebruik ervan is van toepassing op vertaaltaken.
• Samenvatting van de tekst: Het gebruik ervan is toepasbaar bij het samenvatten van grote teksten in korte teksten voor gemakkelijk begrip.
• Onderzoek: Je kunt Llama 2 toepassen voor onderzoeksdoeleinden door vragen over een reeks onderwerpen te beantwoorden.

De toekomst van AI

Met gesloten modellen zoals GPT-3.5 en GPT-4 is het voor kleine spelers behoorlijk moeilijk om iets substantieels te bouwen met behulp van LLM's, aangezien toegang tot de GPT-model-API behoorlijk duur kan zijn.

Het openstellen van geavanceerde grote taalmodellen zoals Llama 2 voor de ontwikkelaarsgemeenschap is nog maar het begin van een nieuw tijdperk van AI. Het zal leiden tot een creatievere en innovatievere implementatie van de modellen in toepassingen in de echte wereld, wat zal leiden tot een versnelde race naar het bereiken van kunstmatige superintelligentie (ASI).