สร้างผู้ช่วย AI สำหรับอีเมลธุรกิจด้วย Gemma

การจัดการกับข้อซักถามของลูกค้ารวมถึงอีเมลเป็นส่วนสำคัญในการทำงาน ธุรกิจส่วนใหญ่ แต่มักจะท่วมท้นอย่างรวดเร็ว ใช้ความพยายามเล็กน้อย โมเดลปัญญาประดิษฐ์ (AI) อย่าง Gemma จะช่วยให้งานนี้ง่ายขึ้น

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

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

ภาพรวม

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

รูปที่ 1 อินเทอร์เฟซผู้ใช้ของโปรเจ็กต์สำหรับการสอบถามทางอีเมลเกี่ยวกับเบเกอรี่

ข้อกำหนดเกี่ยวกับฮาร์ดแวร์

เรียกใช้กระบวนการปรับแต่งนี้ในคอมพิวเตอร์ที่มีหน่วยประมวลผลกราฟิก (GPU) หรือหน่วยประมวลผล Tensor (TPU) และหน่วยความจำ GPU หรือ TPU เพียงพอที่จะเก็บโมเดลที่มีอยู่ รวมถึงข้อมูลการปรับแต่ง ในการเรียกใช้การกำหนดค่าการปรับแต่งใน คุณต้องมีหน่วยความจำ GPU ประมาณ 16 GB ซึ่งเท่ากับปริมาณปกติที่เท่ากัน RAM และพื้นที่ดิสก์อย่างน้อย 50 GB

คุณเรียกใช้ส่วนการปรับแต่งโมเดล Gemma ของบทแนะนำนี้ได้โดยใช้ Colab ที่มีรันไทม์ T4 GPU หากคุณสร้างโปรเจ็กต์นี้ในอินสแตนซ์ VM ของ Google Cloud ให้กําหนดค่าอินสแตนซ์ตามข้อกําหนดต่อไปนี้

• ฮาร์ดแวร์ GPU: ต้องใช้ NVIDIA T4 เพื่อใช้งานโปรเจ็กต์นี้ (แนะนำ NVIDIA L4 ขึ้นไป)
• ระบบปฏิบัติการ: เลือกตัวเลือกการเรียนรู้เชิงลึกใน Linux โดยเฉพาะ VM สำหรับการเรียนรู้เชิงลึกที่มี CUDA 12.3 M124 พร้อมไดรเวอร์ซอฟต์แวร์ GPU ที่ติดตั้งไว้ล่วงหน้า
• ขนาดดิสก์บูท: จัดสรรพื้นที่ดิสก์อย่างน้อย 50 GB สำหรับข้อมูล โมเดล และซอฟต์แวร์ที่รองรับ

การตั้งค่าโปรเจ็กต์

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

ติดตั้งและกำหนดค่า

โปรเจ็กต์นี้ใช้ Python 3 และสภาพแวดล้อมเสมือน (venv) เพื่อจัดการแพ็กเกจ และเรียกใช้แอปพลิเคชัน วิธีการติดตั้งต่อไปนี้มีไว้สำหรับเครื่องโฮสต์ Linux

วิธีติดตั้งซอฟต์แวร์ที่จำเป็น

• ติดตั้ง Python 3 และแพ็กเกจสภาพแวดล้อมเสมือน venv สำหรับ Python โดยทำดังนี้

  sudo apt update
  sudo apt install git pip python3-venv
  

โคลนโปรเจ็กต์

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

วิธีดาวน์โหลดรหัสโปรเจ็กต์

1. โคลนที่เก็บ Git โดยใช้คำสั่งต่อไปนี้

   git clone https://github.com/google-gemini/gemma-cookbook.git
   

2. (ไม่บังคับ) กำหนดค่าที่เก็บ Git ในเครื่องเพื่อใช้การชำระเงินแบบกระจัดกระจาย เพื่อให้คุณมีเพียงไฟล์สำหรับโปรเจ็กต์

   cd gemma-cookbook/
   git sparse-checkout set Demos/business-email-assistant/
   git sparse-checkout init --cone
   

ติดตั้งไลบรารี Python

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

วิธีติดตั้งไลบรารี Python

1. ในหน้าต่างเทอร์มินัล ให้ไปที่ไดเรกทอรี business-email-assistant โดยทำดังนี้

   cd Demos/business-email-assistant/
   

2. กําหนดค่าและเปิดใช้งานสภาพแวดล้อมเสมือนของ Python (venv) สําหรับโปรเจ็กต์นี้

   python3 -m venv venv
   source venv/bin/activate
   

3. ติดตั้งไลบรารี Python ที่จําเป็นสําหรับโปรเจ็กต์นี้โดยใช้สคริปต์ setup_python

   ./setup_python.sh
   

ตั้งค่าตัวแปรสภาพแวดล้อม

โปรเจ็กต์นี้ต้องใช้ตัวแปรสภาพแวดล้อม 2-3 รายการเพื่อทํางาน ซึ่งรวมถึงชื่อผู้ใช้ Kaggle และโทเค็น Kaggle API คุณต้องมี Kaggle และขอสิทธิ์เข้าถึงโมเดล Gemma เพื่อดาวน์โหลด สําหรับโปรเจ็กต์นี้ คุณต้องเพิ่มชื่อผู้ใช้ Kaggle และโทเค็น Kaggle API ลงใน.envไฟล์ 2 ไฟล์ ซึ่งเว็บแอปพลิเคชันและโปรแกรมการปรับแต่งจะอ่านตามลําดับ

วิธีตั้งค่าตัวแปรสภาพแวดล้อม

1. รับชื่อผู้ใช้ Kaggle และคีย์โทเค็นของคุณโดยทำตามคำแนะนำ ในเอกสารประกอบของ Kaggle
2. รับสิทธิ์เข้าถึงโมเดล Gemma โดยทําตามวิธีการรับสิทธิ์เข้าถึง Gemma ในหน้าการตั้งค่า Gemma
3. สร้างไฟล์ตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ โดยสร้าง ไฟล์ข้อความ .env ที่แต่ละตำแหน่งเหล่านี้ในโคลนของโปรเจ็กต์:

   email-processing-webapp/.env
   model-tuning/.env
   

4. หลังจากสร้างไฟล์ข้อความ .env แล้ว ให้เพิ่มการตั้งค่าต่อไปนี้ลงในทั้งไฟล์

   KAGGLE_USERNAME=<YOUR_KAGGLE_USERNAME_HERE>
   KAGGLE_KEY=<YOUR_KAGGLE_KEY_HERE>
   

เรียกใช้และทดสอบแอปพลิเคชัน

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

วิธีเรียกใช้และทดสอบโปรเจ็กต์

1. ในหน้าต่างเทอร์มินัล ให้ไปที่ไดเรกทอรี email-processing-webapp โดยทำดังนี้

   cd business-email-assistant/email-processing-webapp/
   

2. เรียกใช้แอปพลิเคชันโดยใช้สคริปต์ run_app

   ./run_app.sh
   

3. หลังจากเริ่มต้นเว็บแอปพลิเคชัน โค้ดของโปรแกรมจะแสดง URL คุณสามารถเรียกดูและทดสอบ โดยปกติแล้วที่อยู่นี้จะมีลักษณะดังนี้

   http://127.0.0.1:5000/
   

4. ในเว็บอินเทอร์เฟซ ให้กดปุ่มรับข้อมูลด้านล่างอินพุตแรก เพื่อสร้างการตอบสนองจากโมเดล

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

ขยายระยะเวลาของใบสมัคร

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

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

วิธีแก้ไขวิธีการของข้อความแจ้ง

1. ในโปรเจ็กต์การพัฒนา ให้เปิด ไฟล์โค้ด business-email-assistant/email-processing-webapp/app.py

2. ในโค้ด app.py ให้เพิ่มวิธีการเพิ่มเติมใน get_prompt(): ฟังก์ชัน:

   def get_prompt():
     return """
       Extract the relevant details of this request and return them in
       JSON code, with no additional markdown formatting:\n"""
   

ตัวอย่างนี้จะเพิ่มวลี "ไม่มีการจัดรูปแบบ Markdown เพิ่มเติม" ลงในวิธีการ

การให้คำสั่งพรอมต์เพิ่มเติมอาจส่งผลอย่างมากต่อเอาต์พุตที่สร้างขึ้น และใช้งานได้ง่ายขึ้นมาก คุณควรลองทำดู ก่อนเพื่อดูว่าคุณจะได้รับพฤติกรรมที่ต้องการจากโมเดลหรือไม่ แต่การใช้คำสั่งอย่างทันท่วงทีเพื่อแก้ไขลักษณะการทำงานของโมเดล Gemma จะมี ขีดจำกัด โดยเฉพาะอย่างยิ่ง ขีดจํากัดโทเค็นอินพุตโดยรวมของโมเดล ซึ่งเท่ากับ 8,192 โทเค็นสําหรับ Gemma 2 กำหนดให้คุณต้องปรับสมดุลระหว่างวิธีการพรอมต์แบบละเอียดกับขนาดของข้อมูลใหม่ที่ให้ไว้เพื่อให้อยู่ภายใต้ขีดจํากัดดังกล่าว

ปรับแต่งโมเดล

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

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

ข้อกำหนดเกี่ยวกับฮาร์ดแวร์

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

เตรียมข้อมูล

ก่อนเริ่มปรับแต่งโมเดล Gemma คุณต้องเตรียมข้อมูลสำหรับการปรับแต่ง เมื่อปรับแต่งโมเดลสําหรับงานหนึ่งๆ คุณจะต้องมีชุดคําขอและตัวอย่างคําตอบ ตัวอย่างเหล่านี้ควรแสดงข้อความคําขอโดยไม่มีวิธีการใดๆ และข้อความตอบกลับที่คาดไว้ ในการเริ่มต้น คุณควรเตรียมชุดข้อมูลที่มีตัวอย่างประมาณ 10 รายการ ตัวอย่างเหล่านี้ควรแสดงคำขอที่หลากหลายและคำตอบที่เหมาะสม ตรวจสอบว่าคำขอและ ไม่ซ้ำซ้อนกัน เนื่องจากอาจทำให้การตอบสนองของโมเดล เกิดขึ้นซ้ำๆ และไม่ปรับเปลี่ยนให้เข้ากับคำขอรูปแบบต่างๆ หากคุณปรับแต่งโมเดลให้สร้างรูปแบบ Structured Data โปรดตรวจสอบว่าคำตอบทั้งหมดที่ระบุเป็นไปตามรูปแบบเอาต์พุตข้อมูลที่คุณต้องการอย่างเคร่งครัด ตารางต่อไปนี้แสดงตัวอย่างระเบียน 2-3 รายการจากชุดข้อมูลของตัวอย่างโค้ดนี้

ตารางที่ 1 รายการบางส่วนของชุดข้อมูลการปรับแต่งสำหรับข้อมูลอีเมลเกี่ยวกับเบเกอรี่ เครื่องมือแยกข้อมูล

รูปแบบและโหลดข้อมูล

คุณสามารถจัดเก็บข้อมูลการปรับแต่งในรูปแบบใดก็ได้ที่สะดวก ซึ่งรวมถึงระเบียนฐานข้อมูล ไฟล์ JSON, CSV หรือไฟล์ข้อความล้วน ตราบใดที่คุณมีวิธีเรียกข้อมูลระเบียนด้วยโค้ด Python โปรเจ็กต์นี้จะอ่านไฟล์ JSON จากไดเรกทอรี data ไปยังอาร์เรย์ของออบเจ็กต์พจนานุกรม ในโปรแกรมการพลิกตัวอย่างนี้ ชุดข้อมูลการปรับแต่งจะโหลดใน โมดูล model-tuning/main.py ที่ใช้ฟังก์ชัน prepare_tuning_dataset():

def prepare_tuning_dataset():
    # collect data from JSON files
    prompt_data = read_json_files_to_dicts("./data")
    ...

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

รวบรวมระเบียนการปรับแต่ง

สําหรับขั้นตอนการปรับแต่งจริง โปรแกรมจะรวบรวมคําขอและการตอบกลับแต่ละรายการเป็นสตริงเดียวพร้อมคําแนะนําพรอมต์และเนื้อหาของการตอบกลับ จากนั้นโปรแกรมการปรับแต่งจะแบ่งสตริงออกเป็นโทเค็นเพื่อให้โมเดลนำไปใช้ คุณสามารถดูรหัสสำหรับการประกอบระเบียนการปรับแต่งได้ใน model-tuning/main.py โมดูล prepare_tuning_dataset() ทำงานดังต่อไปนี้

def prepare_tuning_dataset():
    ...
    # prepare data for tuning
    tuning_dataset = []
    template = "{instruction}\n{response}"

    for prompt in prompt_data:
        tuning_dataset.append(template.format(instruction=prompt["prompt"],
                                              response=prompt["response"]))

    return tuning_dataset

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

สร้างน้ำหนักโมเดล

เมื่อเตรียมข้อมูลการปรับแต่งพร้อมทั้งโหลดแล้ว คุณสามารถเรียกใช้การปรับแต่ง ของโปรแกรม กระบวนการปรับแต่งสำหรับแอปพลิเคชันตัวอย่างนี้ใช้ Keras NLP ไลบรารีเพื่อปรับแต่งโมเดลด้วย การปรับระดับต่ำ หรือเทคนิค LoRA เพื่อสร้างน้ำหนักโมเดลใหม่ เมื่อเทียบกับการปรับแต่งแบบแม่นยำทั้งหมด การใช้ LoRA จะใช้หน่วยความจําน้อยลงอย่างมากเนื่องจากจะประมาณการเปลี่ยนแปลงของน้ำหนักโมเดล จากนั้น คุณสามารถวางน้ำหนักโดยประมาณเหล่านี้ซ้อนลงบน ถ่วงน้ำหนักโมเดลเพื่อเปลี่ยนลักษณะการทำงานของโมเดล

หากต้องการเรียกใช้การปรับแต่งและคำนวณน้ำหนักใหม่ ให้ทำดังนี้

1. ในหน้าต่างเทอร์มินัล ให้ไปยังไดเรกทอรี model-tuning/

   cd business-email-assistant/model-tuning/
   

2. เรียกใช้กระบวนการปรับแต่งโดยใช้สคริปต์ tune_model ดังนี้

   ./tune_model.sh
   

กระบวนการปรับแต่งอาจใช้เวลาหลายนาทีขึ้นอยู่กับการประมวลผลที่มีอยู่ ที่ไม่ซับซ้อน เมื่อการทดสอบเสร็จสมบูรณ์ โปรแกรมการปรับแต่งจะเขียน *.h5 ใหม่ ไฟล์น้ำหนักในไดเรกทอรี model-tuning/weights โดยใช้รูปแบบต่อไปนี้

gemma2-2b_inquiry_tuned_4_epoch##.lora.h5

การแก้ปัญหา

หากการปรับแต่งไม่เสร็จสมบูรณ์ สาเหตุที่เป็นไปได้มี 2 ประการดังนี้

• หน่วยความจำหรือทรัพยากรหมด: ข้อผิดพลาดเหล่านี้เกิดขึ้นเมื่อ กระบวนการปรับแต่งขอหน่วยความจำที่เกินหน่วยความจำ GPU หรือ CPU ที่ใช้ได้ ความทรงจำ ตรวจสอบว่าคุณไม่ได้เรียกใช้เว็บแอปพลิเคชันขณะที่กระบวนการปรับแต่งกำลังทำงานอยู่ ถ้าคุณปรับแต่งอุปกรณ์ที่มีหน่วยความจำ GPU ขนาด 16 GB ตรวจสอบว่าคุณตั้งค่า token_limit เป็น 256 และ batch_size ตั้งค่าเป็น 1
• ไม่ได้ติดตั้งไดรเวอร์ GPU หรือเข้ากันไม่ได้กับ JAX: กระบวนการเปิดใช้กำหนดให้อุปกรณ์ประมวลผลต้องติดตั้งไดรเวอร์ฮาร์ดแวร์ที่เข้ากันได้กับเวอร์ชันของไลบรารี JAX ดูรายละเอียดเพิ่มเติมได้ที่ การติดตั้ง JAX เอกสารประกอบ

ทำให้โมเดลที่ปรับแต่งแล้วใช้งานได้

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

...
8/8 ━━━━━━━━━━━━━━━━━━━━ 121s 195ms/step - loss: 0.5432 - sparse_categorical_accuracy: 0.5982
Epoch 2/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 194ms/step - loss: 0.3320 - sparse_categorical_accuracy: 0.6966
Epoch 3/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 192ms/step - loss: 0.2135 - sparse_categorical_accuracy: 0.7848

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

วิธีทำให้น้ำหนักที่สร้างขึ้นใช้งานได้ในเว็บแอปพลิเคชัน

1. ในหน้าต่างเทอร์มินัล ให้ไปที่ไดเรกทอรี model-tuning โดยทำดังนี้

   cd business-email-assistant/model-tuning/
   

2. เรียกใช้กระบวนการปรับโดยใช้สคริปต์ deploy_weights

   ./deploy_weights.sh
   

หลังจากเรียกใช้สคริปต์นี้ คุณควรเห็นไฟล์ *.h5 ใหม่ในไดเรกทอรี email-processing-webapp/weights/

ทดสอบรูปแบบใหม่

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

วิธีเรียกใช้และทดสอบโปรเจ็กต์

1. ในหน้าต่างเทอร์มินัล ให้ไปที่ไดเรกทอรี email-processing-webapp โดยทำดังนี้

   cd business-email-assistant/email-processing-webapp/
   

2. เรียกใช้แอปพลิเคชันโดยใช้สคริปต์ run_app

   ./run_app.sh
   

3. หลังจากเริ่มเว็บแอปพลิเคชันแล้ว โค้ดโปรแกรมจะแสดง URL ที่คุณเรียกดูและทดสอบได้ โดยปกติแล้วที่อยู่นี้จะเป็น

   http://127.0.0.1:5000/
   

4. ในเว็บอินเทอร์เฟซ ให้กดปุ่มรับข้อมูลใต้ช่องอินพุตแรกเพื่อสร้างคำตอบจากโมเดล

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

แหล่งข้อมูลเพิ่มเติม

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับโปรเจ็กต์นี้ โปรดดูที่ ที่เก็บโค้ดของ Gemma Cookbook หากต้องการความช่วยเหลือในการสร้างแอปพลิเคชันหรือต้องการร่วมงานด้วย นักพัฒนาซอฟต์แวร์รายอื่นๆ ได้ที่ Discord ในชุมชน Google Developers เซิร์ฟเวอร์ ดูโปรเจ็กต์อื่นๆ ของ Build with Google AI ได้ที่ เพลย์ลิสต์วิดีโอ