แข็ง

ในบรรดาปลั๊กอินที่มีประสิทธิภาพและใช้งานง่ายที่สุดสำหรับการสร้างอัลกอริธึมการเรียนรู้เชิงลึกคือเฟรมเวิร์กประสาทเทียมที่ยกระดับบน Python ที่เรียกว่า Keras ซึ่งจะถูกสร้างขึ้นบนเฟรมเวิร์กการเรียนรู้เชิงลึกที่รู้จักกันดีเช่น TensorFlow หรือ CNTK เพื่อให้การสำรวจรวดเร็วยิ่งขึ้นโดยใช้โครงข่ายประสาทเทียมที่ลึกกว่า ได้รับการออกแบบมาให้ใช้งานง่าย ขยายได้ และปรับเปลี่ยนได้ มันจัดการทั้ง Feedforward และ Retractable Networks แยกจากกัน เช่นเดียวกับในคอมโบ ใช้แพ็คเกจแบ็กเอนด์เพื่อจัดการกับการดำเนินการเล็กๆ เนื่องจากไม่สามารถจัดการได้ บทเรียนนี้ครอบคลุมถึงการใช้งาน Keras พื้นฐานของการเรียนรู้เชิงลึก โครงสร้าง Keras เลเยอร์ Keras แพ็คเกจ Keras และการเขียนโปรแกรมแบบเรียลไทม์

ตั้งค่า Keras บน Linux

ขั้นตอนที่ 01: อัปเดตระบบ

ก่อนที่จะมีการสาธิตการใช้งานไลบรารี 'Keras' ของ Python อย่างเต็มรูปแบบ เราต้องอัปเดตเครื่อง Linux ของเราอย่างเต็มที่เพื่อให้ง่ายต่อการติดตั้งเพิ่มเติม เพื่อจุดประสงค์นี้ เราต้องเปิดแอปพลิเคชัน 'คอนโซล' อย่างรวดเร็วจากแอปพลิเคชันในตัวของระบบ ภายในพื้นที่การสืบค้นโดยเฉพาะ เราได้เพิ่มการสืบค้น “อัปเดต” ของ Linux ด้วยยูทิลิตี้ “apt” และสิทธิ์ “sudo” เพื่ออัปเดตระบบที่เรามีอย่างรวดเร็ว ต้องใช้รหัสผ่านผู้ใช้ของเราเพื่อดำเนินการตามขั้นตอนนี้เพื่อให้ระบบของเราสามารถอัปเดตได้อย่างถูกต้อง

ขั้นตอนที่ 02: ติดตั้ง Python และ Pip

สำหรับการใช้ Deep Learning ผ่าน Keras และ TensorFlow เราจะต้องกำหนดค่าเวอร์ชันล่าสุดของ Python ในเครื่องของเรา ดังนั้นเราจึงเริ่มติดตั้งแพ็คเกจที่อัปเดตของ Python พร้อมกับยูทิลิตี้ 'pip' ที่จำเป็นในระบบของเรา ในการนั้น เราต้องใช้ยูทิลิตี้ “apt” ของระบบ Ubuntu 20.04 Linux อีกครั้งในแบบสอบถาม “ติดตั้ง” บนเชลล์ ตามด้วยชื่อของแพ็คเกจที่จะติดตั้ง เช่น Python3 และ Python3-pip ในการเรียกใช้แบบสอบถามอย่างง่ายนี้บนพื้นที่คอนโซล ระบบจะเริ่มติดตั้งและกำหนดค่าทั้งสองแพ็คเกจในระบบของเรา

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

หลังจากกำหนดค่า Python และยูทิลิตี้ 'pip' สำเร็จแล้ว ก็ถึงเวลาอัปเกรด Setuptools สำหรับ Python เพื่อหลีกเลี่ยงปัญหาใดๆ ในอนาคตอันใกล้นี้ ดังนั้นเราจึงได้ลองค้นหาการติดตั้งด้วยยูทิลิตี้ “pip3” และตัวเลือก –upgrade เพื่อติดตั้งการอัปเกรด Setuptools เช่น เครื่องมือการตั้งค่า จะขอรหัสผ่านปัจจุบันที่เรามีสำหรับระบบของเรา และเราได้เพิ่มเข้าไปแล้ว

ขั้นตอนที่ 03: ติดตั้ง TensorFlow

สำหรับการสร้างแมชชีนเลิร์นนิงและโมเดลประสาทภายใต้การดูแล TensorFlow เป็นแพ็คเกจคณิตศาสตร์เชิงสัญลักษณ์ที่เป็นที่รู้จักมากที่สุด หลังจากผ่านการติดตั้ง เราได้ดำเนินการค้นหาการติดตั้ง 'pip3' เดียวกัน ตามด้วยชื่อแพ็คเกจ 'Tensorflow'

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

ขั้นตอนที่ 04: ติดตั้งแพ็คเกจที่จำเป็น

หลังจากการกำหนดค่า TensorFlow อย่างมีประสิทธิภาพในระบบ Ubuntu 20.04 เรายังต้องกำหนดค่าแพ็คเกจการสร้างบางอย่างพร้อมกับยูทิลิตี้อื่น ๆ เช่น 'git' และ 'cmake' ด้วยการลองใช้เครื่องมือ “apt” เดียวกัน เราได้ติดตั้งแพ็คเกจที่จำเป็นมากมาย ดังที่แสดงด้านล่าง:

ขั้นตอนนี้ให้ความสนใจมากที่สุดโดยการยืนยันการติดตั้งนี้ แตะ 'y' และดำเนินการต่อ

ขั้นตอนที่ 05: สร้างสภาพแวดล้อมเสมือน

หลังจากการติดตั้งที่จำเป็น ก็ถึงเวลาสร้างสภาพแวดล้อมเสมือน ดังนั้นเราจึงต้องใช้ยูทิลิตี้ Python3 พร้อมตัวเลือก '-m' เพื่อสร้างสภาพแวดล้อมเสมือน 'kerasenv' ผ่านตัวแปร 'venv' แบบสอบถาม 'ls' แสดงว่าสภาพแวดล้อมถูกสร้างขึ้น

ตอนนี้ เราต้องย้ายภายในสภาพแวดล้อมเสมือนของโฟลเดอร์ Keras ดังนั้นเราจึงใช้คำสั่ง 'cd' ร่วมกับชื่อโฟลเดอร์สภาพแวดล้อมเสมือน หลังจากนั้น เราได้ย้ายภายในโฟลเดอร์ 'bin' ของสภาพแวดล้อมเสมือนนี้และแสดงรายการย่อย เพื่อเปิดใช้งานสภาพแวดล้อม Python นี้ เราได้ลองใช้คำสั่ง 'แหล่งที่มา' ที่พื้นที่สืบค้นพร้อมกับไฟล์ 'เปิดใช้งาน' สภาพแวดล้อมเสมือนได้รับการเปิดใช้งานด้วยชื่อ “kerasenv”

ขั้นตอนที่ 06: ติดตั้ง Python Libraries

หลังจากตั้งค่าสภาพแวดล้อมเสมือน Python สำเร็จแล้ว คุณต้องติดตั้งไลบรารี Python ที่จำเป็นทั้งหมดก่อนการติดตั้ง Keras ดังนั้นเราจึงได้ติดตั้งไลบรารี่ของแพนด้าก่อนในสภาพแวดล้อมเสมือนเดียวกันโดยใช้แพ็คเกจ 'pip' ของ Python

ระบบจะเริ่มกำหนดค่าภายในสภาพแวดล้อมเสมือนของ Python ดังที่แสดงในภาพ:

หลังจากติดตั้งไลบรารี่ของแพนด้าแล้ว ให้ลองติดตั้งไลบรารี NumPy โดยใช้วิธีการต่อไปนี้:

ในทำนองเดียวกัน ให้ติดตั้งไลบรารี scipy ของ Python ในสภาพแวดล้อมเดียวกัน

ตอนนี้ ติดตั้งไลบรารี matplotlib ของ Python ในสภาพแวดล้อม

Python ใช้อัลกอริธึมการจัดกลุ่มและการถดถอยในการเรียนรู้ของเครื่องเพื่อดำเนินการโมเดลโครงข่ายประสาทเทียม สำหรับสิ่งนี้ มันมีไลบรารีเรียนรู้ sci-kit ที่เรากำลังติดตั้งด้วยยูทิลิตี้ 'pip' พร้อมกับตัวเลือก '-u' เพื่อกำหนดค่าแพ็คเกจที่จำเป็นเช่นกัน

การประมวลผลการติดตั้งไลบรารี scikit แสดงไว้ด้านล่าง:

สำหรับการแสดงภาพในการเรียนรู้เชิงลึก เราจำเป็นต้องติดตั้งไลบรารี่ของ Python ในทะเล ดังนั้นเราจึงทำการติดตั้งในสภาพแวดล้อมเดียวกันกับแบบสอบถาม 'ติดตั้ง'

ขั้นตอนที่ 07: ติดตั้ง Keras Library

หลังจากติดตั้งไลบรารี่ที่จำเป็นทั้งหมดของ Python ในที่สุด เราก็สามารถติดตั้ง Keras ภายในสภาพแวดล้อมเสมือนของ Python ได้ ยูทิลิตี 'pip' จะถูกใช้เพื่อจุดประสงค์นี้ภายในแบบสอบถาม 'ติดตั้ง' ของเราด้วยชื่อโมดูล เช่น 'Keras' หากระบบแสดงว่าเป็นไปตามข้อกำหนดแล้ว แสดงว่าได้รับการติดตั้งและกำหนดค่าแล้ว

หากยังไม่ได้ติดตั้ง แบบสอบถามนี้จะเริ่มดาวน์โหลดและกำหนดค่าในสภาพแวดล้อมเสมือนโดยไม่ชักช้าหนึ่งวินาทีและการประมวลผลจะแสดงดังต่อไปนี้:

หลังจากการกำหนดค่าเต็มรูปแบบและการติดตั้งไลบรารี 'Keras' บน Virtual Environment ก็ถึงเวลาแสดงข้อมูลทั้งหมดเกี่ยวกับไลบรารีบนเชลล์โดยใช้แบบสอบถาม 'pip show' การดำเนินการของข้อความค้นหา 'แสดง' นี้ได้นำเสนอเวอร์ชันของ Keras ที่ติดตั้งในสภาพแวดล้อมเสมือนของ Python, ชื่อ, ข้อมูลสรุป, หน้าแรกของเว็บ, ผู้แต่ง, อีเมลของผู้เขียน, ใบอนุญาต, ตำแหน่งที่ใช้ในระบบของเรา และอื่นๆ เพิ่มเติมตามที่แสดงด้านล่าง:

หลังจากการติดตั้งที่ดีที่สุดของไลบรารี Keras และ TensorFlow ของ Python เราจำเป็นต้องออกจากสภาพแวดล้อมเสมือน ให้ลองใช้แบบสอบถาม 'ปิดใช้งาน' บนเชลล์แล้วออก

ขั้นตอนที่ 08: ติดตั้ง Anaconda Cloud

Python มีคลาวด์ชื่อ “Anaconda” ซึ่งจำเป็นต่อการสร้างตัวอย่างโครงข่ายประสาทเทียมใน Python ดังนั้นเราจึงดาวน์โหลดไฟล์การดำเนินการไปยังระบบของเรา

ไฟล์นี้อยู่ในโฮมโฟลเดอร์ปัจจุบันของเครื่อง Linux ตามคำสั่ง 'ls' คุณต้องตรวจสอบให้แน่ใจว่าเป็นเช็คซัมก่อน กล่าวคือ ถูกต้องหรือไม่ผ่านการสืบค้น sha256sum

หลังจากนั้น เราต้องติดตั้งไฟล์ Bash ที่ดาวน์โหลดของอนาคอนด้าในระบบของเราโดยใช้คำสั่ง 'Bash' และชื่อไฟล์บนคอนโซลเดียวกัน มีการขอให้เราตรวจสอบข้อตกลงใบอนุญาตก่อนการติดตั้ง ดังนั้นเราจึงแตะ 'Enter' เพื่อดำเนินการต่อ

หลังจากผ่านข้อตกลงใบอนุญาตแล้ว ระบบจะขอให้เราแตะ 'ใช่' หากเรายอมรับข้อกำหนด คุณต้องกด Enter เพื่อดำเนินการติดตั้งต่อที่เดิมหรือเขียนพาธไปยังไดเร็กทอรีที่คุณต้องการติดตั้ง มิฉะนั้น ให้ใช้ “Ctrl-c” เพื่อยกเลิกการติดตั้ง

มันจะแสดงรายการแพ็คเกจยาว ๆ ที่จะติดตั้งในกระบวนการนี้ หลังจากดำเนินการธุรกรรมบางอย่างแล้ว จะเริ่มติดตั้งแพ็คเกจ

หลังจากนั้นไม่นาน อนาคอนด้าก็ได้รับการติดตั้งสำเร็จด้วยแพ็คเกจเพิ่มเติม

คุณต้องเรียกใช้ไฟล์ 'เปิดใช้งาน' จากโฟลเดอร์อนาคอนดาผ่านแบบสอบถาม 'แหล่งที่มา' เป็นรูท

ลองเปิดใช้ตัวนำทางอนาคอนดาโดยใช้แบบสอบถามต่อไปนี้

ในการสร้างและทำงานกับสภาพแวดล้อม conda ใหม่ ให้ลองใช้คำสั่ง 'conda create' พร้อมตัวเลือกชื่อตามด้วยชื่อสภาพแวดล้อมใหม่ เช่น PyCPU

กระบวนการนี้ต้องการการยืนยันจากเราเกี่ยวกับการสร้างสภาพแวดล้อมใหม่ แตะ 'y'

ในการเปิดใช้งานและเรียกใช้สภาพแวดล้อม conda ที่สร้างขึ้นใหม่ ให้ใช้แบบสอบถาม 'conda activate' ด้วยชื่อสภาพแวดล้อมใหม่ของคุณ นั่นคือ สภาพแวดล้อม PyCPU ถูกเปิดใช้งานแล้ว

ขั้นตอนที่ 09: ติดตั้ง Spyder IDE

ต้องติดตั้ง Spyder IDE ภายในสภาพแวดล้อมนี้เพื่อเรียกใช้โปรแกรม Python สำหรับสิ่งนี้ เราได้ลองใช้คำค้นหาการติดตั้ง conda ที่เชลล์สภาพแวดล้อม PyCPU ด้วยคำหลัก 'spyder'

แตะ “y” เพื่อติดตั้ง Spyder ต่อ

ขั้นตอนที่ 10: ติดตั้ง Pandas และ Keras Library

หลังจากติดตั้ง Spyder แล้ว ให้ติดตั้งไลบรารี Python ของแพนด้าในสภาพแวดล้อมอนาคอนดาโดยใช้คิวรีการติดตั้ง conda ด้วยตัวเลือก –c

อีกครั้งให้กดปุ่ม 'y' เพื่อดำเนินการต่อ

หลังจากกำหนดค่าแพนด้าสำเร็จแล้ว ให้ติดตั้งไลบรารี Keras ด้วยแบบสอบถามเดียวกัน

ดำเนินการต่อหลังจากคลิกปุ่ม 'y'

คุณสามารถเปิดใช้ Spyder IDE ภายในคอนโซลสภาพแวดล้อมปัจจุบันของอนาคอนดาได้ดังนี้:

Spyder IDE ได้รับการเตรียมที่จะเปิดตัว

โฟลเดอร์ที่ซ่อนอยู่ '.keras' อยู่ในโฮมไดเร็กทอรี เลิกซ่อนและเปิดไฟล์ 'keras.json' เพื่อเพิ่มการกำหนดค่าต่อไปนี้

ตั้งค่า Keras และ TensorFlow บน Windows

ในการตั้งค่า Keras และ TensorFlow ในสภาพแวดล้อม Windows คุณต้องตรวจสอบให้แน่ใจว่าได้ตั้งค่าภาษา Python พร้อมกับไลบรารี 'pip' และ Anaconda Navigator แล้ว หลังจากตั้งค่าแล้ว คุณควรเปิดจากพื้นที่ค้นหาและย้ายภายในแท็บ 'สภาพแวดล้อม' ในแท็บนี้ คุณจะพบชื่อสภาพแวดล้อมที่คุณกำลังทำงานอยู่ เช่น ฐาน ในพื้นที่ด้านล่าง คุณจะพบแท็บต่อไปนี้ แตะตัวเลือก 'สร้าง'

ที่นี่ คุณต้องสร้างชื่อสภาพแวดล้อมใหม่ “TensorFlow” นั่นคือปัจจุบันอยู่ในสภาพแวดล้อมพื้นฐาน เลือกเวอร์ชันล่าสุดของ Python ที่จะใช้แล้วแตะปุ่ม 'สร้าง' เพื่อดำเนินการต่อ

คุณจะเห็นว่าสภาพแวดล้อมเริ่มโหลดแล้ว

หลังจากนั้นไม่นาน สภาพแวดล้อม TensorFlow จะได้รับการติดตั้งอย่างสมบูรณ์

จากพื้นที่ซ้ายสุด คุณสามารถดูไลบรารีและโมดูลที่ติดตั้งและพร้อมใช้งานทั้งหมดสำหรับ Python ดังที่แสดงด้านล่าง:

ตอนนี้ เราต้องติดตั้ง TensorFlow backend library ของ Python โดยใช้พื้นที่นี้ ในแถบค้นหา ให้เขียนว่า “TensorFlow” และทำเครื่องหมายแพ็คเกจเคสเดียวกันจากรายการที่แสดงเพื่อติดตั้ง แตะที่ปุ่ม 'ใช้' เพื่อดำเนินการติดตั้ง TensorFlow พร้อมกับโมดูลย่อยเช่น 'Keras'

เริ่มทำงานและกำหนดค่า TensorFlow ในสภาพแวดล้อม Anaconda ของเราแล้ว

ขณะติดตั้ง จะแสดงรายการของแพ็คเกจย่อยที่จะติดตั้งบนสภาพแวดล้อม Anaconda กดปุ่ม 'Apply' และรอสักครู่จนกว่าจะเสร็จสิ้น

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

จากแถบ Windows Search ค้นหาด้วยคำสำคัญ “Jupyter” แอปพลิเคชันชื่อ “Jupyter Notebook (TensorFlow)” จะแสดงร่วมกับแอปอื่นๆ แตะที่ภาพเพื่อเปิดใช้ jupyter Notebook โดยเปิดใช้ TensorFlow แบ็กเอนด์ สร้างไฟล์ Python ใหม่และเริ่มทำงาน

การเรียนรู้อย่างลึกซึ้งผ่านฮาร์ด

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

โครงข่ายประสาทเทียม (ANN)

วิธีการ 'โครงข่ายประสาทเทียม' (ANN) ดูเหมือนจะเป็นวิธีการเรียนรู้เชิงลึกที่ใช้กันอย่างแพร่หลายและเป็นพื้นฐานที่สุด พวกเขาเอาตัวชี้นำออกจากจิตใจมนุษย์ ซึ่งเป็นองค์ประกอบที่ซับซ้อนที่สุดตามธรรมชาติของร่างกายเรา ซึ่งทำหน้าที่เป็นแบบจำลอง เซลล์ขนาดเล็กกว่า 90 พันล้านเซลล์ที่เรียกว่า 'เซลล์ประสาท' ประกอบขึ้นเป็นสมองของแต่ละคน แอกซอนและเดนไดรต์เป็นเส้นใยประสาทชนิดหนึ่งที่เชื่อมโยงเซลล์ประสาทเข้าด้วยกัน หน้าที่หลักของแอกซอนคือการส่งข้อมูลจากเซลล์ประสาทที่เชื่อมโยงหนึ่งไปยังอีกเซลล์หนึ่ง สำหรับข้อมูลเพิ่มเติม โปรดค้นหาจาก Google Search Engine

สถาปัตยกรรม Keras

สถาปัตยกรรม Keras API แบ่งออกเป็นสามส่วนหลักตามรายการด้านล่าง มาปลอมตัวกันให้ชัดเจน

• แบบอย่าง
• ชั้น
• โมดูลหลัก

ฮาร์ดโมเดล

โมเดล Keras ประกอบด้วยสองประเภท นั่นคือ API แบบลำดับและการทำงาน

แบบจำลองตามลำดับ

โดยพื้นฐานแล้ว โมเดลตามลำดับคือการรวบรวม Keras Layers ตามลำดับเวลา แบบจำลองลำดับที่เรียบง่ายและเรียบง่ายสามารถอธิบายโครงข่ายประสาทเทียมเกือบทั้งหมดที่กำลังใช้งานอยู่ในปัจจุบัน โมเดลที่กำหนดเองสามารถทำได้โดยใช้คลาส Model ที่โมเดลตามลำดับเปิดเผย วิธีการจัดกลุ่มย่อยอาจใช้เพื่อสร้างแบบจำลองที่ซับซ้อนของเราเอง การสาธิตของแบบจำลองตามลำดับได้แสดงไว้ด้านล่าง

เพิ่มเลเยอร์

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

เข้าถึงรุ่น

คุณสามารถรับข้อมูลเกี่ยวกับเลเยอร์โมเดลของคุณ ข้อมูลอินพุตที่ใช้ และข้อมูลเอาต์พุต ฟังก์ชัน model.layers ช่วยให้คุณเข้าถึงเลเยอร์ทั้งหมดได้ model.inputs จะแสดงเมตริกซ์อินพุต และ model.output จะแสดงเมตริกซ์เอาต์พุต

ทำให้โมเดลเป็นอนุกรม

ง่ายต่อการส่งคืนโมเดลที่ใช้ในสคริปต์เป็นวัตถุหรือ JSON ตัวอย่างเช่น ฟังก์ชัน get_config() ให้โมเดลเป็นเอนทิตี/อ็อบเจ็กต์ ฟังก์ชัน from_config() สร้างโมเดลใหม่โดยใช้วัตถุเป็นค่าพารามิเตอร์

คุณยังสามารถเปลี่ยนโมเดลของคุณเป็น JSON โดยใช้ฟังก์ชัน to_json()

สรุปโมเดล

หากต้องการรับข้อมูลสรุปทั้งหมดเกี่ยวกับเลเยอร์ที่ใช้ภายในโมเดลพร้อมกับข้อมูลเพิ่มเติม ให้เรียกใช้ฟังก์ชันสรุป ()

ฝึกและทำนายแบบจำลอง

ในการฝึกและทำนาย เราควรใช้ฟังก์ชันคอมไพล์ ฟังก์ชันพอดี ประเมินฟังก์ชัน และคาดการณ์ฟังก์ชันในเรื่องนี้

ฮาร์ดเลเยอร์

ทุกเลเยอร์อินพุต การปกปิด และผลลัพธ์ในโมเดลที่แนะนำของโครงข่ายประสาทเทียมจะสอดคล้องกับเลเยอร์ Keras ที่แตกต่างกันในโมเดลจริง โครงข่ายประสาทเทียมที่ซับซ้อนสามารถพัฒนาได้อย่างรวดเร็วโดยใช้เลเยอร์ที่สร้างไว้ล่วงหน้าจำนวนมากของไลบรารี Keras มีเลเยอร์ Keras ที่แตกต่างกัน เช่น เลเยอร์หลัก เลเยอร์การรวม เลเยอร์ที่เกิดซ้ำ และเลเยอร์การบิด คุณสามารถศึกษาได้โดยการค้นหาในเว็บ สองบรรทัดแรกได้นำเข้าโหมด Sequential, หนาแน่น, การเปิดใช้งานและเลเยอร์ Dropout

เราได้ลองใช้ Sequential() API เพื่อสร้างโมเดลลำดับการออกกลางคัน ด้วยการยกเลิกโมเดลการเปิดใช้งาน 'relu' เราได้สร้างเลเยอร์ที่หนาแน่นผ่าน API 'Dense' เพื่อรองรับเลเยอร์ที่หนาแน่นมากเกินไป เราได้ใช้ API ของ Dropout() เช่น การวางเลเยอร์ dropout ผ่านฟังก์ชัน dropout() หลังจากนี้ เราใช้เลเยอร์ที่มีความหนาแน่นมากขึ้นที่นี่กับโมเดลการเปิดใช้งาน 'relu' ในการจัดการเลเยอร์ที่หนาแน่นจากการใส่มากเกินไป เราต้องใช้เลเยอร์ Dropout ในท้ายที่สุด เราได้ตัดเลเยอร์ที่หนาแน่นขั้นสุดท้ายออกโดยใช้โมเดลการเปิดใช้งานประเภท 'softmax'

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

• ป้อนข้อมูลรูปร่าง
• เซลล์ประสาททั้งหมด/หน่วยในชั้นหนึ่ง
• ตัวเริ่มต้น
• Regularizers
• ข้อจำกัด
• การเปิดใช้งาน

ป้อนข้อมูลรูปร่าง

ภายในภาษา Python อินพุตทุกประเภทจะถูกแปลงเป็นอาร์เรย์ของจำนวนเต็ม จากนั้นจึงเพิ่มลงในโมเดลอัลกอริธึม ภายใน Python เราจำเป็นต้องระบุรูปร่างอินพุตเพื่อรับเอาต์พุตตามความต้องการของเรา ในตัวอย่างต่อไปนี้ เราได้ระบุรูปร่างอินพุต (3,3) เช่น 3 แถวและ 3 คอลัมน์ ผลลัพธ์ได้รับการแสดงเมทริกซ์

ตัวเริ่มต้น

โมดูล initializers ของ Keras Layers มีฟังก์ชันมากมายเพื่อระบุน้ำหนักเฉพาะสำหรับข้อมูลที่ป้อนเข้า ตัวอย่างเช่น ฟังก์ชัน zeros() ระบุ 0 สำหรับทุกคน โดย one() จะระบุทั้งหมด และฟังก์ชัน constant() จะระบุค่าคงที่ที่ระบุซึ่งเพิ่มโดยผู้ใช้ทั้งหมด และอื่นๆ เพื่อความเข้าใจที่ดีขึ้น เราได้ใช้ฟังก์ชัน identity() เพื่อสร้างเมทริกซ์เอกลักษณ์ ฟังก์ชั่นที่เหลือสามารถค้นหาได้จากเครื่องมือค้นหา

ข้อจำกัด

มีฟังก์ชันข้อจำกัดต่างๆ ที่ใช้ได้เพื่อใช้ข้อจำกัดกับพารามิเตอร์ 'น้ำหนัก' ของเลเยอร์ เช่น non-negative, unit norm, max norm, minmaxnorm และอื่นๆ อีกมากมาย ในภาพประกอบต่อไปนี้ เราได้นำบรรทัดฐานข้อจำกัดที่น้อยกว่าหรือเท่ากับน้ำหนัก พารามิเตอร์ “max_value” คือขอบเขตบนของข้อจำกัดที่จะนำไปใช้ และแกนคือมิติที่จะใช้ข้อจำกัดดังกล่าว กล่าวคือ มิติที่ 1

Regularizers

ตลอดการปรับให้เหมาะสม จะเรียกเก็บค่าใช้จ่ายต่างๆ ในคุณสมบัติของเลเยอร์ นอกจากนี้ยังมีฟังก์ชั่นบางอย่างที่ต้องทำเช่น L1 Regularizer, L2 Regularizer และ Regularizer 'LI และ L2' นี่คือภาพประกอบที่ง่ายที่สุดของฟังก์ชัน L1 Regularizer:

การเปิดใช้งาน

ฟังก์ชันพิเศษที่เรียกว่าฟังก์ชันกระตุ้นถูกใช้เพื่อตรวจสอบว่าเซลล์ประสาทเฉพาะนั้นทำงานอยู่หรือไม่ ฟังก์ชันการเปิดใช้งานจะเปลี่ยนข้อมูลที่เข้ามาในลักษณะที่ซับซ้อน ซึ่งช่วยให้เซลล์ประสาทศึกษาได้อย่างมีประสิทธิภาพมากขึ้น ต่อไปนี้คือวิธีการเปิดใช้งานหลายวิธีที่นำเสนอในตัวอย่างด้านล่าง:

โมดูลฮาร์ด

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

แบ็กเอนด์

หนึ่งในโมดูลที่เป็นที่รู้จักและใช้กันมากที่สุดคือโมดูล 'แบ็กเอนด์' ที่ได้รับการออกแบบมาเพื่อใช้ไลบรารีแบ็กเอนด์ของ Python เช่น TensorFlow และ Theano ด้วยการใช้โมดูลแบ็กเอนด์ เราสามารถใช้ฟังก์ชันแบ็กเอนด์ได้มากเท่าที่เป็นไปได้จากไลบรารี TensorFlow และ Theano ในการใช้โมดูลไลบรารีแบ็กเอนด์ เราจำเป็นต้องระบุไลบรารีแบ็กเอนด์ที่จะใช้ในไฟล์คอนฟิกูเรชัน “keras.json ซึ่งเราสร้างไว้ในโฟลเดอร์ .keras ที่ซ่อนอยู่ โดยค่าเริ่มต้น แบ็กเอนด์ถูกระบุเป็น “TensorFlow” แต่คุณสามารถเปลี่ยนเป็นแบ็กเอนด์อื่นได้เช่นกัน เช่น Theano หรือ CNTK

ภายในตัวอย่างของเรา เราจะใช้ไลบรารี TensorFlow เป็นแบ็กเอนด์ ในการโหลดการกำหนดค่าของแบ็กเอนด์จากไฟล์ keras.json ของโฟลเดอร์ root “keras” ให้ใช้:

• จาก keras นำเข้าแบ็กเอนด์เป็น k

หลังจากนำเข้าแบ็กเอนด์จากไฟล์ keras.json สำเร็จแล้ว ก็ถึงเวลารับข้อมูลแบ็กเอนด์โดยใช้ตัวแปร “k” กับตัวแปรที่จะดึงข้อมูล อันดับแรก เราได้ดึงชื่อแบ็กเอนด์ที่เราใช้และนำเข้าแล้วโดยใช้ฟังก์ชัน “backend()” จะส่งคืน 'Tensorflow' เป็นค่าแบ็กเอนด์ ในการรับค่า float ของแบ็กเอนด์ เราได้เรียกใช้ฟังก์ชัน floatx() ผ่านออบเจกต์ตัวแปร 'k' ของ Keras แสดงว่าเราใช้ค่า float32

ในการรับรูปแบบของข้อมูลภาพ ให้ใช้ฟังก์ชัน image_Data_format() กับตัวแปร “k” เมื่อใช้งาน แสดงว่าแบ็กเอนด์ของเราใช้รูปแบบข้อมูลภาพ “channels_last” ในการรับกำลังเลขชี้กำลังสำหรับแบ็กเอนด์ ให้เรียกใช้ฟังก์ชัน epsilon() ด้วยตัวแปร “k” ส่งคืนว่าแบ็กเอนด์จะใช้กำลังเลขชี้กำลังของ '07' นั่นคือทั้งหมดที่เกี่ยวกับการดึงข้อมูลแบ็กเอนด์

ฟังก์ชัน Get_uid()

ได้เวลาดูฟังก์ชันแบ็กเอนด์ของ TensorFlow เพื่อทำความเข้าใจฟังก์ชันการทำงาน หนึ่งในฟังก์ชันแบ็กเอนด์ที่ใช้มากที่สุด 'get_uid() ฟังก์ชันที่ใช้ในการระบุกราฟเริ่มต้นที่เราใช้ การใช้กับพารามิเตอร์ prefix='' จะส่งกลับ '1' เช่นตามการใช้งาน อีกครั้ง การใช้มันจะคืนค่า '2' ในขณะที่เราเรียกมันอีกครั้งและค่าของกราฟเพิ่มขึ้น หลังจากใช้ฟังก์ชัน “reset_uids” ค่า ID ผู้ใช้ของกราฟจะถูกรีเซ็ตเป็น 0 ดังนั้น การใช้ฟังก์ชัน get_uid() อีกครั้งจะเพิ่มขึ้น 1

ตัวยึดตำแหน่ง() ฟังก์ชั่น

เทนเซอร์ใช้ฟังก์ชัน placeholder() เพื่อเก็บรูปร่างมิติต่างๆ ตัวอย่างเช่น ในภาพประกอบต่อไปนี้ เราได้ใช้มันเพื่อเก็บภาพสามมิติในเทนเซอร์ผ่านตัวแปร Keras 'k' และบันทึกลงในตัวแปร 'd' อื่น ผลลัพธ์ของตัวแปร “d” แสดงคุณสมบัติของรูปร่างที่ใช้ภายในตัวยึดตำแหน่ง

ฟังก์ชัน 'int_shape()' ใช้เพื่อแสดงรูปร่างของค่าที่บันทึกไว้ในตัวยึดตำแหน่ง 'd'

Dot() ฟังก์ชั่น

คุณเคยคูณเวกเตอร์สองตัวหรือไม่? ถ้าเป็นเช่นนั้น มันจะไม่ท้าทายสำหรับคุณที่จะคูณเทนเซอร์สองตัว ด้วยเหตุนี้ ไลบรารีแบ็กเอนด์จึงมาพร้อมกับฟังก์ชัน 'จุด' ขั้นแรก ในการเก็บรูปร่างที่แตกต่างกันสองแบบ เราได้ใช้ค่ารูปร่างในฟังก์ชัน placeholder() ใน 2 บรรทัดแรกเพื่อสร้างตัวยึด 'x' และ 'y' สองตัว ฟังก์ชัน dot() ได้ใช้ตัวจับ 'x' และ 'y' เพื่อคูณเมตริกซ์ทั้งสองและบันทึกผลลัพธ์ไปยังตัวแปรอื่น 'z' เมื่อใช้เทนเซอร์ “z” ในการพิมพ์ ระบบจะแสดงรูปร่างเทนเซอร์ผลลัพธ์แบบคูณ (1, 5) บนหน้าจอ

Ones() ฟังก์ชั่น

ฟังก์ชัน one() ของโมดูลแบ็กเอนด์เป็นที่ทราบกันดีอยู่แล้วสำหรับการกำหนดค่าเริ่มต้นของค่าทั้งหมดของรูปร่างนั้น ๆ เป็น 1 ตัวอย่างเช่น เราใช้ฟังก์ชัน ones() บนรูปร่างเทนเซอร์ (3,3) และบันทึกผลลัพธ์เป็น ตัวแปร 'v' ฟังก์ชัน eval() ถูกละทิ้งที่นี่เพื่อประเมินค่าของตัวแปร “v” และแสดงที่ในสภาพแวดล้อม Python ในทางกลับกัน มันได้แปลงรูปร่าง (3,3) เป็นเมทริกซ์อาร์เรย์ของทั้งหมดที่มีประเภทข้อมูล float32

Batch_dot() ฟังก์ชัน

ชุดเทนเซอร์จะระบุตัวอย่างทั้งหมดที่จะเรียงลำดับก่อนอัปเดตโมเดล ฟังก์ชัน batch_dot() ของแบ็กเอนด์ TensorFlow ส่วนใหญ่จะใช้เพื่อค้นหาผลการคูณของข้อมูลแบตช์สองชุดที่แตกต่างกัน ดังนั้นเราจึงได้สร้างตัวแปรเทนเซอร์สองตัว v1 และ v2 และใช้ฟังก์ชัน Input() เพื่อบันทึกใน v1 และ v2 เป็นอินพุต หลังจากนั้น เราได้ลองใช้ฟังก์ชัน batch_dot() กับทั้งตัวแปรเทนเซอร์ v1 และ v2 และค่าผลลัพธ์จะถูกบันทึกไว้ในตัวแปรอื่น 'v3' ในการพิมพ์ตัวแปร v3 เราพบผลลัพธ์ที่ได้รูปร่าง (2,2) ในทางกลับกัน

ฟังก์ชันตัวแปร

หากคุณเคยทำงานในภาษาอื่นมาก่อน คุณอาจได้เริ่มต้นตัวแปรหลายตัวโดยใช้คีย์เวิร์ด “var” หรือไม่ใช้ก็ได้ หลายครั้ง คุณอาจเริ่มต้นตัวแปรด้วยประเภทข้อมูล เช่น จำนวนเต็ม สตริง หรืออักขระ ภายในไลบรารี Python Keras เราสามารถสร้างตัวแปรใดๆ โดยใช้ฟังก์ชัน variable() กับข้อมูลเทนเซอร์บางตัวในรูปแบบของตัวอย่าง

ภายในรูปภาพต่อไปนี้ เราได้สร้างตัวแปร 'd' โดยการเพิ่มข้อมูลตัวอย่างสองรายการลงในฟังก์ชัน variable() ด้วยวัตถุ Keras 'k' หลังจากเพิ่มตัวแปรนี้ เราได้เรียกใช้ฟังก์ชัน transpose() ในตัวแปรนี้ 'd' เพื่อค้นหาทรานสโพสของข้อมูลตัวอย่างภายในตัวแปร Keras object 'k' ทรานสโพสที่เป็นผลลัพธ์จะถูกบันทึกลงในตัวแปร “val” มีการใช้คำสั่ง print ของภาษา Python เพื่อพิมพ์ค่าของตัวแปรผลลัพธ์ 'val' คำสั่งพิมพ์ได้แสดงตัวเลือกของฟังก์ชันที่เราใช้กับตัวแปร 'd' และจำนวนองค์ประกอบทั้งหมดในแต่ละรายการ

หลังจากนี้ เราลองใช้ฟังก์ชัน 'eval' บนตัวแปร 'val' เพื่อรับทรานสโพสของตัวอย่างที่เพิ่มลงในตัวแปร 'd' และฟังก์ชันการพิมพ์ก็แสดงขึ้น คุณสามารถดูทรานสโพสของสองรายการในผลลัพธ์

ภาพประกอบโค้ดก่อนหน้านี้ทำได้โดยการใช้ฟังก์ชัน Python อย่างง่ายโดยไม่ต้องนำเข้าไลบรารี Python ใดโดยเฉพาะ สามารถค้นหา 'transpose' ของชุดข้อมูลสองชุดได้โดยใช้อาร์เรย์ NumPy สำหรับสิ่งนี้ เราจำเป็นต้องนำเข้าไลบรารี NumPy เป็น “n” ในตอนเริ่มต้น รูปแบบพื้นฐานเหมือนกัน แต่เราจำเป็นต้องเริ่มต้นชุดข้อมูลรูปร่างด้วยคีย์เวิร์ด 'array' แทนการใช้คีย์เวิร์ด 'variable' ตัวอย่างอาร์เรย์ NumPy ควรเก็บไว้ที่ตัวแปร 'd' วัตถุ NumPy เดียวกัน 'n' ใช้เพื่อเรียกใช้ฟังก์ชัน transpose() บนตัวแปร 'd' และบันทึกผลลัพธ์ไปยังตัวแปร 'val'

คำสั่งพิมพ์เรียกตัวแปร 'val' เพื่อแสดงเทนเซอร์ทรานสโพส คุณสามารถเห็นได้ว่าเพื่อแสดงค่าทรานสโพสผลลัพธ์ของตัวแปร 'val' เราไม่ต้องการฟังก์ชัน 'eval' ที่นี่ ตอนนี้เราได้ใช้ฟังก์ชันตัวแปรที่มีอาร์กิวเมนต์ 'd' และบันทึกผลลัพธ์ลงในตัวแปร 'z' หลังจากลองพิมพ์คำสั่งโดยเพิ่มค่าอาร์กิวเมนต์ “z” เข้าไป คำสั่งนั้นจะแสดงผลลัพธ์ในรูปแบบเดียวกับที่เราได้ลองในตัวอย่างตัวแปรข้างต้น

Is_sparse() ฟังก์ชัน

คำว่า 'sparse' ในเทนเซอร์ใช้สำหรับเทนเซอร์แบบเบาบางที่มีรายการที่มีค่าศูนย์เป็นส่วนใหญ่ ภายในตัวอย่างนี้ เราจะใช้ฟังก์ชัน is_sparse() ของโมดูลแบ็กเอนด์เพื่อตรวจสอบว่าเมตริกซ์มีค่าศูนย์ส่วนใหญ่หรือไม่

อันดับแรก เราได้เรียกใช้ฟังก์ชัน placeholder() เพื่อคงรูปร่างเทนเซอร์ (3,3) พร้อมกับอาร์กิวเมนต์ Sparse ที่ตั้งค่าเป็นจริง ค่าตัวยึดตำแหน่งนี้จะถูกเก็บไว้ที่ 'x' ที่เปลี่ยนแปลงได้และแสดงขึ้น ผลลัพธ์แสดงข้อมูลเกี่ยวกับตัวแปรตัวยึดตำแหน่ง 'x'

ตัวอย่างเช่น ชนิดข้อมูล รูปร่าง และฟังก์ชันของข้อมูลถูกนำไปใช้กับข้อมูลดังกล่าว หลังจากนี้ เราลองใช้คำสั่ง print อีกครั้งโดยเรียกใช้ฟังก์ชัน is_Sparse() ในนั้น ฟังก์ชันนี้ใช้ตัวแปร 'x' เป็นอาร์กิวเมนต์เพื่อแสดงว่าเทนเซอร์ 'x' นั้นเบาบางหรือไม่ ผลลัพธ์จะแสดงเป็น 'จริง'

To_dense() ฟังก์ชัน

กล่าวกันว่าความหนาแน่นของเทนเซอร์เป็นสิ่งที่ใช้บล็อกตามลำดับเวลาของหน่วยความจำเพื่อเก็บข้อมูลในลักษณะที่อยู่ติดกันและแสดงค่าของข้อมูลเช่นกัน ฟังก์ชัน “to_dense()” ของโมดูลแบ็กเอนด์ทำให้เราแปลงเทนเซอร์เบาบางเป็นเทนเซอร์หนาแน่นได้ ดังนั้นเราจึงใช้ฟังก์ชันตัวยึดตำแหน่งเดียวกันเพื่อเพิ่มเทนเซอร์ให้กับตัวแปร 'x' และตั้งค่าเทนเซอร์นี้เป็น 'เบาบาง'

ฟังก์ชัน 'to_dense()' ใช้กับตัวแปรเทนเซอร์หนาแน่น 'x' เช่น เพื่อแปลงเป็นเมตริกซ์หนาแน่นและบันทึกลงใน 'res' ของตัวแปรอื่น ตอนนี้ 'res' เป็นเทนเซอร์ที่มีความหนาแน่นสูง คำสั่งพิมพ์ถูกยกเลิกเพื่อพิมพ์ตัวแปร 'res' การใช้คำสั่งพิมพ์สำหรับตัวแปร 'res' แสดงข้อมูลเกี่ยวกับตัวแปรที่แปลงเป็น 'res' กล่าวคือ แปลงเบาบางเป็นหนาแน่นได้สำเร็จและอีกมากมาย

จากนั้น ฟังก์ชันการพิมพ์อื่นจะถูกเรียกโดยใช้ฟังก์ชัน is_sparse() เพื่อตรวจสอบว่าตัวแปร 'res' นั้นเบาบางหรือไม่ ผลลัพธ์แสดงให้เห็นว่าตัวแปร “res” ไม่เบาบาง เช่น เนื่องจากเราได้แปลงเป็นเทนเซอร์ “หนาแน่น” แล้ว

Random_uniform_variable() ฟังก์ชั่น

ฟังก์ชัน random_uniform_variable() ในโมดูลแบ็กเอนด์ Keras ได้รับการออกแบบมาโดยเฉพาะสำหรับการเริ่มต้นเทนเซอร์ผ่านการแจกแจงแบบสม่ำเสมอ ใช้เวลาทั้งหมดสามอาร์กิวเมนต์ อาร์กิวเมนต์แรก “shape” ใช้เพื่อกำหนดแถวและคอลัมน์ของรูปร่างภายในฟอร์มทูเปิล หากคุณเคยทำคณิตศาสตร์มาแล้ว คุณอาจได้เรียนรู้แนวคิดของค่าเฉลี่ยและค่าเบี่ยงเบนมาตรฐาน

ในเมธอด random_uniform_variable() อาร์กิวเมนต์สองอาร์กิวเมนต์ถัดไปคือค่ากลางและค่าเบี่ยงเบนทั่วไปจากการแจกแจงแบบสม่ำเสมอ ภายในภาพประกอบนี้ เราได้เริ่มต้นเมตริกซ์สองตัว 'x' และ 'y' โดยใช้การแจกแจงแบบสม่ำเสมอมาตรฐานผ่านฟังก์ชัน random_uniform_variable() เมตริกซ์ทั้งสองมีรูปแบบรูปร่างที่แตกต่างกัน กล่าวคือ แถวและคอลัมน์ที่มีค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานเท่ากัน กล่าวคือ ต่ำ=0 และสูง=1

หลังจากนี้ เราจะเลิกใช้ฟังก์ชัน 'จุด' โดยใช้เทนเซอร์ 'x' และ 'y' ในการคูณ ผลลัพธ์ของการคูณนี้จะถูกบันทึกไว้ในตัวแปร “z” ในท้ายที่สุด int_shape() เป็นสิ่งที่ต้องใช้เพื่อแสดงรูปร่างของเทนเซอร์ที่เป็นผลลัพธ์ “z” ผลลัพธ์จะแสดงเทนเซอร์ (2,2)

ยูทิลิตี้

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

To_categorical() ฟังก์ชัน

ฟังก์ชันนี้อนุญาตให้คุณแก้ไขเวกเตอร์คลาสเป็นเมทริกซ์ เช่น เมทริกซ์คลาสไบนารี สมมติว่าเราได้นำเข้าฟังก์ชัน to_categorical() จากโมดูล utils และเริ่มต้นเวกเตอร์ 'A' เวกเตอร์ “A” ถูกส่งไปยังฟังก์ชัน to_categorical() แล้ว เมทริกซ์ไบนารีสำหรับเวกเตอร์คลาส 'A' นี้แสดงขึ้นแล้ว

print_summary() ฟังก์ชั่น

ในการพิมพ์สรุปของแบบจำลองที่เราได้คัดออกในสภาพแวดล้อมของเรา ฟังก์ชัน print_summary ถูกใช้

plot_model() ฟังก์ชั่น

ฟังก์ชัน plot_model() หมายถึงโมเดลในรูปแบบจุดและให้คุณบันทึกลงในเอกสารได้

บทสรุป

โดยสรุปแล้ว เราสามารถพูดได้ว่าภาษา Python เป็นภาษาที่จำเป็นสำหรับยุคปัจจุบัน เนื่องจากทุกสิ่งทุกอย่างกำลังดำเนินไปอย่างรวดเร็วและเทคโนโลยีได้พัฒนาไปอย่างรวดเร็วอย่างบ้าคลั่ง ตลอดแนวปฏิบัติการเรียนรู้นี้ เราใช้ไลบรารี Keras ของ Python ในการเรียนรู้เชิงลึกและโครงข่ายประสาทเทียม สำหรับสิ่งนี้ เราได้ผ่านความสำคัญและการใช้แบ็กเอนด์ไลบรารี “TensorFlow” เพื่อให้เข้าใจอย่างชัดเจน นอกจากนี้ เราได้พูดคุยและอธิบายทุกการกำหนดค่าที่จำเป็นในการตั้งค่าสภาพแวดล้อม Keras และ Anaconda ใน Python ภายในระบบปฏิบัติการ Ubuntu 20.04 Linux หลังจากนี้ เราได้พูดถึง Keras Models, Layers และ Modules อย่างละเอียดทีละตัวพร้อมกับฟังก์ชันที่ใช้บ่อยที่สุด สำหรับการสาธิตโมเดล Function API โปรดตรวจสอบเอกสารอย่างเป็นทางการ