Closure and Consistency ใน logic-based reasoning framework คืออะไร

โพสนี้อยู่ในหมวด เรียนรู้ logic programming + argumentation นะคะ

ห่างหายไป พอดีว่ายุ่งๆกับงานมากไปหน่อยนะคะ แต่ก็จะพยายามอัพบล็อกตามสัญญาเดือนละโพสให้ได้(นี่ได้ข่าวว่าสองเดือนผ่านไปแร้วน๊าาาา ที่ไม่ได้อัพเดท  ฮ่าๆๆ)

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

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

อย่างที่เคยเกริ่นไว้ว่า งานด้านที่เราทำนี้คือ Knowledge Representation and Reasoning ดังนั้นเวลาเราจะออกแบบระบบ AI ให้ทำการคิดได้เนี่ย เราต้องมองไปถึงว่า เราจะทำการ represent knowledge ของระบบยังไง ในรูปแบบไหน ที่จะทำให้คอมพิวเตอร์มันเอาไปทำการคิด (reason) ต่อได้


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

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

ซึ่งมาจากความคิดที่ว่า... ถ้าเรามีเซตของข้อมูลตั้งต้นอยู่ แล้วเราทำการอนุมานไป (เป็นการหา closure)  เราก็จะได้ข้อมูลเยอะขึ้นใช่ไหมคะ  เซตของข้อมูลเรามันก็ต้องขยายใหญ่ขึ้น แล้วเราก็เอาเซตข้อมูลที่เพิ่มขึ้นนี้ มาอนุมานต่อ เซตก็ต้องขยายเพิ่มอีก ทำไปเรื่อยๆ จนเราไม่สามารถ derive ข้อมูลอะไรใหม่ๆได้อีกแล้ว เราก็หยุด

ทีนี้ ถ้าเรามีเซตของข้อมูลตั้งต้นอยู่เซตนึง แล้วเราเอามันไปหา closure แล้วปรากฎว่า สุดท้ายแล้ว ข้อมูลที่เราอนุมานได้ มันก็อยู่ในเซตอยู่แล้วแต่แรก พูดสั้นๆคือ Closure(N) = N

อย่างนี้เราจะถือว่าเซตข้อมูล N นี้ Close ค่ะ
การที่เรามีเซตข้อมูลที่มัน close นี้ดียังไง .... ก็แปลว่า เรามีข้อมูลที่จำเป็นครบถ้วนแล้ว ไม่ได้ขาดอะไรไป ไม่ได้อะไรเกินมา

ยกตัวอย่างเช่น เรามีเซตของข้อมูลตั้งต้นคือ  N = { ฝนตก, ถนนเปียก }
แล้วสมมติว่า ใน knowledge base เรามีกฎที่ว่า ถ้า ฝนตก แล้ว ถนนเปียก
นั่นก็แสดงว่าเซต N เนี่ย close เพราะเมื่อเราเอา N ไปหา closure เราก็ได้เซต N เหมือนเดิมอยู่ดี

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

ยกตัวอย่าง
สมมติว่า   เราเถียงกันกับเพื่อนว่า  เพนกวินบินได้หรือไม่ แล้วเราสรุปว่าเพนกวินบินไม่ได้
ดังนั้น เซตข้อมูลที่เรายอมรับเนี่ย ก็จะต้องประกอบไปด้วย ข้อเท็จจริงว่า มีนกเพนกวินอยู่ แล้วก็มี กฎว่า ถ้าเป็นนกเพนกวินแล้วจะบินไม่ได้

ดังนั้นสมมติให้เป็น N = {เพนกวิน,  ถ้าเป็นนกเพนกวินแล้วจะบินไม่ได้ , บินไม่ได้ }
ซึ่งเซตข้อมูล N นี้ จะทำให้เราสามารถได้ข้อมูลครบถ้วนไม่มีอะไรขาด ไม่มีอะไรเกิน ดังนั้นเซต N  เนี่ย close

ดังนั้นเวลาที่เราออกแบบ framework อะไรก็ตามที่ทำการ reasoning   เราจะต้องออกแบบให้ semantic ของ framework นั้นๆ ควรที่จะ satisfy closure postulate ใช่ไหมคะ  (อ่านเรื่อง semantic ของ argumentationได้ที่โพสนี้)

ทีนี้เรามาลอง formalize ตัวอย่างเรื่องนกเพนกวินกันด้วย  Assumption-Based  Argumentation Framework (ABA) นะคะ  (สำหรับใครที่ยังไม่รู้จัก ABA รบกวนอ่านที่นี่นะคะ)

ถ้าเราเอาตัวอย่างเรื่องนี้ มาเขียนในรูปแบบของ ABA จะเป็นยังไงนะคะ
จะได้ว่า กำหนดให้ F = (A,R,T) เมื่อ
A = {not_ab}
R = {
penguine(X) ←
fly(X) ← bird(X), not_ab
ab ← penguine(X)
}
และ T(not_ab) = ab

ทีนี้ เราก็จะมี AF = (AR, att) wrt F ซึ่งจะได้
AR = (A1,A2) และ att = (A2,A1)

เมื่อ A1 คือ                                                   fly(X)
                                               ____________|___________
                                               |                                              |
                                           bird(X)                                    not_ab
                                               |                                             
                                              ◻                                           
และ A2 คือ                                                   ab
                                                                      |                                              
                                                                penguine(X)                                   
                                                                      |                                             
                                                                     ◻                                              

ดังนั้น จากนิยาม prefer semantic ของ ABA เราก็จะได้ เซตของ argument ที่เรายอมรับคือ E={A2}

หมายเหตุ : ตรงนี้จะถือว่า E ตรงกับ เซต N = {เพนกวิน,  ถ้าเป็นนกเพนกวินแล้วจะบินไม่ได้ , บินไม่ได้ } ข้างต้น เนื่องจากว่า ใน argument จะประกอบไปด้วยทั้ง fact (เพนกวิน),assumption และ inference rule (ถ้าเป็นนกเพนกวินแล้วจะบินไม่ได้ ) ส่วน conclusion ของ A2 คือ ab (บินไม่ได้)

ถ้าเราเอา E ไปหา closure เราก็จะได้เซต E กลับมาเหมือนเดิม (ซึ่งก็คือ Closure(E) = E) ดังนั้น ก็แสดงว่าเซตข้อมูลที่เรายอมรับนั้นมีข้อมูลครบถ้วน

ซึ่งเราก็จะเห็นว่า AF เป็น framework ที่ satisfy closure postulate เพราะว่า semantic ของ AF(อย่างในตัวอย่างนี้คือเซต E) มัน close นะคะ


สมมตินะคะว่า ถ้าเกิดเราออกแบบ reasoning framework มาอันนึง สำหรับแก้ปัญหาตัวอย่างนกเพนกวินนี่แหละ แล้วปรากฎว่า semantic ที่ได้ในตอนท้ายเนี่ย เราได้เซต E = {เพนกวิน, บินไม่ได้, คนไทยผมสีดำ} ซึ่งจะเห็นว่า ข้อมูลคนไทยผมสีดำ ไม่ได้เกี่ยวข้องกับปัญหาที่เราต้องการจะแก้ไขเลย แต่ว่า... เราต้องพึ่งข้อมูลคนไทยผมสีดำ เราถึงจะได้ข้อสรุปว่า เพนกวินบินไม่ได้ (ซึ่งจริงๆแล้ว เราต้องกำจัด คนไทยผมสีดำ ออกไปจาก semantic ของ framework เพราะมันไม่เกี่ยวกันกับนกเพนกวินบินไม่ได้เลย)


ดังนั้น ไม่ว่าเราจะออกแบบ logical framework อะไรก็ตามที่ใช้สำหรับการทำ reasoning เราควรจะต้องคำนึงถึงว่า semantic ของ framework เรานั้น ควรจะ satisfy คุณสมบัติของ closure and consistency ด้วยนะคะ
  

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

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

สมมติว่าตอนนี้เราแบ่ง knowledge แบบกลุ่มใหญ่ๆนะคะ ก็มีทั้งข้อเท็จจริงที่เปลี่ยนแปลงไม่ได้ (fact) และข้อมูลที่ได้มาจากการอนุมาน (deduce) ต่อ

ซึ่งก็มีคำถามผุดขึ้นมาว่า ข้อมูลอะไรบ้างล่ะ ที่เราต้องให้มัน consistent (ห้ามขัดแย้งกัน) ?

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

ข้อมูลที่ได้จากการอนุมานล่ะ จะขัดแย้งกันได้ไหม อย่างเช่น จะมีข้อมูลทั้งว่าหลานชายกินเค้กไป และหลานชายไม่ได้กินเค้กไปด้วยได้ไหม


ตรงนี้แหละค่ะ  คือจุดที่น่าสนใจของลอจิก คือ... การที่ข้อมูลมันขัดแย้งกันนี่แหละ เราจะจัดการยังไง และเราจะยอมรับข้อมูลไหน ไม่ยอมรับข้อมูลไหน เพราะอะไร

ซึ่ง โดยทั่วไปแล้ว fact เนี่ย เราจะไม่ยอมให้มันขัดแย้งกันนะคะ เช่น จะบอกว่าในเซตข้อมูล มีทั้ง {พระอาทิตย์ขึ้นทางทิศตะวันตก , พระอาทิตย์ขึ้นทางทิศตะวันออก} ไม่ได้

เพราะ fact คือข้อเท็จจริง ที่ไม่มีการเปลี่ยนแปลง และเป็นการยอมรับโดยสากล

ต่อมา เรื่องของการอนุมาน
เท่าที่พบ ก็จะพบว่า ข้อมูลที่ได้จากการอนุมาน ด้วยกฏที่เป็นกฎตายตัวเป็นที่ยอมรับจริงแท้นั้น เราก็ต้องการให้มัน consistent ค่ะ

ยกตัวอย่างเช่น  กฎที่ว่า   ถ้า X เป็นมนุษย์แล้ว X จะไม่เป็นอมตะ (ต้องตายวันใดวันนึง)

ดังนั้น สมมติว่า เรามี เซตข้อมูล ตั้งต้น S1= {นายกอไก่} แล้วเราเอาเซตนี้ไปอนุมานต่อ ก็จะได้ เซตข้อมูลใหม่คือ S2={นายกอไก่, นายกอไก่ไม่เป็นอมตะ} ซึ่งก็ consistent


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

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


ดังนั้น สมมติว่าเราออกแบบ reasoning framework ของเรา ให้มีข้อมูลที่ขัดแย้งกันในระบบได้ล่ะ แต่ว่า สุดท้ายแล้ว เซตของข้อมูลที่จะยอมรับ (semantic of framework) จะต้อง satisfy consistency postulate ด้วยนะคะ

ดังนั้น จากตัวอย่างนกเพนกวินข้างบน  ที่เราเอามา formalize ด้วย ABA framework แล้วเราก็เอามาหา prefer semantic ได้ E = {A2} ใช่ไหมคะ
เราก็จะพบว่า conclusion (ข้อสรุป) ของ argument ในเซต E นั้น consistent  ก็สามารถบอกได้ว่า  framework นั้น satisfy consistency postulate



แนะนำว่า ถ้าอยากเข้าใจอย่างละเอียด ซึ่งจะมีการยกตัวอย่างให้เห็นที่มาที่ไปชัดเลยว่า ทำไมเราถึงต้องการคุณสมบัติ closure and consistency  แต่จะอธิบายโดยอ้างอิงกับ defeasible argumentation framework  ให้อ่านเปเปอร์ นี้ เพิ่มเติมค่ะ
Reference: Dung P.M., Thang P.M. , Closure and Consistency In Logic-Associated Argumentation.


หวังว่าผู้อ่านคงจะพอเข้าใจมุมมองของ closure and consistency ใน logic-based framework ที่ใช้สำหรับการทำ reasoning AI กันบ้างแล้วนะคะ :)