เกี่ยวกับ Codelab นี้
1 บทนำ
อัปเดตล่าสุด:08-04-2024
การฝังข้อความ
การฝังข้อความหมายถึงกระบวนการเปลี่ยนรูปแบบข้อมูลข้อความเป็นการนำเสนอที่เป็นตัวเลข การนําเสนอตัวเลขเหล่านี้ ซึ่งมักจะเป็นเวกเตอร์ จะจับความหมายเชิงอรรถศาสตร์และความสัมพันธ์ระหว่างคําในข้อความ ลองจินตนาการว่า
ข้อความเป็นเหมือนภาษาที่ซับซ้อน เต็มไปด้วยความแตกต่างและกำกวม
ข้อความที่ฝังจะแปลข้อความนั้นให้เป็นรูปแบบทางคณิตศาสตร์ที่ง่ายยิ่งขึ้น ซึ่งคอมพิวเตอร์สามารถเข้าใจและควบคุมได้
ประโยชน์ของการฝังข้อความ
- ช่วยให้ประมวลผลได้อย่างมีประสิทธิภาพ: คอมพิวเตอร์จะประมวลผลตัวเลขได้เร็วกว่าข้อความดิบมาก วิธีนี้สำคัญอย่างยิ่งสำหรับงานต่างๆ เช่น เครื่องมือค้นหา ระบบการแนะนำ และการแปลด้วยคอมพิวเตอร์
- จับความหมายในเชิงความหมาย: การฝังทำได้มากกว่าแค่ความหมายตรงตัวของคำ โดยจะอธิบายบริบทและความสัมพันธ์ระหว่างคำต่างๆ ทำให้สามารถวิเคราะห์ได้ละเอียดขึ้น
- ปรับปรุงประสิทธิภาพของแมชชีนเลิร์นนิง: การฝังข้อความสามารถใช้เป็นฟีเจอร์ในโมเดลแมชชีนเลิร์นนิง ส่งผลให้งานต่างๆ เช่น การวิเคราะห์ความเห็น การแยกประเภทข้อความ และการประมาณหัวข้อมีประสิทธิภาพดีขึ้น
Use Case ของการฝังข้อความ
การฝังข้อความด้วยการเปลี่ยนรูปแบบข้อความเป็นข้อความตัวเลข จะปลดล็อกแอปพลิเคชันที่หลากหลายในการประมวลผลภาษาธรรมชาติ (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, ส่วนสมุดบันทึก แล้วคลิกที่ Workbench
- ไปที่อินสแตนซ์
- คลิกสร้างใหม่
- ในกล่องโต้ตอบสร้างอินสแตนซ์ ให้ระบุข้อมูลต่อไปนี้สำหรับอินสแตนซ์ใหม่ในส่วน "รายละเอียด"
ชื่อ: ระบุชื่ออินสแตนซ์ใหม่ ชื่อต้องขึ้นต้นด้วยตัวอักษร ตามด้วยตัวอักษรพิมพ์เล็ก ตัวเลข หรือขีดกลาง (-) รวมกันไม่เกิน 62 อักขระ และไม่สามารถลงท้ายด้วยขีดกลาง
ภูมิภาคและโซน: เลือกภูมิภาคและโซนสำหรับอินสแตนซ์ใหม่ เลือกภูมิภาคที่อยู่ใกล้กับคุณที่สุดตามภูมิศาสตร์เพื่อให้เครือข่ายทำงานได้ดีที่สุด
ไม่ต้องติดตั้ง GPU
ในส่วน "การทํางานร่วมกัน" ให้ระบุข้อมูลต่อไปนี้
เครือข่าย: ปรับตัวเลือกเครือข่ายเพื่อใช้เครือข่ายในโปรเจ็กต์ปัจจุบันหรือเครือข่าย VPC ที่แชร์จากโปรเจ็กต์โฮสต์ หากมีการกําหนดค่าไว้ หากคุณใช้ VPC ที่แชร์ในโปรเจ็กต์โฮสต์ คุณต้องมอบบทบาทผู้ใช้เครือข่าย Compute (roles/compute.networkUser) ให้กับตัวแทนบริการ Notebooks จากโปรเจ็กต์บริการด้วย
ในช่องเครือข่าย: เลือกเครือข่ายที่ต้องการ คุณเลือกเครือข่าย VPC ได้ ตราบใดที่เครือข่ายเปิดใช้การเข้าถึง Google แบบส่วนตัวหรือเข้าถึงอินเทอร์เน็ตได้
ในช่องเครือข่ายย่อย: เลือกเครือข่ายย่อยที่ต้องการ คุณเลือกค่าเริ่มต้นได้
ในพร็อพเพอร์ตี้อินสแตนซ์ คุณใช้ค่าเริ่มต้นได้ ซึ่งก็คือ e2-standard-4
- คลิกสร้าง
Vertex AI Workbench จะสร้างอินสแตนซ์และเริ่มอินสแตนซ์นั้นโดยอัตโนมัติ เมื่ออินสแตนซ์พร้อมใช้งาน Vertex AI Workbench จะเปิดใช้งานลิงก์ Open JupyterLab คลิกที่ไอคอน
สร้างสมุดบันทึก Python 3
- ใน Jupyterlab จาก Launcher ให้คลิกที่ไอคอนที่มีโลโก้ Python ที่เขียนว่า Python3
- สมุดบันทึก Jupyter สร้างขึ้นโดยใช้ชื่อ Untitled และส่วนขยาย ipynb
- คุณสามารถเปลี่ยนชื่อได้โดยใช้ส่วนเบราว์เซอร์ไฟล์ทางด้านซ้าย หรือจะปล่อยไว้ตามเดิมก็ได้
ทีนี้เราก็เริ่มวางโค้ดลงในสมุดบันทึกได้แล้ว
3 กำลังนำเข้าไลบรารีที่จำเป็น
เมื่อสร้างอินสแตนซ์และเปิด Jupyterlab แล้ว เราจำเป็นต้องติดตั้งไลบรารีที่จำเป็นทั้งหมดสำหรับ Codelab
โดยเราจะต้องใช้ข้อมูลต่อไปนี้
- หมายเลข
- แพนด้า
- 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 ซึ่งจะรับข้อมูลเป็น DataFrame ของ Pandas ที่มีข้อความสําหรับทำการฝัง จากนั้นฟังก์ชันจะแสดงผลข้อความที่เข้ารหัสเป็นเวกเตอร์
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 เป็นที่ที่เราจัดเก็บและเพิ่มข้อความที่เข้ารหัสของทุกแถวต่อท้าย
ด้วยการใช้วิธีการทำซ้ำจาก Pandas เราสามารถทำซ้ำทุกแถวใน DataFrame เพื่อหาค่าจากคอลัมน์ Text (ซึ่งมีข้อมูลที่กำหนดเองจากฐานข้อมูลจำลองของเรา)
หากต้องการส่งข้อความปกติและแสดงผลเวกเตอร์โดยใช้โมเดล gecko@003 เราจะเริ่มต้นตัวแปรโมเดลซึ่งเป็นที่ที่เราตั้งค่าโมเดลที่จะใช้โดยการเรียกใช้ฟังก์ชัน TextEmbeddingModel.from_pretrained
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
จากนั้น ในการฝังตัวแปร เราจะจับเวกเตอร์ของข้อความที่เราส่งผ่านฟังก์ชัน model.get_embeddings
ในตอนท้ายของฟังก์ชัน เราจะสร้างคอลัมน์ใหม่ในเฟรมข้อมูลชื่อว่า "ข้อความที่ฝัง" ซึ่งจะมีรายการเวกเตอร์ที่สร้างขึ้นตามโมเดล gecko@003
df_input['Embedded text'] = list_embedded_values
return df_input
สุดท้าย ในตัวแปร df_embedded_values_db เราจะจับภาพเฟรมข้อมูลที่มีข้อมูลเดิมของเราจากฐานข้อมูลจำลอง พร้อมด้วยคอลัมน์ใหม่ที่มีรายการเวกเตอร์สำหรับแต่ละแถว
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")
ในตัวแปร embeddings เราจะเรียกใช้ฟังก์ชัน model.get_embeddings และส่งข้อความที่จะแปลงเป็นเวกเตอร์ ซึ่งในกรณีนี้เราจะส่งคำถามที่จะถาม
embeddings = model.get_embeddings([(question)])
สุดท้ายตัวแปร text_to_search จะเก็บรายการเวกเตอร์ที่แปลมาจากคําถาม
เราพิมพ์ความยาวของเวกเตอร์ไว้เพื่อเป็นข้อมูลอ้างอิงเท่านั้น
text_to_search=embeddings[0].values
len(text_to_search)
7 การเปรียบเทียบเวกเตอร์
ตอนนี้เรามีรายการเวกเตอร์ในฐานข้อมูลที่จําลองและคำถามที่เปลี่ยนรูปแบบเป็นเวกเตอร์แล้ว กล่าวคือ ตอนนี้เราสามารถเปรียบเทียบเวกเตอร์ของคำถามกับเวกเตอร์ทั้งหมดในฐานข้อมูลของเราเพื่อดูว่าเวกเตอร์ใดตอบคำถามของเราได้แม่นยำที่สุด
โดยเราจะวัดระยะทางระหว่างเวกเตอร์ของคำถามกับเวกเตอร์แต่ละรายการของฐานข้อมูล การวัดระยะทางระหว่างเวกเตอร์มีหลายเทคนิค แต่สำหรับโค้ดแล็บนี้ เราจะใช้ระยะทางแบบยูคลิดหรือ L2
ใน 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 Loop ในการทำซ้ำและหาระยะห่างระหว่างเวกเตอร์จากคำถามและเวกเตอร์แต่ละรายการบนฐานข้อมูล
เราคำนวณระยะทางโดยใช้ฟังก์ชัน numpy linalg.norm
หากระยะทางที่คำนวณได้น้อยกว่าระยะทางในตัวแปร 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 เหล่านี้...