​สรุป Andrew Ng’s “Improving Deep Neural Networks: Hyperparameter tuning, Regularization and Optimization” Course2 แบบสรุปทั้งคอร์ส!

วันนี้ผมจะสรุปคอร์สของอาจารย์ Andrew Ng ตามความเข้าใจของตัวเอง อาจจะไม่เป๊ะตามที่อาจารย์สอนนะครับ บางครั้งผมก็อธิบายไปตามความเข้าใจของตัวเอง เหมือนกับบทความเหล่านี้เป็นการ take note ไว้อ่านเล่นของผมเอง แต่คิดว่าเอามาลงก็อาจจะมีประโยชน์กับผู้สนใจบ้างละมั้งครับ ฮา

TLDR; คอร์สนี้เป็นคอร์สที่สองของซีรีย์ Deep Learning deep Specialization ของ Deeplearning.AI ของอาจารย์ Andrew Ng ครับ

คอร์สจะแบ่งออกเป็น 3 สัปดาห์ แต่ละสัปดาห์ประกอบด้วย สองส่วน คือส่วนของ Lecture และ ส่วนของ Programming ใน Lecture จะมีความยาวสัปดาห์ละประมาณชั่วโมงกว่าๆจนถึงเกือบสองชั่วโมง ในแต่ละสัปดาห์ก็จะแบ่งเป็นคลิปวีดีโอย่อยๆคลิปละ 3-12 นาทีเหมือนกับคอร์สที่แล้ว

เนื้อหาในส่วนของคอร์สนี้เป็นการเสริมรายละเอียดจากคอร์สที่แล้วครับ คอร์สที่แล้วเป็นการสอนเบสิกของ Neural Network ใช่ไหม๊ครับ แต่มันยังใีรายละเอียดอีกมากมายที่อาจารย์แกยังไม่ได้ลง แน่นอนว่าอัลกอริทึ่ม Deep Neural Network นั้นทรงพลังมากก็จริง แต่มันยังมี Hyperparameter หรือ พารามิเตอร์ที่เราต้องมานั่งปรับมานั่งดีไซน์เองอีกหลายตัวครับ มันยังไม่ง่ายจน plug and play ได้เลยแบบอัลกอริทึ่มบางตัวที่มีการศึกษามานาน เพราะเทียบกันแล้ว Deep Learning มันยังเป็นศาสตร์ที่ไม่นิ่ง นักวิจัยทั้งหลายยังคงพัฒนามันไปเรื่อยๆกันแทบทุกวันฉะนั้นในคอร์สนี้เราจะได้ดูวิธีการ แนวทางการปรับพารามิเตอร์พวกนั้นรวมไปถึง เทคนิคการ Regularization หรือ เทคนิคการหนีการ Overfitting ว่ามีวีธีการอะไรบ้าง และ สุดท้ายก็คือ Optimization หรือก็คือ การหาค่าให้เหมาะสมที่สุดนั่นเอง โดยแต่ละ Week จะมีรายละเอียดดังนี้

  • Week 1 พูดเรื่อง Practical aspects หรือภาคปฎิบัติครับ ประกอบไปด้วย การแบ่ง Train/Test set สำหรับข้อมูล Big Data, การ Regularization อย่าง L2 และ Drop out จบด้วย ปัญหาตั้งต้นว่าทำไมเราจึงต้อง Optimization การ Initialization มีผลอย่างไร
  • Week 2 จะหนักเรื่อง Optimizatlion เลยครับ Mini-Batch, Momentum, Rmsprop, Adam และ Learning Rate Decay
  • Week 3 สุดท้ายมาจบด้วยการทำ Batch Normalization, Multi-class classification และจบที่สอน Tensorflow เบื้องต้นเบาๆครับ

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

Neural Networks and Deep Learning เป็นคอร์สที่สองในชุด specialization Deep Learning ของ DeepLearning.ai ที่ประกอบไปได้ด้วย

  1. Neural Networks and Deep Learning
  2. Improving Deep Neural Networks: Hyperparameter tuning, Regularization and Optimization คอร์สนี้
  3. Structuring Machine Learning Projects
  4. Convolutional Neural Networks
  5. Sequence Models

ตัวคอร์สสามารถเข้าเรียนได้ที่

https://www.coursera.org/learn/neural-networks-deep-learning

สำหรับผู้ไม่ต้องการเสียเงิน เมื่อกดที่ Enroll พอมันจะให้จ่ายเงินให้เราไปกดรูป Audit แทนนะครับ

เท่านี้ก็จะได้เรียนฟรีแล้วครับ แต่ไม่ได้ Certificate นะเออ

Week 1

สัปดาห์แรกจะพูดถึงสามเรื่องครับ

เรื่องแรก Setting up your Machine Learning Application

เนื่องจากศาสตร์ Deep Neural Network มันยังไม่ศาสตร์ที่ยังไม่นิ่งมากนัก ยังมีหลาย Hyperparameter ที่ผู้สร้างโมเดล ไม่สามารถกำหนดให้ถูกต้องได้ตั้งแต่แรก เราจึงต้องอาศัยการทดลองจำนวนมากดังรูป

จะเห็นว่าเราต้องเริ่มจากการมี Idea และการ Implement ไอเดียออกมาเป็นอัลกอริทึ่มจากน้้นก็นำไปทดลอง Experiment เพื่อวัดผลได้ว่าโมเดลที่ว่าดีแย่อย่างไร ต้องพัฒนาตรงจุดไหนบ้าง วนไปเรื่อยๆหลายรอบตามรูปบนครับ

อย่างการแบ่ง Train/Test Split โดยการ Train (ข้อมูลสอน) ที่ใช้ในการสอนโมเดลของเราให้สามารถทำ Task ที่เรากำหนดได้ แต่ทำได้ดีแค่ไหน จะวัดกับข้อมูล Train อย่างเดียวคงไม่พอเราจึงมีคอนเสปในการแบ่งข้อมูลไว้ Test(ข้อมูลที่นำมาทดสอบ) เพื่อดูว่าโมเดลนั้นๆทำงานกับข้อมูลทีไม่เคยเห็นได้ดีแค่ไหน บางครั้งเราก็ต้องแบ่งอีกส่วนหนึงเป็นข้อมูลเพื่อใช้ในการทำ Cross Validation อีกส่วนหนึงใช่ไหมครับ อันนี้อาจารย์ก็จะเรียกว่า “Dev set”

โดยในสมัยก่อนที่ข้อมูลมันยังไม่เป็น Big Data นั้นเราก็คงคุ้นชินกันที่การแบ่งข้อมูล Train 80% และข้อมูลTest 20% หรือบางที่ก็บอกว่า 70/30 60/40 หรือจะเป็น Train 60 Dev 20 Test 20 บ้างล่ะก็ว่ากันไปนะครับ

แต่ในยุคใหม่ การมีข้อมูล Big data หรือการมีข้อมูลมหาศาลเนี่ย ข้อมูลมันมากอยู่แล้วใช่ไหมครับ การจะมา Dev/Test มันไม่ต้องใช้มากขนาดนั้นก็ได้ เช่นถ้ามีข้อมูลเป็น10,000,000 แล้ว เราอาจจะแบ่งเป็น Train 98 Dev 1 Test 1 ก็ได้ แค่นั้นก็อย่างละ 100,000 แล้วครับ หรือถ้าข้อมูลมากกว่านี้อาจจะแบ่งเป็น 99.5/0.25/0.25 ก็ได้ แต่ต้องแบ่งให้มันพอสำหรับการเทสความเสถียรของโมเดลก็พอครับ

ข้อควรระวัง Mismatched train/test distribution กล่าวคือ ข้อมูลที่เอามาสอนและเทสต้องมาจาก การแจกแจงเดียวกันใช่ไหมครับ เช่น ถ้าเราเอารูปแมวจากเวปมาซึ่งมีความละเอียดสูง แล้วไปเก็บข้อมูลเทสจากยูสเซอร์ที่มีการถ่ายที่สไตล์ต่างกันมากอะไรงี้นะครับ นี่คือสิ่งที่อาจารย์อธิบาย แต่ผมคิดว่ายกตัวอย่างง่ายๆเลย ถ้าเราไปรู้จำ ตัวเลขจากฟ้อนสี่ห้าแบบ ใช้เป็นข้อมูลสอน แล้วเราไปให้คนทั่วๆไปส่งข้อมูลการเขียนตัวเลข จากมือมาซักเอง ข้อมูลมันก็จะมาจากคนละการแจกแจงใช่ไหมครับประมาณนี้ สรุปก็คือ ข้อมูลควรจะมาจากการแจงแจงเดียวกันครับ จำรูปแมวถ้าเทสด้วยไก่มันก็จะแปลกหน่อยนึง 555+

ต่อไป Bias/Variance Tradeoff

อันนี้ก็ไม่ต้องพูดอะไรมากแล้วมั้งครับ เราน่าจะคุ้นเคยอยู่แล้วกล่าวคือ

ในการเทรนโมเดลนั้น

  • รูปทางซ้ายสุด ถ้าเราเทรนโมเดลโดยให้ฟรีด้อมมากไป มันก็อาจจะเกิดการวัดผลในข้อมูลสอนแล้วได้ความถูกต้องต่ำมาก อันนี้เราเรียกว่า High Bias หรือ Under-fitting ครับ
  • รูปทางขวาสุด ในทางกลับกันถ้าเราเทรนจนโมเดลมีความแม่นจำมากเกินไปมันก็อาจจะเกิดเหตุการณ์ที่วัดผลในข้อมูลสอนแล้วได้ความถูกต้องสูงมาก อันนี้เราเรียกว่า High Variance หรือ Over-fitting ครับ
  • รูปกลาง คือเป้าหมายของเราครับคือเราต้องพยายามเทรนโมเดลให้หลีกเลี่ยง 2 กรณีข้างต้น โมเดลที่ดีต้องไม่ High Bias ไม่ High Variance มากเกินไป แต่สามารถทำงานในที่นำมาสอนในข้อมูลทดสอบได้ผลดีนั่นแล

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

คราวนี้มาดูกันว่าเข้ากรณีไหนต้องทำยังไงนะครับ

  • High Bias หรือ Under-fitting นั้น คำแนะนำง่ายๆ ก็เพิ่มชั้นเพิ่มนิวรอนต่อชั้นครับ ส่วนใหญ่แล้วมันจะช่วย (แต่ก็ขึ้นกับดาต้าด้วยครับ ถ้าข้อมูลแรนด้อมมากๆใส่เลเยอร์มากๆก็อาจจะไม่ช่วยอะไรนัก ) แต่โดยทั่วไปมันจะช่วยครับ
  • High Bias หรีอ Over-fitting ล่ะทำไงดี คำแนะนำโดยทั่วไปก็ไปหาข้อมูลมาสอนเพิ่มครับ เมื่อข้อมูลมีมากขึ้นมันก็จะได้เจอข้อมูลใหม่ๆมากขึ้นจะได้ลดโอกาสในการ Over-fitting ลงครับ และอีกอย่างก็ต้อง Regularization ครับ เพื่อไม่ให้ฟีเจอร์บางอัน หรือ การ Combination ของบางโหนดมีความสำคัญมากไปเราจึงต้องใช้ Regularization เพื่อลดความสำคัญของ Weight เฉพาะบางอันลงไปครับ

เรื่องที่สอง Regularizing your neural network

อันนี้อาจารย์จะเริ่มกล่าวถึง Regularization แล้วครับ Regularization มันคืออะไร พุดให้เข้าใจง่ายๆมันก็คือ วิธีการช่วยในเรียนรู้ให้ไม่เกิดการ Over-fitting มากเกินไปนั่นเอง

เริ่มที่ L1 L2

โดยจะเริ่มกล่าวจาก วิธีการ Regularization ของ Logistic Regression กันครับ โดยอาจารย์จะพูดถึง L2 หรือ Ridge Regression และ L1 หรือ Lasso Regression ครับ โดยไอเดียคร่าวๆของมันก็คือ แทนที่จะอัพเดต W (Weight), b (Bias) ของมันแบบปรกคติเราก็เพิ่มสมการไปหน่อยหนึงตอนคิด Gradient Descent เท่านั้นแหละครับ โดยการเพิ่มตัวแปรแลมด้าส่วนด้วย m(จำนวนข้อมูล) ไปคูณกับ norm ของ parameter ที่เราต้องการใน regularize มันในที่นี้คือ W แต่อาจารย์แนะนำว่าในส่วนของ m ว่าใช้ 2m จะดีกว่านะครับ แต่ก็ช่างมันเถอะครับ ณ จุดนี้ผมคิดว่าเราเข้าใจแค่ว่า L1 L2 คือเทคนิคการหนีการ Over-fitting ก็โอเคแล้วครับ

ในการทำงานจริงๆ น้อยคนที่จะไปทำ Regularization บนตัวแปร b นะครับ และข้อแตกต่างคือสมการณ์ของ

  • L1 มันจะก่อให้เกิดการ set ค่า W จนเป็น 0 ได้
  • L2 ไม่ได้ครับ มันจะลดค่าอย่างเดียว ในที่นี้อาจารย์แนะนำว่าใช้แต่ L2 ก็พอครับ

ส่วนในส่วนของ Neural Network ก็ไม่ได้ต่างกับ Logistic มากนักครับ แค่มอง W เป็น Matrix เท่านั้นแล ดูได้จากการคิด norm ของ W ด้านล่างนี้ครับ และก็แทนที่จะเรียกว่า L2 norm เค้าก็จะเรียกว่า “Frobenius norm” แทนนะครับ จากนั้นก็นำไปอัพเดต W เป็นอันจบครับ

สรุปที่จำเป็นต้องรู้คือตัวแปร lambda ก็คือตัวแปรที่เอาไว้ลงโทษ น้ำหนัก W ครับ ถ้าเราทำให้ แลมด้าใหญ่ ค่าจอง W ก็เล็กลงตามไปด้วย พอ W เล็กลง ก็จะไปกระทบกับสมการหลักชั้นของ Z = W * a + b (a คือค่าที่ได้มาหลังจาก activation ของชั้นก่อนหน้า) ถ้า lambda ใหญ่ W เล็ก Z ก็จะเล็กไปด้วย และเมื่อ Z เข้าไปสู่ชั้น Activation Function ไม่ว่าจะ Tanh หรือ Sigmoid มันก็จะเล็กไปด้วยครับดังรูป

พอ Z เล็ก ค่าที่ออกมาจาก Tanh มันก็จะเล็กและจะอยู่ในสมการเส้นตรงสีแดง ทำให้ค่าที่ได้มันมีโอกาสที่จะออกมาเป็น Linear มากกว่าไงครับ ถือเป็นการกันไม่ให้ค่าใหญ่เกินไปครับ เพราะถ้าค่ามันใหญ่ เวลาผ่าน Activation ออกมามันจะมีความชันต่ำ เพราะปลายทั้งสองข้างของสมการ Tanh หรือ Sigmoid มันจะ Saturated ครับ ยิ่งค่า Z ใหญ่ มันก็จะไปตกที่ปลายทั้งสองด้านนั้นครับ โครงข่ายของเราก็จะเหมือนกับคำนวณ Linear Function เยอะๆ มันก็จะลดโอกาสเกิด Over-fitting ครับ!!!

ตามมาติดด้วย Dropout

อีกวิธีการที่ทรงพลังในการหลีกหนี Over-fitting ที่ทรงพลังทีเดียวครับ และหลักการทำไม่ได้ยุ่งยากอย่างที่คิดพูดกันแบบชาวบ้านๆ เราก็แค่เป็นการแรมด้อมปิด Neuron บางตัวในแต่ละเลเยอร์เท่านั้นแหละครับ ในแต่ละรอบมันก็จะเปิดๆปิดๆไม่เหมือนกัน แต่ละรอบก็ทำการปรับค่า W และ b แต่อันที่เชื่อม Neuron ที่เปิดอยู่ ด้วยหลักการสุ่มและอัพเดตค่าแบบนี้มันจึงสามารถหนีการ Over-fitting ได้ดีมากเลยทีเดียวล่ะ

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

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

Data augmentation

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

Early Stopping

หรือที่ลุง geoff hinton ให้คำนิยามไว้อย่างสวยงามว่า “Beautiful free lunch” ปรกติเค้าจะบอกเราเสมอว่ามันไม่มีหรอกครับของที่ได้มาฟรีๆในทางอัลกอแบบนี้นะ แต่มันมีครับ ก็คือไอ่นี่แหละครับ เทรนไปจนกว่าค่า Error ของ dev/test มันจะเริ่มเพิ่มมากขึ้ละหยุดเทรน จบ แหม่ข้าวเที่ยงฟรีจริงๆนะครับ จริงๆถ้าว่ากันในรายละเอียดก็คือ ตอนเราเทรนแรกๆเราจะกำหนด W แบบแรนด้อมใช่ไหมครับ(มีแรนด้อมหลายแบบ) แต่โดยรวมแล้วมันจะใกล้ๆ 0 พอเรียนไปเริ่มๆ W มันก็ได้ปรับค่าไปเรื่อยๆค่ามันก็จะใหญ่ขึ้นใช่ไหมครับ ถ้า Early Stopping ไปบอกให้เราหยุดในตำแหน่งที่เหมาะสมมันก็จะกลายๆกับการทำ L2 นั่นแล 

แต่ปัญหามันก็มีอยู่ว่า ถ้าเราทำ Early Stopping เนี่ย เราจะไม่สามารถแบ่งเป็นสองส่วนแยกจากกันได้คือ 1 Optimization Cost function และ 2 Not Overfit ได้แบบขาดจากกันได้อีกแล้วมันต้องทำไปด้วยกัน แล้วทำไมเราไม่ใช้แค่ L2 ละรันไปเรื่อยจนเท่าที่เราต้องการเลยล่ะ คำตอบก็คือ L2 เราต้องมานั่งทดลองหาค่า lambda ครับ มันอาจจะต้องใช้เวลาและ resource มากพอดูเลย

Setting up your optimization problem

มาต่อกันที่ปัญหาของการทำ Machine Learning คือการทำ ML แน่นอนมันก็ต้อง Gradient Descent ใช่ไหมครับ พอมี GD มันก็ต้องมีการหาจุด Optimum ใช่ไหมครับ แต่ถ้า input ของเรามันต่างสเกลกันมากๆ สมมุติเช่น b ในโครงข่ายมีค่าหลัก 10000 W มีค่า 0-1 GD ของเราจะดูไม่จืดแบบรูปนี้

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

เราแก้ยังไง คำตอบก็คือนี่เลย

Normalization

กล่าวคือมันก็คือการทำให้ข้อมูลแกว่งรอบๆ 0 แค่นั้นแหละครับ ทำให้มันแจกแจงปรกตินั่นเอง เรื่องสมการเราคงคุ้นกันอยู่แล้วเนอะ

มันก็จะเปลี่ยนให้ GD ของเราออกมาเป็นแบบรูปขวาด้านล่างนี่

เห็นไหมครับ GD ก็แจกแจฃปรกติแล้ว มันก็จะเป็นเรื่องง่ายขึ้นที่จะเดินไปหา Optimum มากกว่าการแจกแจงแปลกๆด้านขวา!!!!

Vanishing / Exploding gradients

เรื่องต่อมาอาจารย์จะพามาดูปัญหาใหญ่ของการเทรนโมเดล Neural Network ครับ มันจะมีการเชื่อมเลเยอร์กันหลายๆชั้นใช่ไหมครับ แล้วมันก็จะเท่ากับ Activation(W*A + b) ต่อๆกันไปหลายๆชั้นมันก็จะเกิดปัญหาได้ครับในกรณีที่

ก็ถ้ามันต้องคิดต่อกันเป็น chain แบบนี้ ถ้า

  • W มีค่าน้อยเกินไป เช่น ~0.5 แบบนี้เป็นต่อๆกันไปเป็นจำนวน L ชั้น การคำนวณมันก็จะลดค่าลงอย่าง Exponential ครับ Vanishing gradients ค่ามันหายวับไปกับตา T-T
  • W มีค่ามากเกินไป เช่น ~1.5 แบบนี้เป็นต่อๆกันไปเป็นจำนวน L ชั้น การคำนวณมันก็จะเพิ่มขึ้นอย่าง Exponential ครับ อันนี้เรียกว่า Exploding gradients ค่ามันระเบิดตู๊มมม

ทางแก้ที่แน่นอนมันก็ไม่ได้มีชัดเจนนักหรอกครับ แต่ที่ใช้ๆกันตอนนี้คือและช่วยได้มาก การใช้ Weight Initialization หรือการกำหนดค่าเริ่มต้นให้กับ W ครับ

Weight Initialization

หรือการกำหนดค่าเริ่มต้นให้ตัวแปร W ครับ และแน่นอนส่วนใหญ่แล้วเราจะกำหนดมันแบบสุ่ม แต่การสุ่มนั้นๆมันก็มีหลายแบบครับ อาจารย์ก็จะพูดให้ฟังว่าแทนที่จะแรมด้อมสุ่มมาเฉยๆ สำหรับ W ในชั้นหนึงๆ เราก็สุ่มในฟอร์มของแรนด้อม * ด้วย sqrt 1/nที่ (l-1) หรือหารด้วย 1 ส่วนจำนวนยูนิตนั่นแล ในขั้นทำงานจริงอาจารย์ก็แนะนำว่า 2/nที่ (l-1) จะทำงานดีกว่านะ (ที่ทำนี้พูดง่ายๆคือเรากำลัง set variance ของ W ที่แรนด้อมน่ะครับ) อันนี้อาจารย์แนะนำว่าถ้าใช Relu ก็เอาตัวนี้ใช้ได้เลย ตัวอื่นๆก็มีอย่างเช่น Xavier Initialization, He Initialization

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

Gradient Checking

คือในการทำ ML เราก็ต้องใช้ Calculus ในการหาค่า Rate of change ของ cost function เพื่อนำไปอัพเดต W และ bใช่ไหมครับ แล้วเราจะรู้ได้อย่างไรว่าที่เราทำมามันถูก นั่นแหละครับที่มาของ Gradient Checking จะมานั่งไล่โค้ดไล่สมการมันก็ลำบากเราก็เลยใช้เจ้านี่มาเช็คดูกันดีกว่า แล้วมันทำงานอย่างไร

*เพิ่มเติมบางจุดที่อาจารย์ข้ามไป คือเวลาเราหา Rate of change ของ slope เนี่ย ยิ่งเรามองไปลึกๆ จากเส้นโค้งมันก็จะค่อยๆเป็นเส้น linear ใช่ไหมครับ ค่า diff มันก็จะเล็กลงไปๆเรื่อยๆ แต่คอมมันมองตรงนี้ไม่เห็นหรอกครับเพราะมันเข้าหา 0 แบบ Infinity เราก็เลยหาค่าที่เล็กพอสมควรที่จะเอามาเช็คได้ว่าเราทำถูกแล้วนะ

มาที่ส่วนอาจารย์กันต่อ วิธีการก็นั่นแหละครับ แทนที่เราจะหา slope ของตำแหน่งเดียว เราก็เพิ่ม range ให้มันเข้าไปคือ จุดที่เราสนใจจะหา +epsilon, -epsilon โดยค่า epsilon จะเล็กประมาณหนึงครับ เพราะเราจะใช้เพื่อนำมา check กับค่าจริงนั่นเอง ถ้ามันห่างกันซัก 10^-7 อาจารย์ว่าเยี่ยมเลย แต่ถ้ามันแบบ 10^-3 อันนี้จะเริ่มเป็นกังวลครับ อาจจะต้องเริ่มนั่งไล่ความถูกต้องแล้วครับ

Week 2

เอ้ามาต่อกันเลยดีกว่า ระหว่างที่ผมนั่งสรุปผมเริ่มจะเหนื่อยๆละซิครับ ไม่แน่ว่าหลังๆอาจจะสรุปไม่ละเอียดเท่าแรกๆนะครับ ฮา

Optimization algorithms อันนี้จะเป็นหัวเดียวของวีคนี้นะครับ เราจะเรียนเรื่องนี้กันเต็มๆเลย มาเริ่มกันเลยดีกว่า ^^

อาทิตย์นี้เราจะได้เริ่มกันที่ Mini-batch ครับ มันคืออะไร ก็ปรกติเวลาเรา เทรนโมเดลในการเทรนแต่ละรอบ(Epoch) มันก็จะคำนวน Cost Function และอัพค่าแบบ backprop บนข้อมูลทั้งหมด(Batch Gradient Descent) ใช่ไหมครับ ซึ่งถ้าเรามีข้อมูลเยอะมากๆแบบ หลักล้านเรคคอร์ด ถ้าเราทำหมด ในการรันแต่ละรอบมันจะกินเวลาและพลังการคำนวณมากๆครับ เค้าเลยคิดคอนเสป Mini-batch ขึ้นมาครับ

พูดง่ายๆก็คือสุ่มข้อมูลจากข้อมูลตัวอย่างมากลุ่มหนึง เพื่อใช้ในการเทรนแะอัพเคตค่าในแต่ละรอบ สมมุติว่าเราเทรน หมื่น epoch บนข้อมูล 100,000 แรคคอร์ดใช่ไหมครับ เราก็จะสุ่มข้อมูลมาเทรน เช่น รอบหนึง เราจะสุ่มมา 1024 แรคคอร์ด ละคำนวนบนข้อมูลแค่นั้นละก็อัพเดตไป รอบต่อมาก็ บนข้อมูลอีก 1024 ชุดอีกครั้งครับ ทำไปเรื่อยๆ

Gradient Descent มันอาจจะ มี noise หน่อย แต่พอเวลาผ่านไปหลายๆครั้ง มันก็จะเข้าที่ตามกฎการแจกแจงเองครับ ตามรูปบนด้านขวา

สิ่งที่ควรค่าแก่การจดจำคือรูปนี้เลยครับ

  • ถ้า Mini-Batch = m หรือเท่ากับจำนวนข้อมูลทั้งหมดมันก็จะกลายเป็น Batch Gradient Descent
  • ถ้า Mini-Batch = 1 มันก็จะเป็นแค่ Stochastic Gradient Descent ไปด้วยนะครับ ถ้าเป็นแบบนี้เราจะเสียความสามารถในการ Vectorization ไปตัวด้วยนะเออ
  • เลือกMini-Batch เป็นตัวเลขรุปแบบ 2^n จะดีมากครับ เช่น 32 64 128 512 … ไปเรื่อยๆจะดีกว่านะครับ

Exponentially weighted averages

อันนี้ผู้ที่ลงทุนในตลาดหลักทรัพย์โดยเฉพาะแบบ Trend Following คงรู้จักกันดีเนอะ ผมเคยได้ยินความเชื่อเกี่ยวกับการหาตัวเลขวิเศษ หรือหาสูตรวิเศษเพื่อเอาชนะตลาดหลักทรัพย์กันบ้างละ คือเอาจริงๆไม่ว่าจะสูตรไหน EMA ไม่ว่าจะ Hull จะอะไรมันก็ตั้งอยู่สมมุติฐานเดียวกันี่แหละครับ เราต้องดูตัว Theory ให้ดีก่อนค่อยไปนั่งหาเลขวิเศษเนอะ เอาละพอก่อนเดี๋ยวผมนอกเรื่องอีก

กลับมาที่ ANN ของเราก่อนดีกว่า เอาละครับ EMA (Exponentially weighted averages) คืออะไรมันก็คือการคำนวณค่าเฉลี่ยย้อนหลังนี่แหละครับ แต่มันจะให้ความสำคัญกับค่าที่ใกล้กับค่าณเวลาปัจจุบันมากที่สุด

พูดมากไปจะงงเปล่าๆดูสมการมันดีกว่าครับ สมการมันบอกว่าค่า EMA ณ วันที่ t = Beta* ข้อมูล EMA ณ เวลา t-1 + (1 – Beta) * ข้อมูล ณ เวลา t จะมันเป็น portion อย่างชัดเจนนะครับ ตัวแปร Beta นี่แหละครับคือตัวบ่งบอกว่าเป็น Exponential สมมุติว่า Beta = 0.9 ก็หมายความว่า 0.9 * ข้อมูลEMA ณ เวลา t-1 +0.1* ข้อมูล ณ เวลา t ไม่ว่าข้อมูลที่ผ่านมาข้างหน้าจะมีกี่วัน แต่ Constant หลักคือก้อนหลังครับมันยังคงเดิม ไม่ว่าจะผ่านมากี่วัน วันล่าสุดจะให้ค่า 0.1 เสมอ นี่แหละครับหลักการของ EMA

Beta ประมาณ 0.9 เนี่ย ก็แปลความง่ายๆว่า เฉลี่ยประมาณ 10 วัน ถ้า Beta 0.98 ก็จะแปลได้ว่าเฉลี่ยประมาณ 50 วันครับ

เพราะอะไรน่ะหรือ อาจารย์แกจะพาเรามาแกะดูครับว่าทำไมถึงแปลความได้แบบนั้นล่ะ

ชัดเลยครับ ตามตัวอย่างค่า ณ วันที่ 100 จะเท่ากับ 0.1 ของค่าณวันที่ 100 + 0.9 ค่า EMA ณ วันที่ 99 ซึ่งถ้าแกะออกมาอีกค่า วันที่ 99 ก็คิดมาจาก 0.1 * วันที่99 + 0.9 ณ วันที่ 98 อีกไงครับ และวันที่ 98 ก็จะเท่า 0.1 * วันที่ 95 + 0.9 ณ วันที่ 97 แกะไปเรื่อยๆ ค่ามัน ณ วันที่ห่างจากวันปัจจุบันมันจะลดค่าไปเรื่อยๆอย่างเป็น exponential ใช่ไหมครับ นี่แหละครับหลักการมัน ไปจนถึงวันที่ห่างจากวันปัจจุบันครบ 10 วัน ในที่นี้ก็ วันที่ 91 เนอะ มันก็จะได้ 0.9^10 หรือ 1/e หลังจากนี้มันก็ไม่ค่อยมีความสำคัญแล้วแหละครับ เราเลยคิดได้ว่า 0.9 เนี่ยมัน เฉลี่ย 10 วันไงครับ ^^ และเช่นเดียวกันถ้า Beta = 0.98 เนี่ย มันต้องยกกำลัง 50 อะครับถึงจะได้ 1/e เนี่ยแหละครับที่มาของมัน ถ้าพล๊อพเป็นกราฟคือ exponential ที่อัตราการลดหลั่นของวันที่ห่างออกไปนั้นไม่ชันเท่า 0.9 นั่นแหละครับ

Gradient descent with momentum

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

ถ้า Cost Function ของเรามันอยู่ในรูปแบบนี้ ทางแกน y มันจะสั้นกว่าแกน x มากใช่ไหมครับ ถ้าเราไม่ใช่โมเมนตั้มมันเป็นไปได้ว่าการเดินทางไปหา optimum จะกินเวลานานกว่ามากเพราะความเหวี่ยงในแนวตั้ง(ในแต่ละ epoch) แล้วการเหวี่ยงของมันนี่ก็แทบจะ Average เป็น 0 เลยใช่ไหมครับ ส่วนในแนวนอน Average ของมันก็จะไปในทางเดียวกันเลยใช่ไหมครับ ก็จะใหญ่ๆหน่อยหนึง นี่แหละครับ EMA มีประโยชน์ตรงนี้นี่เอง คือมันจะรู้เรื่องส่งใน ขณะนั้นๆได้ครับ แทนที่จะคำนวณแยกกันไปในแต่ละรอบ จะดีกว่าไหมถ้าเรานำรอบก่อนๆมาพิจรณาด้วยจากสมการ EMA ที่ว่าไป สุดท้ายนี่้อาจารย์ว่า Beta 0.9 นี่ก็ทำงานค่อนข้างทีแล้วนะ พวกเราก็ลองเอาไปเล่นกันดูครับ ถ้ามันดีก็จะได้ไม่ต้อง tune Beta กันมากนัก ข้อดีคือลดการเหวี่ยงและเพิ่มความเร็วของการเข้าหา Optimum ของเราได้ครับ

RMSprop

อันนี้จะต่างกับโมเมนตั้มตรงที่จะมีการเก็บค่า Derivative แบบ exponential ไว้ จากนั้นเมื่อเวลานำไปอัพเดต W และ b มันก็จะนำค่า Sdw และ Sdb ไปเป็นตัวหาร dw และ db แทนที่ของโมเนตั้มที่มันจะใช้แค่ Vdw และ Vdw ไปอัพเดตทื่อๆครับ ตามรูป

จากรูปอาจารย์เค้าจะสมมุติว่าแนวนอนเป็น W และแนวตั้งเป็น b ทางที่เราต้องการไปให้ไวก็คือทางที่เป็น W ส่วน B เราต้องการให้เหวี่ยงน้อยลงครับ สมมุติฐานของสมการนี้คือ dW^2 มันจะมีค่าน้อย และ db^2 มันจะมีค่าเยอะครับ และพอเราเอามาหารก่อนจะอัพเดตด้านล่าง มันก็จะทำให้ก้าวของ W กว้างขึ้น และก้าวของ b สั้นลงครับ

Adam optimization

Adam หรือ Adaptive Moment Estimation ก็เป็นการรวมทั้ง Momentum และ RMSprop เข้าด้วยกันครับ ก็ถ้าพูดง่ายๆก็คือ ทำทั้งคู่นั่นแหละครับ โดยเอาแสควร์รูท RMSprop corrected (+ epsilon (ก็ค่าเล็กๆคอนเสปเดียวกับตอนเอามาหา Gradient Checking อะครับ ประมาณ 10^-8 แนวๆนี้))มาหาร Momtum corrected ตอนอัพเดตแทนครับ อาจารย์แนะนำว่าอันนี้ใช้งานดีมากในหลายๆอัลกอริทึ่มเลยครับ

Learning rate decay

ปัญหาอีกอย่างของการเซ็ต Learning Rate ตายตัวนั่นก็คือ ถ้าเกิดเราเซตไว้ใหญ่ระดับหนึง มันเป็นไปได้ว่าเมื่อใกล้ถึงจุด optimum ของ GD มันอาจจะไม่มีวันเจอเลยก็ได้ครับ

เพราะ step ในการเดินใน GD มันใหญ่จนเดินข้ามไปหมด ดังเส้นสีน้ำเงิน (เช่นเดียวกันถ้าเล็กเกินไปมันก็ช้าอีกอะนะ) เราจึงมีวิธีการมาจัดการปัญหานี้ ซึ่งมันก็ดูจะเถรตรงเลยนะครับ มาจาก แหม่ ถ้าแบบนั้นเราก็มาทำให้ Learning Rate มันลดลงกันเถอะ ดังเส้นสีเขียวที่เริ่มมันจะก้าวใหญ่ๆแล้วจากนั้นค่อยๆสั้นลงเมื่อเวลาผ่านไป ตั้งบนสุมมุติฐานที่ว่ายิ่งผ่านไปหลาย epoch เราก็จะยิ่งเข้าใกล้ optimumครับ

วิธีการทำ Learning rate decay มันก็มีหลายวิธีเหลือเกิน เช่น Alpha = 1/(1+decay rate * epoch) ปรับตรง decay rate ว่าอยากให้มันลดลงแค่ไหนในแต่ละ รอบก็โอเคแล้วครับ หรือ 0.xx^epoch * alpha ก็ยอ่มได้ เราก็ปรับ xx ให้เป็นตัวเลขว่าต้องการให้มันลดลงเร็วแค่ไหนอะไรแบบนี้อะครับ

The problem of local optima

ปัญหาของมันได้เปลี่ยนรูปแบบแล้วครับ จากเมื่อก่อนที่เราจะเห็น local optima เหมือนดังรูปขวา เดี๋ยวนี้มันก็มีโอกาสครับที่ยากหน่อยที่จะเกิด แต่ปรากฎว่าใน Deep Learning ที่เรามีฟีเจอร์จำนวนมากนั้น GD มันจะออกมาเป็นรูปแบบของ plateau(ที่ราบสูง) เป็นประจำเหมือนดั่งรูปขวานะครับ ปัญหาคืออะไร คือมันชันต่ำ Derivative ของมันก็จะเข้าใกล้ 0 มันเลยทำให้โมเดลเราก็จะเรียนรู้ได้ช้าครับ

จารย์แกวาดม้าน่ารักดีนะครับ ฮา เอาล่ะครับแล้วเราก็จบ Week 2 กัน ณ ที่นี้แหละครับ ^^

Week 3

เริ่มเรียนกันต่อดีกว่าครับรออะไรล่ะ ฮา

Hyperparameter tuning

เริ่มมาก็ให้ลำดับความสำคัญครับ Hyperparameter ตัวไหนสำคัญสุดตัวไหนสำคัญรองลงมาครับ

สำคัญสุดก็คือ Alpha หรือ Learning Rate นั่นแหละครับ ส่วนพวกสีเหลืองคือรองลงมา และสีม่วงก็คือสำคัญเพียงแค่นิดหน่อยเท่านั้น ส่วน Beta1 Beta2 epsilon ของเรื่อง Adam นั้นไม่ต้องไป tune มันก็ได้ไม่ค่อยเห็นผลเท่าไหร่หรอกครับ ใช้ค่า around default ตามรูปก็โอเคแล้ว หรือ Beta ของ Momentum สีเหลือง 0.9 ก็ถือว่าดีพอสมควรแล้วครับ

สำหรับทุกท่านที่อ่านหรือเรียนคอร์สของอาจารย์ Ng มาถึงจุดนี้ก็คงไม่มีใครไม่รู้จัก Grid Search มั้งครับ? ตามที่เรารู้ๆกัน Grid Search คือการหาค่าพารามิเตอร์ แบบเป็น Systematic ครับ แต่สำหรับ Deep Learning วิธีการนี้อาจจะไม่เหมาะสมนักครับ

เพราะ Grid Search มันคงทำงานได้ดีแหละครับถ้าเรามี hyperpameter น้อย แต่ใน Deep Learning ถ้าทำแบบนั้นคงไม่ดีเพราะเราไม่รู้ว่า hyperparameter ตัวไหนมีความสำคัญมากกว่ากันครับ เช่นถ้า เราทำ Grid Search 25 รอบ 5*5 สำหรับ hyperparameter เช่น Alpha และ epsilon นะครับทำไป 25 ครั้งดังรูปซ้ายเราก็จะได้ค่า Alpha ที่แตกต่างกันจริงๆแค่ 5 ค่าเองนะ ขณะที่การ search epsilon ไปมันก็ไม่ได้ช่วยอะไรมากเลยก็ได้ ขณะที่ใน Deep Learning เราแนะนำให้ใช้ Ramdom ครับ ตามรูปขวา เราก็จะได้ค่าที่แตกต่างกันของ Alpha ถึง 25 ค่า จะทำให้เราเห็นภาพรวมว่า Hyperparameter ตัวไหนมีผลต่อโมเดลอย่างไรได้มากกว่าครับ

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

ต่อมาเป็นเรื่องสเกลการ tune parameter ครับ เอาเป็นว่าถ้าเราจะสุ่มเลขจาก 0.0001 ไป 1 ไอ่จาก 0.0001 ไปถึง 0.1 มันก็กินการเสริชไป 90% แล้วใช่ไหมครับ ซึ่งจะทำให้เราโคตรเปลืองเวลา search อะครับ แล้วเราก็ไม่อาจจะรู้ได้ว่าค่ามากหรือน้อยดีกันแน่ เพราะการแจกแจงแบบนี้

อย่ากระนั้นเลย เราก็มาทำ log scale แล้วค่อยเสริชสิ่ problem solve!!!

Pandas vs. Caviar

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

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

Batch Normalization

อาทิตย์แรกอาจารย์ก็ได้บอกพวกเราไปแล้วนะครับว่าการทำ Normalization ให้ข้อมูลจะทำให้ GD รูปสมมาตรขึ้นและเดินไปหาจุด optimum ได้เร็วกว่าเพราะอินพุตมันอยู่ในเสกลเดียวกัน แต่ถ้าเป็น สถาปัตย์ของ Deep Neural Network ล่ะ เนื่องจากมันมี Hidden Layer เชื่อมต่อหลายชั้นการทำ Normalization แค่อินพุตมันไม่พอแน่ๆฉะนั้นเราจึงต้องทำการ Normalize มันทุกชั้นตามรูป

การทำงานของมันก็ไอ่เจ้า Neural Network จะทำงาน Z = W * X +b จากนั้นจึงไปเข้า Activation Function a = Activation(Z) เราก็จะทำงานตรงชั้นนี้แหละครับ โดยการทำ Normalization Z เป็น Z ~ ก่อนเข้ากระบวนการ Activation ในแต่ละชั้นจะทำเหมือนกันหมดครับ Z –Batch Normalization–>Z~ —-> A —->Z—-Batch Normalization–>Z~ —-> A….

อีกข้อแตกต่างคือคราวนี้เราไม่ได้ Normalization ให้มันมี mean 0 เหมือน normalization ทั่วไปอีกแล้วครับ โดยคราวนี้จะมี Beta (คนละตัวกับ momentum)กับ Gamma เป็นพารามิเตอร์มาเรียนรู้หลังจาก norm มันแล้วอีกต่อหนึงครับ มันจะเรียนรู้จนหาค่า mean ที่เหมาะสมเอาเองดูเข้าท่าเลยใช่ไหมครับถ้าแกะออกมาก็จะประมาณ Z[1]–>norm –>* learnable parameter(Beta Gamma)–>Z~[1]–>a[1]–>Z[2]–>norm –>* learnable parameter(Beta Gamma)–>Z~[2]–>a[2]–>….–>Yhat

แล้วมีพารามิเตอร์เพิ่มมาแบบนี้มันจะทำงานอย่างไรล่ะเนี่ย แหม่ จริงๆแล้วมันก็คล้ายๆมัน W กับ b แหละครับ มีการมาอัพเดต Beta Gamma อีกนั่นแหละครับ มีการหาค่าที่เหมาะสมแบบนี้ย่อมเข้าท่ากว่าทุกชั้น mean 0 เนอะ Batch Normalization สามารถทำงานใน Mini-Batch ได้ด้วย การทำงานก็คือๆกันครับแค่คำนวนบน Mini-Batch นั้นๆ อีกอย่างถ้าเราปรับค่า Learning บน batch normalization แล้วเนี่ย b เราจะตัดทิ้งก็ได้นะครับ เพราะ Beta Gamma ที่คำนวน normalization ของ Z~ เจ้า Beta ได้รับหน้าที่นั้นไปแล้วนั่นเอง

ถ้าเราเทรนรูปแบบด้านซ้ายแมวดำล้วนๆ ละไปเทสกับด้านขวสแมวสีมันก็จะทำงานได้ไม่ดีครับ ถึงแม้ว่าข้อมูลมันจะคล้ายๆกันก็เถอะ เพราะ covariance shift ไปแล้วนั่นเอง หรือ การแจงแจงของข้อมูลมันเปลี่ยนไป

เนี่ยแหละครับ พอเรา Apply เทคนิค Batch Normalization เข้ามามันก็จะทำให้ Mean ของข้อมูลถูกจัดการอย่างเหมาะสมตามรูป อาจารย์แกอาจจะเขียนว่า Mean 0 Variance 1 ก็จริง แต่ทำงานจริงๆไอ่เจ้า Beta Gamma มันจะเรียนค่าที่เหมาะสมระหว่างชั้นให้เองครับ ซึ่งอาจจะไม่ mean 0 variance 1 ก็ได้ แต่มันเหมาะสมก็แล้วกันหน่า!!!

ส่วนตอนเทสโดยใช้เทคนิค Batch Normalization นั้นเราอาจจะไม่มี Mini Batch สำหรับการเทส เราก็จะหา Mean กับ Variance แยกกันตามตัวครับแต่เราก็สามารถเอา Momentum มาช่วยได้นะเออ

softmax

อาจารย์อธิบายเยอะพอควรแต่เพื่อนๆคงรู้จักกันหมดแล้วก็ไม่ต้องพูดเยอะเนอะ สรุปคือที่ neuron ชั้น output จะเห็นว่ามี Classification 4 class แต่ละค่าที่ออกมาก็เยอะบ้างน้อยบ้างแตกต่างกันไป Softmax ก็คือการ หาว่าไอ่ค่าของแต่ละ activation น่ะ ถ้าเอามาคิดเป็นเปอร์เซ็นแล้ว มันมีโอกาสเป็น Class ไหนเท่าไหร่เท่านั้นเองครับ

สมการก็ง่ายๆ e^ค่า Class นั้นๆ /ผลรวมของค่าใน Class ทั้งหมดซึ่งคิดจาก e^ ค่า Class นั้นๆเช่นกันจบครับ!!! แค่นี้แหละ ตัวอย่างที่ Class 0 ตามรูป ได้ค่า 5 แทนค่าในพจน์แรกมันก็ได้ e^5 = 148.4 แล้วของ Class อื่นๆก็ Class 1 = e^2 =7.4, Class 2 = e^2 =0.4, Class 3 = e^2 =20.1 และก็เอามา ค่า Class ที่เราจะคำนวนตั้ง หารด้วย ผลรวมของค่า Class ทั้งหมดผลที่ได้ออกมาย่อมรวมกันได้ 1 ใช่ไหมครับ พอได้แบบนั้นเราก็ได้ Prob แล้วครับว่า ข้อมูลที่เราทำนายออกมา มีโอกาสอยู่ใน Class ไหนกี่เปอร์เซ็น.

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

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

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s