1. บทนำ
อัปเดตล่าสุด: 08-04-2024
การฝังข้อความ
การฝังข้อความหมายถึงกระบวนการแปลงข้อมูลข้อความเป็นตัวแทนตัวเลข การแสดงตัวเลขเหล่านี้ ซึ่งมักจะเป็นเวกเตอร์ จะบันทึกความหมายเชิงความหมายและความสัมพันธ์ระหว่างคำในข้อความ ลองนึกภาพตามนี้
ข้อความก็เหมือนภาษาที่ซับซ้อน ซึ่งเต็มไปด้วยความแตกต่างและความคลุมเครือ
การฝังข้อความจะแปลภาษานั้นเป็นรูปแบบทางคณิตศาสตร์ที่ง่ายขึ้นซึ่งคอมพิวเตอร์สามารถเข้าใจและจัดการได้
ประโยชน์ของการฝังข้อความ
- ช่วยให้ประมวลผลได้อย่างมีประสิทธิภาพ: การแสดงข้อมูลเป็นตัวเลขช่วยให้คอมพิวเตอร์ประมวลผลได้เร็วกว่าข้อความดิบมาก ซึ่งเป็นสิ่งสำคัญสำหรับงานต่างๆ เช่น เครื่องมือค้นหา ระบบคำแนะนำ และการแปลด้วยคอมพิวเตอร์
- จับความหมายเชิงความหมาย: การฝังไม่ได้จำกัดอยู่แค่ความหมายตามตัวอักษรของคำเท่านั้น โดยจะบันทึกบริบทและความสัมพันธ์ระหว่างคำต่างๆ ซึ่งช่วยให้วิเคราะห์ได้ละเอียดมากขึ้น
- ปรับปรุงประสิทธิภาพของแมชชีนเลิร์นนิง: คุณสามารถใช้การฝังข้อความเป็นฟีเจอร์ในโมเดลแมชชีนเลิร์นนิง ซึ่งจะช่วยให้ประสิทธิภาพดีขึ้นในงานต่างๆ เช่น การวิเคราะห์ความเห็น การจัดประเภทข้อความ และการสร้างโมเดลหัวข้อ
กรณีการใช้งานการฝังข้อความ
การฝังข้อความจะปลดล็อกแอปพลิเคชันต่างๆ ในการประมวลผลภาษาธรรมชาติ (NLP) โดยการแปลงข้อความเป็นตัวแทนที่เป็นตัวเลข กรณีการใช้งานที่สำคัญมีดังนี้
1. เครื่องมือค้นหาและการดึงข้อมูล:
การฝังข้อความช่วยให้เครื่องมือค้นหาเข้าใจความหมายเชิงความหมายเบื้องหลังคำค้นหาและจับคู่กับเอกสารที่เกี่ยวข้องได้ แม้ว่าจะไม่มีคีย์เวิร์ดที่ตรงกันทุกประการก็ตาม
การเปรียบเทียบการฝังคำค้นหากับการฝังเอกสารจะช่วยให้เครื่องมือค้นหาระบุเอกสารที่ครอบคลุมหัวข้อหรือแนวคิดที่คล้ายกันได้
2. ระบบการแนะนำ:
ระบบแนะนำใช้การฝังข้อความเพื่อวิเคราะห์พฤติกรรมและความชอบของผู้ใช้ที่แสดงผ่านรีวิว การให้คะแนน หรือประวัติการท่องเว็บ
จากนั้นระบบจะแนะนำสินค้าที่คล้ายกันได้โดยการเปรียบเทียบการฝังของผลิตภัณฑ์ บทความ หรือเนื้อหาอื่นๆ ที่ผู้ใช้โต้ตอบด้วย
3. การตรวจหาการลอกเลียนผลงาน:
การเปรียบเทียบการฝังของข้อความ 2 ชิ้นจะช่วยระบุการลอกเลียนที่อาจเกิดขึ้นได้โดยการค้นหาความคล้ายคลึงกันที่สำคัญในโครงสร้างเชิงความหมาย
นี่เป็นเพียงตัวอย่างบางส่วนเท่านั้น และความเป็นไปได้จะเพิ่มขึ้นเรื่อยๆ เมื่อเทคนิคการฝังข้อความพัฒนาขึ้น เมื่อคอมพิวเตอร์เข้าใจภาษาได้ดียิ่งขึ้นผ่านการฝัง เราก็คาดหวังได้ว่าจะได้เห็นแอปพลิเคชันที่สร้างสรรค์ยิ่งขึ้นในอนาคต
textembedding-gecko@003
Textembedding-gecko@003 เป็นโมเดลการฝังข้อความที่ได้รับการฝึกมาก่อนเวอร์ชันหนึ่งที่ Google Cloud Platform (GCP) นำเสนอผ่าน Vertex AI และชุดเครื่องมือและบริการ AI
สิ่งที่คุณจะสร้าง
ใน Codelab นี้ คุณจะได้สร้างสคริปต์ Python สคริปต์นี้จะทำสิ่งต่อไปนี้
- ใช้ Vertex API เพื่อเรียกใช้ textembedding-gecko@003 และแปลงข้อความเป็นข้อความที่ฝัง (เวกเตอร์)
- สร้างฐานข้อมูลจำลองที่ประกอบด้วยข้อความและเวกเตอร์ของข้อความ
- ทำการค้นหาฐานข้อมูลเวกเตอร์จำลองโดยการเปรียบเทียบเวกเตอร์และรับคำตอบที่มีแนวโน้มมากที่สุด
สิ่งที่คุณจะได้เรียนรู้
- วิธีใช้การฝังข้อความใน GCP
- วิธีเรียกใช้ textembedding-gecko@003
- วิธีเรียกใช้ใน Workbench
- วิธีใช้ Vertex AI - Workbench เพื่อเรียกใช้สคริปต์
สิ่งที่คุณต้องมี
- Chrome เวอร์ชันล่าสุด
- ความรู้เกี่ยวกับ Python
- โปรเจ็กต์ Google Cloud
- การเข้าถึง Vertex AI - Workbench
2. การเริ่มตั้งค่า
สร้างอินสแตนซ์ Vertex AI Workbench
- ในคอนโซล Google Cloud ในหน้าตัวเลือกโปรเจ็กต์ ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud
- ไปที่ตัวเลือกโปรเจ็กต์
- ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Google Cloud แล้ว
- เปิดใช้ Notebooks API
คุณสร้างอินสแตนซ์ Vertex AI Workbench ได้โดยใช้คอนโซล Google Cloud, gcloud CLI หรือ Terraform สำหรับวัตถุประสงค์ของบทแนะนำนี้ เราจะสร้างโดยใช้คอนโซล Google Cloud ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีอื่นๆ ได้ที่นี่
- ในคอนโซล Google Cloud ให้ไปที่หน้าอินสแตนซ์ ซึ่งเข้าถึงได้ในเมนู Vertex AI ส่วน Notebook แล้วคลิก Workbench
- ไปที่อินสแตนซ์
- คลิกสร้างใหม่
- ในกล่องโต้ตอบสร้างอินสแตนซ์ ให้ระบุข้อมูลต่อไปนี้สำหรับอินสแตนซ์ใหม่ในส่วนรายละเอียด
ชื่อ: ระบุชื่ออินสแตนซ์ใหม่ ชื่อต้องขึ้นต้นด้วยตัวอักษร ตามด้วยตัวอักษรพิมพ์เล็ก ตัวเลข หรือขีดกลาง (-) ไม่เกิน 62 ตัว และต้องไม่ลงท้ายด้วยขีดกลาง
ภูมิภาคและโซน: เลือกภูมิภาคและโซนสำหรับอินสแตนซ์ใหม่ เลือกภูมิภาคที่อยู่ใกล้กับคุณมากที่สุดเพื่อประสิทธิภาพเครือข่ายที่ดีที่สุด
ไม่ต้องติดตั้ง GPU
ในส่วนเครือข่าย ให้ระบุข้อมูลต่อไปนี้
ระบบเครือข่าย: ปรับตัวเลือกเครือข่ายเพื่อใช้เครือข่ายในโปรเจ็กต์ปัจจุบันหรือเครือข่าย VPC ที่แชร์จากโปรเจ็กต์โฮสต์ หากมีการกำหนดค่า หากใช้ VPC ที่แชร์ในโปรเจ็กต์โฮสต์ คุณต้องให้บทบาทผู้ใช้เครือข่าย Compute (roles/compute.networkUser) แก่ Notebooks Service Agent จากโปรเจ็กต์บริการด้วย
ในช่องเครือข่าย ให้เลือกเครือข่ายที่ต้องการ คุณเลือกเครือข่าย VPC ได้ตราบใดที่เครือข่ายได้เปิดใช้การเข้าถึง Google แบบส่วนตัวหรือเข้าถึงอินเทอร์เน็ตได้
ในช่องเครือข่ายย่อย: เลือกเครือข่ายย่อยที่ต้องการ คุณเลือกค่าเริ่มต้นได้
ในพร็อพเพอร์ตี้อินสแตนซ์ คุณสามารถปล่อยให้เป็นค่าเริ่มต้นได้ ซึ่งก็คือ e2-standard-4
- คลิกสร้าง
Vertex AI Workbench จะสร้างอินสแตนซ์และเริ่มอินสแตนซ์โดยอัตโนมัติ เมื่ออินสแตนซ์พร้อมใช้งาน Vertex AI Workbench จะเปิดใช้งานลิงก์ "เปิด JupyterLab" ให้คลิกไอคอนนั้น
สร้าง Notebook Python 3
- ภายใน Jupyterlab จาก Launcher ในส่วน Notebook ให้คลิกไอคอนที่มีโลโก้ Python ซึ่งระบุว่า Python3
- ระบบจะสร้างสมุดบันทึก Jupyter โดยใช้ชื่อ Untitled และนามสกุล ipynb
- คุณเปลี่ยนชื่อได้โดยใช้ส่วนโปรแกรมเรียกดูไฟล์ทางด้านซ้าย หรือจะปล่อยไว้ตามเดิมก็ได้
ตอนนี้เราก็เริ่มใส่โค้ดใน Notebook ได้แล้ว
3. การนำเข้าไลบรารีที่จำเป็น
เมื่อสร้างอินสแตนซ์และเปิด Jupyterlab แล้ว เราต้องติดตั้งไลบรารีที่จำเป็นทั้งหมดสำหรับ Codelab
เราจะต้องมีสิ่งต่อไปนี้
- numpy
- แพนด้า
- TextEmbeddingInput, TextEmbeddingModel จาก vertexai.language_models
คัดลอกและวางโค้ดด้านล่างในเซลล์
from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel
import numpy as np
import pandas as pd
URL จะมีหน้าตาดังนี้:
4. สร้างฐานข้อมูลเวกเตอร์จำลอง
ในการทดสอบโค้ด เราจะสร้างฐานข้อมูลที่ประกอบด้วยข้อความและเวกเตอร์ที่เกี่ยวข้องซึ่งแปลโดยใช้โมเดลการฝังข้อความ gecko@003
โดยมีวัตถุประสงค์เพื่อให้ผู้ใช้ค้นหาข้อความ แปลเป็นเวกเตอร์ ค้นหาในฐานข้อมูลของเรา และแสดงผลลัพธ์ที่ใกล้เคียงที่สุด
ฐานข้อมูลเวกเตอร์ของเราจะเก็บ 3 ระเบียน ซึ่งเราจะสร้างดังนี้
คัดลอกและวางโค้ดด้านล่างในเซลล์ใหม่
DOCUMENT1 = {
"title": "Operating the Climate Control System",
"content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console. Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}
DOCUMENT2 = {
"title": "Touchscreen",
"content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon. For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}
DOCUMENT3 = {
"title": "Shifting Gears",
"content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position. Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
ซึ่งจะมีลักษณะดังนี้
มาวิเคราะห์โค้ดกัน
ในตัวแปร DOCUMENT1, DOCUMENT2 และ DOCUMENT3 เราจะจัดเก็บพจนานุกรมที่จะจำลองเอกสารที่มีชื่อและเนื้อหา "เอกสาร" เหล่านี้อ้างอิงถึงคู่มือจำลองของรถยนต์ที่ Google สร้างขึ้น
ในบรรทัดถัดไป เราจะสร้างรายการจากเอกสาร (พจนานุกรม) ทั้ง 3 รายการนั้น
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
สุดท้ายนี้ เราจะใช้ประโยชน์จาก Pandas เพื่อสร้าง DataFrame จากรายการดังกล่าว ซึ่งจะเรียกว่า df_initial_db
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
5. สร้างการฝังข้อความ
ตอนนี้เราจะรับการฝังข้อความโดยใช้โมเดล gecko@003 สำหรับแต่ละระเบียนในฐานข้อมูลเอกสารจำลอง
คัดลอกและวางโค้ดด้านล่างลงในเซลล์ใหม่
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
ซึ่งจะมีลักษณะดังนี้
มาวิเคราะห์โค้ดกัน
เราได้กำหนดฟังก์ชันชื่อ embed_fn ซึ่งจะรับอินพุตเป็น Pandas DataFrame ที่มีข้อความที่จะทำการฝัง จากนั้นฟังก์ชันจะแสดงผลข้อความที่เข้ารหัสเป็นเวกเตอร์
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
ในรายการที่ชื่อว่า list_embedded_values คือที่ที่เราจะจัดเก็บและต่อท้ายข้อความที่เข้ารหัสของทุกแถว
การใช้วิธี iterrows จาก pandas ช่วยให้เราสามารถวนซ้ำทุกแถวใน DataFrame เพื่อรับค่าจากคอลัมน์ข้อความ (ซึ่งมีข้อมูลที่ป้อนด้วยตนเองจากฐานข้อมูลจำลอง)
หากต้องการส่งข้อความปกติและแสดงผลเวกเตอร์โดยใช้โมเดล gecko@003 เราจะเริ่มต้นตัวแปรโมเดล ซึ่งเป็นที่ที่เราตั้งค่าโมเดลที่จะใช้โดยการเรียกฟังก์ชัน TextEmbeddingModel.from_pretrained
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
จากนั้นในการฝังตัวแปร เราจะบันทึกเวกเตอร์ของข้อความที่เราส่งผ่านฟังก์ชัน model.get_embeddings
ที่ส่วนท้ายของฟังก์ชัน เราจะสร้างคอลัมน์ใหม่ใน DataFrame ชื่อว่า "ข้อความที่ฝัง" ซึ่งจะมีรายการเวกเตอร์ที่สร้างขึ้นตามโมเดล gecko@003
df_input['Embedded text'] = list_embedded_values
return df_input
สุดท้าย ในตัวแปร df_embedded_values_db เราจะบันทึก DataFrame ที่มีข้อมูลเดิมจากฐานข้อมูลจำลอง รวมถึงคอลัมน์ใหม่ที่มีรายการเวกเตอร์สำหรับแต่ละแถว
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
6. การถามคำถามกับฐานข้อมูลเวกเตอร์
ตอนนี้ฐานข้อมูลของเรามีข้อความและเวกเตอร์ของข้อความแล้ว เราจึงสามารถถามคำถามและค้นหาฐานข้อมูลเพื่อหาคำตอบได้
โดยให้คัดลอกและวางโค้ดด้านล่างลงในเซลล์ใหม่
question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])
text_to_search=embeddings[0].values
len(text_to_search)
ผลลัพธ์ที่ได้จะมีลักษณะดังนี้
มาวิเคราะห์โค้ดกัน
เช่นเดียวกับฟังก์ชันจากขั้นตอนก่อนหน้า เราจะเริ่มต้นตัวแปรคำถามด้วยสิ่งที่เราต้องการถามฐานข้อมูลก่อน
question='How do you shift gears in the Google car?'
จากนั้นในตัวแปรโมเดล เราจะตั้งค่าโมเดลที่ต้องการใช้ผ่านฟังก์ชัน TextEmbeddingModel.from_pretrained ซึ่งในกรณีนี้คือโมเดล gecko@003
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
ในตัวแปรการฝัง เราจะเรียกใช้ฟังก์ชัน model.get_embeddings และส่งข้อความที่จะแปลงเป็นเวกเตอร์ ในกรณีนี้ เราจะส่งคำถามที่จะถาม
embeddings = model.get_embeddings([(question)])
สุดท้าย ตัวแปร text_to_search จะเก็บรายการเวกเตอร์ที่แปลจากคำถาม
เราพิมพ์ความยาวของเวกเตอร์เพื่อเป็นข้อมูลอ้างอิง
text_to_search=embeddings[0].values
len(text_to_search)
7. การเปรียบเทียบเวกเตอร์
ตอนนี้เรามีรายการเวกเตอร์ในฐานข้อมูลจำลองและคำถามที่แปลงเป็นเวกเตอร์แล้ว ตอนนี้เราสามารถเปรียบเทียบเวกเตอร์ของคำถามกับเวกเตอร์ทั้งหมดในฐานข้อมูลเพื่อดูว่าเวกเตอร์ใดใกล้เคียงที่สุดที่จะตอบคำถามของเราได้อย่างแม่นยำยิ่งขึ้น
เราจะวัดระยะห่างระหว่างเวกเตอร์ของคำถามกับเวกเตอร์แต่ละรายการในฐานข้อมูล เทคนิคการวัดระยะห่างระหว่างเวกเตอร์มีอยู่หลายวิธี สำหรับ Codelab นี้ เราจะใช้ระยะทางแบบยุคลิดหรือ L2 Norm
ใน Python เราสามารถใช้ฟังก์ชัน Numpy เพื่อดำเนินการนี้ได้
คัดลอกและวางโค้ดด้านล่างลงในเซลล์ใหม่
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')
ผลลัพธ์ควรมีลักษณะดังนี้
มาวิเคราะห์โค้ดกัน
เราเริ่มต้นด้วยการแปลงคอลัมน์ที่เก็บข้อความที่ฝังหรือเวกเตอร์ของฐานข้อมูลเป็นรายการ แล้วจัดเก็บไว้ใน list_embedded_text_from_db
นอกจากนี้ เรายังเริ่มต้นตัวแปร shortest_distance เป็น 1 เพื่ออัปเดตต่อไปจนกว่าจะพบระยะทางที่สั้นที่สุดจริง
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
จากนั้นใช้ลูป for เพื่อวนซ้ำและหาระยะห่างระหว่างเวกเตอร์จากคำถามกับเวกเตอร์แต่ละรายการในฐานข้อมูล
เราใช้ฟังก์ชัน linalg.norm ของ numpy เพื่อคำนวณระยะทางของเวกเตอร์
หากระยะทางที่คำนวณได้น้อยกว่าระยะทางในตัวแปร shortest_distance ระบบจะตั้งค่าตัวแปรนี้เป็นระยะทางที่คำนวณได้
จากนั้นเราจะบันทึกระยะทางที่สั้นที่สุด รวมถึงตำแหน่งในรายการที่พบ ในตัวแปร shortest_distance และ shortest_position
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
8. ผลลัพธ์
เมื่อทราบตำแหน่งในรายการเวกเตอร์ที่มีระยะทางสั้นที่สุดระหว่างคำถามกับฐานข้อมูล เราจะพิมพ์ผลลัพธ์ได้
คัดลอกและวางโค้ดด้านล่างในเซลล์ใหม่
print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
df_embedded_values_db.at[shortest_position, 'Title']+": "+
df_embedded_values_db.at[shortest_position, 'Text'])
หลังจากเรียกใช้แล้ว คุณจะได้รับผลลัพธ์คล้ายกับตัวอย่างต่อไปนี้
9. ขอแสดงความยินดี
ยินดีด้วย คุณสร้างแอปพลิเคชันแรกโดยใช้โมเดล textembedding-gecko@003 ใน Use Case จริงได้สำเร็จแล้ว
คุณได้เรียนรู้พื้นฐานของการฝังข้อความและวิธีใช้โมเดล gecko003 ใน GCP Workbench
ตอนนี้คุณทราบขั้นตอนสำคัญที่จำเป็นในการนำความรู้ไปใช้กับกรณีการใช้งานอื่นๆ แล้ว
สิ่งต่อไปที่ควรทำ
ลองใช้ Codelab เหล่านี้