จุดประกายปฏิวัติ AI - การเดินทางร่วมกับ RAG และ LangChain

บทความนี้จะพาผู้อ่านไปสำรวจเจาะลึกเกี่ยวกับเส้นทางการปฏิวัติ AI โดยเจาะลึกแนวคิดการปฏิวัติของ Retrieval-Augmented Generation (RAG) และ LangChain

ในยุคของปัญญาประดิษฐ์ (AI) การดึงความรู้ที่มีความหมายจากชุดข้อมูลจำนวนมหาศาลกลายเป็นสิ่งสำคัญสำหรับภาคธุรกิจและผู้ใช้ทั่วไป เข้าสู่ยุคแห่ง Retrieval-Augmented Generation (RAG) ซึ่งเป็นความก้าวหน้าที่เพิ่มขีดความสามารถของ AI ทำให้ระบบไม่เพียงแต่สร้างข้อความที่เหมือนมนุษย์คิดเท่านั้น แต่ยังดึงข้อมูลที่เกี่ยวข้องแบบเรียลไทม์อีกด้วย การผสมผสานนี้สร้างคำตอบที่มีทั้งบริบทมากมายและเนื้อหาที่แม่นยำ

ในขณะที่เราออกเดินทางสู่การเดินทางอันน่าตื่นเต้นผ่านมหาสมุทรแสนกว้างใหญ่ของปัญญาประดิษฐ์ (AI) เราก็จำเป็นต้องเข้าใจสามเสาหลักที่จะเป็นดาวนำทางให้เราก่อน ได้แก่ Generative AI, Large Language Model (LLM), LangChain, Hugging Face และแอปพลิเคชันที่มีประโยชน์บน RAG (Retriever-Augmented Generation) นี้

Large Language Model และ Generative AI: ตัวขับเคลื่อนแห่งนวัตกรรม

หัวใจสำคัญในการเดินทางของเราคือ Large Language Model (LLM) และ Generative AI ซึ่งเป็นสองตัวขับเคลื่อนอันทรงพลังที่ผลักดันเรือแห่งนวัตกรรมให้แล่นไปข้างหน้า

Large Language Model (LLM)

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

Generative AI (GenAI)

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

LangChain: ร้อยเรียงซิมโฟนี AI ของคุณ

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

Hugging Face: มหานครแห่งโมเดล AI

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

RAG: การใช้ประโยชน์จากฐานข้อมูลเวกเตอร์สำหรับ Accelerated Intelligence

Retrieval-Augmented Generation (RAG) เป็นเทคนิค AI ที่ซับซ้อนซึ่งผสมผสานพลังการสร้างสรรค์ของ Generative AI เข้ากับความแม่นยำในการดึงองค์ความรู้ เป็นการสร้างระบบที่ไม่ได้มีแค่ความชัดเจน แต่ยังได้รับข้อมูลอย่างลึกซึ้งอีกด้วย RAG ได้ผสมผสานฐานข้อมูลเวกเตอร์ ซึ่งเป็นเครื่องมืออันทรงพลังสำหรับการกรองข้อมูลในที่เก็บข้อมูลขนาดใหญ่อย่างรวดเร็ว เพื่อปลดล็อกศักยภาพและประสิทธิภาพของ RAG อย่างเต็มที่ ต่อไปนี้เป็นรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการทำงานของ RAG ที่อาศัยฐานข้อมูลเวกเตอร์

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

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

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

ด้วยความเข้าใจที่สมบูรณ์ยิ่งขึ้นของ LangChain, Hugging Face, LLM, GenAI และ RAG ที่ปรับปรุงฐานข้อมูลเวกเตอร์ เรากำลังเข้าใกล้การผจญภัยในการเขียนโค้ดที่จะทำให้เทคโนโลยีเหล่านี้ใช้งานได้จริง สคริปต์ Python ที่เราจะเจาะลึกแสดงถึงการทำงานร่วมกันขององค์ประกอบเหล่านี้ แสดงให้เห็นถึงระบบ AI ที่สามารถตอบสนองโดยไม่จำกัดแค่ความคิดสร้างสรรค์และบริบทเท่านั้น แต่ยังมีความเข้าใจเชิงลึก ซึ่งครั้งหนึ่งคนเคยคิดว่าเป็นได้ก็แค่ในนิยายแนววิทยาศาสตร์ เตรียมเขียนโค้ดและสัมผัสกับพลังการเปลี่ยนแปลงของ RAG ด้วยฐานข้อมูลเวกเตอร์

เริ่มต้นสู่เส้นทางการเขียนโค้ด

ก่อนเริ่ม: ข้อมูลสำคัญ

ก่อนออกเดินทางสู่การผจญภัยแห่งเทคโนโลยีนี้ เรามาเช็กกันหน่อยดีกว่าว่าคุณพร้อมหรือยัง

เซิร์ฟเวอร์ Linux จะทำงานได้ดีกว่าเมื่อใช้การ์ด GPU เพราะเราต้องยอมรับว่าความเร็วคือสิ่งสำคัญ
Python 3.6 ขึ้นไป คือไม้กายสิทธิ์แห่งการเขียนโปรแกรม
pip หรือ Anaconda ผู้จัดการแพ็กเกจชั้นยอดที่มีประโยชน์ของคุณ
หากใช้การ์ด GPU มีไดรเวอร์ NVIDIA ชุดเครื่องมือ CUDA และ cuDNN ทั้งหมดรวมกันก็เป็นสามสิ่งศักดิ์สิทธิ์สำหรับการเร่งความเร็ว GPU

หากมีครบทั้งหมดแล้ว ก็เยี่ยมไปเลย! มาทำให้มือของเราสกปรกกันเถอะ (แค่เปรียบเปรยเฉยๆ)

การรันโค้ด

ด้วยการจัดการการขึ้นต่อกันของ Python อย่างรอบคอบ คุณจะมั่นใจได้ว่าโปรเจ็กต์ AI ของคุณสร้างขึ้นบนรากฐานที่มั่นคงและเชื่อถือได้ ด้วยการขึ้นต่อกันและตั้งค่าสภาพแวดล้อมอย่างถูกต้อง คุณทุกคนก็พร้อมที่จะรันสคริปต์และเป็นสักขีพยานในประสิทธิภาพของ RAG และ LangChain

ตอนนี้คุณสามารถรันสคริปต์ Python เพื่อดูการทำงานของ RAG ได้แล้ว

การตั้งค่าสเตจ: นำเข้าไลบรารีและโหลดตัวแปร

ก่อนที่เราจะเริ่มต้นการสำรวจ AI ด้วยเฟรมเวิร์ก LangChain และไลบรารี Transformers ของ Hugging Face ได้ สิ่งสำคัญคือต้องสร้างสภาพแวดล้อมที่ปลอดภัยและกำหนดค่าอย่างดี การเตรียมการนี้เกี่ยวข้องกับการนำเข้าไลบรารีที่จำเป็นและการจัดการข้อมูลที่ละเอียดอ่อน เช่น คีย์ API ผ่านตัวแปรสภาพแวดล้อม

from torch import cuda
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
from transformers import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from dotenv import load_dotenv

load_dotenv()

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

ต่อไปนี้คือสิ่งที่คุณต้องทำเพื่อตั้งค่าสภาพแวดล้อมของคุณให้ปลอดภัย

รับคีย์ API ของ Hugging Face: เมื่อคุณสร้างบัญชี Hugging Face แล้ว คุณจะพบคีย์ API ของคุณได้ที่การตั้งค่าบัญชีในตัวเลือก 'Access Tokens' (โทเค็นการเข้าถึง)
รักษาความปลอดภัยคีย์ API: คีย์ API ของคุณเป็นข้อมูลที่ละเอียดอ่อนและควรเก็บไว้เป็นส่วนตัว แทนที่จะฮาร์ดโค้ดลงในสคริปต์ คุณควรใช้ตัวแปรสภาพแวดล้อม
สร้างไฟล์ .env: สร้างไฟล์ชื่อ .env ไฟล์นี้จะจัดเก็บตัวแปรสภาพแวดล้อมของคุณ
เพิ่มคีย์ API ไปยังไฟล์ .env: เปิดไฟล์ .env ตรงแก้ไขข้อความ และเพิ่มคีย์ Hugging Face API ในรูปแบบต่อไปนี้

HUGGINGFACE_API_KEY=your_api_key_here

แทนที่ your_api_key_here ด้วยคีย์ API จริงที่ได้รับจาก Hugging Face

กำหนดเส้นทางโมเดลและกำหนดค่า

modelPath = "sentence-transformers/all-mpnet-base-v2"
device = 'cuda' if cuda.is_available() else 'cpu'
model_kwargs = {'device': device}

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

เริ่มต้นการฝัง Hugging Face และ FAISS Vector Store

embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,
    model_kwargs=model_kwargs,
)

# Made up data, just for fun, but who knows in a future
vectorstore = FAISS.from_texts(
    ["Harrison worked at Alibaba Cloud"], embedding=embeddings
)

retriever = vectorstore.as_retriever()

เราเริ่มต้นอินสแตนซ์ของ HuggingFaceEmbeddings ด้วยโมเดลและการกำหนดค่าที่เราเลือก จากนั้น เราสร้าง vectorstore โดยใช้ FAISS ซึ่งช่วยให้เราทำการค้นหาความคล้ายคลึงกันอย่างมีประสิทธิภาพในพื้นที่มิติสูงได้ เรายังจะสร้างตัวอย่างรีทรีฟเวอร์ด้วย ซึ่งจะดึงข้อมูลตามการฝัง

ตั้งค่าเทมเพลตแชทพรอมต์

template = """Answer the question based only on the following context:
{context}
Question: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

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

เตรียม Tokenizer และโมเดลภาษา

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

ขนาดโมเดลและทรัพยากรการประมวลผล

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

ในทางกลับกัน โมเดลรุ่นเล็กกว่า เช่น Qwen-1.8B จะจัดการได้ดีกว่ามากสำหรับสภาพแวดล้อมการประมวลผลมาตรฐาน แม้แต่รุ่นจิ๋วนี้ก็ควรจะสามารถทำงานบน IoT และอุปกรณ์มือถือได้ แม้ว่าอาจไม่สามารถเข้าใจความซับซ้อนของภาษาได้เช่นเดียวกับภาษาที่คล้ายและกว้างกว่า แต่ก็ยังให้ประสิทธิภาพที่ยอดเยี่ยมและสามารถเข้าถึงได้มากขึ้นสำหรับผู้ที่ไม่มีฮาร์ดแวร์พิเศษ

โมเดลเฉพาะงาน

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

ต้นทุนของการอนุมาน

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

ซีรีส์ Qwen

Qwen-1.8B: เป็นโมเดลขนาดเล็กที่เหมาะสำหรับงานที่ต้องใช้พลังในการประมวลผลน้อยกว่า เหมาะสำหรับการสร้างต้นแบบและใช้งานบนเครื่องที่ไม่มี GPU ทรงพลัง
Qwen-7B: เป็นโมเดลขนาดกลางที่สมดุลทั้งด้านประสิทธิภาพและความต้องการด้านการประมวลผล เหมาะสำหรับงานต่างๆ รวมถึงการสร้างข้อความและการตอบคำถาม
Qwen-14B: เป็นโมเดลขนาดใหญ่ขึ้น ซึ่งสามารถจัดการกับงานที่ซับซ้อนมากขึ้นโดยมีความละเอียดอ่อนมากขึ้นในการทำความเข้าใจและการสร้างภาษา
Qwen-72B: เป็นโมเดลขนาดใหญ่ที่สุดในตระกูลนี้ มีประสิทธิภาพที่ล้ำสมัยสำหรับแอปพลิเคชัน AI ขั้นสูงที่ต้องใช้ความเข้าใจภาษาอย่างลึกซึ้ง
Qwen-1.8B-Chat: เป็นโมเดลการสนทนาที่ออกแบบมาโดยเฉพาะสำหรับการสร้างแชทบอทและระบบสนทนาอื่นๆ
Qwen-7B-Chat: เป็นโมเดลที่คล้ายกับ Qwen-1.8B-Chat แต่มีความจุเพิ่มขึ้นเพื่อจัดการบทสนทนาที่ซับซ้อนมากขึ้น
Qwen-14B-Chat: เป็นโมเดลการสนทนาระดับไฮเอนด์ที่สามารถโต้ตอบบทสนทนาที่ซับซ้อนได้
Qwen-72B-Chat: เป็นโมเดลการสนทนาที่ล้ำสุดในตระกูล Qwen มอบประสิทธิภาพที่ยอดเยี่ยมสำหรับแอปพลิเคชันแชทที่มีความต้องการสูง

การตัดสินใจเลือก

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

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

# This can be changed to any of the Qwen models based on your needs and resources
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B", trust_remote_code=True)
model_name_or_path = "Qwen/Qwen-7B"
model = AutoModelForCausalLM.from_pretrained(model_name_or_path,
                                             device_map="auto",
                                             trust_remote_code=True)

เราโหลด Tokenizer และโมเดลภาษาเชิงสาเหตุจาก Hugging Face ด้วยคลาส AutoTokenizer และ AutoModelForCausalLM ตามลำดับ ส่วนประกอบเหล่านี้มีความสำคัญอย่างยิ่งต่อการประมวลผลอินพุตภาษาที่เป็นธรรมชาติและการสร้างเอาต์พุต

สร้างไปป์ไลน์การสร้างข้อความ

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

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=8192,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    top_k=40,
    repetition_penalty=1.1
)

hf = HuggingFacePipeline(pipeline=pipe)

คำอธิบายของพารามิเตอร์ในไปป์ไลน์การสร้างข้อความ:

Max_new_tokens (8192): พารามิเตอร์นี้จะระบุจำนวนโทเค็นสูงสุดที่สามารถสร้างได้ในเอาต์พุต โดยโทเค็นอาจเป็นคำ อักขระ หรือคำย่อย ขึ้นอยู่กับ Tokenizer
do_sample (True): เมื่อตั้งค่าเป็น True พารามิเตอร์นี้จะเปิดใช้งานการสุ่มตัวอย่างความน่าจะเป็นจากการกระจายโทเค็นถัดไปที่เป็นไปได้ที่สร้างโดยโมเดล ซึ่งจะทำให้เกิดการสุ่มและความหลากหลายในข้อความที่สร้างขึ้น หากตั้งค่าเป็น False โมเดลจะเลือกโทเค็นถัดไปที่เป็นไปได้มากที่สุดเสมอ ซึ่งนำไปสู่เอาต์พุตที่กำหนดและแตกต่างกันน้อยลง
temperature (0.7): พารามิเตอร์ temperature จะควบคุมว่าจะมีการสุ่มตัวอย่างมากน้อยเพียงใดในกระบวนการสุ่มตัวอย่าง ค่า temperature ที่ต่ำกว่า (ใกล้เคียง 0) ทำให้โมเดลมีความมั่นใจในตัวเลือกมากขึ้น ส่งผลให้เกิดเอาท์พุตแบบสุ่มน้อยลง ในขณะที่ค่า temperature ที่สูงขึ้น (ใกล้เคียง 1) จะกระตุ้นให้เกิดการสุ่มและความหลากหลายมากขึ้น
top_p (0.95): พารามิเตอร์นี้ควบคุมการสุ่มตัวอย่างนิวเคลียส ซึ่งเป็นเทคนิคที่พิจารณาเฉพาะโทเค็นที่เป็นไปได้มากที่สุดโดยมีความน่าจะเป็นสะสมที่สูงกว่าเกณฑ์ top_p พารามิเตอร์นี้ช่วยสร้างข้อความที่มีความหลากหลายและสอดคล้องกัน โดยหลีกเลี่ยงการรวมโทเค็นที่มีโอกาสต่ำมากซึ่งอาจทำให้เกิดข้อความที่ไม่มีความหมาย
top_k (40): การสุ่มตัวอย่าง Top-k จำกัดกลุ่มการสุ่มตัวอย่างไว้ที่ k โทเค็นถัดไปที่น่าจะเป็นไปได้มากที่สุด สิ่งนี้จะปรับแต่งชุดโทเค็นที่โมเดลจะพิจารณาเพิ่มเติมเพื่อสร้างข้อความชิ้นถัดไป เพื่อให้มั่นใจว่าเอาต์พุตยังคงมีความเกี่ยวข้องและสอดคล้องกัน
repetition_penalty (1.1): พารามิเตอร์นี้ป้องกันไม่ให้โมเดลทำซ้ำโทเค็นหรือวลีเดียวกัน เพื่อส่งเสริมข้อความที่น่าสนใจและหลากหลายยิ่งขึ้น ค่าที่มากกว่า 1 จะเป็นการลดโอกาสความน่าจะเป็นของโทเค็นที่ปรากฏแล้ว

หลังจากตั้งค่าไปป์ไลน์ด้วยพารามิเตอร์ที่ต้องการแล้ว โค้ดบรรทัดถัดไป:

hf = HuggingFacePipeline(pipeline=pipe)

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

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

สร้างและรันเชน RAG

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

1. การสร้างเชน:

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | hf
    | StrOutputParser()
)

นี่คือสิ่งที่เกิดขึ้นในส่วนนี้ของโค้ด:

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

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

2. การเรียกใช้เชน:

results = chain.invoke("Where did Harrison work?")

ในบรรทัดนี้เชนกำลังถูกเรียกใช้ด้วยคำถามเฉพาะ:_"Where did Harrison work?"_การเรียกใช้นี้จะกระตุ้นลำดับการดำเนินการทั้งหมดที่กำหนดไว้ในเชน รีทรีฟเวอร์ค้นหาข้อมูลที่เกี่ยวข้อง ซึ่งจะถูกส่งต่อพร้อมกับคำถามผ่านพรอมต์และเข้าสู่โมเดล Hugging Face โมเดลสร้างการตอบสนองตามอินพุตที่ได้รับ

3. แสดงผล:

print(results)

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

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

บทสรุป: ประตูสู่ความเชี่ยวชาญด้าน AI

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

บทความนี้มาจากต้นฉบับภาษาอังกฤษ ดูบทความต้นฉบับที่นี่

Community