Wykorzystaj open source Llama 2 LLM, aby zbudować niestandardowego chatbota w języku Python.

Llama 2 to model dużego języka (LLM) o otwartym kodzie źródłowym opracowany przez firmę Meta. Jest to kompetentny, wielkojęzykowy model o otwartym kodzie źródłowym, prawdopodobnie lepszy niż niektóre modele zamknięte, takie jak GPT-3.5 i PaLM 2. Składa się z trzech wstępnie wyszkolonych i precyzyjnie dostrojonych rozmiarów modeli tekstu generatywnego, w tym modeli o parametrach 7 miliardów, 13 miliardów i 70 miliardów.

Poznasz możliwości konwersacyjne Llamy 2, budując chatbota przy użyciu Streamlit i Llama 2.

Zrozumienie Lamy 2: Funkcje i zalety

Jak bardzo różni się Llama 2 od swojej poprzedniczki duży model językowy, Lama 1?

  • Większy rozmiar modelu: Model jest większy i zawiera aż 70 miliardów parametrów. Dzięki temu może nauczyć się bardziej skomplikowanych skojarzeń między słowami i zdaniami.
  • Ulepszone możliwości konwersacji: Uczenie się ze wzmocnieniem na podstawie informacji zwrotnej od ludzi (RLHF) poprawia umiejętności aplikacji konwersacyjnych. Dzięki temu model może generować treści przypominające ludzkie nawet w skomplikowanych interakcjach.
    instagram viewer
  • Szybsze wnioskowanie: Wprowadza nowatorską metodę zwaną uwagą na zapytania grupowe, aby przyspieszyć wnioskowanie. Dzięki temu może tworzyć bardziej przydatne aplikacje, takie jak chatboty i wirtualni asystenci.
  • Bardziej wydajny: Jest bardziej wydajny pod względem pamięci i zasobów obliczeniowych niż jego poprzednik.
  • Licencja typu open source i niekomercyjna: Jest to oprogramowanie typu open source. Badacze i programiści mogą używać i modyfikować Lamę 2 bez ograniczeń.

Llama 2 pod każdym względem znacząco przewyższa swoją poprzedniczkę. Te cechy sprawiają, że jest to potężne narzędzie do wielu zastosowań, takich jak chatboty, wirtualni asystenci i zrozumienie języka naturalnego.

Konfigurowanie usprawnionego środowiska do tworzenia chatbotów

Aby rozpocząć budowanie aplikacji, musisz skonfigurować środowisko programistyczne. Ma to na celu odizolowanie projektu od istniejących projektów na komputerze.

Najpierw zacznij od tworzenie środowiska wirtualnego używając Pipenv bibliotekę w następujący sposób:

pipenv shell

Następnie zainstaluj niezbędne biblioteki, aby zbudować chatbota.

pipenv install streamlit replicate

Usprawniony: Jest to platforma aplikacji internetowych typu open source, która szybko renderuje aplikacje do uczenia maszynowego i analizy danych.

Replika: Jest to platforma chmurowa zapewniająca dostęp do dużych modeli uczenia maszynowego typu open source do wdrożenia.

Zdobądź swój token API Lamy 2 z replikacji

Aby otrzymać klucz tokena Replikuj, należy najpierw zarejestrować konto na Replika używając swojego konta GitHub.

Replikacja umożliwia logowanie tylko za pośrednictwem pliku Konto GitHuba.

Po uzyskaniu dostępu do pulpitu nawigacyjnego przejdź do Badać i wyszukaj czat Llama 2, aby zobaczyć lama-2–70b-czat Model.

Kliknij na lama-2–70b-czat model, aby wyświetlić punkty końcowe API Lamy 2. Kliknij API przycisk na lama-2–70b-czat pasek nawigacyjny modelu. W prawej części strony kliknij przycisk Pyton przycisk. Zapewni to dostęp do tokena API dla aplikacji Python.

Skopiuj REPLICATE_API_TOKEN i przechowuj go w bezpiecznym miejscu do wykorzystania w przyszłości.

Pełny kod źródłowy jest dostępny w tym Repozytorium GitHuba.

Budowa Chatbota

Najpierw utwórz plik Pythona o nazwie llama_chatbot.py oraz plik env (.env). Będziesz pisać swój kod w llama_chatbot.py i przechowywać tajne klucze i tokeny API w pliku .env.

W pliku llama_chatbot.py zaimportuj biblioteki w następujący sposób.

import streamlit as st 
import os 
import replicate

Następnie ustaw zmienne globalne pliku lama-2–70b-czat 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='')

W pliku .env dodaj token replikacji i punkty końcowe modelu w następującym formacie:

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'

Wklej token replikacji i zapisz plik .env.

Projektowanie przebiegu konwersacji w Chatbocie

Utwórz monit wstępny, aby uruchomić model Lamy 2, w zależności od tego, jakie zadanie chcesz wykonać. W tym przypadku chcesz, aby model działał jako asystent.

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

Skonfiguruj konfigurację strony dla swojego chatbota w następujący sposób:

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

Napisz funkcję, która inicjuje i konfiguruje zmienne stanu sesji.

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

Funkcja ustawia podstawowe zmienne, takie jak chat_dialog, pre_prompt, llm, góra_p, max_seq_len, I temperatura w stanie sesji. Obsługuje również wybór modelu Llama 2 w oparciu o wybór użytkownika.

Napisz funkcję renderującą zawartość paska bocznego aplikacji 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

Funkcja wyświetla nagłówek i zmienne ustawień chatbota Llama 2 w celu dostosowania.

Napisz funkcję wyświetlającą historię czatów w głównym obszarze zawartości aplikacji 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"])

Funkcja iteruje po chat_dialogue zapisanym w stanie sesji, wyświetlając każdą wiadomość z odpowiednią rolą (użytkownik lub asystent).

Obsługuj dane wejściowe użytkownika, korzystając z poniższej funkcji.

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)

Funkcja ta przedstawia użytkownik z polem wejściowym, w którym mogą wpisać swoje wiadomości i pytania. Wiadomość została dodana do chat_dialog w stanie sesji z użytkownik rolę po przesłaniu wiadomości przez użytkownika.

Napisz funkcję, która generuje odpowiedzi z modelu Lamy 2 i wyświetla je w obszarze czatu.

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

Funkcja tworzy ciąg historii konwersacji, który zawiera wiadomości użytkownika i asystenta przed wywołaniem debounce_replicate_run funkcję uzyskania odpowiedzi asystenta. Stale modyfikuje odpowiedź w interfejsie użytkownika, aby zapewnić czat w czasie rzeczywistym.

Napisz główną funkcję odpowiedzialną za renderowanie całej aplikacji Streamlit.

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

Wywołuje wszystkie zdefiniowane funkcje w celu ustawienia stanu sesji, renderowania paska bocznego, historii czatów, obsługi danych wprowadzanych przez użytkownika i generowania odpowiedzi asystentów w logicznej kolejności.

Napisz funkcję wywołującą aplikacja_renderowania funkcję i uruchomić aplikację po wykonaniu skryptu.

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

Teraz Twoja aplikacja powinna być gotowa do wykonania.

Obsługa żądań API

Stwórz utils.py plik w katalogu projektu i dodaj poniższą funkcję:

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

Funkcja wykonuje mechanizm odrzucania, aby zapobiec częstym i nadmiernym zapytaniom API z danych wejściowych użytkownika.

Następnie zaimportuj funkcję odpowiedzi na odrzucenie do pliku llama_chatbot.py plik w następujący sposób:

from utils import debounce_replicate_run

Teraz uruchom aplikację:

streamlit run llama_chatbot.py

Oczekiwany wynik:

Wynik przedstawia rozmowę pomiędzy modelem a człowiekiem.

Zastosowania chatbotów Streamlit i Llama 2 w świecie rzeczywistym

Oto kilka rzeczywistych przykładów zastosowań Lamy 2:

  • Chatboty: Jego użycie dotyczy tworzenia chatboty reagujące na ludzi które mogą prowadzić rozmowy w czasie rzeczywistym na kilka tematów.
  • Wirtualni asystenci: Jego zastosowanie dotyczy tworzenia wirtualnych asystentów, którzy rozumieją zapytania w języku ludzkim i odpowiadają na nie.
  • Tłumaczenie językowe: Jego użycie dotyczy zadań związanych z tłumaczeniem językowym.
  • Podsumowanie tekstu: Jego użycie ma zastosowanie przy podsumowywaniu dużych tekstów w krótkie teksty dla łatwego zrozumienia.
  • Badania: Możesz zastosować Llamę 2 do celów badawczych, odpowiadając na pytania z różnych tematów.

Przyszłość sztucznej inteligencji

W przypadku zamkniętych modeli, takich jak GPT-3.5 i GPT-4, małym graczom jest dość trudno zbudować cokolwiek merytorycznego przy użyciu LLM, ponieważ dostęp do API modelu GPT może być dość kosztowny.

Udostępnienie społeczności programistów zaawansowanych, dużych modeli językowych, takich jak Llama 2, to dopiero początek nowej ery sztucznej inteligencji. Doprowadzi to do bardziej kreatywnego i innowacyjnego wdrażania modeli w zastosowaniach w świecie rzeczywistym, co doprowadzi do przyspieszonego wyścigu w kierunku osiągnięcia sztucznej superinteligencji (ASI).