ปัญญาประดิษฐ์ (AI) ได้รับความนิยมอย่างมากในช่วงไม่กี่ปีที่ผ่านมา
หากคุณเป็นวิศวกรซอฟต์แวร์ นักวิทยาศาสตร์คอมพิวเตอร์ หรือผู้คลั่งไคล้วิทยาศาสตร์ข้อมูลโดยทั่วไป คุณอาจรู้สึกทึ่งกับการใช้งานอันน่าทึ่งของการประมวลผลภาพ การจดจำรูปแบบ และการตรวจจับวัตถุที่มีให้ในสาขานี้
ฟิลด์ย่อยที่สำคัญที่สุดของ AI ที่คุณอาจเคยได้ยินคือ Deep Learning ฟิลด์นี้มุ่งเน้นไปที่อัลกอริธึมที่ทรงพลัง (คำสั่งโปรแกรมคอมพิวเตอร์) ซึ่งจำลองตามการทำงานของสมองมนุษย์ที่เรียกว่า โครงข่ายประสาทเทียม.
ในบทความนี้ เราจะพูดถึงแนวคิดของ Neural Networks และวิธีสร้าง รวบรวม ปรับและประเมินโมเดลเหล่านี้โดยใช้ หลาม.
โครงข่ายประสาทเทียม
Neural Networks หรือ NNs เป็นชุดของอัลกอริทึมที่สร้างแบบจำลองตามกิจกรรมทางชีววิทยาของสมองมนุษย์ Neural Networks ประกอบด้วยโหนดหรือที่เรียกว่าเซลล์ประสาท
ชุดของโหนดแนวตั้งเรียกว่าชั้น โมเดลประกอบด้วยหนึ่งอินพุต หนึ่งเอาต์พุต และเลเยอร์ที่ซ่อนอยู่จำนวนหนึ่ง แต่ละชั้นประกอบด้วยโหนดหรือที่เรียกว่าเซลล์ประสาทซึ่งทำการคำนวณ
ในแผนภาพต่อไปนี้ วงกลมแสดงถึงโหนด และคอลเลกชันแนวตั้งของโหนดแสดงถึงเลเยอร์ รุ่นนี้มีสามชั้น
โหนดของชั้นหนึ่งเชื่อมต่อกับชั้นถัดไปผ่านสายส่งดังที่แสดงด้านล่าง
ชุดข้อมูลของเราประกอบด้วยข้อมูลที่มีป้ายกำกับ ซึ่งหมายความว่าแต่ละเอนทิตีข้อมูลได้รับการกำหนดค่าชื่อที่แน่นอน
ดังนั้นสำหรับชุดข้อมูลการจำแนกสัตว์ เราจะมีภาพแมวและสุนัขเป็นข้อมูล โดยมี "แมว" และ "สุนัข" เป็นป้ายกำกับ
สิ่งสำคัญที่ควรทราบคือต้องแปลงป้ายกำกับเป็นค่าตัวเลขสำหรับโมเดลของเราเพื่อให้เข้าใจถึงฉลาก ดังนั้นฉลากรูปสัตว์ของเราจึงกลายเป็น '0' สำหรับแมวและ '1' สำหรับสุนัข ทั้งข้อมูลและป้ายกำกับถูกส่งผ่านโมเดล
การเรียนรู้
ข้อมูลจะถูกป้อนไปยังเอนทิตีโมเดลทีละรายการ ข้อมูลนี้แบ่งออกเป็นส่วนๆ และส่งต่อไปยังแต่ละโหนดของโมเดล โหนดดำเนินการทางคณิตศาสตร์ในส่วนเหล่านี้
คุณไม่จำเป็นต้องรู้ฟังก์ชันทางคณิตศาสตร์หรือการคำนวณสำหรับบทช่วยสอนนี้ แต่สิ่งสำคัญคือต้องมีแนวคิดทั่วไปเกี่ยวกับวิธีการทำงานของแบบจำลองเหล่านี้ หลังจากชุดการคำนวณในชั้นเดียว ข้อมูลจะถูกส่งไปยังชั้นถัดไปเป็นต้น
เมื่อสร้างเสร็จแล้ว แบบจำลองของเราจะคาดการณ์ป้ายกำกับข้อมูลที่เลเยอร์เอาต์พุต (เช่น ในปัญหาการจำแนกสัตว์ เราได้รับการคาดคะเน '0' สำหรับแมว)
จากนั้น โมเดลจะดำเนินการเปรียบเทียบค่าที่คาดการณ์ไว้กับค่าฉลากจริง
หากค่าตรงกัน แบบจำลองของเราจะใช้อินพุตถัดไป แต่ถ้าค่าต่างกัน แบบจำลองจะคำนวณความแตกต่างระหว่างค่าทั้งสองที่เรียกว่าการสูญเสีย และปรับการคำนวณโหนดเพื่อสร้างป้ายกำกับที่ตรงกันในครั้งต่อไป
กรอบการเรียนรู้เชิงลึก
ในการสร้าง Neural Networks ในโค้ด เราต้องนำเข้า กรอบการเรียนรู้เชิงลึก เรียกว่าไลบรารีโดยใช้ Integrated Development Environment (IDE) ของเรา
เฟรมเวิร์กเหล่านี้เป็นชุดของฟังก์ชันที่เขียนไว้ล่วงหน้าซึ่งจะช่วยเราในบทช่วยสอนนี้ เราจะใช้เฟรมเวิร์ก Keras เพื่อสร้างแบบจำลองของเรา
Keras เป็นไลบรารี Python ที่ใช้แบ็กเอนด์ปัญญาประดิษฐ์และการเรียนรู้เชิงลึกที่เรียกว่า เทนเซอร์โฟลว์ เพื่อสร้าง NNs ในรูปแบบของโมเดลลำดับอย่างง่ายได้อย่างง่ายดาย
Keras ยังมาพร้อมกับโมเดลที่มีอยู่ก่อนแล้วซึ่งสามารถใช้งานได้เช่นกัน สำหรับบทช่วยสอนนี้ เราจะสร้างแบบจำลองของเราเองโดยใช้ Keras
คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับกรอบการเรียนรู้เชิงลึกนี้ได้จาก เว็บไซต์ Keras.
การสร้างโครงข่ายประสาทเทียม (กวดวิชา)
มาต่อกันที่การสร้าง Neural Network โดยใช้ Python
คำชี้แจงปัญหา
Neural Networks เป็นวิธีแก้ปัญหาแบบ AI สำหรับบทช่วยสอนนี้ เราจะพูดถึง Pima Indians Diabetes Data ซึ่งมีให้ โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม.
UCI Machine Learning ได้รวบรวมชุดข้อมูลนี้ และมีเวชระเบียนของผู้ป่วยชาวอินเดีย แบบจำลองของเราต้องทำนายว่าผู้ป่วยจะเริ่มเป็นเบาหวานภายใน 5 ปีหรือไม่
กำลังโหลดชุดข้อมูล
ชุดข้อมูลของเราเป็นไฟล์ CSV ไฟล์เดียวที่เรียกว่า 'diabetes.csv' ซึ่งสามารถจัดการได้อย่างง่ายดายโดยใช้ Microsoft Excel
ก่อนสร้างแบบจำลองของเรา เราจำเป็นต้องนำเข้าชุดข้อมูลของเรา คุณสามารถใช้รหัสต่อไปนี้ได้:
นำเข้าแพนด้าเป็น pd
data = pd.read_csv('diabetes.csv')
x = data.drop (“ผลลัพธ์”)
y = ข้อมูล[“ผลลัพธ์”]
ที่นี่เราใช้ นุ่น ไลบรารีเพื่อให้สามารถจัดการข้อมูลไฟล์ CSV ของเรา read_csv() เป็นฟังก์ชันในตัวของ Pandas ที่ช่วยให้เราเก็บค่าในไฟล์ของเราไปยังตัวแปรที่เรียกว่า 'data'
ตัวแปร x มีชุดข้อมูลของเราโดยไม่มีข้อมูลผลลัพธ์ (ป้ายกำกับ) เราบรรลุสิ่งนี้ด้วยฟังก์ชัน data.drop() ที่ลบป้ายกำกับสำหรับ x ในขณะที่ y มีเฉพาะข้อมูลผลลัพธ์ (ป้ายกำกับ)
การสร้างแบบจำลองตามลำดับ
ขั้นตอนที่ 1: การนำเข้าไลบรารี
ประการแรก เราต้องนำเข้า TensorFlow และ Keras พร้อมกับพารามิเตอร์บางอย่างที่จำเป็นสำหรับโมเดลของเรา รหัสต่อไปนี้ช่วยให้เราทำสิ่งนี้ได้:
นำเข้าเทนเซอร์โฟลว์เป็น tf
จาก tensorflow นำเข้า keras
จาก tensorflow.keras.models นำเข้า Sequential
จาก tensorflow.keras.layers การเปิดใช้งานการนำเข้า Dense
จาก tensorflow.keras.optimizers นำเข้า Adam
จาก tensorflow.keras.metrics นำเข้า categorical_crossentropy
สำหรับแบบจำลองของเรา เรากำลังนำเข้าเลเยอร์ที่หนาแน่น เหล่านี้เป็นชั้นที่เชื่อมต่อกันอย่างสมบูรณ์ กล่าวคือ แต่ละโหนดในเลเยอร์หนึ่งเชื่อมต่ออย่างสมบูรณ์กับโหนดอื่นในเลเยอร์ถัดไป
เรายังนำเข้าและ การเปิดใช้งาน ฟังก์ชันที่จำเป็นสำหรับการปรับขนาดข้อมูลที่ส่งไปยังโหนด เครื่องมือเพิ่มประสิทธิภาพ ยังได้นำเข้ามาเพื่อลดการสูญเสีย
อดัมเป็นนักเพิ่มประสิทธิภาพที่มีชื่อเสียงที่ทำให้การคำนวณโหนดอัปเดตโมเดลของเรามีประสิทธิภาพมากขึ้นพร้อมกับ categorical_crossentropy ซึ่งก็คือ ประเภทของฟังก์ชันการสูญเสีย (คำนวณความแตกต่างระหว่างค่าฉลากจริงและค่าที่คาดการณ์ไว้) ที่เราจะใช้
ขั้นตอนที่ 2: การออกแบบแบบจำลองของเรา
โมเดลที่ฉันกำลังสร้างมีหนึ่งอินพุต (มี 16 ยูนิต) หนึ่งเลเยอร์ที่ซ่อนอยู่ (มี 32 ยูนิต) และเลเยอร์เอาต์พุตหนึ่งรายการ (มี 2 ยูนิต) ตัวเลขเหล่านี้ไม่ได้รับการแก้ไขและจะขึ้นอยู่กับปัญหาที่ระบุทั้งหมด
การกำหนดจำนวนหน่วยและชั้นที่เหมาะสมเป็นกระบวนการที่สามารถปรับปรุงการทำงานล่วงเวลาได้ผ่านการฝึกฝน การเปิดใช้งานสอดคล้องกับประเภทของการปรับขนาดที่เราจะดำเนินการกับข้อมูลของเราก่อนที่จะส่งผ่านโหนด
Relu และ Softmax เป็นฟังก์ชันการเปิดใช้งานที่มีชื่อเสียงสำหรับงานนี้
รุ่น = ลำดับ ([
หนาแน่น (หน่วย = 16, input_shape = (1,), การเปิดใช้งาน = 'relu'),
หนาแน่น (หน่วย = 32, การเปิดใช้งาน = 'relu'),
หนาแน่น (หน่วย = 2 การเปิดใช้งาน = 'softmax')
])
นี่คือลักษณะโดยสรุปของแบบจำลอง:
การฝึกโมเดล
โมเดลของเราจะได้รับการฝึกในสองขั้นตอน ขั้นแรกคือการคอมไพล์โมเดล (การรวมโมเดลเข้าด้วยกัน) และขั้นต่อไปคือการปรับโมเดลให้เข้ากับชุดข้อมูลที่กำหนด
สามารถทำได้โดยใช้ฟังก์ชัน model.compile() ตามด้วย model.fit()
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['ความถูกต้อง'])
model.fit(x, y, ยุค = 30, ขนาดแบตช์ = 10)
การระบุเมตริก 'ความแม่นยำ' ช่วยให้เราสังเกตความถูกต้องของแบบจำลองของเราได้ในระหว่างการฝึกอบรม
เนื่องจากป้ายกำกับของเราอยู่ในรูปแบบ 1 และ 0 เราจะใช้ฟังก์ชันการสูญเสียไบนารีเพื่อคำนวณความแตกต่างระหว่างป้ายกำกับจริงและที่คาดคะเนไว้
ชุดข้อมูลยังถูกแบ่งออกเป็นแบทช์ 10 ชุด (batch_size) และจะถูกส่งผ่านโมเดล 30 ครั้ง (ยุค) สำหรับชุดข้อมูลที่กำหนด x จะเป็นข้อมูลและ y จะเป็นป้ายกำกับที่สอดคล้องกับข้อมูล
แบบจำลองการทดสอบโดยใช้การทำนาย
ในการประเมินแบบจำลองของเรา เราทำการคาดคะเนข้อมูลการทดสอบโดยใช้ฟังก์ชันทำนาย ()
การคาดคะเน = model.predict(x)
และนั่นมัน!
ตอนนี้คุณควรมีความเข้าใจที่ดีเกี่ยวกับ การเรียนรู้ลึก ๆ แอปพลิเคชัน Neural Networks วิธีทำงานโดยทั่วไป และวิธีสร้าง ฝึก และทดสอบโมเดลในโค้ด Python
ฉันหวังว่าบทช่วยสอนนี้จะช่วยให้คุณเริ่มต้นในการสร้างและปรับใช้โมเดลการเรียนรู้เชิงลึกของคุณเอง
แจ้งให้เราทราบในความคิดเห็นหากบทความมีประโยชน์
เขียนความเห็น