Jak zbudować chatbota przy użyciu Streamlit i Llama 2
Llama 2 to duży model językowy o otwartym kodzie źródłowym, opracowany przez firmę Meta. Ten konkretny model może pochwalić się imponującymi możliwościami, co czyni go potężnym rywalem w porównaniu z innymi zamkniętymi modelami, takimi jak GPT-3.5 i PaLM. W rzeczywistości wielu ekspertów twierdzi, że Llama 2 przewyższa te alternatywy pod względem wydajności. Architektura tego modelu obejmuje trzy różne wstępnie wytrenowane i dostrojone generatywne modele tekstowe, każdy o różnym poziomie złożoności. Modele te obejmują wersje z odpowiednio 7 miliardami, 13 miliardami i 70 miliardami parametrów.
Zagłęb się w dialogowy potencjał Llama 2, konstruując chatbota wykorzystującego Streamlit i możliwości Llama 2 do interakcji z użytkownikami w czasie rzeczywistym.
Zrozumienie Llama 2: funkcje i korzyści
Jak bardzo różni się Llama 2, najnowsza iteracja dużego modelu językowego, w porównaniu z jego poprzednią wersją, Llama 1?
Rozszerzony model może pochwalić się znacznie rozszerzoną architekturą, obejmującą aż 70 miliardów parametrów. Tak duża liczba parametrów ułatwia przyswajanie coraz bardziej złożonych relacji nieodłącznie związanych z sekwencjami słów.
Reinforcement Learning from Human Feedback (RLHF) wykazał swoją skuteczność w zwiększaniu możliwości aplikacji konwersacyjnych, skutkując bardziej naturalnymi i przekonującymi odpowiedziami, które mogą być generowane w szerokim zakresie złożonych dialogów. Włączenie RLHF do tych modeli nie tylko zwiększa ich zdolność do rozumienia kontekstu, ale także umożliwia im dostarczanie bardziej spójnych i trafnych odpowiedzi, zapewniając w ten sposób lepsze wrażenia użytkownika.
Wprowadzenie innowacyjnej techniki znanej jako “grouped-query attention” znacznie przyspieszyło proces wnioskowania, umożliwiając tym samym rozwój wysoce funkcjonalnych aplikacji, takich jak chatboty i wirtualni asystenci.
Obecna wersja wykazuje wyższy poziom wydajności zarówno w odniesieniu do wykorzystania pamięci, jak i zasobów obliczeniowych, w porównaniu do poprzedniej iteracji.
Llama 2 jest licencjonowana na zasadach open-source i niekomercyjnych, co pozwala badaczom i programistom swobodnie wykorzystywać i modyfikować jej funkcje bez żadnych ograniczeń narzuconych przez interesy komercyjne.
Llama 2 wykazuje lepszą wydajność w różnych aspektach w porównaniu do swojej poprzedniej iteracji, co czyni ją wyjątkowo solidnym narzędziem dla wielu narzędzi, w tym interakcji chatbota, wirtualnych pomocników i rozumienia języka naturalnego.
Konfigurowanie środowiska Streamlit do rozwoju chatbota
Aby rozpocząć tworzenie aplikacji, konieczne jest ustanowienie środowiska programistycznego, które służy do oddzielenia bieżącego projektu od wszelkich wcześniej istniejących projektów przechowywanych na urządzeniu.
Aby rozpocząć, należy utworzyć środowisko wirtualne przy użyciu biblioteki Pipenv w następujący sposób:
pipenv shell
Następnie przystąpimy do instalacji wymaganych komponentów oprogramowania w celu skonstruowania agenta konwersacyjnego.
pipenv install streamlit replicate
Streamlit to wszechstronny framework do tworzenia aplikacji internetowych o otwartym kodzie źródłowym, zaprojektowany w celu ułatwienia szybkiego wdrażania projektów uczenia maszynowego i nauki o danych.
Zasadniczo “Replicate” odnosi się do platformy przetwarzania w chmurze, która oferuje użytkownikom dostęp do szerokiej gamy modeli uczenia maszynowego typu open source, które można łatwo wdrożyć i wykorzystać w różnych aplikacjach.
Uzyskaj swój token API Llama 2 z Replicate
Aby uzyskać klucz tokena Replicate, musisz najpierw zarejestrować konto na Replicate przy użyciu swojego konta GitHub.
Replicate zezwala na logowanie tylko za pośrednictwem konta GitHub .
Po uzyskaniu dostępu do pulpitu nawigacyjnego przejdź do zakładki “Eksploruj” i znajdź pasek wyszukiwania. Wpisz “Llama 2 chat” w polu wyszukiwania, aby wyświetlić konkretny model o nazwie “llama-2-70b-chat”.
Wybierz opcję “Llama 2 API Endpoint” z rozwijanego menu i kliknij na nią. Gdy to zrobisz, przejdź do sekcji oznaczonej “Token API”. Tutaj znajdziesz przycisk oznaczony jako “Aplikacja Python”. Klikając ten przycisk, uzyskasz dostęp do niezbędnych danych uwierzytelniających wymaganych do korzystania z interfejsu API Llama 2 w projektach Python.
Skopiuj token API do celów replikacji i zapewnij jego bezpieczne przechowywanie do wykorzystania w przyszłości.
Dostęp do pełnego kodu źródłowego można uzyskać za pośrednictwem naszego repozytoriumGitHub, które zapewnia kompleksowe zasoby dla programistów do wykorzystania i wniesienia wkładu w projekt.
Budowanie Chatbota
Aby rozpocząć rozwój Llama Chatbot, należy najpierw wygenerować dwa oddzielne pliki - jeden o nazwie “llama\_chatbot.py”, który służy jako podstawowy skrypt do implementacji funkcjonalności chatbota, oraz drugi plik o nazwie “.env”, zaprojektowany specjalnie do przechowywania poufnych informacji, takich jak tajne klucze i tokeny API wymagane do prawidłowego działania. Przestrzegając tej wstępnej konfiguracji, można skutecznie odizolować wrażliwe dane od głównego kodu źródłowego, zapewniając jednocześnie płynną integrację z usługami zewnętrznymi.
W celu wykorzystania różnych funkcjonalności w skrypcie llama_chatbot.py konieczne jest zaimportowanie kilku bibliotek. Proces importowania tych bibliotek polega na określeniu ich nazw i upewnieniu się, że są one odpowiednio zintegrowane z istniejącą bazą kodu. Pozwala to na płynne działanie i realizację zamierzonej funkcjonalności chatbota.
import streamlit as st
import os
import replicate
Następnie ustalimy globalne parametry dla modelu językowego “llama-2-70b-chat”, inicjalizując powiązane z nim zmienne.
# 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='')
Aby włączyć tokeny Replicate API i informacje o modelu do zmiennych środowiskowych aplikacji, należy dołączyć odpowiednie szczegóły do pliku “.env”, wykorzystując określoną strukturę formatowania. Pozwoli to na płynną integrację tych komponentów w projekcie.
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'
Powiel dostarczony token i upewnij się, że zapisałeś odpowiedni plik .env.
Projektowanie przepływu konwersacji Chatbota
Proces inicjowania użycia modelu językowego Llama 2 do określonych zadań można ułatwić, generując wstępny monit, który określa pożądany cel. Na przykład, jeśli celem jest wykorzystanie modelu w charakterze asystenta, sformułowanie odpowiedniego oświadczenia inicjującego obejmowałoby określenie takiego zamiaru i potencjalne określenie wszelkich szczególnych obszarów zainteresowania lub wiedzy specjalistycznej wymaganej do skutecznego pełnienia tej roli. Dzięki dostarczeniu jasnych instrukcji z góry, interakcja z wirtualnym asystentem opartym na sztucznej inteligencji będzie przebiegać sprawniej i dokładniej.
# 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."
Konfiguracja strony chatbota może być zorganizowana na różne sposoby, w zależności od pożądanego wyglądu i funkcjonalności. Niektóre kluczowe kwestie, o których należy pamiętać, obejmują elementy projektu, takie jak schematy kolorów, wybór czcionek i opcje układu. Ponadto ważne jest, aby określić, jakie informacje lub funkcje będą wyświetlane na stronie, w tym wszelkie interaktywne elementy, takie jak przyciski lub formularze. Konkretne szczegóły układu mogą się różnić w zależności od indywidualnych preferencji i wymagań, ale posiadanie jasnego planu może pomóc w zapewnieniu, że ostateczny wynik spełni zamierzone cele i zadania.
# Set initial page configuration
st.set_page_config(
page_title="LLaMA2Chat",
page_icon=":volleyball:",
layout="wide"
)
Inicjowanie i ustalanie konfiguracji zmiennych specyficznych dla sesji poprzez wdrożenie procedury funkcjonalnej.
# 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
def setup_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)
Wspomniany proces konfiguruje kluczowe parametry, takie jak chat_dialog , pre_prompt , llm , top_p , max_seq_len , i temperature w ramach stanu sesji. Dodatkowo ułatwia wybór preferowanego modelu Llama 2 zgodnie z preferencjami użytkownika.
Oto przykład, jak można utworzyć funkcję w Pythonie, która renderuje zawartość paska bocznego dla aplikacji Streamlit: pythondef render_sidebar():# Kod do wygenerowania kodu HTML dla paska bocznego przechodzi tutajeturn “Twoja zawartość paska bocznego przechodzi tutaj”
def render_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 is not None:
st.session_state['pre_prompt'] = new_prompt \\+ "\n"
else:
st.session_state['pre_prompt'] = DEFAULT_PRE_PROMPT
Wyżej wymieniony komponent prezentuje nagłówek i parametry konfiguracyjne, które można modyfikować w celu optymalizacji wydajności chatbota Llama 2, ułatwiając niezbędne dostosowania w celu uzyskania optymalnej funkcjonalności.
Oto możliwa implementacja renderowania historii czatu w głównym obszarze treści aplikacji Streamlit przy użyciu HTML i CSS:pythonimport streamlit as stfrom transformers import GPT2LMHeadModel, GPT2Tokenizerfrom streamlit_chat import message# Load fine-tuned model and tokenizermodel = GPT2LMHeadModel.from_pretrained(‘meditations_model’)tokenizer = GPT2Tokenizer. from_pretrained(‘meditations_model’)# Define chatbot functiondef chatbot(text):input_ids = tokenizer.encode(text, return_tensors=‘pt’)output = model. generate(input_ids=input_ids, max_length=
def render_chat_history():
response_container = st.container()
for message in st.session_state.chat_dialogue:
with st.chat_message(message["role"]):
st.markdown(message["content"])
Metoda przechodzi przez obiekt chat_dialog przechowywany w stanie sesji, wyświetlając każdą komunikację wymienioną między użytkownikiem a asystentem, wraz z odpowiednim identyfikatorem roli (“użytkownik” lub “asystent”).
Dostarczony fragment kodu wydaje się być symbolem zastępczym funkcji przetwarzającej dane wejściowe użytkownika, ale nie podano rzeczywistej implementacji. Aby obsługiwać dane wejściowe użytkownika w bardziej wyrafinowany sposób, konieczne byłoby zdefiniowanie i zaimplementowanie odpowiedniego algorytmu lub logiki w funkcji w oparciu o specyficzne wymagania aplikacji.
def handle_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)
Komponent prezentacyjny zapewnia interfejs wprowadzania tekstu dla użytkowników, umożliwiając im przesyłanie wiadomości lub zapytań w kontekście konwersacji. Po otrzymaniu danych wejściowych użytkownika dołącza wiadomość do trwającego dialogu przechowywanego jako część danych specyficznych dla sesji, które zawierają metadane określające rolę uczestnika jako “użytkownika” lub “bota”.
Oto przykład, jak można zaimplementować tę funkcjonalność przy użyciu Pythona i biblioteki Hugging Face Transformers:pythonfrom transformers import LlamaTokenizer, LlamaForCausalLMimport torchdef generate_responses(input_text):# Załaduj wstępnie wytrenowany tokenizer Llama i modeltokenizer = LlamaTokenizer.from_pretrained(‘facebook/llama-base’)model = LlamaForCausalLM. from_pretrained(‘facebook/llama-base’)# Encode the input text as input IDsinputs = tokenizer(input_text, return_tensors=‘pt’).input_ids# Generate
def generate_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})
System generuje archiwum wcześniejszej komunikacji, obejmujące zarówno dane wejściowe człowieka, jak i sztucznej inteligencji, przed wywołaniem procesu odroczonej replikacji. Umożliwia to płynne prowadzenie dialogu poprzez dynamiczną aktualizację interfejsu o najnowszą odpowiedź sztucznej inteligencji.
Podstawowym zadaniem tej aplikacji jest renderowanie wszystkich komponentów w ramach Streamlit, który służy jako kompleksowy interfejs dla użytkowników.
def render_app():
setup_session_state()
render_sidebar()
render_chat_history()
handle_user_input()
generate_assistant_response()
Aplikacja wykorzystuje zorganizowaną sekwencję operacji w celu ustalenia stanu sesji, wyświetlenia panelu bocznego, kroniki czatów, przetwarzania danych wejściowych użytkownika i tworzenia odpowiedzi pomocniczych przy użyciu wszystkich wcześniej zdefiniowanych funkcji.
Oto przykład tego, jak można zmodyfikować funkcję main() w pliku index.js , aby użyć funkcji renderApp() i uruchomić aplikację, gdy skrypt jest wykonywany: javascriptasync function main() {const app = createContext(null); // Utwórz kontekst dostawcy z wartością początkową null// Owiń funkcję renderApp blokiem try-catch do obsługi błędów try {renderApp(app, document.getElementById(‘root’));} catch (err) {console.error( Błąd wykonania komponentu root:\n${err. stack} );}}// Wywołaj funkcję main, aby uruchomić aplikacjęmain();Ten kod tworzy nową instancję kontekstu dostawcy, przekazując null
def main():
render_app()
if __name__ == "__main__":
main()
Twoja aplikacja jest teraz przygotowana i wyposażona do wdrożenia, umożliwiając jej łatwe wykonanie.
Obsługa żądań API
Aby zaimplementować żądaną funkcjonalność, konieczne jest utworzenie nowego modułu Pythona o nazwie “utils.py” w katalogu głównym projektu. Moduł ten będzie zawierał pojedynczą funkcję wykonującą określone zadanie. Poniżej znajduje się przykład, jak można to osiągnąć:pythondef some_function():# Kod funkcji znajduje się tutaj…
import replicate
import time
# Initialize debounce variables
last_call_time = 0
debounce_interval = 2 # Set the debounce interval (in seconds)
def debounce_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
Funkcjonalność zawiera mechanizm debouncingu w celu zmniejszenia ryzyka zbyt częstych i rozrzutnych żądań API wynikających z interakcji użytkownika, zapewniając w ten sposób rozważne wykorzystanie zasobów.
Włącz funkcję debounced response do skryptu llama_chatbot.py , wykonując następujące kroki:
from utils import debounce_replicate_run
Teraz uruchom aplikację:
streamlit run llama_chatbot.py
Oczekiwane dane wyjściowe:
Interakcja wyświetlana na tym wyjściu to dialog między modelem językowym AI a ludzkim użytkownikiem.
Rzeczywiste zastosowania chatbotów Streamlit i Llama 2
Kilka przypadków praktycznego wykorzystania oprogramowania Llama 2 można zaobserwować w różnych branżach, takich jak:
Chatboty są wszechstronnym narzędziem wykorzystywanym do opracowywania interaktywnych agentów zdolnych do prowadzenia dyskusji w czasie rzeczywistym na różne tematy, wykorzystując przetwarzanie języka naturalnego i algorytmy sztucznej inteligencji w celu zapewnienia odpowiednich odpowiedzi na podstawie danych wejściowych użytkownika.
Narzędzie to, wykorzystujące technologię rozumienia języka naturalnego, zostało zaprojektowane do tworzenia agentów konwersacyjnych zdolnych do rozumienia i odpowiadania na ludzką komunikację w sposób naśladujący ludzką interakcję.
Wykorzystanie technologii tłumaczenia językowego jest ograniczone do tłumaczenia języków w różnych zadaniach językowych.
Streszczanie tekstu polega na skondensowaniu długiego tekstu w krótszą, bardziej zwięzłą wersję, która zachowuje jego podstawowe znaczenie i kluczowe punkty, jednocześnie odrzucając niepotrzebne szczegóły. Proces ten może być przydatny w różnych kontekstach, takich jak dziennikarstwo, artykuły naukowe lub media społecznościowe, gdzie szybki dostęp do informacji ma kluczowe znaczenie. Przedstawiając tylko najważniejsze aspekty danego tematu, streszczenie pozwala czytelnikom skutecznie uchwycić główne idee bez konieczności czytania całego dokumentu słowo po słowie.
Zastosowanie Llama 2 do celów badawczych obejmuje odpowiadanie na zapytania obejmujące szereg tematów.
Przyszłość sztucznej inteligencji
Wyzwanie związane z wysokimi kosztami związanymi z wykorzystaniem dużych modeli językowych, takich jak te znalezione w GPT-3.5 i GPT-4, ograniczyło zdolność mniejszych podmiotów do tworzenia godnych uwagi aplikacji, biorąc pod uwagę, że uzyskanie dostępu do API dla tych modeli często wiąże się ze znacznymi kosztami.
Ujawnienie potężnych frameworków lingwistycznych, takich jak Llama 2, oznacza początek nowej epoki w sztucznej inteligencji. Ta ewentualność będzie sprzyjać pomysłowemu i pomysłowemu wykorzystaniu tych systemów w praktycznych scenariuszach, napędzając w ten sposób postęp w kierunku osiągnięcia sztucznej superinteligencji w przyspieszonym tempie.