เทคโนโลยี
ตั้งแต่การแก้สมการไปจนถึงการเรียนรู้เชิงลึก: บทช่วยสอน TensorFlow Python
เมื่อเร็ว ๆ นี้มีการพัฒนาที่น่าทึ่งบางอย่างในโลกของปัญญาประดิษฐ์ตั้งแต่ความก้าวหน้าที่ได้รับการเผยแพร่อย่างมากกับรถยนต์ที่ขับเคลื่อนด้วยตนเองไปจนถึงเครื่องจักร แต่ง Chopin การเลียนแบบหรือ แค่เก่งในวิดีโอเกม .
ศูนย์กลางของความก้าวหน้าเหล่านี้มีอยู่หลายประการ เครื่องมือ เพื่อช่วยให้ได้มาซึ่งการเรียนรู้เชิงลึกและโมเดลการเรียนรู้ของเครื่องอื่น ๆ โดยมี Torch, Caffe และ Theano เป็นหนึ่งในผู้ที่อยู่ข้างหน้า อย่างไรก็ตามเนื่องจาก Google Brain เปิดตัวโอเพ่นซอร์สในเดือนพฤศจิกายน 2015 ด้วยกรอบงานของตนเอง TensorFlow เราจึงได้เห็นความนิยมของไลบรารีซอฟต์แวร์นี้เพิ่มสูงขึ้นจนเป็นกรอบการเรียนรู้เชิงลึกที่ได้รับความนิยมมากที่สุด
เหตุใดจึงเกิดขึ้น เหตุผลรวมถึงการสนับสนุนและเอกสารที่มีอยู่มากมายความพร้อมในการผลิตความสะดวกในการกระจายการคำนวณไปยังอุปกรณ์ต่างๆและเครื่องมือแสดงภาพที่ยอดเยี่ยม: TensorBoard .
ท้ายที่สุดแล้ว TensorFlow สามารถรวมชุดคุณสมบัติทางเทคนิคที่ครอบคลุมและยืดหยุ่นเข้ากับการใช้งานที่ง่ายมาก
ในบทความนี้คุณจะได้รับความเข้าใจเกี่ยวกับกลไกของเครื่องมือนี้โดยใช้มันเพื่อแก้ปัญหาตัวเลขทั่วไปซึ่งไม่ได้เกี่ยวข้องกับการเรียนรู้ของเครื่องก่อนที่จะแนะนำการใช้งานในการเรียนรู้เชิงลึกด้วยการใช้เครือข่ายประสาทเทียมแบบง่ายๆ
ก่อนเริ่มต้น
ถือว่ามีความรู้พื้นฐานเกี่ยวกับวิธีการเรียนรู้ของเครื่อง หากคุณต้องการติดตามลองดูสิ่งนี้มีประโยชน์มาก โพสต์ .
ในขณะที่เราจะสาธิต Python API ความเข้าใจเกี่ยวกับ Numpy ก็เป็นประโยชน์เช่นกัน
ในการตั้งค่า TensorFlow โปรดปฏิบัติตามคำแนะนำที่พบ ที่นี่ .
ภาษาการเขียนโปรแกรมใดที่ใช้สำหรับวิทยาการหุ่นยนต์
หากคุณใช้ Windows โปรดสังเกตว่าในขณะที่เขียนคุณต้องใช้ Python 3.4+ ไม่ใช่ 2.7
จากนั้นเมื่อคุณพร้อมคุณจะสามารถนำเข้าไลบรารีด้วย:
import tensorflow as tf ขั้นตอนที่ 1 จาก 2 สำหรับโซลูชัน TensorFlow: สร้างกราฟ
การสร้างโปรแกรม TensorFlow โดยทั่วไปประกอบด้วยสองขั้นตอนหลัก ๆ ขั้นตอนแรกคือการสร้างกราฟการคำนวณซึ่งจะอธิบายการคำนวณที่คุณต้องการดำเนินการ แต่ไม่ได้ดำเนินการหรือเก็บค่าใด ๆ
เช่นเดียวกับกราฟใด ๆ เรามีโหนดและขอบ ขอบแสดงถึงเทนเซอร์ซึ่งเป็นเทนเซอร์แทนอาร์เรย์ n มิติ ตัวอย่างเช่นเทนเซอร์ที่มีมิติ (หรืออันดับใน TensorFlow speak) 0 คือสเกลาร์จัดอันดับ 1 เวกเตอร์อันดับ 2 เมทริกซ์และอื่น ๆ
โหนดแสดงถึงการดำเนินการที่สร้างเทนเซอร์เอาต์พุตโดยรับเทนเซอร์เป็นอินพุตหากจำเป็น การดำเนินการดังกล่าวรวมถึงการเพิ่ม (tf.add) การคูณเมทริกซ์ (tf.matmul) และการสร้างค่าคงที่ (tf.constant)
ดังนั้นเรามารวมบางส่วนเข้าด้วยกันสำหรับกราฟแรกของเรา
a = tf.constant([2.5, 2]) b = tf.constant([3, 6], dtype=tf.float32) total = tf.add(a, b) ที่นี่เราได้สร้างการดำเนินการสามรายการสองการดำเนินการเพื่อสร้างอาร์เรย์ 1-d คงที่
ชนิดข้อมูลอนุมานได้จากอาร์กิวเมนต์ค่าที่ส่งเข้ามาหรือคุณสามารถระบุสิ่งเหล่านี้ด้วย dtype การโต้เถียง. ถ้าฉันไม่ได้ทำสิ่งนี้สำหรับ b ดังนั้น int32 จะถูกอนุมานและเกิดข้อผิดพลาดเป็น tf.add จะพยายามกำหนดส่วนเพิ่มเติมในสองประเภทที่แตกต่างกัน
ขั้นตอนที่ 2 จาก 2 สำหรับโซลูชัน TensorFlow: ดำเนินการตามขั้นตอน
กราฟถูกกำหนดไว้ แต่เพื่อที่จะทำการคำนวณใด ๆ กับมัน (หรือส่วนใดส่วนหนึ่ง) เราต้องตั้งค่า TensorFlow Session
sess = tf.Session() หรือหากเรากำลังเรียกใช้เซสชันในเชลล์แบบโต้ตอบเช่น IPython เราจะใช้:
sess = tf.InteractiveSession() run วิธีการบนวัตถุเซสชันเป็นวิธีหนึ่งในการประเมิน Tensor
ดังนั้นในการประเมินการคำนวณเพิ่มเติมที่กำหนดไว้ข้างต้นเราจะส่ง 'total' ซึ่งเป็น Tensor เพื่อดึงข้อมูลซึ่งแสดงถึงผลลัพธ์ของ tf.add op.
print(sess.run(total)) # [ 5.5 8. ] ณ จุดนี้เราขอแนะนำคลาสตัวแปรของ TensorFlow ในขณะที่ค่าคงที่เป็นส่วนคงที่ของนิยามกราฟสามารถอัปเดตตัวแปรได้ ตัวสร้างคลาสต้องการค่าเริ่มต้น แต่ถึงอย่างนั้นตัวแปรก็ต้องการการดำเนินการเพื่อเตรียมใช้งานอย่างชัดเจนก่อนที่จะดำเนินการอื่น ๆ
ตัวแปรถือสถานะของกราฟในเซสชันหนึ่ง ๆ ดังนั้นเราควรสังเกตว่าเกิดอะไรขึ้นกับหลาย ๆ เซสชันโดยใช้กราฟเดียวกันเพื่อทำความเข้าใจตัวแปรได้ดีขึ้น
# Create a variable with an initial value of 1 some_var = tf.Variable(1) # Create op to run variable initializers init_op = tf.global_variables_initializer() # Create an op to replace the value held by some_var to 3 assign_op = some_var.assign(3) # Set up two instances of a session sess1 = tf.Session() sess2 = tf.Session() # Initialize variables in both sessions sess1.run(init_op) sess2.run(init_op) print(sess1.run(some_var)) # Outputs 1 # Change some_var in session1 sess1.run(assign_op) print(sess1.run(some_var)) # Outputs 3 print(sess2.run(some_var)) # Outputs 1 # Close sessions sess1.close() sess2.close() เราได้ตั้งค่ากราฟและสองเซสชัน
หลังจากดำเนินการเริ่มต้นในทั้งสองเซสชัน (หากเราไม่เรียกใช้สิ่งนี้จากนั้นประเมินตัวแปรเราพบข้อผิดพลาด) เราจะดำเนินการกำหนด op ในเซสชันเดียวเท่านั้น อย่างที่เห็นค่าตัวแปรยังคงมีอยู่ แต่จะไม่ปรากฏในเซสชัน
การป้อนกราฟเพื่อแก้ไขปัญหาเชิงตัวเลข
อีกแนวคิดที่สำคัญของ TensorFlow คือตัวยึด ในขณะที่ตัวแปรมีสถานะอยู่ตัวยึดตำแหน่งจะถูกใช้เพื่อกำหนดอินพุตที่กราฟคาดหวังและประเภทข้อมูล (และเลือกรูปร่างได้) จากนั้นเราสามารถป้อนข้อมูลลงในกราฟผ่านตัวยึดตำแหน่งเหล่านี้เมื่อเราเรียกใช้การคำนวณ
กราฟ TensorFlow เริ่มมีลักษณะคล้ายกับโครงข่ายประสาทเทียมที่เราต้องการฝึกในที่สุด แต่ก่อนหน้านั้นให้ใช้แนวคิดเพื่อแก้ปัญหาตัวเลขที่พบบ่อยจากโลกการเงิน
สมมติว่าเราต้องการค้นหา y ในสมการดังนี้:
สำหรับ v (ด้วย C และ P คงที่)
ความยืดหยุ่นของราคาของอุปสงค์คืออะไร?
นี่คือสูตรสำหรับการหาผลตอบแทนต่ออายุ (y) ของพันธบัตรที่มีมูลค่าตลาด v, เงินต้น P และคูปอง C จ่ายทุกครึ่งปี แต่กระแสเงินสดลดลงด้วยการทบต้นอย่างต่อเนื่อง
โดยพื้นฐานแล้วเราต้องแก้สมการเช่นนี้ด้วยการลองผิดลองถูกและเราจะเลือกวิธีการแบ่งส่วนเป็นศูนย์ในค่าสุดท้ายของเราสำหรับ y
ขั้นแรกเราจะจำลองปัญหานี้เป็นกราฟ TensorFlow
C และ P คือค่าคงที่คงที่และเป็นส่วนหนึ่งของนิยามของกราฟของเรา เราต้องการให้มีกระบวนการที่ปรับแต่งขอบเขตล่างและบนของ y ดังนั้นขอบเขตเหล่านี้ (แสดงเป็น a และ b) เป็นตัวเลือกที่ดีสำหรับตัวแปรที่ต้องเปลี่ยนหลังจากการเดา y (นำไปเป็นจุดกึ่งกลางของ a และ b)
# Specify the values our constant ops will output C = tf.constant(5.0) P = tf.constant(100.0) # We specify the initial values that our lower and upper bounds will be when initialised. # Obviously the ultimate success of this algorithm depends on decent start points a = tf.Variable(-10.0) b = tf.Variable(10.0) # We expect a floating number to be inserted into the graph v_target = tf.placeholder('float') # Remember the following operations are definitions, # none are carried out until an operation is evaluated in a session! y = (a+b)/2 v_guess = C*tf.exp(-0.5*y) + C*tf.exp(-y) + C*tf.exp(-1.5*y) + (C + P)*tf.exp(-2*y) # Operations to set temporary values (a_ and b_) intended to be the next values of a and b. # e.g. if the guess results in a v greater than the target v, # we will set a_ to be the current value of y a_ = tf.where(v_guess > v_target, y, a) b_ = tf.where(v_guess ตอนนี้เรามีรายการการดำเนินการและตัวแปรซึ่งสามารถประเมินเทียบกับเซสชันหนึ่ง ๆ ได้ การดำเนินการบางอย่างต้องอาศัยการดำเนินการอื่น ๆ ในการรันดังนั้นการรันพูด v_guess จะกำหนดปฏิกิริยาลูกโซ่ให้มีเทนเซอร์อื่น ๆ เช่น C และ P เพื่อประเมินก่อน
การดำเนินการบางอย่างอาศัยตัวยึดที่ต้องระบุค่าดังนั้นเราจะป้อนค่านั้นอย่างไร?
สิ่งนี้ทำได้ผ่าน feed_dict อาร์กิวเมนต์ใน run ฟังก์ชั่นตัวเอง
หากเราต้องการประเมิน a_ เราใส่ค่าสำหรับตัวยึดของเรา v_target ดังนี้:
sess.run(a_, feed_dict={v_target: 100}) ให้เรา 0.0.
วิธีคำนวนราคา ipo ต่อหุ้น
เสียบ v_target จาก 130 และเราได้ -10.0
เป็นการดำเนินการ 'ขั้นตอน' ของเราซึ่งจริงๆแล้วการดำเนินการอื่น ๆ ทั้งหมดจะต้องดำเนินการเป็นข้อกำหนดเบื้องต้นและมีผลบังคับใช้ทั้งกราฟ นอกจากนี้ยังเป็นการดำเนินการที่เปลี่ยนสถานะจริงในเซสชันของเราด้วย ดังนั้นยิ่งเราดำเนินการขั้นตอนมากเท่าไหร่เราก็ยิ่งขยับตัวแปรของเรามากขึ้นเท่านั้น a และ b ต่อมูลค่าจริงของ y
สมมติว่าคุณค่าของเราสำหรับ v ในสมการของเราเท่ากับ 95 มาสร้างเซสชันและดำเนินการกับกราฟของเรา 100 ครั้ง
# Set up a session and initialize variables sess = tf.Session() tf.global_variables_initializer().run() # Run the step operation (and therefore whole graph) 100 times for i in range (100): sess.run(step, feed_dict={v_target:95}) ถ้าเราประเมิน y ตอนนี้เราได้รับสิ่งที่คล้ายกับคำตอบที่ต้องการ
print(sess.run(y)) # 0.125163 โครงข่ายประสาท
ตอนนี้เรามีความเข้าใจเกี่ยวกับกลไกของ TensorFlow แล้วเราสามารถนำสิ่งนี้มารวมกับการทำงานของแมชชีนเลิร์นนิงเพิ่มเติมที่มีอยู่ใน TensorFlow เพื่อฝึกเครือข่ายประสาทอย่างง่าย
ในที่นี้เราต้องการจัดประเภทจุดข้อมูลบนระบบพิกัด 2d โดยขึ้นอยู่กับว่าจุดข้อมูลนั้นอยู่ในพื้นที่ใดพื้นที่หนึ่งหรือไม่โดยวงกลมรัศมี 0.5 ศูนย์กลางที่จุดกำเนิด
แน่นอนว่าสิ่งนี้สามารถตรวจสอบได้อย่างเป็นรูปธรรมเพียงแค่ตรวจสอบจุดที่กำหนด (a,b) ถ้า a^2 + b^2 <0.5 แต่เพื่อจุดประสงค์ของการทดสอบแมชชีนเลิร์นนิงนี้เราขอส่งต่อในชุดการฝึกอบรม: ชุดของคะแนนสุ่มและไม่ว่าจะอยู่ในภูมิภาคที่เราตั้งใจไว้หรือไม่ วิธีหนึ่งในการสร้างสิ่งนี้มีดังนี้
import numpy as np NO_OF_RANDOM_POINTS = 100 CIRCLE_RADIUS = 0.5 random_spots = np.random.rand(NO_OF_RANDOM_POINTS, 2) * 2 - 1 is_inside_circle = (np.power(random_spots[:,0],2) + np.power(random_spots[:,1],2) เราจะสร้างโครงข่ายประสาทเทียมที่มีลักษณะดังต่อไปนี้:
- ประกอบด้วยเลเยอร์อินพุตที่มีสองโหนดซึ่งเราป้อนชุดเวกเตอร์สองมิติของเราที่มีอยู่ภายใน“ random_spots” สิ่งนี้จะแสดงโดยตัวยึดที่รอข้อมูลการฝึกอบรม
- เลเยอร์เอาต์พุตจะมีโหนดสองโหนดด้วยดังนั้นเราจึงต้องป้อนชุดของเลเบลการฝึกของเรา (“ is_inside_circle”) ให้เป็นตัวยึดสำหรับสเกลาร์จากนั้นแปลงค่าเหล่านั้นให้เป็นเวกเตอร์สองมิติแบบร้อนเดียว
- เราจะมีเลเยอร์ที่ซ่อนอยู่หนึ่งชั้นซึ่งประกอบด้วยสามโหนดดังนั้นเราจะต้องใช้ตัวแปรสำหรับเมทริกซ์น้ำหนักและเวกเตอร์อคติเนื่องจากค่าเหล่านี้เป็นค่าที่จำเป็นต้องได้รับการปรับปรุงเมื่อทำการฝึกอบรม
INPUT_LAYER_SIZE = 2 HIDDEN_LAYER_SIZE = 3 OUTPUT_LAYER_SIZE = 2 # Starting values for weights and biases are drawn randomly and uniformly from [-1, 1] # For example W1 is a matrix of shape 2x3 W1 = tf.Variable(tf.random_uniform([INPUT_LAYER_SIZE, HIDDEN_LAYER_SIZE], -1, 1)) b1 = tf.Variable(tf.random_uniform([HIDDEN_LAYER_SIZE], -1, 1)) W2 = tf.Variable(tf.random_uniform([HIDDEN_LAYER_SIZE, OUTPUT_LAYER_SIZE], -1, 1)) b2 = tf.Variable(tf.random_uniform([OUTPUT_LAYER_SIZE], -1, 1)) # Specifying that the placeholder X can expect a matrix of 2 columns (but any number of rows) # representing random spots X = tf.placeholder(tf.float32, [None, INPUT_LAYER_SIZE]) # Placeholder Y can expect integers representing whether corresponding point is in the circle # or not (no shape specified) Y = tf.placeholder(tf.uint8) # An op to convert to a one hot vector onehot_output = tf.one_hot(Y, OUTPUT_LAYER_SIZE) เพื่อให้คำจำกัดความของกราฟของเราสมบูรณ์เราได้กำหนดตัวเลือกบางอย่างซึ่งจะช่วยให้เราฝึกตัวแปรเพื่อให้ได้ตัวจำแนกที่ดีขึ้น ซึ่งรวมถึงการคำนวณเมทริกซ์ฟังก์ชันการเปิดใช้งานและเครื่องมือเพิ่มประสิทธิภาพ
LEARNING_RATE = 0.01 # Op to perform matrix calculation X*W1 + b1 hidden_layer = tf.add(tf.matmul(X, W1), b1) # Use sigmoid activation function on the outcome activated_hidden_layer = tf.sigmoid(hidden_layer) # Apply next weights and bias (W2, b2) to hidden layer and then apply softmax function # to get our output layer (each vector adding up to 1) output_layer = tf.nn.softmax(tf.add(tf.matmul(activated_hidden_layer, W2), b2)) # Calculate cross entropy for our loss function loss = -tf.reduce_sum(onehot_output * tf.log(output_layer)) # Use gradient descent optimizer at specified learning rate to minimize value given by loss tensor train_step = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(loss) เมื่อตั้งค่ากราฟแล้วก็ได้เวลาตั้งค่าเซสชันและเรียกใช้“ train_step” (ซึ่งเรียกใช้ตัวเลือกที่จำเป็นต้องมีด้วย) ตัวเลือกเหล่านี้บางตัวใช้ตัวยึดตำแหน่งดังนั้นจึงจำเป็นต้องระบุค่าสำหรับสิ่งเหล่านี้ ขั้นตอนการฝึกอบรมนี้แสดงถึงยุคหนึ่งในอัลกอริทึมการเรียนรู้ของเราและด้วยเหตุนี้จึงวนซ้ำกับจำนวนยุคที่เราต้องการดำเนินการ เราสามารถเรียกใช้ส่วนอื่น ๆ ของกราฟเช่นเทนเซอร์ 'การสูญเสีย' เพื่อจุดประสงค์ในการให้ข้อมูล
EPOCH_COUNT = 1000 sess = tf.Session() tf.global_variables_initializer().run() for i in range(EPOCH_COUNT): if i%100 == 0: print('Loss after %d runs: %f' % (i, sess.run(loss, feed_dict={X: random_spots, Y: is_inside_circle}))) sess.run(train_step, feed_dict={X: random_spots, Y: is_inside_circle}) print('Final loss after %d runs: %f' % (i, sess.run(loss, feed_dict={X: random_spots, Y: is_inside_circle}))) เมื่อเราฝึกฝนอัลกอริทึมแล้วเราสามารถป้อนข้อมูลในจุดและรับผลลัพธ์ของโครงข่ายประสาทได้ดังนี้:
sess.run(output_layer, feed_dict={X: [[1, 1]]}) # Hopefully something close to [1, 0] sess.run(output_layer, feed_dict={X: [[0, 0]]}) # Hopefully something close to [0, 1] เราสามารถจำแนกจุดออกจากวงกลมได้ถ้าสมาชิกตัวแรกของเวกเตอร์เอาต์พุตมีค่ามากกว่า 0.5 ไม่เช่นนั้น
ค่าธรรมเนียมวาณิชธนกิจมาตรฐานในการระดมทุนคืออะไร
โดยการเรียกใช้ output_layer เทนเซอร์สำหรับหลาย ๆ จุดเราสามารถเข้าใจได้ว่าผู้เรียนมองเห็นพื้นที่ที่มีคะแนนที่จำแนกเป็นบวกได้อย่างไร ควรลองใช้ขนาดของชุดฝึกอัตราการเรียนรู้และพารามิเตอร์อื่น ๆ เพื่อดูว่าเราจะเข้าใกล้แวดวงที่เราตั้งใจไว้ได้มากน้อยเพียงใด
ชุดฝึก: 100 คะแนน
อัตราการเรียนรู้: 0.01
ยุค: 1,000
ชุดฝึก: 1,000 คะแนน
อัตราการเรียนรู้: 0.01
ยุค: 1,000
ชุดฝึก: 1,000 คะแนน
อัตราการเรียนรู้: 0.01
ยุค: 10,000
ชุดฝึก: 1,000 คะแนน
อัตราการเรียนรู้: 0.001
ยุค: 10,000
สรุป
นี่เป็นบทเรียนที่ดีว่าชุดการฝึกอบรมที่เพิ่มขึ้นหรือจำนวนครั้งไม่สามารถรับประกันได้ว่าจะมีผู้เรียนที่ดี - ควรปรับอัตราการเรียนรู้ให้เหมาะสม
หวังว่าการสาธิตเหล่านี้จะช่วยให้คุณเข้าใจหลักการสำคัญของ TensorFlow ได้เป็นอย่างดีและเป็นรากฐานที่มั่นคงในการนำเทคนิคที่ซับซ้อนขึ้นไปใช้
เรายังไม่ได้กล่าวถึงแนวคิดต่างๆเช่น Tensorboard หรือการฝึกอบรมโมเดลของเราใน GPU แต่สิ่งเหล่านี้ครอบคลุมอย่างดีใน เอกสาร TensorFlow . มีสูตรอาหารจำนวนมากอยู่ในเอกสารประกอบที่ช่วยให้คุณรับมือกับงานการเรียนรู้เชิงลึกที่น่าตื่นเต้นได้อย่างรวดเร็วโดยใช้กรอบการทำงานที่ทรงพลังนี้!
ที่เกี่ยวข้อง: แอพพลิเคชั่นมากมายของ Gradient Descent ใน TensorFlow ทำความเข้าใจพื้นฐาน
กราฟกระแสข้อมูลคืออะไร
กราฟกระแสข้อมูลคือกราฟเชิงคำนวณซึ่งอธิบายการคำนวณที่คุณต้องการดำเนินการ แต่ไม่ได้ดำเนินการตามจริงหรือเก็บค่าใด ๆ
ตัวแปร TensorFlow คืออะไร?
ตัวแปรใน TensorFlow ถือสถานะของกราฟในเซสชันหนึ่ง ๆ ในขณะที่ค่าคงที่ในกราฟ TensorFlow เป็นส่วนคงที่ของนิยามกราฟตัวแปรสามารถอัปเดตได้โดยใช้การดำเนินการ
