AWS Thai Blog

การใช้ Generative AI และสถาปัตยกรรมข้อมูลสมัยใหม่ เพื่อปลดล็อคข้อมูลเชิงลึก

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

บทความนี้แปลจาก Reinventing the data experience: Use generative AI and modern data architecture to unlock insights โดยคุณ Navneet Tuteja และคุณ Sovik Nath

ความสามารถทางภาษาเหล่านี้จะให้ผู้ใช้ที่ไม่มีพื้นฐาน สามารถตามหาข้อมูลผ่านบทสนทนาภาษาอังกฤษได้ แทนที่จะต้องใช้ SQL ที่ค่อนข้างซับซ้อน แต่ว่าการที่จะใช้แล้วได้รับผลประโยชน์เต็มที่นั้น ก็มีความท้าทายของมันด้วยเช่นเดียวกัน  AI และ Language Model จำเป็นที่จะต้องแยกแยะแหล่งข้อมูลที่เหมาะสม สร้าง SQL query ที่มีประสิทธิภาพ และสร้างการตอบสนองที่สอดคล้องกับผลลัพธ์ที่ใส่ไว้ และนอกจากนั้น มันก็จำเป็นที่จะต้องมีส่วนต่อประสานกับผู้ใช้ (User interface) สำหรับการหาข้อมูลผ่านบทสนทนาด้วยเช่นเดียวกัน

โดยรวม การนำสถาปัตยกรรมข้อมูลสมัยใหม่และเทคนิค Generative AI ที่มี AWS มาใช้ ถือว่าเป็นแนวทางที่มีแนวโน้มที่น่าเชื่อถือ สำหรับการเก็บตกและเผยแพร่ข้อมูลเชิงลึกจากข้อมูลที่หลากหลายและกว้างขวางในระดับองค์กร  และข้อเสนอล่าสุดสำหรับ Generative AI จาก AWS ก็คือ Amazon Bedrock ซึ่งก็คือบริการที่ได้รับการจัดการและบริหาร Foundation Model อย่างเต็มที่ และยังสามารถเป็นวิธีที่ง่ายที่สุดที่จะสร้างและวางระบบแอพพลิเคชั่น Generative AI ที่มีโมเดลเป็นแบบแผนอยู่แล้ว นอกจากนี้แล้ว AWS ก็ยังเสนอโมเดลแบบแผนผ่านจุดสิ้นสุดต่างๆของ Amazon SageMaker เช่น Amazon SageMaker JumpStart  การผสมผสานระหว่าง Large Language Models (LLMs) ความสะดวกของการนำคุณสมบัติต่างๆของ Amazon Bedrock มาใช้ รวมไปถึงโครงสร้างพื้นฐานข้อมูลเชิงโดเมนที่ปรับขนาดได้ ทำให้แนวทางนี้ถือว่าเป็นแนวทางที่ฉลาด ที่จะใช้ประโยชน์จากข้อมูลที่มีอยู่มากมายในฐานข้อมูลต่างๆ และ Data Lakes

ในโพสต์นี้ เรานำเสนอกรณีศึกษาที่บริษัทบริษัทหนึ่งได้นำสถาปัตยกรรมข้อมูลสมัยใหม่มาใช้ โดยมีข้อมูลอยู่ในหลายๆฐานข้อมูลและ APIs เช่น ข้อมูลทางกฏหมายอยู่ใน Amazon Simple Storage Service (Amazon S3) ข้อมูลทางทรัพยากรมนุษย์อยู่ใน Amazon Relational Database Service (Amazon RDS) ข้อมูลการขายและการตลาดอยู่ใน Amazon Redshift ข้อมูลตลาดการเงินอยู่ใน Snowflake (บริการจัดเก็บข้อมูลโซลูชั่น Third-Party) และ ข้อมูลผลิตภัณฑ์จัดว่าเป็น API  การดำเนินงานแบบนี้ มีจุดมุ่งหมายเพื่อเพิ่มประสิทธิภาพการทำงานของการวิเคราะห์ธุรกิจขององค์กร เจ้าของผลิตภัณฑ์ และผู้เชี่ยวชาญด้านโดเมนธุรกิจ  โดยสิ่งต่างๆเหล่านี้สามารถประสบความสำเร็จได้ด้วยการใช้ Generative AI ในสถาปัตยกรรม Domain Mesh ซึ่งทำให้บริษัทนั้นบรรลุวัตถุประสงค์ทางธุรกิจได้อย่างมีประสิทธิภาพยิ่งขึ้น  นอกจากนี้ โซลูชั่นนี้ก็มีทางเลือกที่จะเพิ่ม LLMs จาก JumpStart มาเป็นจุดสิ้นสุดของ SageMaker ได้ และสามารถเพิ่มโมเดลจาก Third-Party ได้อีกเช่นเดียวกัน เราเตรียมพร้อมสื่อกลางในการถามคำถามที่มีพื้นฐานจากข้อเท็จจริง (Fact-based question) ให้กับผู้ใช้ระดับองค์กร โดยไม่ต้องมีความรู้พื้นฐานเกี่ยวกับช่องข้อมูล ดังนั้นจึงถือว่าเป็นการสรุปความซับซ้อนของการเขียน SQL query แบบง่ายไปจนถึงแบบยาก

ภาพรวมของโซลูชั่น

สถาปัตยกรรมข้อมูลสมัยใหม่ใน AWS นำปัญญาประดิษฐ์และภาษาที่เข้าใจง่ายมาใช้ เพื่อประมวลผลในการ query ฐานข้อมูลการวิเคราะห์หลายรายการ โดยการนำบริการอย่าง Amazon Redshift, Amazon RDS, Snowflake, Amazon Athena, และ AWS Glue มาใช้ เราจะสร้างโซลูชั่นที่ปรับขนาดได้ และรวบรวมข้อมูลจากฐานข้อมูลต่างๆได้เช่นเดียวกัน การใช้ LangChain (Library ประสิทธิภาพสูงสำหรับการทำงานกับ LLMs) รวมถึงโมเดลแบบแผนจาก Amazon Bedrock และ JumpStart ใน Amazon SageMaker Studio notebooks เราสามารถที่จะสร้างระบบที่ผู้ใช้สามารถถามคำถามธุรกิจในภาษาอังกฤษที่เข้าใจง่าย และได้รับคำตอบจากข้อมูลที่ดึงมาจากฐานข้อมูลที่เกี่ยวข้องได้

แผนภาพต่อไปนี้จะแสดงให้เห็นถึงสถาปัตยกรรม

สถาปัตยกรรมไฮบริดนี้ใช้หลากหลายฐานข้อมูลและ LLMs โดยมีแบบแผนจาก Amazon Bedrock และ JumpStart สำหรับการระบุแหล่งข้อมูล การสร้าง SQL และการสร้างข้อความและผลลัพท์

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

ขั้นตอนมีดังนี้

  1. ผู้ใช้ธุรกิจเตรียมคำถามเป็นภาษาอังกฤษ
  2. Crawler จาก AWS Glue จะถูกกำหนดให้ถูกเรียกใช้งานเป็นระยะๆ เพื่อดึงเมตาดาต้าจากฐานข้อมูล และสร้างคำจำกัดความของตารางใน AWS Glue Data Catalog
    และ Data Catalog ก็จะป้อนเข้าไปใน Chain Sequence 1 (ดูแผนภาพก่อนหน้า)
  3. LangChain (เครื่องมือสำหรับการทำงานกับ LLMs และ พรอมต์) จะถูกใช้ใน Studio notebooks  โดย LangChain จำเป็นต้องใช้ LLM เพื่อที่จะถูกกำหนดได้
    และในส่วนหนึ่งของ Chain Sequence 1 พรอมต์และ Data Catalog เมตาดาต้าจะถูกส่งไปสู่ LLM โดยจัดตั้งอยู่ในจุดสิ้นสุดของ SageMaker สำหรับการแยกแยะฐานข้อมูลที่เกี่ยวข้องและตารางโดยใช้ LangChain
  4. พรอมต์และฐานข้อมูลที่ถูกระบุแล้วจะถูกส่งต่อไปสู่ Chain Sequence 2
  5. LangChain ก่อตั้งการเชื่อมต่อกับฐานข้อมูลและเรียกใช้ SQL query เพื่อได้รับผลลัพท์
  6. ผลลัพท์ถูกส่งต่อไปสู้ LLM เพื่อสร้างคำตอบในภาษาอังกฤษพร้อมกับข้อมูล
  7. ผู้ใช้ได้รับคำตอบภาษาอังกฤษที่ตรงกับพรอมต์ของตน โดยข้อมูลเหล่านี้ก็จะมาจากหลากหลายฐานข้อมูล

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

ข้อกำหนดเบื้องต้น

คุณสามารถใช้ฐานข้อมูลไหนก็ได้ที่รองรับ SQLAlchemy เพื่อที่จะสร้างคำตอบจาก LLMs และ LangChain แต่อย่างไรก็ตาม ฐานข้อมูลเหล่านี้จะต้องมีเมตาดาต้าที่ลงทะเบียนไว้กับ AWS Glue Data Catalog และนอกจากนี้ คุณก็จำเป็นที่จะต้องเข้าถึง LLMs ได้เช่นเดียวกัน ไม่ว่าจะผ่านทาง JumpStart หรือ API Keys ก็ตาม

การเชื่อมต่อเข้าสู่ฐานข้อมูลโดยใช้ SQLAlchemy

โดยตามปกตินั้น LangChain จะใช้ SQLAlchemy ในการเชื่อมต่อเข้าสู่ฐานข้อมูลของ SQL  ทางเราใช้ฟังค์ชั่น SQLDatabase ของ LangChain โดยสร้างเอนจิ้นและการเชื่อมต่อสำหรับแต่ละฐานข้อมูล ในลำดับต่อไปจะเป็นตัวอย่างของการเชื่อมต่อกับ Amazon Aurora MySQL-Compatible Edition ซึ่งเป็นฐานข้อมูลแบบไร้เซิร์ฟเวอร์และรวมเฉพาะตารางพนักงาน:

#connect to AWS Aurora MySQL
cluster_arn = <cluster_arn>
secret_arn = <secret_arn>
engine_rds=create_engine('mysql+auroradataapi://:@/employees',echo=True,
  connect_args=dict(aurora_cluster_arn=cluster_arn, secret_arn=secret_arn))
dbrds = SQLDatabase(engine_rds, include_tables=['employees'])

ต่อไป เราจะสร้างพรอมต์ที่จะใช้โดย Chain Sequence 1 เพื่อจำแนกฐานข้อมูลและชื่อของตารางที่จะขึ้นอยู่กับคำถามของผู้ใช้

การสร้างเทมเพลตพรอมต์แบบไดนามิก

เราจะใช้ AWS Glue Data Catalog (ซึ่งถูกดีไซน์มาสำหรับการจัดเก็บและควบคุมข้อมูลเมต้าดาต้า) เพื่อระบุแหล่งที่มาของข้อมูล สำหรับการ query จากผู้ใช้และการสร้างพร้อมท์สำหรับ Chain Sequence 1 ตามรายละเอียดในขั้นตอนต่อไปนี้:

เราสร้าง Data Catalog โดยรวบรวมข้อมูลผ่านเมตาดาต้าจากหลากหลายฐานข้อมูล จากการใช้ JDBC Connection ที่ได้ใช้ไปในการสาธิตเบื้องต้น
โดยใช้ Boto3 library เราสร้างมุมมองแบบรวมของ Data Catalog จากหลากหลายฐานข้อมูล ในลำดับต่อจะเป็นตัวอย่างวิธีการรับเมตาดาต้าของตารางพนักงานจาก Data Catalog สำหรับฐานข้อมูล Aurora MySQL database:

 #retrieve metadata from glue data catalog
  glue_tables_rds = glue_client.get_tables(DatabaseName=<database_name>, MaxResults=1000)
    for table in glue_tables_rds['TableList']:
        for column in table['StorageDescriptor']['Columns']:
             columns_str=columns_str+'\n'+('rdsmysql|employees|'+table['Name']+"|"+column['Name'])

ในส่วนของ Data Catalog ที่ถูกรวบรวมแล้วจะมีรายละเอียดที่เกี่ยวกับแหล่งข้อมูล เช่น แผนผัง ชื่อตาราง และชื่อคอลัมน์  ลำดับต่อจากนี้จะเป็นตัวอย่างเอาท์พุตของ Data Catalog ที่รวบรวมแล้ว:

database|schema|table|column_names
redshift|tickit|tickit_sales|listid
rdsmysql|employees|employees|emp_no
....
s3|none|claims|policy_id

เราจะส่ง Data Catalog ที่รวบรวมแล้วไปยังเทมเพลตพรอมต์และกำหนดพรอมต์ที่ถูกใช้โดย LangChain

prompt_template = """
From the table below, find the database (in column database) which will contain the data (in corresponding column_names) to answer the question {query} \n
"""+glue_catalog +""" Give your answer as database == \n Also,give your answer as database.table =="""

Chain Sequence 1: การตรวจหาที่มาของเมตาดาต้าสำหรับ query ของผู้ใช้ โดยใช้ LangChain และ LLM

เราจะส่งเทมเพลตพรอมต์ที่ถูกสร้างขึ้นมาจากขั้นตอนเบื้องต้นไปสู่พรอมต์ พร้อมกับ query จากผู้ใช้ไปสู่โมเดลของ LangChain เพื่อที่จะหาแหล่งข้อมูลที่ดีที่สุดมาตอบคำถามจากผู้ใช้ LangChain จะใช้โมเดล LLM ที่เราเลือกเพื่อตรวจหาเมตาดาต้าของแหล่งที่มา

คุณสามารถใช้โค้ดต่อไปนี้เพื่อใช้ LLM จาก JumpStart หรือโมเดลจาก third-party ได้

#define your LLM model here
llm = <LLM>
#pass prompt template and user query to the prompt
PROMPT = PromptTemplate(template=prompt_template, input_variables=["query"])
# define llm chain
llm_chain = LLMChain(prompt=PROMPT, llm=llm)
#run the query and save to generated texts
generated_texts = llm_chain.run(query)

และข้อความที่ถูกสร้างขึ้นมาจะมีข้อมูลต่างๆเช่น ฐานข้อมูล หรือชื่อตารางที่ใช้เรียก query ของผู้ใช้

โดยยกตัวอย่างเช่น สำหรับ query ของผู้ใช้ที่ถามถึง “พนักงานที่มีเดือนเกิดเป็นเดือนนี้” (“Name all employees with birth date this month”)

generated_text จะมีข้อมูล database == rdsmysql กับ database.table == rdsmysql.employees.

ต่อไป เราจะส่งข้อมูลต่างๆของโดเมนทรัพยากรมนุษย์ (ฐานข้อมูล Aurora MySQL) และตารางพนักงานไปสู่ Chain Sequence 2

Chain Sequence 2: การดึงการตอบสนองจากแหล่งข้อมูลเพื่อตอบ query ของผู้ใช้

ถัดจากนี้เราจะใช้ SQL Database Chain จาก LangChain เพื่อแปลงจากข้อความเป็น SQL และเรียกใช้ SQL ที่สร้างขึ้นกับฐานข้อมูล เพื่อดึงผลลัพธ์ของฐานข้อมูลออกมาเป็นภาษาที่อ่านง่าย

เราจะเริ่มจากการระบุเทมเพลตพรอมต์ที่จะสั่ง LLM มาสร้าง SQL ที่ถูกต้องตามหลักภาษาขึ้น และรันกับฐานข้อมูล:

DEFAULT_TEMPLATE = """Given an input question, first create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.

Only use the following tables:

{table_info}

If someone asks for the sales, they really mean the tickit.sales table.

Question: {input}"""

#define the prompt

PROMPT = PromptTemplate( input_variables=["input", "table_info", "dialect"], template=_DEFAULT_TEMPLATE)

และสุดท้ายนี้ เราจะส่ง LLM (1) การเชื่อมต่อกับฐานข้อมูล (2) และพรอมต์ (3) ไปสู่ SQL Database Chain และรัน Query ของ SQL:

db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=PROMPT)
response=db_chain.run(query)

ยกตัวอย่างเช่น สำหรับ Query ของผู้ใช้ที่ถามถึง “พนักงานที่มีเดือนเกิดเป็นเดือนนี้” (“Name all employees with birth date this month”) คำตอบจะเป็นดังนี้

Question: Name all employees with birth date this month

SELECT * FROM employees WHERE MONTH(birth_date) = MONTH(CURRENT_DATE());

User Response:
The employees with birthdays this month are:
Christian Koblick
Tzvetan Zielinski

คลีน Resource

หลังจากคุณรันสถาปัตยกรรมข้อมูลนี้กับ Generative AI เรียบร้อยแล้ว อย่าลืมที่จะทำความสะอาดหรือจัดการทรัพยากรที่จะไม่ถูกนำมาใช้  ปิดและลบฐานข้อมูลต่างๆที่นำมาใช้ (Amazon Redshift, Amazon RDS, Snowflake)  โดยนอกจากนั้น คุณควรลบข้อมูลต่างๆใน Amazon S3 และหยุดการใช้งานของ Studio notebook เพื่อไม่ให้มีการเปลี่ยนแปลงเพิ่มเติมนอกจากที่ต้องการ  ถ้าหากว่าคุณใช้ JumpStart ในการ deploy LLM มาเป็นจุดสิ้นสุดของ SageMaker คุณก็ควรลบจุดสิ้นสุดนั้นผ่านคอนโซลของ SageMaker หรือ Studio ด้วยเช่นเดียวกัน

บทสรุป

ในโพสต์นี้ เราได้นำสถาปัตยกรรมข้อมูลสมัยใหม่มาใช้งานพร้อมกับ Generative AI และ LLMs ใน SageMaker  โซลูชั่นนี้ได้ใช้หลากหลายโมเดลเเบบหรือพื้นฐานที่เป็น Text-to-text จาก JumpStart และหลากหลายโมเดลจาก Third-Party อีกเช่นเดียวกัน  แนวทางไฮบริดนี้ได้ระบุแหล่งข้อมูล เขียน queries SQL และสร้างการตอบสนองกับผลลัพธ์ query  แนวทางนี้ได้ใช้ Amazon Redshift, Amazon RDS, Snowflake, และ LLMs  เพื่อพัฒนาโซลูชั่นนี้ คุณสามารถเพิ่มฐานข้อมูลเพิ่มเติม (1) UI สำหรับ Query ภาษาอังกฤษ (2) วิศวะกรรมสำหรับพรอมต์ (Prompt Engineering) (3) และเครื่องมือทางข้อมูล (4)  แนวทางนี้สามารถกลายเป็นวิธีที่ฉลาดที่จะได้รับข้อมูลเชิงลึกจากหลากหลายที่เก็บข้อมูลได้  หากว่าคุณต้องการที่จะเจาะลึกลงไปในโซลูชั่นและโค้ดที่กล่าวถึงในโพสต์นี้ สามารถหาข้อมูลเพิ่มเติมได้ใน GitHub repo  นอกจากนั้นคุณสามารถไปดู Amazon Bedrock เพิ่มเติมได้สำหรับกรณีศึกษาใน Generative AI โมเดลแบบแผน และ LLM