Hello May! กับบทสนทนาแบบ argumentation

Hello May ! 

อาจจะงงๆว่า เอ... ทำไมถึงใช้รูปนี้ ซึ่งไม่ได้เกี่ยวข้องอะไรกับหัวข้อที่โพสเลยนะคะ
อันที่จริงก็คือ รูปนี้คือ รูปแรกที่ถ่ายของวันนี้ ในเดือนพฤษภาคม ปีนี้ค่ะ เพราะอยากจะให้ตรงกับหัวข้อโพส Hello May!  ดังนั้น เราก็เลยสวัสดี พฤษภาปีนี้ด้วยทุเรียนหมอนทอง หวานกรอบ อร่อยๆ ค่ะ 😋


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

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


งั้นเรามาลองดูกันนะคะว่า บทสนทนาขำๆ วันนี้มีว่าอย่างไร (ขอใช้ภาษาวิบัติ เพื่อความสมจริง)

M1:       ทำไมวันนี้เธอตื่นเช้าจังเลยล่ะ
A1:       ไม่เช้าแล้วค่ะ สายแร้ว
M2:       อ้าว ตอนนี้ไม่ใช่เกือบเก้าโมงเช้าหรอ
A2:       เก้าโมง นี่เช้าหรอคะหญิงมดดี้ ตายแระ
M3:       ฮ่าๆๆ ช่ายเรย  สำหรับชั้นไง
M4:       แล้วนี่เธอทำอะไรอยู่
A3:       เพิ่งตื่นค่ะ
M5:      ว๊าย... ตื่นสายนะเธอ
A4:       อ่าว เมื่อกี๊ยังบอกเช้าอยู่เลย
M6:      55555555 (เขิล)


เอาล่ะค่ะ บทสนทนานี้มันคือความโก๊ะของเราเองที่มักจะเป็นแบบนี้ประจำ อยากแกล้งคนอื่นแต่ก็เข้าตัวเองตลอดๆ

ลองสังเกตบทสนทนานี้ดีๆนะคะ จะพบว่า ในความเข้าใจของเราตอนแรก การตื่นนอนตอน 9.00 น. นี่คือ ตื่นเช้า ในขณะที่เพื่อน จะมองว่าเป็นการตื่นสาย (เพราะเพื่อนต้องการจะแซวเราฮ่าๆๆ)  แต่เมื่อคุยกันต่อ เราเองกลับเปลี่ยนประโยคว่า การตื่น 9.00 น. คือการตื่นสาย


คำถามคือ เราจะทำการ โมเดลในระบบ เพื่อให้ได้ เซตของ accepted argument ได้ไหม ทำได้อย่างไร
หรือ พูดอีกอย่างก็คือ  เราจะสร้างโมเดลของ argument เพื่อทำ การคิดหาเหตุผลได้หรือไม่

Can we provide a formal model of argument systems for practical reasoning ?


ถ้าเราจะลอง formalize บทสนทนานี้ ด้วย argumentation ก็สามารถทำได้ โดยจะใช้ AA หรือ ABA แบบที่เคยอธิบายไปคร่าวๆแล้วนะคะ  ถ้าหากยังจำได้ ABA เนี่ย โครงสร้างของ argument จะมีเฉพาะ ส่วนของ assumption เท่านั้นที่เราจะ attack ได้ ซึ่งเราจะเรียกการ attack แบบนี้ว่า undermine

เพื่อความเข้าใจก่อนอื่นเลย เราจะโชว์ให้เห็นว่า ถ้า formalize บทสนทนานี้ในรูปแบบของ AA คือ argument ไม่มีโครงสร้างอะไรพิเศษ เราแค่กำหนดว่า argument ไหน attack ใครก็พอ

เราจะสามารถวาดแผนผังการตีกัน(ฮ่าๆๆ attack relation) ของ argument ได้ดังนี้ค่ะ
ซึ่งเราตัด ประโยคท้ายสองประโยคออก เนื่องจากไม่ได้สื่อความหมายอะไรพิเศษนะคะ

จะเห็นว่าในแผนผัง argument M2, M4, A3 จะอยู่แยกออกมา ไม่ได้ attack ใคร เนื่องจากให้ความหมายเหมือนๆกันก็คือ A ตื่นนอนเวลา 9.00 น.

ส่วน A1, A2 นั้น จะทำการ attack ฝั่งตรงข้ามก็คือ M1, M3  และในขณะเดียวกัน M1, M3 ก็ attack A1, A2 ด้วยเช่นกัน

แต่ทีนี้ ถ้าดู M5 จะพบว่า M5 attack M1,M3  ซึ่งก็แน่นอนว่า M1,M3 ก็ attack กลับได้

ถ้าหากว่ายังจำ นิยามของ acceptability of arguments  จากที่เคยเกริ่นเรื่อง Abstract argumentation ได้ ก็จะเห็นว่า เซตของ acceped arguments นั้นจะต้อง ไม่ขัดแย้งในตัวเองและ attack ข้อโต้แย้งอื่นๆได้หมด

ถ้าหากว่าเรา ทำการหา prefer semantic  ก็จะได้ออกมา 2 set คือ
{A1, A2, M5 , M2, M4, A3}และ {M1, M3, M2, M4, A3}
นั่นก็หมายความจะเลือก เชื่อฝั่งไหนก็ได้  ว่า การตื่นเก้าโมงเป็นการตื่นเช้า หรือจะเชื่อว่า เป็นการตื่นสายก็ได้

ถ้าหากว่าหา grounded semantic ก็จะได้ เป็น empty set


ขอโน้ตไว้นิดนึงนะคะว่า แต่ถ้าหากว่าเรานับ argument  A4 เข้าไปด้วย แล้วให้ A4 attacks  M5 จะกลายเป็นว่า เรามี prefer semantic = grounded semantic ซึ่งก็คือ  {A1, A2, M5 , A4,  M2, M4, A3 }ค่ะ



แต่พอดีว่า เราอยากให้เห็นกรณีว่า agent (ตัวบุคคล) นั้น ขัดแย้งในตัวเอง เลย ไม่พิจารณา A4 เข้าไปนะคะ


 ถ้าหากว่า เรามาพิจารณาเซตของการให้เหตุผล  จากตัวผู้พูดล่ะคะ (ขอไม่รวม M2,M4,A3 ก่อนนะคะ  เพื่อไม่ให้สับสนตัวบุคคล )
เซตของ argument ของ A จะมี {A1, A2} ซึ่ง conflict free และ attack ทุกการ attack ที่มาจากข้างนอก
ก็เป็น acceptable set  of arguments

แต่ส่วนเซตของ argument ของ M มี { M1, M3, M5 } เป็นเซตที่ ไม่ conflict free เพราะ M5 attack เซตตัวเอง ดังนั้น ไม่ใช่ acceptable set of arguments

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

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

แล้วเราจะสร้างหุ่นที่คิดแบบเป็นเหตุเป็นผลได้ไหมคะ ? 

ขอให้ Happy in May  นะคะ 😊


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

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 กันบ้างแล้วนะคะ :)

โครงสร้าง argument กับ attack : assumption-based argumentation

โพสนี้อยู่ในหมวด เรียนรู้ logic programming + argumentation นะคะ
จากที่โพสก่อนหน้า เราได้สรุปเกี่ยวกับแนวคิดของ abstract argumentation framework ไปแล้ว ซึ่งเป็นไอเดียให้ผู้อ่านพอมองเห็นภาพได้ว่า argumentation คืออะไร ประกอบไปด้วยอะไรบ้าง และเกี่ยวข้องกับงานด้าน reasoning ยังไง

ถ้าย้อนความกลับไปถึงโพสที่แล้ว ก็คงพอจำกันได้นะคะว่า abstract argumentation framework (ขอเรียกย่อๆว่า AA) เนี่ย ประกอบไปด้วย เซตของ argument กับ attack relationship ที่บอกว่า argument ไหน attack argument ไหนบ้าง

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

อย่างจะเห็นจากตัวอย่างในโพสที่แล้วเรื่องขนมเค้กหาย เรากำหนดให้แต่ละ argument เป็นแค่ statement ธรรมดาๆ และก็กำหนดค่า attack relationship ตรงๆ 

แต่ว่าในการทำ reasoning ที่เป็น logic-based เราก็จะมีการนำเอา logical deduction เข้ามาใช้ใช่ไหมคะ ซึ่งตรงนี้ ทำให้เราต้องกำหนดโครงสร้างให้กับ argument และ กำหนดรูปแบบการ attack ด้วย

ดังนั้น ในโพสนี้เรามาดูลูกหลาน หรือพูดง่ายๆคือ instance ของ AA กันบ้างค่ะ อันที่จริงมีงานหลายงานที่ถือได้ว่าเป็น instance ของ AA (และมีอีกหลายงานที่เอา AA ไปใช้ร่วมกับ approach อื่นๆ) แต่เราคงจะขอหยิบ instance of AA มาอธิบายแค่บางตัวนะคะ เอาเฉพาะตัวที่เราได้ศึกษาจริงๆจังๆเท่านั้น ซึ่งผู้อ่านท่านใดที่สนใจสามารถไปศึกษาเพิ่มเติมได้ค่ะ

งั้นวันนี้เรามาเริ่มที่ตัวแรกกันก่อน Assumption-Based Argumentation (ABA) framework  นะคะ ซึ่ง ABA มีแนวคิดที่เข้าใจง่าย แต่มีประสิทธิภาพยิ่งนักว่า "เราจะยอมรับข้อสมมติฐานใดๆได้ ตราบใดที่ยังไม่มีหลักฐานโต้แย้งข้อสมมติฐานนั้นๆ" 

จากประโยคนี้นี่แหละค่ะ เป็นตัวที่บ่งบอกว่าโครงสร้างของ ABA เป็นอย่างไร

นิยามของ ABA ก็มีดังนี้ค่ะ
ถ้าเรากำหนดให้ L เป็น language ใดๆ

1. A เป็นซับเซตของ L ซึ่ง A เป็นเซตของ ข้อสมมติฐาน (A is a set of assumptions)
2. R เป็น inference rules มีซึ่งลักษณะคือ  h ← b1,...,bn เมื่อ b แต่ละตัวสามารถที่จะเป็น ข้อเท็จจริงก็ได้ หรือจะเป็น assumption ก็ได้ค่ะ แต่ว่า h เนี่ยไม่สามารถเป็น assumption ได้ (คือเราไม่สามารถ derive ให้เป็นข้อสรุป assumption  ได้ค่ะ)
3. (total) Mapping function T เป็นฟังก์ชันที่ทำการ map ค่าจาก เซตของ A ไปหา L ซึ่งค่าของ เรนจ์ที่เรา map ไปหาเนี่ย คือ ค่าที่เรากำหนดให้เป็นข้อโต้แย้ง(is a contrary of) ของ assumption นั้นๆนั่นเองค่ะ  ( T: A → L )

สมมติตัวอย่างนะคะ เอาจากตัวอย่างของโพสที่แล้วเรื่องเค้กหายเลยละกัน

ถ้าเรากำหนดให้ inference rules มีกฎดังนี้ (เราจะเขียนเป็นคำอธิบายก่อนนะคะ แล้วจะเขียนกฎในรูปแบบของ first order logic อีกที)

• ถ้าเราไม่อนุญาตให้กินได้ แล้ว เด็กๆ ก็จะไม่กินเค้ก
• ถ้า มีกระดาษเปื้อนเศษเค้กอยู่ในถังขยะ แล้ว ต้องมีคนกินเค้ก

และ ก็มีข้อเท็จจริงว่า

• ทั้งบ้านเรา มีแค่ น้องเปรม ซึ่งเป็นหลานชาย
• เรามีเค้กช็อคโกแลตวางอยู่ในตู้เย็น
• เราไม่ได้อนุญาตให้หลานกินเค้ก

ซึ่งเราจะสามารถเขียนในรูปแบบของ inference rules ได้ดังนี้ค่ะ  (ขอเขียนโดยใช้ first order logic และจะเห็นว่า แต่ละ rule มีตัวแปรอยู่ ดังนั้น แต่ละ rule ก็สามารถที่จะมี instance ของตัวเองได้นะคะ)

R =

• ~ Eat(X, Y) ← not_Get_permission(X), Cake(Y)
• Eat(X,Y) ← Found_in_trash(Y), Nephew(X), Cake(Y)
• Nephew( Prame ) ← 
• Cake( Chocolate_Cake ) ←  
• Found_in_trash( Chocolate_Cake ) ←  

ในที่นี้เรากำหนดให้ not_Get_permission เป็น assumption ค่ะ ซึ่งก็คือ เรามีสมมติฐานอยู่แล้วว่า เราไม่ได้อนุญาตให้ใครกินเค้กในตู้เย็น เพราะฉะนั้น A = {not_Get_permission(X)}

และ ข้อโต้แย้งของ not_Get_permission ก็คือ Get_permission  (ฟังก์ชัน mapping T(not_Get_permission(X) ) = Get_permission(X) )


ตอนนี้เราให้นิยามองค์ประกอบของ ABA ครบแล้วทั้งสามส่วนใช่ไหมคะ
ทวนนิดนึงว่า ABA เนี่ย เราจะสามารถ attack ได้เฉพาะตรง assumption เท่านั้น


ทีนี้เราก็จะมาทำการพิสูจน์กันล่ะว่า หลานได้กินเค้กไปหรือไม่ค่ะ ด้วยการหา semantic จาก argumentation framework based on ABA
อย่างที่บอกว่า ABA เนี่ยเป็น instance ของ AA ดังนั้น semantic ของ AA ก็ต้องถูกถ่ายทอดมาใช้ได้กับ ABA ทุกอย่างเลย

อย่างที่เราได้คุยกันไปแล้วในโพสที่แล้วว่า AA ประกอบด้วย arguments กับ attack relationship ใช่ไหมคะ  ก่อนอื่นเราก็มาสร้าง argument กันก่อนค่ะ

สำหรับการสร้าง argument ใน ABA นี้ ง่ายๆเลยเราก็มองเป็นรูปแบบของ ทรี ก็ได้ค่ะ
โดยเราจะให้ ข้อสรุป หรือ conclusion of argument เนี่ย เป็น root node  แล้วเราก็ทำการสร้างไล่ลงไปเรื่อยๆ ด้วยการเลือก inference rules หรือ assumption ที่สามารถให้ conclusion ของ node ที่เราต้องการได้ ซึ่งเราเรียกกระบวนการนี้ว่า backward deduction

ตัวอย่างเช่น เราจะทำการสร้าง argument ที่มี conclusion ว่า หลานกินเค้กไป (เพราะเราจะเริ่มพิสูจน์ข้อสันนิษฐานว่าหลานกินเค้กไปหรือไม่)  ซึ่งก็จะได้ argument A1 ตามรูปนะคะ

                                            Eat( Prame , Chocolate_Cake )
                                               ____________|___________
                                               |                       |                     |
 Found_in_trash( Chocolate_Cake )   Nephew( Prame )  Cake(Chocolate_Cake)
                      |                                                 |                    |
                     ◻                                               ◻                 ◻

จะเห็นว่าจากรูปทรี (พยายามมองให้เป็นทรีนะคะ ฮ่าๆๆ แบบว่าขี้เกียจไปวาดรูปข้างนอกมาแปะ ) ตรง leaf nodes จะเป็น ข้อเท็จจริงทั้งหมด  (สัญญลักษณ์ ◻ คือ tautology เป็นข้อเท็จจริงนะคะ)

ต่อมา เราจะลองสร้าง argument ที่มี conclusion ว่า หลานไม่ได้กินเค้กไป ก็จะได้ argument A2 ตามรูปค่ะ

                                            ~ Eat( Prame , Chocolate_Cake )
                                           _____________|___________                                           
                                           |                                               |
                  not_Get_permission( Prame)                    Cake(Chocolate_Cake)
                                                                                           |
                                                                                         ◻

ก็จะเห็นว่าจากรูปทรี ตรง leaf nodes เป็นข้อเท็จจริงก็ได้ หรือจะเป็น assumption ก็ได้ค่ะ

ซึ่งทั้งสองกรณีนี้จะถือว่าเป็น argument ที่สมบูรณ์ แต่ถ้าหากว่า leaf node ไม่ใช่ assumption หรือ ข้อเท็จจริงแล้ว จะไม่ถือว่าสร้าง argument เสร็จสมบูรณ์นะคะ

หลังจากสร้าง argument เสร็จแล้ว เรามาดู attack relationship กันบ้างค่ะ ซึ่งใน ABA เนี่ย เราจะมีรูปแบบการ attack เพียงอย่างเดียว คือ เราจะ attack ได้เฉพาะตรง  assumption เท่านั้น  ทีนี้จากตัวอย่างที่เรามีเนี่ย เรามี เซต assumption คือ A = {not_Get_permission(X)}
ซึ่ง จะเห็นว่าใน argument A2 มี assumption อยู่ ดังนั้น attack ที่จะเกิดได้คือเราสามารถ attack A2 ได้  ถ้าเรามีข้อโต้แย้ง ข้อสมมติฐานที่ว่า เราไม่ได้อนุญาตให้ใครกินเค้ก

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

เราก็จะได้ว่า argumentation framework based on ABA  เรียกว่า  AF = (AR, att) ซึ่ง AR = {A1, A2} และ att = empty set 

ดังนั้น ถ้าเราเอาไปหา semantic ของ AF ก็จะได้ว่า grounded extension = prefer extension = stable extension = { A1, A2} คือยอมรับทั้งสองข้อสรุป ว่า  น้องเปรมกินเค้กไป และ น้องเปรมไม่ได้กินเค้กไป


เพื่อให้เห็น attack relationship สมมติว่าเราเพิ่มข้อเท็จจริงไปอีกอย่างนึง ว่า

• แม่อนุญาตให้น้องเปรมกินเค้กได้

เซต inference rules R ก็จะเพิ่มมาอีกหนึ่งกฎค่ะ ว่า

• Get_permission( Prame ) ←

ดังนั้น เราก็จะสามารถสร้าง argument เพิ่มขึ้นมาอีกอันนึงคือ A3 ดังรูป

                                           Get_permission( Prame )
                                                              |
                                                             ◻


ทีนี้ เราก็จะเห็นว่า Get_permission( Prame ) เป็น ข้อโต้แย้ง ของ not_Get_permission( Prame)
ก็จะได้ว่า ฟังก์ชัน T ของเราคือ T(not_Get_permission(Prame)) = Get_permission(Prame)

ดังนั้น ก็จะได้ว่า A3 attacks A2 (คือเดิมที มีสมมติฐานว่า น้องเปรมไม่ได้รับอนุญาตให้กินเค้ก แต่ว่า มีข้อเท็จจริงมาแย้งว่า แม่ได้อนุญาตไปแล้ว )

ดังนั้น  AF ของเราก็จะเปลี่ยนเป็น  AF = (AR, att) ซึ่ง AR = {A1, A2,A3} และ att = {(A3,A2)}

พอเราไปหา semantic ของ AF ก็จะได้ว่า grounded extension = prefer extension = stable extension = { A1, A3} คือได้ข้อสรุป ว่า  น้องเปรมกินเค้กไป ค่ะ

สรุป โพสนี้นะคะ จะเห็นว่านี่เป็นการนำเอา argumentation มาใช้ในงาน reasoning ซึ่งไม่ยากเลยใช่ไหมคะ  สำหรับคนที่จะประยุกต์ใช้เฉยๆ ก็ไม่จำเป็นที่จะต้องเข้าใจ logic programming อย่างละเอียดมาก่อนก็ได้ เพราะถ้า represent ในแบบ ABA เราก็แค่กำหนด inference rule เท่านั้นเอง

ถ้าสังเกตดีๆ ก็จะเห็นว่า ABA มีลักษณะคล้ายคลึงกับ logic programming ค่ะ  เพราะตรง assumption จะคล้ายกับ negation as failure ใน logic programming  (แต่ว่าไม่ได้หมายความว่า มันคือ negation as finite failure นะคะ  เพราะ ABA ไม่ได้กำหนดว่าเป็น negation as finite failure หรือ negation as possibly infinite failure อะไรเลย มันคือ assumption ตราบใดที่หา ข้อโต้แย้งมาไม่ได้ ก็ต้องยอมรับมัน)

จริงๆแล้ว ก็มีหลายเปเปอร์เลยที่เอา ABA ไปใช้ ในงานด้านต่างๆ (ส่วนใหญ่อาจจะพบในงานด้านกฎหมายนะคะ)  สำหรับผู้อ่านท่านใดที่สนใจตัวทฤษฎี สามารถอ่านได้จากเปเปอร์ Assumption-Based Argumentation link  นะคะ

ตัวอย่างที่เรายกมาในบล็อกนี้ เราพยายามเลือกตัวอย่างง่ายๆ ไม่ซับซ้อน เพื่อที่จะได้เข้าใจภาพรวมก่อน ซึ่งเวลาที่เราเอาไป implement กับระบบจริงๆ ก็ย่อมที่จะซับซ้อนมากกว่า ตามโดเมนที่เราเลือก ตัว inference rules หรือ assumption เองก็อาจจะต้องออกแบบแตกต่างออกไป แต่ว่าไอเดียหลักก็ยังคงเหมือนกันค่ะ

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

ขอให้สนุกกับ argumentation นะคะ :)

แนวคิด abstract argumentation โดยสรุป

โพสนี้อยู่ในหมวด เรียนรู้ logic programming + argumentation นะคะ
สำหรับโพสนี้ เราอยากจะเขียนสรุปแนวคิดของ Abstract Argumentation Framework ไว้นะคะ เผื่อว่าใครที่ไปอ่านเปเปอร์ มาแล้วอาจจะรู้สึกว่าอยากหาเพื่อนคุยถกปัญหาหรือความเข้าใจกันจังเลย

หรือสำหรับใครที่เป็นมือใหม่ในงานด้าน reasoning  ก็อาจจะไม่คุ้นเคยกับหลายๆคำศัพท์ หรือหลายๆเรื่องตอนที่อ่าน  ซึ่งตัวเราเองก็เป็นเช่นนั้นเหมือนกัน ในครั้งแรกๆที่อ่านเปเปอร์นี้ เราไม่เคยเรียนหรืออ่านหนังสือเกี่ยวกับ mathematical logic เราก็เลยไม่สามารถจับไอเดียได้เลยค่ะ รู้สึกแต่ว่ายากไม่เข้าใจ  (เราใช้เวลาอ่านนานมากค่ะ แล้วก็หลายรอบมากๆ ตามแบบฉบับเต่าๆของเราเอง >//< )

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

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

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

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

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

เริ่มจาก เราจำได้ว่า เมื่อวานนี้หลานมาเล่นที่บ้าน  => A1: ก็เลยต้องสันนิษฐานว่า หลานกินเค้กไป

แต่ว่าเรารู้ว่าปกติแล้วเด็กๆจะไม่หยิบของกินเองโดยไม่ได้รับอนุญาต => A2: ก็เลยเป็นข้อโต้แย้งความคิดด้านบน
พอดีเราพบว่ามีกระดาษทิชชู่เปื้อนเศษเค้กทิ้งอยู่ในถังขยะในบ้าน => A3: ก็เลยเป็นข้อสนับสนุนว่าเด็กๆต้องกินเค้ก และโต้แย้งความคิดที่ว่าหลานไม่ได้กิน

อย่างนี้เราก็เลยสรุปว่า"หลานกินเค้กไป"

สังเกตุไหมคะว่า เรามีการสร้าง argument ในหัวเราขึ้นมา 3 argument คือ A1,A2,A3 แล้วก็สมมติว่าเรากำหนดให้ A2 attacks A1 , A3 attacks A2 ดังนั้นเราก็เลยสรุปว่า "หลานกินเค้ก"

แล้วถ้าดูลักษณะของ argumentation framework ผู้อ่านรู้สึกคุ้นๆไหมคะ (ถ้าใครเคยอ่านเรื่อง natural deduction มาอาจจะคุ้นเคย) ... ใช่แล้วค่ะ ลักษณะการใช้ argument attack กันนี่คล้ายๆกับแนวทาง prove แล้วก็ disprove ไปเรื่อยๆ คล้ายคลึงกับ natural deduction เลยแต่ว่า argumentation ไม่ได้ลงรายละเอียดของกฎแต่ละข้อเหมือนกับที่ natural deduction มี

ดังนั้น Abstract Argumentation Framework (AA) เนี่ย ไม่ได้กำหนดรายละเอียดไว้ว่า argument จะต้องมีรูปร่างหน้าตาเป็นยังไง สร้างขึ้นมายังไง และก็ไม่ได้บอกว่า attack relation มีลักษณะเป็นยังไง กรณีไหนถึือว่า attack กรณีไหนไม่เรียกว่า attack

เจ้าตัว AA เนี่ยอธิบายการทำ reasoning ในแบบของทฤษฎี argumentation ก่อนให้เข้าใจได้ง่ายๆค่ะ ก็เลยไม่ได้กำหนดรายละเอียดของ argument และ attack relation ไว้ชัดเจน
พูดอีกอย่างก็คือ ผู้ใช้สามารถจะเอา AA ไปใช้ได้ โดยที่ต้องออกแบบรายละเอียดของ argument กับ attack กันเอาเอง (ดังนั้นก็จะพบว่าท้ายเปเปอร์ มีบทที่ใช้ AA อธิบาย semantic ของการทำ reasoning ในแบบอื่นๆเปรียบเทียบด้วย)

ถึงแม้ว่า AA จะไม่ได้บอกว่าต้องออกแบบ argument หรือ attack relation ยังไง แต่ก็บอกเอาไว้อยู่ว่า โอเค เมื่อเรามี argument ( เหตุผล) แล้ว และก็มี attack relation (ความสัมพันธ์ของเหตุผลทั้งหลาย) แล้ว เราก็จะมาดูกันว่า ถ้าอย่างนั้นเราควรจะสรุปอะไรได้ ควรจะเข้าใจอะไรได้บ้าง จาก framework นี้

ก็มาพูดถึงเรื่องของ semantic ค่ะ ซึ่งมันก็คือ meaning หรือความหมายที่เราจะเข้าใจได้ใช่ไหมคะ  แล้วจาก framework นี้เราจะเข้าใจความหมายอะไรได้บ้างล่ะ
ในเมื่อ AA เองถูกออกแบบมาใช้อธิบายการทำ reasoning ในแบบที่ไม่มี intended model ซึ่งก็คือ ตัว AA เองไม่ได้เป็นคนกำหนด ว่าคนจะต้องคิดยังไง ได้ข้อสรุปอะไรจากสิ่งที่มี
แต่ว่า AA อธิบายว่า คนเราเนี่ยจะยอมรับในเหตุผลที่ตัวเองรับได้ ซึ่งก็คือเหตุผลที่ไม่ขัดแย้งกันเองในหัวเรา แล้วก็ defend ความคิดอื่นๆขัดแย้งกับเราได้

ก็เลยมีนิยามอันนึงที่เหมือนกับชื่อเปเปอร์ค่ะ on the acceptability ไงคะ ...
ซึ่งก็บอกไว้ว่า argument หลายๆอันที่เรามีอยู่เนี่ยจะ accept ได้(admissible set of arguments) ถ้า มันไม่ conflict(ขัดแย้ง) กันเอง แล้วมันก็ attack ทุกๆ argument อื่นๆที่พยายาม attack กลุ่มของมัน (อ่านนิยามของ admissible set of arguments ทวนได้นะคะ)

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

ดังนั้นตอนนี้เรารู้ละว่า เซตของ argument ที่เรายอมรับจะต้องมีเงื่อนไขอย่างไร

ต่อมาเราก็มาดูว่า เซตของ admissible arguments ใช้อธิบายอะไรได้บ้าง
เริ่มจากแบ่งคนออกเป็นสองกลุ่มค่ะ คือคนที่ skeptical ไม่เชื่ออะไรง่ายๆ กับคนที่ credulous เลือกเชื่อมากที่สุดเท่าที่จะทำได้ไว้ก่อน

จากตัวอย่างเรื่องขนมเค้ก ไม่ว่าคนที่ skeptical หรือ credulous ก็จะสรุปว่า "หลานกินเค้กไป" ทั้งคู่ เพราะว่าเหตุผล A3 attacks A2 และ A2 attacks A1 โดยที่ไม่มี attack แบบอื่นๆเพิ่มอีก

ทีนี้ถ้าเกิดว่าต่อมา เราพบวันที่หมดอายุบนกล่องเค้กเป็นเมื่อวานพอดิบพอดี
 => A4: แม่อาจจะเอาคิดว่าเค้กหมดอายุแล้วเลยเอาทิ้งก็ได้

ซึ่งตรงนี้ข้อมูลเรามีจะได้ attack relation เพิ่มขึ้นมา คือ A4 attacks A3 และในขณะเดียวกันเอง A3 attacks A4 (เพราะว่า แม่ก็อาจจะให้หลานกินเค้กไปก็ได้)

ดังนั้นตอนนี้เรามี attack relation = {(A2,A1),(A3,A2),(A3,A4),(A4,A3)}
ดังนั้นถ้าเป็นคนที่ skeptical ก็จะไม่สรุปอะไรจากข้อมูลที่มีเลย  (ไม่ยอมรับ argument ใดเลย)
แต่ถ้าเป็น credulous ก็จะเลือกยอมรับเซตของ argument
{A1,A3} ซึ่งสรุปว่าหลานกินเค้กไป หรือ {A2,A4}ซึ่งสรุปได้ว่าหลานไม่ได้กินเค้กไป

เราเรียก เซตของ argument ที่คนที่ skeptical ยอมรับนี้ว่า grounded semantic  หรือ grounded extension
ส่วนเซต argument ที่คนที่เป็นประเภท credulous ยอมรับ จะเรียกว่า prefer semantic หรือ prefer extension

และมีอีก semantic นึงที่สำคัญคือ complete extension ค่ะ ซึ่งนิยามไว้ว่า มันคือเซตของ argument ที่รวมเอาทุก argument ที่มันสามารถ defend ได้มารวมไว้ในเซตของตัวเอง

ทีนี้วิธีการหา grounded extension ทำได้โดยการหาค่า least fix point ของฟังก์ชัน โดยที่เรากำหนดฟังก์ชันคือ F(S) ={A| S defends A}

ส่วนการหา prefer extension ก็หาได้จาก greatest fix point ของฟังก์ชันนั่นเองค่ะ

เพราะว่า complete extension จะสามารถมีได้หลายอันใช่ไหมคะ
อย่างตัวอย่างเรื่องขนมเค้ก
complete extension จะมี 3 เซตคือ
i) empty set
ii) {A1,A3}
iii) {A2,A4}

ดังนั้นเราจะเห็นว่า grounded extension ก็คือ minimal (set inclusion) complete extension ส่วน prefer extension คือ maximal (set inclusion) complete extension ค่ะ
ในตัวอย่างเรื่องขนม grounded extension (minimal complete extension) = empty set
ส่วน prefer extension (maximal complete extension) = {A1,A3} และ {A2,A4}

นอกจากนี้ ก็ยังมีการนำเสนอในแบบของ stable extension (ถ้าใครเคยอ่านเปเปอร์ stable model ก็จะเข้าใจได้นะคะ) ซึ่งก็ถูกนิยามไว้ว่า มันคือเซตของ argument ที่ไม่ขัดแย้งในตัวเอง และ attack arguments อื่นๆทั้งหมดที่อยู่นอกเซตของตัวมัน

ซึ่งจากตัวอย่างเรื่องขนมเค้ก stable extension ก็จะมีสองเซตคือ  {A1,A3} และ {A2,A4} เพราะ เซตว่างนั้นถึงแม้จะไม่ขัดแย้งในตัวเอง แต่มันก็ไม่ attack argument อื่นๆที่อยู่นอกเซตของมันเลย

จบจากเรื่อง semantic แล้วในเปเปอร์ก็ได้ให้นิยามว่ากรณีใด ที่ argumentation framework  จะ coherent บ้าง(ถ้าเรามี prefer extension แต่หา stable extension ไม่ได้ แสดงว่าต้องมีอะไรผิดปกติแน่ๆเลยค่ะ อย่างเช่นมี argument A ซึ่ง A attack ตัวเอง ก็ทำให้หา stable extension ไม่ได้ อย่างนี้ก็ไม่ coherent )

นอกจากนี้ก็ยังมีนิยามว่ากรณีใดที่จะมี grounded semantic ตรงกันกับ prefer และ stable บ้าง (ให้นิยามของ well-founded argumentation framework)

อีกบทที่สำคัญก็คือเปเปอร์ได้แสดงให้เห็นว่า สามารถใช้ argumentation อธิบาย semantic ของการทำ reasoning แบบอื่นๆได้ค่ะ ทั้ง default reasoning และรวมถึง logic programming
และเนื่องจาก logic programming มีวิธีการ implement แล้ว ก็ซึ่งเป็นการแสดงให้เห็นว่าเราสามารถที่จะใช้ logic programming เป็นเครื่องมือในการ implement argumentation ก็ได้เช่นกันค่ะ (คือเรามี abstract argumentation อยู่แล้วก็ใช้อะไรก็ได้เป็นเครื่องมือในการ implement มันค่ะ)

สำหรับรายละเอียดเรื่อง semantic ของ argumentation กับ logic programming นี้เราขอยกยอดไปเล่าในโพสครั้งหน้าละกันนะคะ เพราะรู้สึกว่าโพสนี้จะยาวมากเกินไปแล้ว 😓

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

เรื่อยเปื่อยกับ argumentation

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

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

เรื่องที่อยากจะพร่ำเพ้อวันนี้คือ อะไรคือ argumentation หรือ แล้วมันมีบทบาทยังไงกับงานด้าน AI ล่ะ
.
.
.
.
นั่นสินะ เราเคยเล่าไว้ในโพสก่อนๆว่า มีงานวิจัยด้าน practical reasoning หรือ พูดง่ายๆว่า จะทำการจำลองว่ามนุษย์มีกระบวนการคิดยังไง แล้วไอ้งานวิจัยด้านนี้ มีแนวทางหนึ่งที่เรากำลังศึกษา ก็ชื่อว่า argumentation นั่นเอง ....แล้วเราก็ไม่เคยได้อธิบายแนวคิดที่มาที่ไปของมันเสียที

งั้นวันนี้เรามาพร่ำเพ้อถึงมันกันสักหน่อยดีไหมคะ

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

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

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

ก่อนอื่นของพูดถึงลักษณะของการทำ reasoning ก่อน ว่าจะมีอยู่ 2 ลักษณะใหญ่ๆ คือ monotonic reasoning กับ non- monotonic reasoning
เรามาลองทำความเข้าใจจากตัวอย่างกันดีกว่านะคะ

ยกตัวอย่างให้เห็นภาพ เช่น เราบอกว่าถ้าฝนตก แล้วเสื้อผ้าจะเปียก
แล้วเรามีข้อเท็จจริงอยู่ว่า ฝนตก แน่นอนว่า เราจะสรุปได้ว่า เสื้อผ้าเปียก
เมื่อเพิ่มข้อเท็จจริงใหม่เข้าไปว่า ฝนตก + ฉันเดินเล่น ก็ยังคงสรุปได้ว่า เสื้อผ้าเปียกถูกไหมคะ
อย่างนี้คือ monotonic reasoning

เพราะว่า monotonic reasoning นิยามไว้ว่า ถ้าเซต P  สามารถให้ข้อสรุป Q ได้แล้ว แล้วเอา เซต PU{a} ก็ต้องยังคงข้อสรุป Q ได้เหมือนเดิม พูดง่ายๆก็คือ ต่อให้ข้อมูลเพิ่มขึ้นแค่ไหน เราก็ยังควรจะสรุปข้อสรุปเดิมได้

แต่ถ้า เราเพิ่มข้อเท็จจริงไปว่า ฝนตก + ฉันเดินเล่น + ฉันเดินกางร่ม อย่างนี้แล้ว เราจะไม่สามารถสรุปว่า เสื้อผ้าเปียกได้ ก็จะเห็นว่าจริงๆแล้ว practical reasoning เป็น non-monotonic reasoning ค่ะ เพราะว่าในโลกของความจริงแล้วบางครั้งพอข้อเท็จจริงเพิ่มขึ้น ข้อสรุปเดิมก็เปลี่ยนเป็นข้อสรุปใหม่ใช่ไหมคะ


ทีนี้เรามาดู แนวทางต่างๆ ที่ใช้ในการทำ reasoning ก็มีแนวทางมีคนนำเสนอแนวคิดมากมายเลยค่ะ แรกเริ่มเดิมทีก็มี classical logic ใช่ไหมคะ ซึ่งมันมีลักษณะแค่อย่างเดียวคือ monotonic reasoning  ดังนั้นเราจะใช้แค่ classical logic มาทำการจำลองการทำ practical reasoning/ human reasoning ก็ไม่ได้


ดังนั้นเราก็ต้องมองหาแนวทางอื่นๆ ที่มีลักษณะของ non-monotonic reasoning ร่วมด้วย ซึ่งก็มีคนนำเสนอแนวทางไว้เยอะแยะมากมายเลยค่ะ แต่ที่เราจะคุยกันวันนี้คือ แนวทางที่ชื่อว่า argumentation

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

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

ทีนี้มาดูกันว่า แล้วไอเดียหลักที่อยู่บนแนวคิดของargumentation คืออะไร

ก็ลองมองไปที่ human reasoning เลยค่ะว่า ถ้าเราจะโมเดลการคิดของคนแบบตัวอย่างข้างต้น ที่จะเห็นว่า มันเป็น  non-monotonic reasoning เนี่ย จะทำยังไง
ถ้าเราใช้ classical logic ก็ไม่ตอบโจทย์ใช่ไหมคะ เพราะ classical logic มีลักษณะเป็น  monotonic

(จากนี้จะอธิบายไอเดียของ abstract argumentation  นะคะ คือเป็นคอนเซปที่กว้างที่สุดแล้ว)
ทีนี้ argumentation ก็ตอบโจทย์ตรงที่ว่า โอเค เราไม่ต้องสนใจนะว่า คนเราควรจะคิดให้คำตอบยังไง ไม่เหมือนหลักใน classical logic ที่ว่า ถ้ามีข้อเท็จจริงนี้แล้ว ควรจะคิดแบบนี้  ควรจะได้ข้อสรุปนี้ พูดง่ายๆคือ ไม่มี intended model ที่แน่นอนเพียงอันเดียว (intended model เป็นความอุดมคติตามหลักการเหตุผลว่า ควรจะต้องคิดแบบนี้ ตอบแบบนี้ )

งั้นแล้ว ข้อสรุปที่ควรจะได้ล่ะจะเอามาจากไหน ถ้าเราไม่มี intended model ที่แน่นอน

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

ดังนั้น framework ของ argumentation ก็มีแค่ argument ที่แต่ละคนยกขึ้นมา กับ attack relation ก็คือดูว่า  argument อันไหน attack อันไหนบ้าง

สุดท้ายแล้วเราก็จะได้ว่า  argument ใดบ้างที่ยอมรับได้ ก็กลายเป็นข้อสรุปไป

ยกตัวอย่างเช่น

นาย ก บอกว่า A1:  "นกบินได้ และ เพนกวินเป็นนก ดังนั้น เพนกวินบินได้"
นาย ข บอกว่า A2:  "แต่ว่า เพนกวินบินไม่ได้"

เราจะเห็นว่า argument A1 ของนาย ก แพ้ให้กับ A2 ของนาย ข (คือนาย ก ไม่มีอะไรจะเถียงต่ออีกแล้ว ก็แพ้ไปใช่ไหมคะ) ดังนั้น การถกเถียงกันครั้งนี้ argumentation framework เรามีแค่ 2 arguments และ attack relationship ก็คือ A2 attacks A1 ก็จะได้ว่า A2 เป็น arguments ที่ยอมรับได้
เมื่อเรายอมรับ A2 ก็ถือว่าข้อสรุปคือ เพนกวินบินไม่ได้

จะเห็นว่าพอโมเดลด้วยไอเดียนี้แล้ว ทำให้การทำ reasoning จำลองการคิดแบบมีเหตุผลดูง่ายขึ้นไหมคะ

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

นอกจากนี้ในเปเปอร์ ก็โชว์ให้เห็นว่า semantic ของ  argumentation นั้นตรงกันกับ semantic หลายๆแบบใน  approach อื่นๆที่เสนอแนวทางการพัฒนา non-monotonic reasoning ด้วย ไม่ว่าจะเป็น well-founded semantic, stable model, etc.

ที่สำคัญ ก็โชว์ให้เห็นว่าตรงกับ semantic ของ logic programming ซึ่งเป็นการบอกว่า argumentation ไม่ใช่แค่ไอเดียต่อไปแล้วนะ ถ้าอยากจะ implement ณ ตอนนี้เราก็มีเครื่องมือที่สามารถจะ implement มันได้แล้ว ซึ่งก็คือ logic programming นั่นเองค่ะ

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

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

แนวทางศึกษา Logic Programming & Argumentation

กลับมาทำตามสัญญาก่อนปีใหม่ที่จะต้องเขียนบล็อกเกี่ยวกับความรู้เรื่อง Logic Programming + Argumentation ตอนแรกตั้งใจว่าจะให้ตัวเองศึกษาให้จบเรียบร้อยก่อน แล้วจะได้ค่อยๆอธิบายไปตามลำดับ แต่ดูเหมือนว่าเราจะยุ่งกับการเรียนและมีอะไรหลายๆอย่างเกิดขึ้นจนไม่ได้เขียนตามที่คาดหวังไว้

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

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

ซึ่งข้อดีก็คือสำหรับผู้อ่านที่สนใจศึกษา logic programming และ argumentation จะได้ศึกษาไปพร้อมๆกันกับเราเองด้วย และเราเองก็จะได้อัพเดทบล็อกโดยใช้เวลาไม่มากได้ ซึ่งจะดีกว่าที่เราจะต้องรอให้ตัวเองพร้อมแล้วค่อยมาเรียบเรียงเนื้อหาจากต้นจนจบ เหมือนกับการเขียนหนังสือ ซึ่งจะทำให้เราเองก็จะไม่พร้อมสักที ถ้าท่านใดที่สนใจหลงเข้ามาอ่าน ^ ^ หวังว่าคงเข้าใจเจตนาของเรานะคะ และถ้ามีคำถามอะไรสงสัย ยินดีที่ช่วยตอบค่ะ แต่ขอบอกก่อนเลยนะคะว่าเราเองก็มือใหม่เหมือนกัน :)

ดังนั้นขอให้โพสนี้เป็นที่รวมบล็อกของเราไล่ลำดับเนื้อหาเกี่ยวกับ logic programming และ argumentation ละกันนะคะ

1. หนังสือแนะนำ อ่านได้ ที่นี่ ค่ะ
2. เปเปอร์เกี่ยวกับ Argumentation ที่นี่
3. โพสเรื่อง Mathematical Logic + Natural Deduction ที่ลิงก์นี้
• พื้นฐาน
• ต่อ
• สรุป 
4. โพสเรื่อง Logic Programming 
• Complete Lattice & Fixpoint Theory
5. โพสเรื่อง Argumentation
• Introduction
• Abstract Argumentation Framework
• Assumption Based Argumentation Framework 

โพสเก็บตก

• Symbolic logic and Classical logic ต่างกันยังไง
• Closure and Consistency คืออะไร

แนะนำเปเปอร์ เกี่ยวกับ Argumentation

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

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

สำหรับคนที่ไม่รู้เลยว่า Argumentation คืออะไร มีความสำคัญยังไงใน Reasoning System ควรจะเริ่มอ่านเปเปอร์แรกสุดก่อนเลย คือ

Phan Minh Dung: On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games. Artificial Intelligence, 77(2), pp. 321-357, 1995

หลังจากอ่านเปเปอร์หลักเพื่อเข้าใจ abstract argumentation theory แล้วก็จะมีเปเปอร์ที่เป็น instance ของ argumentation ได้แก่ assumption based argumentation และ structured argumentation with priorities ดังนี้ค่ะ

Phan Minh Dung, Robert A. Kowalski, and Francesca Toni: Assumption-based Argumentation, Argumentation in AI, I. Rahwan and G. Simari (Eds.), 199-218, Springer 2009.

Phan Minh Dung: An axiomatic analysis of structured argumentation with priorities, Artificial Intelligence, Elsevier, 2016
(อยากแนะนำให้อ่านเวอร์ชันเต็มมากกว่าค่ะ ซึ่งเป็นเปเปอร์ล่าสุดของสิ้นปี 2017  อันนี้ เพราะเปเปอร์นี้จะแนะนำว่า properties ของ attack relation ควรจะมีอะไรบ้างอย่างไร)

และมีอีกอันที่เป็น instance ของ argumentation คือ probabilistic argumentation

Phan Minh Dung, Phan Minh Thang: Towards Probabilistic Argumentation for Jury-based Dispute Resolution, COMMA10, Third International Conference on Computational Models of Argument, Desenzano del Garda, Italy, 8-10 September, 2010.

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

Phan Minh Dung, Giovanni Sartor: The modular logic of private international law, Artif. Intell. Law 19(2-3): 233-261 (2011), Springer Verlag.

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