หน้านี้ได้รับการแปลโดย 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 Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ปกติแล้วคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสแบบสุ่มอื่นได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าเหล่านี้ในเอกสารประกอบ

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

เริ่มต้น Cloud Shell

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

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

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

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

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

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

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

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

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

คลิกปุ่ม ส่ง เพื่อดูผลลัพธ์

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

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

ภูมิภาคคือที่ที่ควรเรียกใช้คำขอสร้าง
โมเดลจะเลือกโมเดลภาษาขนาดใหญ่ที่คุณต้องการใช้ สำหรับ Codelab นี้ ให้ใช้ "gemini-1.0-pro-001" ต่อไป
อุณหภูมิจะควบคุมระดับการสุ่มในการเลือกโทเค็น อุณหภูมิที่ต่ำลงส่งผลดีต่อพรอมต์ที่คาดว่าจะได้รับการตอบสนองที่ถูกต้องหรือเป็นจริง ส่วนอุณหภูมิที่สูงขึ้นอาจนำไปสู่ผลลัพธ์ที่หลากหลายหรือคาดไม่ถึงมากขึ้น
ขีดจำกัดของโทเค็นจะกำหนดจำนวนข้อความสูงสุดที่ส่งออกจากพรอมต์ 1 รายการ โทเค็นมีความยาวประมาณ 4 อักขระ ค่าเริ่มต้นคือ 1024
Top-k จะเปลี่ยนวิธีที่โมเดลเลือกโทเค็นเพื่อแสดงผล ส่วนบนสุดของ 1 หมายถึงโทเค็นที่เลือกน่าจะเป็นไปได้มากที่สุดในบรรดาโทเค็นทั้งหมดในคำศัพท์ของโมเดล (หรือที่เรียกว่าการถอดรหัสแบบโล่ง) ส่วนบนสุดของ k ของ 3 หมายความว่าโทเค็นถัดไปจะเลือกจากโทเค็นที่เป็นไปได้มากที่สุด 3 รายการ (โดยใช้อุณหภูมิ) ค่า Top-k เริ่มต้นคือ 40
หน้าบนสุดจะเปลี่ยนวิธีที่โมเดลเลือกโทเค็นเพื่อแสดงผล ระบบจะเลือกโทเค็นจากที่เป็นไปได้มากที่สุดไปน้อยที่สุดจนกว่าผลรวมของความน่าจะเป็นจะเท่ากับค่า 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 ที่ใช้เพื่อส่งพรอมต์ไปยัง Vertex AI LLM แบบเป็นโปรแกรมได้ หากสนใจใช้ภาษาโปรแกรมอื่นที่ไม่ใช่ Python โปรดดู https://cloud.google.com/vertex-ai/docs/samples?text=generative

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

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

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

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

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

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

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

ตอนนี้เราพร้อมที่จะใช้ไลบรารีของไคลเอ็นต์ Vertex AI Python เพื่อสร้างแบบทดสอบแล้ว การทำเช่นนี้จะทำให้ข้อความแจ้งแบบอินเทอร์แอกทีฟที่คุณทำในขั้นตอนที่ 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 Terminal (จากไดเรกทอรี 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. นำชิ้นส่วนทั้งหมดมารวมกัน

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

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

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