ปรับแต่ง Gemini บน Vertex AI

1. บทนำ

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

คุณจะได้ใช้ Gemini 2.5 Flash ซึ่งเป็นโมเดลที่มีน้ำหนักเบาและคุ้มค่า และทำการปรับแต่งโดยใช้ Vertex AI

ภาพรวมสถาปัตยกรรม

สิ่งที่เราจะสร้างมีดังนี้

  • Cloud Shell: สภาพแวดล้อมในการพัฒนาซอฟต์แวร์ของคุณ
  • Cloud Storage: จัดเก็บข้อมูลการฝึก/การตรวจสอบในรูปแบบ JSONL
  • Vertex AI Training: จัดการงานการปรับแต่ง
  • Vertex AI Endpoint: โฮสต์โมเดลที่ปรับแต่งแล้ว

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

  • เตรียมชุดข้อมูลคุณภาพสูงสำหรับการปรับแต่งภายใต้การควบคุมดูแล
  • กำหนดค่าและเปิดใช้งานการปรับแต่งโดยใช้ Vertex AI SDK สำหรับ Python
  • ประเมินโมเดลโดยใช้เมตริกอัตโนมัติ (คะแนน ROUGE)
  • เปรียบเทียบโมเดลพื้นฐานกับโมเดลที่ปรับแต่งแล้วเพื่อวัดปริมาณการปรับปรุง

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

บัญชี Google

หากยังไม่มีบัญชี Google ส่วนบุคคล คุณต้องสร้างบัญชี Google

ใช้บัญชีส่วนบุคคล แทนบัญชีของที่ทำงานหรือโรงเรียน

ลงชื่อเข้าใช้คอนโซล Google Cloud

ลงชื่อเข้าใช้ คอนโซล Google Cloud โดยใช้บัญชี Google ส่วนบุคคล

เปิดใช้การเรียกเก็บเงิน

แลกรับเครดิต Google Cloud มูลค่า $5 (ไม่บังคับ)

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

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

ตอนนี้คุณเชื่อมต่อกับบัญชีสำหรับการเรียกเก็บเงินของ Google Cloud Platform เวอร์ชันทดลองใช้งานแล้ว

ภาพหน้าจอของภาพรวมการเรียกเก็บเงิน

สร้างโปรเจ็กต์ (ไม่บังคับ)

หากไม่มีโปรเจ็กต์ปัจจุบันที่ต้องการใช้สำหรับห้องทดลองนี้ ให้ สร้างโปรเจ็กต์ใหม่ที่นี่

3. เปิด Cloud Shell Editor

  1. คลิกลิงก์นี้เพื่อไปยัง Cloud Shell Editor โดยตรง
  2. หากระบบแจ้งให้ให้สิทธิ์ในวันนี้ ให้คลิกให้สิทธิ์ เพื่อดำเนินการต่อคลิกเพื่อให้สิทธิ์ Cloud Shell
  3. หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดโดยทำดังนี้
    • คลิกดู
    • คลิก Terminalเปิดเทอร์มินัลใหม่ใน Cloud Shell Editor
  4. ในเทอร์มินัล ให้ตั้งค่าโปรเจ็กต์ด้วยคำสั่งนี้
    gcloud config set project [PROJECT_ID]
    • ตัวอย่าง
      gcloud config set project lab-project-id-example
    • หากจำรหัสโปรเจ็กต์ไม่ได้ คุณสามารถแสดงรหัสโปรเจ็กต์ทั้งหมดได้ด้วยคำสั่งต่อไปนี้
      gcloud projects list
      ตั้งค่ารหัสโปรเจ็กต์ในเทอร์มินัล Cloud Shell Editor
  5. คุณควรเห็นข้อความนี้
    Updated property [core/project].

4. เปิดใช้ API

หากต้องการใช้ Vertex AI และบริการอื่นๆ คุณต้องเปิดใช้ API ที่จำเป็นในโปรเจ็กต์ Google Cloud

  1. เปิดใช้ API ในเทอร์มินัลโดยทำดังนี้
    • Vertex AI API (aiplatform.googleapis.com): ช่วยให้ใช้ Vertex AI ในการปรับแต่งและแสดงโมเดล
    • Cloud Storage API (storage.googleapis.com): ช่วยให้จัดเก็บชุดข้อมูลและอาร์ติแฟกต์ของโมเดลได้
    gcloud services enable aiplatform.googleapis.com \
    storage.googleapis.com

5. ตั้งค่าสภาพแวดล้อมของโปรเจ็กต์

สร้างไดเรกทอรีการทำงาน

  1. ใน เทอร์มินัล ให้สร้างไดเรกทอรีสำหรับโปรเจ็กต์แล้วไปยังไดเรกทอรีนั้น
    mkdir gemini-finetuning
cd gemini-finetuning

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

  1. ใน เทอร์มินัล ให้กำหนดตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ เราจะสร้างไฟล์ env.sh เพื่อจัดเก็บตัวแปรเหล่านี้เพื่อให้โหลดซ้ำได้ง่ายหากเซสชันของคุณถูกตัดการเชื่อมต่อ
    cat <<EOF > env.sh
export PROJECT_ID=\$(gcloud config get-value project)
export REGION="us-central1"
export BUCKET_NAME="\${PROJECT_ID}-gemini-tuning"
EOF

source env.sh

สร้าง Bucket ของ Cloud Storage

  1. ใน เทอร์มินัล ให้สร้าง Bucket เพื่อจัดเก็บชุดข้อมูลและอาร์ติแฟกต์ของโมเดล
    gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID --location=$REGION

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

  1. เราจะใช้ uv เพื่อจัดการสภาพแวดล้อม Python ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
    uv venv .venv
source .venv/bin/activate
  2. ในเทอร์มินัล ให้ติดตั้งแพ็กเกจ Python ที่จำเป็น
    uv pip install google-cloud-aiplatform rouge-score matplotlib pandas tqdm

6. เตรียมข้อมูลฝึกฝน

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

  1. ในเทอร์มินัล ให้สร้างไฟล์ชื่อ prepare_data.py
    cloudshell edit prepare_data.py
  2. วางโค้ดต่อไปนี้ลงใน prepare_data.py
    import json
import os
import pandas as pd
from google.cloud import storage
import subprocess

# Configuration
BUCKET_NAME = os.environ["BUCKET_NAME"]
PROJECT_ID = os.environ["PROJECT_ID"]

def download_data():
    print("Downloading WikiLingua dataset...")
    # Using gsutil to copy from public bucket
    subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/*", "."], check=True)

def convert_to_gemini_format(input_file, output_file, max_samples=1000):
    print(f"Converting {input_file} to Gemini format (first {max_samples} samples)...")
    converted_data = []
    with open(input_file, 'r') as f:
        for i, line in enumerate(f):
            if i >= max_samples:
                break
            obj = json.loads(line)
            messages = obj.get("messages", [])

            # Convert messages to Gemini 2.5 format
            # Input: {"messages": [{"role": "user", "content": "..."}, {"role": "model", "content": "..."}]}
            # Output: {"contents": [{"role": "user", "parts": [{"text": "..."}]}, {"role": "model", "parts": [{"text": "..."}]}]}

            contents = []
            for msg in messages:
                role = msg["role"]
                content = msg["content"]
                contents.append({
                    "role": role,
                    "parts": [{"text": content}]
                })

            converted_data.append({"contents": contents})

    with open(output_file, 'w') as f:
        for item in converted_data:
            f.write(json.dumps(item) + "\n")

    print(f"Saved {len(converted_data)} examples to {output_file}")

def upload_to_gcs(local_file, destination_blob_name):
    print(f"Uploading {local_file} to gs://{BUCKET_NAME}/{destination_blob_name}...")
    storage_client = storage.Client(project=PROJECT_ID)
    bucket = storage_client.bucket(BUCKET_NAME)
    blob = bucket.blob(destination_blob_name)
    blob.upload_from_filename(local_file)
    print("Upload complete.")

def main():
    download_data()

    # Process Training Data
    convert_to_gemini_format("sft_train_samples.jsonl", "train_gemini.jsonl")
    upload_to_gcs("train_gemini.jsonl", "datasets/train/train_gemini.jsonl")

    # Process Validation Data
    convert_to_gemini_format("sft_val_samples.jsonl", "val_gemini.jsonl")
    upload_to_gcs("val_gemini.jsonl", "datasets/val/val_gemini.jsonl")

    print("Data preparation complete!")

if __name__ == "__main__":
    main()
  3. ในเทอร์มินัล ให้เรียกใช้สคริปต์การเตรียมข้อมูล
    python prepare_data.py

7. กำหนดประสิทธิภาพเกณฑ์พื้นฐาน

คุณต้องมีเกณฑ์มาตรฐานก่อนการปรับแต่ง คุณจะได้วัดประสิทธิภาพของโมเดล gemini-2.5-flash พื้นฐานในงานสรุปโดยใช้คะแนน ROUGE

  1. ในเทอร์มินัล ให้สร้างไฟล์ชื่อ evaluate.py
    cloudshell edit evaluate.py
  2. วางโค้ดต่อไปนี้ลงใน evaluate.py
    import argparse
import json
import os
import pandas as pd
from google.cloud import aiplatform
import vertexai
from vertexai.generative_models import GenerativeModel, GenerationConfig, HarmCategory, HarmBlockThreshold
from rouge_score import rouge_scorer
from tqdm import tqdm
import matplotlib.pyplot as plt
import time

# Configuration
PROJECT_ID = os.environ["PROJECT_ID"]
REGION = os.environ["REGION"]

aiplatform.init(project=PROJECT_ID, location=REGION)

def evaluate(model_name, test_file, max_samples=50, output_json="results.json"):
    print(f"Evaluating model: {model_name}")

    # Load Test Data
    test_df = pd.read_csv(test_file)
    test_df = test_df.head(max_samples)

    model = GenerativeModel(model_name)

    safety_settings = {
        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    }

    generation_config = GenerationConfig(
        temperature=0.1,
        max_output_tokens=1024,
    )

    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
    results = []

    for index, row in tqdm(test_df.iterrows(), total=len(test_df)):
        input_text = row['input_text']
        reference_summary = row['output_text']

        try:
            response = model.generate_content(
                input_text,
                generation_config=generation_config,
                safety_settings=safety_settings
            )
            generated_summary = response.text

            scores = scorer.score(reference_summary, generated_summary)

            results.append({
                "generated": generated_summary,
                "reference": reference_summary,
                "rouge1": scores['rouge1'].fmeasure,
                "rouge2": scores['rouge2'].fmeasure,
                "rougeL": scores['rougeL'].fmeasure
            })
        except Exception as e:
            print(f"Error processing example {index}: {e}")
            # Sleep briefly to avoid quota issues if hitting limits
            time.sleep(1)

    # Save results
    with open(output_json, 'w') as f:
        json.dump(results, f, indent=2)

    return pd.DataFrame(results)

def plot_results(df, title, filename):
    os.makedirs("plots", exist_ok=True)

    metrics = ['rouge1', 'rouge2', 'rougeL']
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    for i, metric in enumerate(metrics):
        axes[i].hist(df[metric], bins=10, alpha=0.7, color='skyblue', edgecolor='black')
        axes[i].set_title(f'{metric} Distribution')
        axes[i].set_xlabel('Score')
        axes[i].set_ylabel('Count')

    plt.suptitle(title)
    plt.tight_layout()
    plt.savefig(f"plots/{filename}")
    print(f"Plot saved to plots/{filename}")

def compare_results(baseline_file, tuned_file):
    with open(baseline_file, 'r') as f:
        baseline_data = pd.DataFrame(json.load(f))
    with open(tuned_file, 'r') as f:
        tuned_data = pd.DataFrame(json.load(f))

    print("\n--- Comparison ---")
    metrics = ['rouge1', 'rouge2', 'rougeL']
    for metric in metrics:
        base_mean = baseline_data[metric].mean()
        tuned_mean = tuned_data[metric].mean()
        diff = tuned_mean - base_mean
        print(f"{metric}: Base={base_mean:.4f}, Tuned={tuned_mean:.4f}, Diff={diff:+.4f}")

    # Comparative Plot
    os.makedirs("plots", exist_ok=True)
    comparison_df = pd.DataFrame({
        'Metric': metrics,
        'Baseline': [baseline_data[m].mean() for m in metrics],
        'Tuned': [tuned_data[m].mean() for m in metrics]
    })

    comparison_df.plot(x='Metric', y=['Baseline', 'Tuned'], kind='bar', figsize=(10, 6))
    plt.title('Baseline vs Tuned Model Performance')
    plt.ylabel('Average Score')
    plt.xticks(rotation=0)
    plt.tight_layout()
    plt.savefig("plots/comparison.png")
    print("Comparison plot saved to plots/comparison.png")

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", type=str, default="gemini-2.5-flash", help="Model resource name")
    parser.add_argument("--baseline", type=str, help="Path to baseline results json for comparison")
    parser.add_argument("--output", type=str, default="results.json", help="Output file for results")
    args = parser.parse_args()

    # Ensure test data exists (it was downloaded in prepare_data step)
    if not os.path.exists("sft_test_samples.csv"):
        # Fallback download if needed
        subprocess.run(["gsutil", "cp", "gs://github-repo/generative-ai/gemini/tuning/summarization/wikilingua/sft_test_samples.csv", "."], check=True)

    df = evaluate(args.model, "sft_test_samples.csv", output_json=args.output)

    print("\n--- Results Summary ---")
    print(df.describe())

    plot_filename = "baseline_dist.png" if not args.baseline else "tuned_dist.png"
    plot_results(df, f"ROUGE Scores - {args.model}", plot_filename)

    if args.baseline:
        compare_results(args.baseline, args.output)

if __name__ == "__main__":
    main()
  3. ในเทอร์มินัล ให้เรียกใช้การประเมินเกณฑ์พื้นฐาน
    python evaluate.py --model "gemini-2.5-flash" --output "baseline.json"
    การดำเนินการนี้จะสร้างไฟล์ baseline.json และพล็อตใน plots/baseline_dist.png

8. กำหนดค่าและเปิดใช้งานการปรับแต่ง

ตอนนี้คุณจะเปิดใช้งานการปรับแต่งที่มีการจัดการใน Vertex AI

  1. ในเทอร์มินัล ให้สร้างไฟล์ชื่อ tune.py
    cloudshell edit tune.py
  2. วางโค้ดต่อไปนี้ลงใน tune.py
    import os
import time
from google.cloud import aiplatform
import vertexai
from vertexai.preview.tuning import sft

# Configuration
PROJECT_ID = os.environ["PROJECT_ID"]
REGION = os.environ["REGION"]
BUCKET_NAME = os.environ["BUCKET_NAME"]

aiplatform.init(project=PROJECT_ID, location=REGION)

def train():
    print("Launching fine-tuning job...")

    sft_tuning_job = sft.train(
        source_model="gemini-2.5-flash", # Using specific version for stability
        train_dataset=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl",
        validation_dataset=f"gs://{BUCKET_NAME}/datasets/val/val_gemini.jsonl",
        epochs=1, # Keep it short for the lab
        adapter_size=4,
        learning_rate_multiplier=1.0,
        tuned_model_display_name="gemini-2.5-flash-wikilingua",
    )

    print(f"Job started: {sft_tuning_job.resource_name}")
    print("Waiting for job to complete... (this may take ~45 minutes)")

    # Wait for the job to complete
    while not sft_tuning_job.has_ended:
        time.sleep(60)
        sft_tuning_job.refresh()
        print(f"Status: {sft_tuning_job.state.name}")

    print("Job completed!")
    print(f"Tuned Model Endpoint: {sft_tuning_job.tuned_model_endpoint_name}")
    return sft_tuning_job.tuned_model_endpoint_name

if __name__ == "__main__":
    train()
  3. ในเทอร์มินัล ให้เรียกใช้สคริปต์การปรับแต่ง
    python tune.py
    หมายเหตุ: กระบวนการนี้อาจใช้เวลาประมาณ 45 นาที คุณสามารถตรวจสอบงานใน Vertex AI Console ได้

9. ทำความเข้าใจโค้ดการฝึก

ขณะที่งานกำลังทำงานอยู่ ลองดูสคริปต์ tune.py อย่างละเอียดเพื่อทำความเข้าใจวิธีการทำงานของการปรับแต่ง

การปรับแต่งภายใต้การควบคุมดูแลที่มีการจัดการ

สคริปต์ใช้วิธี vertexai.tuning.sft.train เพื่อส่งงานการปรับแต่งที่มีการจัดการ ซึ่งจะตัดความซับซ้อนของการจัดสรรโครงสร้างพื้นฐาน การกระจายการฝึก และการจัดการจุดตรวจสอบออก

sft_tuning_job = sft.train(
    source_model="gemini-2.5-flash",
    train_dataset=f"gs://{BUCKET_NAME}/datasets/train/train_gemini.jsonl",
    # ...
)

การกำหนดค่า LoRA

Vertex AI ทำให้การกำหนด LoraConfig ด้วยตนเองง่ายขึ้นเป็นพารามิเตอร์หลัก 2-3 รายการ ซึ่งแตกต่างจากที่คุณอาจทำในเฟรมเวิร์กโอเพนซอร์ส

  • adapter_size: พารามิเตอร์นี้ (ตั้งค่าเป็น 4 ในสคริปต์ของเรา) จะควบคุมอันดับของอะแดปเตอร์ LoRA ขนาดที่ใหญ่ขึ้นจะช่วยให้โมเดลเรียนรู้การปรับตัวที่ซับซ้อนมากขึ้น แต่จะเพิ่มจำนวนพารามิเตอร์ที่ฝึกได้
  • epochs: เราตั้งค่านี้เป็น 1 สำหรับห้องทดลองนี้เพื่อให้เวลาการฝึกสั้นลง (ประมาณ 20 นาที) ในสถานการณ์จริง คุณอาจเพิ่มค่านี้เพื่อให้โมเดลเรียนรู้จากข้อมูลของคุณได้ลึกซึ้งยิ่งขึ้น แต่คุณควรระวังการปรับให้เข้ากับข้อมูลการฝึกมากเกินไป

การเลือกโมเดล

เราระบุ source_model="gemini-2.5-flash" อย่างชัดเจน Vertex AI รองรับ Gemini หลายเวอร์ชัน และการปักหมุดเวอร์ชันที่เฉพาะเจาะจงจะช่วยให้ไปป์ไลน์ของคุณมีความเสถียรและทำซ้ำได้

10. เปรียบเทียบโมเดล

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

  1. รับอุปกรณ์ปลายทางของโมเดลที่ปรับแต่งแล้ว ระบบจะพิมพ์อุปกรณ์ปลายทางที่ส่วนท้ายของสคริปต์ tune.py โดยจะมีลักษณะคล้ายกับ projects/.../locations/.../endpoints/...
  2. เรียกใช้สคริปต์การประเมินอีกครั้ง โดยคราวนี้ส่งโมเดลที่ปรับแต่งแล้วและผลลัพธ์เกณฑ์พื้นฐานเพื่อเปรียบเทียบ
    # Replace [YOUR_TUNED_MODEL_ENDPOINT] with the actual endpoint name
export TUNED_MODEL="projects/[YOUR_PROJECT_ID]/locations/[YOUR_REGION]/endpoints/[YOUR_ENDPOINT_ID]"

python evaluate.py --model "$TUNED_MODEL" --baseline "baseline.json" --output "tuned.json"
  3. ดูผลลัพธ์ สคริปต์จะแสดงการเปรียบเทียบคะแนน ROUGE และสร้างแผนภูมิ plots/comparison.png ที่แสดงการปรับปรุง คุณสามารถดูพล็อตได้โดยเปิดโฟลเดอร์ plots ใน Cloud Shell Editor

11. ล้างข้อมูล

ลบทรัพยากรที่คุณสร้างขึ้นเพื่อหลีกเลี่ยงค่าใช้จ่าย

  1. ในเทอร์มินัล ให้ลบ Bucket ของ Cloud Storage และโมเดลที่ปรับแต่งแล้ว
    gcloud storage rm -r gs://$BUCKET_NAME
# Note: You can delete the model endpoint from the Vertex AI Console

12. ยินดีด้วย

คุณปรับแต่ง Gemini 2.5 Flash ใน Vertex AI ได้สำเร็จแล้ว

สรุป

ในห้องทดลองนี้ คุณได้ทำสิ่งต่อไปนี้

  • เตรียมชุดข้อมูลในรูปแบบ JSONL สำหรับการปรับแต่ง Gemini
  • กำหนดเกณฑ์พื้นฐานโดยใช้โมเดล Gemini 2.5 Flash พื้นฐาน
  • เปิดใช้งานการปรับแต่งภายใต้การควบคุมดูแลใน Vertex AI
  • ประเมินและเปรียบเทียบโมเดลที่ปรับแต่งแล้วกับเกณฑ์พื้นฐาน

ขั้นตอนถัดไป

ห้องทดลองนี้เป็นส่วนหนึ่งของเส้นทางการเรียนรู้ AI พร้อมใช้งานจริงกับ Google Cloud

สำรวจหลักสูตรทั้งหมดเพื่อเชื่อมช่องว่างจากต้นแบบไปสู่เวอร์ชันที่ใช้งานจริง

แชร์ความคืบหน้าของคุณด้วยแฮชแท็ก #ProductionReadyAI