โมดูลนี้ครอบคลุมแนวคิดและเทคนิคสำคัญสำหรับการสร้างพรอมต์ที่มีประสิทธิภาพในโมเดล AI สร้างสรรค์ วิธีการเขียนพรอมต์ไปยัง LLM ก็มีความสำคัญเช่นกัน พรอมต์ที่ถูกออกแบบอย่างรอบคอบสามารถทำให้ได้คุณภาพการตอบสนองที่ดีกว่า แต่คำว่า พรอมต์ และ การออกแบบพรอมต์ หมายถึงอะไรกันแน่? และฉันจะปรับปรุงข้อมูล อินพุตพรอมต์ ที่ฉันส่งไปยัง LLM ได้อย่างไร? คำถามเหล่านี้เราจะพยายามตอบภายในบทนี้และบทถัดไป
Generative AI มีความสามารถในการสร้างเนื้อหาใหม่ (เช่น ข้อความ, รูปภาพ, เสียง, โค้ด ฯลฯ) ตามคำร้องขอของผู้ใช้ โดยใช้ โมเดลภาษาใหญ่ (LLMs) เช่น ซีรีส์ GPT ของ OpenAI ("Generative Pre-trained Transformer") ซึ่งได้รับการฝึกฝนเพื่อใช้ภาษาธรรมชาติและโค้ด
ผู้ใช้สามารถโต้ตอบกับโมเดลเหล่านี้ได้โดยใช้รูปแบบที่คุ้นเคย เช่น แชท โดยไม่จำเป็นต้องมีความเชี่ยวชาญทางเทคนิคหรือการฝึกอบรม โมเดลเหล่านี้เป็นแบบ ขึ้นอยู่กับพรอมต์ — ผู้ใช้ส่งข้อความอินพุต (พรอมต์) และได้รับการตอบกลับจาก AI (การเติมข้อมูล) จากนั้นสามารถ "แชทกับ AI" อย่างต่อเนื่องในบทสนทนาหลายรอบ ปรับพรอมต์จนกว่าคำตอบจะตรงกับความคาดหวัง
“พรอมต์” กลายเป็น อินเทอร์เฟซโปรแกรมหลัก สำหรับแอป generative AI บอกโมเดลว่าจะทำอะไร และมีผลต่อคุณภาพของการตอบกลับ “การออกแบบพรอมต์” เป็นสาขาวิชาที่เติบโตอย่างรวดเร็วที่มุ่งเน้นที่ การออกแบบและการปรับแต่ง พรอมต์เพื่อให้ได้การตอบสนองที่สม่ำเสมอและมีคุณภาพในระดับกว้าง
ในบทเรียนนี้ เราจะเรียนรู้ว่า การออกแบบพรอมต์คืออะไร ทำไมจึงสำคัญ และเราจะสร้างพรอมต์ที่มีประสิทธิภาพมากขึ้นสำหรับโมเดลและวัตถุประสงค์แอปพลิเคชันได้อย่างไร เราจะเข้าใจแนวคิดหลักและแนวทางปฏิบัติที่ดีที่สุดสำหรับการออกแบบพรอมต์ — และเรียนรู้เกี่ยวกับสภาพแวดล้อม sandbox แบบโต้ตอบด้วย Jupyter Notebooks ซึ่งเราสามารถดูแนวคิดเหล่านี้ถูกใช้ในตัวอย่างจริง
เมื่อจบบทเรียนนี้ เราจะสามารถ:
- อธิบายว่าการออกแบบพรอมต์คืออะไรและทำไมจึงสำคัญ
- อธิบายส่วนประกอบของพรอมต์และวิธีการใช้งาน
- เรียนรู้แนวปฏิบัติและเทคนิคที่ดีที่สุดสำหรับการออกแบบพรอมต์
- นำเทคนิคที่เรียนรู้ไปใช้กับตัวอย่างจริงโดยใช้ OpenAI endpoint
การออกแบบพรอมต์ (Prompt Engineering): การปฏิบัติในการออกแบบและปรับแต่งอินพุตเพื่อชี้นำโมเดล AI ให้ผลิตผลลัพธ์ตามที่ต้องการ
การแยกหน่วยภาษา (Tokenization): กระบวนการแปลงข้อความเป็นหน่วยเล็ก ๆ ที่เรียกว่าโทเคน ซึ่งโมเดลสามารถเข้าใจและประมวลผลได้
Instruction-Tuned LLMs: โมเดลภาษาใหญ่ที่ได้รับการฝึกเพิ่มเติมด้วยคำสั่งเฉพาะเพื่อปรับปรุงความแม่นยำและความเกี่ยวข้องของการตอบสนอง
การออกแบบพรอมต์ในปัจจุบันยังถือว่าเป็นศิลปะมากกว่าวิทยาศาสตร์ วิธีที่ดีที่สุดในการปรับปรุงสัญชาตญาณของเราคือการ ฝึกฝนมากขึ้น และใช้วิธีลองผิดลองถูก ซึ่งผสมผสานความเชี่ยวชาญในโดเมนการใช้งานกับเทคนิคแนะนำและการปรับแต่งเฉพาะโมเดล
Jupyter Notebook ที่แนบมาพร้อมบทเรียนนี้มีสภาพแวดล้อม sandbox ที่คุณสามารถทดลองสิ่งที่เรียนรู้ไปแล้ว — ระหว่างเรียนหรือเป็นส่วนหนึ่งของความท้าทายโค้ดตอนท้าย ในการดำเนินแบบฝึกหัด คุณจะต้องมี:
- คีย์ API Azure OpenAI — จุดเชื่อมต่อบริการสำหรับ LLM ที่ผ่านการปรับใช้
- สภาพแวดล้อม Python Runtime — สำหรับรัน Notebook
- ตัวแปรสภาพแวดล้อมในเครื่อง — ทำตามขั้นตอน SETUP ตอนนี้เพื่อเตรียมพร้อม
โน้ตบุ๊คมาพร้อมแบบฝึกหัด เริ่มต้น — แต่คุณสามารถเสริมส่วน Markdown (คำอธิบาย) และ Code (คำขอพรอมต์) ของคุณเองเพื่อทดลองตัวอย่างหรือไอเดียเพิ่มเติม — และสร้างสัญชาตญาณสำหรับการออกแบบพรอมต์
ต้องการภาพรวมของสิ่งที่บทเรียนนี้ครอบคลุมก่อนเริ่มเรียนไหม? ลองดูคู่มือภาพประกอบนี้ ซึ่งจะช่วยให้เห็นหัวข้อหลักที่ครอบคลุมและแนวคิดสำคัญที่ควรคิดในแต่ละหัวข้อ แผนที่บทเรียนพาคุณจากการเข้าใจแนวคิดหลักและความท้าทาย ไปสู่การแก้ไขด้วยเทคนิคการออกแบบพรอมต์ที่เกี่ยวข้องและแนวปฏิบัติที่ดีที่สุด โปรดทราบว่าส่วน "เทคนิคขั้นสูง" ในคู่มือนี้ หมายถึงเนื้อหาที่ครอบคลุมในบทถัดไปของหลักสูตรนี้
ตอนนี้ มาพูดถึงว่า หัวข้อนี้ เกี่ยวข้องกับพันธกิจสตาร์ตอัพของเราที่ นำพานวัตกรรม AI สู่การศึกษา อย่างไร เราต้องการสร้างแอป AI ที่ขับเคลื่อนการเรียนรู้ แบบส่วนบุคคล — ลองคิดว่าผู้ใช้แต่ละกลุ่มของแอปเราจะ "ออกแบบ" พรอมต์กันอย่างไร:
- ผู้ดูแลระบบ อาจขอให้ AI วิเคราะห์ข้อมูลหลักสูตรเพื่อระบุช่องว่างในเนื้อหา AI สามารถสรุปผลลัพธ์หรือแสดงผลเป็นภาพด้วยโค้ด
- ครูผู้สอน อาจขอให้ AI สร้างแผนการสอนสำหรับกลุ่มเป้าหมายและหัวข้อ AI จะสร้างแผนส่วนบุคคลในรูปแบบที่กำหนด
- นักเรียน อาจขอให้ AI ติวเตอร์พวกเขาในวิชาที่ยาก AI จะช่วยสอนด้วยบทเรียน คำแนะนำ และตัวอย่างที่เหมาะให้ตรงกับระดับของนักเรียน
นี่เป็นเพียงจุดเริ่มต้น ลองดูที่ Prompts For Education — ห้องสมุดพรอมต์โอเพ่นซอร์สที่คัดสรรโดยผู้เชี่ยวชาญทางการศึกษา — เพื่อเห็นขอบเขตความเป็นไปได้ที่กว้างขึ้น! ลองรันพรอมต์เหล่านี้ใน sandbox หรือใช้ OpenAI Playground ดูว่าเกิดอะไรขึ้น!
เราเริ่มบทเรียนนี้ด้วยการนิยาม การออกแบบพรอมต์ ว่าเป็นกระบวนการ ออกแบบและปรับแต่ง อินพุตข้อความ (พรอมต์) เพื่อให้ได้การตอบสนอง (completion) ที่สม่ำเสมอและมีคุณภาพสำหรับวัตถุประสงค์ของแอปและโมเดลที่กำหนด เราสามารถคิดเป็นขั้นตอน 2 ขั้นตอน:
- ออกแบบ พรอมต์เริ่มต้นสำหรับโมเดลและวัตถุประสงค์ที่กำหนด
- ปรับแต่ง พรอมต์ซ้ำ ๆ เพื่อเพิ่มคุณภาพการตอบสนอง
นี่เป็นกระบวนการที่ต้องลองผิดลองถูก ซึ่งต้องใช้สัญชาตญาณและความพยายามจากผู้ใช้เพื่อให้ได้ผลลัพธ์ที่เหมาะสม แล้วทำไมมันถึงสำคัญ? คำตอบคือเราต้องเข้าใจสามแนวคิดนี้ก่อน:
- Tokenization = โมเดล "มองเห็น" พรอมต์อย่างไร
- Base LLMs = โมเดลฐาน "ประมวลผล" พรอมต์อย่างไร
- Instruction-Tuned LLMs = โมเดลสามารถมองเห็น "งาน" ได้อย่างไร
LLM มองพรอมต์เป็น ลำดับของโทเคน ซึ่งโมเดลต่าง ๆ (หรือเวอร์ชันของโมเดล) สามารถแยกโทเคนของพรอมต์เดียวกันได้แตกต่างกัน เนื่องจาก LLM ถูกฝึกด้วยโทเคน (ไม่ใช่ข้อความดิบ) วิธีที่พรอมต์ถูกแบ่งโทเคนจึงส่งผลโดยตรงต่อคุณภาพของคำตอบที่สร้างขึ้น
เพื่อเข้าใจการทำงานของ Tokenization ให้ลองใช้เครื่องมืออย่าง OpenAI Tokenizer ด้านล่างนี้ คัดลอกพรอมต์ของคุณเข้าไป แล้วดูว่ามันถูกแปลงเป็นโทเคนอย่างไร โดยสังเกตการจัดการช่องว่างและเครื่องหมายวรรคตอน โปรดทราบว่าตัวอย่างนี้แสดงโมเดล LLM รุ่นเก่า (GPT-3) ดังนั้นการลองกับโมเดลใหม่กว่าอาจให้ผลลัพธ์ต่างกัน
เมื่อพรอมต์ถูกแบ่งโทเคนแล้ว ฟังก์ชันหลักของ "Base LLM" (หรือโมเดลฐาน) คือการทำนายโทเคนถัดไปในลำดับนั้น เนื่องจาก LLM ถูกฝึกบนชุดข้อมูลข้อความจำนวนมหาศาล ทำให้มันมีความเข้าใจเชิงสถิติของความสัมพันธ์ระหว่างโทเคนและสามารถทำนายได้อย่างมั่นใจ โปรดทราบว่ามันไม่เข้าใจ ความหมาย ของคำในพรอมต์หรอโทเคน เพียงแค่เห็นรูปแบบที่สามารถ "เติมเต็ม" ด้วยการทำนายถัดไป โมเดลสามารถทำนายลำดับต่อเนื่องจนกว่าจะถูกหยุดโดยผู้ใช้หรือเงื่อนไขที่ตั้งไว้ล่วงหน้า
อยากเห็นว่าการเติมเนื้อหาด้วยพรอมต์ทำงานอย่างไร? ใส่พรอมต์ด้านบนใน Azure OpenAI Studio Chat Playground ด้วยการตั้งค่าพื้นฐาน ระบบถูกตั้งค่าให้ปฏิบัติต่อพรอมต์เป็นการขอข้อมูล — คุณจะเห็นการเติมเนื้อหาที่สอดคล้องกับบริบทนี้
แต่ถ้าผู้ใช้ต้องการเห็นบางสิ่งบางอย่างที่ตรงตามเกณฑ์หรือเป้าหมายของงานล่ะ? นี่คือที่ที่ Instruction-tuned LLM เข้ามา
Instruction Tuned LLM เริ่มต้นด้วยโมเดลฐานและฝึกปรับแต่งเพิ่มเติมกับตัวอย่างหรือคู่ข้อมูลอินพุต/ผลลัพธ์ (เช่น "ข้อความ" หลายรอบ) ที่มีคำสั่งชัดเจน — และ AI พยายามตอบสนองให้สอดคล้องกับคำสั่งนั้น
ใช้เทคนิคอย่าง Reinforcement Learning with Human Feedback (RLHF) ที่ช่วยฝึกโมเดลให้ ปฏิบัติตามคำสั่ง และ เรียนรู้จากข้อเสนอแนะ เพื่อให้ได้การตอบสนองที่เหมาะสมกับแอปพลิเคชันจริงและเกี่ยวข้องกับวัตถุประสงค์ของผู้ใช้มากขึ้น
ลองทำดู — กลับไปที่พรอมต์ข้างต้น แต่เปลี่ยน system message เพื่อให้คำสั่งต่อไปนี้เป็นบริบท:
สรุปเนื้อหาที่ได้รับให้กับนักเรียนชั้นประถมศึกษาปีที่ 2 จำกัดผลลัพธ์เป็นย่อหน้าเดียวพร้อมจุดย่อย 3-5 ข้อ
ดูว่าผลลัพธ์ถูกปรับแต่งให้สะท้อนเป้าหมายและรูปแบบที่ต้องการอย่างไร ครูผู้สอนสามารถใช้งานตอบกลับนี้โดยตรงในสไลด์สำหรับชั้นเรียนได้
เมื่อเรารู้ว่า LLM ประมวลผลพรอมต์อย่างไร ต่อไปมาคุยกันว่า ทำไม เราต้องการการออกแบบพรอมต์ คำตอบอยู่ที่ว่า LLM ปัจจุบันมีความท้าทายหลายประการซึ่งทำให้ การเติมเนื้อหาที่เชื่อถือได้และสม่ำเสมอ ยากขึ้นหากไม่ใส่ความพยายามในการสร้างและปรับแต่งพรอมต์ เช่น:
-
การตอบกลับของโมเดลมีความสุ่ม พรอมต์เดิม อาจให้ผลลัพธ์ต่างกันเมื่อใช้โมเดลต่างกันหรือเวอร์ชันต่างกัน และอาจให้ผลลัพธ์แตกต่างกันแม้แต่กับ โมเดลเดียวกัน ในเวลาต่างกัน เทคนิคการออกแบบพรอมต์ช่วยลดความแปรปรวนเหล่านี้โดยจัดกรอบการใช้งานได้ดีขึ้น
-
โมเดลอาจสร้างข้อมูลเท็จ โมเดลได้รับการฝึกด้วยชุดข้อมูลที่ ใหญ่แต่จำกัด หมายความว่ามันขาดความรู้ในเรื่องที่อยู่นอกขอบเขตการฝึก ดังนั้นมันจึงอาจสร้างคำตอบที่ไม่ถูกต้อง หรือนิทาน หรือขัดแย้งกับข้อเท็จจริงที่รู้ เทคนิคการออกแบบพรอมต์ช่วยให้ผู้ใช้ระบุและลดผลกระทบจากสิ่งเหล่านี้ เช่น การขอให้ AI อ้างอิงหรือให้เหตุผล
-
ความสามารถของโมเดลจะแตกต่างกัน โมเดลใหม่หรือรุ่นใหม่จะมีความสามารถมากขึ้น แต่ก็มีความลักษณะเฉพาะและข้อจำกัดที่แตกต่างกันในเรื่องต้นทุนและความซับซ้อน การออกแบบพรอมต์ช่วยพัฒนาแนวปฏิบัติและเวิร์กโฟลว์ที่ซ่อนความแตกต่างและปรับให้เหมาะกับความต้องการเฉพาะของโมเดลได้อย่างราบรื่นและขยายได้
ลองดูสิ่งนี้ใน OpenAI หรือ Azure OpenAI Playground:
- ใช้พรอมต์เดียวกันกับการปรับใช้ LLM ต่าง ๆ (เช่น OpenAI, Azure OpenAI, Hugging Face) — คุณเห็นความแตกต่างไหม?
- ใช้พรอมต์เดียวกันซ้ำ ๆ กับการปรับใช้ LLM เดียวกัน (เช่น Azure OpenAI playground) — ความแตกต่างเหล่านี้เป็นอย่างไร?
ในหลักสูตรนี้ เราใช้คำว่า "fabrication" เพื่ออ้างถึงปรากฏการณ์ที่ LLM บางครั้งสร้างข้อมูลที่ผิดพลาดเนื่องจากข้อจำกัดของการฝึกหรือข้อจำกัดอื่น ๆ คุณอาจเคยได้ยินคำนี้ในบทความหรือการวิจัยที่เรียกว่า "hallucinations" อย่างไรก็ตาม เราแนะนำให้ใช้คำว่า "fabrication" เพื่อไม่ให้พฤติกรรมถูกเข้าใจผิดว่าเป็นลักษณะของมนุษย์ซึ่งไม่เหมาะสมและเสริมแนวทาง Responsible AI ในแง่ของคำศัพท์ ซึ่งตัดคำที่อาจถือว่าไม่เหมาะสมหรือไม่ครอบคลุมในบางบริบทออก
อยากรู้ว่าการสร้างข้อมูลเท็จทำงานอย่างไร? ลองคิดพรอมต์ที่สั่งให้ AI สร้างเนื้อหาสำหรับหัวข้อที่ไม่มีอยู่จริง (เพื่อให้แน่ใจว่าไม่มีในชุดข้อมูลฝึก) ตัวอย่างเช่น — ฉันทดลองพรอมต์นี้:
พรอมต์: สร้างแผนการสอนเกี่ยวกับสงครามดาวอังคารในปี 2076. การค้นหาทางเว็บแสดงให้ฉันเห็นว่ามีเรื่องเล่าจินตนาการ (เช่น รายการโทรทัศน์หรือหนังสือ) เกี่ยวกับสงครามดาวอังคาร - แต่ไม่มีในปี 2076 สัญชาตญาณก็ยังบอกเราว่า 2076 อยู่ ในอนาคต และดังนั้น ไม่สามารถเชื่อมโยงกับเหตุการณ์จริงได้
แล้วจะเกิดอะไรขึ้นเมื่อเรารันพรอมต์นี้กับผู้ให้บริการ LLM ต่างกัน?
คำตอบที่ 1: OpenAI Playground (GPT-35)
คำตอบที่ 2: Azure OpenAI Playground (GPT-35)
คำตอบที่ 3: : Hugging Face Chat Playground (LLama-2)
ตามที่คาดไว้ แต่ละโมเดล (หรือเวอร์ชันของโมเดล) สร้างคำตอบที่แตกต่างกันเล็กน้อย เนื่องจากพฤติกรรมแบบสุ่มและความสามารถที่แตกต่างกันของโมเดล ตัวอย่างเช่น โมเดลหนึ่งมีเป้าหมายสำหรับผู้ฟังระดับมัธยมต้น ในขณะที่อีกโมเดลหนึ่งสมมติว่าผู้ใช้เป็นนักเรียนมัธยมปลาย แต่ทั้งสามโมเดลต่างก็สร้างคำตอบที่อาจโน้มน้าวให้ผู้ใช้ที่ไม่มีข้อมูลเชื่อว่าเหตุการณ์นั้นเป็นเรื่องจริง
เทคนิคการออกแบบพรอมต์ เช่น metaprompting และ temperature configuration อาจช่วยลดการสร้างข้อมูลเท็จของโมเดลได้ในระดับหนึ่ง สถาปัตยกรรมการออกแบบพรอมต์ใหม่ ๆ ยังผสานรวมเครื่องมือและเทคนิคใหม่ ๆ เข้าไปในลำดับพรอมต์อย่างราบรื่น เพื่อบรรเทาหรือช่วยลดผลกระทบบางส่วนเหล่านี้
เราจะสรุปส่วนนี้ด้วยการทำความเข้าใจว่าเทคนิคการออกแบบพรอมต์ถูกใช้ในโซลูชันในโลกจริงอย่างไร ผ่านการดูกรณีศึกษา: GitHub Copilot
GitHub Copilot คือ "โปรแกรมเมอร์คู่ AI" ของคุณ - มันแปลงพรอมต์ข้อความเป็นโค้ดที่เติมเต็มและถูกรวมเข้ากับสภาพแวดล้อมการพัฒนาของคุณ (เช่น Visual Studio Code) เพื่อประสบการณ์ผู้ใช้ที่ราบรื่น ตามที่บันทึกในซีรีส์บทความด้านล่าง เวอร์ชันแรกสุดอิงจากโมเดล OpenAI Codex - โดยวิศวกรตระหนักได้อย่างรวดเร็วถึงความจำเป็นในการปรับแต่งโมเดลและพัฒนาเทคนิคการออกแบบพรอมต์ที่ดียิ่งขึ้น เพื่อปรับปรุงคุณภาพโค้ด ในเดือนกรกฎาคม พวกเขาได้ เปิดตัวโมเดล AI ที่ปรับปรุงแล้วซึ่งก้าวข้าม Codex สำหรับคำแนะนำที่รวดเร็วขึ้น
อ่านโพสต์ตามลำดับเพื่อทำตามเส้นทางการเรียนรู้ของพวกเขา
- พฤษภาคม 2023 | GitHub Copilot กำลังเข้าใจโค้ดของคุณได้ดีขึ้น
- พฤษภาคม 2023 | เบื้องหลัง GitHub: การทำงานกับ LLMs เบื้องหลัง GitHub Copilot
- มิถุนายน 2023 | วิธีเขียนพรอมต์ที่ดีกว่าสำหรับ GitHub Copilot
- กรกฎาคม 2023 | .. GitHub Copilot ก้าวข้าม Codex ด้วยโมเดล AI ที่ปรับปรุงแล้ว
- กรกฎาคม 2023 | คู่มือสำหรับนักพัฒนาเกี่ยวกับการออกแบบพรอมต์และ LLMs
- กันยายน 2023 | วิธีสร้างแอป LLM สำหรับองค์กร: บทเรียนจาก GitHub Copilot
คุณยังสามารถเรียกดู บล็อกฝ่ายวิศวกรรม ของพวกเขาเพื่อดูโพสต์เพิ่มเติม เช่น โพสต์นี้ ซึ่งแสดงให้เห็นว่าโมเดลและเทคนิคเหล่านี้ถูก นำไปใช้ อย่างไรเพื่อขับเคลื่อนแอปพลิเคชันในโลกจริง
เราเห็นแล้วว่าทำไมการออกแบบพรอมต์จึงสำคัญ - ตอนนี้มาทำความเข้าใจวิธีที่พรอมต์ถูก สร้าง ขึ้นเพื่อให้เราสามารถประเมินเทคนิคต่างๆ สำหรับการออกแบบพรอมต์ที่มีประสิทธิภาพมากขึ้นได้
เริ่มจากพรอมต์พื้นฐาน: ข้อความนำส่งไปยังโมเดลโดยไม่มีบริบทอื่น ๆ นี่คือตัวอย่าง - เมื่อเราส่งคำเปิดบทเพลงชาติสหรัฐไปยัง OpenAI Completion API โมเดลจะ เติมคำตอบ ต่อด้วยคำถัดไปทันที แสดงพฤติกรรมการทำนายขั้นพื้นฐาน
| Prompt (Input) | Completion (Output) |
|---|---|
| Oh say can you see | ฟังดูเหมือนคุณกำลังเริ่มต้นเนื้อเพลง "The Star-Spangled Banner" เพลงชาติของสหรัฐอเมริกา เนื้อเพลงเต็มมีว่า ... |
ตอนนี้เพิ่มบริบทและคำแนะนำลงในพรอมต์พื้นฐานนั้น Chat Completion API ช่วยให้เราสร้างพรอมต์ซับซ้อนได้จากชุด ข้อความ ที่ประกอบด้วย:
- คู่ป้อนเข้า/ผลลัพธ์ที่สะท้อนถึงข้อมูลป้อนจาก ผู้ใช้ และคำตอบจาก ผู้ช่วย
- ข้อความระบบที่กำหนดบริบทสำหรับพฤติกรรมหรือบุคลิกของผู้ช่วย
คำขออยู่ในรูปแบบด้านล่าง โดยการ ตัดคำ (tokenization) เก็บข้อมูลที่เกี่ยวข้องจากบริบทและบทสนทนาไว้ได้อย่างมีประสิทธิภาพ การเปลี่ยนบริบทของระบบสามารถส่งผลต่อคุณภาพคำตอบได้มากเท่ากับข้อมูลป้อนของผู้ใช้
response = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who won the world series in 2020?"},
{"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
{"role": "user", "content": "Where was it played?"}
]
)ในตัวอย่างข้างต้น พรอมต์ของผู้ใช้เป็นข้อความง่าย ๆ ที่สามารถตีความเป็นคำขอข้อมูลได้ ด้วยพรอมต์แบบ คำสั่ง เราสามารถใช้ข้อความนั้นเพื่อระบุภารกิจอย่างละเอียดมากขึ้น ให้คำแนะนำที่ดีกว่าแก่ AI นี่คือตัวอย่าง:
| Prompt (Input) | Completion (Output) | Instruction Type |
|---|---|---|
| Write a description of the Civil War | คืนข้อความย่อหน้าเรียบง่าย | ง่าย |
| Write a description of the Civil War. Provide key dates and events and describe their significance | คืนข้อความย่อหน้าตามด้วยรายการวันที่สำคัญและคำอธิบายของเหตุการณ์ | ซับซ้อน |
| Write a description of the Civil War in 1 paragraph. Provide 3 bullet points with key dates and their significance. Provide 3 more bullet points with key historical figures and their contributions. Return the output as a JSON file | คืนข้อมูลรายละเอียดมากขึ้นในกล่องข้อความในรูปแบบ JSON ที่คุณสามารถคัดลอก-วางลงในไฟล์และตรวจสอบได้ตามต้องการ | ซับซ้อน. มีรูปแบบ. |
ในตัวอย่างข้างต้น พรอมต์ยังคงเป็นแบบเปิดกว้างพอสมควร ทำให้ LLM ตัดสินใจเลือกส่วนใดของชุดข้อมูลที่โมเดลฝึกมาแล้วได้ว่าสำคัญ ด้วยรูปแบบการออกแบบ เนื้อหาหลัก ข้อความนำเข้าจะแบ่งออกเป็นสองส่วน:
- คำสั่ง (การกระทำ)
- เนื้อหาที่เกี่ยวข้อง (ซึ่งมีผลต่อการกระทำ)
นี่คือตัวอย่างที่คำสั่งคือ "สรุปสิ่งนี้ใน 2 ประโยค"
| Prompt (Input) | Completion (Output) |
|---|---|
| Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history. It is named after the Roman god Jupiter.[19] When viewed from Earth, Jupiter can be bright enough for its reflected light to cast visible shadows,[20] and is on average the third-brightest natural object in the night sky after the Moon and Venus. Summarize this in 2 short sentences |
ดาวพฤหัสบดี ซึ่งเป็นดาวเคราะห์ดวงที่ห้าจากดวงอาทิตย์ เป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะ และเป็นที่รู้จักว่าเป็นหนึ่งในวัตถุที่สว่างที่สุดบนท้องฟ้ายามค่ำคืน ถูกตั้งชื่อตามเทพเจ้าพฤหัสบดีแห่งโรมัน เป็นดาวยักษ์แก๊สที่มีมวลหนักกว่าสองเท่าครึ่งของดาวเคราะห์ดวงอื่นทั้งหมดในระบบสุริยะรวมกัน |
ส่วนเนื้อหาหลักสามารถใช้ในหลายวิธีเพื่อขับเคลื่อนคำสั่งที่มีประสิทธิภาพมากขึ้น:
- ตัวอย่าง - แทนที่จะบอกโมเดลว่าให้ทำอะไรด้วยคำสั่งที่ชัดเจน ให้ตัวอย่างสิ่งที่ต้องทำและให้โมเดลสรุปรูปแบบ
- สัญญาณ - ตามคำสั่งด้วย "สัญญาณ" ที่เป็นตัวชี้นำคำตอบ เพื่อโน้มน้าวโมเดลไปยังคำตอบที่เกี่ยวข้องมากขึ้น
- แม่แบบ - นี่คือ 'สูตร' ที่ใช้ซ้ำได้สำหรับพรอมต์ที่มีที่ว่างสำหรับใส่ตัวแปร (variables) เพื่อปรับแต่งด้วยข้อมูลสำหรับกรณีการใช้งานเฉพาะ
เรามาสำรวจตัวอย่างเหล่านี้กัน
นี่คือแนวทางที่คุณใช้เนื้อหาหลักเพื่อ "ป้อนโมเดล" ด้วยตัวอย่างของผลลัพธ์ที่ต้องการสำหรับคำสั่งที่กำหนด และปล่อยให้โมเดลสรุปรูปแบบสำหรับผลลัพธ์ที่ต้องการ ตามจำนวนตัวอย่างที่ให้ เราสามารถมี zero-shot prompting, one-shot prompting, few-shot prompting เป็นต้น
พรอมต์ประกอบด้วยสามองค์ประกอบ:
- คำอธิบายงาน
- ตัวอย่างผลลัพธ์ที่ต้องการไม่กี่ตัว
- จุดเริ่มต้นของตัวอย่างใหม่ (ซึ่งกลายเป็นคำอธิบายงานอย่างเงียบ ๆ)
| Learning Type | Prompt (Input) | Completion (Output) |
|---|---|---|
| Zero-shot | "The Sun is Shining". Translate to Spanish | "El Sol está brillando". |
| One-shot | "The Sun is Shining" => ""El Sol está brillando". "It's a Cold and Windy Day" => |
"Es un día frío y ventoso". |
| Few-shot | The player ran the bases => Baseball The player hit an ace => Tennis The player hit a six => Cricket The player made a slam-dunk => |
Basketball |
สังเกตว่าต้องให้คำสั่งที่ชัดเจน ("Translate to Spanish") ในการ zero-shot prompting แต่คำสั่งนั้นจะถูกตีความเองในตัวอย่าง one-shot ตัวอย่าง few-shot แสดงให้เห็นว่าการเพิ่มตัวอย่างมากขึ้นช่วยให้โมเดลสามารถสรุปได้แม่นยำขึ้นโดยไม่ต้องเพิ่มคำสั่ง
เทคนิคอีกอย่างสำหรับการใช้เนื้อหาหลักคือการให้ สัญญาณ แทนการให้ตัวอย่าง ในกรณีนี้ เรากำลังโน้มน้าวโมเดลไปในทิศทางที่ถูกต้องโดยการ เริ่มต้น ด้วยข้อความตัวอย่างที่สะท้อนรูปแบบคำตอบที่ต้องการ โมเดลจะ "รับสัญญาณ" และดำเนินต่อในแนวทางนั้น
| Number of Cues | Prompt (Input) | Completion (Output) |
|---|---|---|
| 0 | Jupiter is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half times that of all the other planets in the Solar System combined. Jupiter is one of the brightest objects visible to the naked eye in the night sky, and has been known to ancient civilizations since before recorded history. Summarize This |
ดาวพฤหัสบดีเป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะของเราและอยู่ในลำดับที่ห้าจากดวงอาทิตย์ เป็นดาวยักษ์แก๊สที่มีมวลเท่ากับ 1/1000 ของดวงอาทิตย์ แต่มีน้ำหนักมากกว่าดาวเคราะห์อื่นทั้งหมดรวมกัน อารยธรรมโบราณรู้จักดาวพฤหัสบดีมานานแล้ว และสามารถมองเห็นได้อย่างชัดเจนในท้องฟ้ายามค่ำคืน |
| 1 | ดาวพฤหัสบดีเป็นดาวเคราะห์ดวงที่ห้าจากดวงอาทิตย์และเป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะ มันเป็นดาวยักษ์ก๊าซที่มีมวลเพียงหนึ่งในพันของดวงอาทิตย์ แต่เป็นสองเท่าครึ่งของมวลรวมของดาวเคราะห์ทั้งหมดยกเว้นดาวพฤหัสบดี ดาวพฤหัสบดีเป็นหนึ่งในวัตถุที่สว่างที่สุดที่มองเห็นด้วยตาเปล่าในท้องฟ้ายามค่ำคืน และเป็นที่รู้จักของอารยธรรมโบราณตั้งแต่ก่อนประวัติศาสตร์บันทึกไว้ สรุปสิ่งนี้ สิ่งที่เราได้เรียนรู้คือดาวพฤหัสบดี |
เป็นดาวเคราะห์ดวงที่ห้าจากดวงอาทิตย์และเป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะ มันเป็นดาวยักษ์ก๊าซที่มีมวลเพียงหนึ่งในพันของดวงอาทิตย์ แต่เป็นสองเท่าครึ่งของมวลรวมของดาวเคราะห์ทั้งหมดยกเว้นดาวพฤหัสบดี สามารถมองเห็นได้ง่ายด้วยตาเปล่า และเป็นที่รู้จักตั้งแต่สมัยโบราณ |
| 2 | ดาวพฤหัสบดีเป็นดาวเคราะห์ดวงที่ห้าจากดวงอาทิตย์และเป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะ มันเป็นดาวยักษ์ก๊าซที่มีมวลเพียงหนึ่งในพันของดวงอาทิตย์ แต่เป็นสองเท่าครึ่งของมวลรวมของดาวเคราะห์ทั้งหมดยกเว้นดาวพฤหัสบดี ดาวพฤหัสบดีเป็นหนึ่งในวัตถุที่สว่างที่สุดที่มองเห็นด้วยตาเปล่าในท้องฟ้ายามค่ำคืน และเป็นที่รู้จักของอารยธรรมโบราณตั้งแต่ก่อนประวัติศาสตร์บันทึกไว้ สรุปสิ่งนี้ 3 ข้อเท็จจริงสำคัญที่เราได้เรียนรู้: |
1. ดาวพฤหัสบดีเป็นดาวเคราะห์ดวงที่ห้าจากดวงอาทิตย์และเป็นดาวเคราะห์ที่ใหญ่ที่สุดในระบบสุริยะ 2. มันเป็นดาวยักษ์ก๊าซที่มีมวลเพียงหนึ่งในพันของดวงอาทิตย์... 3. ดาวพฤหัสบดีสามารถมองเห็นได้ด้วยตาเปล่าตั้งแต่สมัยโบราณ ... |
แม่แบบพรอมต์คือ สูตรที่กำหนดไว้ล่วงหน้าสำหรับพรอมต์ ที่สามารถเก็บและใช้งานซ้ำได้ตามต้องการ เพื่อให้ประสบการณ์ของผู้ใช้มีความสม่ำเสมอมากขึ้น ในรูปแบบที่ง่ายที่สุด มันเป็นเพียงชุดตัวอย่างพรอมต์เช่น ตัวอย่างนี้จาก OpenAI ที่มอบทั้งส่วนประกอบพรอมต์แบบโต้ตอบ (ข้อความผู้ใช้และระบบ) และรูปแบบคำขอที่ขับเคลื่อนด้วย API – เพื่อสนับสนุนการนำกลับมาใช้ใหม่
ในรูปแบบที่ซับซ้อนมากขึ้น เช่น ตัวอย่างนี้จาก LangChain จะมี ตัวแปรช่องว่าง ที่สามารถแทนที่ด้วยข้อมูลจากแหล่งต่าง ๆ (ข้อมูลผู้ใช้, บริบทระบบ, แหล่งข้อมูลภายนอก ฯลฯ) เพื่อสร้างพรอมต์แบบไดนามิก ซึ่งช่วยให้เราสร้างคลังแม่แบบพรอมต์ที่นำกลับมาใช้ใหม่ได้ เพื่อมอบประสบการณ์ผู้ใช้ที่สม่ำเสมอแบบ โปรแกรมเมติก ในระดับใหญ่
สุดท้าย คุณค่าที่แท้จริงของแม่แบบอยู่ที่ความสามารถในการสร้างและเผยแพร่ คลังแม่แบบพรอมต์ สำหรับโดเมนแอปพลิเคชันเฉพาะ – โดยแม่แบบพรอมต์นั้นจะได้รับการ ปรับแต่ง ให้สอดคล้องกับบริบทแอปพลิเคชันเฉพาะหรือมีตัวอย่างที่ทำให้การตอบสนองเหมาะสมและแม่นยำยิ่งขึ้นสำหรับกลุ่มผู้ใช้เป้าหมาย ตัวอย่างที่ดีคือ Prompts For Edu ที่รวบรวมคลังแม่แบบพรอมต์สำหรับโดเมนการศึกษา โดยเน้นวัตถุประสงค์สำคัญ เช่น การวางแผนบทเรียน การออกแบบหลักสูตร การติวนักเรียน ฯลฯ
หากเรามองว่าการสร้างพรอมต์ประกอบด้วยคำสั่ง (งาน) และเป้าหมาย (เนื้อหาหลัก) แล้ว เนื้อหารอง ก็เหมือนบริบทเพิ่มเติมที่เราให้เพื่อ มีอิทธิพลต่อผลลัพธ์ในบางวิธี อาจจะเป็นพารามิเตอร์ปรับแต่ง คำแนะนำรูปแบบ ต้นแบบหัวข้อ เป็นต้น ที่ช่วยให้โมเดล ปรับคำตอบ ให้เหมาะสมกับวัตถุประสงค์หรือความคาดหวังของผู้ใช้
ตัวอย่างเช่น: หากมีแคตตาล็อกหลักสูตรที่มีข้อมูลเมต้ามากมาย (ชื่อ คำอธิบาย ระดับ ป้ายกำกับข้อมูลเมตา ผู้สอน ฯลฯ) ของหลักสูตรทั้งหมดในหลักสูตรการเรียนรู้:
- เราสามารถกำหนดคำสั่งให้ "สรุปแคตตาล็อกหลักสูตรสำหรับฤดูใบไม้ร่วง 2023"
- เราสามารถใช้เนื้อหาหลักเพื่อให้ตัวอย่างผลลัพธ์ที่ต้องการไม่กี่ตัวอย่าง
- เราสามารถใช้เนื้อหารองเพื่อระบุ 5 "แท็ก" ที่สนใจสูงสุด
ตอนนี้ โมเดลสามารถให้สรุปในรูปแบบที่แสดงโดยตัวอย่างเหล่านั้น – แต่ถ้าผลลัพธ์มีแท็กหลายแท็ก ก็สามารถจัดลำดับความสำคัญ 5 แท็กที่ระบุในเนื้อหารองได้
ตอนนี้ที่เรารู้ว่าพรอมต์สามารถ สร้าง อย่างไร เราก็สามารถเริ่มคิดเกี่ยวกับการ ออกแบบ พรอมต์เพื่อให้สะท้อนถึงแนวทางปฏิบัติที่ดีที่สุด เราสามารถแบ่งเป็นสองส่วน – มีทัศนคติที่ถูกต้องและใช้เทคนิคที่เหมาะสม
การออกแบบพรอมต์เป็นกระบวนการลองผิดลองถูก ดังนั้นให้คำนึงถึงปัจจัยนำทางกว้างๆ สามประการไว้เสมอ:
-
ความเข้าใจโดเมนสำคัญ ความแม่นยำและความเกี่ยวข้องของคำตอบขึ้นกับ โดเมน ที่แอปพลิเคชันหรือผู้ใช้ทำงานอยู่ ใช้สัญชาตญาณและความเชี่ยวชาญโดเมนของคุณเพื่อ ปรับแต่งเทคนิค ให้เหมาะสม เช่น กำหนด บุคลิกเฉพาะโดเมน ในพรอมต์ระบบของคุณ หรือใช้ แม่แบบเฉพาะโดเมน ในพรอมต์ผู้ใช้ ให้เนื้อหารองสะท้อนบริบทเฉพาะโดเมน หรือใช้ สัญญาณและตัวอย่างเฉพาะโดเมน เพื่อชักนำโมเดลไปสู่รูปแบบการใช้งานที่คุ้นเคย
-
ความเข้าใจโมเดลสำคัญ เรารู้ว่าโมเดลมีลักษณะสุ่มตามธรรมชาติ แต่การใช้งานโมเดลอาจแตกต่างกันตามชุดข้อมูลฝึกฝนที่ใช้ (ความรู้ที่ฝึกไว้ล่วงหน้า) ความสามารถที่ให้ (เช่น ผ่าน API หรือ SDK) และประเภทเนื้อหาที่ถูกปรับแต่ง (เช่น โค้ด กับ รูปภาพ กับ ข้อความ) เข้าใจจุดแข็งและข้อจำกัดของโมเดลที่คุณใช้ และใช้ความรู้นั้นเพื่อ จัดลำดับความสำคัญงาน หรือสร้าง แม่แบบปรับแต่ง ที่เหมาะกับความสามารถโมเดล
-
การทำซ้ำและตรวจสอบสำคัญ โมเดลพัฒนาอย่างรวดเร็ว และเทคนิคการออกแบบพรอมต์ก็เช่นกัน ในฐานะผู้เชี่ยวชาญโดเมนอาจมีบริบทหรือเกณฑ์อื่นที่ แอปพลิเคชัน เฉพาะของคุณต้องการ ซึ่งอาจไม่เหมือนกับชุมชนทั่วไป ใช้เครื่องมือและเทคนิคการออกแบบพรอมต์เพื่อ "เริ่มต้น" การสร้างพรอมต์ แล้วทำซ้ำและตรวจสอบผลโดยใช้สัญชาตญาณและความเชี่ยวชาญโดเมนของคุณ บันทึกข้อมูลเชิงลึกและสร้าง ฐานความรู้ (เช่น คลังแม่แบบพรอมต์) ที่คนอื่นสามารถใช้เป็นจุดเริ่มต้นใหม่ เพื่อการทำซ้ำที่รวดเร็วขึ้นในอนาคต
ตอนนี้มาดูแนวทางปฏิบัติที่ดีที่สุดทั่วไปที่แนะนำโดย OpenAI และผู้ปฏิบัติ Azure OpenAI
| เรื่อง | เหตุผล |
|---|---|
| ประเมินโมเดลล่าสุด | เจเนอเรชันโมเดลใหม่มีแนวโน้มที่จะมีคุณลักษณะและคุณภาพที่ดีกว่า – แต่ก็อาจมีค่าใช้จ่ายสูงขึ้น ประเมินผลกระทบแล้วจึงตัดสินใจย้ายระบบ |
| แยกคำสั่งและบริบท | ตรวจสอบว่าผู้ให้บริการหรือโมเดลของคุณกำหนด ตัวคั่น เพื่อแยกคำสั่ง เนื้อหาหลัก และเนื้อหารองอย่างชัดเจน วิธีนี้ช่วยให้โมเดลประเมินน้ำหนักของโทเคนได้แม่นยำขึ้น |
| ระบุให้ชัดเจนและเจาะจง | ให้รายละเอียดเพิ่มเกี่ยวกับบริบทที่ต้องการ ผลลัพธ์ ความยาว รูปแบบ สไตล์ ฯลฯ เพื่อปรับปรุงคุณภาพและความสม่ำเสมอของคำตอบ จัดเก็บสูตรในแม่แบบนำกลับมาใช้ใหม่ได้ |
| อธิบายพร้อมตัวอย่าง | โมเดลอาจตอบสนองได้ดีกว่าด้วยวิธี "สาธิตพร้อมอธิบาย" เริ่มด้วยวิธี zero-shot ที่ให้คำสั่งโดยไม่มีตัวอย่าง จากนั้นลอง few-shot เป็นการปรับปรุง ให้ตัวอย่างผลลัพธ์ที่ต้องการเล็กน้อย ใช้อุปมาอุปไมยประกอบ |
| ใช้สัญญาณกระตุ้นให้เริ่มต้น | สนับสนุนให้โมเดลมุ่งสู่ผลลัพธ์โดยให้คำหรือตอนเริ่มที่เป็นจุดตั้งต้นสำหรับคำตอบ |
| ทำซ้ำเพิ่มความชัดเจน | บางครั้งคุณอาจต้องทำซ้ำคำสั่งให้โมเดล ฟังชั่นก่อนและหลังเนื้อหาหลัก ใช้คำสั่งและสัญญาณประกอบ ทำซ้ำและตรวจสอบเพื่อดูว่าวิธีใดใช้ได้ |
| ลำดับมีผล | ลำดับที่คุณจัดข้อมูลให้โมเดลอาจส่งผลต่อผลลัพธ์ แม้ในตัวอย่างการเรียนรู้ เนื่องจากอคติข้อมูลล่าสุด ลองตัวเลือกต่าง ๆ เพื่อหาสิ่งที่เหมาะสมที่สุด |
| ให้ทางเลือกสำหรับโมเดล | ให้โมเดลมี คำตอบสำรอง ที่จะตอบหากไม่สามารถทำงานได้ ลดโอกาสที่โมเดลจะสร้างคำตอบเท็จหรือบิดเบือน |
เหมือนกับแนวทางปฏิบัติใด ๆ ให้จำไว้ว่า ผลลัพธ์อาจแตกต่างกัน ขึ้นกับโมเดล งาน และโดเมนของคุณ ใช้สิ่งเหล่านี้เป็นจุดเริ่มต้น แล้วทำซ้ำเพื่อค้นหาสิ่งที่เหมาะกับคุณ ปรับปรุงกระบวนการออกแบบพรอมต์อย่างต่อเนื่องเมื่อมีโมเดลและเครื่องมือใหม่ ๆ พร้อมใช้งาน โดยเน้นที่ความสามารถในการเพิ่มขนาดกระบวนการและคุณภาพคำตอบ
ขอแสดงความยินดี! คุณมาถึงส่วนท้ายของบทเรียนแล้ว ถึงเวลาทดสอบแนวคิดและเทคนิคเหล่านั้นด้วยตัวอย่างจริง!
สำหรับงานนี้ เราจะใช้ Jupyter Notebook ที่มีแบบฝึกหัดให้คุณทำแบบโต้ตอบได้ คุณยังสามารถขยาย Notebook ด้วย Markdown และเซลล์โค้ดของคุณเองเพื่อสำรวจไอเดียและเทคนิคได้ด้วยตัวเอง
- (แนะนำ) เปิดใช้งาน GitHub Codespaces
- (ทางเลือก) โคลนรีโปไปยังเครื่องของคุณและใช้กับ Docker Desktop
- (ทางเลือก) เปิด Notebook ด้วยสภาพแวดล้อมรันไทม์ Notebook ที่คุณชอบ
- คัดลอกไฟล์
.env.copyที่โฟลเดอร์ root ของรีโปเป็น.envและกรอกค่าAZURE_OPENAI_API_KEY,AZURE_OPENAI_ENDPOINTและAZURE_OPENAI_DEPLOYMENTกลับไปที่ส่วน Learning Sandbox เพื่อศึกษาวิธีทำ
- เลือกเคอร์เนลรันไทม์ หากใช้ตัวเลือกที่ 1 หรือ 2 ให้เลือกเคอร์เนล Python 3.10.x ที่จัดเตรียมโดย dev container
ตอนนี้คุณพร้อมที่จะรันแบบฝึกหัดแล้ว โปรดทราบว่าไม่มีคำตอบที่ ถูกหรือผิด ในที่นี้ เพียงแต่สำรวจตัวเลือกด้วยวิธีลองผิดลองถูกและสร้างสัญชาตญาณว่าอะไรเหมาะกับโมเดลและโดเมนแอปพลิเคชัน
ด้วยเหตุนี้ บทเรียนนี้จึงไม่มีส่วนคำตอบโค้ดแทนที่ Notebook จะมีเซลล์ Markdown ชื่อ "My Solution:" ที่แสดงตัวอย่างผลลัพธ์เพื่อเป็นข้อมูลอ้างอิง
คำถาม: ข้อใดต่อไปนี้เป็นพรอมต์ที่ดีตามแนวทางปฏิบัติที่เหมาะสม?
- แสดงรูปภาพรถสีแดงให้ฉันดู
- แสดงรูปภาพรถสีแดงยี่ห้อ Volvo รุ่น XC90 จอดอยู่ริมหน้าผาพร้อมดวงอาทิตย์ลับขอบฟ้า
- แสดงรูปภาพรถสีแดงยี่ห้อ Volvo รุ่น XC90
คำตอบ: 2 ดีที่สุดเพราะให้รายละเอียดเกี่ยวกับ "อะไร" และลงลึกเฉพาะเจาะจง (ไม่ใช่แค่รถใดๆ แต่เป็นยี่ห้อและรุ่นเฉพาะ) และยังอธิบายฉากโดยรวม 3 เป็นลำดับถัดไปเพราะมีคำอธิบายมากเช่นกัน
ลองใช้เทคนิค "สัญญาณ" กับพรอมต์: เติมประโยค "แสดงรูปภาพรถสีแดงยี่ห้อ Volvo และ " ดูว่ามันตอบอะไร และคุณจะปรับปรุงอย่างไร?
ต้องการเรียนรู้แนวคิดการออกแบบพรอมต์อื่น ๆ เพิ่มเติมไหม? ไปที่ หน้าการเรียนรู้ต่อเนื่อง เพื่อค้นหาแหล่งข้อมูลดี ๆ เพิ่มเติมในหัวข้อนี้
ไปดูบทเรียนที่ 5 ที่ซึ่งเราจะเรียนรู้เกี่ยวกับ เทคนิคการออกแบบพรอมต์ขั้นสูง!
ข้อจำกัดความรับผิดชอบ:
เอกสารนี้แปลโดยใช้บริการแปลภาษาด้วยปัญญาประดิษฐ์ Co-op Translator แม้เราจะพยายามให้ความถูกต้องสูงสุด โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้องได้ เอกสารต้นฉบับในภาษาต้นทางถือเป็นแหล่งข้อมูลที่ถูกต้องและเชื่อถือได้ สำหรับข้อมูลสำคัญ แนะนำให้ใช้บริการแปลโดยมนุษย์มืออาชีพ เราจะไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความผิดใด ๆ ที่เกิดจากการใช้การแปลนี้