Prompt engineering
วิศวกรรมพรอมป์ต์ตั้งแต่พื้นฐานถึงขั้นสูงด้วย LangChain ใน Python

ประเด็นสำคัญLangChain กำหนดมาตรฐานการผสานรวม LLM ด้วยโครงสร้างแบบโมดูลาร์ของเชน เอเจนต์…
ดูเพิ่มเติม
- LangChain กำหนดมาตรฐานการผสานรวม LLM ด้วยโครงสร้างแบบโมดูลาร์ของเชน เอเจนต์ และหน่วยความจำ
- การออกแบบพรอมต์ขั้นสูงด้วย LangChain ใช้เทมเพลตที่มีโครงสร้างและรูปแบบอย่าง ReAct เพื่อชี้นำการให้เหตุผลของโมเดล
- LangChain ก้าวข้ามข้อจำกัดของ LLM โดยการเชื่อมต่อโมเดลกับเครื่องมือภายนอกและแหล่งข้อมูลผ่านเอเจนต์
ด้านหนึ่งของโมเดลภาษาขนาดใหญ่ (LLMs) คือจำนวนพารามิเตอร์ที่โมเดลเหล่านี้ใช้ในการเรียนรู้ โมเดลที่มีพารามิเตอร์มากขึ้นสามารถเข้าใจความสัมพันธ์ระหว่างคำและวลีได้ดีขึ้น ซึ่งหมายความว่าโมเดลที่มีพารามิเตอร์หลายพันล้านสามารถสร้างรูปแบบข้อความที่หลากหลายและตอบคำถามที่เปิดกว้างและท้าทายได้อย่างมีรายละเอียด
โมเดล LLMs เช่น ChatGPT ซึ่งใช้โมเดล Transformer มีความสามารถในการเข้าใจและสร้างภาษามนุษย์ ทำให้พวกมันใช้ได้กับแอปพลิเคชันที่ต้องการความเข้าใจภาษาธรรมชาติ อย่างไรก็ตาม พวกมันก็มีข้อจำกัด เช่น ความรู้ที่ล้าสมัย การไม่สามารถโต้ตอบกับระบบภายนอกได้ การขาดความเข้าใจบริบท และการสร้างคำตอบที่ฟังดูสมเหตุสมผลแต่ไม่ถูกต้องหรือไม่มีความหมาย
การแก้ไขข้อจำกัดเหล่านี้ต้องอาศัยการผสมผสาน LLMs กับแหล่งข้อมูลและความสามารถภายนอก ซึ่งอาจมีความซับซ้อนและต้องการทักษะการเขียนโค้ดและจัดการข้อมูลอย่างมาก นอกจากนี้ การเข้าใจแนวคิด AI และอัลกอริทึมที่ซับซ้อนยังช่วยเพิ่มความชันของการเรียนรู้ที่จำเป็นต่อการพัฒนาแอปพลิเคชันโดยใช้ LLMs
อย่างไรก็ตาม การผสมผสาน LLMs กับเครื่องมืออื่น ๆ เพื่อสร้างแอปพลิเคชันที่ใช้ LLMs อาจเปลี่ยนแปลงภูมิทัศน์ดิจิทัลของเราได้ แอปพลิเคชันเหล่านี้มีศักยภาพที่จะปรับปรุงประสิทธิภาพและผลผลิต ลดความซับซ้อนของงาน ปรับปรุงการตัดสินใจ และให้ประสบการณ์ที่เป็นส่วนตัว
ในบทความนี้ เราจะสำรวจประเด็นเหล่านี้อย่างลึกซึ้ง โดยการสำรวจเทคนิคขั้นสูงของวิศวกรรมพรอมป์ต์ด้วย LangChain โดยให้คำอธิบายที่ชัดเจน ตัวอย่างเชิงปฏิบัติ และคำแนะนำทีละขั้นตอนเกี่ยวกับวิธีการนำไปใช้
Langchain เป็นไลบรารีที่ทันสมัย ซึ่งนำความสะดวกและความยืดหยุ่นมาให้กับการออกแบบ การใช้งาน และการปรับแต่งพรอมป์ต์ เมื่อเราทำความเข้าใจหลักการและแนวทางปฏิบัติของการออกแบบพรอมป์ต์ คุณจะเรียนรู้วิธีการใช้คุณสมบัติที่ทรงพลังของ Langchain เพื่อใช้ประโยชน์จากโมเดล Generative AI ชั้นนำ เช่น GPT-4
การเข้าใจพรอมป์ต์
ก่อนที่จะดำดิ่งลงสู่รายละเอียดทางเทคนิคของการออกแบบพรอมป์ต์ มันเป็นสิ่งสำคัญที่จะต้องเข้าใจแนวคิดของพรอมป์ต์และความสำคัญของมัน
พรอมป์ต์คือลำดับของโทเค็นที่ใช้เป็นข้อมูลเข้าสำหรับโมเดลภาษา โดยสั่งให้สร้างคำตอบในลักษณะเฉพาะ พรอมป์ต์มีบทบาทสำคัญในการกำหนดพฤติกรรมของโมเดล พวกมันสามารถส่งผลต่อคุณภาพของข้อความที่สร้างขึ้น และเมื่อสร้างขึ้นอย่างถูกต้อง สามารถช่วยให้โมเดลให้ผลลัพธ์ที่แม่นยำและเฉพาะเจาะจงได้
การออกแบบพรอมป์ต์คือศิลปะและวิทยาศาสตร์ของการสร้างพรอมป์ต์ที่มีประสิทธิภาพ เป้าหมายคือการดึงผลลัพธ์ที่ต้องการออกจากโมเดลภาษา โดยการเลือกและจัดโครงสร้างพรอมป์ต์อย่างระมัดระวัง สามารถชี้นำโมเดลให้สร้างคำตอบที่แม่นยำและเกี่ยวข้องมากขึ้น ในทางปฏิบัติ สิ่งนี้เกี่ยวข้องกับการปรับถ้อยคำอินพุตให้เหมาะสมกับอคติในการฝึกอบรมและโครงสร้างของโมเดล
ความซับซ้อนของการออกแบบพรอมป์ต์อาจเป็นเทคนิคที่ง่าย เช่น การให้คำสำคัญที่เกี่ยวข้องแก่โมเดล ไปจนถึงวิธีการที่ซับซ้อนกว่า เช่น การออกแบบพรอมป์ต์ที่ซับซ้อนซึ่งใช้กลไกภายในของโมเดลให้เป็นประโยชน์
Langchain: เครื่องมือพรอมป์ต์ที่เติบโตเร็วที่สุด
LangChain ซึ่งเปิดตัวในเดือนตุลาคม 2022 โดย Harrison Chase ได้กลายเป็นหนึ่งในเฟรมเวิร์กโอเพ่นซอร์สที่ได้รับการจัดอันดับสูงสุดบน GitHub ในปี 2023 มันให้อินเทอร์เฟซที่เรียบง่ายและมาตรฐานสำหรับการรวมโมเดลภาษาขนาดใหญ่ (LLMs) เข้ากับแอปพลิเคชัน นอกจากนี้ยังมีอินเทอร์เฟซที่มีคุณสมบัติสำหรับการออกแบบพรอมป์ต์ ช่วยให้นักพัฒนาสามารถทดลองกับกลยุทธ์ต่างๆ และประเมินผลลัพธ์ได้ โดยการใช้ Langchain คุณสามารถทำงานการออกแบบพรอมป์ต์ได้อย่างมีประสิทธิภาพและเป็นธรรมชาติมากขึ้น
LangFlow ทำหน้าที่เป็นอินเทอร์เฟซผู้ใช้สำหรับการจัดเรียงองค์ประกอบของ LangChain เป็นแผนภาพที่สามารถดำเนินการได้ ทำให้สามารถสร้างต้นแบบและทดลองได้อย่างรวดเร็ว

LangChain ช่วยเติมช่องว่างที่สำคัญในการพัฒนา AI สำหรับคนจำนวนมาก มันทำให้สามารถสร้างแอปพลิเคชัน NLP หลากหลาย เช่น ผู้ช่วยเสมือน ผู้สร้างเนื้อหา ระบบตอบคำถาม และอื่นๆ เพื่อแก้ปัญหาโลกแห่งความเป็นจริงต่างๆ
ไม่ใช่โมเดลหรือผู้ให้บริการแบบสแตนด์อโลน แต่ LangChain ทำให้การโต้ตอบกับโมเดลต่างๆ ง่ายขึ้น โดยขยายความสามารถของแอปพลิเคชันที่ใช้ LLMs ไปไกลกว่าข้อจำกัดของการเรียก API ทั่วไป
สถาปัตยกรรมของ LangChain
ส่วนประกอบหลักของ LangChain รวมถึง Model I/O, Prompt Templates, Memory, Agents และ Chains
Model I/O
LangChain ทำให้การเชื่อมต่อกับโมเดลภาษาต่างๆ ง่ายขึ้นโดยการห่อด้วยอินเทอร์เฟซมาตรฐานที่เรียกว่า Model I/O ซึ่งทำให้สามารถเปลี่ยนโมเดลได้อย่างง่ายดายเพื่อการปรับให้เหมาะสมหรือประสิทธิภาพที่ดีขึ้น LangChain รองรับโมเดลภาษาหลายๆ ผู้ให้บริการ รวมถึง OpenAI, HuggingFace, Azure, Fireworks และอื่นๆ
Prompt Templates
สิ่งเหล่านี้ใช้เพื่อจัดการและปรับให้เหมาะสมการโต้ตอบกับ LLMs โดยการให้คำแนะนำหรือตัวอย่างที่กระชับ การปรับให้เหมาะสมของพรอมป์ต์สามารถปรับปรุงประสิทธิภาพของโมเดล และความยืดหยุ่นของพวกมันช่วยให้กระบวนการรับอินพุตมีความยืดหยุ่นขึ้น
ตัวอย่างง่ายๆ ของเทมเพลตพรอมป์ต์:
from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))
เมื่อเราขยับไปสู่ความซับซ้อนที่เพิ่มขึ้น เราจะพบกับรูปแบบที่ซับซ้อนกว่าใน LangChain เช่น รูปแบบ Reason and Act (ReAct) ReAct เป็นรูปแบบที่สำคัญสำหรับการดำเนินการโดยที่ตัวแทนกำหนดงานให้กับเครื่องมือที่เหมาะสม ปรับคำสั่งให้เหมาะสม และวิเคราะห์ผลลัพธ์เพื่อให้บรรลุเป้าหมาย รูปแบบ Python ต่อไปนี้แสดงให้เห็นถึงรูปแบบ ReAct ซึ่งแสดงให้เห็นว่าพรอมป์ต์ถูกสร้างขึ้นใน LangChain โดยใช้ลำดับของความคิดและการดำเนินการเพื่อแก้ปัญหาและให้คำตอบสุดท้าย:
PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""
Memory
Memory เป็นแนวคิดที่สำคัญใน LangChain ซึ่งช่วยให้ LLMs และเครื่องมือสามารถเก็บข้อมูลได้ตลอดเวลา พฤติกรรมที่มีสถานะนี้ช่วยปรับปรุงประสิทธิภาพของแอปพลิเคชัน LangChain โดยการเก็บข้อมูลก่อนหน้า การโต้ตอบของผู้ใช้ สภาพแวดล้อม และเป้าหมายของตัวแทน กลยุทธ์ ConversationBufferMemory และ ConversationBufferWindowMemory ช่วยให้สามารถติดตามการสนทนาทั้งหมดหรือเฉพาะช่วงล่าสุดได้ตามลำดับ สำหรับแนวทางที่ซับซ้อนกว่า กลยุทธ์ ConversationKGMemory ช่วยให้สามารถเข้ารหัสการสนทนาเป็นกราฟความรู้ซึ่งสามารถส่งกลับไปยังพรอมป์ต์หรือใช้เพื่อคาดการณ์คำตอบโดยไม่ต้องเรียกใช้ LLM
Agents
ตัวแทนโต้ตอบกับโลกโดยการดำเนินการและงาน ใน LangChain ตัวแทนรวมเครื่องมือและชุดการดำเนินการเพื่อการดำเนินงาน พวกมันสามารถเชื่อมต่อกับโลกภายนอกเพื่อการค้นหาข้อมูลเพื่อเพิ่มความรู้ของ LLMs และเอาชนะข้อจำกัดที่มีอยู่ ตัวแทนสามารถเลือกที่จะส่งการคำนวณไปยังเครื่องคิดเลขหรือตัวแปล Python ขึ้นอยู่กับสถานการณ์
ตัวแทนประกอบด้วยส่วนประกอบย่อย:
- เครื่องมือ: สิ่งเหล่านี้เป็นส่วนประกอบที่ใช้การทำงาน
- ชุดเครื่องมือ: ชุดของเครื่องมือ
- ตัวดำเนินการของตัวแทน: สิ่งนี้เป็นกลไกการดำเนินการซึ่งช่วยให้สามารถเลือกเครื่องมือได้
ตัวแทนใน LangChain ยังปฏิบัติตามรูปแบบ ReAct แบบ Zero-shot ซึ่งการตัดสินใจขึ้นอยู่กับคำอธิบายเครื่องมือเท่านั้น กลไกนี้ขยายด้วยหน่วยความจำเพื่อพิจารณาประวัติการสนทนาทั้งหมดได้ ด้วย ReAct แทนที่จะให้ LLM เติมข้อความต่อ คุณสามารถให้มันตอบในวงรอบความคิด การกระทำ และการสังเกตผล
Chains
Chains หรือชุดการดำเนินการเป็นส่วนประกอบสำคัญของ LangChain ที่ช่วยให้สามารถประมวลผลข้อมูลเข้าและออกของโมเดลภาษาได้อย่างราบรื่น ชุดการดำเนินการเหล่านี้ประกอบด้วยลิงก์ ซึ่งสามารถเป็นอีกชุดการดำเนินการหรือสิ่งพื้นฐาน เช่น พรอมป์ต์ โมเดลภาษา หรือยูทิลิตี้
ลองนึกภาพชุดการดำเนินการเป็นเส้นการผลิตในโรงงาน แต่ละขั้นตอนในเส้นการผลิตนี้แสดงถึงการดำเนินการเฉพาะ เช่น การเรียกใช้โมเดลภาษา การใช้ฟังก์ชัน Python กับข้อความ หรือการให้พรอมป์ต์ในลักษณะเฉพาะ
LangChain แบ่งชุดการดำเนินการออกเป็นสามประเภท: Utility Chains, Generic Chains และ Combine Documents Chains เราจะสำรวจ Utility Chains และ Generic Chains ในการอภิปรายของเรา
- Utility Chains ได้รับการออกแบบมาเพื่อดึงคำตอบที่แม่นยำออกจากโมเดลภาษา สำหรับงานที่กำหนดไว้อย่างชัดเจน ตัวอย่างเช่น LLMMathChain ช่วยให้โมเดลภาษาสามารถดำเนินการคำนวณทางคณิตศาสตร์ได้ มันรับคำถามในภาษาธรรมชาติ และโมเดลภาษาผลิตโค้ด Python ซึ่งถูกดำเนินการเพื่อให้ได้คำตอบ
- Generic Chains ทำหน้าที่เป็นบล็อกสร้างสำหรับชุดการดำเนินการอื่นๆ แต่ไม่สามารถใช้งานได้ด้วยตนเอง ชุดการดำเนินการเหล่านี้ เช่น LLMChain เป็นชุดการดำเนินการพื้นฐานที่มักถูกใช้ร่วมกับชุดการดำเนินการอื่นๆ เพื่อทำงานที่ซับซ้อน เช่น LLMChain มักใช้สอบถามโมเดลภาษา โดยจัดรูปอินพุตตามเทมเพลตพรอมป์ต์แล้วส่งให้โมเดล
การนำการออกแบบพรอมป์ต์ไปใช้กับ Langchain
เราจะแนะนำคุณผ่านขั้นตอนการนำการออกแบบพรอมป์ต์ไปใช้กับ Langchain ก่อนที่จะเริ่ม โปรดตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งซอฟต์แวร์และแพ็คเกจที่จำเป็นแล้ว
คุณสามารถใช้เครื่องมือยอดนิยม เช่น Docker, Conda, Pip และ Poetry เพื่อตั้งค่า LangChain ไฟล์การติดตั้งที่เกี่ยวข้องสำหรับวิธีการเหล่านี้สามารถพบได้ในรีโพ LangChain ที่ https://github.com/benman1/generative_ai_with_langchain ซึ่งรวมถึง Dockerfile สำหรับ Docker, requirements.txt สำหรับ Pip, pyproject.toml สำหรับ Poetry และ langchain_ai.yml สำหรับ Conda
ในบทความนี้ เราจะใช้ Pip ซึ่งเป็นผู้จัดการแพ็คเกจมาตรฐานสำหรับ Python เพื่ออำนวยความสะดวกในการติดตั้งและจัดการไลบรารี่ของบุคคลที่สาม หากไม่ได้รวมอยู่ในกระบวนการกระจาย Python ของคุณ คุณสามารถติดตั้ง Pip ได้โดยทำตามคำแนะนำที่ https://pip.pypa.io/
ในการติดตั้งไลบรารี่โดยใช้ Pip ใช้คำสั่ง pip install library_name
อย่างไรก็ตาม Pip ไม่จัดการสภาพแวดล้อมด้วยตนเอง เพื่อจัดการสภาพแวดล้อมที่แตกต่างกัน เราใช้เครื่องมือ virtualenv
ในบทความนี้ เราจะพูดถึงการผสมผสานโมเดล
ขั้นตอนที่ 1: การตั้งค่า Langchain
ขั้นแรก คุณต้องติดตั้งแพ็คเกจ Langchain เราใช้ระบบปฏิบัติการ Windows ใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อติดตั้งมัน:
pip install langchain
ขั้นตอนที่ 2: การนำเข้า Langchain และโมดูลที่จำเป็นอื่นๆ
ต่อไป นำเข้า Langchain พร้อมกับโมดูลที่จำเป็นอื่นๆ ที่นี่ เรายังนำเข้าไลบรารี transformers ซึ่งใช้กันอย่างแพร่หลายในงาน NLP
import langchain from transformers import AutoModelWithLMHead, AutoTokenizer
ขั้นตอนที่ 3: โหลดโมเดลพรีเทรน
Open AI
OpenAI โมเดลสามารถเชื่อมต่อกับไลบรารี LangChain หรือไลบรารีไคลเอ็นต์ OpenAI Python ได้อย่างสะดวก โน้ตที่น่าสังเกตคือ OpenAI มีคลาส Embedding สำหรับโมเดลการฝังตัวข้อความ สองโมเดล LLM ที่สำคัญคือ GPT-3.5 และ GPT-4 ซึ่งแตกต่างกันหลักๆ ในความยาวของโทเค็น ราคาของแต่ละโมเดลสามารถพบได้บนเว็บไซต์ของ OpenAI ในขณะที่มีโมเดลที่ซับซ้อนกว่า เช่น GPT-4-32K ที่มีการยอมรับโทเค็นสูงกว่า แต่การเข้าถึงผ่าน API ไม่ได้รับประกันเสมอไป

การเข้าถึงโมเดลเหล่านี้ต้องใช้คีย์ API ของ OpenAI ซึ่งสามารถทำได้โดยการสร้างบัญชีบนแพลตฟอร์ม OpenAI การตั้งค่าข้อมูลการเรียกเก็บเงิน และสร้างคีย์ลับใหม่
import os os.environ["OPENAI_API_KEY"] = 'your-openai-token'
หลังจากสร้างคีย์แล้ว คุณสามารถตั้งค่ามันเป็นตัวแปรสภาพแวดล้อม (OPENAI_API_KEY) หรือส่งมันไปเป็นพารามิเตอร์ระหว่างการสร้างอินสแตนซ์คลาสสำหรับเรียก OpenAI
พิจารณาสคริปต์ LangChain เพื่อแสดงการโต้ตอบกับโมเดล OpenAI:
from langchain.llms import OpenAI llm = OpenAI(model_name="text-davinci-003") # The LLM takes a prompt as an input and outputs a completion prompt = "who is the president of the United States of America?" completion = llm(prompt)
The current President of the United States of America is Joe Biden.
ในตัวอย่างนี้ ตัวแทนถูกเริ่มต้นเพื่อดำเนินการคำนวณ ตัวแทนรับข้อมูลเข้า ซึ่งเป็นงานบวกง่ายๆ จัดการมันโดยใช้โมเดล OpenAI ที่ให้มา และส่งผลลัพธ์กลับ
Hugging
Hugging Face เป็นไลบรารี Transformers Python ที่ใช้ได้ฟรี ซึ่งเข้ากันได้กับ PyTorch, TensorFlow และ JAX และรวมการนำไปใช้ของโมเดล เช่น BERT และ T5
Hugging Face ยังให้ Hugging Face Hub ซึ่งเป็นแพลตฟอร์มสำหรับการโฮสต์รีโพซิตอรี่โค้ด โมเดลการเรียนรู้ของเครื่อง ชุดข้อมูล และเว็บแอปพลิเคชัน
ในการใช้ Hugging Face เป็นผู้ให้บริการโมเดล คุณจะต้องมีบัญชีและคีย์ API ซึ่งสามารถหาได้จากเว็บไซต์ของพวกเขา คีย์สามารถใช้ได้ในสภาพแวดล้อมของคุณเป็น HUGGINGFACEHUB_API_TOKEN
พิจารณาตัวอย่าง Python ต่อไปนี้ที่ใช้โมเดลที่เปิดเผยต่อสาธารณะที่พัฒนาโดย Google (GOOGL ) ซึ่งก็คือ Flan-T5-XXL:
from langchain.llms import HuggingFaceHub
llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)
สคริปต์นี้รับคำถามเป็นข้อมูลเข้าและส่งกลับคำตอบ โดยแสดงให้เห็นถึงความรู้และความสามารถในการทำนายของโมเดล
ขั้นตอนที่ 4: การออกแบบพรอมป์ต์ขั้นพื้นฐาน
เพื่อเริ่มต้น เราจะสร้างพรอมป์ต์ที่ง่ายๆ และดูว่าโมเดลตอบสนองอย่างไร
prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))
ในตัวอย่างโค้ดข้างต้น เราให้พรอมป์ต์เพื่อแปลข้อความภาษาอังกฤษเป็นภาษาฝรั่งเศส โมเดลภาษาจะพยายามแปลข้อความที่ให้มาโดยอาศัยพรอมป์ต์
ขั้นตอนที่ 5: การออกแบบพรอมป์ต์ขั้นสูง
ในขณะที่แนวทางข้างต้นใช้ได้ผล แต่ก็ไม่ได้ใช้ประโยชน์จากความสามารถเต็มที่ของการออกแบบพรอมป์ต์ มาทำให้ดีขึ้นโดยการแนะนำโครงสร้างพรอมป์ต์ที่ซับซ้อนกว่า
prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))
ในตัวอย่างโค้ดนี้ เราปรับเปลี่ยนพรอมป์ต์เพื่อแนะนำว่าการแปลทำโดย “นักแปลภาษาฝรั่งเศสที่มีความสามารถสูง” การเปลี่ยนแปลงพรอมป์ต์สามารถนำไปสู่การแปลที่ดีขึ้น เนื่องจากโมเดลสมมติว่าเป็นนักแปลที่มีประสบการณ์
การสร้างระบบถาม-ตอบวิชาการด้วย Langchain
เราจะสร้างระบบถาม-ตอบวิชาการโดยใช้ LangChain ซึ่งสามารถตอบคำถามเกี่ยวกับเอกสารวิชาการที่ตีพิมพ์เมื่อเร็วๆ นี้

ก่อนอื่น เพื่อตั้งค่าสภาพแวดล้อมของเรา เราต้องติดตั้งความพึ่งพาที่จำเป็น
pip install langchain arxiv openai transformers faiss-cpu
หลังจากการติดตั้งแล้ว เราสร้างโน้ตบุ๊ก Python ใหม่และนำเข้าไลบรารีที่จำเป็น:
from langchain.llms import OpenAI from langchain.chains.qa_with_sources import load_qa_with_sources_chain from langchain.docstore.document import Document import arxiv
แก่นกลางของระบบถาม-ตอบวิชาการของเราคือความสามารถในการดึงเอกสารวิชาการที่เกี่ยวข้องจากฐานข้อมูลวิชาการ arXiv โดยเฉพาะในสาขาการประมวลผลภาษาธรรมชาติ (NLP) เพื่อทำสิ่งนี้ เราจะกำหนดฟังก์ชัน get_arxiv_data(max_results=10) ฟังก์ชันนี้รวบรวมสรุปเอกสารวิชาการ NLP ล่าสุดจาก arXiv และห่อพวกมันไว้ในวัตถุเอกสาร LangChain โดยใช้สรุปเป็นเนื้อหาและ ID การเข้าถึงที่ไม่ซ้ำกันเป็นแหล่งที่มา
เราจะใช้ API arXiv เพื่อดึงเอกสารวิชาการล่าสุดที่เกี่ยวข้องกับ NLP:
def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)
documents = []
for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={"source": result.entry_id},
))
return documents
ฟังก์ชันนี้ดึงสรุปของเอกสารวิชาการ NLP ล่าสุดจาก arXiv และแปลงพวกมันให้เป็นวัตถุเอกสาร LangChain โดยใช้สรุปเป็นเนื้อหาและ URL ที่ไม่ซ้ำกันเป็นแหล่งที่มา
def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)
มาทำให้แหล่งที่มาและตั้งค่า LangChain ของเราพร้อมใช้งาน:
sources = get_arxiv_data(2) chain = load_qa_with_sources_chain(OpenAI(temperature=0))
ด้วยระบบถาม-ตอบวิชาการที่พร้อมแล้ว เราสามารถทดสอบมันโดยการถามคำถาม:
print_answer("What are the recent advancements in NLP?")
ผลลัพธ์จะเป็นคำตอบสำหรับคำถามของคุณ โดยอ้างอิงแหล่งที่มาจากที่ข้อมูลถูกดึงมา
Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1
คุณสามารถเปลี่ยนโมเดลหรือปรับระบบตามความต้องการได้ ตัวอย่างเช่น ที่นี่เรากำลังเปลี่ยนเป็น GPT-4 ซึ่งให้ผลลัพธ์ที่ดีกว่าและละเอียดมากขึ้น
sources = get_arxiv_data(2) chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))
Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm. SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1
โทเค็นใน GPT-4 สามารถสั้นได้ตั้งแต่หนึ่งตัวอักษรจนถึงหนึ่งคำ ตัวอย่างเช่น GPT-4-32K สามารถประมวลผลได้ถึง 32,000 โทเค็นในครั้งเดียว ในขณะที่ GPT-4-8K และ GPT-3.5-Turbo รองรับ 8,000 และ 4,000 โทเค็นตามลำดับ อย่างไรก็ตาม สิ่งสำคัญที่ต้องทราบคือการโต้ตอบทุกครั้งกับโมเดลเหล่านี้มีค่าใช้จ่ายที่สัมพันธ์กับจำนวนโทเค็นที่ประมวลผล ไม่ว่าจะเป็นข้อมูลเข้าหรือออก
ในบริบทของระบบถาม-ตอบวิชาการของเรา หากเอกสารวิชาการใดๆ มีขนาดใหญ่เกินขีดจำกัดโทเค็น ระบบจะล้มเหลวในการประมวลผลมันอย่างสมบูรณ์ ทำให้คุณภาพและความสมบูรณ์ของคำตอบลดลง เพื่อแก้ไขปัญหานี้ ข้อความสามารถถูกแบ่งออกเป็นส่วนเล็กๆ ที่สอดคล้องกับขีดจำกัดโทเค็น
FAISS (Facebook AI Similarity Search) (META ) ช่วยในการค้นหาส่วนข้อความที่เกี่ยวข้องมากที่สุดกับคำถามของผู้ใช้อย่างรวดเร็ว มันสร้างการแสดงผลเวกเตอร์ของแต่ละส่วนข้อความและใช้เวกเตอร์เหล่านี้เพื่อระบุและส่งคืนส่วนข้อความที่คล้ายกับเวกเตอร์แสดงถึงคำถามที่ให้มามากที่สุด
สิ่งสำคัญที่ต้องจำไว้คือ แม้ว่าจะใช้เครื่องมืออย่าง FAISS การแบ่งข้อความออกเป็นส่วนเล็กๆ เนื่องจากขีดจำกัดโทเค็นอาจทำให้สูญเสียบริบทไปบ้าง ซึ่งอาจส่งผลต่อคุณภาพของคำตอบ ดังนั้น การจัดการและการปรับให้เหมาะสมการใช้โทเค็นจึงเป็นสิ่งสำคัญเมื่อทำงานกับโมเดลภาษาขนาดใหญ่เหล่านี้
pip install faiss-cpu langchain CharacterTextSplitter
หลังจากตรวจสอบให้แน่ใจว่าไลบรารี่เหล่านี้ได้รับการติดตั้งแล้ว ให้ดำเนินการ:
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # We can now use feed more data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))
search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())
chain = load_qa_with_sources_chain(OpenAI(temperature=0))
def print_answer(question):
print(
chain(
{
"input_documents": search_index.similarity_search(question, k=4),
"question": question,
},
return_only_outputs=True,
)["output_text"]
)
ด้วยโค้ดที่สมบูรณ์แล้ว เรามีเครื่องมือที่ทรงพลังสำหรับการสืบค้นเอกสารวิชาการล่าสุดในสาขาการประมวลผลภาษาธรรมชาติ
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1
สรุป
การผสมผสานโมเดลภาษาขนาดใหญ่ (LLMs) เข้ากับแอปพลิเคชันต่างๆ ได้เร่งการนำไปใช้ในหลายโดเมน รวมถึงการแปลภาษา การวิเคราะห์ความรู้สึก และการค้นหาข้อมูล การออกแบบพรอมป์ต์เป็นเครื่องมือที่ทรงพลังในการเพิ่มประสิทธิภาพของโมเดลเหล่านี้ และ Langchain เป็นผู้นำในการทำให้การออกแบบพรอมป์ต์ง่ายขึ้น ด้วยอินเทอร์เฟซมาตรฐาน เทมเพลตพรอมป์ต์ที่ยืดหยุ่น การผสมผสานโมเดลที่แข็งแกร่ง และการใช้ตัวแทนและชุดการดำเนินการอย่างสร้างสรรค์ องค์ประกอบเหล่านี้ช่วยให้ LLM ทำงานได้อย่างมีประสิทธิภาพสูงสุด
อย่างไรก็ตาม ในการใช้ Langchain สิ่งสำคัญคือต้องเข้าใจว่าคุณภาพของผลลัพธ์ขึ้นอยู่กับการเขียนพรอมป์ต์ การทดลองกับวิธีการเขียนพรอมป์ต์ที่แตกต่างกันสามารถให้ผลลัพธ์ที่ดีขึ้น นอกจากนี้ แม้ LangChain รองรับโมเดลภาษาหลากหลาย แต่แต่ละโมเดลมีจุดแข็งและจุดอ่อน การเลือกให้เหมาะกับงานเฉพาะจึงสำคัญ สุดท้าย สิ่งสำคัญคือต้องจำไว้ว่าการใช้โมเดลเหล่านี้มาพร้อมกับการพิจารณาค่าใช้จ่าย เนื่องจากการประมวลผลโทเค็นส่งผลโดยตรงต่อค่าใช้จ่ายของการโต้ตอบ
ตามที่ได้แสดงไว้ในคำแนะนำทีละขั้นตอน Langchain สามารถเป็นพลังในการขับเคลื่อนแอปพลิเคชันที่แข็งแกร่ง เช่น ระบบถาม-ตอบวิชาการ ด้วยชุมชนผู้ใช้ที่เติบโตและความโดดเด่นที่เพิ่มขึ้นในภูมิทัศน์โอเพ่นซอร์ส Langchain มีแนวโน้มที่จะเป็นเครื่องมือสำคัญในการปลดปล่อยศักยภาพเต็มที่ของ LLMs เช่น GPT-4














