หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. บทนำ

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

สิ่งที่จะต้องทำ...

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

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

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

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

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

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

2. ตั้งค่า

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

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

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

ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตวิธีการชำระเงินได้ทุกเมื่อ
รหัสโปรเจ็กต์จะซ้ำกันไม่ได้ในโปรเจ็กต์ Google Cloud ทั้งหมดและจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) คอนโซล Cloud จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นจะเป็นอะไร ในโค้ดแล็บส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (ปกติจะระบุเป็น 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 (ภาษา) คุณควรเห็นหน้าเว็บดังต่อไปนี้

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

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

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

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

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

ภูมิภาคคือที่ที่ควรเรียกใช้คำขอสร้าง
โมเดลจะเลือกโมเดลภาษาขนาดใหญ่ที่คุณต้องการใช้ สําหรับโค้ดแล็บนี้ ให้ใช้ "gemini-1.0-pro-001"
อุณหภูมิจะควบคุมระดับความสุ่มในการเลือกโทเค็น อุณหภูมิที่ต่ำลงส่งผลดีต่อพรอมต์ที่คาดว่าจะได้รับการตอบสนองที่ถูกต้องหรือเป็นจริง ส่วนอุณหภูมิที่สูงขึ้นอาจทำให้เกิดผลลัพธ์ที่หลากหลายหรือคาดไม่ถึงมากขึ้น
ขีดจํากัดโทเค็นจะกําหนดจํานวนข้อความเอาต์พุตสูงสุดจากพรอมต์ 1 รายการ โทเค็นมีความยาวประมาณ 4 อักขระ ค่าเริ่มต้นคือ 1,024
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

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

ใช้เทคนิคเดียวกันเพื่อสร้างไฟล์ใหม่อีกไฟล์ชื่อ 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 ได้ที่โค้ดแล็บจากนักพัฒนาซอฟต์แวร์สู่เวอร์ชันที่ใช้งานจริงใน 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

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

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

ซึ่งจะบอกคำสั่ง gcloud ว่าคุณต้องการใช้บิลด์แพ็กเพื่อสร้างอิมเมจคอนเทนเนอร์ โดยอิงตามไฟล์ต้นฉบับที่พบในไดเรกทอรีปัจจุบัน (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. นำชิ้นส่วนทั้งหมดมารวมกัน

ในขั้นตอนสุดท้ายนี้ เราพร้อมที่จะเรียกใช้โปรแกรมสร้างแบบทดสอบโดยเป็นส่วนหนึ่งของแอปแบบทดสอบ โปรดไปที่ URL ของแบบทดสอบ เข้าสู่ระบบบัญชี 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

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