สองวิธี embed_query() และ embed_documents() มีให้โดยคลาสพื้นฐาน แบบแรกทำงานในเอกสารเดียว ส่วนอีกแบบหนึ่งสามารถทำงานกับเอกสารหลายชุดได้
บทความนี้จะอธิบายถึงการสาธิตเชิงปฏิบัติของการฝังใน LangChain โดยใช้การฝังข้อความ OpenAI
ตัวอย่าง: การรับข้อความอินพุตเดียวโดยใช้การฝังข้อความ OpenAI
สำหรับภาพประกอบแรก เราป้อนสตริงข้อความเดียวและดึงข้อความ OpenAI ที่ฝังไว้ โปรแกรมเริ่มต้นด้วยการติดตั้งไลบรารีที่จำเป็น
ไลบรารีแรกที่เราต้องติดตั้งในโครงการของเราคือ LangChain มันไม่ได้มาพร้อมกับไลบรารีมาตรฐานของ Python ดังนั้นเราต้องติดตั้งแยกต่างหาก เนื่องจาก langchain พร้อมใช้งานบน PyPi เราจึงสามารถติดตั้งได้อย่างง่ายดายโดยใช้คำสั่ง pip บนเทอร์มินัล ดังนั้นเราจึงเรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งไลบรารี LangChain:
$ pip ติดตั้ง langchain
ห้องสมุดได้รับการติดตั้งทันทีที่ตรงตามความต้องการ
เรายังต้องการไลบรารี OpenAI เพื่อติดตั้งในโครงการของเรา เพื่อให้เราสามารถเข้าถึงโมเดล OpenAI ได้ ห้องสมุดนี้สามารถเปิดตัวได้โดยเขียนคำสั่ง pip:
$ pip ติดตั้ง openaiตอนนี้ทั้งสองไลบรารีที่จำเป็นได้รับการติดตั้งในไฟล์โครงการของเรา เราต้องนำเข้าโมดูลที่ต้องการ
จาก แลงเชน การฝัง . เปิด นำเข้า OpenAIEmbeddings
นำเข้า คุณ
คุณ . ประมาณ [ 'OPENAI_API_KEY' ] = 'sk-YOUR_API_KEY'
ในการรับ OpenAI embeddings เราต้องอิมพอร์ตคลาส OpenAIEmbeddings จากแพ็คเกจ “langchain.embeddings.openai” จากนั้น เราตั้งค่าคีย์ API เป็นตัวแปรสภาพแวดล้อม เราต้องการคีย์ API ลับเพื่อเข้าถึงโมเดล OpenAI ต่างๆ คีย์นี้สามารถสร้างได้จากแพลตฟอร์ม OpenAI เพียงลงทะเบียนและรับรหัสลับจากส่วน 'ดูรหัสลับ' ในโปรไฟล์ของคุณ คีย์นี้สามารถใช้ได้ในโครงการต่างๆ สำหรับลูกค้าเฉพาะราย
ตัวแปรสภาพแวดล้อมใช้เพื่อจัดเก็บคีย์ API สำหรับสภาพแวดล้อมเฉพาะ แทนที่จะเข้ารหัสฮาร์ดโค้ดลงในฟังก์ชัน ดังนั้น ในการตั้งค่าคีย์ API เป็นตัวแปรสภาพแวดล้อม เราต้องนำเข้าโมดูล 'os' เมธอด os.environ() ใช้เพื่อตั้งค่าคีย์ API เป็นตัวแปรสภาพแวดล้อม ประกอบด้วยชื่อและค่า ชื่อที่เราตั้งคือ “OPENAI_API_KEY” และรหัสลับถูกกำหนดเป็น “value”
แบบอย่าง = OpenAIEmbeddings ( )อินพุต_ข้อความ = 'นี่คือการสาธิต'
ผล = แบบอย่าง. embed_query ( อินพุต_ข้อความ )
พิมพ์ ( ผล )
พิมพ์ ( เท่านั้น ( ผล ) )
เราได้เชื่อมต่อกับ OpenAI embedding wrapper แล้ว หลังจากนั้น เราเรียกตัวสร้างของคลาส OpenAIEmbedding OpenAI มีรูปแบบการฝังที่หลากหลาย แต่คุณต้องจ่ายเงิน ที่นี่เราใช้รูปแบบการฝังเริ่มต้นของ OpenAI เช่น text-embedding-ada-002 ซึ่งฟรี เมื่อคุณไม่ได้ระบุชื่อรุ่นใดๆ เป็นพารามิเตอร์ ระบบจะใช้รุ่นเริ่มต้น
จากนั้นเราระบุข้อความที่เราต้องได้รับการฝัง มีการระบุข้อความว่า “นี่คือการสาธิต” และเก็บไว้ในตัวแปร input_text หลังจากนั้น เมธอด embed_query() เพื่อฝังข้อความที่ระบุจะถูกเรียกพร้อมกับโมเดลที่ใช้ และ input_text ที่มีสตริงข้อความเพื่อเรียกข้อมูลการฝังซึ่งระบุเป็นพารามิเตอร์ การฝังที่ดึงมาถูกกำหนดให้กับวัตถุผลลัพธ์
สุดท้ายเพื่อให้ผลลัพธ์ดู เรามีเมธอด print() ของ Python เราเพียงแค่ต้องส่งวัตถุที่เก็บค่าที่เราต้องการแสดงไปยังเมธอด print() ดังนั้นเราจึงเรียกใช้ฟังก์ชันนี้สองครั้ง อันดับแรกเพื่อแสดงรายการของตัวเลขลอยตัว และลำดับที่สองเพื่อพิมพ์ความยาวของค่าเหล่านี้โดยใช้เมธอด len()
รายการค่าลอยตัวสามารถดูได้ในสแน็ปช็อตต่อไปนี้พร้อมความยาวของค่าเหล่านี้:
ตัวอย่าง: การรับข้อความ/เอกสารอินพุตหลายรายการโดยใช้การฝังข้อความ OpenAI
นอกเหนือจากการได้รับการฝังสำหรับข้อความอินพุตเดียว เรายังสามารถดึงข้อมูลสำหรับสตริงอินพุตหลายรายการได้อีกด้วย เราใช้สิ่งนี้ในภาพประกอบนี้
เราได้ติดตั้งไลบรารี่ในภาพประกอบก่อนหน้านี้แล้ว ไลบรารีอื่นที่เราต้องติดตั้งที่นี่คือไลบรารี tiktoken ของ Python เขียนคำสั่งบนเทอร์มินัลเพื่อติดตั้ง:
$ pip ติดตั้ง tiktokenแพ็คเกจ tiktoken เป็นโทเค็นการเข้ารหัส Byte Pair ใช้กับโมเดล OpenAI และแบ่งข้อความเป็นโทเค็น สิ่งนี้ใช้เนื่องจากบางครั้งสตริงที่ให้มานั้นยาวไปหน่อยสำหรับโมเดล OpenAI ที่ระบุ ดังนั้นจึงแยกข้อความและเข้ารหัสเป็นโทเค็น ตอนนี้เรามาทำงานในโครงการหลักกัน
จาก แลงเชน การฝัง . เปิด นำเข้า OpenAIEmbeddingsแบบอย่าง = OpenAIEmbeddings ( openai_api_key = 'sk-YOUR_API_KEY'
สตริง = [' นี้ เป็น สำหรับ สาธิต. ', ' นี้ สตริง เป็น อีกด้วย สำหรับ สาธิต. ', ' นี้ เป็น การสาธิตอื่น สตริง . ', ' อันนี้ เป็น ล่าสุด สตริง . ']
ผลลัพธ์ = model.embed_documents (สตริง)
พิมพ์(ผล)
พิมพ์(เลนส์(ผลลัพธ์))
คลาส OpenAIEmbeddings นำเข้าจากแพ็คเกจ “langchain.embeddings.openai” ในตัวอย่างก่อนหน้านี้ เราตั้งค่าคีย์ API เป็นตัวแปรสภาพแวดล้อม แต่สำหรับสิ่งนี้ เราส่งต่อไปยังตัวสร้างโดยตรง ดังนั้นเราจึงไม่ต้องนำเข้าโมดูล 'os' ที่นี่
หลังจากเรียกใช้โมเดล OpenAI ซึ่งเป็น OpenAIEmbeddings แล้ว เราจะส่งคีย์ API ลับไปให้ ในบรรทัดถัดไป สตริงข้อความจะถูกระบุ ที่นี่ เราจัดเก็บสตริงข้อความสี่รายการในสตริงวัตถุ สตริงเหล่านี้คือ 'นี่คือสตริงสำหรับการสาธิต' 'สตริงนี้มีไว้สำหรับการสาธิตด้วย' 'นี่คือสตริงการสาธิตอื่น' และ 'สตริงนี้เป็นสตริงสุดท้าย'
คุณสามารถระบุได้หลายสตริงโดยคั่นแต่ละสตริงด้วยเครื่องหมายจุลภาค ในตัวอย่างก่อนหน้านี้ มีการเรียกเมธอด embed_text() แต่เราไม่สามารถใช้ที่นี่ได้ เนื่องจากเมธอดนี้ใช้ได้กับสตริงข้อความเดียวเท่านั้น ในการฝังหลายสตริง วิธีที่เรามีคือ embed_document() ดังนั้นเราจึงเรียกมันด้วยโมเดล OpenAI และสตริงข้อความที่ระบุเป็นอาร์กิวเมนต์ ผลลัพธ์จะถูกเก็บไว้ในวัตถุผลลัพธ์ สุดท้าย เพื่อแสดงผลลัพธ์ ใช้เมธอด Python print() โดยมีผลลัพธ์ของออบเจกต์เป็นพารามิเตอร์ นอกจากนี้ เราต้องการดูความยาวของค่าลอยเหล่านี้ ดังนั้นเราจึงเรียกใช้เมธอด len() ภายในเมธอด print()
เอาต์พุตที่เรียกมามีอยู่ในรูปภาพต่อไปนี้:
บทสรุป
โพสต์นี้กล่าวถึงแนวคิดของการฝังใน LangChain เราได้เรียนรู้ว่าการฝังคืออะไรและทำงานอย่างไร การใช้งานจริงของการฝังสตริงข้อความแสดงไว้ที่นี่ เราวาดภาพประกอบสองภาพ ตัวอย่างแรกทำงานเกี่ยวกับการดึงการฝังของสตริงข้อความเดี่ยว และตัวอย่างที่สองเข้าใจวิธีรับการฝังของสตริงอินพุตหลายรายการโดยใช้โมเดลการฝัง OpenAI