สำหรับคนขี้เกียจอ่าน

Deep Learning

แบบง่าย แทบไม่มีสมการ :)

Deep Learning คือการกลับมาครั้งใหม่ของ neural network โดยคราวนี้เน้นที่โครงสร้างที่ลึกกว่าก่อนมาก และที่เป็นไปได้ตอนนี้เพราะ

  1. เรามีข้อมูลเยอะพอ พวก big data ที่คนพูดๆ กัน
  2. เรามีอุปกรณ์คำนวณที่เหมาะสมนั่นคือ GPU card สำหรับคำนวณ และ
  3. เรามีเทคนิคในการ train network ที่มีโครงสร้างที่ลึกได้

สำหรับคนขยันอ่าน เชิญอ่านต่อได้ :)

Neural network (NN) หรือ neuralnet หรือ artificial neural network หรือโครงข่ายประสาทเทียม เป็นแบบจำลองการทำงานของโครงข่ายประสาทจริง ในโครงข่ายประสาทจริงนั้นเซลล์ประสาทต่างก็เชื่อมต่อกัน แต่ละเซลล์รับกระแสประสาทจากเซลล์ข้างเคียงผ่านแขนงประสาท เมื่อแอมพลิจูดของสัญญาณที่รับมาสูงพอจะเกิดการชักนำให้เซลล์นี้สร้างกระแสประสาทใหม่และส่งออกไปให้เพื่อนบ้าน แนวความคิดนี้นำไปสู่แบบจำลองเซลล์ประสาทเทียม เซลล์เดียว

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

f(x1,x2,…,xn,w1,…,wn) = g( x1*w1 + x2*w2 + … + xn*wn )

เมื่อ x1,…,xn เป็นสัญญาณเข้าจากเซลล์เพื่อนบ้าน w1,…,wn เป็นค่าถ่วงน้ำหนักของแขนงประสาท และ g เป็น activation function หรือ transfer function หรือฟังก์ชันแปลงสัญญาณที่รับเข้ามาก่อนจะส่งค่าออก ซึ่งหนึ่งใน transfer function นี้ก็คือ sign function นั่นคือ g(t)=1 เมื่อ t≥0 และ g(t)=-1 เมื่อ t<0

เราสามารถเขียนฟังก์ชันข้างบนนี้ให้กระชับได้อีกในรูปเวคเตอร์ โดยเวคเตอร์ x เป็นเมตริกซ์ที่มี 1 สดมภ์ และมี n แถวโดยแถวที่ i ก็เก็บค่าของ xi ให้ w เป็นเวคเตอร์ของค่าถ่วงน้ำหนัก ฟังก์ชันของแบบจำลองเซลล์ประสาทเดี่ยวอย่างง่ายข้างบนนี้ก็เขียนได้ใหม่เป็น

f( x, w) = sign(⟨ x, w⟩)

จะเห็นว่าค่าส่งออกของ f นั้นเป็นได้เพียง 1 หรือ -1 นั่นคือ f สามารถจำแนกประเภทของได้เพียง 2 ประเภท หรือ 2 คลาส แต่ในทางปฏิบัติหากเราต้องการจำแนกของ 3 ประเภทเราก็ยังสามารถทำได้โดยใช้ฟังก์ชัน f กับค่าถ่วงน้ำหนักที่ต่างกันออกไป เช่นให้ w(0,1) เป็นค่าถ่วงน้ำหนักสำหรับแยกประเภท 0 และ 1 และให้ w(0,2), w(1,2) เป็นค่าถ่วงน้ำหนักสำหรับแยกประเภท 0 และ 2 และระหว่าง 1 และ 2 ตามลำดับ เราสามารถตั้งกฎง่ายๆ เช่นหาก f(x,w(0,1))=1 และ f(x,w(0,2))=1 แล้วให้ตอบคลาส 0 เป็นต้น

คำถามตอนนี้คือแล้วเราควรจะเลือกค่าถ่วงน้ำหนักเหล่านี้อย่างไร? คำตอบคือจากขั้นตอนการ train บนชุดฝึกสอน (training data) ตัวอย่างขั้นตอนการ train ก็คืออัลกอริธึ่มชื่อ เปอร์เซปตรอน (Perceptron)

สมมติว่า w เป็นค่าถ่วงน้ำหนักปัจจุบันและข้อมูลสอนที่เรามีคือ (x,y) เมื่อ x เป็นเวคเตอร์สัญญาณที่รับมา และ y เป็นคลาสของมันที่เราต้องการให้ทำนายถูก อัลกอริธึมเปอร์เซปตรอนบอกว่า หาก f(x,w)=y แล้ว เราไม่ต้องทำอะไร แต่ถ้าไม่เท่ากันให้ปรับ w โดย

ww + y x

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

เรามีแบบจำลองของเซลล์ประสาทพร้อมอัลกอริธึมในการสอนแล้วแต่มันก็ยังมีข้อจำกัดอยู่ ข้อจำกัดนี้มาจากตัวแบบจำลองเอง หากเราพิจารณาฟังก์ชัน f เราจะเห็นว่ามันเกิดจากการเอาค่านำเข้า x1,…,xn มาคูณกับค่าถ่วงน้ำหนัก w1,…,wn และบวกกัน เราเรียกกระบวนการนี้ว่าเป็น linear combination และฟังก์ชัน f นั้นก็คือ linear classifier ซึ่งเส้นแบ่งระหว่างคลาสที่มันสามารถทำได้ก็มีเพียงเส้นแบ่งแบบเส้นตรง หรือระนาบเกิน (hyperplane) ในปริภูมิหลายมิติ ถ้าขอบเขตระหว่างคลาสไม่ใช่เส้นตรงแบบจำลองนี้ก็ไม่สามารถจำแนกได้ถูกเสมอไป

ข้อจำกัดนี้ทำให้ความสนใจเกี่ยวกับ NN นั้นตกลงไป ประจวบกับในยุคนั้นซึ่งเป็นตอนต้นของ AI ผู้คนต่างคาดหวังกับ AI ไว้สูงมาก ซึ่งก็ต่างผิดหวังเพราะมันให้ผลที่แย่ในการใช้งานจริงหรือไม่สามารถใช้งานได้เลย เทคนิค AI ในยุคเริ่มต้นนี้คือพวก symbolic AI ซึ่งใช้ logic ในการ infer ผลต่างๆ กับพวกเทคนิคการค้น search space สำหรับหาคำตอบที่ดีที่สุดเช่น A* เป็นต้น

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

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

สมมติว่าเรามีฟังก์ชัน 1 ตัวแปร E(z) ที่เราต้องการหาค่า z ที่ทำให้ E(z) สูงสุด วิธีหนึ่งที่ทำได้ง่ายคือทำการปรับค่า z ตามค่าอนุพันธ์ (derivative) E’(z) ไปเรื่อยๆ 
สำหรับฟังก์ชันหลายตัวแปรก็เช่นกัน แต่ในกรณีนี้เรามีค่าอนุพันธ์หลายค่า ขึ้นกับเราพิจารณาตัวแปรใด สำหรับตัวแปรหนึ่งๆ เราสามารถคำนวณอนุพันธ์ย่อย (partial derivative) ได้โดยการมองตัวแปรอื่นเป็นค่าคงที่แล้วคำนวณค่าอนุพันธ์ของตัวแปรนี้ หากเรามีตัวแปร n ตัว เราก็จะมีอนุพันธ์ย่อย n ค่า ซึ่งเราเก็บค่าเหล่านี้ไว้ในเวคเตอร์ n มิติที่เรียกว่าแกรเดียนต์ (gradient)

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

ในส่วนการคำนวณแกรเดียนต์นั้นมีหลายทีมที่ได้ค้นพบอัลกอริธึม backprop หรือชื่อเต็มคือ error back-propagation ได้ในเวลาไล่เลี่ยกันเพราะจริงๆ แล้วแนวความคิดหลักของมันก็ไม่ได้ยากนัก เป็นสิ่งที่เราเรียนมาตั้งแต่มัธยมปลาย นั่นคือ chain rule

หากเรามี h(x) = f(g(x)) แล้ว h’(x) = f’(g(x))g’(x)

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

จุดเด่นอีกอย่างของ backprop คือสามารถใช้ได้กับโครงสร้างของ NN แบบใดก็ได้ ขอเพียงเรารู้ว่าแต่ละโหนดรับข้อมูลจากเพื่อนบ้านโหนดใด และส่งข้อมูลออกไปให้เพื่อนบ้านโหนดใด ก็พอแล้ว จากจุดนี้ทำให้มีการทดลองทำ NN ที่มีโครงสร้างแปลกๆ ออกไป เช่น Autoencoder ที่มีจำนวนเซลล์ชั้นนำเข้าเท่ากับชั้นส่งออก และมีเซลล์ชั้นกลางหรือชั้นซ่อนเร้น (hidden layer) น้อยกว่า เพื่อใช้ในการบีบอัดและสร้างคืนข้อมูลแบบไม่เป็นเส้นตรง (non-linear encoding and decoding) หรือพวก Recurrent NN (RNN) ที่เอาข้อมูลบางส่วนที่ทำนายมาใช้ในการทำนายครั้งต่อไป เพื่อใช้ในการประมวลผลข้อมูลเชิงลำดับเวลาเช่นเสียงพูดหรือข้อความที่เป็นสายอักขระเป็นต้น

ผลการใช้งาน NN ที่มีโครงสร้างแปลกๆ เหล่านี้ก็ดีบ้างแย่บ้าง แต่โดยรวมแล้วโครงสร้างที่ง่ายสุดที่ให้ผลดีที่ใช้กันก็คือโครงสร้างที่มี 3 ชั้น คือชั้นนำเข้า ชั้นซ่อนเร้น และชั้นส่งออก โดยตัวแปรที่เราปรับก็คือจำนวนโหนดบนชั้นซ่อนเร้น หนึ่งในเหตุผลที่ทำให้โครงสร้างง่ายๆ นี้ให้ผลที่ดีกว่าก็คือในการคำนวณ backprop นั้นค่าของแกรเดียนต์ของชั้นล่างๆ นั้นเกิดจากการคูณทับหลายรอบของค่าที่มีขนาดต่ำกว่า 1 ดังนั้นแอมพลิจูดของแกรเดียนต์เหล่านี้จึงน้อยมาก ไม่พอให้ทำการปรับ ผลที่เกิดขึ้นก็คือในกรณีที่เราใช้ NN ที่โครงสร้างลึกมากชั้นแรกๆ ที่แทบไม่ถูกปรับจะทำตัวเหมือน การฉายสุ่ม หรือ Random Projection (RP) โดยรวมแล้ว NN แบบนี้จึงเปรียบได้กับ NN แบบตื้นที่ทำงานบนข้อมูลที่ถูกฉายสุ่มมา ซึ่ง RP นี้ทำให้เกิดการเสียข้อมูลบางส่วนไปดังนั้นในหลายๆ ครั้งผลที่ได้จึงไม่ดีเท่ากับที่ได้จากโครงสร้างตื้นที่ทำงานกับข้อมูลเดิมโดยตรง

อย่างไรก็ดีเราก็มีงานวิจัยทางทฤษฎีหลายงานที่บอกว่าโครงสร้างตื้นเพียง 3 ชั้นนี้เพียงพอสำหรับการประมาณค่าฟังก์ชันทั่วไปใดๆ ก็ได้ (NN เป็น universal approximator) หากเรามีจำนวนโหนดในชั้นซ่อนเร้นมากพอ ในทางปฏิบัตินั้นจำนวนโหนดบนชั้นซ่อนเร้นนั้นมักได้จากการทดลองปรับ trial and error ซึ่งกินเวลานาน

อีกกระบวนการที่กินเวลานานเช่นกันคือขั้นตอนการ train ของ NN นั้นอิงการปรับค่าถ่วงน้ำหนักตามข้อมูลแกรเดียนต์ซึ่งเป็นข้อมูลที่ local มากๆ นั่นคือทิศทางที่ได้มักมีประโยชน์เฉพาะใกล้ๆ กับค่าปัจจุบัน ดังนั้นเราจึงต้องทำการปรับนี้ซ้ำๆ หลายๆ รอบมากกว่าที่ NN จะเจอค่าถ่วงน้ำหนักที่เหมาะสมสำหรับชุดข้อมูลสอนที่มี 
นอกจากนี้เนื่องจากแกรเดียนต์เป็นข้อมูล local ทำให้ค่าที่เราได้อาจเป็นเพียงจุดดีที่สุดในแถวนั้น (local optimum) แต่ไม่ใช่จุดดีที่สุดจริง (global optimum) 
มีหลายๆ งานที่เสนอกระบวนการปรับแกรเดียนต์ให้มีความเสถียรมากขึ้น หรือเอาข้อมูลของแกรเดียนต์ก่อนหน้ามาใช้ร่วมด้วย
การปรับค่า learning rate นั่นคือขนาดของก้าวที่เราจะทำการปรับในแต่ละครั้งก็สำคัญมีหลายวิธีที่ถูกเสนอมาสำหรับปรับแบบอัตโนมัติ

การปรับส่วนประกอบต่างๆ ที่จำเป็นเพื่อทำให้การ train NN นั้นเป็นไปได้ด้วยดีนั้นค่อนข้างละเอียดอ่อน บางคนมองว่าเกือบเป็นงานศิลป์ด้วยซ้ำ มีการรวบรวมกระบวนการเหล่านี้ไว้ในบทความสรุปที่น่าสนใจชื่อ “Efficient Backprop”

จุดเปลียนของ NN มาจากแบบจำลองใหม่ที่ชื่อ Support Vector Machine (SVM) ที่เป็นการขยายแนวความคิดของ linear classifier อีกแบบ ที่ไม่ได้เอาเปอร์เซปตรอนมาต่อกัน แต่อาศัยฟังก์ชันคณิตศาสตร์ที่เรียกว่า เคอร์แนล (kernel function) ในการจัดการกับขอบเขตที่ไม่เป็นเส้นตรง

จุดเด่นอีกอย่างของ SVM คือกระบวนการ train นั้นถูกตั้งให้อยู่ในรูปการแก้ปัญหาแบบมีข้อแม้ ที่มีฟังก์ชันจุดประสงค์เป็นฟังก์ชันกำลังสอง (quadratic constrained optimization) ซึ่งทำให้เราสามารถประยุกต์ใช้กระบวนการ optimize ต่างๆ ได้ง่าย และยังสามารถตรวจสอบได้อีกว่าเราค่าที่ได้นั้นดีที่สุดหรือไม่ ซึ่งนับว่าง่ายกว่าการ train NN อย่างมาก

ในปี 1995 มีบทความที่น่าสนใจมากอันหนึ่งคือ “Comparison of learning algorithms for handwritten digit recognition” ที่มีผลการทดลองรู้จำลายมือเขียน โดยเปรียบเทียบ learning algorithm หลายแบบ รวมทั้ง NN แบบพิเศษที่เรียกว่า Convolutional NN (CNN) และ SVM ที่ในบทความใช้ชื่อว่า Optimal Margin Classifier และใช้เคอร์แนลพหุนาม (polynomial kernel) สิ่งที่น่าสนใจพิเศษสำหรับผมคือในตอนท้ายบทความคณะผู้เขียนเขียนไว้ว่าถ้าเราทำการสลับลำดับของ pixel ในภาพนำเข้าแบบสุ่ม SVM ก็ยังคงให้ผลที่เหมือนเดิม ในขณะที่ CNN นั้นจะให้ผลที่แย่ลง นั่นแปลว่า SVM นั้นยังไม่ต้องใช้ความรู้เบื้องต้น (prior knowledge) เกี่ยวกับ domain ที่ใช้งานก็สามารถให้ผลลัพธ์ที่ดีแล้ว

ในช่วง 10 กว่าปีต่อมางานวิจัยในกลุ่ม Machine Learning ก็เทกันไปทาง SVM และแบบจำลองที่อิงเคอร์แนลกันหมด และผลที่ได้จากงานกลุ่มนี้ก็กลายเป็น state of the art ในหลายๆ ด้าน 
จริงๆ แล้วในหลายๆ งาน NN ก็ยังให้ผลดีอยู่ แต่ผลดีที่สุดก็ไม่ได้ต่างกันมากนัก และดูเหมือนกับว่าผลที่ได้จากหลายๆ งานนั้นตัน เราไม่รู้จะเพิ่มความแม่นยำอย่างไรแล้ว

NN ยุคสาม: หลายๆๆๆๆ ชั้น

ปี 2006 มีบทความที่ถือได้ว่าเป็นจุดเปลี่ยนของ NN คือ “A fast learning for deep belief nets” แนวความคิดหลักของบทความนี้คือเราสามารถสร้าง NN ที่มีโครงสร้างลึกได้โดยการ train ทีละชั้นและนำมาต่อกัน ตอนนี้เราเรียกกระบวนการนี้ว่าเป็นการทำ pre-training ซึ่งทำให้ได้ค่าถ่วงน้ำหนักที่ไม่ใช่ค่าสุ่มจริงๆ ดังนั้นถึงแม้ว่าแกรเดียนต์ของชั้นล่างๆ จะมีขนาดเล็กไม่พอสำหรับการปรับ แต่เราก็ยังมีโครงสร้างที่ให้ค่าที่มีความหมายอยู่ ไม่ใช่การฉายสุ่มเหมือนก่อน ซึ่งโครงสร้างที่ได้จากกระบวนการนี้ก็ให้ผลที่ดีกว่าจริง

NN ที่ใช้ในบทความข้างบนนี้ชื่อ Restricted Boltzmann Machine (RBM) ซึ่งเป็น NN ที่แปลก ผมเคยเห็นผ่านๆ ในหนังสือ ไม่เคยเห็นคนใช้มาก่อน เป็น อ.ประภาส บอกว่ามันเป็น NN ในยุคอนาลอก ตอนต้นของคอมพิวเตอร์เลยด้วยซ้ำ 
ถึงแม้ว่า RBM จะไม่ใช่ NN แบบทั่วไป เราก็ยังสามารถ “ตีความ” การคำนวณของมันได้ ว่ามันทำการบีบอัดและสร้างคืนข้อมูล ดังนั้นในเวลาไม่นานนักก็มีคนเสนอให้เอา Autoencoder มาต่อกันเป็นโครงสร้างลึกอีกแบบหนึ่งซึ่งให้ผลดีกว่าการสร้างรวดเดียว งานเหล่านี้ทำให้คนเริ่มหันมาสนใจ NN ใหม่อีกครั้ง

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

ในช่วงถัดจากปี 2006 มีจุดเปลี่ยนอีกอันหนึ่งคือการใช้ GPU ในการคำนวณ ซึ่งทำให้เราสามารถประมวลผล NN ได้เร็วขึ้นอีก โดยเฉพาะ Convolutional Neural Network (CNN) ซึ่งอิงการทำ Convolution ที่เราสามารถมองได้ว่าเป็นการตรวจหาลักษณะเด่น local ในภาพ จุดเด่นของ CNN ก็คือตัวแปรของชั้น Convolution นี้ถูก train ไปพร้อมๆ กับส่วนอื่นของ NN ทำให้ได้ลักษณะเด่นที่เหมาะกับงานจริง
ข้อเสียคือการประมวลผลบน CNN นั้นช้ามาก จริงๆ แล้ว CNN ได้ถูกเสนอมาตั้งแต่ ~1990 แต่มีการใช้งานที่จำกัด จำได้ว่าเคยเห็นว่า AT&T สมัยนั้นก็มีการทำชิปเฉพาะสำหรับ CNN แต่ก็ขายยากเพราะไม่สามารถเสียบใช้กับคอมพิวเตอร์ได้ทันที การ train CNN บนเครื่องปกติก็ช้ามากทำให้คนไม่ค่อยใช้กัน เมื่อเราสามารถคำนวณ CNN บน GPU ได้ก็ทำให้คนหันมาสนใจมันมากขึ้น

จริงๆ แล้ว CNN ก็นับว่ามีโครงสร้างที่ลึกอยู่แล้ว แต่ไม่มีปัญหาของแกรเดียนต์ และไม่ต้องการการทำ pre-training เพราะกระบวนการ Convolution นั้นเป็นการ share ค่าถ่วงน้ำหนักในหลายๆ ตำแหน่งในภาพนำเข้าทำให้เวลาเราคำนวณแกรเดียนต์เราก็ต้องทำการรวมค่าแกรเดียนต์ที่หลายตำแหน่ง ทำให้ค่าที่ได้นั้นใหญ่พอให้ทำการปรับค่าถ่วงน้ำหนักได้อย่างเหมาะสม การมาถึงของ GPU ทำให้ CNN กลับมาบูมอย่างมาก โดยเฉพาะหากดูจากงานแข่ง image recognition เช่น ImageNet

งานแข่ง ImageNet Large Scale Visual Recognition Contest นั้นจัดมาตั้งแต่ปี 2010 ซึ่งหากดูจากทีมที่ชนะเลิศแล้วเราสามารถเห็นจุดเปลี่ยนหลักๆ ได้ 2 ครั้ง ครั้งแรกช่วง 2011–2012 ที่มีการนำเอา CNN มาใช้ครั้งแรกทำให้ error ลดลงเกือบ 10% และครั้งที่ 2 ช่วง 2013–2014 จากการเพิ่มจำนวนชั้นของ CNN ปี 2013 นั้น CNN ส่วนมากมี 7–8 ชั้น ในขณะที่ปี 2014 มี >20 ชั้น และในปีนี้เรามี CNN >100 ชั้นไปแล้ว 
จุดที่น่าสนใจอันหนึ่งคือในขณะที่โครงสร้างปัจจุบันนั้นลึกขึ้นเรื่อยๆ จำนวนของค่าถ่วงน้ำหนักโดยรวมกลับลดลง CNN ที่ชนะปี 2012 มี 7 ชั้นแต่มีตัวแปรที่ต้องปรับถึง 60 ล้านค่า ในขณะที่ Residual CNN ในปัจจุบัน 110 ชั้นมีตัวแปรเพียง 1.7 ล้านตัวเท่านั้น

จุดเปลี่ยนอีกอันหนึ่งของ Deep Learning คือเมื่อต้นปี 2016 ที่ AlphaGO ได้เอาชนะนักเล่นโกะชั้นนำของโลกที่ทำให้คนยิ่งหันมาศึกษาเรื่องนี้เพิ่มอีก 
สิ่งที่น่าสนใจอีกอย่างคือ AlphaGO นั้นมีองค์ประกอบหลายส่วนแต่ที่น่าสนใจคือส่วน CNN ที่ใช้ในการเลือกตาเดินถัดไปนั้นมีเพียง 10 กว่าชั้นเท่านั้นทั้งๆ ที่การเล่นโกะดูจะยากกว่าการทำ image recognition ใน ImageNet อีก

กระแส Deep Learning นี้ทำให้โครงสร้าง NN อื่นก็กลับมาได้รับความสนใจอีก เช่น Long Short-Term Memory (LSTM) network ซึ่งเป็น Recurrent NN (RNN) แบบหนึ่งที่ถูกออกแบบมาเพื่อแก้ปัญหาของค่าแกรเดียนต์เช่นกัน LSTM นี้ถูกเสนอมาตั้งแต่ปี 1997 แล้ว แต่ก็ไม่ได้มีการใช้งานที่แพร่หลาย

ใน RNN นั้นเราเอาข้อมูลที่ส่งออกจากโหนดกลับมาเป็นข้อมูลนำเข้าใหม่ ดังนั้นในการทำ Backprop เราต้องทำการคลี่การคำนวณออกด้วย ที่เรียกว่า Back-propagation through time ซึ่งแปลว่าถ้าเราเอา RNN ที่มีโหนดเดียวไปประมวลผลลำดับที่ยาวมาก สุดท้ายแล้วแกรเดียนต์ที่ถูกส่งย้อนกลับมาจากตำแหน่งปลายของลำดับก็มีค่าน้อยเช่นกัน ผลคือ RNN นี้จะไม่สามารถจับความสัมพันธ์ระยะยาวในลำดับได้ แบบจำลอง RNN จึงถูกแซงไปโดยแบบจำลองพวก Markov เช่น Markov chain หรือ Hidden Markov Model

บทความแรกๆ ของ LSTM นั้นอ่านแล้วปวดหัวมาก (ใครมาอธิบายได้ ผมจะเลี้ยงกาแฟเลย) แต่เท่าที่เข้าใจจากการอ่านหลายๆ บทความพอจะสรุปได้ว่าค่าที่ส่งออกจากแต่ละโหนดของ LSTM นั้นจะมี 2 ทาง​ ทางหนึ่งที่ผ่าน non-linear transfer function อีกทางหนึ่งไม่ผ่าน และเราจะนำเอาค่าทั้งสองทางนี้มาบวกกัน การมีเส้นทางเพิ่มนี้ทำให้การส่งแกรเดียนต์ย้อนกลับนั้นทำได้สะดวกขึ้นผ่านเส้นทางที่ไม่มี non-linear transfer function ดังนั้น LSTM จึงสามารถจับความสัมพันธ์ระยะยาวได้ดีกว่า RNN ปกติ

แนวความคิดคล้ายๆ กันนี้ก็ได้ถูกนำมาประยุกต์ใช้เพื่อสร้าง CNN ที่มีความลึกมากขึ้นเช่น Highway Network หรือ Residual CNN เป็นต้น

กระแส Deep Learning ยังทำให้คนหันกลับมาศึกษารายละเอียดเกี่ยวกับ NN เพิ่มอีกทำให้ตอนนี้เรามีส่วนประกอบใหม่ๆ เช่นตอนนี้เรามี transfer function ใหม่ชื่อ Rectified Linear Unit (ReLU) ที่ให้ผลดี บางคนยังเชื่อด้วยว่าถ้าใช้ ReLU ใน NN ปกติแล้วขั้นตอนการทำ pre-training ก็ไม่จำเป็นอีกต่อไป, เรามีขั้นตอนการ regularize NN แบบใหม่ที่เรียกว่า Drop out, เรามีชั้นซ่อนเร้นพิเศษสำหรับทำ Batch Normalization ที่ทำให้ผลดีขึ้น เป็นต้น แต่ก็ยังมีส่วนที่เราไม่รู้อีก หลักๆ เลยคือเรื่องการเลือกโครงสร้าง NN

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