มีกระบวนทัศน์สำหรับการเขียนฟังก์ชั่น“ การอัพเดทที่เพิ่มขึ้น” ในสไตล์ดาต้าโฟลที่แท้จริงหรือไม่?

10

ฉันไม่รู้คำศัพท์ที่ถูกต้องสำหรับการถามคำถามนี้ดังนั้นฉันจะอธิบายด้วยคำจำนวนมากแทนอดทนกับฉัน

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

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

input = [5, 20, 7, 2, 4, 9, 6, 13, 1, 45]
intermediate = sort(input)
final_output = substring(intermediate, 0, 5)

ความซับซ้อนของฟังก์ชั่นการเรียงลำดับคือ O (N log N) แต่ให้พิจารณาว่าโฟลว์นี้ใช้ในแอปพลิเคชันที่อินพุตจะเปลี่ยนเพียงเล็กน้อยในแต่ละครั้งโดยเพิ่ม 1 องค์ประกอบ แทนที่จะเรียงลำดับใหม่ตั้งแต่เริ่มต้นทุกครั้งมันจะเร็วขึ้นในความเป็นจริง O (N) เพื่อใช้ฟังก์ชั่นที่อัพเดตรายการที่เรียงแคชเก่าโดยการแทรกองค์ประกอบใหม่ในตำแหน่งที่ถูกต้อง นี่เป็นเพียงตัวอย่างเดียว - ฟังก์ชั่น "ตั้งแต่เริ่มต้น" มีฟังก์ชั่น "การอัพเดทเพิ่มเติม" เช่นกัน นอกจากนี้องค์ประกอบที่เพิ่งเพิ่มเข้ามาใหม่อาจจะไม่ปรากฏใน final_output เพราะอยู่หลังอันดับที่ 5

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

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

— Hallting
แหล่งที่มา

BTW ในกรณีที่เฉพาะเจาะจงของตัวอย่างของวิธีการแก้ปัญหามีประสิทธิภาพมากขึ้นจะใช้กอง ใส่รายการขณะนี้เป็นเพียงและการสร้างรายการที่เรียงลำดับการปรับปรุงในด้านบนค่าขณะนี้เป็นเพียงn)

O (\log n)

$O(\log n)$

k

$k$

O (k \log n)

$O(k \log n)$

— j_random_hacker

7

ฟิลด์นี้ถูกประดิษฐ์ขึ้นหลายครั้งและอยู่ภายใต้ชื่อหลายชื่อเช่น:

อัลกอริทึมออนไลน์
อัลกอริธึมการสตรีมการสืบค้นสตรีมการสืบค้นแบบต่อเนื่อง
โครงสร้างข้อมูลแบบไดนามิก
การคำนวณแบบปรับตัวเอง (ตาม Andrej)

(และอาจมากกว่า) สิ่งเหล่านี้ไม่เหมือนกัน แต่เกี่ยวข้องกัน

การถอดความ Cai et al (1): มีสองวิธีหลักของการใช้อัลกอริทึมออนไลน์ทั่วไป (เช่นโดยไม่มีการอ้างอิงถึงปัญหาอัลกอริทึมเฉพาะ):

การเพิ่มขึ้นคงที่ วิธีการวิเคราะห์แบบคงที่โปรแกรมที่รวบรวมเวลาและผลิตรุ่นที่เพิ่มขึ้นที่มีประสิทธิภาพปรับปรุงผลลัพธ์ของโปรแกรมต้นฉบับตามการเปลี่ยนแปลงอินพุต วิธีการคงที่มีศักยภาพที่จะมีประสิทธิภาพมากกว่าวิธีการแบบไดนามิกเพราะไม่ต้องทำบัญชีที่รันไทม์ นอกจากนี้เวอร์ชันที่เพิ่มขึ้นที่คำนวณได้สามารถปรับให้เหมาะสมโดยใช้เทคนิคคอมไพเลอร์มาตรฐานเช่นการพับแบบคงที่หรืออินไลน์ นี่คือวิธีการตรวจสอบใน (1)
การเพิ่มขึ้นแบบไดนามิก แนวทางแบบไดนามิกสร้างกราฟการพึ่งพาแบบไดนามิกในขณะที่โปรแกรมรันและเผยแพร่การเปลี่ยนแปลงตามกราฟเหล่านี้ วิธีการที่ดีที่สุดคือการคำนวณการปรับตัวเองของ Acar. แนวคิดหลักคือง่าย ๆ : โปรแกรมดำเนินการกับอินพุตต้นฉบับในสภาพแวดล้อมรันไทม์ที่ปรับปรุงแล้วซึ่งติดตามการพึ่งพาระหว่างค่าในกราฟการพึ่งพาแบบไดนามิก ผลลัพธ์ระดับกลางถูกแคช (อย่างที่คุณอาจจินตนาการว่าสิ่งนี้มีแนวโน้มที่จะใช้หน่วยความจำจำนวนมากและการวิจัยจำนวนมากในสาขานี้เป็นเรื่องเกี่ยวกับวิธี จำกัด การใช้หน่วยความจำ) ต่อมาการเปลี่ยนแปลงอินพุตจะแพร่กระจายผ่านกราฟพึ่งพาจากอินพุตที่เปลี่ยนเป็นผลลัพธ์ ผลสุดท้าย; การประมวลผลนี้มักจะมีประสิทธิภาพมากกว่าการคำนวณใหม่ อย่างไรก็ตามการสร้างกราฟการพึ่งพาแบบไดนามิกกำหนดค่าใช้จ่ายปัจจัยคงที่ที่มีขนาดใหญ่ในช่วงรันไทม์ตั้งแต่ 2 ถึง 30 ในการทดลองที่รายงาน

นอกจากนี้เราสามารถลองใช้ 'มือ' ด้วยอัลกอริทึมรุ่นออนไลน์ สิ่งนี้อาจเป็นเรื่องยาก

^{(1) วาย Cai, PG Giarrusso ต Rendel พ Ostermann, ทฤษฎีการเปลี่ยนแปลงที่สูงขึ้น-Order ภาษา: Incrementalizing λ-นิ่วโดยคงความแตกต่าง}

— มาร์ตินเบอร์เกอร์
แหล่งที่มา

1

คุณอาจจะมองหาการเขียนโปรแกรมการปรับตัว ดูวิทยานิพนธ์เอกของ Umut Acar อีกด้วย ฉันไม่ได้รับข้อมูลล่าสุดเกี่ยวกับงานด้านนี้ แต่คุณควรเริ่มต้นคุณสามารถไล่ตามการอ้างอิง

— Andrej Bauer
แหล่งที่มา