หมายเหตุ
การเข้าถึงหน้านี้ต้องได้รับการอนุญาต คุณสามารถลอง ลงชื่อเข้าใช้หรือเปลี่ยนไดเรกทอรีได้
การเข้าถึงหน้านี้ต้องได้รับการอนุญาต คุณสามารถลองเปลี่ยนไดเรกทอรีได้
Copilot ใน Microsoft Fabric เป็นเทคโนโลยีการช่วยเหลือ AI เชิงสร้างซึ่งมีจุดประสงค์เพื่อปรับปรุงประสบการณ์การวิเคราะห์ข้อมูลในแพลตฟอร์ม Fabric บทความนี้ช่วยให้คุณเข้าใจว่า Copilot ใน Fabric ทํางานอย่างไร และให้คําแนะนําและข้อควรพิจารณาระดับสูงเกี่ยวกับวิธีการที่คุณอาจใช้งานที่ดีที่สุด
หมายเหตุ
ความสามารถของ Copilot กําลังพัฒนาตลอดเวลา หากคุณวางแผนที่จะใช้ Copilot โปรดอย่าลืมอัปเดตรายเดือนของ Fabric และการเปลี่ยนแปลงหรือประกาศต่างๆ เกี่ยวกับประสบการณ์การใช้งาน Copilot
บทความนี้ช่วยให้คุณเข้าใจวิธีการทํางานของ Copilot ใน Fabric รวมถึงสถาปัตยกรรมและค่าใช้จ่าย ข้อมูลในบทความนี้มีไว้เพื่อแนะนําคุณและองค์กรของคุณให้ใช้และจัดการ Copilot อย่างมีประสิทธิภาพ บทความนี้มีการกําหนดเป้าหมายที่:
กรรมการ BI และผู้กํากับการวิเคราะห์หรือผู้จัดการ: ผู้มีอํานาจตัดสินใจที่มีหน้าที่ดูแลโปรแกรมและกลยุทธ์ BI และผู้ตัดสินใจว่าจะเปิดและใช้งาน Copilot ใน Fabric หรือเครื่องมือ AI อื่น ๆ หรือไม่
ผู้ดูแลระบบผ้า: บุคลากรในองค์กรที่ดูแล Microsoft Fabric และปริมาณงานต่าง ๆ ผู้ดูแลระบบผ้าดูแลผู้ที่ใช้ Copilot ใน Fabric สําหรับแต่ละปริมาณงานเหล่านี้ และตรวจสอบว่าการใช้งาน Copilot ส่งผลต่อความจุผ้าที่มีอยู่อย่างไร
สถาปนิกข้อมูล: บุคคลที่รับผิดชอบในการออกแบบ การสร้าง และการจัดการแพลตฟอร์มและสถาปัตยกรรมที่สนับสนุนข้อมูลและการวิเคราะห์ในองค์กร สถาปนิกข้อมูลพิจารณาการใช้ Copilot ในการออกแบบสถาปัตยกรรม
ศูนย์แห่งความเป็นเลิศ (COE) ทีมไอทีและ BI: ทีมที่มีหน้าที่รับผิดชอบในการอํานวยความสะดวกในการปรับใช้และการใช้แพลตฟอร์มข้อมูลเช่น Fabric ในองค์กรให้ประสบความสําเร็จ ทีมงานและบุคคลเหล่านี้อาจใช้เครื่องมือ AI เช่น Copilot ด้วยตนเอง แต่ยังสนับสนุนและที่ปรึกษาผู้ใช้บริการตนเองในองค์กรเพื่อใช้ประโยชน์จากพวกเขาด้วย
ภาพรวมของวิธีการทํางานของ Copilot ใน Fabric
Copilot ใน Fabric ทํางานคล้ายกับ Microsoft Copilots อื่น ๆ เช่น Microsoft 365 Copilot, Microsoft Security Copilots และ Copilots และ AI ที่สร้างใน Power Platform อย่างไรก็ตาม มีหลายแง่มุมที่เฉพาะเจาะจงสําหรับวิธีการทํางานของ Copilot ใน Fabric
ไดอะแกรมภาพรวมของกระบวนการ
ไดอะแกรมต่อไปนี้แสดงภาพรวมของวิธีการทํางานของ Copilot ใน Fabric
หมายเหตุ
แผนภาพต่อไปนี้แสดงถึงสถาปัตยกรรมทั่วไปของ Copilot ใน Fabric อย่างไรก็ตาม อาจมีการเพิ่มหรือความแตกต่างทั้งนี้ขึ้นอยู่กับปริมาณงานและประสบการณ์ที่เฉพาะเจาะจง
ไดอะแกรมประกอบด้วยส่วนและกระบวนการต่อไปนี้:
| สินค้า | คำอธิบาย: |
|---|---|
| 1 | ผู้ใช้มีการป้อนข้อมูลไปยัง Copilot ใน Fabric, Power BI Desktop หรือแอปสําหรับอุปกรณ์เคลื่อนที่ Power BI อินพุตอาจเป็นพร้อมท์ที่เขียนขึ้นหรือการโต้ตอบอื่นที่สร้างพร้อมท์ การโต้ตอบทั้งหมดกับ Copilot เป็นแบบเฉพาะของผู้ใช้ |
| 2 | ข้อมูลป้อนเข้าประกอบด้วยข้อมูลที่รวมถึงพร้อมท์ โทเค็นของผู้ใช้ และบริบท เช่น ประวัติการแชทในเซสชัน Copilot ของผู้ใช้และเมตาดาต้าพร้อมเมตาดาต้าของระบบ รวมถึงตําแหน่งที่ผู้ใช้และสิ่งที่พวกเขากําลังทําใน Fabric หรือ Power BI Desktop |
| 3 | Copilot จัดการการประมวลผลล่วงหน้าและหลังการประมวลผลการป้อนข้อมูลของผู้ใช้และการตอบสนองแบบจําลองภาษาขนาดใหญ่ (LLM) ตามลําดับ บางขั้นตอนที่เฉพาะเจาะจงทําระหว่างการประมวลผลล่วงหน้าและหลังกระบวนการขึ้นอยู่กับว่า Copilot ประสบการณ์ของแต่ละบุคคลกําลังใช้ Copilot ต้องเปิดใช้งานโดยผู้ดูแลระบบ Fabric ในการตั้งค่าผู้เช่าเพื่อใช้งาน |
| 4 | ในระหว่างการประมวลผลล่วงหน้า Copilot ดําเนินการโดยพื้นฐานในการดึงข้อมูลบริบทเพิ่มเติมเพื่อปรับปรุงความเฉพาะเจาะจงและประโยชน์ของการตอบสนอง LLM ในที่สุด ข้อมูลพื้นฐานอาจรวมถึงเมตาดาต้า (เช่น Schema จากเลคเฮ้าส์หรือแบบจําลองเชิงความหมาย) หรือจุดข้อมูลจากรายการในพื้นที่ทํางาน หรือประวัติการแชทจากเซสชัน Copilot ปัจจุบัน Copilot ดึงข้อมูลพื้นฐานที่ผู้ใช้มีสิทธิ์เข้าถึงเท่านั้น |
| 5 | ผลลัพธ์ของการประมวลผลล่วงหน้าในการป้อนข้อมูลขั้นสุดท้าย: ข้อมูลพร้อมท์และพื้นฐานขั้นสุดท้าย ข้อมูลที่ส่งขึ้นอยู่กับประสบการณ์ Copilot ที่เฉพาะเจาะจงและสิ่งที่ผู้ใช้ถาม |
| 6 | Copilot ส่งข้อมูลป้อนเข้าไปยังบริการ Azure OpenAI บริการนี้จัดการโดย Microsoft และไม่สามารถกําหนดค่าโดยผู้ใช้ได้ Azure OpenAI ไม่ได้ฝึกแบบจําลองด้วยข้อมูลของคุณ ถ้า Azure OpenAI ไม่พร้อมใช้งานในพื้นที่ทางภูมิศาสตร์ของคุณ และคุณได้เปิดใช้งานการตั้งค่าผู้เช่า ที่ส่งไปยัง Azure OpenAI สามารถดําเนินการภายนอกภูมิภาคทางภูมิศาสตร์ ขอบเขตการปฏิบัติตามกฎระเบียบ หรืออินสแตนซ์คลาวด์แห่งชาติ จากนั้น Copilot อาจส่งข้อมูลของคุณภายนอกพื้นที่ทางภูมิศาสตร์เหล่านี้ |
| 7 | Azure OpenAI โฮสต์ LLMs เช่นชุดแบบจําลอง GPT Azure OpenAI ไม่ได้ใช้บริการสาธารณะหรือ API ของ OpenAI และ OpenAI ไม่สามารถเข้าถึงข้อมูลของคุณ LLM เหล่านี้สร้างโทเค็นการป้อนข้อมูลและใช้การฝังจากข้อมูลการฝึกเพื่อประมวลผลอินพุตลงในการตอบสนอง LLM จะถูกจํากัดในขอบเขตและขนาดของข้อมูลการฝึกของพวกเขา Azure OpenAI ประกอบด้วยการกําหนดค่าที่กําหนดวิธีการที่ LLM ประมวลผลอินพุตและการตอบสนองใดที่ส่งกลับ ลูกค้าไม่สามารถดูหรือเปลี่ยนแปลงการกําหนดค่านี้ได้ การโทรศัพท์ไปยังบริการ OpenAI จะดําเนินการผ่าน Azure และไม่ได้ผ่านอินเทอร์เน็ตสาธารณะ |
| 8 | การตอบสนอง LLM จะถูกส่งจาก Azure OpenAI ไปยัง Copilot ใน Fabric การตอบกลับนี้ประกอบด้วยข้อความ ซึ่งอาจเป็นภาษาธรรมชาติ รหัส หรือเมตาดาต้า การตอบสนองอาจรวมถึงข้อมูลที่ไม่ถูกต้องหรือมีคุณภาพต่ํา นอกจากนี้ยังเป็นแบบไม่มีการกําหนดซึ่งหมายความว่าอาจมีการส่งกลับการตอบสนองที่แตกต่างกันสําหรับการป้อนข้อมูลเดียวกัน |
| 9 | Copilot postprocesses การตอบสนอง LLM Postprocessing รวมถึงการกรองสําหรับความรับผิดชอบ AI แต่ยังเกี่ยวข้องกับการจัดการการตอบสนอง LLM และการผลิตเอาต์พุต Copilot ขั้นสุดท้าย ขั้นตอนเฉพาะที่ใช้ในระหว่างกระบวนการโพสต์ขึ้นอยู่กับประสบการณ์การใช้งานรายบุคคลของ Copilot |
| 10 | Copilot ส่งกลับผลลัพธ์สุดท้ายไปยังผู้ใช้ ผู้ใช้ตรวจสอบเอาต์พุตก่อนใช้งาน เนื่องจากเอาต์พุตไม่มีการระบุความน่าเชื่อถือ ความถูกต้อง หรือความน่าเชื่อถือ |
ส่วนถัดไปจะอธิบายห้าขั้นตอนในกระบวนการ Copilot ที่แสดงอยู่ในไดอะแกรมก่อนหน้า ขั้นตอนเหล่านี้อธิบายรายละเอียดว่า Copilot เปลี่ยนจากการป้อนข้อมูลของผู้ใช้ไปยังเอาต์พุตของผู้ใช้อย่างไร
ขั้นตอนที่ 1: ผู้ใช้ป้อนข้อมูลไปยัง Copilot
หากต้องการใช้ Copilot ผู้ใช้ต้องส่งการ ป้อนข้อมูลก่อน อินพุตนี้อาจเป็นข้อความแจ้งเตือนที่ผู้ใช้ส่งด้วยตนเอง หรืออาจเป็นพร้อมท์ที่สร้างขึ้นโดย Copilot เมื่อผู้ใช้เลือกองค์ประกอบแบบโต้ตอบใน UI ทั้งนี้ขึ้นอยู่กับปริมาณงาน Fabric รายการ และประสบการณ์ Copilot เฉพาะที่ผู้ใช้ใช้ พวกเขามีวิธีที่แตกต่างกันในการให้ข้อมูลป้อนเข้าไปยัง Copilot
ส่วนต่อไปนี้อธิบายตัวอย่างหลายตัวอย่างว่าผู้ใช้สามารถป้อนข้อมูลไปยัง Copilot ได้อย่างไร
ป้อนข้อมูลผ่านแผงการสนทนา Copilot
ด้วยประสบการณ์การใช้งาน Copilot มากมายใน Fabric คุณสามารถขยายแผงแชท Copilot เพื่อโต้ตอบกับ Copilot โดยใช้ภาษาธรรมชาติเช่นเดียวกับที่คุณทํากับแชทบอทหรือบริการส่งข้อความ ในแผงแชท Copilot คุณสามารถเขียนพร้อมท์ภาษาธรรมชาติที่อธิบายการดําเนินการที่คุณต้องการให้ Copilot ดําเนินการ อีกวิธีหนึ่งคือ แผงแชท Copilot อาจมีปุ่มที่มีพร้อมท์ที่แนะนําที่คุณสามารถเลือกได้ การโต้ตอบกับปุ่มเหล่านี้ทําให้ Copilot สร้างพร้อมท์ที่สอดคล้องกัน
รูปต่อไปนี้แสดงตัวอย่างของการใช้แผงการสนทนา Copilot เพื่อถามคําถามเกี่ยวกับข้อมูลเกี่ยวกับรายงาน Power BI
หมายเหตุ
ถ้าคุณใช้เบราว์เซอร์ Microsoft Edge คุณอาจสามารถเข้าถึง Copilot ที่นั่นได้ นอกจากนี้ Copilot ใน Microsoft Edge ยังสามารถเปิดแผงแชทของ Copilot (หรือแถบด้านข้าง) ในเบราว์เซอร์ของคุณได้ Copilot ใน Microsoft Edge ไม่สามารถโต้ตอบหรือใช้ประสบการณ์การใช้งาน Copilot ใดๆ ใน Fabric ได้ ในขณะที่ทั้งสอง Copilots มีประสบการณ์ผู้ใช้ที่คล้ายกัน Copilot ใน Microsoft Edge แยกจาก Copilot ใน Fabric อย่างสมบูรณ์
การป้อนข้อมูลผ่านหน้าต่างแบบผุดขึ้นที่ขึ้นอยู่กับบริบท
ในประสบการณ์การใช้งานบางอย่าง คุณสามารถเลือกไอคอน Copilot เพื่อทริกเกอร์หน้าต่างป็อปอัพเพื่อโต้ตอบกับ Copilot ตัวอย่างรวมถึงเมื่อคุณใช้ Copilot ในมุมมองคิวรี DAX หรือในมุมมองการเขียนสคริปต์ TMDL ของ Power BI Desktop หน้าต่างป๊อปอัปนี้มีพื้นที่สําหรับคุณในการป้อนพร้อมท์ภาษาธรรมชาติ (คล้ายกับแผงแชท Copilot) เช่นเดียวกับปุ่มบริบทเฉพาะที่สามารถสร้างพร้อมท์สําหรับคุณ หน้าต่างนี้อาจมีข้อมูลผลลัพธ์ เช่น คําอธิบายเกี่ยวกับคิวรี DAX หรือแนวคิดเมื่อใช้ Copilot ในมุมมองคิวรี DAX
รูปต่อไปนี้แสดงตัวอย่างของบุคคลที่ใช้ประสบการณ์ Copilot ในมุมมองคิวรี DAX เพื่ออธิบายคิวรีที่พวกเขาสร้างขึ้นโดยใช้ Copilot ใน Power BI
ชนิดของข้อมูลป้อนเข้าของผู้ใช้
การป้อนข้อมูลของ Copilot อาจมาจากพร้อมท์ที่เขียนหรือปุ่มใน UI:
พร้อมท์ที่เขียนขึ้น: ผู้ใช้สามารถเขียนพร้อมท์ในแผงการสนทนาของ Copilot หรือในประสบการณ์การใช้งาน Copilot อื่น ๆ เช่น มุมมองคิวรี DAX ใน Power BI Desktop ข้อความปรากฏเป็นลายลักษณ์อักษรกําหนดให้ผู้ใช้อธิบายคําแนะนําหรือคําถามสําหรับ Copilot อย่างเพียงพอ ตัวอย่างเช่น ผู้ใช้สามารถถามคําถามเกี่ยวกับแบบจําลองเชิงความหมายหรือรายงานเมื่อใช้ Copilot ใน Power BI
กระดุม: ผู้ใช้สามารถเลือกปุ่มในแผงการสนทนา Copilot หรือประสบการณ์การใช้งาน Copilot อื่น ๆ เพื่อให้การป้อนข้อมูล จากนั้น Copilot จะสร้างพร้อมท์ตามการเลือกผู้ใช้ ปุ่มเหล่านี้อาจเป็นการป้อนข้อมูลเริ่มต้นไปยัง Copilot เช่น คําแนะนําในแผงแชทของ Copilot อย่างไรก็ตาม ปุ่มเหล่านี้อาจปรากฏขึ้นในระหว่างเซสชันเมื่อ Copilot ทําการแนะนําหรือร้องขอการชี้แจง พร้อมท์ Copilot สร้างขึ้นอยู่กับบริบท เช่น ประวัติการแชทของเซสชันปัจจุบัน ตัวอย่างของการป้อนข้อมูลปุ่มคือ เมื่อคุณขอให้ Copilot แนะนําคําพ้องสําหรับเขตข้อมูลแบบจําลอง หรือคําอธิบายสําหรับหน่วยวัดแบบจําลอง
นอกจากนี้ คุณสามารถใส่ข้อมูลป้อนเข้าในบริการหรือแอปพลิเคชันที่แตกต่างกัน:
ผ้า: คุณสามารถใช้ Copilot ใน Fabric จากเว็บเบราว์เซอร์ของคุณ นี่เป็นวิธีเดียวที่จะใช้ Copilot สําหรับรายการใด ๆ ที่คุณสร้าง จัดการ และใช้ใน Fabric โดยเฉพาะ
Power BI Desktop: คุณสามารถใช้ Copilot ใน Power BI Desktop กับแบบจําลองความหมายและรายงานได้ ซึ่งรวมถึงประสบการณ์การพัฒนาและการใช้ Copilot สําหรับปริมาณงาน Power BI ใน Fabric
แอป Power BI สําหรับอุปกรณ์เคลื่อนที่: คุณสามารถใช้ Copilot ในแอป Power BI สําหรับอุปกรณ์เคลื่อนที่ถ้ารายงานอยู่ในพื้นที่ทํางานที่ได้รับการสนับสนุน (หรือแอปที่เชื่อมต่อกับพื้นที่ทํางานนั้น) ด้วยการเปิดใช้งาน Copilot
หมายเหตุ
หากต้องการใช้ Copilot กับ Power BI Desktop คุณต้องกําหนดค่า Power BI Desktop เพื่อใช้ปริมาณการใช้ Copilot จากพื้นที่ทํางานที่ได้รับการสนับสนุนโดยความจุ Fabric จากนั้นคุณสามารถใช้ Copilot กับแบบจําลองความหมายที่เผยแพร่ไปยังพื้นที่ทํางานใด ๆ รวมถึงพื้นที่ทํางาน Pro และ PPU
แม้ว่าคุณจะไม่สามารถเปลี่ยนพร้อมท์ที่ Copilot สร้างขึ้นเมื่อคุณเลือกปุ่มที่มีพร้อมท์เป็นลายลักษณ์อักษร คุณสามารถถามคําถามและให้คําแนะนําโดยใช้ภาษาธรรมชาติได้ หนึ่งในวิธีที่สําคัญที่สุดในการปรับปรุงผลลัพธ์ที่คุณได้รับจาก Copilot คือการเขียนพร้อมท์ที่ชัดเจนและสื่อความหมายที่ถูกต้องว่าคุณต้องการทําอย่างถูกต้อง
ปรับปรุงพร้อมท์ที่เขียนสําหรับ Copilot
ความชัดเจนและคุณภาพของพร้อมท์ที่ผู้ใช้ส่งไปยัง Copilot อาจส่งผลต่อประโยชน์ของการแสดงผลที่ผู้ใช้ได้รับ สิ่งที่ประกอบขึ้นเป็นพร้อมท์ที่เป็นลายลักษณ์อักษรที่ดีขึ้นอยู่กับประสบการณ์ Copilot เฉพาะที่คุณกําลังใช้ อย่างไรก็ตาม มีเทคนิคบางอย่างที่คุณสามารถนําไปใช้กับประสบการณ์ทั้งหมดเพื่อปรับปรุงพร้อมท์ของคุณโดยทั่วไป
ต่อไปนี้เป็นหลายวิธีในการปรับปรุงพร้อมท์ที่คุณส่งไปยัง Copilot:
ใช้พร้อมท์ภาษาภาษาอังกฤษ: วันนี้ ฟีเจอร์ของ Copilot จะทํางานได้ดีที่สุดในภาษาอังกฤษ นั่นเป็นเพราะ corpus ของข้อมูลการฝึกอบรมสําหรับ LLMs เหล่านี้ส่วนใหญ่เป็นภาษาอังกฤษ ภาษาอื่นๆ อาจไม่ทํางานด้วยเช่นกัน คุณสามารถลองเขียนพร้อมท์ในภาษาอื่นๆ แต่เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด เราขอแนะนําให้คุณเขียนและส่งพร้อมท์ภาษาภาษาอังกฤษ
เจาะจง: หลีกเลี่ยงความคลุมเครือหรือความคลุมเครือในคําถามและคําแนะนํา รวมรายละเอียดที่เพียงพอเพื่ออธิบายงานที่คุณต้องการให้ Copilot ทํางาน และผลลัพธ์ที่คุณคาดหวังคืออะไร
ให้บริบท: หากจําเป็น ให้บริบทที่เกี่ยวข้องสําหรับพร้อมท์ของคุณ รวมถึงสิ่งที่คุณต้องการทําหรือคําถามที่คุณต้องการตอบด้วยผลลัพธ์ ตัวอย่างเช่น คอมโพเนนต์หลักสําหรับพร้อมท์ที่ดีอาจรวมถึง:
- เป้าหมาย: เอาต์พุตใดที่คุณต้องการให้ Copilot บรรลุ
- บริบท: สิ่งที่คุณต้องการทํากับเอาต์พุตเฉพาะและเหตุผล
- ความคาดหวัง: สิ่งที่คุณคาดหวังว่าผลลัพธ์จะมีลักษณะเหมือน
- ที่มา: ข้อมูลหรือเขตข้อมูลใดที่ Copilot ควรใช้
ใช้คํากริยา: อ้างอิงถึงการดําเนินการเฉพาะที่คุณต้องการให้ Copilot ดําเนินการเช่น "สร้าง หน้ารายงาน" หรือ "กรอง ไปยังบัญชีคีย์ลูกค้า"
ใช้คําศัพท์ที่ถูกต้องและเกี่ยวข้อง: อ้างถึงคําศัพท์ที่เหมาะสมในพร้อมท์ของคุณอย่างชัดเจน เช่น ฟังก์ชัน เขตข้อมูล หรือชื่อตาราง ชนิดของวิชวล หรือคําศัพท์ทางเทคนิค หลีกเลี่ยงการสะกดผิด คําย่อ หรือตัวย่อ ตลอดจนไวยากรณ์ที่มัวยาว หรืออักขระที่ไม่เหมาะสม เช่น อักขระ Unicode หรืออิโมจิ
ทําซ้ําและแก้ไขปัญหา: เมื่อคุณไม่ได้รับผลลัพธ์ที่คาดหวัง ลองปรับพร้อมท์และส่งใหม่อีกครั้งเพื่อดูว่าวิธีนี้ช่วยปรับปรุงเอาต์พุตหรือไม่ ประสบการณ์การใช้งาน Copilot บางอย่างยังมีปุ่ม ลองใหม่ เพื่อส่งพร้อมท์เดิมอีกครั้งและตรวจสอบผลลัพธ์ที่แตกต่างกัน
สําคัญ
พิจารณาการฝึกอบรมผู้ใช้เพื่อเขียนพร้อมท์ที่ดีก่อนที่คุณจะเปิดใช้งาน Copilot สําหรับพวกเขา ตรวจสอบให้แน่ใจว่าผู้ใช้เข้าใจความแตกต่างระหว่างพร้อมท์ที่ชัดเจนที่สามารถสร้างผลลัพธ์ที่เป็นประโยชน์และพร้อมท์ที่คลุมเครือที่ไม่มี
นอกจากนี้เครื่องมือ Copilot และเครื่องมือ LLM อื่น ๆ ก็ไม่มีการกําหนด ซึ่งหมายความว่าผู้ใช้สองรายที่ส่งพร้อมท์เดียวกันที่ใช้ข้อมูลพื้นฐานเดียวกันอาจได้รับผลลัพธ์ที่แตกต่างกัน โดยไม่ใช่การกําหนดนี้มีอยู่กับเทคโนโลยีพื้นฐานของ AI ที่สร้างไว้และเป็นข้อควรพิจารณาที่สําคัญเมื่อคุณคาดหวังหรือต้องการผลลัพธ์แบบเชิงกําหนด เช่น คําตอบสําหรับคําถามเกี่ยวกับข้อมูล เช่น "ยอดขายในเดือนสิงหาคม 2021 คืออะไร"
ข้อมูลป้อนเข้าอื่นๆ ที่ Copilot ใช้ในการประมวลผลล่วงหน้า
นอกเหนือจากข้อมูลที่ผู้ใช้ให้ไว้ Copilot ยังดึงข้อมูลเพิ่มเติมที่ใช้ในการประมวลผลล่วงหน้าในระหว่างขั้นตอนถัดไป ข้อมูลนี้ประกอบด้วย:
โทเค็นของผู้ใช้ Copilot ไม่ทํางานภายใต้บัญชีระบบหรือผู้มีอํานาจ ข้อมูลทั้งหมดที่ส่งไปและใช้โดย Copilot เป็นข้อมูลเฉพาะสําหรับผู้ใช้ Copilot ไม่สามารถอนุญาตให้ผู้ใช้ดูหรือเข้าถึงรายการหรือข้อมูลที่พวกเขาไม่มีสิทธิ์ในการดู
ประวัติการแชทเซสชัน Copilot สําหรับเซสชันปัจจุบัน สําหรับประสบการณ์การสนทนาหรือแผงการสนทนา Copilot Copilot จะให้ประวัติการแชทสําหรับใช้ในการประมวลผลล่วงหน้าเป็นส่วนหนึ่งของบริบทข้อมูลพื้นฐานเสมอ Copilot จําหรือใช้ประวัติการแชทจากเซสชันก่อนหน้าได้
Meta-prompt พร้อมเมตาดาต้าของระบบ meta-prompt ให้บริบทเพิ่มเติมเกี่ยวกับตําแหน่งที่ผู้ใช้อยู่และสิ่งที่พวกเขากําลังทําใน Fabric หรือ Power BI Desktop ข้อมูล meta-prompt นี้ถูกใช้ระหว่างการประมวลผลล่วงหน้าเพื่อกําหนดทักษะหรือเครื่องมือ Copilot ควรใช้เพื่อตอบคําถามของผู้ใช้
เมื่อผู้ใช้ส่งการป้อนข้อมูลของพวกเขา Copilot จะดําเนินการขั้นตอนถัดไป
ขั้นตอนที่ 2: ตัวนําหน้าประมวลผลข้อมูลป้อนเข้า
ก่อนที่จะส่งพร้อมท์ไปยังบริการ Azure OpenAI Copilot จะประมวลผลล่วงหน้า การประมวลผลล่วงหน้าถือเป็นการดําเนินการทั้งหมดที่จัดการโดย Copilot ระหว่างเมื่อได้รับอินพุตและเมื่ออินพุตนี้ได้รับการประมวลผลในบริการ Azure OpenAI การประมวลผลล่วงหน้าเป็นสิ่งจําเป็นเพื่อให้แน่ใจว่าเอาต์พุตของ Copilot มีความเฉพาะและเหมาะสมกับคําแนะนําหรือคําถามของคุณ
คุณไม่สามารถส่งผลกระทบต่อสิ่งที่ทําก่อนการประมวลผลเสร็จสมบูรณ์โดย Copilot อย่างไรก็ตาม สิ่งสําคัญคือต้องทําความเข้าใจเกี่ยวกับการประมวลผลล่วงหน้าเพื่อให้คุณทราบว่าข้อมูลใดที่ Copilot ใช้และวิธีที่ทําให้สําเร็จ นี่คือความเกี่ยวข้องกับการทําความเข้าใจค่าใช้จ่ายของ Copilot ใน Fabric และเมื่อคุณแก้ไขปัญหาที่ทําให้ผลลัพธ์ไม่ถูกต้องหรือที่ไม่คาดคิด
เคล็ดลับ
ในประสบการณ์การใช้งานบางอย่าง คุณยังสามารถทําการเปลี่ยนแปลงรายการเพื่อให้ข้อมูลพื้นฐานของพวกเขามีโครงสร้างที่ดีกว่าสําหรับ Copilot ที่จะใช้ ตัวอย่างกําลังดําเนินการสร้างแบบจําลองภาษาในแบบจําลองความหมาย หรือการเพิ่มคําพ้องและคําอธิบายไปยังหน่วยวัดและคอลัมน์ของแบบจําลองความหมาย
แผนภาพต่อไปนี้แสดงสิ่งที่เกิดขึ้นระหว่างการประมวลผลล่วงหน้าโดย Copilot ใน Fabric
หลังจากได้รับการป้อนข้อมูลของผู้ใช้ Copilot ดําเนินการประมวลผลล่วงหน้าซึ่งเกี่ยวข้องกับขั้นตอนต่อไปนี้:
ดิน: Copilot ดําเนินการสร้างแบบเสริม (RAG) เพื่อรวบรวมข้อมูลพื้นฐาน ข้อมูลพื้นฐานประกอบด้วยข้อมูลที่เกี่ยวข้องจากบริบทปัจจุบันที่คุณกําลังใช้ Copilot ใน Fabric ข้อมูลพื้นฐานอาจรวมถึงบริบทเช่น:
- ประวัติการแชทจากเซสชันปัจจุบันด้วย Copilot
- เมตาดาต้าเกี่ยวกับรายการ Fabric ที่คุณกําลังใช้กับ Copilot (เช่น Schema ของแบบจําลองความหมายหรือเลคเฮ้าส์ของคุณ หรือเมตาดาต้าจากวิชวลรายงาน)
- จุดข้อมูลเฉพาะ เช่น จุดข้อมูลที่แสดงในวิชวลรายงาน เมตาดาต้ารายงาน ในการกําหนดค่าวิชวลยังประกอบด้วยจุดข้อมูล
- Meta-prompts ซึ่งเป็นคําแนะนําเพิ่มเติมที่ให้ไว้สําหรับแต่ละประสบการณ์การใช้งาน เพื่อช่วยให้แน่ใจว่ามีเอาต์พุตที่เฉพาะเจาะจงและสอดคล้องกันมากขึ้น
การเสริมพร้อมท์: โดยขึ้นอยู่กับสถานการณ์สมมติ ผู้เขียนซ้ํา (หรือ การเสริม) พร้อมท์ที่ยึดตามข้อมูลป้อนเข้าและการวางสายข้อมูล พร้อมท์เสริมควรดีกว่า และบริบทรู้จักมากกว่าพร้อมท์การป้อนค่าเดิมของคุณ
แค: ในบางสถานการณ์ Copilot จะแคชพร้อมท์และข้อมูลพื้นฐานของคุณเป็นเวลา 48 ชั่วโมง การแคชพร้อมท์ช่วยให้แน่ใจว่าพร้อมท์ที่ทําซ้ําจะส่งกลับผลลัพธ์เดียวกันในขณะที่แคช แต่จะส่งกลับผลลัพธ์เหล่านี้ได้เร็วขึ้น และคุณไม่ได้ใช้ความจุ Fabric สําหรับการทําซ้ําพร้อมท์ในบริบทเดียวกัน การแคชเกิดขึ้นในสองสถานที่ที่แตกต่างกัน:
- แคชเบราว์เซอร์ของผู้ใช้
- แคช back-end แรกในภูมิภาคเดิมของผู้เช่าซึ่งจะถูกเก็บไว้สําหรับวัตถุประสงค์การตรวจสอบ ไม่มีข้อมูลถูกแคชในบริการ Azure OpenAI หรือตําแหน่งที่ตั้งของ GPI สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการแคชใน Fabric ดูที่เอกสารทางเทคนิคเรื่องความปลอดภัยของ Microsoft Fabric
การส่งอินพุตไปยัง Azure OpenAI: Copilot ส่งพร้อมท์เสริมและข้อมูลพื้นฐานที่เกี่ยวข้องไปยังบริการ Azure OpenAI
เมื่อ Copilot ดําเนินการลงดิน จะรวบรวมข้อมูลจากข้อมูลหรือรายการที่ผู้ใช้สามารถเข้าถึงได้ตามปกติเท่านั้น Copilot เคารพบทบาทพื้นที่ทํางาน สิทธิ์รายการ และความปลอดภัยของข้อมูล นอกจากนี้ Copilot ยังไม่สามารถเข้าถึงข้อมูลจากผู้ใช้รายอื่นได้ด้วย การโต้ตอบกับ Copilot จะเฉพาะเจาะจงกับผู้ใช้แต่ละราย
ข้อมูลที่ Copilot รวบรวมในระหว่างกระบวนการพื้นฐานและกระบวนการ Azure OpenAI ขึ้นอยู่กับประสบการณ์ Copilot เฉพาะที่คุณใช้ สําหรับข้อมูลเพิ่มเติม ให้ดู ข้อมูลใดที่ Copilot ใช้และวิธีการประมวลผล
หลังจากเสร็จสิ้นการประมวลผลล่วงหน้าและ Copilot ได้ส่งการป้อนข้อมูลไปยัง Azure OpenAI บริการ Azure OpenAI สามารถประมวลผลการป้อนข้อมูลนั้นเพื่อสร้างการตอบสนองและเอาท์พุทที่ถูกส่งกลับไปยัง Copilot
ขั้นตอนที่ 3: Azure OpenAI ประมวลผลพร้อมท์และสร้างเอาต์พุต
ประสบการณ์การใช้งาน Copilot ทั้งหมดได้รับการสนับสนุนโดยบริการ Azure OpenAI
ทําความเข้าใจกับบริการ Azure OpenAI
Copilot ใช้ Azure OpenAI— ไม่ใช่บริการที่พร้อมใช้งานแบบสาธารณะของ OpenAI เพื่อประมวลผลข้อมูลทั้งหมดและส่งกลับการตอบสนอง ตามที่กล่าวถึงก่อนหน้านี้ การตอบกลับนี้ผลิตโดย LLM LLM เป็นวิธีการเฉพาะใน AI "แคบ" ที่มุ่งเน้นการใช้การเรียนรู้เชิงลึกเพื่อค้นหาและทําซ้ํารูปแบบในข้อมูลที่ไม่มีโครงสร้าง โดยเฉพาะ ข้อความ ข้อความในบริบทนี้ประกอบด้วยภาษาธรรมชาติ เมตาดาต้า โค้ด และการจัดเรียงอักขระที่มีความหมายอื่น ๆ ที่มีความหมาย
ขณะนี้ Copilot ใช้การรวมกันของแบบจําลอง GPT รวมถึงชุดแบบจําลองที่สร้างไว้ล่วงหน้า (GPT) จาก OpenAI
หมายเหตุ
คุณไม่สามารถเลือกหรือเปลี่ยนแบบจําลองที่ Copilot ใช้ รวมถึงการใช้แบบจําลองพื้นฐานอื่น ๆ หรือแบบจําลองของคุณเอง Copilot ใน Fabric ใช้แบบจําลองต่าง ๆ คุณยังไม่สามารถให้คุณเปลี่ยนแปลงหรือกําหนดค่าบริการ Azure OpenAI ให้ทํางานแตกต่างกันกับ Copilot ใน Fabric บริการนี้จัดการโดย Microsoft
แบบจําลองที่ใช้โดย Copilot ใน Fabric ปัจจุบันไม่ได้ใช้การปรับแต่งที่ดีใดๆ แบบจําลองจะอาศัยข้อมูลพื้นฐานและเมตาพร้อมท์เพื่อสร้างเอาต์พุตที่เฉพาะเจาะจงและมีประโยชน์มากขึ้น
แบบจําลองที่ใช้โดย Copilot ใน Fabric ปัจจุบันไม่ได้ใช้การปรับแต่งที่ดีใดๆ แบบจําลองจะอาศัยข้อมูลพื้นฐานและเมตาพร้อมท์เพื่อสร้างเอาต์พุตที่เฉพาะเจาะจงและมีประโยชน์มากขึ้น
Microsoft เป็นโฮสต์แบบจําลอง OpenAI ในสภาพแวดล้อมของ Microsoft Azure และบริการไม่โต้ตอบกับบริการสาธารณะใดๆ โดย OpenAI (ตัวอย่างเช่น ChatGPT หรือ OpenAI API สาธารณะ) ข้อมูลของคุณไม่ได้ถูกใช้เพื่อฝึกแบบจําลองและไม่พร้อมใช้งานสําหรับลูกค้ารายอื่น สําหรับข้อมูลเพิ่มเติม ดูบริการ Azure OpenAI
ทําความเข้าใจเกี่ยวกับโทเค็น
จําเป็นอย่างยิ่งที่คุณต้องทําความเข้าใจเกี่ยวกับโทเค็น เนื่องจาก ต้นทุนของ Copilot ใน Fabric (ซึ่งเป็นปริมาณการใช้งาน Fabric Capacity Copilot) จะถูกกําหนดโดยจํานวนโทเค็น ที่ผลิตโดยอินพุตและเอาต์พุตของ Copilot ของคุณ
เพื่อประมวลผลการป้อนข้อความจาก Copilot, Azure OpenAI ต้องแปลงข้อมูลป้อนเข้านั้นเป็นการแสดงตัวเลขเสียก่อน ขั้นตอนสําคัญในกระบวนการนี้คือ โทเค็น ซึ่งเป็นการแบ่งพาร์ติชันของข้อความที่ป้อนเข้าไปยังส่วนต่างๆ ที่มีขนาดเล็กกว่า เรียกว่า โทเค็น โทเค็นคือชุดของอักขระที่เกิดขึ้นร่วมกัน และเป็นหน่วยที่เล็กที่สุดของข้อมูลที่ LLM ใช้เพื่อสร้างผลลัพธ์ โทเค็นแต่ละรายการมี ID ตัวเลขที่สอดคล้องกันซึ่งกลายเป็นคําศัพท์ของ LLM เพื่อเข้ารหัสและใช้ข้อความเป็นตัวเลข มีหลายวิธีที่จะโทเค็นข้อความ และ LLMs ที่แตกต่างกันโทเค็นการป้อนข้อความในรูปแบบที่แตกต่างกัน Azure OpenAI ใช้ การเข้ารหัสByte-Pair (BPE) ซึ่งเป็นวิธีการโทเค็นคําย่อย
เพื่อให้เข้าใจมากขึ้นว่าโทเค็นคืออะไรและวิธีที่พร้อมท์จะกลายเป็นโทเค็น ให้พิจารณาตัวอย่างต่อไปนี้ ตัวอย่างนี้แสดงพร้อมท์การป้อนข้อมูลและโทเค็นโดยประมาณโดยใช้ โทเค็น OpenAI Platform(สําหรับ GPT4) ภายใต้โทเค็นที่เน้นในข้อความพร้อมต์คืออาร์เรย์ (หรือรายการ) ของรหัสโทเค็นตัวเลข
ในตัวอย่าง การไฮไลต์ที่มีสีแตกต่างกันแต่ละรายการจะระบุโทเค็นเดียว ตามที่กล่าวถึงก่อนหน้านี้ Azure OpenAI ใช้โทเค็น คําย่อย ดังนั้นโทเค็นจึงไม่ใช่คํา แต่ก็ไม่ใช่อักขระหรืออักขระจํานวนคงที่ ตัวอย่างเช่น "รายงาน" เป็นโทเค็นเดียว แต่ "." ก็เป็นเช่นเดียวกัน
หากต้องการย้ําคุณควรทําความเข้าใจว่าโทเค็นคืออะไรเนื่องจากค่าใช้จ่ายของ Copilot (หรืออัตราปริมาณการใช้ความจุ Fabric) จะถูกกําหนดโดยโทเค็น ดังนั้นการทําความเข้าใจว่าโทเค็นคืออะไรและวิธีสร้างโทเค็นอินพุตและเอาท์พุทช่วยให้คุณเข้าใจและคาดหวังว่าการใช้งาน Copilot ส่งผลให้การใช้ Fabric CUs เป็นอย่างไร สําหรับข้อมูลเพิ่มเติมเกี่ยวกับ ค่าใช้จ่ายของ Copilot ใน Fabric โปรดดูส่วนที่เหมาะสมในภายหลังของบทความนี้
Copilot ใน Fabric ใช้ทั้งโทเค็นอินพุตและเอาต์พุต ตามที่อธิบายไว้ในไดอะแกรมต่อไปนี้
Copilot สร้างโทเค็นที่แตกต่างกันสองประเภท:
- โทเค็นอินพุต เป็นผลมาจากการทําโทเค็นทั้งพร้อมท์สุดท้ายและข้อมูลพื้นฐานใด ๆ
- โทเค็นผลลัพธ์ จากการทําโทเค็นการตอบสนอง LLM
ประสบการณ์การใช้งาน Copilot บางอย่างส่งผลให้เรียกใช้ LLM ได้หลายรายการ ตัวอย่างเช่น เมื่อถามคําถามเกี่ยวกับแบบจําลองและรายงาน การตอบสนองของ LLM แรกอาจเป็นคิวรีที่ประเมินเทียบกับแบบจําลองความหมาย จากนั้น Copilot ส่งผลลัพธ์ของคิวรีที่ประเมินแล้วไปยัง Azure OpenAI อีกครั้งและร้องขอสรุป ซึ่ง Azure OpenAI จะส่งกลับพร้อมกับคําตอบอื่น การเรียกใช้ LLM เพิ่มเติมเหล่านี้อาจได้รับการจัดการและการตอบสนองของ LLM รวมกันในระหว่างขั้นตอนหลังกระบวนการ
หมายเหตุ
ด้วย Copilot ใน Fabric ยกเว้นการเปลี่ยนแปลงในพร้อมท์การป้อนข้อมูลเป็นลายลักษณ์อักษร คุณสามารถปรับโทเค็นอินพุตและเอาท์พุตให้เหมาะสมได้โดยการปรับการกําหนดค่าของรายการที่เกี่ยวข้อง เช่น การซ่อนคอลัมน์ในแบบจําลองเชิงความหมาย หรือลดจํานวนวิชวลหรือหน้าในรายงาน คุณไม่สามารถสกัดกั้นหรือปรับเปลี่ยนข้อมูลพื้นฐานก่อนที่จะถูกส่งไปยัง Azure OpenAI โดย Copilot
ทําความเข้าใจเกี่ยวกับการประมวลผล
สิ่งสําคัญคือคุณต้องเข้าใจว่า LLM ใน Azure OpenAI ประมวลผลข้อมูลของคุณและสร้างเอาต์พุตอย่างไร เพื่อให้คุณสามารถเข้าใจได้ดีขึ้นว่าเหตุใดคุณจึงได้รับเอาต์พุตบางอย่างจาก Copilot และสาเหตุที่คุณควรใช้ข้อมูลเหล่านั้นก่อนที่จะใช้งานหรือตัดสินใจต่อไป
หมายเหตุ
บทความนี้ให้ภาพรวมระดับสูงอย่างง่ายว่า LLMs ที่ Copilot ใช้ (เช่น GPTs) ทํางานอย่างไร สําหรับรายละเอียดทางเทคนิคและความเข้าใจอย่างลึกซึ้งถึงวิธีการป้อนข้อมูลกระบวนการแบบจําลอง GPT เพื่อสร้างการตอบสนองหรือเกี่ยวกับสถาปัตยกรรมของพวกเขา อ่านเอกสารการวิจัย ที่สนใจคือสิ่งที่คุณต้องการ (2017) โดย Ashish Vaswani และรุ่นอื่น ๆ และ แบบจําลองภาษา Few-Shot Learners (2020) โดย Tom Brown และอื่น ๆ
วัตถุประสงค์ของ Copilot (และ LLMs โดยทั่วไป) คือเพื่อให้ได้ผลลัพธ์ที่เหมาะสมและเป็นประโยชน์ตามบริบทตามการป้อนข้อมูลที่ผู้ใช้ให้และข้อมูลพื้นฐานอื่น ๆ ที่เกี่ยวข้อง LLM ทําสิ่งนี้โดยการตีความความหมายของโทเค็นในบริบทที่คล้ายกันตามที่เห็นในข้อมูลการฝึกของพวกเขา เพื่อให้เข้าใจความหมายของโทเค็นอย่างมีความหมาย LLMs ได้รับการฝึกฝนเกี่ยวกับชุดข้อมูลขนาดใหญ่ที่คิดว่าจะประกอบด้วยข้อมูลทั้งลิขสิทธิ์และโดเมนสาธารณะ อย่างไรก็ตาม ข้อมูลการฝึกนี้จะถูกจํากัดในแง่ของความสดใหม่ของเนื้อหา คุณภาพ และขอบเขต ซึ่งสร้างข้อจํากัดสําหรับ LLM และเครื่องมือที่ใช้เช่น Copilot สําหรับข้อมูลเพิ่มเติมเกี่ยวกับข้อจํากัดเหล่านี้ ดู ทําความเข้าใจข้อจํากัดของ Copilot และ LLM ภายหลังในบทความนี้
ความหมายของโทเค็นถูกจับภาพในโครงสร้างทางคณิตศาสตร์ที่เรียกว่า การฝังซึ่งจะเปลี่ยนโทเค็นเป็นเวกเตอร์ที่หนาแน่นของจํานวนจริง ในคําที่ง่ายกว่า การฝังให้ LLMs มีความหมายเชิงความหมายของโทเค็นที่กําหนดโดยยึดตามโทเค็นอื่น ๆ รอบๆ ความหมายนี้ขึ้นอยู่กับข้อมูลการฝึก LLM ลองนึกถึงโทเค็น เช่น บล็อกการสร้างที่ไม่ซ้ํากัน ในขณะที่การฝังจะช่วยให้ LLM ทราบว่าควรใช้บล็อกอะไรเมื่อใด
การใช้โทเค็นและการฝัง LLM ใน Azure OpenAI จะประมวลผลอินพุตของคุณและสร้างการตอบสนอง การประมวลผลนี้เป็นงานที่มีการคํานวณที่ต้องใช้ทรัพยากรที่สําคัญ ซึ่งเป็นที่มาของต้นทุน LLM สร้างโทเค็นหนึ่งการตอบกลับในแต่ละครั้ง ซึ่งเลือกโทเค็นแต่ละรายการโดยใช้ความน่าจะเป็นจากการคํานวณตามบริบทการป้อนข้อมูล โทเค็นที่สร้างขึ้นแต่ละรายการจะถูกเพิ่มไปยังบริบทที่มีอยู่ก่อนที่จะสร้างโทเค็นถัดไป การตอบสนองสุดท้ายของ LLM ต้องเป็นข้อความเสมอซึ่ง Copilot อาจโพสต์กระบวนการในภายหลังเพื่อสร้างผลลัพธ์ที่มีประโยชน์มากขึ้นสําหรับผู้ใช้
สิ่งสําคัญคือต้องทําความเข้าใจแง่มุมที่สําคัญต่าง ๆ เกี่ยวกับการตอบสนองที่สร้างขึ้นนี้:
- ซึ่งไม่ใช่แบบเชิงกําหนด การป้อนข้อมูลเดียวกันสามารถสร้างการตอบกลับที่แตกต่างกันได้
- ผู้ใช้สามารถตีความได้ว่ามีคุณภาพต่ําหรือไม่ถูกต้องโดยผู้ใช้ในบริบทของพวกเขา
- ซึ่งขึ้นอยู่กับข้อมูลการฝึก LLM ซึ่งมีจํากัดและจํากัดในขอบเขตของมัน
ทําความเข้าใจเกี่ยวกับข้อจํากัดของ Copilot และ LLM
เป็นสิ่งสําคัญที่ต้องทําความเข้าใจและยอมรับข้อจํากัดของ Copilot และเทคโนโลยีพื้นฐานที่ใช้ การทําความเข้าใจข้อจํากัดเหล่านี้ช่วยให้คุณได้รับคุณค่าจาก Copilot ในขณะที่ยังช่วยลดความเสี่ยงจากการใช้งาน หากต้องการใช้ Copilot ใน Fabric อย่างมีประสิทธิภาพ คุณควรทําความเข้าใจเกี่ยวกับกรณีการใช้งานและสถานการณ์ที่เหมาะสมกับเทคโนโลยีนี้ที่สุด
สิ่งสําคัญคือต้องคํานึงถึงข้อควรพิจารณาต่อไปนี้เมื่อคุณใช้ Copilot ใน Fabric:
Copilot ใน Fabric ไม่ใช่ค่าเชิงกําหนด ยกเว้นเมื่อมีการแคชพร้อมท์และเอาต์พุต อินพุตเดียวกันสามารถสร้างเอาต์พุตที่แตกต่างกันได้ เมื่อคุณยอมรับช่วงของเอาต์พุตที่เป็นไปได้ เช่น หน้ารายงาน รูปแบบโค้ด หรือข้อมูลสรุป – นี่เป็นปัญหาน้อยกว่าเนื่องจากคุณสามารถยอมรับและอาจคาดหวังว่าจะมีความหลากหลายในการตอบกลับ อย่างไรก็ตาม สําหรับสถานการณ์เมื่อคุณคาดว่าจะได้คําตอบที่ถูกต้องเพียงคําตอบเดียว คุณอาจต้องการพิจารณาทางเลือกอื่นสําหรับ Copilot
Copilot ใน Fabric สามารถผลิตเอาต์พุตที่มีคุณภาพต่ําหรือไม่ถูกต้อง: เช่นเดียวกับเครื่องมือ LLM ทั้งหมด เป็นไปได้ที่ Copilot จะผลิตเอาต์พุตที่อาจไม่ถูกต้อง คาดหวัง หรือเหมาะสมสําหรับสถานการณ์ของคุณ ซึ่งหมายความว่าคุณควรหลีกเลี่ยงการใช้ Copilot ใน Fabric ที่มีข้อมูลที่ละเอียดอ่อนหรือในพื้นที่ที่มีความเสี่ยงสูง ตัวอย่างเช่น คุณไม่ควรใช้เอาต์พุตของ Copilot เพื่อตอบคําถามเกี่ยวกับคําถามเกี่ยวกับกระบวนการทางธุรกิจที่สําคัญ หรือสร้างโซลูชันข้อมูลที่อาจส่งผลกระทบต่อบุคคลหรือความเป็นอยู่ที่ดีของแต่ละคน ผู้ใช้ควรตรวจสอบและตรวจสอบเอาต์พุตของ Copilot ก่อนที่จะใช้งาน
Copilot ไม่เข้าใจเรื่อง "ความถูกต้อง" หรือ "ความจริง": เอาต์พุตที่ Copilot ให้ไว้ไม่ได้บ่งชี้ถึงความน่าเชื่อถือ ความน่าเชื่อถือ หรือความคิดเห็นที่คล้ายกัน เทคโนโลยีพื้นฐานเกี่ยวข้องกับการจดจํารูปแบบและไม่สามารถประเมินคุณภาพหรือประโยชน์ของเอาต์พุตได้ ผู้ใช้ควรประเมินเอาต์พุตอย่างยิ่งก่อนที่จะใช้เอาต์พุตเหล่านี้ในการทํางานหรือการตัดสินใจอื่น ๆ
Copilot ไม่สามารถให้เหตุผล ทําความเข้าใจเจตนาของคุณ หรือทราบบริบทนอกเหนือจากการป้อนข้อมูล: ในขณะที่กระบวนการพื้นฐานของ Copilot ทําให้แน่ใจว่าเอาต์พุตมีความเฉพาะเจาะจงมากขึ้น แต่การลงพื้นเพียงอย่างเดียวไม่สามารถให้ข้อมูลทั้งหมดที่ Copilot ต้องตอบคําถามของคุณ ตัวอย่างเช่น หากคุณใช้ Copilot เพื่อสร้างโค้ด Copilot ยังไม่ทราบว่าคุณจะทําอะไรด้วยโค้ดนั้น ซึ่งหมายความว่าโค้ดอาจทํางานในบริบทเดียว แต่ไม่ใช่อีกบริบทหนึ่ง และผู้ใช้ต้องปรับเปลี่ยนเอาต์พุตหรือพร้อมท์เพื่อแก้ไขปัญหานี้
เอาต์พุต Copilot จะถูกจํากัดโดยข้อมูลการฝึกของ LLM ที่ใช้: ในบางประสบการณ์การใช้งาน Copilot เช่น ประสบการณ์ที่คุณสร้างโค้ด คุณอาจต้องการให้ Copilot สร้างโค้ดด้วยฟังก์ชันหรือรูปแบบที่เผยแพร่ใหม่ อย่างไรก็ตาม Copilot จะไม่สามารถทําเช่นนี้ได้อย่างมีประสิทธิภาพหากไม่มีตัวอย่างในข้อมูลการฝึกของแบบจําลอง GPT ที่ใช้ซึ่งมีการตัดขาดในอดีต นอกจากนี้ยังเกิดขึ้นเมื่อคุณพยายามนํา Copilot ไปใช้กับบริบทที่กระจัดกระจายในข้อมูลการฝึก เช่น เมื่อใช้ Copilot กับตัวแก้ไข TMDL ใน Power BI Desktop ในสถานการณ์เหล่านี้ คุณควรมีความระมัดระวังและสําคัญอย่างยิ่งต่อผลลัพธ์ที่มีคุณภาพต่ําหรือไม่แม่นยํา
คำเตือน
เพื่อลดความเสี่ยงของข้อจํากัดและข้อควรพิจารณาเหล่านี้ และข้อเท็จจริงที่ว่า Copilot, LLM และ AI ที่ก่อให้เกิดเป็นเทคโนโลยีที่น่ารังเกียจ คุณ ไม่ควร ใช้ Copilot ใน Fabric สําหรับกระบวนการอัตโนมัติ ความเสี่ยงสูง หรือกระบวนการทางธุรกิจที่สําคัญและการตัดสินใจ
สําหรับข้อมูลเพิ่มเติม ให้ดู คําแนะนําความปลอดภัยสําหรับ LLM
เมื่อบริการ Azure OpenAI ประมวลผลการป้อนข้อมูลและสร้างการตอบสนอง จะส่งกลับการตอบสนองนี้เป็นผลลัพธ์ไปยัง Copilot
ขั้นตอนที่ 4: Copilot ดําเนินการโพสต์การประมวลผลบนเอาต์พุต
เมื่อได้รับการตอบสนองจาก Azure OpenAI Copilot จะประมวลผลเพิ่มเติมเพื่อให้แน่ใจว่าการตอบสนองนั้นเหมาะสม วัตถุประสงค์ของ postprocessing คือเพื่อกรองเนื้อหาที่ไม่เหมาะสมออก
ในการดําเนินการโพสต์กระบวนการ Copilot อาจทํางานต่อไปนี้:
ตรวจสอบ AI ที่รับผิดชอบ: ตรวจสอบให้แน่ใจว่า Copilot ปฏิบัติตามมาตรฐาน AI ที่รับผิดชอบที่ Microsoft สําหรับข้อมูลเพิ่มเติม โปรดดู ฉันควรใช้ Copilot แบบตอบสนองอย่างไร?
การกรองด้วยการควบคุมเนื้อหา Azure: การกรองคําตอบเพื่อให้แน่ใจว่า Copilot ส่งกลับการตอบสนองที่เหมาะสมกับสถานการณ์และประสบการณ์การใช้งานเท่านั้น นี่คือตัวอย่างบางส่วนของวิธีที่ Copilot ดําเนินการกรองด้วยการควบคุมเนื้อหา Azure:
- การใช้โดยไม่ได้ตั้งใจหรือไม่เหมาะสม: การควบคุมเนื้อหาช่วยให้แน่ใจว่าคุณไม่สามารถใช้ Copilot ในลักษณะที่ไม่ได้ตั้งใจหรือไม่เหมาะสม เช่น การถามคําถามเกี่ยวกับหัวข้ออื่น ๆ ภายนอกขอบเขตของปริมาณงาน รายการ หรือประสบการณ์ที่คุณกําลังใช้
- เอาต์พุตที่ไม่เหมาะสมหรือไม่เหมาะสม: Copilot ป้องกันเอาต์พุตที่อาจมีภาษา คําศัพท์ หรือวลีที่ไม่สามารถยอมรับได้
- ความพยายามของการฉีดพร้อมท์: Copilot ป้องกันการฉีดพร้อมท์ ซึ่งผู้ใช้พยายามซ่อนคําแนะนําที่ขัดจังหวะในข้อมูลพื้นฐาน เช่น ในชื่อวัตถุ คําอธิบาย หรือข้อคิดเห็นโค้ดในแบบจําลองความหมาย
ข้อจํากัดเฉพาะสถานการณ์: ทั้งนี้ขึ้นอยู่กับประสบการณ์การใช้งาน Copilot ที่อาจมีการตรวจสอบเพิ่มเติมและการจัดการการตอบสนอง LLM ก่อนที่คุณจะได้รับเอาต์พุต นี่คือตัวอย่างบางส่วนของวิธีที่ Copilot บังคับใช้ข้อจํากัดเฉพาะของสถานการณ์:
- ตัวแยกวิเคราะห์โค้ด: รหัสที่สร้างขึ้นอาจวางผ่านตัวแยกวิเคราะห์เพื่อกรองคําตอบและข้อผิดพลาดที่มีคุณภาพต่ําเพื่อให้แน่ใจว่าโค้ดทํางาน ซึ่งเกิดขึ้นเมื่อคุณสร้างคิวรี DAX โดยใช้ Copilot ในมุมมองคิวรี DAX ของ Power BI Desktop
- การตรวจสอบความถูกต้องของวิชวลและรายงาน: Copilot ตรวจสอบว่าวิชวลและรายงานสามารถแสดงก่อนที่จะส่งกลับในผลลัพธ์ได้หรือไม่ Copilot ไม่ตรวจสอบว่าผลลัพธ์ถูกต้องหรือมีประโยชน์ หรือคิวรีที่เป็นผลลัพธ์จะหมดเวลา (และสร้างข้อผิดพลาด) หรือไม่
การจัดการและใช้การตอบสนอง: รับการตอบสนองและเพิ่มข้อมูลเพิ่มเติมหรือใช้ในกระบวนการอื่น ๆ เพื่อให้ผลลัพธ์แก่ผู้ใช้ นี่คือตัวอย่างบางส่วนของวิธีที่ Copilot อาจจัดการและใช้การตอบกลับระหว่างการโพสต์กระบวนการ:
- การสร้างหน้ารายงาน Power BI: Copilot ได้รวมการตอบกลับ LLM (เมตาดาต้าวิชวลรายงาน) กับเมตาดาต้ารายงานอื่น ๆ ซึ่งส่งผลให้เกิดการสร้างหน้ารายงานใหม่ นอกจากนี้ Copilot อาจใช้ ธีม Copilot หากคุณยังไม่ได้สร้างวิชวลใด ๆ ในรายงาน ธีมไม่ได้เป็นส่วนหนึ่งของการตอบสนองของ LLM และมีรูปภาพพื้นหลัง รวมถึงสีและสไตล์ของวิชวล หากคุณได้สร้างวิชวลแล้ว Copilot จะไม่ใช้ธีม Copilot และใช้ธีมที่คุณได้นําไปใช้อยู่แล้ว เมื่อเปลี่ยนหน้ารายงาน Copilot จะลบหน้าที่มีอยู่และแทนที่ด้วยหน้าใหม่ที่มีการปรับใช้
- คําถามเกี่ยวกับข้อมูล Power BI: Copilot ประเมินคิวรีเทียบกับแบบจําลองความหมาย
- คําแนะนําขั้นตอนการแปลงกระแสข้อมูลกระแสข้อมูล gen2: Copilot ปรับเปลี่ยนเมตาดาต้าของหน่วยข้อมูลเพื่อแทรกขั้นตอนใหม่ และปรับคิวรี่
การโทรของ LLM เพิ่มเติม: ในบางสถานการณ์ Copilot อาจดําเนินการเรียกใช้ LLM เพิ่มเติมเพื่อเสริมสร้างเอาต์พุต ตัวอย่างเช่น Copilot อาจส่งผลลัพธ์ของคิวรีที่ประเมินแล้วไปยัง LLM เป็นอินพุตใหม่และร้องขอคําอธิบาย จากนั้นคําอธิบายภาษาธรรมชาตินี้จะรวมเข้าด้วยกันกับผลลัพธ์คิวรีในผลลัพธ์ที่ผู้ใช้เห็นในแผงการสนทนา Copilot
ถ้าเนื้อหาถูกกรองออกในเอาต์พุต Copilot จะส่งพร้อมท์ใหม่ ที่ถูกปรับเปลี่ยน หรือส่งกลับการตอบสนองมาตรฐานอีกครั้ง
ส่งพร้อมท์ใหม่อีกครั้ง: เมื่อการตอบสนองไม่ตรงกับข้อจํากัดเฉพาะของสถานการณ์ Copilot จะสร้างพร้อมท์ที่ปรับเปลี่ยนแล้วอีกรายการหนึ่งเพื่อลองอีกครั้ง ในบางกรณี Copilot อาจแนะนําพร้อมท์ใหม่หลายรายการเพื่อให้ผู้ใช้เลือกก่อนที่จะส่งพร้อมท์เพื่อสร้างผลลัพธ์ใหม่
การตอบสนองมาตรฐาน: การตอบสนองมาตรฐานในกรณีนี้จะระบุข้อผิดพลาดทั่วไป ทั้งนี้ขึ้นอยู่กับสถานการณ์สมมติ Copilot อาจให้ข้อมูลเพิ่มเติมเพื่อแนะนําผู้ใช้ให้สร้างการป้อนข้อมูลอื่น
หมายเหตุ
ไม่สามารถดูการตอบสนองเดิมที่กรองแล้วจาก Azure OpenAI หรือเปลี่ยนการตอบสนองมาตรฐานจากหรือลักษณะการทํางานของ Copilot ซึ่ง Microsoft จัดการ
หลังจากการเลื่อนกระบวนการเสร็จสมบูรณ์ Copilot จะส่งกลับผลลัพธ์ไปยังผู้ใช้
ขั้นตอนที่ 5: Copilot ส่งกลับผลลัพธ์ไปยังผู้ใช้
ผลลัพธ์สําหรับผู้ใช้สามารถใช้รูปแบบภาษาธรรมชาติ รหัส หรือเมตาดาต้าได้ เมตาดาต้านี้มักจะแสดงใน UI ของ Fabric หรือ Power BI Desktop เช่นเมื่อ Copilot ส่งกลับวิชวล Power BI หรือแนะนําหน้ารายงาน สําหรับประสบการณ์การใช้งาน Copilot ใน Power BI ผู้ใช้สามารถใส่ทั้งอินพุตและเอาต์พุตไปยัง Copilot ผ่านแอป Power BI สําหรับอุปกรณ์เคลื่อนที่ได้
โดยทั่วไป เอาต์พุตสามารถอนุญาตการดําเนินการของผู้ใช้หรือทํางานโดยอัตโนมัติได้อย่างสมบูรณ์และไม่อนุญาตให้ผู้ใช้เปลี่ยนแปลงผลลัพธ์
การดําเนินการของผู้ใช้: ผลลัพธ์เหล่านี้ช่วยให้ผู้ใช้สามารถปรับเปลี่ยนผลลัพธ์ก่อนที่จะถูกประเมินหรือแสดงได้ ตัวอย่างบางส่วนของเอาต์พุตที่อนุญาตการดําเนินการของผู้ใช้ได้แก่:
- การสร้างโค้ด เช่น คิวรี DAX หรือ SQL ซึ่งผู้ใช้สามารถเลือกที่จะเก็บหรือเรียกใช้ได้
- การสร้างคําอธิบายหน่วยวัดในแบบจําลองความหมาย ซึ่งผู้ใช้สามารถเลือกที่จะเก็บ แก้ไข หรือลบได้
อิสระ: เอาต์พุตเหล่านี้ไม่สามารถเปลี่ยนแปลงได้โดยผู้ใช้ รหัสอาจถูกประเมินโดยตรงเทียบกับรายการ Fabric หรือข้อความไม่สามารถแก้ไขได้ในบานหน้าต่าง ตัวอย่างบางส่วนของผลลัพธ์แบบอัตโนมัติได้แก่:
- ตอบคําถามเกี่ยวกับข้อมูลเกี่ยวกับแบบจําลองเชิงความหมายหรือรายงานในแผงแชท Copilot ซึ่งจะประเมินคิวรีเทียบกับแบบจําลองและแสดงผลลัพธ์โดยอัตโนมัติ
- สรุปหรือคําอธิบายของโค้ด รายการ หรือข้อมูล ซึ่งเลือกสิ่งที่จะสรุปและอธิบายโดยอัตโนมัติ และแสดงผลลัพธ์
- การสร้างหน้ารายงาน ซึ่งจะสร้างหน้าและวิชวลในรายงานโดยอัตโนมัติ
ในบางครั้ง ในฐานะที่เป็นส่วนหนึ่งของเอาต์พุต Copilot อาจแนะนําพร้อมท์เพิ่มเติม ติดตามผล เช่น การร้องขอการชี้แจง หรือคําแนะนําอื่น การดําเนินการนี้จะเป็นประโยชน์เมื่อผู้ใช้ต้องการปรับปรุงผลลัพธ์หรือทํางานในผลลัพธ์ที่เฉพาะเจาะจงต่อไป เช่น การอธิบายแนวคิดเพื่อทําความเข้าใจรหัสที่สร้างขึ้น
ผลลัพธ์จาก Copilot อาจมีเนื้อหาที่มีคุณภาพต่ําหรือไม่ถูกต้อง
Copilot ไม่มีวิธีประเมินหรือระบุถึงประโยชน์หรือความแม่นยําของเอาต์พุต ด้วยเหตุนี้ จึงเป็นสิ่งสําคัญที่ผู้ใช้จะประเมินตนเองเมื่อใดก็ตามที่พวกเขาใช้ Copilot
เพื่อลดความเสี่ยงหรือความท้าทายจากหลอน LLM ใน Copilot ให้พิจารณาคําแนะนําต่อไปนี้:
ฝึกผู้ใช้ให้ใช้ Copilot และเครื่องมืออื่นที่คล้ายกันที่ใช้ประโยชน์จาก LLM พิจารณาการฝึกอบรมเกี่ยวกับหัวข้อต่อไปนี้:
- สิ่งที่ Copilot สามารถทําได้และทําไม่ได้
- เมื่อต้องใช้ Copilot และเมื่อไม่ใช้งาน
- วิธีการเขียนพร้อมท์ที่ดีกว่า
- วิธีการแก้ไขปัญหาผลลัพธ์ที่ไม่คาดคิด
- วิธีการตรวจสอบเอาต์พุตโดยใช้แหล่งข้อมูลออนไลน์เทคนิคหรือแหล่งข้อมูลที่เชื่อถือได้
ทดสอบรายการด้วย Copilot ก่อนที่คุณจะอนุญาตให้นํารายการเหล่านี้ไปใช้กับรายการดังกล่าว บางรายการต้องการงานเตรียมการบางอย่างเพื่อให้แน่ใจว่าพวกเขาทํางานได้ดีกับ Copilot
หลีกเลี่ยงการใช้ Copilot ในกระบวนการตัดสินใจที่มีความเสี่ยงสูง หรือมีความเสี่ยงทางธุรกิจที่สําคัญ
สําคัญ
นอกจากนี้ ให้ตรวจสอบ ข้อกําหนดการแสดงตัวอย่างเพิ่มเติมสําหรับ Fabric ซึ่งรวมถึงข้อกําหนดการใช้สําหรับการแสดงตัวอย่างบริการ Microsoft Generative AI ถึงแม้ว่าคุณสามารถลองและทดลองกับฟีเจอร์ตัวอย่างเหล่านี้ได้ เราขอแนะนําให้คุณไม่ใช้คุณลักษณะ Copilot ในการแสดงตัวอย่างในโซลูชันการผลิต
ความเป็นส่วนตัว ความปลอดภัย และความรับผิดชอบของ AI
Microsoft มุ่งมั่นที่จะทําให้แน่ใจว่าระบบ AI ของเราได้รับคําแนะนําจาก หลักการ AI ของเราและ มาตรฐาน AI ที่รับผิดชอบ ดู ความเป็นส่วนตัว ความปลอดภัย และความรับผิดชอบของการใช้งาน Copilot ใน Fabric สําหรับภาพรวมโดยละเอียด ดูข้อมูลเพิ่มเติม ความเป็นส่วนตัว และความปลอดภัยสําหรับบริการ Azure OpenAI สําหรับข้อมูลโดยละเอียดเฉพาะสําหรับ Azure OpenAI
สําหรับภาพรวมโดยเฉพาะสําหรับแต่ละปริมาณงาน Fabric ให้ดูบทความต่อไปนี้:
- รับผิดชอบการใช้งานใน Data Factory
- การใช้อย่างรับผิดชอบในวิทยาศาสตร์ข้อมูลและวิศวกรรมข้อมูล
- การใช้อย่างรับผิดชอบในคลังข้อมูล
- การใช้ที่รับผิดชอบใน Power BI
- รับผิดชอบในการใช้งานข่าวกรอง Real-Time
ค่าใช้จ่ายของ Copilot ในผ้า
ไม่เหมือนกับ Microsoft Copilots อื่น ๆ Copilot ใน Fabric ไม่จําเป็นต้องมีสิทธิ์การใช้งานต่อผู้ใช้ต่อผู้ใช้หรือต่อความจุเพิ่มเติม แต่ Copilot ใน Fabric ใช้จากหน่วยความจุผ้า (CUs) ที่คุณมี อัตราการบริโภคของ Copilot จะถูกกําหนดโดยจํานวนโทเค็นในอินพุตและเอาต์พุตของคุณเมื่อคุณใช้มันผ่านประสบการณ์การใช้งานต่าง ๆ ใน Fabric
ถ้าคุณมีความจุ Fabric คุณกําลังใช้อินสแตนซ์แบบ pay-as-you-go หรือ reserved ในทั้งสองกรณี การบริโภคของ Copilot ทํางานเหมือนกัน ในสถานการณ์การชําระค่าบริการตามการใช้งานจริง คุณจะถูกเรียกเก็บเงินต่อวินาทีที่ความจุของคุณเปิดใช้งานจนกว่าคุณจะหยุดความจุของคุณชั่วคราว อัตราการเรียกเก็บเงินไม่มีความสัมพันธ์กับการใช้ Fabric CU ของคุณ คุณต้องชําระจํานวนเงินเดียวกันหากความจุของคุณถูกใช้ประโยชน์ทั้งหมดหรือไม่ได้ใช้งานโดยสิ้นเชิง ดังนั้น Copilot จึงไม่มีค่าใช้จ่ายโดยตรงหรือมีผลกระทบต่อการเรียกเก็บเงิน Azure ของคุณ แต่ Copilot ใช้จาก CUs ที่มี ซึ่งปริมาณงาน Fabric และรายการอื่น ๆ ยังใช้และหากคุณใช้มากเกินไปผู้ใช้จะได้รับประสิทธิภาพลดลงและการควบคุม นอกจากนี้ยังเป็นไปได้ที่จะเข้าสู่รัฐของหนี้ CU ที่เรียกว่าแบรกฟอร์ด สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการควบคุมและหัตถการ ดูควบคุมปริมาณทริกเกอร์และควบคุมปริมาณขั้นตอน
ส่วนต่อไปนี้อธิบายเพิ่มเติมเกี่ยวกับวิธีที่คุณควรทําความเข้าใจและจัดการปริมาณการใช้ Copilot ใน Fabric
หมายเหตุ
สําหรับข้อมูลเพิ่มเติม ดู Copilot ในปริมาณการใช้ผ้า
การใช้ Copilot ใน Fabric จะถูกกําหนดโดยโทเค็น
Copilot ใช้ Fabric CU ที่พร้อมใช้งานของคุณ ซึ่งมักเรียกว่าความจุคํานวณ หรือทรัพยากร ปริมาณการใช้จะถูกกําหนดโดยโทเค็นอินพุตและเอาต์พุตเมื่อคุณใช้ หากต้องการตรวจสอบ คุณสามารถทําความเข้าใจโทเค็นอินพุตและเอาท์พุตเนื่องจากการทําโทเค็นดังต่อไปนี้:
- โทเค็นอินพุต: การทําโทเค็นของพร้อมท์ที่เขียนขึ้นและข้อมูลพื้นฐานของคุณ
- โทเค็นผลลัพธ์: โทเค็นของการตอบสนอง Azure OpenAI ขึ้นอยู่กับการป้อนข้อมูล โทเค็นผลลัพธ์มีราคาแพงกว่าโทเค็นอินพุตสามเท่า
คุณสามารถจํากัดจํานวนโทเค็นขาเข้าโดยใช้พร้อมท์ที่สั้นลง แต่คุณไม่สามารถควบคุมสิ่งที่ Copilot ใช้ข้อมูลพื้นฐานสําหรับการประมวลผลล่วงหน้า หรือจํานวนโทเค็นผลลัพธ์ที่ LLM ใน Azure OpenAI ส่งกลับ ตัวอย่างเช่น คุณอาจคาดหวังว่า ประสบการณ์การสร้างรายงาน สําหรับ Copilot ใน Power BI จะมีอัตราปริมาณการใช้สูงเนื่องจากอาจใช้ข้อมูลพื้นฐาน (เช่น Schema แบบจําลองของคุณ) และอาจสร้างเอาต์พุตแบบอย่างละเอียด (เมตาดาต้ารายงาน)
ข้อมูลป้อนเข้า ผลลัพธ์ และข้อมูลพื้นฐานจะถูกแปลงเป็นโทเค็น
การกล่าวซ้ําจากส่วนก่อนหน้าในบทความนี้ สิ่งสําคัญคือต้องทําความเข้าใจ กระบวนการโทเค็น เพื่อให้คุณทราบว่าอินพุตและเอาต์พุตชนิดใดสร้างปริมาณการใช้สูงสุด
การปรับโทเค็นพร้อมท์ให้เหมาะสมไม่น่าจะมีผลกระทบต่อค่าใช้จ่าย Copilot ของคุณอย่างมีนัยสําคัญ ตัวอย่างเช่น จํานวนโทเค็นในพร้อมท์ผู้ใช้ที่เขียนมักจะมีขนาดเล็กกว่าโทเค็นของข้อมูลพื้นฐานและเอาต์พุตมาก Copilot จัดการข้อมูลพื้นฐานและเอาต์พุตโดยอัตโนมัติ คุณไม่สามารถปรับหรือมีผลต่อโทเค็นเหล่านี้ได้ ตัวอย่างเช่น เมื่อใช้ Copilot ใน Power BI, Copilot อาจใช้ Schema จากแบบจําลองความหมายหรือเมตาดาต้าของคุณจากรายงานของคุณเป็นข้อมูลพื้นฐานในระหว่างการประมวลผลล่วงหน้า เมตาดาต้านี้อาจประกอบด้วยโทเค็นมากกว่าพร้อมท์เริ่มต้นของคุณ
Copilot ดําเนินการปรับระบบให้เหมาะสมต่าง ๆ เพื่อลดโทเค็นอินพุตและเอาท์พุต การเพิ่มประสิทธิภาพเหล่านี้ขึ้นอยู่กับประสบการณ์ Copilot ที่คุณกําลังใช้ ตัวอย่างของการปรับระบบให้เหมาะสมได้แก่:
การลด Schema: Copilot ไม่ส่ง Schema ทั้งหมดของตารางแบบจําลองความหมายหรือเลคเฮ้าส์ แต่ใช้การฝังเพื่อกําหนดว่าคอลัมน์ใดที่จะส่ง
การเสริมพร้อมท์: เมื่อเขียนพร้อมท์ใหม่ในระหว่างการประมวลผลล่วงหน้า Copilot จะพยายามสร้างพร้อมท์สุดท้ายที่จะส่งคืนผลลัพธ์ที่เฉพาะเจาะจงมากขึ้น
นอกจากนี้ยังมีการเพิ่มประสิทธิภาพผู้ใช้ต่าง ๆ ที่คุณสามารถใช้เพื่อจํากัดสิ่งที่ข้อมูลพื้นฐาน Copilot สามารถดู และใช้งาน การเพิ่มประสิทธิภาพให้ผู้ใช้เหล่านี้ขึ้นอยู่กับรายการและประสบการณ์ที่คุณกําลังใช้ ตัวอย่างบางส่วนของการเพิ่มประสิทธิภาพผู้ใช้ได้แก่:
การซ่อนเขตข้อมูลหรือการทําเครื่องหมายตารางให้เป็น ส่วนตัว ในแบบจําลองความหมาย: วัตถุที่ซ่อนอยู่หรือวัตถุส่วนตัวใด ๆ จะไม่ถูกพิจารณาโดย Copilot
การซ่อนหน้ารายงานหรือวิชวล: ในทํานองเดียวกัน หน้ารายงานหรือวิชวลที่ซ่อนอยู่หลังบุ๊กมาร์กรายงานจะไม่ถูกพิจารณาโดย Copilot
เคล็ดลับ
การปรับผู้ใช้ให้เหมาะสมส่วนใหญ่มีประสิทธิภาพสําหรับการปรับปรุงประโยชน์ของเอาต์พุต Copilot แทนที่จะปรับต้นทุน Copilot ให้เหมาะสม สําหรับข้อมูลเพิ่มเติม โปรดดูบทความเฉพาะสําหรับปริมาณงานต่าง ๆ และประสบการณ์การใช้งาน Copilot
คุณไม่สามารถมองเห็นได้ในกระบวนการโทเค็น และคุณสามารถส่งผลกระทบน้อยที่สุดต่อโทเค็นอินพุตและเอาท์พุตได้ ดังนั้น วิธีที่มีประสิทธิภาพที่สุดสําหรับคุณในการจัดการปริมาณการใช้ Copilot และหลีกเลี่ยงการ จํากัดผลลัพธ์ คือการจัดการการใช้งาน Copilot
Copilot เป็นการทํางานเบื้องหลังที่เรียบเนียนขึ้น
การใช้งานพร้อมกันของ Copilot ใน Fabric — เมื่อบุคคลจํานวนมากกําลังใช้งานในเวลาเดียวกัน - จะได้รับการจัดการโดยกระบวนการที่เรียกว่า การปรับให้เรียบ ใน Fabric การดําเนินการใด ๆ ที่จัดประเภทเป็น การทํางานแบบเบื้องหลัง มีการใช้งาน CU ซึ่งแบ่งเป็นหน้าต่างตลอด 24 ชั่วโมง โดยเริ่มจากเวลาของการดําเนินการจนถึง 24 ชั่วโมงต่อมา ซึ่งตรงกันข้ามกับ การดําเนินการโต้ตอบ เช่น คิวรีแบบจําลองเชิงความหมายจากบุคคลที่ใช้รายงาน Power BI ซึ่งไม่ราบรื่น
หมายเหตุ
เพื่อลดความซับซ้อนของความเข้าใจ การทํางานแบบเบื้องหลัง และการทํางานแบบโต้ตอบ จะแยกประเภทสิ่งต่างๆ ที่เกิดขึ้นใน Fabric เพื่อวัตถุประสงค์ในการเรียกเก็บเงิน ซึ่งไม่จําเป็นต้องเกี่ยวข้องกับว่ารายการหรือคุณลักษณะนั้นสามารถ โต้ตอบได้สําหรับผู้ใช้ หรือ เกิดขึ้นในพื้นหลังเนื่องจากชื่ออาจแนะนํา
ตัวอย่างเช่น ถ้าคุณใช้ 48 CU กับการทํางานแบบเบื้องหลังในตอนนี้ จะส่งผลให้มีปริมาณการใช้ 2 CUs ในขณะนี้ และ CU 2 ตัวต่อชั่วโมงนับจากตอนนี้จนถึง 24 ชั่วโมงนับจากตอนนี้ หากคุณใช้ 48 CUs กับการทํางานแบบโต้ตอบจะส่งผลให้มี 48 CU ที่สังเกตได้ ที่ใช้ในตอนนี้ และจะไม่มีผลต่อการบริโภคในอนาคต อย่างไรก็ตาม การทําให้เรียบยังหมายความว่าคุณอาจสะสมปริมาณการใช้ CU ในหน้าต่างนั้น หากการใช้งาน Copilot หรือปริมาณงานผ้าอื่น ๆ สูงพอ
เพื่อให้เข้าใจถึงความราบรื่นและผลกระทบต่อการใช้ Fabric CU ของคุณให้พิจารณาแผนภาพต่อไปนี้:
แผนภาพแสดงตัวอย่างของสถานการณ์ที่มีการใช้งานพร้อมกันสูงของการทํางานแบบโต้ตอบ (ซึ่งไม่ราบรื่น) การทํางานแบบโต้ตอบข้ามขีดจํากัดการควบคุม (ความจุของ Fabric ที่มีให้) และป้อน carryforward นี่คือสถานการณ์โดยไม่ทําให้เรียบ ในทางกลับกัน การทํางานแบบเบื้องหลังเช่น Copilot มีการบริโภคมากกว่า 24 ชั่วโมง การดําเนินการที่ตามมาภายในหน้าต่าง 24 ชั่วโมงนั้นจะ "สแตก" และมีส่วนร่วมในปริมาณการใช้สะสมทั้งหมดในรอบระยะเวลานั้น ในสถานการณ์ที่ราบรื่นของตัวอย่างนี้ การทํางานแบบเบื้องหลังเช่น Copilot จะมีส่วนร่วมในการใช้ CU ในอนาคต แต่ไม่ทริกเกอร์การจํากัดหรือข้ามขีดจํากัดใด ๆ
ตรวจสอบปริมาณการใช้ Copilot ในผ้า
ผู้ดูแลระบบผ้าสามารถตรวจสอบปริมาณการใช้งาน Copilot ที่เกิดขึ้นในความจุ Fabric ของคุณโดยใช้แอปเมตริกความจุของ Microsoft Fabric ในแอป ผู้ดูแลระบบ Fabric สามารถดูการแบ่งย่อยตามกิจกรรมและผู้ใช้ ซึ่งช่วยให้พวกเขาสามารถระบุบุคคลและพื้นที่ที่พวกเขาอาจจําเป็นต้องมุ่งเน้นในช่วงเวลาที่มีการบริโภคสูง
เคล็ดลับ
แทนที่จะพิจารณาการคํานวณนามธรรม เช่น โทเค็นไปยัง CUs เราขอแนะนําให้คุณมุ่งเน้นไปที่ เปอร์เซ็นต์ของความจุ Fabric ของคุณที่คุณใช้ เมตริกนี้เป็นวิธีที่ง่ายที่สุดในการทําความเข้าใจและดําเนินการเนื่องจากเมื่อคุณใช้งาน% ถึง 100 รายการ คุณสามารถพบ การจํากัดผลลัพธ์ได้
คุณสามารถค้นหาข้อมูลนี้บนหน้าจุดเวลาของแอป
หมายเหตุ
เมื่อคุณหยุดความจุชั่วคราว การใช้งานที่ราบรื่นจะกระชับลงในจุดเวลาที่ความจุจะหยุดชั่วคราว การกระชับของปริมาณการใช้ที่ราบรื่นนี้ส่งผลให้มีการบริโภคที่สังเกตได้สูงสุดซึ่งไม่สะท้อนการใช้งานจริงของคุณ จุดสูงสุดนี้มักจะสร้างการแจ้งเตือนและคําเตือนว่าคุณได้ใช้ความจุ Fabric ที่คุณมีอยู่ แต่สิ่งเหล่านี้เป็นผลบวกเท็จ
ลดการใช้งานและการจํากัดปริมาณสูง
Copilot ใช้ Fabric CU และแม้จะมีการทําให้เรียบคุณอาจพบกับสถานการณ์ที่มีการใช้งานสูงซึ่งนําไปสู่การบริโภคสูงและจํากัดปริมาณงานผ้าอื่น ๆ ของคุณ ส่วนต่อไปนี้อธิบายถึงกลยุทธ์บางอย่างที่คุณสามารถใช้เพื่อบรรเทาผลกระทบที่มีต่อความจุ Fabric ของคุณในสถานการณ์นี้
การฝึกอบรมผู้ใช้และการอนุญาต
วิธีสําคัญในการรับรองการปรับใช้เครื่องมือที่มีประสิทธิภาพของเครื่องมือใด ๆ คือการให้ผู้ใช้ได้รับคําแนะนําและการฝึกอบรมที่เพียงพอและค่อยๆเผยแพร่การเข้าถึงเมื่อผู้คนเสร็จสิ้นการฝึกอบรมดังกล่าว การฝึกอบรมที่มีประสิทธิภาพเป็นมาตรการป้องกันเพื่อหลีกเลี่ยงการใช้ประโยชน์สูงและการควบคุมไว้ล่วงหน้าโดยการให้ความรู้แก่ผู้ใช้เกี่ยวกับวิธีการใช้ Copilot อย่างมีประสิทธิภาพและสิ่งที่ไม่ควรทํา
คุณสามารถควบคุมได้ดีที่สุดว่าใครสามารถใช้ Copilot ใน Fabric ได้โดยการสร้าง รายการที่อนุญาต ของผู้ใช้ที่มีสิทธิ์เข้าถึงคุณลักษณะจากการตั้งค่าผู้เช่า Fabric ซึ่งหมายความว่าคุณเปิดใช้งาน Copilot ใน Fabric สําหรับผู้ใช้ที่อยู่ในกลุ่มความปลอดภัยเฉพาะเท่านั้น หากจําเป็น คุณอาจสร้างกลุ่มความปลอดภัยแยกต่างหากสําหรับปริมาณงาน Fabric แต่ละรายการ ซึ่งคุณสามารถเปิดใช้งาน Copilot เพื่อให้ได้การควบคุมเกรนที่ดีขึ้นว่าใครสามารถใช้ประสบการณ์ Copilot ใดได้ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการสร้างกลุ่มความปลอดภัย ดูสร้าง แก้ไข หรือลบกลุ่มความปลอดภัย
เมื่อคุณเพิ่มกลุ่มความปลอดภัยเฉพาะลงในการตั้งค่าผู้เช่า Copilot คุณสามารถรวบรวมการฝึกอบรมการเตรียมความพร้อมสําหรับผู้ใช้ได้ หลักสูตรการฝึกอบรม Copilot ควรครอบคลุมหัวข้อพื้นฐาน เช่น หัวข้อต่อไปนี้
เคล็ดลับ
พิจารณาการสร้างการฝึกอบรมภาพรวมสําหรับแนวคิดพื้นฐานเกี่ยวกับ LLMs และ AI ที่ถูกสร้างขึ้น แต่สร้างการฝึกอบรมเฉพาะปริมาณงานสําหรับผู้ใช้ ไม่ใช่ทุกคนที่จําเป็นต้องเรียนรู้เกี่ยวกับปริมาณงาน Fabric ทั้งหมดหากไม่จําเป็นต้องเกี่ยวข้องกับพวกเขา
LLM: อธิบายพื้นฐานของสิ่งที่ LLM คืออะไรและทํางานอย่างไร คุณไม่ควรลงในรายละเอียดทางเทคนิค แต่คุณควรอธิบายแนวคิดเช่นพร้อมท์ พื้นฐาน และโทเค็น นอกจากนี้คุณยังสามารถอธิบายว่า LLMs สามารถรับความหมายจากการป้อนข้อมูลและสร้างคําตอบตามบริบทที่เหมาะสมได้อย่างไรเนื่องจากข้อมูลการฝึกของพวกเขา การสอนสิ่งนี้กับผู้ใช้ช่วยให้พวกเขาเข้าใจวิธีการทํางานของเทคโนโลยีและสิ่งที่สามารถทําได้และไม่สามารถทําได้
Copilot และเครื่องมือ AI แบบสร้างอื่น ๆ ที่ใช้สําหรับ: คุณควรอธิบายว่า Copilot ไม่ใช่ตัวแทนอัตโนมัติและไม่ได้มีวัตถุประสงค์เพื่อแทนที่มนุษย์ในงานของพวกเขา แต่มีไว้เพื่อเสริมให้บุคคลสามารถทํางานในปัจจุบันได้ดีขึ้นและเร็วขึ้น นอกจากนี้คุณควรเน้นกรณีที่ Copilot ไม่เหมาะสมใช้ตัวอย่างเฉพาะและอธิบายว่าเครื่องมือและข้อมูลอื่น ๆ ที่บุคคลอาจใช้เพื่อแก้ไขปัญหาของพวกเขาในสถานการณ์เหล่านั้น
วิธีการประเมินเอาต์พุต Copilot ที่สําคัญ: สิ่งสําคัญคือคุณต้องแนะนําผู้ใช้เกี่ยวกับวิธีที่พวกเขาสามารถตรวจสอบเอาต์พุตของ Copilot ได้ การตรวจสอบความถูกต้องนี้ขึ้นอยู่กับประสบการณ์ Copilot ที่พวกเขากําลังใช้ แต่โดยทั่วไปคุณควรเน้นประเด็นต่อไปนี้:
- ตรวจสอบเอาต์พุตแต่ละรายการก่อนที่คุณจะใช้งาน
- ประเมินและถามตัวคุณเองว่าเอาต์พุตถูกต้องหรือไม่
- เพิ่มข้อคิดเห็นเพื่อสร้างโค้ดเพื่อทําความเข้าใจวิธีการทํางาน อีกวิธีหนึ่งคือ ขอให้ Copilot สําหรับคําอธิบายสําหรับโค้ดนั้น ถ้าจําเป็น และอ้างอิงข้ามคําอธิบายนั้นกับแหล่งข้อมูลที่เชื่อถือได้
- หากผลลัพธ์สร้างผลลัพธ์ที่ไม่คาดคิด ให้แก้ไขปัญหาด้วยพร้อมท์ที่แตกต่างกันหรือโดยการดําเนินการตรวจสอบด้วยตนเอง
ความเสี่ยงและข้อจํากัดของ LLMs และ AI ที่สร้าง: คุณควรอธิบายความเสี่ยงและข้อจํากัดที่สําคัญของ Copilot, LLMs และ AI ที่ก่อให้เกิดเช่นที่กล่าวถึงในบทความนี้:
- ซึ่งไม่ใช่แบบเชิงกําหนด
- ซึ่งไม่มีข้อบ่งชี้หรือรับประกันความถูกต้อง ความน่าเชื่อถือ หรือความเป็นจริง
- พวกเขาสามารถทําให้หลอนประสาทและผลิตเอาต์พุตที่ไม่ถูกต้องหรือมีคุณภาพต่ํา
- พวกเขาไม่สามารถสร้างข้อมูลที่อยู่นอกขอบเขตของข้อมูลการฝึกของพวกเขาได้
ตําแหน่งที่จะหา Copilot ใน Fabric: ให้ภาพรวมระดับสูงของปริมาณงาน รายการ และประสบการณ์ Copilot ที่แตกต่างกันที่ใครบางคนอาจใช้
ปรับขนาดความจุของคุณ
เมื่อคุณพบการจํากัดการใช้งานใน Fabric เนื่องจากการใช้งาน Copilot หรือการดําเนินการอื่น ๆ คุณสามารถ ปรับขนาด (หรือปรับขนาด) ความจุของคุณชั่วคราว ให้เป็น SKU ที่สูงขึ้นได้ นี่เป็นการวัดผลแบบ reactive ที่ยกระดับค่าใช้จ่ายของคุณชั่วคราวเพื่อบรรเทาปัญหาระยะสั้นเนื่องจากการจํากัดหรือดําเนินการ ซึ่งจะเป็นประโยชน์อย่างยิ่งเมื่อคุณพบการจํากัดผลลัพธ์เป็นหลักเนื่องจากการทํางานแบบเบื้องหลัง เนื่องจากปริมาณการใช้ (และดังนั้นผลกระทบ) อาจแพร่กระจายผ่านหน้าต่าง 24 ชั่วโมง
กลยุทธ์การแบ่งความจุ
ในสถานการณ์ที่คุณคาดหวังการใช้งานสูงของ Copilot ใน Fabric (เช่นในองค์กรขนาดใหญ่) คุณอาจพิจารณาแยกปริมาณการใช้ Copilot ออกจากปริมาณงาน Fabric อื่นๆ ของคุณ ในสถานการณ์ของความจุแบบแยกนี้ คุณป้องกันปริมาณการใช้ Copilot จากผลกระทบเชิงลบต่อปริมาณงาน Fabric อื่น ๆ โดยการเปิดใช้งาน Copilot บน F64 ที่แยกต่างหากหรือสูงกว่า SKU ซึ่งคุณใช้เพื่อประสบการณ์ Copilot เฉพาะเท่านั้น กลยุทธ์การแยกความจุนี้สร้างค่าใช้จ่ายที่สูงกว่า แต่อาจทําให้ง่ายต่อการจัดการและควบคุมการใช้งาน Copilot
เคล็ดลับ
คุณสามารถใช้ประสบการณ์ Copilot กับรายการในความจุอื่น ๆ ที่ไม่รองรับหรือเปิดใช้งาน Copilot ตัวอย่างเช่นใน Power BI Desktop คุณสามารถเชื่อมโยงไปยังพื้นที่ทํางานที่มีความจุ F64 SKU Fabric แต่จากนั้นเชื่อมต่อกับแบบจําลองความหมายในพื้นที่ทํางาน F2 หรือ PPU จากนั้น คุณสามารถใช้ประสบการณ์ Copilot ใน Power BI Desktop และปริมาณการใช้ Copilot จะมีผลต่อ F64 SKU เท่านั้น
แผนภาพต่อไปนี้แสดงตัวอย่างของกลยุทธ์การแยกความจุเพื่อแยกปริมาณการใช้ Copilot ที่มีประสบการณ์เช่นเดียวกับใน Copilot ใน Power BI Desktop
คุณยังสามารถใช้โซลูชันความจุแบบแยกได้โดยการกําหนดปริมาณการใช้ Copilot ให้กับความจุแยกต่างหาก การกําหนดปริมาณการใช้ Copilot ให้กับความจุแยกต่างหากช่วยให้มั่นใจได้ว่าการใช้งาน Copilot สูงไม่ส่งผลกระทบต่อปริมาณงาน Fabric อื่น ๆ ของคุณและกระบวนการที่สําคัญทางธุรกิจที่ขึ้นอยู่กับปริมาณงานเหล่านี้ แน่นอนว่าการใช้กลยุทธ์การแยกความจุใด ๆ จะต้องมี SKU อย่างน้อยสอง F64 หรือสูงกว่า ดังนั้นกลยุทธ์นี้อาจไม่สามารถจัดการได้สําหรับองค์กรที่มีขนาดเล็กหรือองค์กรที่มีงบประมาณ จํากัด เพื่อใช้จ่ายบนแพลตฟอร์มข้อมูลของพวกเขา
ไม่ว่าคุณจะเลือกที่จะจัดการ Copilot อะไรสําคัญที่สุดคือการตรวจสอบปริมาณการใช้ Copilot ในความจุ Fabric ของคุณ