ทำความเข้าใจ (Information) Entropy

credit: https://medium.com/@tejpal.abhyuday/information-theory-explained-for-machine-learning-a1bd8e7cd242

[คำถาม] โปรแกรมเมอร์ที่กำลังแบ๊คอัพข้อมูลอันสำคัญในไดรฟ์ของเขา และ ผีพนันที่พยายามทายผลบอลนัดที่กำลังจะเกิดขึ้น มีอะไรเหมือนกัน??

คนหนึ่งอาจจะพูดถึงเรื่อง:

เราต้องการพื้นที่น้อยที่สุดเท่าไรเพื่อจะเก็บข้อมูลหนังลับๆทั้งหมดของเขา?

ในขณะที่อีกคนอาจจะถามว่า:

เราจะเหวอแค่ไหน ถ้าแมนยูจะเป็นแชมป์ในพรีเมียร์ลีกขึ้นมาจริงๆ?

เชื่อไหมว่า สองคำถามนี้ที่ดูเหมือนจะเดินขนานกัน แท้จริงแล้วมันคือการถามหาตัวเลขตัวเดียวกันในทางคณิตศาสตร์ และเจ้าตัวเลขนั้นคือสิ่งที่เราเรียกว่า “Information Entropy”

Information Entropy คืออะไร?

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

และในทาง Computer Science ก็มีการหยิบยืมคำว่า Entropy มาเช่นกัน โดย Claude Shannon ในช่วงปี 1940s ซึ่งต่อมาพัฒนาไปสู่ Information theory

หากอ้างอิงจาก Wikipedia จะพบว่าใน 2 ประโยคแรก กลับมีการพูดถึง Entropy ในรูปแบบที่แตกต่างกัน

ในส่วนแรก พูดถึง Entropy ในความหมายของ [the average level of uncertainty] หรือ ค่าเฉลี่ยของระดับของความไม่แน่นอน ////เอิ่มมมมม ยิ่งอ่านก็ยิ่งงง

[T]he entropy of a random variable quantifies the average level of uncertainty or information associated with the variable’s potential states or possible outcomes.

ในส่วนที่ 2 กลับพูดถึง Entropy ในความหมายของ [the expected amount of information needed to describe the state] หรือ จำนวนข้อมูลที่ต้องการสำหรับใช้อธิบายข้อมูล ////อ๊าาาาาากกกกกกก มันคืออะไร????

[The entropy] measures the expected amount of information needed to describe the state of the variable, considering the distribution of probabilities across all potential states.

แล้วนิยามไหน คือ นิยามที่ถูกต้องของ Entropy และ Entropy มันคืออะไรกันแน่!! สำหรับคนที่ชอบ SPOIL: ผมขอเฉลยสั้นๆตรงนี้เลยว่า นิยามทั้ง 2 นิยาม เป็นนิยามที่ถูกต้องทั้งคู่ แต่มองในมุมมองที่แตกต่างกัน

จากมุมมอง Data Communication

ผมขออนุญาตนอกเรื่อง และ ถามคำถามใหม่กับทุกๆคนว่า

ถ้าในโลกนี้ สามารถแยกชนชั้นของแมวได้เป็นแค่ 4 ประเภท คือ

แมวสลิด
แมวดำ
แมวขาว
และ นังแมวส้ม

และ ผมบอกว่า ที่บ้านผมมีแมว 1 ตัว และผมจะตอบตามความเป็นจริงเสมอ แต่สามารถตอบได้แค่ จริง หรือ ไม่จริง เท่านั้น

[คำถาม] โดยเฉลี่ยแล้ว คุณจะต้องถามกี่ครั้ง ถึงจะทราบว่า แมวของผมเป็นชนชั้นอะไร?

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

[วิธีการถามแบบที่ 1]

ถ้าเราใช้วิธีการถามแบบง่ายๆ โดยการไล่ถามไปทีละชนชั้นไปเรื่อยๆ ประมาณนี้

Q1: แมวคุณเป็นแมวสลิดใช่หรือไม่? ถ้าใช่ ตอบ แมวสลิด ถ้าไม่ใช่ ไป Q2

Q2: แมวคุณเป็นแมวดำใช่หรือไม่? ถ้าใช่ ตอบ แมวดำ ถ้าไม่ใช่ ไป Q3

Q3: แมวคุณเป็นแมวขาวใช่หรือไม่? ถ้าใช่ ตอบ แมวขาว ถ้าไม่ใช่ ตอบ นังแมวส้ม

ถ้าถามแบบนี้ จะได้ว่า

ถ้าผมมีแมวสลิด => ถาม 1 คร้ัง

ถ้าผมมีแมวดำ => ถาม 2 คร้ัง

ถ้าผมมีแมวขาว => ถาม 3 คร้ัง

ถ้าผมมีนังแมวส้ม => ถาม 3 คร้ัง

นั้นคือ โดยเฉลี่ยแล้ว ผมจะโดยถามประมาณ 2.25 ครั้ง

[วิธีการถามแบบที่ 2]

คราวนี้ ลองเปลี่ยนรูปแบบของการถามเป็นรูปแบบที่ซับซ้อนมากกว่าเดิมอีกนิดนึง ดังนี้

Q1: แมวคุณเป็นแมวสลิดหรือแมวดำใช่หรือไม่? ถ้าใช่ ไป Q2 ถ้าไม่ใช่ ไป Q3

Q2: แมวคุณเป็นแมวสลิดใช่หรือไม่? ถ้าใช่ ตอบ แมวสลิด ถ้าไม่ใช่ ตอบ แมวดำ

Q3: แมวคุณเป็นแมวขาวใช่หรือไม่? ถ้าใช่ ตอบ แมวขาว ถ้าไม่ใช่ ตอบ นังแมวส้ม

คิดแบบเดิม ถ้าถามแบบนี้ จะได้ว่า

ถ้าผมมีแมวสลิด => ถาม 2 คร้ัง

ถ้าผมมีแมวดำ => ถาม 2 คร้ัง

ถ้าผมมีแมวขาว => ถาม 2 คร้ัง

ถ้าผมมีนังแมวส้ม => ถาม 2 คร้ัง

นั้นคือ โดยเฉลี่ยแล้ว ผมจะโดยถามประมาณ 2 ครั้ง //เอ๊ย มันน้อยกว่าเดิม

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

คราวนี้ ถ้าลองแก้ไขโจทย์เพิ่มเติม จาก 4 ชนชั้น เป็นแมว 8 ชนชั้น จะได้จำนวนคำถามเฉลี่ยดังนี้

[วิธีการถามแบบที่ 1] = (1+2+3+…+8+8)/8 =4.375

[วิธีการถามแบบที่ 2] = 3

//Challange#1: ลองคิดด้วยตัวเองต่อว่าทำไม [คำตอบแบบที่ 2] = 3 นะ ???

จะเห็นได้ว่า [คำตอบแบบที่ 2]ใช้จำนวนคำถามน้อยกว่ามากๆ ซึ่งถ้าให้จำนวนชนชั้นของแมว แทนด้วย N

ถ้าให้ N = 16 ก็พอเดาได้ว่า จำนวนคำถามที่ต้องถามโดยเฉลี่ย = 4

ถ้าให้ N = 32 ก็พอเดาได้ว่า จำนวนคำถามที่ต้องถามโดยเฉลี่ย = 5

ถ้าให้ N = 50 ?? จำนวนคำถามที่ต้องถามโดยเฉลี่ย = log2(50) ≈ 5.64

เราจึงพออนุมาณได้ว่า “จำนวนคำถามที่ต้องถามโดยเฉลี่ย สำหรับข้อมูล N ประเภท เท่ากับ log₂(N) นั้น”

หรือ ตีความอีกแบบได้ว่า “จำนวนข้อมูลที่ต้องใช้สำหรับแยกของ N ประเภทออกจากกัน โดยใช้วิธี Binary Tree เท่ากับ log₂(N)”

//เริ่มเห็นความเชื่อมโยงกับ Entropy ขึ้นมานิดๆละ แต่มันยังไม่สิ้นสุดที่จุดๆนี้

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

แมวสลิด => 100%
แมวดำ => 0%
แมวขาว => 0%
และ นังแมวส้ม => 0%

ย้อนมาถามคำถามเดิม

เราสามารถตอบได้ง่ายๆ โดยไม่ต้องถามเลย เลยว่า แมวของผมต้องเป็น “แมวสลิด” อย่างแน่นอน ถึงแม้ว่าจะมีคำตอบที่เป็นไปได้มากถึง 4 แบบ

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

ลองพิจารณาให้จำนวนแมวในแต่ละชนชั้น ในกรณีต่อไปนี้

แมวสลิด => 25%
แมวดำ => 12.5%
แมวขาว => 50%
และ นังแมวส้ม => 12.5%

ถ้าเราออกแบบวิธีการถามดังนี้ (แบบเดียวกับ [วิธีการถามแบบที่ 1]ก่อนหน้านี้)

Q1: แมวคุณเป็นแมวสลิดใช่หรือไม่? ถ้าใช่ ตอบ แมวสลิด ถ้าไม่ใช่ ไป Q2

Q2: แมวคุณเป็นแมวดำใช่หรือไม่? ถ้าใช่ ตอบ แมวดำ ถ้าไม่ใช่ ไป Q3

Q3: แมวคุณเป็นแมวขาวใช่หรือไม่? ถ้าใช่ ตอบ แมวขาว ถ้าไม่ใช่ ตอบ นังแมวส้ม

คิดแบบเดิม

ถ้าผมมีแมวสลิด => ถาม 1 คร้ัง แต่มีโอกาสเกิดขึ้น 25% = 1*0.25 = 0.5

ถ้าผมมีแมวดำ => ถาม 2 คร้ัง แต่มีโอกาสเกิดขึ้น 12.5% = 2*0.125 = 0.25

ถ้าผมมีแมวขาว => ถาม 3 คร้ัง แต่มีโอกาสเกิดขึ้น 50% = 3*0.50 = 1.5

ถ้าผมมีนังแมวส้ม => ถาม 3 คร้ัง แต่มีโอกาสเกิดขึ้น 12.5% = 3*0.125 = 0.375

จำนวนคำถามเฉลี่ย = 0.5 + 0.25 + 1.5 + 0.375 = 2.625 ครั้ง

เทียบจากของเดิม 2.25 ครั้ง จะเห็นว่า ถ้าพิจารณา โอกาศที่จะพบรูปแบบต่างๆของแมวไปด้วย เราพบว่า จำนวนคำถามที่เราต้องถามจริงๆ เพิ่มไปเป็น 2.625 ครั้ง

งั้นลองคิดวิธีการถามแบบใหม่อีกครั้ง คราวนี้ เราจะเรียงลำดับตามสัดส่วนของแมวในชนชั้นนั้นๆบ้าง

[วิธีการถามแบบที่ 3]

Q1: แมวคุณเป็นแมวขาวใช่หรือไม่? ถ้าใช่ ตอบ แมวขาว ถ้าไม่ใช่ ไป Q2

Q2: แมวคุณเป็นแมวสลิดใช่หรือไม่? ถ้าใช่ ตอบ แมวสลิด ถ้าไม่ใช่ ไป Q3

Q3: แมวคุณเป็นแมวดำใช่หรือไม่? ถ้าใช่ ตอบ แมวดำ ถ้าไม่ใช่ ตอบ นังแมวส้ม

คิดแบบเดิม

ถ้าผมมีแมวสลิด => ถาม 2 คร้ัง แต่มีโอกาสเกิดขึ้น 25% = 2*0.25 = 0.5

ถ้าผมมีแมวดำ => ถาม 3 คร้ัง แต่มีโอกาสเกิดขึ้น 12.5% = 3*0.125 = 0.375

ถ้าผมมีแมวขาว => ถาม 1 คร้ัง แต่มีโอกาสเกิดขึ้น 50% = 1*0.50 = 0.5

ถ้าผมมีนังแมวส้ม => ถาม 3 คร้ัง แต่มีโอกาสเกิดขึ้น 12.5% = 3*0.125 = 0.375

จำนวนคำถามเฉลี่ย = 0.5 + 0.375 + 0.5 + 0.375 = 1.75 ครั้ง

จะเห็นว่า แค่เรียงลำดับการถาม ก็สามารถลดจำนวนคำถามที่เราต้องถาม เหลือแค่ 1.75 ครั้ง เท่านั้นเอง

คำถามที่น่าสนใจต่อมา คือ วิธีการถามแบบนี้ เป็นวิธีที่ดีที่สุดรึยัง??

และคำตอบก็คือ ถูกกกกกต้องนะคร๊าบ

//แต่ขอเว้นไว้เป็นการบ้านว่า จะรู้ได้ยังไงว่าวิธีนี้เป็นวิธีที่ดีที่สุด???

แต่ถ้าเราเชื่อว่า 1.75 เป็นวิธีที่น้อยที่สุดจริงๆ จะได้ว่าเจ้าเลข 1.75 ที่ว่านี้แหละ คือ Information Entropy ของข้อมูลชุดนี้ (ตามตัวอย่าง คือ ข้อมูลชนชั้นแมว)

หรือ พูดอีกอย่างได้ว่า

Information Entropy คือ จำนวนข้อมูลที่น้อยที่สุดที่ใช้ในการแยกประเภทของตัวแปรหนึ่งๆ (ลองเทียบกับ นิยามจาก Wikipedia อีกครั้ง)

[The entropy] measures the expected amount of information needed to describe the state of the variable, considering the distribution of probabilities across all potential states.

จำนวนข้อมูลที่ว่า ก็คือ จำนวนคำถามที่ต้องใช้เพื่อแยกข้อมูลนั้นๆ ซึ่งในความเป็นจริง คือ จำนวน 0/1 ที่คอมพิวเตอร์ต้องใช้ หรือ bits

และ วิธีการถาม แบบต่างๆ ก็คือ รูปแบบต่างๆในการแทนข้อมูลแต่ละประเภท

ถ้าอ้างอิง [วิธีการถามแบบที่ 1] จะเสมือนกับการแทนด้วย bits

แมวสลิด => ถาม 1 คร้ัง แทนด้วย bitcode: 0

แมวดำ => ถาม 2 คร้ัง แทนด้วย bitcode: 10

แมวขาว => ถาม 3 คร้ัง แทนด้วย bitcode: 110

นังแมวส้ม => ถาม 3 คร้ัง แทนด้วย bitcode: 111

สำหรับ [วิธีการถามแบบที่ 2]

แมวสลิด => ถาม 2 คร้ัง แทนด้วย bitcode: 00

แมวดำ => ถาม 2 คร้ัง แทนด้วย bitcode: 01

แมวขาว => ถาม 2 คร้ัง แทนด้วย bitcode: 10

นังแมวส้ม => ถาม 2 คร้ัง แทนด้วย bitcode: 11

นั้นคือ การหา Information Entropy คือ การหาจำนวนคำถามที่ต้องใช้เพื่อแยกข้อมูลนั้นๆ โดยใช้ coding ที่ดีที่สุดสำหรับข้อมูลนั้นๆ

ซึ่งจะไปเชื่อมโยงกับ Huffman coding ซึ่งเป็น algorithm ที่หาวิธีการถาม หรือ coding ที่ดีที่สุด (But, optimal only among methods encoding symbols separately)

===================

แล้วเราจะคำนวน Information Entropy ได้ยังไงละ ???

ถ้าลองย้อนกลับไปดูตัวอย่างด้านบนอีกครั้ง จะเห็นคำใบ้บางอย่าง

Entropy เกี่ยวข้องกับ จำนวนประเภทของข้อมูล [N]
Entropy เกี่ยวข้องกับ ความน่าจะเป็นที่จะเจอข้อมูลแต่ละประเภท [p(N)]
Entropy = log₂(N) ในกรณีที่ ถ้าข้อมูลแต่ละประเภท มีโอกาศเจอเท่าๆกัน
Entropy = 0 ในกรณีที่ ถ้าข้อมูลอันใดอันหนึ่ง มี p(x) = 1
Entropy คือ ผลรวมเฉลี่ยของจำนวน bits ที่ต้องใช้สำหรับแทนข้อมูลแต่ละประเภท

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

//ในกรณีตัวอย่าง X = {แมวสลิด, แมวดำ, แมวขาว, นังแมวส้ม}

\[\text{Entropy} = H(X) = \sum_{x \in X} p(x)I(x)\]

และ ถ้าแทนจากคำใบ้ในข้อ 3 จะได้ว่า

\[log_2(N) = \sum_{i=1}^{N} \frac{1}{N} I(x_i)\]

หาพิจารณาเฉพาะในกรณีที่ ข้อมูลแต่ละประเภทมีโอกาศเจอเท่าๆกัน แปลว่า ข้อมูลแต่ละประเภทต่างเหมือนๆกันทั้งหมด I(xᵢ) และ I(xⱼ) ใดๆ จะต้องเท่ากัน ก็จะแก้สมการได้ว่า I(x) = log₂(N)

และ ถ้าเอาไปตรวจสอบกับกรณีทั่วๆไปที่ ข้อมูลแต่ละประเภทมีโอกาศเจอแตกต่างกัน จะพอเดาๆได้ว่า I(x) ในรูปแบบทั่วไป ควรจะเป็น

\[\begin{array}{rcl} I(x) & = & -log_2 p(x) \\\\ H(X) & = & \sum_{x \in X} p(x)I(x) \\\\ & = & -\sum_{x \in X} p(x)log_2 p(x) \end{array}\]

โดยจะเรียก I(x) มีชื่อเป็นทางการว่า “self-information” ของข้อมูลประเภท x

หากใครที่สนใจหา proof จริงๆว่า ทำไม I(x) ถึงต้องเป็น -log₂(p(x)) สามารถไปดู proof เต็มๆได้ตามลิงค์นี้เลยฮะ: C. Shannon (1948)

ดังนั้นจากมุมมองของ Data Communication จะเห็นว่า Entropy หรือ H(X) คือ จำนวนบิตที่น้อยที่สุดที่จำเป็นต้องแทนข้อมูล X ใดๆ

โดยที่ ข้อมูลประเภท x ∈ X จะต้องแทนด้วย I(x) = -log₂(p(x)) บิต

ซึ่ง C. Shannon พิสูจน์ว่า มันคือจำนวนบิตที่น้อยที่สุดจริงๆนะ สำหรับข้อมูลใดๆ

ยกตัวอย่าง ข้อมูลที่จะสื่อสารเป็นข้อความภาษาใดๆ

จะได้ว่า X = อักรขระที่เป็นไปได้ทั้งหมดของภาษานั้นๆ เช่น X = {a, b, c, …, z} สำหรับภาษาอังกฤษ

ถ้าจะสื่อสารให้ได้ประสิทธิภาพมากที่สุด ตัวอักษรแต่ละตัว จะต้องแทนด้วย coding ที่มีจำนวนบิต = I(x) = -log₂(p(x)) นั้นเอง

นั้นคือ ตัวอักษรที่เจอบ่อยๆ ควรจะแทนด้วยจำนวนบิตน้อยๆ กลับกัน ตัวอักษรที่นานๆเจอ สามารถแทนด้วยจำนวนบิตมากๆได้

ซึ่งมีงานวิจัยประมาณว่า ถ้ามองว่า X เป็น เซตของอัขระภาษาอังกฤษ 26 ตัว สามารถประมาณ H(X) ≈ 4.0 - 4.2 bits (แปลว่า โดยรวมๆแล้ว เราสามารถแทนตัวอักษรภาษาอังกฤษทั้งหมดด้วย 4 – 5 bits เท่านั้น!!)

Entropy ในมุมมองนี้ สามารถต่อยอดไปใช้ในส่วนของ Data Communication เพื่อหาวิธีการที่มีประสิทธิภาพที่สุดในการส่งข้อมูล — finding the maximum rate at which information can be reliably transmitted through a noisy channel.

และก็ยังนำไปสู่แนวคิดของการบีบอัดข้อมูล — finding the theoretical limit on how much a file can be shrunk without losing information.

จากมุมมอง Data Uncertainty

//ยังไม่หมดอีกเหรอ ?? Entropy ยังสามารถตีความแบบอื่นได้อีกเหรอ??

คราวนี้ เรามามอง Entropy จากฝั่งของ Statistics กันบ้าง

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

แต่ถ้าผมบอกคุณว่า “เลขท้าย 2 ตัวงวดนี้จะออกเลข 42” หลายๆคนคงจะตื่นเต้นกับข้อมูลนี้ไม่มากก็น้อย (สมมติว่ามันเป็นจริง)

ทำไมข้อมูลสองชุดนี้ถึงมีค่าไม่เท่ากัน? ทำไมประโยคหลังกลับมี “มูลค่า” มากกว่าประโยคแรก ทั้งๆที่มันก็เป็นประโยคบอกเล่าเหมือนกัน

ซึ่งไอ้เจ้า “มูลค่า” ที่ว่า มันสามารถเรียกอีกอย่างได้ว่า มันคือ “ความเซอร์ไพรส์” เมื่อเราเจอเหตุการณ์นั้นๆ ซึ่งในที่นี้ ผมจะขอแทนมันด้วย S(E)

โดย E คือ เหตุการณ์ใดๆที่เราสนใจ และ S(E) คือ ความเซอร์ไพรส์ เมื่อเหตุการณ์นั้นๆเกิดขึ้น

ข้อสังเกตุที่ 1 คือ ความเซอร์ไพรส์ ของ E ใดๆ ต้องเป็น function ของ ความเป็นไปได้ที่จะเกิดเหตุการณ์ E

\[S(X) = f(p(E))\]

โดย p(E) คือ ความเป็นไปได้ที่จะเกิดเหตุการณ์ E

แปลว่า สำหรับเหตุการณ์ที่เกิดขึ้นเป็นประจำทุกเช้าวัน = เราก็ควรจะไม่ Surprise นั้น คือ ถ้า p(E) → 1 จะต้องให้ S(E) → 0

และ สำหรับเหตุการณ์ที่นานนนนนนนนๆเกิดขึ้นสักครั้ง = เราก็ควรจะ Surprise มากๆ นั้น คือ ถ้า p(E) → 0 จะต้องให้ S(E) → ∞

ข้อสังเกตุที่ 2 คือ ความเซอร์ไพรส์ของเหตุการณ์ที่เป็นเกิดจากการรวมกันของ 2 เหตุการณ์ E = E₁+E₂ ต้องเท่ากับ ผลรวมของความเซอร์ไพรส์ของเหตุการณ์ย่อยๆ

แต่ แต่ แต่ ความน่าจะเป็นของ E จะเท่ากับ ผลคูณระหว่างความน่าจะเป็นของเหตุการณ์ ย่อยๆ นั้น คือ p(E) = p(E₁)p(E₂) จะได้ว่า

\[\begin{array}{rcl} S(E_1 + S_2) & = & S(E_1) + S(E_2) \\ & = & f(p(E_1+E_2)) \\\\ f(p(E_1)\cdot p(E_2)) & = & f(p(E_1)) + f(p(E_2)) \end{array}\]

ซึ่ง ฟังก์ชั่น f ที่มีคุณสมบัติตามนี้ มีได้แค่รูปแบบเดียว นั้นคือ f = -logarithm (อ้างอิงจาก C. Shannon (1948))

ดังนั้น เราจึงสรุปได้ว่า เราสามารถแทนค่า ความเซอร์ไพรส์ของเหตุการณ์หนึ่งได้ด้วยสมการว่า

\[S(E) = -log(p(E))\]

หรือดูได้จากกราฟ

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

ซึ่งตรงตาม นิยามจาก Wikipedia ที่เคยแปะไว้ก่อนหน้านี้

[T]he entropy of a random variable quantifies the average level of uncertainty or information associated with the variable’s potential states or possible outcomes.

เพื่อตรวจสอบความถูกต้องของสมการ

ลองมาจำลองสถาณการณ์ง่ายๆกัน ถ้าเรามีเหรียญ 1 เหรียญ ซึ่งสามารถทอยออกมาได้ Head ด้วยความน่าจะเป็น p และ Tail ด้วยความน่าจะเป็น 1-p

เราจะสามารถคำนวน Entropy ของระบบนี้ได้ว่า

\[\begin{array}{rcl} H({\text{Head}, \text{Tail}}) & = & p \cdot S(\text{Head})+ (1-p) \cdot S(\text{Tail}) \\\\ & = & p \cdot log_2(\frac{1}{p}) + (1-p) \cdot log_2\frac{1}{1-p} \\\\ & = & p \cdot (log_2(1-p) - log_2(p)) - 1 \end{array}\]

ความน่าสนใจ คือ เมื่อเรา plot Entropy โดยมี p เป็น x-axis จะได้ว่า

See: C. Shannon (1948)

นั้นคือ ระบบจะมี Entropy มากที่สุดก็ต่อเมื่อ p = 0.5 หรือพูดอีกอย่าง คือ

ตอนที่มีความน่าจะเป็นของเหตุการณ์ทุกอย่างเท่าๆกัน

= เราไม่สามารถคาดเดาอะไรได้เลย

= ระบบจะมีความเซอรไพรส์เฉลี่ยสูงที่สุด

Entropy ในมุมมองนี้ เป็นการมองว่า Entropy คือ การวัดผลความเซอร์ไพรส์ หรือ ไม่ต่างกันกับการวัดผลความไม่แน่นอน (Uncertainty) ของระบบ

ยิ่งระบบมี Entropy มาก = ระบบที่มี Uncertainty สูง

สิ่งนี้นำไปใช้ในหลายๆศาสตร์ อาทิ Machine Learning อย่างในโมเดล Decision Tree (ID3 or C4.5 algorithms) ใช้ Entropy ในการนิยาม Information Gain เพื่อคำนวนว่า ฟีเจอร์ใดเป็นฟีเจอร์ที่สามารถช่วยให้ทำนาย ouputs ได้ดีที่สุด — finding the best feature to split the data most effectively.

หรือ อย่างใน Cryptography ซึ่งต่อยอด Entropy มาใช้ในการประเมินความยากของกระบวนการเข้ารหัส— finding how hard a password is to crack

แล้ว Cross-Entropy หล่ะ??

อีกคำหนึ่งที่หลายๆคนอาจจะเคยผ่านหูผ่านตามาบ้าง คือ คำว่า Cross-Entropy ?? แล้วมันต่างจาก Entropy ยังไง? ทำไมถึงนิยมเอา Cross-Entropy Loss มาใช้ในการเทรนโมเดล AI ต่างๆ

สิ่งสำคัญที่สุดที่ทำให้ Cross-Entropy แตกต่างจาก Entropy คือ

Entropy เป็น function 1 ตัวแปร หรือก็คือ Entropy เป็นการคำนวนคุณสมบัติเฉพาะตัวของระบบหนึ่งๆ

แต่ Cross-Entropy เป็น function 2 ตัวแปร ซึ่งหมายความว่า มันเป็นคุณสมบัติเปรียบเทียบระหว่างระบบ 2 ระบบ

แต่เช่นเดียวกับ Entropy เราสามารถตีความ Cross-Entropy ได้จากทั้ง 2 มุมมอง นั้น คือ

หากมองในมุมมองของ Data Communication

จะมองว่า Cross-Entropy(P, Q) = จำนวน bits ที่ต้องใช้ในการแทนข้อมูลใน P ด้วย coding ที่ดีที่สุดที่สำหรับข้อมูล Q

ลองดูตัวอย่างตามรูปด้านล่าง จากตัวอย่างก่อนหน้านี้ เราน่าจะพอเดาได้ว่า coding ที่ดีที่สุดสำหรับข้อมูลทางซ้าย (น่าจะ)ไม่เหมือนกับ coding ที่ดีที่สุดสำหรับข้อมูลทางขวา

ดังนั้น Cross-Entropy(P, Q) คือ การหาว่า ถ้าเราเอา coding ที่ดีที่สุดสำหรับแบบนึง ไปใช้กับ ข้อมูลอีกแบบนึง มันจะเป็นยังไงนะ??

ข้อสังเกตุ คือ Cross-Entropy(P, P) = Entropy(P)

และที่น่าสนใจอีกอย่าง คือ Entropy(P) คือ จำนวน bits ที่น้อยที่สุดต้องใช้ในการแทนข้อมูลใน P ด้วย coding ที่ดีที่สุด

จะได้ว่า Cross-Entropy(P, Q) ≥ Entropy(P) เสมอ!! เพราะ coding ที่ได้จาก Q ไม่มีทางทำให้ได้ จำนวน bits ที่น้อยกว่า (จำนวน bits ที่น้อยที่สุดได้ ตามนิยาม)

และ จำนวน bits ที่เกินมา หรือ Cross-Entropy(P, Q) - Entropy(P) เรียกด้วยชื่อ แฟนซีๆว่า “KL-divergence”

ซึ่งเราสามารถตีความ KL-divergence ได้ว่า มันแทน จำนวนบิตที่ต้องใช้เพิ่มเติมจาก วิธี coding ที่ดีที่สุด

\[\begin{array}{rcl} D_{KL}(P, Q) & = & H(P, Q) - H(P) \\\\ & = & \sum p_x log_2(q_x) - \sum p_x log_2(p_x) \\\\ & = & \sum p_x log_2(\frac{q_x}{p_x}) \end{array}\]

หากมองในมุมมองของ Data Uncertainty

จะมองว่า Cross-Entropy(P, Q) = ความเซอร์ไพรส์จากที่เกิดจากเหตุการณ์ตามความน่าจะเป็น P แต่เราเชื่อว่า จริงๆแล้วเหตุการณ์เป็นไปตามความน่าจะเป็น Q

แปลว่า Cross-Entropy(P, Q) ควรจะให้ค่าน้อยๆ ถ้า สิ่งที่เราเชื่อ (P) สอดคล้องกับ สิ่งที่เราเจอจริงๆ (Q) และกลับกัน Cross-Entropy(P, Q) ควรจะให้ค่ามากๆ ถ้า P และ Q ไม่สอดคล้องกัน

นอกจากนี้ เรายังสามารถเชื่อมโยง Cross-Entropy(P, Q) เข้ากับ KL-divergence โดยมองว่า

Cross-Entropy(P, Q) = ความเซอร์ไพรส์ทั้งหมดที่เราตรวจพบ ซึ่งเกิดจาก 2 องค์ประกอบ ได้แก่

ความมั่วที่เกิดจากการไม่สอดคล้องกันระหว่าง P & Q (Believing in the wrong model) แทนด้วย Er₁
ความมั่วที่เกิดจาก noise ของ ข้อมูล (Inherent uncertainty of the data) แทนด้วย Er₂ ซึ่งจริงๆมัน คือ Entropy(P)

เราจะได้ว่า KL-divergence = Cross-Entropy(P, Q) - Entropy(P) = Er₁

แปลว่า KL-divergence สามารถเป็นตัวแทนของค่าของ uncertainty ที่เกิดจากการไม่สอดคล้องกันระหว่าง P และ Q