สร้างเครื่องมือสร้างแบบทดสอบด้วย GenAI และ Cloud Run

1. บทนำ

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

สิ่งที่คุณต้องทำ...

คุณจะสร้างพรอมต์ที่สร้างแบบทดสอบความรู้รอบตัวตามชุดเกณฑ์
คุณจะสร้างเว็บแอปอย่างง่ายและยืนยันว่าแอปทำงานได้ตามที่คาดไว้ในสภาพแวดล้อมการพัฒนา
คุณจะค่อยๆ เพิ่มตรรกะลงในเว็บแอปเพื่อเปลี่ยนให้เป็นเซิร์ฟเวอร์ API ที่สร้างแบบทดสอบตามชุดพารามิเตอร์อินพุต
คุณจะเห็นว่าการทําให้บริการสร้างแบบทดสอบใช้งานได้ในระบบคลาวด์โดยใช้ Google Cloud Run นั้นง่ายเพียงใด
สุดท้าย คุณจะกำหนดค่าแอปจริง ( quizaic.com) ให้ใช้บริการเครื่องมือสร้างแบบทดสอบที่ติดตั้งใช้งาน และจะเล่นแบบทดสอบสดตามเอาต์พุตได้

สิ่งที่คุณจะได้เรียนรู้...

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

สิ่งที่คุณต้องมี...

เว็บเบราว์เซอร์ Chrome
บัญชี Google
โปรเจ็กต์ Cloud ที่เปิดใช้การเรียกเก็บเงิน

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

2. ตั้งค่า

ส่วนนี้จะครอบคลุมทุกอย่างที่คุณต้องทำเพื่อเริ่มต้นใช้งานแล็บนี้

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

ลงชื่อเข้าใช้ Google Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ คุณอัปเดตได้ทุกเมื่อ
รหัสโปรเจ็กต์จะไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมดและเปลี่ยนแปลงไม่ได้ (เปลี่ยนไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งโดยปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นคืออะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยทั่วไปจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณอาจสร้างรหัสแบบสุ่มอีกรหัสหนึ่งได้ หรือคุณอาจลองใช้ชื่อของคุณเองและดูว่ามีชื่อนั้นหรือไม่ คุณจะเปลี่ยนแปลงรหัสนี้หลังจากขั้นตอนนี้ไม่ได้ และรหัสจะคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
โปรดทราบว่ายังมีค่าที่ 3 ซึ่งคือหมายเลขโปรเจ็กต์ที่ API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 นี้ได้ในเอกสารประกอบ

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของ Cloud การทำตาม Codelab นี้จะไม่มีค่าใช้จ่ายมากนัก หรืออาจไม่มีค่าใช้จ่ายเลย หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่ม Cloud Shell

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

เปิดใช้งาน Cloud Shell

จาก Cloud Console ให้คลิกเปิดใช้งาน Cloud Shell

หากคุณเริ่มใช้ Cloud Shell เป็นครั้งแรก คุณจะเห็นหน้าจอระดับกลางที่อธิบายว่า Cloud Shell คืออะไร หากเห็นหน้าจอระดับกลาง ให้คลิกต่อไป

การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน

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

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นว่าคุณได้รับการตรวจสอบสิทธิ์และระบบได้ตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์ของคุณ

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว

gcloud auth list

เอาต์พุตของคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

หมายเหตุ: gcloud เครื่องมือบรรทัดคำสั่งเป็นเครื่องมือบรรทัดคำสั่งที่มีประสิทธิภาพและเป็นหนึ่งเดียวใน Google Cloud โดยจะติดตั้งมาล่วงหน้าใน Cloud Shell คุณจะเห็นว่าเครื่องมือนี้รองรับการเติมข้อความอัตโนมัติด้วยการกด Tab ระบบอาจแจ้งให้คุณตรวจสอบสิทธิ์ในครั้งแรกที่เรียกใช้คำสั่ง ดูข้อมูลเพิ่มเติมได้ที่ภาพรวมเครื่องมือบรรทัดคำสั่ง gcloud

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

เอาต์พุตของคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่ได้ตั้งค่าไว้ คุณตั้งค่าได้ด้วยคำสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตของคำสั่ง

Updated property [core/project].

เปิดใช้ API บางรายการ

ในขั้นตอนต่อๆ ไป คุณจะเห็นว่าจำเป็นต้องใช้บริการเหล่านี้ที่ใด (และเพราะเหตุใด) แต่ตอนนี้ ให้เรียกใช้คำสั่งนี้เพื่อให้โปรเจ็กต์เข้าถึง Cloud Build, Artifact Registry, Vertex AI และ Cloud Run

gcloud services enable cloudbuild.googleapis.com        \
                       artifactregistry.googleapis.com  \
                       aiplatform.googleapis.com        \
                       run.googleapis.com

ซึ่งควรจะแสดงข้อความว่าสำเร็จคล้ายกับข้อความต่อไปนี้

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. การเขียนพรอมต์ - การเขียนโปรแกรมในภาษาธรรมชาติ

เราจะเริ่มจากการเรียนรู้วิธีพัฒนาพรอมต์สำหรับโมเดลภาษาขนาดใหญ่ ไปที่ Google Cloud Console > Vertex AI > Vertex AI Studio (ภาษา) คุณควรเห็นหน้าเว็บที่มีลักษณะดังนี้

ในส่วนGenerate Text ให้คลิกปุ่ม Text Prompt ในกล่องโต้ตอบถัดไป ให้ป้อนพรอมต์ที่คุณคิดว่าอาจมีประสิทธิภาพในการสร้างแบบทดสอบความรู้ตามข้อกำหนดต่อไปนี้

หัวข้อ: ประวัติศาสตร์โลก
จำนวนคำถาม: 5
ระดับความยาก: ปานกลาง
ภาษา: อังกฤษ

คลิกปุ่มส่งเพื่อดูเอาต์พุต

ดังที่แสดงในภาพหน้าจอต่อไปนี้ แผงด้านขวาช่วยให้คุณเลือกโมเดลที่ต้องการใช้และปรับแต่งการตั้งค่าบางอย่างได้

สามารถใช้การตั้งค่าต่อไปนี้ได้

ภูมิภาคคือตำแหน่งที่ควรเรียกใช้คำขอการสร้าง
โมเดลจะเลือกโมเดลภาษาขนาดใหญ่ที่คุณต้องการใช้ สำหรับ Codelab นี้ ให้ใช้ "gemini-1.0-pro-001"
อุณหภูมิจะควบคุมระดับความสุ่มในการเลือกโทเค็น อุณหภูมิที่ต่ำเหมาะสำหรับพรอมต์ที่คาดหวังคำตอบที่ถูกต้องหรือแม่นยำ ในขณะที่อุณหภูมิที่สูงอาจทำให้ได้ผลลัพธ์ที่หลากหลายหรือคาดไม่ถึงมากขึ้น
ขีดจำกัดโทเค็นจะกำหนดจำนวนข้อความสูงสุดที่เอาต์พุตจากพรอมต์เดียว โทเค็นมีความยาวประมาณ 4 อักขระ ค่าเริ่มต้นคือ 1024
Top-k จะเปลี่ยนวิธีที่โมเดลเลือกโทเค็นสำหรับเอาต์พุต ค่า top-k เป็น 1 หมายความว่าโทเค็นที่เลือกมีความน่าจะเป็นมากที่สุดในบรรดาโทเค็นทั้งหมดในคำศัพท์ของโมเดล (หรือที่เรียกว่าการถอดรหัสแบบตะกละ) ขณะที่ค่า top-k เป็น 3 หมายความว่าระบบจะเลือกโทเค็นถัดไปจากโทเค็นที่มีความน่าจะเป็นมากที่สุด 3 รายการ (โดยใช้ค่าอุณหภูมิ) ค่าเริ่มต้นของ top-k คือ 40
Top-p จะเปลี่ยนวิธีที่โมเดลเลือกโทเค็นสำหรับเอาต์พุต ระบบจะเลือกโทเค็นจากโทเค็นที่มีแนวโน้มมากที่สุดไปจนถึงน้อยที่สุดจนกว่าผลรวมของความน่าจะเป็นจะเท่ากับค่า top-p
คำตอบสูงสุดคือจำนวนคำตอบของโมเดลสูงสุดที่สร้างขึ้นต่อพรอมต์
ลำดับการหยุดคือชุดอักขระ (รวมถึงการเว้นวรรค) ที่หยุดการสร้างคำตอบหากโมเดลพบ
การสตรีมคำตอบจะเลือกว่าควรพิมพ์คำตอบเมื่อสร้างขึ้นหรือบันทึกไว้และแสดงเมื่อเสร็จสมบูรณ์
เกณฑ์ตัวกรองความปลอดภัยจะปรับความน่าจะเป็นที่คุณจะเห็นคำตอบที่อาจเป็นอันตราย

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

แบบทดสอบในแล็บนี้แสดงเป็นอาร์เรย์ของออบเจ็กต์ โดยแต่ละออบเจ็กต์จะมีคำถาม อาร์เรย์ของคำตอบที่เป็นไปได้สำหรับคำถามนั้น และคำตอบที่ถูกต้อง ต่อไปนี้คือการเข้ารหัส JSON สำหรับแบบทดสอบในแล็บนี้

[
    {
        "question": "Who was the first person to walk on the moon?",
          "responses": [
              "Neil Armstrong",
              "Buzz Aldrin",
              "Michael Collins",
              "Yuri Gagarin"
           ],
           "correct": "Neil Armstrong"
    },
    {
        "question": "What was the name of the war that took place between the British and the French in North America from 1754 to 1763??",
          "responses": [
              "The French and Indian War",
              "The Seven Years' War",
              "The War of the Austrian Succession",
              "The Great War"
           ],
           "correct": "The French and Indian War"
    },

    ...
]

ลองดูว่าคุณแก้ไขพรอมต์เพื่อส่งออกแบบทดสอบในรูปแบบ JSON ที่จำเป็นได้หรือไม่

ระบุรูปแบบที่แน่นอนที่คุณต้องการเป็นคำพูด (เช่น ประโยคที่ทำเป็นตัวเอียงด้านบน)
ใส่ตัวอย่างรูปแบบ JSON ที่ต้องการในพรอมต์

เมื่อได้พรอมต์ที่สร้างแบบทดสอบตามข้อกำหนดที่ต้องการแล้ว ให้คลิกปุ่ม GET CODE ที่มุมขวาบนของหน้าเพื่อดูโค้ด Python ที่ใช้ส่งพรอมต์ไปยัง LLM ของ Vertex AI โดยอัตโนมัติได้ หากสนใจใช้ภาษาโปรแกรมอื่นนอกเหนือจาก Python โปรดดู https://cloud.google.com/vertex-ai/docs/samples?text=generative

4. สร้างเว็บเซิร์ฟเวอร์แบบง่าย

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

เริ่มต้นโดยคลิกปุ่ม Open Editor ที่ด้านบนของแผง Cloud Shell โดยจะมีลักษณะดังนี้

จากนั้นคุณจะอยู่ในสภาพแวดล้อม IDE ที่คล้ายกับ Visual Studio Code ซึ่งคุณสามารถสร้างโปรเจ็กต์ แก้ไขซอร์สโค้ด เรียกใช้โปรแกรม ฯลฯ

หากหน้าจอแคบเกินไป คุณสามารถขยายหรือย่อเส้นแบ่งระหว่างคอนโซลกับหน้าต่างแก้ไข/เทอร์มินัลได้โดยการลากแถบแนวนอนระหว่าง 2 ภูมิภาคดังกล่าว ซึ่งไฮไลต์ไว้ที่นี่

คุณสามารถสลับไปมาระหว่างตัวแก้ไขกับเทอร์มินัลได้โดยคลิกปุ่ม Open Editor และ Open Terminal ตามลำดับ ตอนนี้ลองสลับไปมาระหว่าง 2 สภาพแวดล้อมนี้

จากนั้นสร้างโฟลเดอร์เพื่อจัดเก็บงานสำหรับแล็บนี้โดยคลิกปุ่มเพิ่มโฟลเดอร์ ป้อน quiz-generator แล้วกด Enter ไฟล์ทั้งหมดที่คุณสร้างในแล็บนี้และงานทั้งหมดที่คุณทำใน Cloud Shell จะอยู่ในโฟลเดอร์นี้

ตอนนี้ให้สร้างไฟล์ requirements.txt ซึ่งจะบอก Python ว่าแอปของคุณขึ้นอยู่กับไลบรารีใด สำหรับเว็บแอปแบบง่ายนี้ คุณจะต้องใช้โมดูล Python ยอดนิยมสำหรับสร้างเว็บเซิร์ฟเวอร์ที่เรียกว่าFlask,ไลบรารีของไคลเอ็นต์ google-cloud-aiplatform และเฟรมเวิร์กเว็บเซิร์ฟเวอร์ที่เรียกว่า gunicorn ในบานหน้าต่างการนำทางไฟล์ ให้คลิกขวาที่โฟลเดอร์ quiz-generator แล้วเลือกรายการเมนู New file ดังนี้

เมื่อระบบแจ้งให้ป้อนชื่อไฟล์ใหม่ ให้ป้อน requirements.txt แล้วกดปุ่ม Enter ตรวจสอบว่าไฟล์ใหม่อยู่ในquiz-generatorโฟลเดอร์โปรเจ็กต์

วางบรรทัดต่อไปนี้ในไฟล์ใหม่เพื่อระบุว่าแอปของคุณขึ้นอยู่กับแพ็กเกจ flask ของ Python, เว็บเซิร์ฟเวอร์ gunicorn และไลบรารีไคลเอ็นต์ google-cloud-aiplatform พร้อมกับเวอร์ชันที่เกี่ยวข้องของแต่ละรายการ

flask==3.0.0
gunicorn==21.2.0
google-cloud-aiplatform==1.47.0

คุณไม่จำเป็นต้องบันทึกไฟล์นี้อย่างชัดเจนเนื่องจาก Cloud Editor จะบันทึกการเปลี่ยนแปลงให้คุณโดยอัตโนมัติ

สร้างไฟล์ใหม่ขึ้นมาอีกไฟล์หนึ่งชื่อ main.py โดยใช้เทคนิคเดียวกัน ซึ่งจะเป็นไฟล์ต้นฉบับ Python หลัก (และไฟล์เดียว) ของแอป โปรดตรวจสอบอีกครั้งว่าไฟล์ใหม่จะอยู่ในโฟลเดอร์ quiz-generator

แทรกโค้ดต่อไปนี้ลงในไฟล์นี้

from flask import Flask
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

กลับไปที่เทอร์มินัลแล้วเปลี่ยนเป็นโฟลเดอร์โปรเจ็กต์ด้วยคำสั่งนี้

cd quiz-generator

เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งทรัพยากร Dependency ของโปรเจ็กต์

pip3 install -r requirements.txt

หลังจากติดตั้งการขึ้นต่อกันแล้ว คุณควรเห็นเอาต์พุตที่ลงท้ายด้วยข้อความต่อไปนี้

Successfully installed flask-3.0.0

ตอนนี้ให้เปิดแอปโดยเรียกใช้คำสั่งนี้ในเทอร์มินัล

flask --app main.py --debug run --port 8080

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

คลิกปุ่ม web preview แล้วคลิกรายการเมนู Preview on Port 8080 ดังนี้

ซึ่งจะเป็นการเปิดแท็บเว็บเบราว์เซอร์ไปยังแอปที่กําลังทํางานอยู่ ซึ่งควรมีลักษณะดังนี้

5. เพิ่มเมธอด generate พร้อมการแยกวิเคราะห์พารามิเตอร์

ตอนนี้เราต้องการเพิ่มการรองรับการใช้เมธอดใหม่ที่เรียกว่า generate โดยเพิ่มคำสั่งนำเข้าเพื่อจัดการคำขอ HTTP และแก้ไขเส้นทางหลักเพื่อแยกวิเคราะห์คำขอนี้และพิมพ์พารามิเตอร์ ดังนี้

from flask import Flask
from flask import request                       #<-CHANGED
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])                #<-CHANGED
def generate():                                 #<-CHANGED
    params = request.args.to_dict()             #<-CHANGED
    html = f"<h1>Quiz Generator</h1>"           #<-CHANGED
    for param in params:                        #<-CHANGED
        html += f"<br>{param}={params[param]}"  #<-CHANGED
    return html                                 #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

ตอนนี้ให้โหลดแท็บเว็บเบราว์เซอร์ที่มีอยู่ซ้ำเพื่อดูผลลัพธ์ คราวนี้คุณควรเห็น "เครื่องมือสร้างแบบทดสอบ" พร้อมกับพารามิเตอร์การค้นหาที่เพิ่มลงใน URL โดยอัตโนมัติ (authuser) ลองเพิ่มพารามิเตอร์อีก 2 รายการโดยต่อสตริง "`&param1=val1&param2=val2`" ที่ท้าย URL ในแถบที่อยู่ของเบราว์เซอร์ จากนั้นโหลดหน้าเว็บซ้ำ คุณควรเห็นข้อความคล้ายกับตัวอย่างต่อไปนี้

ตอนนี้เราได้เห็นวิธีส่งและแยกวิเคราะห์พารามิเตอร์การค้นหาใน URL แล้ว เราจะเพิ่มการรองรับพารามิเตอร์เฉพาะที่เราต้องการส่งไปยังเครื่องมือสร้างแบบทดสอบ ซึ่งมีดังนี้

topic - เนื้อหาแบบทดสอบที่ต้องการ
num_q - จำนวนคำถามที่ต้องการ
diff - ระดับความยากที่ต้องการ (ง่าย ปานกลาง ยาก)
lang - ภาษาของแบบทดสอบที่ต้องการ

from flask import Flask
from flask import request
import os

# Default quiz settings  #<-CHANGED
TOPIC = "History"        #<-CHANGED
NUM_Q = "5"              #<-CHANGED
DIFF = "intermediate"    #<-CHANGED
LANG = "English"         #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):  #<-CHANGED
    if name in args:             #<-CHANGED
        return args[name]        #<-CHANGED
    return default               #<-CHANGED

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()        #<-CHANGED
    topic = check(args, "topic", TOPIC)  #<-CHANGED
    num_q = check(args, "num_q", NUM_Q)  #<-CHANGED
    diff = check(args, "diff", DIFF)     #<-CHANGED
    lang = check(args, "lang", LANG)     #<-CHANGED
    html = f"""
        <h1>Quiz Generator</h1><br>
        {topic=}<br>
        {num_q=}<br>
        {diff=}<br>
        {lang=}"""                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

ตอนนี้ให้โหลดแท็บเว็บเบราว์เซอร์ที่มีอยู่ซ้ำเพื่อดูผลลัพธ์ คุณควรเห็นหน้าเว็บที่มีลักษณะคล้ายกับหน้าเว็บต่อไปนี้

ลองเปลี่ยน URL เพื่อตั้งค่าสำหรับพารามิเตอร์ต่างๆ เช่น ลองใช้คำต่อท้าย "?authuser=0&topic=Literature&num_q=10&diff=easy&lang=French" ที่ท้าย URL ในแถบที่อยู่

6. เพิ่มและจัดรูปแบบพรอมต์

จากนั้น เราจะเพิ่มการรองรับพารามิเตอร์ที่เฉพาะเจาะจงซึ่งเราต้องการส่งไปยังเครื่องมือสร้างแบบทดสอบ ซึ่งมีดังนี้

topic - เนื้อหาแบบทดสอบที่ต้องการ
num_q - จำนวนคำถามที่ต้องการ
diff - ระดับความยากที่ต้องการ (ง่าย ปานกลาง ยาก)
lang - ภาษาของแบบทดสอบที่ต้องการ

คัดลอกพรอมต์ที่คุณพัฒนาด้วย Vertex Generative AI Studio ในขั้นตอนก่อนหน้า แต่เปลี่ยนค่าที่ฮาร์ดโค้ดสำหรับหัวข้อ จำนวนคำถาม และระดับความยากด้วยสตริงต่อไปนี้

{topic}
{num_q}
{diff}
{lang}

from flask import Flask
from flask import request
import os

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys:
"Question", "responses", and "correct".

"""  #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)  #<-CHANGED 
    html = f"<h1>Prompt:</h1><br><pre>{prompt}</pre>"                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

ลองแก้ไข URL เพื่อเปลี่ยนพารามิเตอร์ทั้ง 4 รายการ

7. เพิ่มไลบรารีของไคลเอ็นต์ Vertex AI

ตอนนี้เราพร้อมที่จะใช้ไลบรารีของไคลเอ็นต์ Python สำหรับ Vertex AI เพื่อสร้างแบบทดสอบแล้ว ซึ่งจะทำให้การแจ้งแบบอินเทอร์แอกทีฟที่คุณทำในขั้นตอนที่ 3 เป็นไปโดยอัตโนมัติ และให้สิทธิ์การเข้าถึงแบบเป็นโปรแกรมแก่บริการเครื่องกำเนิดของคุณเพื่อใช้ความสามารถของ LLM ของ Google อัปเดตไฟล์ main.py ดังนี้

อย่าลืมแทนที่ "YOUR_PROJECT" ด้วยรหัสโปรเจ็กต์จริง

from flask import Flask
from flask import request
from flask import Response                                          #<-CHANGED
import os

import vertexai    
from vertexai.generative_models import GenerativeModel  #<-CHANGED

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"
MODEL = "gemini-1.0-pro"  #<-CHANGED

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys "question", "responses", and "correct".

"""

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# Initialize Vertex AI access.
vertexai.init(project="YOUR_PROJECT", location="us-central1")  #<-CHANGED
parameters = {                                                 #<-CHANGED
    "candidate_count": 1,                                      #<-CHANGED
    "max_output_tokens": 1024,                                 #<-CHANGED
    "temperature": 0.5,                                        #<-CHANGED
    "top_p": 0.8,                                              #<-CHANGED
    "top_k": 40,                                               #<-CHANGED
}                                                              #<-CHANGED
model = GenerativeModel(MODEL)             #<-CHANGED

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)
    response = model.generate_content(prompt, generation_config=parameters)  #<-CHANGED
    print(f"Response from Model: {response.text}")           #<-CHANGED
    html = f"{response.text}"                                #<-CHANGED
    return Response(html, mimetype="application/json")       #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

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

ลองเปลี่ยน URL เพื่อขอหัวข้อแบบทดสอบ จำนวนคำถาม และระดับความยากที่แตกต่างกัน

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

8. ไปที่ระบบคลาวด์

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

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

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

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับคอนเทนเนอร์และวิธีการทำงานใน Google Cloud Run ได้ที่ Codelab Dev to Prod ใน 3 ขั้นตอนง่ายๆ ด้วย Cloud Run

ทำให้แอปใช้งานได้กับ Cloud Run

Cloud Run เป็นบริการระดับภูมิภาค ซึ่งหมายความว่าโครงสร้างพื้นฐานที่เรียกใช้บริการ Cloud Run จะอยู่ในภูมิภาคที่เฉพาะเจาะจงและได้รับการจัดการโดย Google เพื่อให้พร้อมใช้งานอย่างซ้ำซ้อนในทุกโซนภายในภูมิภาคนั้น ในห้องทดลองนี้ เราจะใช้ภูมิภาคที่ฮาร์ดโค้ด us-central1 เพื่อให้ง่ายต่อการใช้งาน

เราจะใช้สิ่งที่เรียกว่า Buildpack เพื่อสร้างคอนเทนเนอร์โดยอัตโนมัติ สร้างไฟล์ใหม่ชื่อ Procfile ใน Cloud Editor แล้วแทรกข้อความ 1 บรรทัดนี้

web: gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

ซึ่งจะบอกระบบ Buildpack วิธีเรียกใช้แอปในคอนเทนเนอร์ที่สร้างขึ้นโดยอัตโนมัติ จากนั้นเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell (จากไดเรกทอรี quiz-generator เดียวกัน)

gcloud run deploy quiz-generator  \
    --source .                    \
    --region us-central1          \
    --allow-unauthenticated

ซึ่งจะบอกคำสั่ง gcloud ว่าคุณต้องการให้ใช้ Buildpack เพื่อสร้างอิมเมจคอนเทนเนอร์ตามไฟล์ต้นฉบับที่พบในไดเรกทอรีปัจจุบัน (dot ใน --source . เป็นคำย่อของไดเรกทอรีปัจจุบัน) เนื่องจากบริการจะดูแลอิมเมจคอนเทนเนอร์โดยนัย คุณจึงไม่จำเป็นต้องระบุอิมเมจในคำสั่ง gcloud นี้

โปรดรอสักครู่จนกว่าการติดตั้งใช้งานจะเสร็จสมบูรณ์ เมื่อสำเร็จ gcloud จะแสดง URL ของบริการใหม่ดังนี้

Building using Buildpacks and deploying container to Cloud Run service [quiz-generator] in project [YOUR_PROJECT] region [YOUR_REGION]
OK Building and deploying new service... Done.                                                                          
  OK Creating Container Repository...                                                                                   
  OK Uploading sources...                                                                                               
  OK Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds/0cf1383f-35db-412d
  -a973-557d5e2cd4a4?project=780573810218].                                                                             
  OK Creating Revision...                                                                                               
  OK Routing traffic...                                                                                                 
  OK Setting IAM Policy...                                                                                              
Done.                                                                                                                   
Service [quiz-generator] revision [quiz-generator-00001-xnr] has been deployed and is serving 100 percent of traffic.
Service URL: https://quiz-generator-co24gukjmq-uc.a.run.app

นอกจากนี้ คุณยังเรียก URL ของบริการด้วยคำสั่งนี้ได้ด้วย

gcloud run services describe quiz-generator  \
  --region us-central1                       \
  --format "value(status.url)"

ซึ่งควรแสดงผลดังนี้

https://quiz-generator-co24gukjmq-uc.a.run.app

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

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

ยินดีด้วย ตอนนี้แอปของคุณทำงานในระบบคลาวด์ของ Google แล้ว แอปของคุณจะพร้อมให้บริการแก่สาธารณะโดยไม่ต้องกังวลเรื่องใดๆ ด้วยการเข้ารหัส TLS (HTTPS) และการปรับขนาดอัตโนมัติเพื่อรองรับการเข้าชมในระดับที่น่าทึ่ง

9. การรวมทุกอย่างเข้าด้วยกัน

ในขั้นตอนสุดท้ายนี้ เราพร้อมที่จะเรียกใช้เครื่องมือสร้างแบบทดสอบเป็นส่วนหนึ่งของแอป Quizaic แล้ว ไปที่ URL ของ Quizaic ลงชื่อเข้าใช้บัญชี Google แล้วไปที่แท็บ Create Quiz เลือกประเภทเครื่องมือสร้าง Custom วาง URL ของ Cloud Run ลงในช่อง URL กรอกข้อมูลในช่องอื่นๆ ที่จำเป็น แล้วส่งแบบฟอร์ม

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

10. การล้างข้อมูล

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

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

gcloud config set artifacts/repository cloud-run-source-deploy
gcloud config set artifacts/location us-central1
gcloud artifacts docker images list

# Note image tag for resulting list

gcloud artifacts docker images delete <IMAGE-TAG>

หากต้องการลบบริการ Cloud Run ให้ใช้คำสั่งต่อไปนี้

gcloud run services delete quiz-generator --region us-central1 --quiet

11. คุณทำได้แล้ว!

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

ฉันอยากจะทิ้งท้ายด้วยคำถามสำคัญข้อหนึ่ง

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

คำตอบคือ 0 :)

Codelab อื่นๆ ที่ควรลอง

เอกสารอ้างอิง...

12. คำกระตุ้นให้ดำเนินการ (Call-To-Action)

หากคุณสนุกกับ Codelab นี้และมีแนวโน้มที่จะใช้เวลามากขึ้นในการลงมือปฏิบัติจริงกับ Google Cloud คุณควรเข้าร่วม Google Cloud Innovators วันนี้

Google Cloud Innovators ไม่มีค่าใช้จ่ายและมีสิทธิประโยชน์ดังนี้

การสนทนาแบบสด เซสชันถามและตอบ และเซสชันแผนกลยุทธ์เพื่อเรียนรู้ข้อมูลล่าสุดจาก Googler โดยตรง
ข่าวสารล่าสุดเกี่ยวกับ Google Cloud ในกล่องจดหมายของคุณ
ป้ายดิจิทัลและพื้นหลังการประชุมทางวิดีโอ
เครดิต 500 เครดิตสำหรับแล็บและการเรียนรู้ใน Skills Boost

คลิกที่นี่เพื่อลงทะเบียน