จากพื้นฐานถึงขั้นสูงด้วยการออกแบบคำสั่งพื้นฐานพร้อม Langchain ใน Python

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

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

การแก้ไขข้อจำกัดเหล่านี้ต้องอาศัยการผสมผสาน LLMs กับแหล่งข้อมูลและความสามารถภายนอก ซึ่งอาจมีความซับซ้อนและต้องการทักษะการเขียนโค้ดและจัดการข้อมูลอย่างกว้างขวาง นอกจากนี้ การเข้าใจแนวคิด AI และอัลกอริทึมที่ซับซ้อนยังช่วยเพิ่มความชันของการเรียนรู้ในการพัฒนาแอปพลิเคชันโดยใช้ LLMs

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

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

Langchain เป็นไลบรารีที่ทันสมัย ซึ่งนำความสะดวกและความยืดหยุ่นมาให้กับการออกแบบ การใช้งาน และการปรับแต่งคำสั่งพื้นฐาน เมื่อเราทำความเข้าใจหลักการและแนวทางปฏิบัติของการออกแบบคำสั่งพื้นฐาน คุณจะเรียนรู้วิธีการใช้คุณสมบัติที่ทรงพลังของ Langchain เพื่อใช้ประโยชน์จากโมเดล 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 โดยการให้คำแนะนำหรือตัวอย่างที่กระชับ การปรับให้เหมาะสมของคำสั่งพื้นฐานสามารถปรับปรุงประสิทธิภาพของโมเดล และความยืดหยุ่นของพวกมันช่วยให้การเข้าถึงข้อมูลง่ายขึ้น

ตัวอย่างง่ายๆ ของเทมเพลตคำสั่งพื้นฐาน:

<p>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"))</p>

เมื่อเราขยับไปสู่ความซับซ้อนที่เพิ่มขึ้น เราจะพบกับรูปแบบที่ซับซ้อนกว่าใน 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 ซึ่งการตัดสินใจขึ้นอยู่กับคำอธิบายเครื่องมือเท่านั้น กลไกนี้สามารถขยายได้ด้วยความจำเพื่อพิจารณาเรื่องราวการสนทนาเต็มรูปแบบ

Chains

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

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

LangChain แบ่งชุดการดำเนินการออกเป็นสามประเภท: Utility Chains, Generic Chains และ Combine Documents Chains เราจะสำรวจ Utility Chains และ Generic Chains ในการอภิปรายของเรา

• Utility Chains ได้รับการออกแบบมาเพื่อดึงคำตอบที่แม่นยำออกจากโมเดลภาษา สำหรับงานที่กำหนดไว้อย่างชัดเจน ตัวอย่างเช่น LLMMathChain ช่วยให้โมเดลภาษาสามารถดำเนินการคำนวณทางคณิตศาสตร์ได้ มันรับคำถามในภาษาธรรมชาติ และโมเดลภาษาผลิตโค้ด Python ซึ่งถูกดำเนินการเพื่อให้ได้คำตอบ
• Generic Chains ทำหน้าที่เป็นบล็อกสร้างสำหรับชุดการดำเนินการอื่นๆ แต่ไม่สามารถใช้งานได้ด้วยตนเอง ชุดการดำเนินการเหล่านี้ เช่น 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

<p>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 การตั้งค่าข้อมูลการเรียกเก็บเงิน และสร้างคีย์หลักใหม่

<p>import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'</p>

หลังจากสร้างคีย์แล้ว คุณสามารถตั้งค่ามันเป็นตัวแปรสภาพแวดล้อม (OPENAI_API_KEY) หรือส่งมันไปเป็นพารามิเตอร์ระหว่างการสร้างคลาสสำหรับการเรียก OpenAI

พิจารณาสคริปต์ LangChain เพื่อแสดงการโต้ตอบกับโมเดล OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM รับคำสั่งพื้นฐานเป็นข้อมูลเข้าและผลิตการเติมเต็ม
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

<p>ปัจจุบันประธานาธิบดีสหรัฐอเมริกาคือ Joe Biden.</p>

ในตัวอย่างนี้ ตัวแทนถูกเริ่มต้นเพื่อดำเนินการคำนวณ ตัวแทนรับข้อมูลเข้า ซึ่งเป็นงานบวกง่ายๆ จัดการมันโดยใช้โมเดล 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

<p>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)</p>

สคริปต์นี้รับคำถามเป็นข้อมูลเข้าและส่งกลับคำตอบ โดยแสดงให้เห็นถึงความรู้และความสามารถในการทำนายของโมเดล

ขั้นตอนที่ 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')

<p>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')

<p>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:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)</p>

documents = []

<p>for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={"source": result.entry_id},
))</p>

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

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

<p>ความก้าวหน้าล่าสุดใน NLP รวมถึงโมเดลที่เพิ่มความสามารถในการปฏิบัติงานตามคำสั่งและโมเดลที่ใช้กราฟความรู้เพื่อการประมวลผลภาษา
แหล่งที่มา: 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))

<p>ความก้าวหน้าล่าสุดใน NLP รวมถึงการพัฒนาโมเดลที่เพิ่มความสามารถในการปฏิบัติงานตามคำสั่งและโมเดลที่ใช้กราฟความรู้สำหรับการประมวลผลภาษา
แหล่งที่มา: 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) # เราสามารถใช้ข้อมูลได้มากขึ้น
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))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(question):
print(
chain(
{
"input_documents": search_index.similarity_search(question, k=4),
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

ด้วยโค้ดที่สมบูรณ์แล้ว เรามีเครื่องมือที่ทรงพลังสำหรับการสืบค้นเอกสารวิชาการล่าสุดในสาขาวิชาการภาษาธรรมชาติ

ความก้าวหน้าล่าสุดใน NLP รวมถึงการใช้เครือข่ายประสาทเทียมลึก (DNNs) สำหรับการวิเคราะห์ข้อความอัตโนมัติและงาน NLP เช่น การตรวจสอบการสะกด การตรวจสอบภาษา การดึงข้อมูลหน่วย และอื่นๆ
แหล่งที่มา: 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 เป็นผู้นำในการทำให้การออกแบบคำสั่งพื้นฐานง่ายขึ้น ด้วยอินเทอร์เฟซมาตรฐาน เทมเพลตคำสั่งพื้นฐานที่ยืดหยุ่น การผสมผสานโมเดลที่แข็งแกร่ง และการใช้ตัวแทนและชุดการดำเนินการอย่างสร้างสรรค์ Langchain รับประกันว่าจะเป็นเครื่องมือสำคัญในการปลดปล่อยศักยภาพเต็มที่ของ LLMs เช่น GPT-4

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

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