การสร้าง AI ที่เชื่อถือได้ด้วยความเร็ว 100 ไมล์ต่อชั่วโมง

1. ภาพรวม

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

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

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

สิ่งที่คุณจะสร้าง

ใน Codelab นี้ คุณจะได้สร้างต้นแบบ AI ที่เชื่อถือได้ซึ่งมีลักษณะดังนี้

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

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

เมื่อสิ้นสุด Codelab นี้ คุณจะทำสิ่งต่อไปนี้ได้

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

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

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

ข้อกำหนดเบื้องต้น

คุณควรมีสิ่งต่อไปนี้

• บัญชี Google ส่วนตัวที่ใช้อีเมล Gmail
• สิทธิ์เข้าถึง Google Cloud และความเข้าใจพื้นฐานเกี่ยวกับ CLI
• บัญชีสำหรับการเรียกเก็บเงินที่ใช้งานอยู่หรือเครดิตคลาวด์
• ทำความเข้าใจ Google Cloud และ Generative AI โดยใช้ Gemini ในภาพรวม

Gemini คือโมเดล AI ของ Google ที่สร้างขึ้นบนพื้นฐานของการให้เหตุผลที่ทันสมัยซึ่งจะช่วยให้คุณทำทุกไอเดียให้เป็นจริงได้ โมเดลนี้เหมาะอย่างยิ่งสำหรับการทำความเข้าใจข้อมูลหลายรูปแบบ การเขียนโค้ดแบบเป็น Agent และ Vibe Coding

การขอรับเครดิตเพื่อใช้ Google Cloud

หากต้องการรับเครดิต ให้ไปที่ลิงก์นี้แล้วเข้าสู่ระบบด้วยอีเมล Gmail (โดเมน gmail.com) จากนั้นยอมรับเครดิตในบัญชีสำหรับการเรียกเก็บเงินของ Google Cloud Platform (GCP) แล้วระบบจะนำเครดิตไปใช้กับบัญชีของคุณ

3. เหตุใด AI ที่เชื่อถือได้จึงมีความสำคัญ

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

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

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

มาดูตัวอย่างการวัดระยะไกลขนาดเล็กและเปรียบเทียบเอาต์พุต 2 แบบที่เป็นไปได้กัน

Racing Car Telemetry Data
{
   "speedMph": 118,
   "throttle": 91,
   "frontGrip": "nominal",
   "rearGrip": "low",
   "trackPosition": "Turn 1 Entry"
}

คำตอบจาก AI ที่ไม่ซับซ้อน

"Stay aggressive on the throttle and carry your speed into Turn 1"

การตอบกลับที่คำนึงถึงความน่าเชื่อถือ

"Rear grip is low at Turn 1 entry. Reduce your throttle slightly and prioritize a stable corner entry"

เห็นความแตกต่างไหม

จะเกิดอะไรขึ้นหากเราพึ่งพาคำตอบของ AI แบบง่ายๆ เพียงอย่างเดียว

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

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

ตอนนี้มาดูวิธีสร้างสถาปัตยกรรมดังกล่าวกัน

4. ทำความเข้าใจ AI ที่มีความเร็วสูงและสถาปัตยกรรมแบบโมดูลที่เชื่อถือได้

ระบบ AI บางระบบต้องการลักษณะการทำงานที่แตกต่างกันอย่างมาก โมเดลต้องตอบสนองต่อสภาวะที่เปลี่ยนแปลงอย่างรวดเร็วและยังรองรับการให้เหตุผลที่ช้าลงและรอบคอบมากขึ้นด้วย

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

การตัดสินใจบางอย่างต้องเกิดขึ้นแบบเรียลไทม์ การตัดสินใจบางอย่างต้องใช้เวลาคิดนานขึ้น

AI ที่เชื่อถือได้มักต้องมีทั้ง 2 อย่าง

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

ในโปรแกรมขนาดเล็กนี้ เรามีเส้นทางการตอบสนองและเส้นทางกลยุทธ์ที่นำไปใช้เป็นฟังก์ชัน Python

const telemetry = {
  speed: 147,
  grip: 0.68,
  corner_type: "sharp",
  lap_trend: "entering_corners_too_fast",
};

function reflexPath(event: typeof telemetry): string {
  if (event.grip < 0.70) {
    return "REFLEX: Reduce throttle now";
  }
  return "REFLEX: No urgent issue";
}

function strategyPath(event: typeof telemetry): string {
  if (event.lap_trend === "entering_corners_too_fast") {
    return "STRATEGY: Brake earlier and prioritize corner exit";
  }
  return "STRATEGY: Driving pattern looks stable";
}

console.log(reflexPath(telemetry));
console.log(strategyPath(telemetry));

ฟังก์ชันทั้ง 2 จะทํางานแตกต่างกันเมื่อได้รับข้อมูลการวัดและส่งข้อมูลเดียวกัน ฟังก์ชันรีเฟล็กซ์คือการเตือนทันที ฟังก์ชันกลยุทธ์จะให้คำแนะนำในการฝึกสอนตามกฎ

คุณคิดว่าการแยกตรรกะนี้ไว้ต่างหากมีประโยชน์อย่างไร

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

5. สร้างเซิร์ฟเวอร์การสตรีมข้อมูลการวัดและส่งข้อมูล

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

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

ในส่วนนี้ คุณจะได้ทำสิ่งต่อไปนี้

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

1. เปิด Cloud Shell

ก. ไปที่ คอนโซล Google Cloud
ข. สร้างโปรเจ็กต์ใหม่สำหรับโค้ดแล็บนี้ คลิกเมนูแบบเลื่อนลงของโปรเจ็กต์ที่ด้านบน

เมื่อสร้างโปรเจ็กต์ คุณสามารถลิงก์บัญชีสำหรับการเรียกเก็บเงินได้

(ไม่บังคับ) หากสร้างโปรเจ็กต์แล้ว คุณสามารถเปิดแผงด้านซ้าย คลิก Billing แล้วตรวจสอบว่าบัญชีสำหรับการเรียกเก็บเงินลิงก์กับบัญชี GCP นี้หรือไม่

ค. การขอรับคีย์ Gemini API

เมื่อเปิดใช้เครดิต Google Cloud แล้ว คุณจะต้องมีคีย์ Gemini API เพื่อเข้าถึง Gemini ใน Google Cloud

หากต้องการสร้างคีย์ Gemini API เราต้องใช้ Google Vertex AI Studio เพื่อสร้างคีย์

ใน Vertex AI Studio ให้คลิก "รับคีย์ API" ที่มุมซ้ายล่างเหนือ "เอกสารประกอบ" สร้างคีย์ API สำหรับ Gemini (มีลักษณะเป็นสตริงยาวที่มีอักขระที่ดูเหมือนจะสุ่ม) บันทึกคีย์นี้ไว้ในที่ปลอดภัย เราจะใช้คีย์ API นี้ในขั้นตอนที่ 6 "สร้างโปรแกรมจำลองรถแข่ง" เพื่อตรวจสอบสิทธิ์การเข้าถึง Gemini ใน Google Cloud

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

ง. คลิกไอคอน Cloud Shell ในแถบด้านบน (ไอคอนเทอร์มินัล) เพื่อเปิดเทอร์มินัลที่ใช้เบราว์เซอร์

จ. รอให้เซสชันเทอร์มินัลเริ่มต้น

2. รับโค้ด

โคลนที่เก็บหลัก

git clone https://github.com/ocupop/trustable-ai-codelab.git
cd trustable-ai-codelab

โปรดสังเกตว่ามี 2 โฟลเดอร์ในที่เก็บนี้ ได้แก่ "koru-application" (เว็บแอปพลิเคชัน) และ "streaming-telemetry-server" (การวัดและส่งข้อมูลทางไกลของรถแข่งแบบเรียลไทม์จำลอง) ขั้นตอนนี้อธิบาย "streaming-telemetry-server" เราจะใช้ "koru-application" ในขั้นตอนถัดไป

3. เปิดใช้ API ที่จำเป็น

เรียกใช้ครั้งเดียวต่อโปรเจ็กต์

# Set Project ID
gcloud config set project YOUR_PROJECT_ID
# Enable APIs
gcloud services enable \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  artifactregistry.googleapis.com

แทนที่ YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์จริง (หรือข้ามบรรทัดแรกหากตั้งค่าโปรเจ็กต์ไว้แล้ว)

คุณดู YOUR_PROJECT_ID ได้ในรายการโปรเจ็กต์

4. ติดตั้งใช้งานแบ็กเอนด์ใน Cloud Run

จากรูทของที่เก็บ (เช่น ตรวจสอบว่าคุณอยู่ในโฟลเดอร์ trustable-ai-codelab):

gcloud run deploy streaming-telemetry-server \
  --source streaming-telemetry-server \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated

โปรดทราบว่าคุณอาจต้องกด "Y" เมื่อได้รับข้อความแจ้ง

• การเรียกใช้ครั้งแรกอาจแจ้งให้คุณเปิดใช้ API หรือสร้างที่เก็บ Artifact Registry ให้ยอมรับตามที่จำเป็น
• หากคุณใช้ภูมิภาคอื่นที่ไม่ใช่ us-central1 ให้ระบุภูมิภาคนั้นโดยใช้ --region
• เมื่อการติดตั้งใช้งานเสร็จสมบูรณ์ gcloud จะพิมพ์ service-URL เราเพียงแค่ต้องต่อท้าย "events" ไปยัง URL นี้เพื่อใช้เป็นปลายทางแบบเต็มสำหรับเซิร์ฟเวอร์การวัดและส่งข้อมูล

5. ใช้ URL ของสตรีม

ตอนนี้เซิร์ฟเวอร์การวัดและส่งข้อมูลทางไกลจะส่งข้อมูลการวัดและส่งข้อมูลทางไกลจำลองโดยใช้เหตุการณ์ที่เซิร์ฟเวอร์ส่ง (SSE) ที่ปลายทางในรูปแบบต่อไปนี้

service-URL/events		// service-URL - the last line displayed by "deploy"

รูปแบบของปลายทางการสตรีมอยู่ในรูปแบบ https://streaming-telemetry-server-${PROJECT_NUMBER}.${REGION}.run.app/events โดยที่ $PROJECT_NUMBER และ $REGION จะตั้งค่าเป็นค่าสำหรับเซิร์ฟเวอร์ที่เฉพาะเจาะจง

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

คุณปิดแท็บเบราว์เซอร์เพื่อสิ้นสุดการเชื่อมต่อได้

ทดสอบด้วย curl:

ตอนนี้มาทดสอบจากบรรทัดคำสั่งเชลล์กัน

curl -N service-URL/events		# Replace service-URL with actual deployment endpoint

คุณควรเห็นข้อมูลที่สตรีมเข้ามาในหน้าต่าง Cloud Shell

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

สิ่งที่คุณควรสังเกต

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

แต่ก่อนอื่น มาสร้างส่วนหน้าของเว็บเพื่อแสดงข้อมูลเป็นภาพกัน

6. สร้างเครื่องจำลองการแข่งรถ

ในส่วนนี้ คุณจะได้ทำสิ่งต่อไปนี้

• สร้างการจำลองรถแข่ง
• เชื่อมต่อเซิร์ฟเวอร์การวัดและส่งข้อมูลทางไกลกับเว็บแอปพลิเคชันของรถแข่ง
• ดูการแข่งขันจำลอง

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

แอปพลิเคชัน AI ที่เชื่อถือได้ของเราใช้ทั้งประสิทธิภาพและความยืดหยุ่นของบริการ Google Cloud และข้อมูลอัจฉริยะในเครื่องที่ทำงานใน Chrome

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

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

โคลนแอปพลิเคชันส่วนหน้าจาก GitHub โดยทำดังนี้

git clone https://github.com/ocupop/trustable-ai-codelab.git
cd trustable-ai-codelab

เมื่อโคลนที่เก็บในแล็ปท็อปหรือเดสก์ท็อปแล้ว ให้เรียกใช้แอปพลิเคชัน

cd koru-application		# racing car simulation app
npm install
npm run dev

"Koru" เป็นสัญลักษณ์จากวัฒนธรรมเมารีในนิวซีแลนด์ ซึ่งแสดงถึงการเริ่มต้นใหม่

ใน Chrome ให้เปิดพอร์ตในเครื่องของคุณ (http://localhost:5173 ตามตัวอย่างด้านบน) คุณจะเห็นหน้า Landing Page สำหรับแอปพลิเคชัน "AI Motorsport Coaching"

คลิกปุ่ม "เปิดแดชบอร์ด ->" ซึ่งจะเริ่ม UI สำหรับแอปพลิเคชัน

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

คลิกไอคอนรูปเฟือง (การตั้งค่า) ที่มุมขวาบนของแอปพลิเคชัน

ป้อนคีย์ Gemini API จากขั้นตอนที่ 2 ซึ่งจะช่วยให้คุณเข้าถึงบริการ Gemini ใน Google Cloud ได้

คลิก "บันทึก" เพื่อให้แอปพลิเคชันจดจำคีย์ API ของคุณ

ตอนนี้มาเชื่อมต่อแอปพลิเคชันกับเซิร์ฟเวอร์การวัดและส่งข้อมูลกัน ในแดชบอร์ดแอปพลิเคชัน ให้คลิก "เซสชันสด"

ป้อน URL ที่เฉพาะเจาะจงของเซิร์ฟเวอร์การวัดและส่งข้อมูลทางไกลบนระบบคลาวด์ (ขั้นตอนที่ 5) ในช่องข้อความที่ระบุว่า "SSE URL or .txt file path" URL ของ SSE มีรูปแบบดังนี้

https://streaming-telemetry-server-${PROJECT_NUMBER}.${REGION}.run.app/events

เมื่อป้อน URL ของอุปกรณ์ปลายทางของเซิร์ฟเวอร์การวัดและส่งข้อมูลแล้ว ให้คลิก "เชื่อมต่อ" (ทางด้านขวาของช่องข้อความ) อย่าลืมใส่ "events" ต่อท้าย URL

ตอนนี้คุณควรเห็นแอปพลิเคชันที่แสดงภาพข้อมูลจำลองแล้ว

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

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

7. เตรียมข้อมูลการวัดและส่งข้อมูลเพื่อการให้เหตุผลของ AI

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

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

ในส่วนนี้ คุณจะได้ทำสิ่งต่อไปนี้

• ตรวจสอบ JSON ของการวัดและส่งข้อมูลแบบดิบ
• ระบุช่องที่เกี่ยวข้องมากที่สุดสำหรับการให้เหตุผล
• กรองหรือสรุปข้อมูล
• ลดรายละเอียดที่ไม่จำเป็น
• เตรียมการแสดงสถานะการขับขี่ที่เหมาะกับ AI

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

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

../src/services/telemetryStreamService.ts near line 180

// Clamp G-forces
gLat = Math.max(-3, Math.min(3, gLat));		// sideways G-force
gLong = Math.max(-3, Math.min(3, gLong));	// front/back G-force

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

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

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

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

ในไฟล์เดียวกัน (telemetryStreamService.ts) ใกล้บรรทัดที่ 158 คุณจะเห็นฟังก์ชัน processPoint() ในฟังก์ชันนั้น ให้จำกัดความเร็ว

เปลี่ยน

private processPoint(point: GpsSSEPoint) {
...
 const speedKmh = point.speed > 200 ? point.speed : point.speed * 3.6;
...

ถึง:

private processPoint(point: GpsSSEPoint) {
...
 let speedKmh = point.speed > 200 ? point.speed : point.speed * 3.6;
 speedKmh = Math.min(speedKmh, 48);   // 48 kmh is approx 30 mph
...

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

ตอนนี้ให้เปลี่ยนกลับการเปลี่ยนแปลงเหล่านั้นและเรียกใช้แอปพลิเคชันอีกครั้ง

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

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

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

8. เพิ่มการควบคุมและประสบการณ์จากผู้เชี่ยวชาญที่เข้ารหัส

ระบบ AI ที่เชื่อถือได้ไม่ควรอาศัยเอาต์พุตโมเดลเพียงอย่างเดียว ในหลายๆ กรณี ระบบที่เชื่อถือได้มากที่สุดจะรวมการให้เหตุผลของโมเดลภาษาขนาดใหญ่เข้ากับกฎที่ชัดเจน ความรู้เกี่ยวกับโดเมน และข้อจํากัดที่เจ้าหน้าที่แนะนำ

ในส่วนนี้ คุณจะเพิ่มเลเยอร์ดังกล่าว

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

ในส่วนนี้ คุณจะได้ทำสิ่งต่อไปนี้

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

มาดูกันว่าเราจะเพิ่มความเชี่ยวชาญเฉพาะด้านลงในแอปพลิเคชันได้อย่างไร

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

../src/utils/coachingKnowledge.ts near line 115

...
export const RACING_PHYSICS_KNOWLEDGE = `
CORE PRINCIPLES:
1. **The Friction Circle:** A tire has 100% grip. If you use 100% for braking, you have 0% for turning.
  - *Error:* Turning while 100% braking = Understeer (Plowing).
  - *Fix:* "Trail braking" (releasing brake pressure as steering angle increases).

2. **Weight Transfer:**
  - Braking shifts weight forward (Front grip UP, Rear grip DOWN).
  - Accelerating shifts weight backward (Front grip DOWN, Rear grip UP).
  - *Error:* Lifting off throttle mid-corner shifts weight forward abruptly -> Oversteer (Spin risk).

3. **The racing line:**
...

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

มาลบ RACING_PHYSICS_KNOWLEDGE ออก แล้วดูคำแนะนำเกี่ยวกับการแข่งรถกัน

export const RACING_PHYSICS_KNOWLEDGE = ``;

เรียกใช้แอปพลิเคชันอีกครั้ง ปัจจุบันเราได้รับคำแนะนำในการฝึกประเภทใด

สังเกตคำแนะนำทั่วไป

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

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

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

9. ออกแบบลักษณะตัวตนของการโค้ชและประสบการณ์ของผู้ใช้

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

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

ในส่วนนี้ คุณจะได้ทำสิ่งต่อไปนี้

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

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

PERSONA	ลักษณะ
Tony	สร้างแรงบันดาลใจตามความรู้สึก
Rachel	เทคนิค เน้นฟิสิกส์
AJ	คำสั่งตรงๆ
Garmin	การเพิ่มประสิทธิภาพเดลต้าที่เน้นข้อมูล
Super AJ	สวิตช์ที่ปรับเปลี่ยนได้ต่อประเภทข้อผิดพลาด

โดยมีการกำหนดลักษณะตัวตนเหล่านี้ไว้ในไฟล์ ../src/utils/coachingKnowledge.ts

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

มาลองเปลี่ยนsystem promptsหนึ่งรายการ แล้วดูว่า LLM จะตอบสนองอย่างไร

ที่บรรทัด 31 คุณจะเห็น systemPrompt สำหรับ "AJ" ซึ่งเป็นคนตรงไปตรงมาและพูดจาโผงผาง มาเปลี่ยนsystemPromptเพื่อให้ AJ สุภาพมากเกินไปกัน

systemPrompt: `You are AJ, a race engineer that is excessively polite. 
	Use telemtry terminology.  Be actionable
	Examples: 	"Lat G settling. please throttle", 
				"Brake when its convenient."
	Keep responses under 12 words. Never explain — just command.`

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

ตอนนี้ให้กู้คืน systemPrompt เดิมและเรียกใช้แอปพลิเคชันอีกครั้ง โปรดทราบว่าพรอมต์ของระบบมีความสำคัญอย่างยิ่งในการชี้นำ LLM ให้ตอบสนองตามลักษณะตัวตน

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

ระบบที่เชื่อถือได้ต้องสื่อสารได้ดี ประสบการณ์ของผู้ใช้เป็นส่วนหนึ่งของสถาปัตยกรรมความน่าเชื่อถือ

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

10. ตรวจสอบสถาปัตยกรรมแบบครบวงจร

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

ตอนนี้แอปพลิเคชันของคุณมีคอมโพเนนต์ต่อไปนี้

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

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

เราจะเพิ่มการบันทึกเพื่อดูข้อมูลการวัดและส่งข้อมูลเมื่อไหลผ่านเส้นทาง

ก่อนอื่น มาดูข้อมูลการวัดและส่งข้อมูลกัน ใน telemetryStreamService.ts ที่บรรทัดที่ 212 โดยประมาณ (ก่อน this.emit(frame) ให้เพิ่มบรรทัดที่แสดงความเร็ว แรง G ด้านข้าง (การเร่งความเร็วในแนวนอน) และแรงที่ผู้ขับเหยียบแป้นเบรก

console.log('FRAME', { 
    speed: frame.speed.toFixed(1), 
    gLat: frame.gLat.toFixed(2),
    brake: frame.brake.toFixed(0) }
);

โหลดแอปพลิเคชันซ้ำ ก่อนที่จะเรียกใช้แอปพลิเคชัน ให้เปิดคอนโซลใน DevTools ของ Chrome เพื่อดูข้อมูลการแก้ไขข้อบกพร่องนี้

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

ตอนนี้เรามาเพิ่มการบันทึกสำหรับเส้นทางรีเฟล็กซ์และเส้นทางกลยุทธ์กัน

ใน ../src/services/coachingService.ts ที่บรรทัดที่ 71 ก่อน this.emit() ให้เพิ่มบรรทัดการบันทึกสำหรับเส้นทาง reflex ดังนี้

console.log('Reflex', { 
	action: rule.action, 
	text, 
	coach: this.coachId }
);

และในไฟล์เดียวกัน ที่บรรทัดประมาณ 287 ก่อน this.emit() ให้เพิ่มบรรทัดการบันทึกที่คล้ายกันสำหรับเส้นทาง strategy (มาเพิ่มการตอบกลับการโค้ช text ที่ Gemini API ส่งคืนกัน)

console.log('Strategy', { 
	coach: coach.id, 
	chars: text.length, 
	preview: text.slice(0, 60) }
);

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

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

AI ที่เชื่อถือได้เป็นผลลัพธ์ทางสถาปัตยกรรม ไม่ใช่ฟีเจอร์เดียว

การแยกส่วน (การนำบริการออก)

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

gcloud run services delete streaming-telemetry-server \
  --region us-central1 \
  --platform managed

อย่าลืมแทนที่ us-central1 ด้วยภูมิภาคที่คุณใช้เมื่อทำการติดตั้งใช้งาน หากจำเป็น ยืนยันเมื่อได้รับข้อความแจ้ง

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

11. ความท้าทาย

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

ความท้าทายที่แนะนำ

• ย้ายตรรกะการฝึกสอนเพิ่มเติมไปยัง Edge
• แก้ไขการจำลองเพื่อรองรับฝนตกหรือแรงฉุดลดลง
• สํารวจว่าการปรับแต่งโมเดลหรือการปรับแต่งอาจช่วยปรับปรุงประสิทธิภาพได้อย่างไร
• ปรับสถาปัตยกรรมสำหรับโดเมนอื่น เช่น การแพทย์ การผลิต หรือโลจิสติกส์

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

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

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

12. ช่วงสรุปและขั้นตอนต่อไป

ใน Codelab นี้ คุณได้สร้างมากกว่าแค่การสาธิตการแข่งรถ คุณได้สร้างตัวอย่างที่เป็นรูปธรรมเกี่ยวกับวิธีออกแบบระบบ AI ที่เชื่อถือได้

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

ระบบ AI ที่เชื่อถือได้มักจะรวมองค์ประกอบต่อไปนี้

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

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