วิธีวิเคราะห์เอกสารด้วย LangChain และ OpenAI API

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

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

การตั้งค่าสภาพแวดล้อมของคุณ

หากต้องการสร้างสภาพแวดล้อมเสมือน Python ใหม่และติดตั้งไลบรารีที่จำเป็น ให้ทำตามขั้นตอนเหล่านี้:ขั้นแรก สร้างสภาพแวดล้อม Python ใหม่โดยใช้โมดูล venv ที่มาพร้อมกับ Python 3.x วิธีนี้จะป้องกันปัญหาความเข้ากันได้ระหว่างแพ็คเกจที่ติดตั้งเวอร์ชันต่างๆ ในการดำเนินการนี้ ให้เปิดเทอร์มินัลหรือพรอมต์คำสั่งแล้วไปที่ไดเร็กทอรีที่ต้องการซึ่งคุณต้องการสร้างสภาพแวดล้อมเสมือน ให้ป้อนคำสั่งต่อไปนี้:bashpython-m venv myenvแทนที่ “myenv” ด้วยชื่อที่คุณต้องการสำหรับสภาพแวดล้อมเสมือนของคุณ จากนั้น เปิดใช้งานสภาพแวดล้อมที่สร้างขึ้นใหม่โดยใช้คำสั่ง ./bin/activate (บน Windows) หรือ source bin/activate (บน macOS หรือ Linux) หลังจากเปิดใช้งานแล้ว ให้ดำเนินการติดตั้งไลบรารีที่จำเป็นต่อไปโดยเรียกใช้

 pip install langchain openai tiktoken faiss-cpu pypdf 

การใช้ประโยชน์ของแต่ละห้องสมุดสามารถสรุปได้ดังนี้

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

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

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

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

PyPDF2 เป็นแพ็คเกจ Python ที่อำนวยความสะดวกในการแยกข้อความจากไฟล์ Portable Document Format (PDF) ซอฟต์แวร์ปรับปรุงกระบวนการโหลดเอกสาร PDF และเปิดใช้งานการดึงเนื้อหาเพื่อการจัดการหรือการวิเคราะห์ในภายหลัง

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

รับคีย์ OpenAI API

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

หากต้องการรับคีย์ OpenAI API โปรดไปที่ แพลตฟอร์ม OpenAI

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

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

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

การนำเข้าไลบรารีที่จำเป็น

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

 from langchain.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

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

กำลังโหลดเอกสารเพื่อการวิเคราะห์

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

 # Hardcoded API key
openai_api_key = "Your API key"

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

แน่นอน! นี่คือตัวอย่างวิธีที่คุณสามารถปรับใช้สิ่งนี้ใน Python โดยใช้ไลบรารี PyPDF2 สำหรับการทำงานกับไฟล์ PDF และฟังก์ชัน open() ในตัวเพื่ออ่านไฟล์ข้อความธรรมดา: pythonimport PyPDF2from io import BytesIOdef load_document(file_path):“““ โหลดเอกสารจากเส้นทางไฟล์ที่ระบุ”””# ตรวจสอบว่ามีไฟล์อยู่หรือไม่ก่อนที่จะพยายามเปิด ittry:if not file_path.endswith(’.pdf’):# Document is not a PDF file, ดังนั้นลองเปิดเป็นข้อความ ไฟล์แทนด้วย open(file_path,‘r’) as f:return f.read()elif file_path.endswith(’.pdf’):

 def load_document(filename):
   if filename.endswith(".pdf"):
       loader = PyPDFLoader(filename)
       documents = loader.load()
   elif filename.endswith(".txt"):
       loader = TextLoader(filename)
       documents = loader.load()
   else:
       raise ValueError("Invalid file type") 

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

    text_splitter = CharacterTextSplitter(chunk_size=1000,
                                          chunk_overlap=30, separator="\n")

   return text_splitter.split_documents(documents=documents)

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

การสืบค้นเอกสาร

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

 def query_pdf(query, retriever):
   qa = RetrievalQA.from_chain_type(llm=OpenAI(openai_api_key=openai_api_key),
                                    chain_type="stuff", retriever=retriever)
   result = qa.run(query)
   print(result)

ฟังก์ชันปัจจุบันใช้โมเดลการตอบคำถามแบบอินสแตนซ์เพื่อดำเนินการสอบถามและแสดงผลลัพธ์

การสร้างฟังก์ชั่นหลัก

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

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

 def main():
   filename = input("Enter the name of the document (.pdf or .txt):\n")
   docs = load_document(filename)
   embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
   vectorstore = FAISS.from_documents(docs, embeddings)
   vectorstore.save_local("faiss_index_constitution")
   persisted_vectorstore = FAISS.load_local("faiss_index_constitution", embeddings)
   query = input("Type in your query (type 'exit' to quit):\n")

   while query != "exit":
       query_pdf(query, persisted_vectorstore.as_retriever())
       query = input("Type in your query (type 'exit' to quit):\n")

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

โค้ดปัจจุบันแปลงเนื้อหาข้อความภายในเอกสารเป็นการแสดงเวกเตอร์โดยใช้การฝังที่สร้างโดย OpenAIEmbeddings จากนั้นจัดทำดัชนีการแสดงเวกเตอร์ดังกล่าวด้วย FAISS (การค้นหาความคล้ายคลึงกันของ Facebook AI) เพื่ออำนวยความสะดวกในการเรียกค้นและเปรียบเทียบรูปแบบเวกเตอร์ที่คล้ายกันอย่างรวดเร็ว ช่วยให้สามารถตรวจสอบเอกสารที่ส่งมาได้

การรวมแอตทริบิวต์ \_\_name\_\_ เข้ากับค่าที่สอดคล้องกันของ "\_\_main\_\_" ถือเป็นขั้นตอนสำคัญในการเรียกใช้ฟังก์ชันหลักเมื่อสคริปต์ทำงานเป็นโปรแกรมแบบสแตนด์อโลน ด้วยการใช้โครงสร้างนี้ ช่วยให้สามารถดำเนินการฟังก์ชันหลักได้อย่างราบรื่นเมื่อมีการโต้ตอบกับผู้ใช้ โดยไม่ต้องแจ้งหรือการแทรกแซงจากภายนอก

 if __name__ == "__main__":
   main() 

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

ดำเนินการวิเคราะห์เอกสาร

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

การแสดงกราฟิกที่ให้ไว้ในที่นี้แสดงให้เห็นถึงการค้นพบที่ได้รับจากการประมวลผลไฟล์ Portable Document Format (PDF) ดังที่แสดงในภาพหน้าจอที่อยู่ใต้ข้อความนี้

จอแสดงผลถัดมาเป็นตัวอย่างการค้นพบจากการตรวจสอบเอกสารที่มีโค้ดโปรแกรม

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

ทำความเข้าใจเทคโนโลยีเบื้องหลังโมเดลภาษาขนาดใหญ่

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