วิธีสร้าง Chatbot โดยใช้ Streamlit และ Llama 2

Llama 2 เป็นโมเดลภาษาโอเพ่นซอร์สขนาดใหญ่ที่พัฒนาโดย Meta นาฬิการุ่นนี้มีความสามารถที่น่าประทับใจ ทำให้เป็นคู่แข่งที่น่าเกรงขามเมื่อเปรียบเทียบกับรุ่นปิดอื่นๆ เช่น GPT-3.5 และ PaLM ในความเป็นจริง ผู้เชี่ยวชาญหลายคนแย้งว่า Llama 2 เหนือกว่าทางเลือกเหล่านี้ในแง่ของประสิทธิภาพ สถาปัตยกรรมของโมเดลนี้ประกอบด้วยโมเดลข้อความที่สร้างไว้ล่วงหน้าและปรับแต่งอย่างละเอียดสามโมเดล โดยแต่ละโมเดลมีระดับความซับซ้อนที่แตกต่างกัน โมเดลเหล่านี้ประกอบด้วยเวอร์ชันที่มีพารามิเตอร์ 7 พันล้าน, 13 พันล้าน และ 70 พันล้านตามลำดับ

เจาะลึกศักยภาพเชิงโต้ตอบของ Llama 2 ด้วยการสร้างแชทบอตที่ใช้ความสามารถของ Streamlit และ Llama 2 เพื่อโต้ตอบกับผู้ใช้แบบเรียลไทม์

ทำความเข้าใจ Llama 2: คุณสมบัติและคุณประโยชน์

Llama 2 ซึ่งเป็นเวอร์ชันภาษาขนาดใหญ่มีความแตกต่างกันเพียงใด เมื่อเปรียบเทียบกับ Llama 1 เวอร์ชันก่อนหน้า

โมเดลเสริมมีสถาปัตยกรรมที่ขยายตัวอย่างมาก โดยครอบคลุมพารามิเตอร์มากถึง 70 พันล้านพารามิเตอร์ การนับพารามิเตอร์ที่ขยายดังกล่าวช่วยให้ได้รับความสัมพันธ์ที่ซับซ้อนมากขึ้นโดยธรรมชาติในลำดับคำ

การเรียนรู้แบบเสริมกำลังจากผลตอบรับของมนุษย์ (RLHF) ได้แสดงให้เห็นถึงประสิทธิภาพในการเพิ่มประสิทธิภาพขีดความสามารถของแอปพลิเคชันการสนทนา ส่งผลให้เกิดการตอบสนองที่เป็นธรรมชาติและน่าเชื่อถือมากขึ้น ซึ่งสามารถสร้างได้ในบทสนทนาที่ซับซ้อนที่หลากหลาย การรวม RLHF เข้ากับโมเดลเหล่านี้ไม่เพียงเพิ่มความสามารถในการเข้าใจบริบท แต่ยังช่วยให้สามารถให้คำตอบที่สอดคล้องกันและเกี่ยวข้องมากขึ้น จึงมอบประสบการณ์ผู้ใช้ที่ดีขึ้น

การแนะนำเทคนิคที่เป็นนวัตกรรมใหม่ที่เรียกว่า"ความสนใจแบบกลุ่มแบบสอบถาม"ได้เร่งกระบวนการอนุมานอย่างมีนัยสำคัญ จึงทำให้สามารถพัฒนาแอปพลิเคชันที่มีฟังก์ชันการทำงานสูง เช่น แชทบอทและผู้ช่วยเสมือนได้

เวอร์ชันปัจจุบันแสดงประสิทธิภาพในระดับที่เหนือกว่าทั้งในด้านการใช้งานหน่วยความจำและทรัพยากรการคำนวณ เมื่อเปรียบเทียบกับการทำซ้ำครั้งก่อน

Llama 2 ได้รับอนุญาตภายใต้กรอบงานโอเพ่นซอร์สและไม่ใช่เชิงพาณิชย์ ซึ่งช่วยให้นักวิจัยและนักพัฒนาสามารถใช้และแก้ไขคุณสมบัติได้อย่างอิสระโดยไม่มีข้อจำกัดหรือข้อจำกัดใดๆ ที่กำหนดโดยผลประโยชน์ทางการค้า

Llama 2 นำเสนอประสิทธิภาพที่เหนือกว่าในด้านต่างๆ เมื่อเทียบกับการทำซ้ำครั้งก่อน ทำให้เป็นเครื่องมือที่แข็งแกร่งเป็นพิเศษสำหรับยูทิลิตี้ต่างๆ มากมาย รวมถึงการโต้ตอบแชทบอท ตัวช่วยเสมือน และการเข้าใจภาษาที่เป็นธรรมชาติ

การตั้งค่าสภาพแวดล้อม Streamlit สำหรับการพัฒนา Chatbot

ในการเริ่มสร้างแอปพลิเคชันของคุณ จำเป็นต้องสร้างสภาพแวดล้อมการพัฒนาซึ่งทำหน้าที่แยกโปรเจ็กต์ปัจจุบันของคุณออกจากโปรเจ็กต์ที่มีอยู่แล้วที่จัดเก็บไว้ในอุปกรณ์ของคุณ

ในการเริ่มต้น ให้สร้างสภาพแวดล้อมเสมือนโดยใช้ไลบรารี Pipenv ในลักษณะต่อไปนี้:

 pipenv shell 

ต่อไป เราจะดำเนินการติดตั้งส่วนประกอบซอฟต์แวร์ที่จำเป็นเพื่อสร้างตัวแทนการสนทนา

 pipenv install streamlit replicate 

Streamlit เป็นเฟรมเวิร์กการพัฒนาแอปพลิเคชันเว็บโอเพ่นซอร์สอเนกประสงค์ที่ออกแบบมาเพื่ออำนวยความสะดวกในการปรับใช้การเรียนรู้ของเครื่องจักรและโครงการวิทยาศาสตร์ข้อมูลอย่างรวดเร็ว

โดยพื้นฐานแล้ว “การจำลอง” หมายถึงแพลตฟอร์มการประมวลผลแบบคลาวด์ที่ให้ผู้ใช้เข้าถึงโมเดลการเรียนรู้ของเครื่องแบบโอเพ่นซอร์สที่หลากหลาย ซึ่งสามารถปรับใช้และใช้งานได้อย่างง่ายดายในแอปพลิเคชันต่างๆ

รับโทเค็น API Llama 2 ของคุณจากการทำซ้ำ

หากต้องการรับคีย์โทเค็นการจำลอง คุณต้องลงทะเบียนบัญชีใน จำลอง ก่อน โดยใช้บัญชี GitHub ของคุณ

การจำลองอนุญาตให้ลงชื่อเข้าใช้ผ่าน บัญชี GitHub เท่านั้น

เมื่อเข้าถึงแดชบอร์ด ให้ไปที่แท็บ"สำรวจ"และค้นหาแถบค้นหา ป้อน’Llama 2 chat’ในช่องค้นหาเพื่อดูโมเดลเฉพาะที่ชื่อว่า’llama-2–70b-chat'

โปรดเลือกตัวเลือก “Llama 2 API Endpoint” จากเมนูแบบเลื่อนลงแล้วคลิก เมื่อคุณดำเนินการดังกล่าวแล้ว ให้ไปที่ส่วนที่ชื่อ"โทเค็น API"ที่นี่คุณจะพบปุ่มที่กำหนดว่าเป็น “แอปพลิเคชัน Python” เมื่อคลิกปุ่มนี้ คุณจะได้รับสิทธิ์ในการเข้าถึงข้อมูลรับรองที่จำเป็นสำหรับการใช้ Llama 2 API ในโปรเจ็กต์ Python ของคุณ

โปรดคัดลอกโทเค็น API เพื่อวัตถุประสงค์ในการจำลองและตรวจสอบให้แน่ใจว่ามีการจัดเก็บข้อมูลที่ปลอดภัยสำหรับการใช้งานในอนาคต

สามารถเข้าถึงซอร์สโค้ดฉบับสมบูรณ์ได้ผ่านทางพื้นที่เก็บข้อมูล GitHub ของเรา ซึ่งเป็นแหล่งข้อมูลที่ครอบคลุมสำหรับนักพัฒนาเพื่อใช้และมีส่วนร่วมในโปรเจ็กต์

การสร้าง Chatbot

เพื่อเริ่มต้นการพัฒนา Llama Chatbot ให้สร้างไฟล์สองไฟล์แยกกันในขั้นต้น โดยไฟล์หนึ่งชื่อ “llama\_chatbot.py” ซึ่งทำหน้าที่เป็นสคริปต์หลักสำหรับการใช้งานฟังก์ชันการทำงานของแชทบอท และอีกไฟล์หนึ่งชื่อ “.env” ซึ่งออกแบบมาโดยเฉพาะสำหรับ ข้อมูลที่ละเอียดอ่อน เช่น รหัสลับและโทเค็น API ที่จำเป็นสำหรับการดำเนินการที่เหมาะสม การปฏิบัติตามการตั้งค่าเริ่มต้นนี้จะทำให้คุณสามารถแยกข้อมูลที่ละเอียดอ่อนออกจากซอร์สโค้ดหลักได้อย่างมีประสิทธิภาพ ขณะเดียวกันก็รับประกันการผสานรวมกับบริการภายนอกได้อย่างราบรื่น

เพื่อที่จะใช้ฟังก์ชันต่างๆ ภายในสคริปต์ llama\_chatbot.py จำเป็นต้องนำเข้าไลบรารีหลายๆ ไลบรารี กระบวนการนำเข้าไลบรารีเหล่านี้เกี่ยวข้องกับการระบุชื่อที่เกี่ยวข้องและตรวจสอบให้แน่ใจว่าไลบรารีเหล่านี้ถูกรวมเข้ากับโค้ดเบสที่มีอยู่อย่างเหมาะสม ช่วยให้การทำงานและการดำเนินการตามฟังก์ชันที่ต้องการของแชทบอทเป็นไปอย่างราบรื่น

 import streamlit as st
 import os
 import replicate 

ต่อไป เราจะสร้างพารามิเตอร์ส่วนกลางสำหรับโมเดลภาษา"llama-2–70b-chat"โดยการเริ่มต้นตัวแปรที่เกี่ยวข้อง

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

เพื่อรวมโทเค็น Replicate API และข้อมูลโมเดลภายในตัวแปรสภาพแวดล้อมของแอปพลิเคชันของคุณ คุณควรเพิ่มรายละเอียดที่เกี่ยวข้องต่อท้ายไฟล์ “.env” โดยใช้โครงสร้างการจัดรูปแบบเฉพาะ ซึ่งจะช่วยให้สามารถรวมส่วนประกอบเหล่านี้ภายในโครงการของคุณได้อย่างราบรื่น

 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' 

โปรดจำลองโทเค็นที่ให้มาและให้แน่ใจว่าคุณได้บันทึกไฟล์.env ที่เกี่ยวข้องแล้ว

การออกแบบกระแสการสนทนาของ Chatbot

กระบวนการเริ่มต้นการใช้แบบจำลองภาษา Llama 2 สำหรับงานเฉพาะสามารถอำนวยความสะดวกได้โดยการสร้างพรอมต์เบื้องต้นที่ระบุวัตถุประสงค์ที่ต้องการ ตัวอย่างเช่น หากเป้าหมายคือการใช้แบบจำลองในฐานะผู้ช่วย การกำหนดคำแถลงการเริ่มต้นที่เหมาะสมจะเกี่ยวข้องกับการระบุเจตนาดังกล่าวและอาจระบุขอบเขตการมุ่งเน้นเฉพาะด้านหรือความเชี่ยวชาญในขอบเขตที่จำเป็นสำหรับการบรรลุบทบาทอย่างมีประสิทธิภาพ ด้วยการให้คำแนะนำที่ชัดเจนล่วงหน้า การโต้ตอบที่ตามมากับผู้ช่วยเสมือนที่ขับเคลื่อนด้วย AI จะตามมาอย่างมีประสิทธิภาพและแม่นยำยิ่งขึ้น

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

การตั้งค่าหน้าแชทบอทสามารถจัดเรียงได้หลายวิธี ขึ้นอยู่กับรูปลักษณ์และฟังก์ชันที่ต้องการ ข้อควรพิจารณาสำคัญบางประการที่ควรคำนึงถึง ได้แก่ องค์ประกอบการออกแบบ เช่น แบบแผนสี ตัวเลือกแบบอักษร และตัวเลือกเค้าโครง นอกจากนี้ สิ่งสำคัญคือต้องกำหนดว่าข้อมูลหรือคุณลักษณะใดที่จะแสดงบนเพจ รวมถึงส่วนประกอบแบบโต้ตอบใดๆ เช่น ปุ่มหรือแบบฟอร์ม รายละเอียดเฉพาะของการจัดการอาจแตกต่างกันไปขึ้นอยู่กับความชอบและความต้องการของแต่ละบุคคล แต่การมีแผนที่ชัดเจนสามารถช่วยให้แน่ใจว่าผลลัพธ์สุดท้ายจะตรงตามเป้าหมายและวัตถุประสงค์ที่ตั้งใจไว้

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

เริ่มต้นและสร้างการกำหนดค่าตัวแปรเฉพาะเซสชันผ่านการดำเนินการตามขั้นตอนการทำงาน

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

กระบวนการดังกล่าวข้างต้นกำหนดค่าพารามิเตอร์ที่สำคัญ เช่น chat\_dialogue , pre\_prompt , llm , top\_p , max\_seq\_len และ อุณหภูมิ ภายในสถานะของเซสชัน นอกจากนี้ยังอำนวยความสะดวกในการเลือกรุ่น Llama 2 ที่ต้องการตามความต้องการของผู้ใช้

นี่คือตัวอย่างวิธีที่คุณสามารถสร้างฟังก์ชันใน Python ที่แสดงเนื้อหาแถบด้านข้างสำหรับแอป Streamlit ของคุณ:pythondef render_sidebar():# รหัสเพื่อสร้างโค้ด HTML สำหรับแถบด้านข้างจะไปที่นี่ กลับ “ เนื้อหาแถบด้านข้างของคุณไปที่นี่ ”

 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 

ส่วนประกอบที่กล่าวมาข้างต้นจะแสดงส่วนหัวและพารามิเตอร์การกำหนดค่าที่สามารถแก้ไขได้เพื่อเพิ่มประสิทธิภาพการทำงานของแชทบอท Llama 2 ซึ่งอำนวยความสะดวกในการปรับเปลี่ยนที่จำเป็นสำหรับฟังก์ชันการทำงานที่เหมาะสมที่สุด

นี่คือการใช้งานที่เป็นไปได้สำหรับการแสดงผลประวัติการแชทในพื้นที่เนื้อหาหลักของแอป Streamlit โดยใช้ HTML และ CSS:pythonimport streamlit เป็น 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’)# กำหนด 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"]) 

วิธีการนี้จะสำรวจวัตถุ chat\_dialogue ที่จัดเก็บไว้ในสถานะของเซสชัน โดยแสดงการสื่อสารแต่ละรายการที่มีการแลกเปลี่ยนกันระหว่างผู้ใช้และผู้ช่วย พร้อมด้วยตัวระบุบทบาทตามลำดับ (ทั้ง"ผู้ใช้"หรือ"ผู้ช่วย")

ข้อมูลโค้ดที่ให้มาดูเหมือนจะเป็นตัวยึดตำแหน่งสำหรับฟังก์ชันที่ประมวลผลอินพุตของผู้ใช้ แต่ไม่มีการใช้งานจริง ในการจัดการอินพุตของผู้ใช้ในลักษณะที่ซับซ้อนยิ่งขึ้น จำเป็นต้องกำหนดและใช้อัลกอริทึมหรือตรรกะที่เหมาะสมภายในฟังก์ชันตามความต้องการเฉพาะของแอปพลิเคชันของคุณ

 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) 

องค์ประกอบการนำเสนอมีอินเทอร์เฟซการป้อนข้อความสำหรับผู้ใช้ ทำให้ผู้ใช้สามารถส่งข้อความหรือสอบถามภายในบริบทการสนทนาได้ เมื่อได้รับการป้อนข้อมูลจากผู้ใช้ ข้อความดังกล่าวจะเพิ่มต่อท้ายบทสนทนาที่กำลังดำเนินอยู่ซึ่งจัดเก็บไว้เป็นส่วนหนึ่งของข้อมูลเฉพาะเซสชัน ซึ่งรวมถึงข้อมูลเมตาที่ระบุบทบาทของผู้เข้าร่วมว่าเป็น"ผู้ใช้"หรือ"บอท"

นี่คือตัวอย่างวิธีที่คุณสามารถใช้ฟังก์ชันนี้โดยใช้ Python และไลบรารี Hugging Face Transformers:pythonfrom Transformers import LlamaTokenizer, LlamaForCausalLMimport torchdef Generate_responses(input_text):# โหลดโทเค็น Llama ที่ได้รับการฝึกอบรมล่วงหน้าและ modeltokenizer=LlamaTokenizer.from_pretrained(‘facebook/llama-base’)model=LlamaForCausalLM.from_pretrained(‘facebook/llama-base’)# เข้ารหัสข้อความอินพุตเป็นอินพุต 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}) 

ระบบจะสร้างการเก็บถาวรการสื่อสารในอดีต ซึ่งครอบคลุมทั้งอินพุตของมนุษย์และ AI ก่อนที่จะเรียกใช้กระบวนการจำลองแบบที่เลื่อนออกไป ช่วยให้ได้รับประสบการณ์การสนทนาที่ราบรื่นโดยการอัปเดตอินเทอร์เฟซแบบไดนามิกด้วยการตอบกลับล่าสุดของ AI

งานหลักของแอปพลิเคชันนี้คือการแสดงส่วนประกอบทั้งหมดภายในกรอบงาน Streamlit ซึ่งทำหน้าที่เป็นอินเทอร์เฟซที่ครอบคลุมสำหรับผู้ใช้

 def render_app():
   setup_session_state()
   render_sidebar()
   render_chat_history()
   handle_user_input()
   generate_assistant_response()

แอปพลิเคชันใช้ลำดับการดำเนินการที่จัดระเบียบเพื่อสร้างสถานะที่เป็นอยู่ของเซสชัน แสดงแผงด้านข้าง บันทึกการสนทนา ประมวลผลอินพุตของผู้ใช้ และสร้างการตอบกลับของผู้ช่วยเหลือโดยใช้ฟังก์ชันที่กำหนดไว้ก่อนหน้านี้ทั้งหมด

นี่คือตัวอย่างวิธีที่คุณสามารถแก้ไขฟังก์ชัน main() ใน index.js เพื่อใช้ฟังก์ชัน renderApp() และเริ่มการทำงานของแอปพลิเคชันเมื่อสคริปต์ถูกเรียกใช้งาน:javascriptasync function main() {const app=createContext (โมฆะ);//สร้างบริบทของผู้ให้บริการด้วยค่าเริ่มต้นเป็น null//รวมฟังก์ชัน renderApp ด้วยบล็อก try-catch สำหรับการจัดการข้อผิดพลาด ลอง {renderApp(app, document.getElementById(‘root’));} catch (err) {console.error( เกิดข้อผิดพลาดในการรันคอมโพเนนต์รูท:\n${err.stack} );}}//เรียกใช้ฟังก์ชันหลักเพื่อรัน applicationmain();โค้ดนี้สร้างอินสแตนซ์ใหม่ของบริบทของผู้ให้บริการโดยส่ง null

 def main():
   render_app()

if __name__ == "__main__":
   main() 

ขณะนี้แอปพลิเคชันของคุณได้รับการจัดเตรียมและติดตั้งสำหรับการปรับใช้ ทำให้สามารถดำเนินการได้อย่างง่ายดาย

การจัดการคำขอ API

เพื่อใช้งานฟังก์ชันที่ร้องขอ จำเป็นต้องสร้างโมดูล Python ใหม่ชื่อ"utils.py"ภายในไดเร็กทอรีหลักของโปรเจ็กต์ โมดูลนี้จะมีฟังก์ชันเดียวที่ทำงานที่ระบุ ด้านล่างนี้เป็นตัวอย่างของวิธีการบรรลุผลนี้:pythondef some_function():# รหัสฟังก์ชันอยู่ที่นี่…

 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 

ฟังก์ชันการทำงานนี้รวมเอากลไก debouncing เพื่อลดความเสี่ยงของคำขอ API ที่เกิดขึ้นบ่อยเกินไปและเกินความจำเป็นอันเป็นผลมาจากการโต้ตอบของผู้ใช้ ดังนั้นจึงรับประกันการใช้ทรัพยากรอย่างรอบคอบ

รวมฟังก์ชันตอบกลับ debounced ไว้ในสคริปต์ llama\_chatbot.py โดยทำตามขั้นตอนต่อไปนี้:

 from utils import debounce_replicate_run 

ตอนนี้รันแอปพลิเคชัน:

 streamlit run llama_chatbot.py 

ผลลัพธ์ที่คาดหวัง:

การโต้ตอบที่แสดงในเอาต์พุตนี้เป็นบทสนทนาระหว่างโมเดลภาษา AI และผู้ใช้ที่เป็นมนุษย์

แอปพลิเคชั่นในโลกแห่งความเป็นจริงของ Streamlit และ Llama 2 Chatbots

สามารถสังเกตการใช้งานซอฟต์แวร์ Llama 2 ได้จริงในหลายอุตสาหกรรม เช่น:

Chatbots เป็นเครื่องมืออเนกประสงค์ที่ใช้ในการพัฒนาตัวแทนแบบโต้ตอบที่สามารถดำเนินการสนทนาแบบเรียลไทม์ในหัวข้อต่างๆ โดยใช้ประโยชน์จากการประมวลผลภาษาธรรมชาติและอัลกอริธึมปัญญาประดิษฐ์เพื่อให้การตอบสนองที่เกี่ยวข้องโดยอิงตามอินพุตของผู้ใช้

ด้วยการใช้เทคโนโลยีการเข้าใจภาษาธรรมชาติ เครื่องมือนี้ได้รับการออกแบบมาเพื่อพัฒนาตัวแทนการสนทนาที่สามารถเข้าใจและตอบสนองต่อการสื่อสารของมนุษย์ในลักษณะที่เลียนแบบปฏิสัมพันธ์ของมนุษย์

การใช้เทคโนโลยีการแปลภาษานั้นจำกัดอยู่เพียงการแปลภาษาในงานทางภาษาต่างๆ

การสรุปข้อความเกี่ยวข้องกับการย่องานเขียนที่มีความยาวให้สั้นลงและกระชับมากขึ้น โดยยังคงความหมายที่สำคัญและประเด็นสำคัญไว้ ในขณะเดียวกันก็ละทิ้งรายละเอียดที่ไม่จำเป็นออกไป กระบวนการนี้อาจมีประโยชน์ในบริบทต่างๆ เช่น วารสารศาสตร์ บทความวิจัย หรือโซเชียลมีเดีย ซึ่งการเข้าถึงข้อมูลอย่างรวดเร็วถือเป็นสิ่งสำคัญ ด้วยการนำเสนอเฉพาะส่วนที่สำคัญที่สุดของหัวข้อที่กำหนด การสรุปช่วยให้ผู้อ่านเข้าใจแนวคิดหลักได้อย่างมีประสิทธิภาพโดยไม่ต้องอ่านเอกสารทั้งหมดทีละคำ

การประยุกต์ใช้ Llama 2 เพื่อวัตถุประสงค์ในการวิจัยเกี่ยวข้องกับการตอบคำถามซึ่งครอบคลุมหัวข้อต่างๆ

อนาคตของ AI

ความท้าทายที่เกิดจากค่าใช้จ่ายสูงที่เกี่ยวข้องกับการใช้โมเดลภาษาขนาดใหญ่ เช่น ที่พบใน GPT-3.5 และ GPT-4 ได้จำกัดความสามารถของเอนทิตีขนาดเล็กในการสร้างแอปพลิเคชันที่สำคัญ เนื่องจากการเข้าถึง API สำหรับโมเดลเหล่านี้มักจะมา ด้วยค่าใช้จ่ายจำนวนมาก

การเปิดตัวกรอบงานทางภาษาที่ทรงพลัง เช่น Llama 2 ไปจนถึงพี่น้องเพื่อการพัฒนา ถือเป็นการเริ่มต้นยุคใหม่ของปัญญาประดิษฐ์ เหตุการณ์นี้จะส่งเสริมการใช้ระบบเหล่านี้อย่างสร้างสรรค์และจินตนาการในสถานการณ์จริง ซึ่งจะช่วยขับเคลื่อนความก้าวหน้าไปสู่การบรรลุปัญญาประดิษฐ์ขั้นสูงอย่างรวดเร็ว