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

แอปพลิเคชันดังกล่าวสามารถจัดการได้อย่างไร? ฉันจินตนาการว่าหลังจากสองสามร้อยประโยค IF มันจะดีเท่าที่คาดเดาไม่ได้ว่าโปรแกรมจะตอบสนองและดีบั๊กอะไรที่นำไปสู่ปฏิกิริยาบางอย่างจะหมายความว่าเราจะต้องสำรวจต้นไม้คำสั่ง IF ทั้งหมดทุกครั้ง

ฉันได้อ่านนิดหน่อยเกี่ยวกับเอ็นจิ้นกฎ แต่ฉันไม่เห็นว่าพวกเขาจะรับมือกับความซับซ้อนนี้ได้อย่างไร

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

โปรแกรม Prolog ประกอบด้วยข้อเท็จจริงและกฎที่ใช้ ต่อไปนี้เป็นกฎตัวอย่างง่ายๆที่ระบุว่า "วัวย้ายไปยังที่ตั้งถ้าวัวหิวและมีอาหารในที่ตั้งใหม่มากกว่าในที่เก่า":

moves_to(Cow, Location) :-
  hungry(Cow),
  current_location(Cow, OldLoc),
  food_in(OldLoc, OldFood), food_in(Location, NewFood),
  NewFood > OldFood.

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

นอกจากกฎแล้วยังมีการจัดทำฐานข้อมูลข้อเท็จจริง ตัวอย่างง่ายๆที่ทำงานกับกฎข้างต้นอาจเป็นสิ่งที่ชอบ:

current_location(white_cow, pasture).

current_location(black_cow, barn).
hungry(black_cow).

current_location(angry_bull, forest).
hungry(angry_bull).

food_in(barn, 3).
food_in(pasture, 5).
food_in(forest, 1).

ขอให้สังเกตว่า white_cow และทุ่งหญ้าเลี้ยงสัตว์ ฯลฯ ไม่ได้เขียนในเมืองหลวง พวกมันไม่ใช่ตัวแปรพวกมันคืออะตอม

ในที่สุดคุณก็สอบถามและถามว่าจะเกิดอะไรขึ้น

?- moves_to(white_cow, Destination).
No.
?- moves_to(black_cow, Destination).
Destination = pasture
?- moves_to(Cow, Destination).
Cow = black_cow, Destination = pasture
Cow = angry_bull, Destination = barn
Cow = angry_bull, Destination = pasture

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

แบบสอบถามที่สองถามว่าวัวดำเคลื่อนไปที่ไหน มันย้ายไปที่ทุ่งหญ้าเพื่อกิน

แบบสอบถามสุดท้ายถามว่าวัวทั้งหมดย้ายไปไหน เป็นผลให้คุณได้รับทั้งหมด (วัวปลายทาง) ที่เหมาะสม ในกรณีนี้วัวดำจะย้ายไปยังทุ่งหญ้าตามที่คาดไว้ อย่างไรก็ตามกระทิงโกรธมีสองตัวเลือกที่ตอบสนองกฎมันสามารถย้ายไปยังทุ่งหญ้าหรือยุ้งฉาง

หมายเหตุ: เป็นเวลาหลายปีแล้วที่ฉันเขียน Prolog ครั้งล่าสุดตัวอย่างทั้งหมดอาจไม่ถูกต้องตามหลักไวยากรณ์ แต่ความคิดควรถูกต้อง

การแก้ปัญหาเว็บหากคุณสามารถสร้างเอ็นจิ้นกฎซึ่งแต่ละกฎจะถูกเข้ารหัสอย่างอิสระ การปรับแต่งเพิ่มเติมสำหรับสิ่งนี้คือการสร้างภาษาเฉพาะโดเมน (DSL) เพื่อสร้างกฎอย่างไรก็ตาม DSL เพียงอย่างเดียวแทนที่ปัญหาจากรหัสฐานหนึ่ง (หลัก) ไปยังอีก (DSL) หากไม่มีโครงสร้างแล้ว DSL จะไม่ดีไปกว่าภาษาพื้นเมือง (Java, C # ฯลฯ ) ดังนั้นเราจะกลับมาหาเราหลังจากเราพบวิธีปรับปรุงโครงสร้าง

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

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

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

ตัวอย่างการใช้สิ่งนี้กับโดเมนของคุณ

คุณกำลังพยายามสร้างแบบจำลองว่าวัวเคลื่อนผ่านภูมิประเทศอย่างไร แม้ว่าคำถามของคุณจะไม่มีรายละเอียด แต่ฉันเดาว่าจำนวนมากของ ifs นั้นรวมถึงส่วนการตัดสินใจเช่นif cow.isStanding then cow.canRun = trueแต่คุณจะจมลงเมื่อคุณเพิ่มรายละเอียดของภูมิประเทศเช่น ดังนั้นสำหรับทุกการกระทำที่คุณต้องการพาคุณต้องตรวจสอบทุกแง่มุมที่คุณสามารถคิดและทำซ้ำการตรวจสอบเหล่านี้สำหรับการกระทำที่เป็นไปได้ต่อไป

ก่อนอื่นเราต้องมีการออกแบบที่สามารถทำซ้ำได้ซึ่งในกรณีนี้จะเป็น FSM เพื่อจำลองสภาวะการเปลี่ยนแปลงของการจำลอง ดังนั้นสิ่งแรกที่ฉันจะทำคือการใช้ FSM อ้างอิงกำหนดอินเทอร์เฟซของรัฐการเปลี่ยนอินเทอร์เฟซและบางทีบริบทการเปลี่ยนแปลงที่สามารถมีข้อมูลที่ใช้ร่วมกันเพื่อให้สามารถใช้ได้กับอีกสองคน การใช้งาน FSM ขั้นพื้นฐานจะเปลี่ยนจากการเปลี่ยนภาพหนึ่งไปสู่อีกภาพหนึ่งโดยไม่คำนึงถึงบริบทนี่เป็นที่ที่กฎของโปรแกรมเข้ามากฎของโปรแกรมนั้นจะสรุปเงื่อนไขที่ต้องปฏิบัติให้เรียบร้อยหากการเปลี่ยนแปลงนั้นเกิดขึ้น เอ็นจินกฎที่นี่สามารถทำได้ง่ายเหมือนรายการของกฎแต่ละอันมีฟังก์ชันประเมินผลที่ส่งคืนบูลีน หากต้องการตรวจสอบว่ามีการเปลี่ยนแปลงเกิดขึ้นหรือไม่ให้ทำซ้ำรายการกฎและถ้ามีการประเมินว่าเป็นเท็จการเปลี่ยนแปลงจะไม่เกิดขึ้น การเปลี่ยนแปลงตัวเองจะมีรหัสพฤติกรรมเพื่อแก้ไขสถานะปัจจุบันของ FSM (และงานอื่น ๆ ที่เป็นไปได้)

ตอนนี้ถ้าฉันเริ่มใช้การจำลองเป็น FSM ขนาดใหญ่เดียวที่ระดับ GOD ฉันจบด้วยสถานะที่เป็นไปได้จำนวนมากการเปลี่ยนผ่าน ฯลฯ ระเบียบอื่น ๆ ดูเหมือนว่ามันจะได้รับการแก้ไข แต่จริงๆแล้วมันแพร่กระจายไปรอบ ๆ : แต่ละ IF คือ ตอนนี้กฎที่ดำเนินการทดสอบกับข้อมูลเฉพาะของบริบท (ซึ่ง ณ จุดนี้มีทุกอย่างมาก) และแต่ละเนื้อหาของ IF อยู่ที่ไหนสักแห่งในรหัสการเปลี่ยนแปลง

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

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

จะลึกลงไป

ตอนนี้ GOD ไม่ต้องจัดการกับความซับซ้อนทั้งหมดในการจัดการสถานะภายในของวัวอีกต่อไป แต่เราสามารถผลักดันมันต่อไปได้ ยังมีความซับซ้อนมากมายในการจัดการภูมิประเทศเช่น นี่คือที่ที่คุณตัดสินใจว่าการแยกย่อยเพียงพอหรือไม่ ตัวอย่างเช่นใน GOD ของคุณคุณจะจัดการพลวัตภูมิประเทศ (หญ้ายาวโคลนโคลนแห้งหญ้าสั้น ฯลฯ ) เราสามารถทำซ้ำรูปแบบเดียวกันได้ ไม่มีอะไรขัดขวางคุณจากการฝังตรรกะดังกล่าวในภูมิประเทศโดยการแยกสถานะภูมิประเทศทั้งหมด (หญ้ายาวหญ้าสั้นโคลนแห้ง ฯลฯ ) ลงใน FSM ภูมิประเทศใหม่ด้วยการเปลี่ยนระหว่างรัฐและกฎง่าย ๆ ตัวอย่างเช่นในการเข้าสู่สถานะโคลนเอ็นจิ้นกฎควรตรวจสอบบริบทเพื่อค้นหาของเหลวมิฉะนั้นจะไม่สามารถทำได้ ตอนนี้พระเจ้าก็เรียบง่ายขึ้น

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

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

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

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

ปะยางรถ

ดังที่ระบุไว้ข้างต้น FSM ที่นี่ไม่ใช่วิธีแก้ปัญหาเพียงวิธีการที่จะแสดงให้เห็นว่าการแก้ปัญหาดังกล่าวไม่พบในรหัสต่อคำพูด แต่วิธีที่คุณวางโมเดลปัญหาของคุณ มีวิธีแก้ไขปัญหาอื่น ๆ ที่เป็นไปได้และเป็นไปได้ดีกว่าข้อเสนอ FSM ของฉัน อย่างไรก็ตามวิธีการ "เศษส่วน" ยังคงเป็นวิธีที่ดีในการจัดการปัญหานี้ หากทำอย่างถูกต้องคุณสามารถจัดสรรระดับที่ลึกกว่าซึ่งเป็นเรื่องสำคัญในขณะที่ให้แบบจำลองที่เรียบง่ายกว่า คุณสามารถจัดคิวการเปลี่ยนแปลงและนำไปใช้เมื่อทรัพยากรมีมากขึ้น ในลำดับการกระทำอาจไม่สำคัญเลยที่จะคำนวณการถ่ายเทสารอาหารจากวัวสู่หญ้า อย่างไรก็ตามคุณสามารถบันทึกช่วงการเปลี่ยนภาพเหล่านี้และใช้การเปลี่ยนแปลงในภายหลังหรือเพียงแค่ประมาณด้วยการเดาที่มีการศึกษาโดยเพียงแค่เปลี่ยนกฎของเครื่องมือหรืออาจแทนที่การใช้งาน FSM พร้อมกับรุ่นที่ไร้เดียงสาที่ง่ายกว่าสำหรับองค์ประกอบที่ไม่อยู่ใน ความสนใจ (วัวที่ปลายอีกด้านของฟิลด์) เพื่อให้การโต้ตอบที่มีรายละเอียดมากขึ้นเพื่อรับการมุ่งเน้นและการแบ่งปันทรัพยากรที่มีขนาดใหญ่ขึ้น ทั้งหมดนี้โดยไม่ต้องทบทวนระบบทั้งหมดอีกครั้ง เนื่องจากแต่ละส่วนแยกได้ดีมันจะง่ายกว่าในการสร้างการ จำกัด การแทนที่แบบดรอปดาวน์หรือขยายความลึกของโมเดลของคุณ ด้วยการใช้การออกแบบมาตรฐานคุณสามารถสร้างสิ่งนั้นและเพิ่มการลงทุนในเครื่องมือ Ad-hoc เช่น DSL เพื่อกำหนดกฎหรือคำศัพท์มาตรฐานสำหรับเหตุการณ์เริ่มต้นที่ระดับสูงมากและเพิ่มการปรับแต่งตามต้องการ เนื่องจากแต่ละส่วนแยกได้ดีมันจะง่ายกว่าในการสร้างการ จำกัด การแทนที่แบบดรอปดาวน์หรือขยายความลึกของโมเดลของคุณ ด้วยการใช้การออกแบบมาตรฐานคุณสามารถสร้างสิ่งนั้นและเพิ่มการลงทุนในเครื่องมือ Ad-hoc เช่น DSL เพื่อกำหนดกฎหรือคำศัพท์มาตรฐานสำหรับเหตุการณ์เริ่มต้นที่ระดับสูงมากและเพิ่มการปรับแต่งตามต้องการ เนื่องจากแต่ละส่วนแยกได้ดีมันจะง่ายกว่าในการสร้างการ จำกัด การแทนที่แบบดรอปดาวน์หรือขยายความลึกของโมเดลของคุณ ด้วยการใช้การออกแบบมาตรฐานคุณสามารถสร้างสิ่งนั้นและเพิ่มการลงทุนในเครื่องมือ Ad-hoc เช่น DSL เพื่อกำหนดกฎหรือคำศัพท์มาตรฐานสำหรับเหตุการณ์เริ่มต้นที่ระดับสูงมากและเพิ่มการปรับแต่งตามต้องการ

ฉันจะให้ตัวอย่างรหัส แต่นี่คือทั้งหมดที่ฉันสามารถทำได้ตอนนี้

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

มีหลายวิธีในการจำลองโลกแห่งความเป็นจริงโดยขึ้นอยู่กับลักษณะของปัญหาของคุณ เงื่อนไขต่าง ๆ ของคุณอาจกลายเป็นกฎหรือข้อ จำกัด ที่ใช้กับการจำลอง แทนที่จะมีโค้ดที่ดูเหมือน:

if (sunLevel > 0.75) {
   foreach(cow in cows) {
       cow.desireForShade += 0.5;
   }
}
if (precipitation > 0.2) {
   foreach(cow in cows) {
       cow.desireForShelter += 0.8;
   }
}

คุณสามารถมีรหัสแทนได้ดังนี้:

foreach(rule in rules) {
   foreach (cow in cows) {
      cow.apply(rule);
   }
}

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

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

ไม่มีใครพูดถึงเรื่องนี้ดังนั้นฉันคิดว่าฉันจะพูดอย่างชัดเจน:

กฎ "If .. Then .. Else" นับพันเป็นสัญญาณของแอปพลิเคชันที่ออกแบบมาไม่ดี

ในขณะที่การแสดงข้อมูลโดเมนเฉพาะอาจมีลักษณะกฎเหล่านี้คุณแน่ใจหรือไม่ว่าการใช้งานของคุณควรมีลักษณะคล้ายกับการแสดงเฉพาะโดเมน

โปรดใช้ภาษาซอฟต์แวร์ / คอมพิวเตอร์ที่เหมาะสมกับงาน Matlabถูกใช้บ่อยมากในการสร้างแบบจำลองระบบที่ซับซ้อนซึ่งคุณสามารถมีเงื่อนไขนับพันอย่างแท้จริง ไม่ใช้คำสั่ง if / then / else แต่ใช้การวิเคราะห์เชิงตัวเลข Rเป็นภาษาคอมพิวเตอร์โอเพนซอร์สที่เต็มไปด้วยเครื่องมือและแพคเกจให้ทำเช่นเดียวกัน แต่นี่หมายความว่าคุณต้องปรับแบบจำลองของคุณในแง่คณิตศาสตร์เพิ่มเติมดังนั้นคุณสามารถรวมทั้งอิทธิพลหลักและการโต้ตอบระหว่างอิทธิพลในแบบจำลอง

หากคุณยังไม่ได้ทำตามหลักสูตรเกี่ยวกับการสร้างแบบจำลองและการจำลอง สิ่งสุดท้ายที่คุณควรทำคือการพิจารณาเขียนแบบเช่นนั้นในแง่ของถ้า - แล้ว - อื่น เรามีโซ่มาร์คอฟ monte carlo, สนับสนุนเครื่องเวกเตอร์, โครงข่ายประสาทเทียม, การวิเคราะห์ตัวแปรแฝง, ... โปรดอย่าโยนตัวคุณเองย้อนหลังไป 100 ปีด้วยการเพิกเฉยต่อความมั่งคั่งในเครื่องมือสร้างแบบจำลองที่คุณมี

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

คุณสามารถดูโซลูชันการเขียนโปรแกรมเชิงตรรกะ (เช่น Prolog) คุณสามารถปรับเปลี่ยนรายการของ if / then statement ได้อย่างรวดเร็วและให้มันทำสิ่งต่าง ๆ เช่นดูว่าการรวมกันของอินพุตใด ๆ จะนำไปสู่ผลลัพธ์ที่แน่นอน ฯลฯ มันอาจจะเกิดความสะอาดกว่าในลำดับแรกของตรรกะ รหัสเชิงวัตถุ)

ทันใดนั้นเองก็เริ่มกับฉัน:

คุณต้องใช้Decision Learning Tree (อัลกอริทึม ID3)

มีโอกาสสูงที่มีคนนำไปใช้ในภาษาของคุณ ถ้าไม่คุณสามารถพอร์ตห้องสมุดที่มีอยู่

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

ฉันไม่คิดว่ามีความจำเป็นที่จะต้องย้ำเตือนว่าคุณควรใช้วิธีการที่แตกต่างกันในการใช้รหัสอื่น ๆ

• การเขียนโปรแกรม DSL (ภาษาเฉพาะโดเมน)
• Markov Model / กระบวนการตัดสินใจของมาร์คอฟ
• Rete net / Rete algorithm
• ระบบผู้เชี่ยวชาญ
• Matlab , (Wikipedia)
• R

แอปพลิเคชันขนาดใหญ่ทุกอันประกอบด้วยข้อความนับพันif-then-elseไม่นับการควบคุมการไหลอื่น ๆ และแอปพลิเคชันเหล่านั้นยังคงดีบั๊กและดูแลรักษาแม้จะมีความซับซ้อน

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

คุณควรอธิบายให้ดีขึ้นว่าคุณกำลังพยายามทำอะไรกับ Stack Overflow หรือCode Review เพื่อให้ผู้คนสามารถแนะนำเทคนิคการปรับโครงสร้างที่แม่นยำให้คุณใช้ คุณอาจต้องการถามคำถามที่แม่นยำยิ่งขึ้นเช่น "ฉันจะหลีกเลี่ยงการวางifคำสั่งมากเกินไป<ให้ชิ้นส่วนของรหัส>" ได้อย่างไร

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

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

ดูเทคนิคต่างๆเช่นกฎที่พูดถึงในRefactoringเพื่อหาวิธีแบ่งเงื่อนไขขนาดใหญ่ให้เป็นกลุ่มที่จัดการได้ - คลาสที่มีอินเตอร์เฟสทั่วไปสามารถแทนที่คำสั่ง case ตัวอย่างเช่น

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

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

ฉันขอแนะนำให้คุณใช้เครื่องมือสร้างกฎ ในกรณีของ Java, jBPM หรือ Oracle BPM จะมีประโยชน์ เอ็นจินกฎโดยทั่วไปจะอนุญาตให้คุณกำหนดค่าแอปพลิเคชันผ่าน XML

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

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

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

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

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

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

ฉันไม่คิดว่าคุณควรกำหนดคำสั่ง if-else จำนวนมาก จากมุมมองของฉันปัญหาของคุณมีหลายองค์ประกอบ:

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

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

  วัวควรไปในทิศทางที่มีน้ำหนักรวมมากที่สุดเสมอ ดังนั้นแทนที่จะสร้างต้นไม้ตัดสินใจขนาดใหญ่คุณสามารถเพิ่มชุดของกฎ (พร้อมทิศทางที่แตกต่าง - ฟังก์ชั่นน้ำหนัก) ให้กับวัวแต่ละตัวและเพียงประมวลผลผลลัพธ์ในแต่ละครั้งที่คุณถามทิศทาง คุณสามารถกำหนดค่ากฎเหล่านั้นใหม่ได้โดยการเปลี่ยนตำแหน่งทุกครั้งหรือเมื่อเวลาผ่านไปหรือคุณสามารถเพิ่มรายละเอียดเหล่านี้เป็นพารามิเตอร์ซึ่งทุกกฎควรได้รับ มันคือการตัดสินใจดำเนินการ วิธีที่ง่ายที่สุดในการรับทิศทางเพื่อเพิ่มการวนซ้ำอย่างง่ายจาก 0 °ถึง 360 °ด้วยขั้นตอน 1 ° หลังจากนั้นคุณสามารถนับน้ำหนักรวมของแต่ละทิศทาง 360 และเรียกใช้ผ่านฟังก์ชัน max () เพื่อรับทิศทางที่เหมาะสม

• คุณไม่จำเป็นต้องใช้โครงข่ายประสาทเทียมในการทำสิ่งนี้เพียงแค่คลาสเดียวสำหรับแต่ละกฎหนึ่งคลาสสำหรับวัวอาจเป็นภูมิประเทศ ฯลฯ ... และหนึ่งคลาสสำหรับสถานการณ์ (ตัวอย่างเช่น 3 วัวที่มีกฎแตกต่างกัน & 1 ภูมิประเทศเฉพาะ) รูปที่ 2 - โหนดการตัดสินใจ async ของ async และการเชื่อมต่อ

  • สีแดงสำหรับทิศทางการส่งข้อความ - แผนที่น้ำหนักผ่านกฎ
  • เป็นสีน้ำเงินสำหรับการปฐมนิเทศและการอัปเดตตำแหน่งหลังจากการตัดสินใจ
  • สีเขียวสำหรับการอัพเดตอินพุทหลังจากการวางแนวและการอัพเดตตำแหน่ง
  • สีดำสำหรับรับอินพุต

  หมายเหตุ: คุณอาจต้องใช้กรอบงานการส่งข้อความเพื่อนำสิ่งนี้มาใช้

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

ฉันจะเพิ่มว่าอาจเป็นกรณีที่ถ้าคุณมีIF หลายพันตัวจริงๆ ... จากนั้นกฎคุณก็อาจจะใช้จ่ายเกินจริง สำหรับสิ่งที่คุ้มค่าการพูดคุยเกี่ยวกับการสร้างแบบจำลองโครงข่ายประสาทที่ฉันได้เข้าร่วมมักจะเริ่มต้นด้วยการระบุว่าด้วย "กฎง่ายๆ" พวกเขาสามารถสร้างพฤติกรรมการจับคู่ความเป็นจริงที่ซับซ้อนและสมเหตุสมผลได้ ดังนั้นคุณแน่ใจคุณต้องการเงื่อนไขหลายพันเหรอ? ฉันหมายความว่านอกจากสภาพอากาศ 4-5 ด้านสถานที่ตั้งของแหล่งอาหารเหตุการณ์ฉับพลันฝูงสัตว์และภูมิประเทศคุณจะมีตัวแปรอีกมากมายหรือไม่? แน่นอนว่าถ้าคุณพยายามทำทุกอย่างที่เป็นไปได้ในการรวมเงื่อนไขเหล่านั้นเข้าด้วยกันคุณอาจมีกฎหลายพันข้อได้อย่างง่ายดาย แต่นั่นไม่ใช่แนวทางที่ถูกต้อง บางทีแนวทางแบบตรรกะฟัซซี่ซึ่งปัจจัยต่าง ๆ นำมาซึ่งความลำเอียงในตำแหน่งของวัวแต่ละตัวที่รวมเข้ากับการตัดสินใจโดยรวมจะช่วยให้คุณทำสิ่งนี้ได้ในกฎน้อย

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

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

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

หากคุณเป็น. NET'er ดังนั้นInfer.NETอาจเป็นประโยชน์สำหรับคุณ

เนื่องจากคุณมองการเคลื่อนไหวของวัวพวกมันติดอยู่ในทิศทาง 360 องศา (วัวบินไม่ได้) คุณมีอัตราการเดินทางของคุณ สิ่งนี้สามารถกำหนดเป็นเวกเตอร์

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

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

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

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

ถ้าอย่างนั้นการบอกว่าวัวจะไปในทิศทางใดก็ได้ 360 ให้แบ่งมันเป็น 36 ทิศทาง แต่ละอันมีค่า 10 องศา

ถ้าอย่างนั้นการบอกว่าวัวจะไปในทิศทาง 360 ให้แบ่งลงเป็น 36 ทิศทาง แต่ละอันมีค่า 10 องศา ขึ้นอยู่กับว่าคุณจะต้องเจาะจงแบบไหน

ใช้ OOP วิธีสร้างกลุ่มคลาสที่จัดการกับเงื่อนไขพื้นฐานและรันเมธอดแบบสุ่มเพื่อจำลองสิ่งที่คุณกำลังทำ

รับโปรแกรมเมอร์เพื่อช่วย

class COW_METHODS {

    Function = array('Action1','Action2',....'ActionX');

    function doAction() {
       execute(Function[random(1,5000]);
    }

    function execute(DynamicFunction) {
        exec(DynamicFunction());
    }

    Function Action1() {
        turnRight();
        eatGrass();
    }
    /*  keep adding functions for COW Methods ...  etc  */
    /*  and add classes for conditions inherit them as needed  */
    /*  keep an object to define conditions =  Singleton etc.  */
}