เป็นหนึ่งในหัวข้อที่ร้อนแรงที่สุดของปี 2018-19 และด้วยเหตุผลที่ดี มีความก้าวหน้ามากมายในอุตสาหกรรมซึ่งถึงเวลาแล้วที่เครื่องจักรหรือโปรแกรมคอมพิวเตอร์เข้ามาแทนที่มนุษย์จริงๆ นี้ การเรียนรู้เชิงลึกกับ Python บทความนี้จะช่วยให้คุณเข้าใจว่า Deep Learning คืออะไรและการเปลี่ยนแปลงนี้เกิดขึ้นได้อย่างไร ฉันจะพูดถึงหัวข้อต่อไปนี้ในบทความนี้:
- วิทยาศาสตร์ข้อมูลและส่วนประกอบ
- ความจำเป็นในการเรียนรู้เชิงลึก
- Deep Learning คืออะไร?
- Perceptron และโครงข่ายประสาทเทียม
- การประยุกต์ใช้การเรียนรู้เชิงลึก
- ทำไมต้อง Python สำหรับการเรียนรู้เชิงลึก
- Deep Learning with Python: Perceptron Example
- การเรียนรู้เชิงลึกด้วย Python: การสร้าง Deep Neural Network
วิทยาศาสตร์ข้อมูลและส่วนประกอบ
Data Science เป็นสิ่งที่มีมานานแล้ว วิทยาศาสตร์ข้อมูล คือการดึงความรู้จากข้อมูลโดยใช้เทคนิคและอัลกอริทึมที่แตกต่างกัน
เป็นเทคนิคที่ทำให้เครื่องจักรสามารถเลียนแบบพฤติกรรมของมนุษย์ได้ แนวคิดเบื้องหลัง AI นั้นค่อนข้างเรียบง่าย แต่น่าสนใจนั่นคือการสร้างเครื่องจักรอัจฉริยะที่สามารถตัดสินใจได้ด้วยตัวเอง หลายปีที่ผ่านมามีความคิดว่าคอมพิวเตอร์จะไม่มีวันเทียบได้กับพลังของสมองมนุษย์
ตอนนั้นเราไม่มีข้อมูลและพลังในการคำนวณเพียงพอ แต่ตอนนี้มี ข้อมูลใหญ่ เกิดขึ้นและด้วยการถือกำเนิดของ GPU ปัญญาประดิษฐ์จึงเป็นไปได้
เป็นชุดย่อยของเทคนิค AI ซึ่งใช้วิธีการทางสถิติเพื่อให้เครื่องจักรสามารถปรับปรุงได้ด้วยประสบการณ์
การเรียนรู้เชิงลึก เป็นส่วนย่อยของ ML ซึ่งทำให้การคำนวณของโครงข่ายประสาทเทียมหลายชั้นเป็นไปได้ ใช้โครงข่ายประสาทเทียมเพื่อจำลองการตัดสินใจเหมือนมนุษย์
ความจำเป็นในการเรียนรู้เชิงลึก
ขั้นตอนสู่ปัญญาประดิษฐ์คือการเรียนรู้ของเครื่อง Machine Learning เป็นชุดย่อยของ AI และตั้งอยู่บนแนวคิดที่ว่าเครื่องควรได้รับการเข้าถึงข้อมูลและควรปล่อยให้เรียนรู้และสำรวจด้วยตนเอง เกี่ยวข้องกับการแยกรูปแบบจากชุดข้อมูลขนาดใหญ่ การจัดการชุดข้อมูลขนาดใหญ่ไม่ใช่ปัญหา
- อัลกอริทึมการเรียนรู้ของเครื่อง ไม่สามารถจัดการกับข้อมูลมิติสูงได้ - ที่ซึ่งเรามีอินพุตและเอาต์พุตจำนวนมาก: รอบหลายพันมิติ การจัดการและการประมวลผลข้อมูลประเภทนี้มีความซับซ้อนและใช้ทรัพยากรอย่างครบถ้วน นี้เรียกว่า คำสาปแห่งมิติ
- ความท้าทายอื่นที่ต้องเผชิญคือการระบุ คุณสมบัติที่จะดึงออกมา . สิ่งนี้มีบทบาทสำคัญในการทำนายผลลัพธ์เช่นกันในการบรรลุความแม่นยำที่ดีขึ้น ดังนั้นหากไม่มีการแยกคุณลักษณะ ความท้าทายสำหรับโปรแกรมเมอร์เพิ่มขึ้นเนื่องจากประสิทธิภาพของอัลกอริทึมขึ้นอยู่กับว่าโปรแกรมเมอร์มีความเข้าใจลึกซึ้งเพียงใด
ตอนนี้นี่คือจุดที่ Deep Learning เข้ามาช่วย การเรียนรู้เชิงลึกคือ สามารถจัดการข้อมูลมิติสูงได้ และยังมีประสิทธิภาพอีกด้วย มุ่งเน้นไปที่คุณสมบัติที่เหมาะสม ด้วยตัวของมันเอง
Deep Learning คืออะไร?
Deep Learning เป็นชุดย่อยของการเรียนรู้ของเครื่องที่ใช้อัลกอริทึมการเรียนรู้ของเครื่องที่คล้ายกันในการฝึกอบรม เพื่อให้เกิดความแม่นยำที่ดีขึ้นในกรณีที่อดีตไม่ได้ผลตามที่กำหนด โดยพื้นฐานแล้ว การเรียนรู้เชิงลึกจะเลียนแบบการทำงานของสมองของเรา นั่นคือเรียนรู้จากประสบการณ์
อย่างที่ทราบกันดีว่าสมองของเราประกอบด้วย เซลล์ประสาทหลายพันล้านเซลล์ ที่ช่วยให้เราทำสิ่งที่น่าอัศจรรย์ แม้แต่สมองของเด็กตัวเล็ก ๆ ก็ยังสามารถแก้ปัญหาที่ซับซ้อนได้ซึ่งยากมากที่จะแก้ไขได้แม้กระทั่งการใช้ Super-Computers ดังนั้นเราจะบรรลุฟังก์ชันการทำงานเดียวกันในโปรแกรมได้อย่างไร? ตอนนี้นี่คือที่ที่เราเข้าใจ เซลล์ประสาทเทียม (Perceptron) และ โครงข่ายประสาทเทียม
Perceptron และโครงข่ายประสาทเทียม
Deep Learning ศึกษาหน่วยพื้นฐานของสมองที่เรียกว่าเซลล์สมองหรือเซลล์ประสาท ตอนนี้ให้เราเข้าใจการทำงานของเซลล์ประสาททางชีววิทยาและวิธีที่เราเลียนแบบการทำงานนี้ในการรับรู้หรือเซลล์ประสาทเทียม
- เดนไดรต์: รับสัญญาณจากเซลล์ประสาทอื่น ๆ
- ร่างกายของเซลล์: รวมอินพุตทั้งหมด
- แอกซอน: ใช้ในการส่งสัญญาณไปยังเซลล์อื่น ๆ
เซลล์ประสาทเทียมหรือก เพอร์เซปตรอน เป็นแบบจำลองเชิงเส้นที่ใช้สำหรับการจำแนกไบนารี เป็นการจำลองเซลล์ประสาทที่มีชุดของอินพุตซึ่งแต่ละส่วนจะได้รับน้ำหนักที่เฉพาะเจาะจง เซลล์ประสาทคำนวณการทำงานบางอย่างในสิ่งเหล่านี้ ถ่วงน้ำหนัก อินพุตและให้เอาต์พุต
ได้รับ n อินพุต (สอดคล้องกับคุณสมบัติแต่ละอย่าง) จากนั้นจะรวมอินพุตเหล่านั้นใช้การแปลงและสร้างเอาต์พุต มีสองฟังก์ชั่น:
- สรุป
- การเปลี่ยนแปลง (การเปิดใช้งาน)
น้ำหนักแสดงประสิทธิภาพของอินพุตเฉพาะ น้ำหนักของอินพุตมากขึ้นก็จะมีผลกระทบต่อโครงข่ายประสาทเทียม . ในทางกลับกัน, อคติ เป็น พารามิเตอร์เพิ่มเติม ใน Perceptron ซึ่งใช้ในการปรับเอาท์พุทพร้อมกับผลรวมถ่วงน้ำหนักของอินพุตไปยังเซลล์ประสาทซึ่งช่วยให้แบบจำลองในแบบที่เหมาะสมที่สุดสำหรับข้อมูลที่กำหนด
ฟังก์ชั่นการเปิดใช้งาน แปลอินพุตเป็นเอาต์พุต ใช้ขีด จำกัด ในการสร้างเอาต์พุต มีฟังก์ชันมากมายที่ใช้เป็นฟังก์ชันการเปิดใช้งานเช่น:
- Linear หรือ Identity
- หน่วยหรือขั้นตอนไบนารี
- Sigmoid หรือ Logistic
- Tanh
- ReLU
- ซอฟต์แม็กซ์
ดี. ถ้าคุณคิดว่า Perceptron แก้ปัญหาได้แสดงว่าคุณคิดผิด มีปัญหาใหญ่สองประการ:
- Perceptrons ชั้นเดียว ไม่สามารถจำแนกจุดข้อมูลที่แยกกันไม่เป็นเชิงเส้นได้ .
- ปัญหาที่ซับซ้อนซึ่งเกี่ยวข้องกับ พารามิเตอร์มากมาย ไม่สามารถแก้ไขได้ด้วย Single-Layer Perceptrons
พิจารณาตัวอย่างที่นี่และความซับซ้อนของพารามิเตอร์ที่เกี่ยวข้องในการตัดสินใจโดยทีมการตลาด
การต่อสู้บทบาทหลักและความรับผิดชอบ pdf
เซลล์ประสาทหนึ่งเซลล์ไม่สามารถรับอินพุตจำนวนมากได้และนั่นคือเหตุผลที่จะใช้เซลล์ประสาทมากกว่าหนึ่งเซลล์ในการแก้ปัญหานี้ Neural Network เป็นเพียงไฟล์ องค์ประกอบของ Perceptrons เชื่อมต่อกันในรูปแบบต่างๆ และใช้งานฟังก์ชันการเปิดใช้งานที่แตกต่างกัน
- อินพุตโหนด ให้ข้อมูลจากโลกภายนอกไปยังเครือข่ายและรวมกันเรียกว่า 'เลเยอร์อินพุต'
- โหนดที่ซ่อนอยู่ ทำการคำนวณและถ่ายโอนข้อมูลจากโหนดอินพุตไปยังโหนดเอาต์พุต คอลเลกชันของโหนดที่ซ่อนอยู่ในรูปแบบ 'Hidden Layer'
- โหนดเอาต์พุต เรียกรวมกันว่า 'เลเยอร์เอาต์พุต' และมีหน้าที่ในการคำนวณและถ่ายโอนข้อมูลจากเครือข่ายไปยังโลกภายนอก
เมื่อคุณมีความคิดแล้วว่า Perceptron ทำงานอย่างไรพารามิเตอร์ต่างๆที่เกี่ยวข้องและเลเยอร์ต่างๆของ Neural Network เรามาเรียนรู้เชิงลึกต่อไปด้วย Python Blog และดูแอปพลิเคชัน Deep Learning ที่น่าสนใจ
การประยุกต์ใช้การเรียนรู้เชิงลึก
มีแอปพลิเคชัน Deep Learning มากมายในอุตสาหกรรมต่อไปนี้เป็นสิ่งสำคัญบางส่วนที่มีอยู่ในงานประจำวันของเรา
- การรู้จำเสียง
- การแปลด้วยเครื่อง
- การจดจำใบหน้าและการติดแท็กอัตโนมัติ
- ผู้ช่วยส่วนตัวเสมือน
- รถขับเอง
- แชทบอท
ทำไมต้อง Python สำหรับการเรียนรู้เชิงลึก
- เป็นเครื่องมือชนิดหนึ่งที่มีคุณลักษณะเฉพาะของการเป็นไฟล์ ภาษาโปรแกรมวัตถุประสงค์ทั่วไป ในฐานะที่เป็น ง่ายต่อการใช้ เมื่อพูดถึงการคำนวณเชิงวิเคราะห์และเชิงปริมาณ
- มันเป็นอย่างมาก เข้าใจง่าย
- Python คือ พิมพ์แบบไดนามิก
- ใหญ่มาก
- ห้องสมุดมากมายสำหรับวัตถุประสงค์ที่แตกต่างกันเช่น Numpy, Seaborn, Matplotlib, Pandas และ Scikit-learn
พอมีทฤษฎีแล้วมาดูกันว่าเราจะเริ่มการเรียนรู้เชิงลึกกับ Python ด้วยตัวอย่างเล็ก ๆ แต่น่าตื่นเต้นได้อย่างไร
การเรียนรู้เชิงลึกด้วย Python: ตัวอย่าง Perceptron
ตอนนี้ฉันแน่ใจว่าพวกคุณต้องคุ้นเคยกับการทำงานของ“ หรือ' ประตู. ผลลัพธ์คือ หนึ่ง หากมีอินพุตใด ๆ ด้วย หนึ่ง.
ดังนั้น Perceptron จึงสามารถใช้เป็นตัวคั่นหรือเส้นการตัดสินใจที่แบ่งชุดอินพุตของ OR Gate ออกเป็นสองคลาส:
ชั้น 1: อินพุตที่มีเอาต์พุตเป็น 0 ซึ่งอยู่ด้านล่างบรรทัดการตัดสินใจ
ชั้น 2: อินพุตที่มีเอาต์พุตเป็น 1 ซึ่งอยู่เหนือเส้นการตัดสินใจหรือตัวคั่น
จนถึงตอนนี้เราเข้าใจแล้วว่าสามารถใช้ linear perceptron เพื่อจำแนกชุดข้อมูลอินพุตออกเป็นสองคลาสได้ แต่มันจำแนกข้อมูลได้อย่างไร?
ในทางคณิตศาสตร์ Perceptron สามารถคิดได้เหมือนสมการของ Weights, Inputs และ Bias
ขั้นตอนที่ 1: นำเข้าไลบรารีที่จำเป็นทั้งหมด
ที่นี่ฉันจะนำเข้าห้องสมุดเดียวเท่านั้นคือ TensorFlow
นำเข้าเทนเซอร์โฟลว์เป็น tf
ขั้นตอนที่ 2: กำหนดตัวแปรเวกเตอร์สำหรับอินพุตและเอาต์พุต
ต่อไปเราต้องสร้างตัวแปรสำหรับจัดเก็บอินพุตเอาต์พุตและอคติสำหรับ Perceptron
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]
ขั้นตอนที่ 3: กำหนดตัวแปรน้ำหนัก
ในที่นี้เราจะกำหนดตัวแปรเทนเซอร์ของรูปร่าง 3 × 1 สำหรับน้ำหนักของเราและกำหนดค่าสุ่มให้กับมันในตอนแรก
w = tf ตัวแปร (tf.random_normal ([3, 1], เมล็ดพันธุ์ = 15))
ขั้นตอนที่ 4: กำหนดตัวยึดตำแหน่งสำหรับอินพุตและเอาต์พุต
เราจำเป็นต้องกำหนดตัวยึดตำแหน่งเพื่อให้พวกเขาสามารถรับอินพุตภายนอกในการรัน
x = tf.placeholder (tf.float32, [ไม่มี, 3]) y = tf.placeholder (tf.float32, [ไม่มี, 1])
ขั้นตอนที่ 5: คำนวณเอาต์พุตและฟังก์ชันการเปิดใช้งาน
ตามที่กล่าวไว้ก่อนหน้านี้อินพุตที่ได้รับโดย perceptron จะถูกคูณด้วยน้ำหนักตามลำดับก่อนจากนั้นอินพุตที่ถ่วงน้ำหนักทั้งหมดเหล่านี้จะรวมเข้าด้วยกัน จากนั้นค่าที่สรุปนี้จะถูกป้อนเข้าสู่การเปิดใช้งานเพื่อให้ได้ผลลัพธ์สุดท้าย
เอาท์พุท = tf.nn.relu (tf.matmul (x, w))
หมายเหตุ: ในกรณีนี้ฉันใช้ไฟล์ relu เป็นฟังก์ชันการเปิดใช้งานของฉัน คุณมีอิสระที่จะใช้ฟังก์ชันการเปิดใช้งานใด ๆ ตามความต้องการของคุณ
ขั้นตอนที่ 6: คำนวณต้นทุนหรือข้อผิดพลาด
เราจำเป็นต้องคำนวณ Cost = Mean Squared Error ซึ่งไม่มีอะไรนอกจากกำลังสองของความแตกต่างของเอาต์พุต Perceptron และเอาต์พุตที่ต้องการ
การสูญเสีย = tf.reduce_sum (tf.square (เอาต์พุต - y))
ขั้นตอนที่ 7: ลดข้อผิดพลาด
เป้าหมายของ perceptron คือการลดการสูญเสียหรือต้นทุนหรือข้อผิดพลาด ดังนั้นที่นี่เราจะใช้เครื่องมือเพิ่มประสิทธิภาพการไล่ระดับสี
เครื่องมือเพิ่มประสิทธิภาพ = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (การสูญเสีย)
ขั้นตอนที่ 8: เริ่มต้นตัวแปรทั้งหมด
ตัวแปรถูกกำหนดด้วย tf ตัวแปร ดังนั้นเราต้องเริ่มต้นตัวแปรที่กำหนดไว้
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)
ขั้นตอนที่ 9: ฝึก Perceptron ในการทำซ้ำ
เราจำเป็นต้องฝึก Perceptron ของเราเช่นอัปเดตค่าน้ำหนักและอคติในการทำซ้ำอย่างต่อเนื่องเพื่อลดข้อผิดพลาดหรือการสูญเสียให้น้อยที่สุด ที่นี่ฉันจะฝึก Perceptron ของเราใน 100 ยุค
สำหรับฉันอยู่ในช่วง (100): sess.run (รถไฟ, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', ฉัน,' - ขาดทุน - ', ต้นทุน)ขั้นตอนที่ 10: เอาต์พุต
……
……
ดังที่คุณเห็นที่นี่การสูญเสียเริ่มต้นที่ 2.07 และสิ้นสุดที่ 0.27
.
การเรียนรู้เชิงลึกด้วย Python: การสร้าง Deep Neural Network
ตอนนี้เราได้สร้าง perceptron สำเร็จและฝึกฝนมันสำหรับประตู OR มาอ่านบทความนี้ต่อและดูว่าจะสร้าง Neural Network ของเราเองจาก Scratch ได้อย่างไรโดยที่เราจะสร้าง Input Layer, Hidden Layers และ Output Layer
เราจะใช้ชุดข้อมูล MNIST ชุดข้อมูล MNIST ประกอบด้วย 60,000 การฝึกอบรม ตัวอย่างและ 10,000 การทดสอบ ตัวอย่างภาพหลักที่เขียนด้วยลายมือ ภาพมีขนาด 28 × 28 พิกเซล และผลลัพธ์สามารถอยู่ระหว่าง 0-9 .
งานนี้คือการฝึกโมเดลที่สามารถระบุตัวเลขที่ปรากฏบนรูปภาพได้อย่างแม่นยำ
ประการแรกเราจะใช้การนำเข้าด้านล่างเพื่อนำฟังก์ชันการพิมพ์จาก Python 3 ไปสู่ Python 2.6+ ข้อความ __future__ ต้องอยู่ใกล้ด้านบนสุดของไฟล์เนื่องจากเปลี่ยนสิ่งพื้นฐานเกี่ยวกับภาษาดังนั้นคอมไพเลอร์จึงจำเป็นต้องรู้เกี่ยวกับพวกเขาตั้งแต่เริ่มต้น
จาก __future__ นำเข้า print_function
ต่อไปนี้เป็นรหัสที่มีความคิดเห็นในทุกขั้นตอน
# นำเข้าข้อมูล MNIST จาก tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) นำเข้าเทนเซอร์โฟลว์เป็น tf นำเข้า matplotlib.pyplot เป็น plt # พารามิเตอร์ learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # พารามิเตอร์เครือข่าย n_hidden_1 = 256 # จำนวนชั้นที่ 1 ของคุณสมบัติ n_hidden_2 = 256 # จำนวนชั้นที่ 2 ของคุณสมบัติ n_input = 784 # MNIST การป้อนข้อมูล (รูปร่าง img: 28 * 28) n_classes = 10 # คลาสทั้งหมด MNIST ( 0-9 หลัก) # tf อินพุตกราฟ x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # สร้างโมเดล def multilayer_perceptron (x, น้ำหนัก , อคติ): # เลเยอร์ที่ซ่อนด้วยการเปิดใช้งาน RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # เลเยอร์ที่ซ่อน ด้วยการเปิดใช้งาน RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # ชั้นเอาต์พุตที่มีการเปิดใช้งานเชิงเส้น out_layer = tf matmul (ชั้น _2, weights ['out']) + biases ['out'] return out_layer # Store Layer weight & bias weights = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # สร้างโมเดล pred = multilayer_perceptron (x, น้ำหนัก, อคติ) # กำหนดต้นทุนการสูญเสียและเครื่องมือเพิ่มประสิทธิภาพ = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, label = y)) เครื่องมือเพิ่มประสิทธิภาพ = tf.train.AdamOptimizer (learning_rate = learning_rate) ลด (ต้นทุน) # การเริ่มต้นตัวแปร init = tf.global_variables_initializer () # สร้างรายการว่างเพื่อจัดเก็บประวัติต้นทุนและประวัติความถูกต้อง cost_history = [] precision_history = [] # เรียกใช้กราฟด้วย tf.Session () เป็น sess: sess.run (init ) # รอบการฝึกสำหรับยุคในระยะ (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # วนรอบแบทช์ทั้งหมดสำหรับ i ในช่วง (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # เรียกใช้การเพิ่มประสิทธิภาพ op (backprop) และต้นทุน op (เพื่อรับมูลค่าการสูญเสีย) _, c = sess.run ([เครื่องมือเพิ่มประสิทธิภาพ, ค่าใช้จ่าย], feed_dict = {x: batch_x, y: batch_y}) # คำนวณการสูญเสียเฉลี่ย avg_cost + = c / total_batch # แสดงบันทึกต่อยุคถ้า epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # คำนวณความถูกต้องแม่นยำ = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = ความถูกต้อง.eval ({x: mnist.test.images, y: mnist.test.labels}) # ใส่ความถูกต้องให้กับรายการ precision_history.append (acu_temp) #append the cost history cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. format (avg_cost), '- Accuracy =', acu_temp) print ('Optimization finished! ') #plot ประวัติต้นทุน plt.plot (cost_history) plt.show () #plot ประวัติความถูกต้อง plt.plot (ความถูกต้อง _history) plt.show () # แบบทดสอบ correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # คำนวณความถูกต้องแม่นยำ = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) พิมพ์ (' ความถูกต้อง: ', ความถูกต้อง.eval ({x: mnist.test.images, y: mnist.test.labels}))เอาท์พุต:
ตอนนี้เรามาถึงตอนท้ายของบทความ Deep Learning with Python แล้ว ฉันหวังว่าคุณจะเข้าใจองค์ประกอบต่างๆของ Deep Learning ว่ามันเริ่มต้นอย่างไรและการใช้ Python เราสามารถสร้าง perceptron แบบง่ายและ Deep Neural Network ได้อย่างไร
Edureka’s ได้รับการดูแลโดยผู้เชี่ยวชาญในอุตสาหกรรมตามความต้องการและความต้องการของอุตสาหกรรม คุณจะเชี่ยวชาญแนวคิดต่างๆเช่นฟังก์ชัน SoftMax, Autoencoder Neural Networks, เครื่อง Boltzmann ที่ จำกัด (RBM) และทำงานกับไลบรารีเช่น Keras & TFLearn หลักสูตรนี้ได้รับการดูแลเป็นพิเศษโดยผู้เชี่ยวชาญในอุตสาหกรรมพร้อมกรณีศึกษาแบบเรียลไทม์
มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของ“ Deep Learning with Python” แล้วเราจะติดต่อกลับไป