Deep Learning with TensorFlow - Creating the Neural Network Model

หมายเหตุ: บทความนี้เป็นส่วนหนึ่งของ "บทความชุด Article with Machine Translation" ซึ่งเป็นการแปลบทความจากต้นฉบับภาษาต่างประเทศด้วย Machine translation ดังนั้นจึงมีข้อผิดพลาดอยู่หลายจุด ขอให้ผู้อ่านโปรดใช้วิจารณญาณในการอ่าน ทาง EPT ไม่ขอรับประกันว่าข้อมูลที่ท่านได้อ่านเป็นข้อมูลที่ถูกต้อง และไม่ขอรับผิดชอบความเสียหายใด ๆ ที่เกิดต่อผู้อ่านทั้งทางร่างกาย จิตใจ ทรัพย์สิน ฯลฯ นะครับ

การเรียนรู้อย่างลึกซึ้งกับ TensorFlow - การสร้างโมเดลเครือข่ายประสาท

https://youtu.be/BhpvH5DuVu8?list=PLQVvvaa0QuDfKTOs3Keq_kaG2P55YRn5v

ยินดีต้อนรับสู่บทที่ 3 เกี่ยวกับการเรียนรู้ที่ลึกซึ้งเกี่ยวกับเครือข่ายประสาทและ TensorFlow และเป็นบทที่ 45 ของชุดการเรียนการสอน Machine Learning ในการเรียนการสอนนี้ เรากำลังจะลงลึกไปในเรื่องของการสร้างเครือข่ายประสาท ที่ลึกซึ้งโดยตัวเราเองด้วย TensorFlow

เราจะทำงานอย่างแรกด้วยชุดข้อมูล MNIST ซึ่งเป็นชุดข้อมูลที่ประกอบไปด้วย ตัวอย่างการฝึก 60,000 ตัวอย่าง และ 10,000 ตัวอย่างของตัวอย่างการทดสอบ ลายมือและตัวเลขที่ทำเครื่องหมาย 0 ไปจนถึง 9 ดังนั้น ทั้งหมด 10 "classes"

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

ในชุดข้อมูล MNIST มีรูปภาพ ที่เราจะทำงานร่วมกับที่เป็นขาวดำทั้งหมด ที่ถูก ตามเกณฑ์ คือ ภาพที่มีขนาด 28 x 28 หรือทั้งหมด 784 pixels คุณสมบัติของ เราจะเป็นค่า pixel สำหรับแต่ละ pixel ที่ถูกตามเกณฑ์ ทั้งพิกเซล "ว่าง" (ไม่มี อะไรเลย เป็น 0) หรือมีบางอย่างอยู่ (1) นั่นเป็นคุณสมบัติของพวกเรา เรากำลัง พยายามใช้ข้อมูลที่เป็นพื้นฐานอย่างแรกนี้และทำนายตัวเลขที่เรากำลังจะไปดู (0,1,2,3,4,5,6,7,8, หรือ 9) เราหวังว่าบางทีเครือข่ายประสาทของพวกเรา จะสร้างแบบจำลองภายใน ของความสัมพันธ์ระหว่าง pixels และสามารถดู ตัวอย่างตัวเลขใหม่และคาดการณ์พวกมันในระดับสูงได้

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

อย่างแรก เราเอา input data (ข้อมูลขาเข้า) ของเรามาและเราจำเป็นที่จะต้อง ส่งมันไปยัง hidden layer 1 (ชั้นที่ถูกซ่อน 1) ดังนั้น เรา weight input data (ให้นน.ข้อ มูลขาเข้า) แล้วส่งมันไปยัง layer 1 (ชั้นที่ 1) ที่ๆมันจะได้รับ activation function (ฟังก์ชั่นการเปิดใช้งาน) ดังนั้น เซลล์ประสาทสามารถ ตัดสินใจว่าจะยิงหรือส่งข้อมูลบางส่วนไปยังชั้นขาออกหรือเลเยอร์อื่นที่ซ่อนอยู่ หรือไม่ เราจะมี 3 เลเยอร์ ที่ถูกซ่อนในตัวอย่างนี้ ในการทำเครือข่ายประสาทที่ ลึกซึ้งนี้ จาก output ที่เราได้รับ เราจะเปรียบเทียบเอาต์พุตดังกล่าวกับผลลัพธ์ที่ ต้องการ เราจะใช้ cost function (ฟังก์ชั่นค่าใช้จ่าย) (เรียกอีกอย่างหนึ่งว่าฟังก์ชัน การสูญเสีย) เพื่อที่จะกำหนดว่า เราผิดอย่างไร ท้ายที่สุด เราจะใช้ optimizer function (ฟังก์ชั่นตัว optimizer) ใน กรณีนี้ผมใช้ Adam Optimizer เพื่อที่จะลด cost (เราผิดยังไง) วิธีที่ cost จะถูกลด คือ โดยการปรับแต่งด้วยน้ำหนัก โดยมีเป้าหมายอย่างมีความหวังในการลด cost ความเร็วที่เราต้องการลด cost ถูกกำหนดโดย learning rate (อัตราการเรียนรู้) ค่าที่ ต่ำลงสำหรับอัตราการ เรียนรู้จะช้าเท่ากับความช้าที่เราจะได้เรียนรู้และผลลัพธ์ที่เราจะได้รับที่ดีขึ้น ยิ่งอัตราการเรียนรู้สูงเท่าไหร่ เราก็จะเรียนรู้ได้เร็วเท่านั้นและจะทำให้เรามีเวลาใน การฝึกที่เร็วขึ้นแต่อาจจะสร้างความยากลำบากให้กับผลลัพธ์ได้ มีผลตอบแทน ที่น้อยลงที่นี่ คุณไม่เพียงแค่สามารถที่จะลดอัตราการเรียนรู้ลงไปเท่านั้นแต่มันมัก จะดีขึ้นแน่นอน                                                                        

การกระทำของการส่งข้อมูลไปตรงๆผ่านทางเครือข่ายของเรา หมายความว่า เรา กำลังดำเนินการ feed forward เครือข่ายประสาท ในการปรับน้ำหนักถอยหลัง คือ  back propagation ของเรา 

อย่างไรก็ตามเราสามารถทำการ feeding forward และ back propagation ได้หลาย ครั้งอย่างที่เราต้องการ วัฏจักรนี้เรียกว่า epoch เราสามารถหยิบเลขไหนๆก็ได้ที่เรา ชอบสำหรับหมายเลขของ epochs แต่คุณอาจจะต้องหลีกเลี่ยงการทำที่มากเกินไป เพราะมันทำให้เกิด overfitment 

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

เข้าใจมั้ย? เยี่ยม! เตรียมตัวสำหรับการ launch!

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

เรานำเข้า TensorFlow และข้อมูลตัวอย่างที่เรากำลังจะใช้ โน๊ตว่า one_hot parameter ที่นั่น  คำที่มาจากอุปกรณ์อิเล็กทรอนิกส์ที่มีเพียงองค์ประกอบเดียว จากอัน อื่นๆ โดยทางอักษร คือ "hot," หรือเปิด สิ่งนี้มีประโยชน์มากสำหรับภาระ งานการจัดกลุ่มแบบหลายๆคลาส ซึ่งเรามีที่นี่ (0,1,2,3,4,5,6,7,8, หรือ 9) ดังนั้น แทนที่จะให้เอาท์พุทของ 0 เป็นเพียง 0 และ 1 1
เรามีบางอย่างที่มากขึ้นแบบนี้ :

ดังนั้น เรามีข้อมูลของเรา ผมเลือกที่จะใช้ชุดข้อมูล MNIST เพราะว่ามันเป็นชุด ข้อมูลที่เหมาะสมที่จะเริ่มต้นด้วยและจริงๆแล้วยังเก็บสะสมข้อมูลดิบและการ แปลงให้เป็นสิ่งที่ต้องใช้ร่วมกันซึ่งอาจใช้เวลามากกว่าการสร้างโมเดล machine learning ด้วยตัวมันเองและผมคิดว่าผู้คนส่วนใหญ่ที่นี่ต้องการที่จะเรียนรู้เครือข่าย ประสาทไม่ใช่ web scraping และนิพจน์ธรรมดา

ตอนนี้เรากำลังจะเริ่มต้นสร้างโมเดลกัน :

เราเริ่มต้นโดยการระบุว่าจะต้องมี nodes กี่อันที่ในแต่ละเลเยอร์ที่ถูกซ่อนต้องมี ต้องมี classes ทั้งหมดกี่ classes ที่ชุดข้อมูลของเราต้องมีและขนาดของ batch ของเราจะต้องเป็นเท่าไหร่ ขณะที่คุณ *สามารถ* ในทฤษฎีการฝึกเครือข่าย ทั้งหมดในครั้งเดียว แต่มันทำแบบนั้นในครั้งเดียวไม่ได้! หลายๆคนอาจจะมี คอมพิวเตอร์ที่สามารถรองรับชุดข้อมูล MNIST แบบฉบับเต็มแต่หลายๆคนก็ไม่มี คอมพิวเตอร์หรือการเข้าถึงคอมพิวเตอร์ที่สามารถทำชุดข้อมูลที่มีความสมจริงทั้ง หมดได้ในครั้งเดียว ดังนั้น เราต้องทำการ optimization ใน batches ในกรณีนี้ เราจะทำ batches ของ 100

นี่เป็นตัวยึดของเราสำหรับค่าบางค่าในกราฟของเรา จำได้มั๊ยที่คุณสร้างโมเดลใน กราฟ TensorFlow ของคุณ จากตรงนี้ TensorFlow ควบคุมทุกสิ่งทุกอย่าง ไม่ใช่ คุณ สิ่งนี้จะเห็นได้ชัดมากยิ่งขึ้นเมื่อเราทำเสร็จและคุณพยายามที่จะหาที่ๆจะ เปลี่ยนแปลงน้ำหนัก! สังเกตว่าผมได้ใช้ [None,784] เป็น parameter อันดับ 2 ใน ตัวยึดอันแรก นี่เป็น parameter ที่ไม่ได้สำคัญมากนัก อย่างไรก็ตามมันเป็น ประโยชน์มากเพื่อให้มันชัดเจนแบบนี้ ถ้าคุณยังไม่ชัดเจน TensorFlow จะมีอะไร อยู่ในนั้น ถ้าคุณแจ่มแจ้งแล้วเกี่ยวกับรูปร่าง TensorFlow จะแจ้งข้อผิดพลาด ถ้าบางสิ่งบางอย่างออกจากรูปร่างและพยายามที่จะกระโดดเข้าไปในสถานที่ของ ตัวแปรนั้น

ขณะนี้เรามีค่าคงที่และค่าเริ่มต้นแล้ว ต่อไปเราจะสร้างโมเดลเครือข่ายประสาท จริงๆแล้ว :

def neural_network_model(data):
    hidden_1_layer = {'weights':tf.Variable(tf.random_normal([784, n_nodes_hl1])),
                      'biases':tf.Variable(tf.random_normal([n_nodes_hl1]))}

    hidden_2_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
                      'biases':tf.Variable(tf.random_normal([n_nodes_hl2]))}

    hidden_3_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
                      'biases':tf.Variable(tf.random_normal([n_nodes_hl3]))}

    output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
                    'biases':tf.Variable(tf.random_normal([n_classes]))}

ที่นี่ เราจะเริ่มต้นกำหนดน้ำหนักของเราและ…ไปเรื่อยๆ รอสักครู่ อะไรคือ biases เหล่านี้ !? bias คือ ค่าที่ถูกเพิ่มเข้าไปในการบวกของเราก่อนที่จะถูกส่งไปยัง ฟังก์ชั่นการเปิดใช้งาน อย่าสับสนกับ bias node ซึ่งก็เป็นแค่ node ที่เปิดตลอด เวลา จุดประสงค์ของ bias ที่นี่ โดยหลักคือเพื่อรองรับสถานการณ์ที่เซลล์ประสาท ทั้งหมดยิง 0 ไปยังเลเยอร์ bias ทำให้มันเป็นไปได้ว่าเซลล์ประสาทยังคงยิงไปยัง เลเยอร์นั้นๆ bias มีลักษณะเฉพาะโดดเด่นพอๆกับน้ำหนักและจำเป็นที่จะ ต้องถูก optimization ด้วย        

สิ่งที่เราได้ทำจนสำเร็จมาจนถึงตอนนี้ คือ สร้างคำจำกัดความเริ่มต้นสำหรับน้ำหนัก และ biases ของพวกเรา คำจำกัดความเหล่านั้นเป็นค่าที่สุ่มขึ้นมา สำหรับรูปร่างที่ เลเยอร์ของเมทริกซ์ควรจะเป็น (สิ่งนี้คือสิ่งที่ tf.random_normal ทำเพื่อเรา มัน แสดงผลค่าที่สุ่มขึ้นมาสำหรับรูปร่างที่เราต้องการ) ไม่มีอะไรเกิดขึ้นจริงและไม่มี การไหล (feed forward) ที่เกิดขึ้น มาทำให้มันไหลกันเถอะ :

l1 = tf.add(tf.matmul(data,hidden_1_layer['weights']), hidden_1_layer['biases'])
    l1 = tf.nn.relu(l1)

    l2 = tf.add(tf.matmul(l1,hidden_2_layer['weights']), hidden_2_layer['biases'])
    l2 = tf.nn.relu(l2)

    l3 = tf.add(tf.matmul(l2,hidden_3_layer['weights']), hidden_3_layer['biases'])
    l3 = tf.nn.relu(l3)

    output = tf.matmul(l3,output_layer['weights']) + output_layer['biases']
ที่นี่เราเอาค่าไปใส่ยังเลเยอร์ 1 ค่าเหล่านั้นคืออะไร ? พวกมัน คือ การคูณของ ข้อมูลขาเข้าดิบที่ถูกคูณโดยน้ำหนักที่เฉพาะตัวของพวกเขา (เริ่มต้นด้วยการสุ่ม แต่จะต้องถูก optimization) : tf.matmul(l1,hidden_2_layer['weights']) ต่อไป เราก็จะไปเพิ่มด้วยไบแอส tf.add เราทำการดำเนินการนี้ซ้ำสำหรับแต่ละเลเยอร์ที่ ถูกซ่อนไปตามทางที่ไปยัง output ของเรา ที่ๆเราจะมีค่าสุดท้ายที่ยังคงทำการคูณ ของ input และน้ำหนัก บวกกับค่า output layer's bias อยู่

เมื่อเสร็จแล้ว เราก็กลับไปยังเลเยอร์ output นั้น ดังนั้น ตอนนี้เราได้จำลองเครือ ข่ายแล้วและเกือบจะเสร็จกราฟการคำนวณทั้งหมดแล้ว ในการเรียนการสอน ต่อไป เราจะสร้าง function ที่รันและฝึกเครือข่ายด้วย TensorFlow

ที่นี่มี 2 quiz/question(s) สำหรับการเรียนการสอนนี้ https://pythonprogramming .net/+=1/ เพื่อเข้าถึงสิ่งเหล่านี้ ดาวน์โหลดวิดีโอและไร้โฆษณาด้วย

การเรียนการสอนต่อไป : https://pythonprogramming.net/tensorflow-neural-net work-session-machine-learning-tutorial/?completed=/tensorflow-deep-neural-network-machine-learning-tutorial/

References : https://pythonprogramming.net/tensorflow-deep-neural-network-machine-learning-tutorial/