หน่วยความจำ
Perch รันระบบหน่วยความจำสามระบบพร้อมกัน ได้แก่ ไฟล์โปรเจกต์ที่คุณเป็นเจ้าของ หน่วยความจำระยะยาวระดับบัญชีที่ดึงด้วยการค้นหาแบบไฮบริด และการเรียนรู้ที่เก็บจากการแก้ไขของคุณ หน้านี้อธิบายว่าแต่ละระบบทำอะไร และส่งข้อมูลถึงโมเดลอย่างไร
harness ของเอเจนต์ส่วนใหญ่มีระบบหน่วยความจำเพียงระบบเดียว ซึ่งมักเป็นไฟล์ที่คุณแก้ไขเอง Perch รันสามระบบ และแต่ละระบบทำหน้าที่ต่างกันจริงๆ ไฟล์โปรเจกต์เก็บกฎประจำของงานชิ้นหนึ่ง หน่วยความจำระยะยาวเก็บสิ่งที่เป็นจริงเกี่ยวกับตัวคุณในทุกงาน และการเก็บการเรียนรู้จะเปลี่ยนการแก้ไขของคุณให้เป็นหน่วยความจำ โดยที่คุณไม่ต้องจดอะไรเลย
หน้านี้อธิบายทั้งสามระบบ แล้วต่อด้วยส่วนที่สำคัญที่สุด คือข้อมูลเหล่านี้ไปถึงโมเดลจริงๆ อย่างไรในแต่ละเทิร์น และคุณจะดูได้อย่างไรว่าอะไรไปถึงบ้าง
สรุปสั้นๆ
ชั้นที่หนึ่ง: หน่วยความจำโปรเจกต์
หน่วยความจำโปรเจกต์อยู่บนดิสก์ ในโฟลเดอร์ที่คุณกำลังทำงาน เป็นไฟล์ markdown ธรรมดาที่คุณเป็นเจ้าของ และคุณอ่านหรือแก้ไขส่วนใดก็ได้โดยไม่ต้องผ่าน Perch
| พาธ | สิ่งที่เก็บ |
|---|---|
.perch/PERCH.md | คู่มือโปรเจกต์ คำสั่งประจำที่ Perch ทำตามทุกเทิร์นในโฟลเดอร์นี้ |
.perch/memory/*.md | ไฟล์หน่วยความจำแยกรายการ หนึ่งไฟล์ต่อหนึ่งข้อเท็จจริงหรือหนึ่งโน้ต |
.perch/rules/ | กฎของโปรเจกต์ แยกจากเนื้อหาร้อยแก้วเพื่อให้นำไปใช้ได้อย่างเคร่งครัด |
~/Documents/Perch/PERCH.md | คู่มือระดับ global ใช้กับทุกโฟลเดอร์ ไม่ใช่แค่โฟลเดอร์นี้ |
PERCH.md คือที่ที่เหมาะสำหรับทุกอย่างที่คุณจะบอกเพื่อนร่วมทีมใหม่ที่เข้ามาร่วมโปรเจกต์ เช่น แนวปฏิบัติของคดีนี้ รูปแบบผลลัพธ์สำหรับลูกค้ารายนี้ พาธที่สำคัญ และสิ่งที่ห้ามแตะโดยไม่ถามก่อน Perch อ่านไฟล์นี้ทุกเทิร์นในโฟลเดอร์นั้น และทำตามไฟล์นี้ก่อนค่าเริ่มต้นของตัวเอง
Perch เขียนไฟล์เหล่านี้เองได้เมื่อคุณขอให้จำอะไรบางอย่าง แต่ผลลัพธ์จะเป็นไฟล์ที่คุณเปิดดูได้เสมอ ไม่มีส่วนใดของหน่วยความจำโปรเจกต์ที่ถูกซ่อนจากคุณ
นอกจากไฟล์แล้ว แอปเดสก์ท็อปยังส่งเมทาดาทาขอบเขตโฟลเดอร์ให้กับเทิร์นด้วย ได้แก่ ชื่อโปรเจกต์ โน้ตของคุณ สรุปหน่วยความจำ และโฟลเดอร์รากที่ต้องการ นี่คือวิธีที่ Perch รู้ว่าอยู่ในโปรเจกต์ไหนก่อนจะอ่านไฟล์แม้แต่ไฟล์เดียว
ชั้นที่สอง: หน่วยความจำระยะยาว
หน่วยความจำระยะยาวอยู่ในระดับบัญชี ไม่ใช่ระดับโฟลเดอร์ เก็บสิ่งที่ยังคงเป็นจริงเกี่ยวกับตัวคุณเมื่อคุณย้ายไปมาระหว่างโปรเจกต์และแพลตฟอร์ม ได้แก่ บทบาทของคุณ แนวปฏิบัติของคุณ วิธีที่คุณชอบให้นำเสนอผลลัพธ์ และข้อเท็จจริงที่คุณบอก Perch ไปแล้วครั้งหนึ่งและไม่ควรต้องพูดซ้ำ
หน่วยความจำนี้ไม่ใช่ข้อมูลก้อนเดียวที่ถูกแปะลงในทุกพรอมต์ แต่เป็นชุดการ์ดแยกรายการ และในแต่ละเทิร์นจะมีขั้นตอนการดึงข้อมูลเพื่อตัดสินว่าการ์ดใบไหนคุ้มกับโทเค็นที่ใช้
การดึงข้อมูลทำงานอย่างไร
Perch ค้นหาหน่วยความจำระยะยาวสองวิธีพร้อมกัน แล้วรวมผลลัพธ์เข้าด้วยกัน
- การค้นหาเชิงความหมาย บน embeddings ซึ่งหาการ์ดที่มีความหมายเดียวกับเทิร์นปัจจุบันได้แม้ถ้อยคำจะต่างกัน
- การค้นหาด้วยคีย์เวิร์ดแบบ sparse ซึ่งจับคำที่ตรงตัว ชื่อ และตัวระบุ ที่ embeddings มักทำให้เลือนไป
รายการที่จัดอันดับแล้วทั้งสองรายการจะถูกรวมกันด้วย reciprocal rank fusion การ์ดที่ทั้งสองวิธีจัดอันดับไว้ค่อนข้างดีจึงชนะการ์ดที่มีเพียงวิธีเดียวชอบมาก จากนั้นคะแนนที่รวมแล้วจะถูกปรับตามความมั่นใจของการ์ดเองและความใหม่ของการ์ด แล้วผลลัพธ์อันดับต้นๆ จะถูกเลือกเข้ามาใช้
ถ้าใช้ embeddings ไม่ได้ การดึงข้อมูลจะลดระดับลงตามลำดับแทนที่จะล้มเหลว คือจากแบบไฮบริด เป็นเชิงความหมายอย่างเดียว เป็น sparse อย่างเดียว แล้วเป็นการเรียงตามความใหม่ธรรมดา คุณจะได้ผลการดึงข้อมูลที่ครบถ้วนน้อยลง แต่ไม่มีวันได้เทิร์นที่พัง
แต่ละการ์ดมีอะไรบ้าง
การ์ดหน่วยความจำระยะยาวทุกใบที่ถูกเลือกเข้ามาในเทิร์นจะนำเมทาดาทาของตัวเองมาด้วย ซึ่งทำให้ระบบนี้ตรวจดูได้ ไม่ใช่เวทมนตร์
- ประเภทและขอบเขต บอกว่าเป็นหน่วยความจำประเภทใดและใช้ได้กว้างแค่ไหน
- ป้ายบอกความใหม่ และธงว่าล้าสมัย เมื่อการ์ดเก่าเกินกว่าจะเชื่อถือได้โดยไม่ตรวจสอบ
- คะแนนความมั่นใจ แสดงเป็นเปอร์เซ็นต์
- ธงว่าถูกตัดทอน ตั้งไว้เมื่อต้องย่อการ์ดให้สั้นลงเพื่อให้พอดีกับงบหน่วยความจำของเทิร์นนั้น
- เหตุผลที่ถูกดึงมา ส่งต่อมาจากขั้นตอนการค้นหา
ชั้นที่สาม: การเรียนรู้จากการแก้ไข
ระบบที่สามคือระบบที่คุณไม่ต้องควบคุมเลย เมื่อคุณแก้ไข Perch การแก้ไขนั้นจะถูกเก็บเป็นเหตุการณ์ การเก็บการเรียนรู้จะอ่านเหตุการณ์เหล่านั้นและเสนอหน่วยความจำถาวรใหม่จากเหตุการณ์ได้
นี่คือความแตกต่างระหว่างเครื่องมือที่จำสิ่งที่คุณพิมพ์ลงในหน้าตั้งค่า กับเครื่องมือที่จำได้ว่าเคยถูกบอกว่าทำผิด การแก้ไข Perch ครั้งเดียวคือวิธีสอนที่ออกแบบไว้ และคุณไม่ต้องไปจดบทเรียนนั้นไว้ที่อื่นอีก
หน่วยความจำไปถึงโมเดลอย่างไร
การมีระบบหน่วยความจำสามระบบจะมีประโยชน์ก็ต่อเมื่อสิ่งที่เก็บไว้ไปถึงบริบทของโมเดลจริงๆ และส่วนที่ยากคือบริบทมีขนาดจำกัด Perch จัดการเรื่องนี้ด้วยเลนที่เรียงลำดับไว้ภายใต้งบโทเค็น
ในแต่ละเทิร์น เนื้อหาจะถูกจัดลงในเลนที่ตั้งชื่อไว้ และถูกเลือกเข้ามาตามลำดับจนกว่างบจะหมด เลนเหล่านี้ได้แก่ หน่วยความจำโปรเจกต์ หน่วยความจำถาวร หลักฐานจากเธรด หลักฐานจากเครื่องมือ ไฟล์ เครื่องมือ สกิลที่เลือก และโมเดลที่เลือก โดยกันพื้นที่สำรองไว้สำหรับผลลัพธ์ของโมเดลเอง เพื่อไม่ให้คำตอบยาวๆ ถูกตัดเพราะบริบทของตัวเอง
มีสองคุณสมบัติที่ทำให้เรื่องนี้ควรค่าแก่การทำความเข้าใจ
- การคัดเลือกมีความชัดเจน เมื่อบางอย่างไม่ได้เข้าไปในเทิร์น นั่นคือการตัดสินใจที่มีเหตุผลบันทึกไว้ ไม่ใช่การทิ้งไปเงียบๆ
- ทุกส่วนมีเหตุผลกำกับ บริบทแต่ละชิ้นที่ถูกเลือกเข้ามามีคำอธิบายสั้นๆ ว่าทำไมจึงอยู่ตรงนั้น และส่วนที่ถูกข้ามไปก็บันทึกว่าทำไมจึงไม่ถูกเลือก
เลนกับการบีบอัดบริบทเป็นคนละเรื่องกัน
ดูว่า Perch ทำงานจากข้อมูลอะไร
เพราะทุกส่วนที่ถูกเลือกเข้ามามีเลน ป้ายกำกับ และเหตุผลของตัวเอง แอปเดสก์ท็อปจึงแสดงทั้งหมดออกมาได้ แผง Context Window แสดงบริบทของเทิร์นเป็นแถว โดยการ์ดหน่วยความจำระยะยาวแต่ละใบเป็นแถวของตัวเอง พร้อมสถานะ ความใหม่ และความมั่นใจ
นี่คือคำตอบของคำถามที่เครื่องมือเอเจนต์ทุกตัวต้องเจอในที่สุด นั่นคือ "ทำไมมันถึงทำแบบนั้น" คุณดูได้ว่าโมเดลได้รับอะไรไปจริงๆ
ควบคุมได้เอง
หน่วยความจำโปรเจกต์เป็นไฟล์ธรรมดา คุณเปิด แก้ไข ลบ หรือ check in เข้าระบบควบคุมเวอร์ชันพร้อมกับส่วนอื่นของโปรเจกต์ได้ หน่วยความจำระยะยาวมีขอบเขตอยู่ที่บัญชีของคุณและตามคุณไปทั้งในเว็บแชต แอปเดสก์ท็อป และ CLI สิ่งที่ Perch เรียนรู้บนแพลตฟอร์มหนึ่งจึงใช้ได้บนแพลตฟอร์มอื่นด้วย
เมื่อข้อความที่ใหม่กว่าขัดแย้งกับข้อความที่เก่ากว่า Perch จะเลือกข้อความที่ใหม่กว่า การแก้ไข Perch คือกลไกการอัปเดต และตั้งใจให้ง่ายแค่นั้น
