PyTorch - คู่มือฉบับย่อ

PyTorch ถูกกำหนดให้เป็นไลบรารีการเรียนรู้ของเครื่องโอเพนซอร์สสำหรับ Python ใช้สำหรับการใช้งานเช่นการประมวลผลภาษาธรรมชาติ เริ่มต้นพัฒนาโดยกลุ่มวิจัยปัญญาประดิษฐ์ของ Facebook และซอฟต์แวร์ Pyro ของ Uber สำหรับการเขียนโปรแกรมความน่าจะเป็นซึ่งสร้างขึ้นจากมัน

ในขั้นต้น PyTorch ได้รับการพัฒนาโดย Hugh Perkins เป็นเครื่องห่อ Python สำหรับ LusJIT โดยใช้ Torch framework PyTorch มีสองรูปแบบ

PyTorch ออกแบบใหม่และใช้งาน Torch ใน Python ในขณะที่แชร์ไลบรารี C หลักเดียวกันสำหรับโค้ดแบ็กเอนด์ นักพัฒนา PyTorch ได้ปรับแต่งโค้ดส่วนหลังนี้เพื่อเรียกใช้ Python อย่างมีประสิทธิภาพ พวกเขายังคงไว้ซึ่งการเร่งฮาร์ดแวร์ที่ใช้ GPU เช่นเดียวกับคุณสมบัติความสามารถในการขยายที่ทำให้ Torch ที่ใช้ Lua

คุณสมบัติ

คุณสมบัติหลักของ PyTorch มีดังต่อไปนี้ -

Easy Interface- PyTorch เสนอ API ที่ใช้งานง่าย ดังนั้นจึงถือว่าง่ายมากในการใช้งานและรันบน Python การเรียกใช้โค้ดในเฟรมเวิร์กนี้ค่อนข้างง่าย

Python usage- ไลบรารีนี้ถือเป็น Pythonic ซึ่งรวมเข้ากับ Python data science stack ได้อย่างราบรื่น ดังนั้นจึงสามารถใช้ประโยชน์จากบริการและฟังก์ชันทั้งหมดที่นำเสนอโดยสภาพแวดล้อม Python

Computational graphs- PyTorch เป็นแพลตฟอร์มที่ยอดเยี่ยมซึ่งนำเสนอกราฟการคำนวณแบบไดนามิก ดังนั้นผู้ใช้สามารถเปลี่ยนได้ในระหว่างรันไทม์ สิ่งนี้มีประโยชน์อย่างมากเมื่อนักพัฒนาไม่ทราบว่าจำเป็นต้องใช้หน่วยความจำเท่าใดในการสร้างแบบจำลองเครือข่ายประสาทเทียม

PyTorch เป็นที่ทราบกันดีว่ามีนามธรรมสามระดับตามที่ระบุด้านล่าง -

• Tensor - อาร์เรย์ n มิติที่จำเป็นซึ่งทำงานบน GPU

• ตัวแปร - โหนดในกราฟการคำนวณ สิ่งนี้จัดเก็บข้อมูลและการไล่ระดับสี

• โมดูล - เลเยอร์เครือข่ายประสาทซึ่งจะเก็บสถานะหรือน้ำหนักที่เรียนรู้ได้

ข้อดีของ PyTorch

ต่อไปนี้เป็นข้อดีของ PyTorch -

• ง่ายต่อการดีบักและทำความเข้าใจโค้ด

• ประกอบด้วยหลายชั้นเป็น Torch

• ประกอบด้วยฟังก์ชันการสูญเสียจำนวนมาก

• ถือได้ว่าเป็นส่วนขยาย NumPy สำหรับ GPU

• ช่วยให้สามารถสร้างเครือข่ายที่มีโครงสร้างขึ้นอยู่กับการคำนวณเอง

TensorFlow กับ PyTorch

เราจะพิจารณาความแตกต่างที่สำคัญระหว่าง TensorFlow และ PyTorch ด้านล่าง -

PyTorch	TensorFlow
PyTorch มีความเกี่ยวข้องอย่างใกล้ชิดกับ Torch framework ที่ใช้ lua ซึ่งใช้กันอย่างแพร่หลายใน Facebook	TensorFlow ได้รับการพัฒนาโดย Google Brain และมีการใช้งานที่ Google
PyTorch ค่อนข้างใหม่เมื่อเทียบกับเทคโนโลยีการแข่งขันอื่น ๆ	TensorFlow ไม่ใช่เรื่องใหม่และถือเป็นเครื่องมือสำหรับพกพาโดยนักวิจัยและผู้เชี่ยวชาญในอุตสาหกรรมจำนวนมาก
PyTorch รวมทุกอย่างไว้ในลักษณะที่จำเป็นและมีพลวัต	TensorFlow ประกอบด้วยกราฟแบบคงที่และแบบไดนามิกเป็นชุดค่าผสม
กราฟการคำนวณใน PyTorch ถูกกำหนดระหว่างรันไทม์	TensorFlow ไม่มีตัวเลือกเวลาทำงานใด ๆ
PyTorch รวมถึงการปรับใช้ที่โดดเด่นสำหรับมือถือและเฟรมเวิร์กแบบฝัง	TensorFlow ทำงานได้ดีกว่าสำหรับเฟรมเวิร์กแบบฝัง

PyTorch เป็นกรอบการเรียนรู้เชิงลึกยอดนิยม ในบทช่วยสอนนี้เราถือว่า“ Windows 10” เป็นระบบปฏิบัติการของเรา ขั้นตอนสำหรับการตั้งค่าสภาพแวดล้อมที่ประสบความสำเร็จมีดังนี้ -

ขั้นตอนที่ 1

ลิงค์ต่อไปนี้ประกอบด้วยรายการแพ็คเกจซึ่งรวมถึงแพ็คเกจที่เหมาะสมสำหรับ PyTorch

https://drive.google.com/drive/folders/0B-X0-FlSGfCYdTNldW02UGl4MXM

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

ขั้นตอนที่ 2

เกี่ยวข้องกับการตรวจสอบการติดตั้ง PyTorch framework โดยใช้ Anaconda Framework

คำสั่งต่อไปนี้ใช้เพื่อตรวจสอบสิ่งเดียวกัน -

conda list

“ รายการ Conda” แสดงรายการเฟรมเวิร์กที่ติดตั้ง

ส่วนที่ไฮไลต์แสดงว่า PyTorch ได้รับการติดตั้งในระบบของเราเรียบร้อยแล้ว

คณิตศาสตร์มีความสำคัญอย่างยิ่งในอัลกอริทึมการเรียนรู้ของเครื่องและรวมถึงแนวคิดหลักต่างๆของคณิตศาสตร์เพื่อให้ได้อัลกอริทึมที่ถูกต้องซึ่งออกแบบในลักษณะเฉพาะ

ความสำคัญของหัวข้อคณิตศาสตร์สำหรับการเรียนรู้ของเครื่องและวิทยาศาสตร์ข้อมูลมีการกล่าวถึงด้านล่าง -

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

เวกเตอร์

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

การแสดงเวกเตอร์จะแสดงดังที่กล่าวไว้ด้านล่าง -

temp = torch.FloatTensor([23,24,24.5,26,27.2,23.0])
temp.size()
Output - torch.Size([6])

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

สเกลาร์

สเกลาร์ถูกเรียกว่ามีมิติเป็นศูนย์ที่มีเพียงค่าเดียว เมื่อพูดถึง PyTorch จะไม่รวมเทนเซอร์พิเศษที่มีขนาดศูนย์ ดังนั้นจะมีการประกาศดังนี้ -

x = torch.rand(10)
x.size()
Output - torch.Size([10])

เมทริกซ์

ข้อมูลที่มีโครงสร้างส่วนใหญ่มักแสดงในรูปแบบของตารางหรือเมทริกซ์เฉพาะ เราจะใช้ชุดข้อมูลที่เรียกว่า Boston House Prices ซึ่งพร้อมใช้งานในไลบรารี Machine Learning ของ Python scikit-learn

boston_tensor = torch.from_numpy(boston.data)
boston_tensor.size()
Output: torch.Size([506, 13])
boston_tensor[:2]
Output:
Columns 0 to 7
0.0063 18.0000 2.3100 0.0000 0.5380 6.5750 65.2000 4.0900
0.0273 0.0000 7.0700 0.0000 0.4690 6.4210 78.9000 4.9671
Columns 8 to 12
1.0000 296.0000 15.3000 396.9000 4.9800
2.0000 242.0000 17.8000 396.9000 9.1400

หลักการสำคัญของโครงข่ายประสาทรวมถึงการรวบรวมองค์ประกอบพื้นฐานเช่นเซลล์ประสาทเทียมหรือเพอร์เซปตรอน ประกอบด้วยอินพุตพื้นฐานหลายอย่างเช่น x1, x2 … .. xn ซึ่งสร้างเอาต์พุตไบนารีหากผลรวมมากกว่าศักยภาพในการกระตุ้น

การแสดงแผนผังของเซลล์ประสาทตัวอย่างมีดังต่อไปนี้ -

ผลลัพธ์ที่สร้างขึ้นถือได้ว่าเป็นผลรวมถ่วงน้ำหนักที่มีศักยภาพในการเปิดใช้งานหรืออคติ

$$ เอาต์พุต = \ sum_jw_jx_j + อคติ $$

สถาปัตยกรรมเครือข่ายประสาทเทียมโดยทั่วไปอธิบายไว้ด้านล่าง -

เลเยอร์ระหว่างอินพุตและเอาต์พุตเรียกว่าเลเยอร์ที่ซ่อนอยู่และความหนาแน่นและประเภทของการเชื่อมต่อระหว่างเลเยอร์คือการกำหนดค่า ตัวอย่างเช่นการกำหนดค่าที่เชื่อมต่ออย่างสมบูรณ์จะมีเซลล์ประสาททั้งหมดของเลเยอร์ L เชื่อมต่อกับ L + 1 สำหรับการแปลให้ชัดเจนยิ่งขึ้นเราสามารถเชื่อมต่อเฉพาะพื้นที่ใกล้เคียงเช่นเซลล์ประสาทเก้าเซลล์กับเลเยอร์ถัดไป รูปที่ 1-9 แสดงเลเยอร์ที่ซ่อนอยู่สองชั้นด้วยการเชื่อมต่อที่หนาแน่น

โครงข่ายประสาทเทียมประเภทต่างๆมีดังนี้ -

Feedforward Neural Networks

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

เครือข่ายประสาทที่กำเริบ

Recurrent Neural Networks คือการที่รูปแบบข้อมูลเปลี่ยนแปลงตามมาในช่วงเวลาหนึ่ง ใน RNN เลเยอร์เดียวกันจะถูกใช้เพื่อยอมรับพารามิเตอร์อินพุตและแสดงพารามิเตอร์เอาต์พุตในโครงข่ายประสาทที่ระบุ

โครงข่ายประสาทเทียมสามารถสร้างได้โดยใช้แพ็คเกจ torch.nn

เป็นเครือข่ายฟีดไปข้างหน้าอย่างง่าย ใช้อินพุตป้อนข้อมูลผ่านหลายชั้นทีละชั้นจากนั้นจึงให้เอาต์พุตในที่สุด

ด้วยความช่วยเหลือของ PyTorch เราสามารถใช้ขั้นตอนต่อไปนี้สำหรับขั้นตอนการฝึกอบรมทั่วไปสำหรับโครงข่ายประสาทเทียม -

• กำหนดโครงข่ายประสาทเทียมที่มีพารามิเตอร์ (หรือน้ำหนัก) ที่เรียนรู้ได้
• วนซ้ำชุดข้อมูลของอินพุต
• ประมวลผลอินพุตผ่านเครือข่าย
• คำนวณการสูญเสีย (ผลลัพธ์อยู่ห่างจากความถูกต้องเท่าใด)
• กระจายการไล่ระดับสีกลับเข้าไปในพารามิเตอร์ของเครือข่าย
• อัปเดตน้ำหนักของเครือข่ายโดยทั่วไปจะใช้การอัปเดตอย่างง่ายตามที่ระบุด้านล่าง

rule: weight = weight -learning_rate * gradient

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

การเรียนรู้ของเครื่อง

การเรียนรู้ของเครื่องเป็นศิลปะของวิทยาศาสตร์ที่ช่วยให้คอมพิวเตอร์ทำหน้าที่ตามอัลกอริทึมที่ออกแบบและตั้งโปรแกรมไว้ นักวิจัยหลายคนคิดว่าการเรียนรู้ของเครื่องเป็นวิธีที่ดีที่สุดในการก้าวไปสู่ ​​AI ระดับมนุษย์ รวมถึงรูปแบบประเภทต่างๆเช่น -

• รูปแบบการเรียนรู้ภายใต้การดูแล
• รูปแบบการเรียนรู้ที่ไม่มีผู้ดูแล

การเรียนรู้เชิงลึก

การเรียนรู้เชิงลึกเป็นส่วนย่อยของการเรียนรู้ของเครื่องที่อัลกอริทึมที่เกี่ยวข้องได้รับแรงบันดาลใจจากโครงสร้างและการทำงานของสมองที่เรียกว่า Artificial Neural Networks

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

กระบวนการเรียนรู้ของเครื่องถูกกำหนดโดยใช้ขั้นตอนต่อไปนี้ -

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

ในบทนี้เราจะพูดถึงความแตกต่างที่สำคัญระหว่างแนวคิดของ Machine และ Deep learning

ปริมาณข้อมูล

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

การพึ่งพาฮาร์ดแวร์

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

วิศวกรรมคุณลักษณะ

วิศวกรรมคุณลักษณะเป็นกระบวนการในการใส่ความรู้โดเมนลงในคุณลักษณะเฉพาะเพื่อลดความซับซ้อนของข้อมูลและสร้างรูปแบบที่สามารถมองเห็นได้ในอัลกอริทึมการเรียนรู้

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

PyTorch มีคุณสมบัติพิเศษในการสร้างและใช้เครือข่ายประสาทเทียม ในบทนี้เราจะสร้างโครงข่ายประสาทเทียมอย่างง่ายโดยมีเลเยอร์ที่ซ่อนอยู่หนึ่งชั้นซึ่งพัฒนาหน่วยเอาต์พุตเดียว

เราจะใช้ขั้นตอนต่อไปนี้เพื่อใช้เครือข่ายประสาทเทียมแรกโดยใช้ PyTorch -

ขั้นตอนที่ 1

ขั้นแรกเราต้องนำเข้าไลบรารี PyTorch โดยใช้คำสั่งด้านล่าง -

import torch 
import torch.nn as nn

ขั้นตอนที่ 2

กำหนดเลเยอร์และขนาดแบตช์ทั้งหมดเพื่อเริ่มเรียกใช้เครือข่ายประสาทตามที่แสดงด้านล่าง -

# Defining input size, hidden layer size, output size and batch size respectively
n_in, n_h, n_out, batch_size = 10, 5, 1, 10

ขั้นตอนที่ 3

เนื่องจากเครือข่ายประสาทเทียมมีการรวมกันของข้อมูลอินพุตเพื่อรับข้อมูลเอาต์พุตตามลำดับเราจะดำเนินการตามขั้นตอนเดียวกันกับที่ระบุด้านล่าง -

# Create dummy input and target tensors (data)
x = torch.randn(batch_size, n_in)
y = torch.tensor([[1.0], [0.0], [0.0], 
[1.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]])

ขั้นตอนที่ 4

สร้างแบบจำลองตามลำดับด้วยความช่วยเหลือของฟังก์ชันที่สร้างขึ้น ใช้บรรทัดด้านล่างของรหัสสร้างแบบจำลองตามลำดับ -

# Create a model
model = nn.Sequential(nn.Linear(n_in, n_h),
   nn.ReLU(),
   nn.Linear(n_h, n_out),
   nn.Sigmoid())

ขั้นตอนที่ 5

สร้างฟังก์ชันการสูญเสียโดยใช้เครื่องมือเพิ่มประสิทธิภาพ Gradient Descent ดังที่แสดงด้านล่าง -

Construct the loss function
criterion = torch.nn.MSELoss()
# Construct the optimizer (Stochastic Gradient Descent in this case)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

ขั้นตอนที่ 6

ใช้โมเดลการไล่ระดับสีด้วยการวนซ้ำด้วยบรรทัดรหัสที่กำหนด -

# Gradient Descent
for epoch in range(50):
   # Forward pass: Compute predicted y by passing x to the model
   y_pred = model(x)

   # Compute and print loss
   loss = criterion(y_pred, y)
   print('epoch: ', epoch,' loss: ', loss.item())

   # Zero gradients, perform a backward pass, and update the weights.
   optimizer.zero_grad()

   # perform a backward pass (backpropagation)
   loss.backward()

   # Update the parameters
   optimizer.step()

ขั้นตอนที่ 7

ผลลัพธ์ที่สร้างขึ้นมีดังนี้ -

epoch: 0 loss: 0.2545787990093231
epoch: 1 loss: 0.2545052170753479
epoch: 2 loss: 0.254431813955307
epoch: 3 loss: 0.25435858964920044
epoch: 4 loss: 0.2542854845523834
epoch: 5 loss: 0.25421255826950073
epoch: 6 loss: 0.25413978099823
epoch: 7 loss: 0.25406715273857117
epoch: 8 loss: 0.2539947032928467
epoch: 9 loss: 0.25392240285873413
epoch: 10 loss: 0.25385022163391113
epoch: 11 loss: 0.25377824902534485
epoch: 12 loss: 0.2537063956260681
epoch: 13 loss: 0.2536346912384033
epoch: 14 loss: 0.25356316566467285
epoch: 15 loss: 0.25349172949790955
epoch: 16 loss: 0.25342053174972534
epoch: 17 loss: 0.2533493936061859
epoch: 18 loss: 0.2532784342765808
epoch: 19 loss: 0.25320762395858765
epoch: 20 loss: 0.2531369626522064
epoch: 21 loss: 0.25306645035743713
epoch: 22 loss: 0.252996027469635
epoch: 23 loss: 0.2529257833957672
epoch: 24 loss: 0.25285571813583374
epoch: 25 loss: 0.25278574228286743
epoch: 26 loss: 0.25271597504615784
epoch: 27 loss: 0.25264623761177063
epoch: 28 loss: 0.25257670879364014
epoch: 29 loss: 0.2525072991847992
epoch: 30 loss: 0.2524380087852478
epoch: 31 loss: 0.2523689270019531
epoch: 32 loss: 0.25229987502098083
epoch: 33 loss: 0.25223103165626526
epoch: 34 loss: 0.25216227769851685
epoch: 35 loss: 0.252093642950058
epoch: 36 loss: 0.25202515721321106
epoch: 37 loss: 0.2519568204879761
epoch: 38 loss: 0.251888632774353
epoch: 39 loss: 0.25182053446769714
epoch: 40 loss: 0.2517525553703308
epoch: 41 loss: 0.2516847252845764
epoch: 42 loss: 0.2516169846057892
epoch: 43 loss: 0.2515493929386139
epoch: 44 loss: 0.25148195028305054
epoch: 45 loss: 0.25141456723213196
epoch: 46 loss: 0.2513473629951477
epoch: 47 loss: 0.2512802183628082
epoch: 48 loss: 0.2512132525444031
epoch: 49 loss: 0.2511464059352875

การฝึกอัลกอริทึมการเรียนรู้เชิงลึกมีขั้นตอนต่อไปนี้ -

• การสร้างท่อส่งข้อมูล
• การสร้างสถาปัตยกรรมเครือข่าย
• การประเมินสถาปัตยกรรมโดยใช้ฟังก์ชันการสูญเสีย
• การปรับน้ำหนักสถาปัตยกรรมเครือข่ายให้เหมาะสมโดยใช้อัลกอริทึมการปรับให้เหมาะสม

การฝึกอัลกอริธึมการเรียนรู้เชิงลึกที่เฉพาะเจาะจงเป็นข้อกำหนดที่แน่นอนในการแปลงโครงข่ายประสาทเทียมเป็นบล็อกการทำงานดังที่แสดงด้านล่าง -

สำหรับแผนภาพข้างต้นอัลกอริทึมการเรียนรู้เชิงลึกใด ๆ เกี่ยวข้องกับการรับข้อมูลอินพุตการสร้างสถาปัตยกรรมตามลำดับซึ่งรวมถึงเลเยอร์จำนวนมากที่ฝังอยู่ในนั้น

หากคุณสังเกตแผนภาพด้านบนความแม่นยำจะถูกประเมินโดยใช้ฟังก์ชันการสูญเสียที่เกี่ยวข้องกับการปรับน้ำหนักของโครงข่ายประสาทเทียมให้เหมาะสม

ในบทนี้เราจะพูดถึงคำศัพท์ที่ใช้บ่อยที่สุดใน PyTorch

PyTorch NumPy

PyTorch tensor เหมือนกับอาร์เรย์ NumPy เทนเซอร์เป็นอาร์เรย์ n มิติและในส่วนที่เกี่ยวกับ PyTorch จะมีฟังก์ชันมากมายในการทำงานกับเทนเซอร์เหล่านี้

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

ตัวแปรและ Autograd

เมื่อใช้ autograd การส่งต่อเครือข่ายของคุณจะกำหนด a computational graph - โหนดในกราฟจะเป็น Tensors และ edge จะเป็นฟังก์ชันที่สร้างเอาต์พุต Tensors จากอินพุต Tensors

PyTorch Tensors สามารถสร้างเป็นออบเจ็กต์ตัวแปรโดยที่ตัวแปรแสดงถึงโหนดในกราฟการคำนวณ

กราฟแบบไดนามิก

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

ความแตกต่างที่สำคัญระหว่างกราฟเหล่านี้คือกราฟการคำนวณของ Tensor Flow เป็นแบบคงที่และ PyTorch ใช้กราฟการคำนวณแบบไดนามิก

Optim Package

แพ็คเกจการเพิ่มประสิทธิภาพใน PyTorch สรุปแนวคิดของอัลกอริทึมการเพิ่มประสิทธิภาพซึ่งนำไปใช้ในหลาย ๆ วิธีและให้ภาพประกอบของอัลกอริทึมการปรับให้เหมาะสมที่ใช้กันทั่วไป สิ่งนี้สามารถเรียกได้ภายในคำสั่งนำเข้า

การประมวลผลหลายขั้นตอน

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

PyTorch มีแพ็คเกจที่เรียกว่า torchvision ซึ่งใช้ในการโหลดและเตรียมชุดข้อมูล ประกอบด้วยฟังก์ชันพื้นฐานสองอย่าง ได้แก่ Dataset และ DataLoader ซึ่งช่วยในการแปลงและโหลดชุดข้อมูล

ชุดข้อมูล

ชุดข้อมูลใช้เพื่ออ่านและแปลงจุดข้อมูลจากชุดข้อมูลที่กำหนด ไวยากรณ์พื้นฐานที่จะนำไปใช้มีดังต่อไปนี้ -

trainset = torchvision.datasets.CIFAR10(root = './data', train = True,
   download = True, transform = transform)

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

trainloader = torch.utils.data.DataLoader(trainset, batch_size = 4,
   shuffle = True, num_workers = 2)

ตัวอย่าง: การโหลดไฟล์ CSV

เราใช้ Python package Panda เพื่อโหลดไฟล์ csv ไฟล์ต้นฉบับมีรูปแบบต่อไปนี้: (ชื่อภาพจุดสังเกต 68 จุด - จุดสังเกตแต่ละจุดมีขวานพิกัด y)

landmarks_frame = pd.read_csv('faces/face_landmarks.csv')

n = 65
img_name = landmarks_frame.iloc[n, 0]
landmarks = landmarks_frame.iloc[n, 1:].as_matrix()
landmarks = landmarks.astype('float').reshape(-1, 2)

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

ความสัมพันธ์ระหว่างตัวแปรทั้งสองนี้ถือเป็นเส้นตรงกล่าวคือถ้า y เป็นตัวแปรตามและ x ถือเป็นตัวแปรอิสระความสัมพันธ์การถดถอยเชิงเส้นของสองตัวแปรจะมีลักษณะเหมือนสมการที่กล่าวไว้ด้านล่าง -

Y = Ax+b

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

• ฟังก์ชันต้นทุน
• อัลกอริทึมการสืบเชื้อสายไล่ระดับสี

การแสดงแผนผังของการถดถอยเชิงเส้นแสดงไว้ด้านล่าง

การตีความผลลัพธ์

$$ Y = ขวาน + b $$

• คุณค่าของ a คือความลาดชัน

• คุณค่าของ b คือ y − intercept.

• r คือ correlation coefficient.

• r² คือ correlation coefficient.

มุมมองกราฟิกของสมการการถดถอยเชิงเส้นมีการกล่าวถึงด้านล่าง -

ขั้นตอนต่อไปนี้ใช้สำหรับการใช้การถดถอยเชิงเส้นโดยใช้ PyTorch -

ขั้นตอนที่ 1

นำเข้าแพ็คเกจที่จำเป็นสำหรับการสร้างการถดถอยเชิงเส้นใน PyTorch โดยใช้รหัสด้านล่าง -

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import seaborn as sns
import pandas as pd
%matplotlib inline

sns.set_style(style = 'whitegrid')
plt.rcParams["patch.force_edgecolor"] = True

ขั้นตอนที่ 2

สร้างชุดการฝึกอบรมชุดเดียวโดยใช้ชุดข้อมูลดังที่แสดงด้านล่าง -

m = 2 # slope
c = 3 # interceptm = 2 # slope
c = 3 # intercept
x = np.random.rand(256)

noise = np.random.randn(256) / 4

y = x * m + c + noise

df = pd.DataFrame()
df['x'] = x
df['y'] = y

sns.lmplot(x ='x', y ='y', data = df)

ขั้นตอนที่ 3

ใช้การถดถอยเชิงเส้นกับไลบรารี PyTorch ดังที่กล่าวไว้ด้านล่าง -

import torch
import torch.nn as nn
from torch.autograd import Variable
x_train = x.reshape(-1, 1).astype('float32')
y_train = y.reshape(-1, 1).astype('float32')

class LinearRegressionModel(nn.Module):
   def __init__(self, input_dim, output_dim):
      super(LinearRegressionModel, self).__init__()
      self.linear = nn.Linear(input_dim, output_dim)

   def forward(self, x):
      out = self.linear(x)
      return out
input_dim = x_train.shape[1]
output_dim = y_train.shape[1]
input_dim, output_dim(1, 1)
model = LinearRegressionModel(input_dim, output_dim)
criterion = nn.MSELoss()
[w, b] = model.parameters()

def get_param_values():
   return w.data[0][0], b.data[0]

def plot_current_fit(title = ""):
plt.figure(figsize = (12,4))
plt.title(title)
plt.scatter(x, y, s = 8)
w1 = w.data[0][0]
b1 = b.data[0]
x1 = np.array([0., 1.])
y1 = x1 * w1 + b1
plt.plot(x1, y1, 'r', label = 'Current Fit ({:.3f}, {:.3f})'.format(w1, b1))
plt.xlabel('x (input)')
plt.ylabel('y (target)')
plt.legend()
plt.show()
plot_current_fit('Before training')

พล็อตที่สร้างขึ้นมีดังนี้ -

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

เครือข่ายประสาทเทียมที่สำคัญสองประเภทมีดังต่อไปนี้ -

• Convolutional Neural Networks
• เครือข่ายประสาทที่กำเริบ

ในบทนี้เราจะเน้นไปที่ประเภทแรก ได้แก่ Convolutional Neural Networks (CNN)

Convolutional Neural Networks

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

ความแตกต่างหลักระหว่าง CNN และเครือข่ายประสาทเทียมอื่น ๆ คือ CNN รับอินพุตเป็นอาร์เรย์สองมิติและทำงานโดยตรงบนภาพแทนที่จะมุ่งเน้นไปที่การแยกคุณลักษณะซึ่งเครือข่ายประสาทเทียมอื่น ๆ มุ่งเน้นไปที่

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

โครงข่ายประสาทเทียมทุกอันประกอบด้วยแนวคิดพื้นฐานสามประการ -

• เขตข้อมูลที่เกี่ยวข้อง
• Convolution
• Pooling

ให้เราเข้าใจคำศัพท์เหล่านี้โดยละเอียด

เขตข้อมูลที่เกี่ยวข้องในท้องถิ่น

CNN ใช้ความสัมพันธ์เชิงพื้นที่ที่มีอยู่ภายในข้อมูลอินพุต แต่ละชั้นของเครือข่ายประสาทที่เชื่อมต่อกันของเซลล์ประสาทอินพุตบางส่วนพร้อมกัน ภูมิภาคเฉพาะนี้เรียกว่า Local Receptive Field มันเน้นเฉพาะเซลล์ประสาทที่ซ่อนอยู่ เซลล์ประสาทที่ซ่อนอยู่จะประมวลผลข้อมูลอินพุตภายในฟิลด์ดังกล่าวโดยไม่ตระหนักถึงการเปลี่ยนแปลงนอกขอบเขตเฉพาะ

การแสดงไดอะแกรมของการสร้างฟิลด์ในท้องถิ่นมีการกล่าวถึงด้านล่าง -

การแปลง

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

การแมปการเชื่อมต่อจากเลเยอร์อินพุตไปยังแมปคุณลักษณะที่ซ่อนอยู่ถูกกำหนดเป็น "น้ำหนักที่ใช้ร่วมกัน" และการรวมอคติเรียกว่า "อคติร่วม"

การรวมกลุ่ม

Convolutional Neural Network ใช้การรวมเลเยอร์ซึ่งวางตำแหน่งทันทีหลังจากการประกาศของ CNN ใช้ข้อมูลที่ป้อนจากผู้ใช้เป็นแผนที่คุณลักษณะซึ่งออกมาจากเครือข่าย Convolutional และเตรียมแผนที่คุณลักษณะแบบย่อ การรวมเลเยอร์ช่วยในการสร้างชั้นด้วยเซลล์ประสาทของชั้นก่อนหน้า

การใช้งาน PyTorch

ขั้นตอนต่อไปนี้ใช้เพื่อสร้าง Convolutional Neural Network โดยใช้ PyTorch

ขั้นตอนที่ 1

นำเข้าแพ็คเกจที่จำเป็นสำหรับการสร้างโครงข่ายประสาทเทียมอย่างง่าย

from torch.autograd import Variable
import torch.nn.functional as F

ขั้นตอนที่ 2

สร้างคลาสที่มีการแสดงแบทช์ของโครงข่ายประสาทเทียม รูปร่างแบทช์ของเราสำหรับอินพุต x มีขนาด (3, 32, 32)

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

ขั้นตอนที่ 3

คำนวณการเปิดใช้งานขนาด Convolution แรกเปลี่ยนจาก (3, 32, 32) เป็น (18, 32, 32)

ขนาดของมิติเปลี่ยนจาก (18, 32, 32) เป็น (18, 16, 16) ปรับรูปร่างขนาดข้อมูลของชั้นอินพุตของตาข่ายประสาทเนื่องจากขนาดเปลี่ยนจาก (18, 16, 16) เป็น (1, 4608)

จำได้ว่า -1 อนุมานมิตินี้จากมิติอื่นที่กำหนด

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)

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

แผนภาพด้านล่างระบุแนวทางที่สมบูรณ์และการทำงานของเครือข่ายประสาทที่เกิดซ้ำ -

ในรูปด้านบน c1, c2, c3 และ x1 ถือเป็นอินพุตที่มีค่าอินพุตที่ซ่อนอยู่ ได้แก่ h1, h2 และ h3 ที่ให้เอาต์พุตตามลำดับของ o1 ตอนนี้เราจะมุ่งเน้นไปที่การใช้ PyTorch เพื่อสร้างคลื่นไซน์ด้วยความช่วยเหลือของเครือข่ายประสาทที่เกิดซ้ำ

ในระหว่างการฝึกอบรมเราจะปฏิบัติตามแนวทางการฝึกอบรมกับโมเดลของเราโดยใช้จุดข้อมูลทีละจุด ลำดับอินพุต x ประกอบด้วยจุดข้อมูล 20 จุดและลำดับเป้าหมายจะถือว่าเหมือนกับลำดับอินพุต

ขั้นตอนที่ 1

นำเข้าแพ็คเกจที่จำเป็นสำหรับการใช้งานเครือข่ายประสาทเทียมซ้ำโดยใช้รหัสด้านล่าง -

import torch
from torch.autograd import Variable
import numpy as np
import pylab as pl
import torch.nn.init as init

ขั้นตอนที่ 2

เราจะตั้งค่าพารามิเตอร์ไฮเปอร์โมเดลด้วยขนาดของเลเยอร์อินพุตที่กำหนดเป็น 7 จะมี 6 เซลล์ประสาทบริบทและ 1 เซลล์ประสาทอินพุตสำหรับสร้างลำดับเป้าหมาย

dtype = torch.FloatTensor
input_size, hidden_size, output_size = 7, 6, 1
epochs = 300
seq_length = 20
lr = 0.1
data_time_steps = np.linspace(2, 10, seq_length + 1)
data = np.sin(data_time_steps)
data.resize((seq_length + 1, 1))

x = Variable(torch.Tensor(data[:-1]).type(dtype), requires_grad=False)
y = Variable(torch.Tensor(data[1:]).type(dtype), requires_grad=False)

เราจะสร้างข้อมูลการฝึกอบรมโดยที่ x คือลำดับข้อมูลอินพุตและ y คือลำดับเป้าหมายที่ต้องการ

ขั้นตอนที่ 3

น้ำหนักเริ่มต้นในโครงข่ายประสาทที่เกิดซ้ำโดยใช้การแจกแจงแบบปกติโดยมีค่าเฉลี่ยเป็นศูนย์ W1 จะแสดงถึงการยอมรับตัวแปรอินพุตและ w2 จะแสดงถึงเอาต์พุตที่สร้างขึ้นตามที่แสดงด้านล่าง -

w1 = torch.FloatTensor(input_size, 
hidden_size).type(dtype)
init.normal(w1, 0.0, 0.4)
w1 = Variable(w1, requires_grad = True)
w2 = torch.FloatTensor(hidden_size, output_size).type(dtype)
init.normal(w2, 0.0, 0.3)
w2 = Variable(w2, requires_grad = True)

ขั้นตอนที่ 4

ตอนนี้สิ่งสำคัญคือต้องสร้างฟังก์ชันสำหรับฟีดไปข้างหน้าซึ่งกำหนดเครือข่ายประสาทเทียมโดยเฉพาะ

def forward(input, context_state, w1, w2):
   xh = torch.cat((input, context_state), 1)
   context_state = torch.tanh(xh.mm(w1))
   out = context_state.mm(w2)
   return (out, context_state)

ขั้นตอนที่ 5

ขั้นตอนต่อไปคือการเริ่มขั้นตอนการฝึกอบรมการใช้คลื่นไซน์ของเครือข่ายประสาทที่เกิดซ้ำ วงนอกวนซ้ำในแต่ละลูปและวงในจะวนซ้ำผ่านองค์ประกอบของลำดับ ในที่นี้เราจะคำนวณ Mean Square Error (MSE) ซึ่งช่วยในการคาดคะเนตัวแปรต่อเนื่อง

for i in range(epochs):
   total_loss = 0
   context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = True)
   for j in range(x.size(0)):
      input = x[j:(j+1)]
      target = y[j:(j+1)]
      (pred, context_state) = forward(input, context_state, w1, w2)
      loss = (pred - target).pow(2).sum()/2
      total_loss += loss
      loss.backward()
      w1.data -= lr * w1.grad.data
      w2.data -= lr * w2.grad.data
      w1.grad.data.zero_()
      w2.grad.data.zero_()
      context_state = Variable(context_state.data)
   if i % 10 == 0:
      print("Epoch: {} loss {}".format(i, total_loss.data[0]))

context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = False)
predictions = []

for i in range(x.size(0)):
   input = x[i:i+1]
   (pred, context_state) = forward(input, context_state, w1, w2)
   context_state = context_state
   predictions.append(pred.data.numpy().ravel()[0])

ขั้นตอนที่ 6

ตอนนี้ได้เวลาพล็อตคลื่นไซน์ตามที่ต้องการ

pl.scatter(data_time_steps[:-1], x.data.numpy(), s = 90, label = "Actual")
pl.scatter(data_time_steps[1:], predictions, label = "Predicted")
pl.legend()
pl.show()

เอาต์พุต

ผลลัพธ์สำหรับกระบวนการข้างต้นมีดังนี้ -

ในบทนี้เราจะเน้นมากขึ้น torchvision.datasetsและประเภทต่างๆ PyTorch ประกอบด้วยตัวโหลดชุดข้อมูลต่อไปนี้ -

• MNIST
• COCO (คำบรรยายภาพและการตรวจจับ)

ชุดข้อมูลประกอบด้วยฟังก์ชันส่วนใหญ่สองประเภทที่ระบุด้านล่าง -

• Transform- ฟังก์ชั่นที่ใช้ในรูปภาพและส่งคืนเวอร์ชันมาตรฐานที่แก้ไขแล้ว สิ่งเหล่านี้สามารถประกอบขึ้นพร้อมกับการแปลงร่าง

• Target_transform- ฟังก์ชั่นที่ใช้เป้าหมายและแปลงมัน ตัวอย่างเช่นรับสตริงคำอธิบายภาพและส่งกลับค่าดัชนีโลก

MNIST

ต่อไปนี้เป็นโค้ดตัวอย่างสำหรับชุดข้อมูล MNIST -

dset.MNIST(root, train = TRUE, transform = NONE, 
target_transform = None, download = FALSE)

พารามิเตอร์มีดังนี้ -

• root - ไดเร็กทอรีรากของชุดข้อมูลที่มีข้อมูลที่ประมวลผลแล้ว

• train - จริง = ชุดการฝึก, เท็จ = ชุดทดสอบ

• download - True = ดาวน์โหลดชุดข้อมูลจากอินเทอร์เน็ตและวางไว้ในรูท

โกโก้

ต้องติดตั้ง COCO API ตัวอย่างต่อไปนี้ใช้เพื่อสาธิตการใช้งานชุดข้อมูล COCO โดยใช้ PyTorch -

import torchvision.dataset as dset
import torchvision.transforms as transforms
cap = dset.CocoCaptions(root = ‘ dir where images are’, 
annFile = ’json annotation file’,
transform = transforms.ToTensor())
print(‘Number of samples: ‘, len(cap))
print(target)

ผลลัพธ์ที่ได้มีดังนี้ -

Number of samples: 82783
Image Size: (3L, 427L, 640L)

Convents เป็นข้อมูลเกี่ยวกับการสร้างแบบจำลอง CNN ตั้งแต่เริ่มต้น สถาปัตยกรรมเครือข่ายจะประกอบด้วยขั้นตอนต่อไปนี้ -

• Conv2d
• MaxPool2d
• แก้ไขหน่วยเชิงเส้น
• View
• เลเยอร์เชิงเส้น

การฝึกอบรมรูปแบบ

การฝึกโมเดลเป็นกระบวนการเดียวกันเช่นปัญหาการจำแนกรูปภาพ ข้อมูลโค้ดต่อไปนี้ทำตามขั้นตอนของแบบจำลองการฝึกอบรมในชุดข้อมูลที่ให้มา -

def fit(epoch,model,data_loader,phase 
= 'training',volatile = False):
   if phase == 'training':
      model.train()
   if phase == 'training':
      model.train()
   if phase == 'validation':
      model.eval()
   volatile=True
   running_loss = 0.0
   running_correct = 0
   for batch_idx , (data,target) in enumerate(data_loader):
      if is_cuda:
         data,target = data.cuda(),target.cuda()
         data , target = Variable(data,volatile),Variable(target)
      if phase == 'training':
         optimizer.zero_grad()
         output = model(data)
         loss = F.nll_loss(output,target)
         running_loss + = 
         F.nll_loss(output,target,size_average = 
         False).data[0]
         preds = output.data.max(dim = 1,keepdim = True)[1]
         running_correct + = 
         preds.eq(target.data.view_as(preds)).cpu().sum()
         if phase == 'training':
            loss.backward()
            optimizer.step()
   loss = running_loss/len(data_loader.dataset)
   accuracy = 100. * running_correct/len(data_loader.dataset)
   print(f'{phase} loss is {loss:{5}.{2}} and {phase} accuracy is {running_correct}/{len(data_loader.dataset)}{accuracy:{return loss,accuracy}})

วิธีการนี้รวมถึงตรรกะที่แตกต่างกันสำหรับการฝึกอบรมและการตรวจสอบความถูกต้อง มีสาเหตุหลักสองประการในการใช้โหมดต่างๆ -

• ในโหมดรถไฟการออกกลางคันจะลบเปอร์เซ็นต์ของค่าซึ่งไม่ควรเกิดขึ้นในขั้นตอนการตรวจสอบความถูกต้องหรือการทดสอบ

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

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

ขั้นตอนที่ 1

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

class Neural_Network(nn.Module):
   def __init__(self, ):
      super(Neural_Network, self).__init__()
      self.inputSize = 2
      self.outputSize = 1
      self.hiddenSize = 3
      # weights
      self.W1 = torch.randn(self.inputSize, 
      self.hiddenSize) # 3 X 2 tensor
      self.W2 = torch.randn(self.hiddenSize, self.outputSize) # 3 X 1 tensor

ขั้นตอนที่ 2

สร้างรูปแบบฟังก์ชั่นฟีดไปข้างหน้าด้วยฟังก์ชัน sigmoid

def forward(self, X):
   self.z = torch.matmul(X, self.W1) # 3 X 3 ".dot" 
   does not broadcast in PyTorch
   self.z2 = self.sigmoid(self.z) # activation function
   self.z3 = torch.matmul(self.z2, self.W2)
   o = self.sigmoid(self.z3) # final activation 
   function
   return o
   def sigmoid(self, s):
      return 1 / (1 + torch.exp(-s))
   def sigmoidPrime(self, s):
      # derivative of sigmoid
      return s * (1 - s)
   def backward(self, X, y, o):
      self.o_error = y - o # error in output
      self.o_delta = self.o_error * self.sigmoidPrime(o) # derivative of sig to error
      self.z2_error = torch.matmul(self.o_delta, torch.t(self.W2))
      self.z2_delta = self.z2_error * self.sigmoidPrime(self.z2)
      self.W1 + = torch.matmul(torch.t(X), self.z2_delta)
      self.W2 + = torch.matmul(torch.t(self.z2), self.o_delta)

ขั้นตอนที่ 3

สร้างแบบจำลองการฝึกอบรมและการทำนายตามที่ระบุไว้ด้านล่าง -

def train(self, X, y):
   # forward + backward pass for training
   o = self.forward(X)
   self.backward(X, y, o)
def saveWeights(self, model):
   # Implement PyTorch internal storage functions
   torch.save(model, "NN")
   # you can reload model with all the weights and so forth with:
   # torch.load("NN")
def predict(self):
   print ("Predicted data based on trained weights: ")
   print ("Input (scaled): \n" + str(xPredicted))
   print ("Output: \n" + str(self.forward(xPredicted)))

Convolutional Neural Network ประกอบด้วยคุณสมบัติหลัก extraction. ขั้นตอนต่อไปนี้ใช้เพื่อใช้การแยกคุณลักษณะของโครงข่ายประสาทเทียมแบบ convolutional

ขั้นตอนที่ 1

นำเข้าโมเดลที่เกี่ยวข้องเพื่อสร้างโมเดลการแยกคุณลักษณะด้วย“ PyTorch”

import torch
import torch.nn as nn
from torchvision import models

ขั้นตอนที่ 2

สร้างคลาสของตัวแยกคุณลักษณะซึ่งสามารถเรียกได้ว่าเป็นและเมื่อต้องการ

class Feature_extractor(nn.module):
   def forward(self, input):
      self.feature = input.clone()
      return input
new_net = nn.Sequential().cuda() # the new network
target_layers = [conv_1, conv_2, conv_4] # layers you want to extract`
i = 1
for layer in list(cnn):
   if isinstance(layer,nn.Conv2d):
      name = "conv_"+str(i)
      art_net.add_module(name,layer)
      if name in target_layers:
         new_net.add_module("extractor_"+str(i),Feature_extractor())
      i+=1
   if isinstance(layer,nn.ReLU):
      name = "relu_"+str(i)
      new_net.add_module(name,layer)
   if isinstance(layer,nn.MaxPool2d):
      name = "pool_"+str(i)
      new_net.add_module(name,layer)
new_net.forward(your_image)
print (new_net.extractor_3.feature)

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

ขั้นตอนที่ 1

นำเข้าโมดูลที่จำเป็นซึ่งมีความสำคัญต่อการสร้างภาพของโครงข่ายประสาทเทียมแบบเดิม

import os
import numpy as np
import pandas as pd
from scipy.misc import imread
from sklearn.metrics import accuracy_score

import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, Activation, Input
from keras.layers import Conv2D, MaxPooling2D
import torch

ขั้นตอนที่ 2

หากต้องการหยุดการสุ่มที่อาจเกิดขึ้นด้วยข้อมูลการฝึกอบรมและการทดสอบให้เรียกชุดข้อมูลตามลำดับตามที่ระบุในรหัสด้านล่าง -

seed = 128
rng = np.random.RandomState(seed)
data_dir = "../../datasets/MNIST"
train = pd.read_csv('../../datasets/MNIST/train.csv')
test = pd.read_csv('../../datasets/MNIST/Test_fCbTej3.csv')
img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'train', img_name)
img = imread(filepath, flatten=True)

ขั้นตอนที่ 3

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

pylab.imshow(img, cmap ='gray')
pylab.axis('off')
pylab.show()

ผลลัพธ์จะแสดงดังต่อไปนี้ -

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

ที่นี่เราจะเน้น creating the sequential network with specific pooling from the values included in dataset. นอกจากนี้กระบวนการนี้ยังใช้ได้ดีที่สุดใน“ Image Recognition Module”

ขั้นตอนต่อไปนี้ใช้เพื่อสร้างแบบจำลองการประมวลผลลำดับด้วยคอนแวนต์โดยใช้ PyTorch -

ขั้นตอนที่ 1

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

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout, Flatten 
from keras.layers import Conv2D, MaxPooling2D 
import numpy as np

ขั้นตอนที่ 2

ดำเนินการที่จำเป็นเพื่อสร้างรูปแบบตามลำดับโดยใช้รหัสด้านล่าง -

batch_size = 128 
num_classes = 10 
epochs = 12
# input image dimensions 
img_rows, img_cols = 28, 28
# the data, split between train and test sets 
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000,28,28,1) 
x_test = x_test.reshape(10000,28,28,1)
print('x_train shape:', x_train.shape) 
print(x_train.shape[0], 'train samples') 
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, num_classes) 
y_test = keras.utils.to_categorical(y_test, num_classes)

ขั้นตอนที่ 3

รวบรวมแบบจำลองและพอดีกับรูปแบบในแบบจำลองเครือข่ายประสาทเทียมทั่วไปดังที่แสดงด้านล่าง -

model.compile(loss = 
keras.losses.categorical_crossentropy, 
optimizer = keras.optimizers.Adadelta(), metrics = 
['accuracy'])
model.fit(x_train, y_train, 
batch_size = batch_size, epochs = epochs, 
verbose = 1, validation_data = (x_test, y_test)) 
score = model.evaluate(x_test, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

ผลลัพธ์ที่สร้างขึ้นมีดังนี้ -

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

การใช้งานโมเดล word2vec ใน PyTorch ได้อธิบายไว้ในขั้นตอนด้านล่างนี้ -

ขั้นตอนที่ 1

ใช้ไลบรารีในการฝังคำตามที่กล่าวไว้ด้านล่าง -

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

ขั้นตอนที่ 2

ใช้ Skip Gram Model ของการฝังคำกับคลาสที่เรียกว่า word2vec ซึ่งรวมถึงemb_size, emb_dimension, u_embedding, v_embedding ประเภทของแอตทริบิวต์

class SkipGramModel(nn.Module):
   def __init__(self, emb_size, emb_dimension):
      super(SkipGramModel, self).__init__()
      self.emb_size = emb_size
      self.emb_dimension = emb_dimension
      self.u_embeddings = nn.Embedding(emb_size, emb_dimension, sparse=True)
      self.v_embeddings = nn.Embedding(emb_size, emb_dimension, sparse = True)
      self.init_emb()
   def init_emb(self):
      initrange = 0.5 / self.emb_dimension
      self.u_embeddings.weight.data.uniform_(-initrange, initrange)
      self.v_embeddings.weight.data.uniform_(-0, 0)
   def forward(self, pos_u, pos_v, neg_v):
      emb_u = self.u_embeddings(pos_u)
      emb_v = self.v_embeddings(pos_v)
      score = torch.mul(emb_u, emb_v).squeeze()
      score = torch.sum(score, dim = 1)
      score = F.logsigmoid(score)
      neg_emb_v = self.v_embeddings(neg_v)
      neg_score = torch.bmm(neg_emb_v, emb_u.unsqueeze(2)).squeeze()
      neg_score = F.logsigmoid(-1 * neg_score)
      return -1 * (torch.sum(score)+torch.sum(neg_score))
   def save_embedding(self, id2word, file_name, use_cuda):
      if use_cuda:
         embedding = self.u_embeddings.weight.cpu().data.numpy()
      else:
         embedding = self.u_embeddings.weight.data.numpy()
      fout = open(file_name, 'w')
      fout.write('%d %d\n' % (len(id2word), self.emb_dimension))
      for wid, w in id2word.items():
         e = embedding[wid]
         e = ' '.join(map(lambda x: str(x), e))
         fout.write('%s %s\n' % (w, e))
def test():
   model = SkipGramModel(100, 100)
   id2word = dict()
   for i in range(100):
      id2word[i] = str(i)
   model.save_embedding(id2word)

ขั้นตอนที่ 3

ใช้วิธีการหลักเพื่อให้ได้รูปแบบการฝังคำที่แสดงในวิธีที่เหมาะสม

if __name__  ==  '__main__':
   test()

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

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

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

คุณสมบัติของ Recursive Neural Network

• โครงข่ายประสาทแบบวนซ้ำถูกสร้างขึ้นในลักษณะที่รวมการใช้ชุดของน้ำหนักเดียวกันกับโครงสร้างที่เหมือนกราฟที่แตกต่างกัน

• โหนดจะถูกส่งผ่านตามลำดับโทโพโลยี

• เครือข่ายประเภทนี้ได้รับการฝึกฝนโดยโหมดย้อนกลับของการสร้างความแตกต่างอัตโนมัติ

• การประมวลผลภาษาธรรมชาติรวมถึงกรณีพิเศษของเครือข่ายประสาทแบบเรียกซ้ำ

• โครงข่ายเทนเซอร์ประสาทแบบเรียกซ้ำนี้ประกอบด้วยโหนดการทำงานขององค์ประกอบต่างๆในต้นไม้

ตัวอย่างของโครงข่ายประสาทแบบวนซ้ำแสดงอยู่ด้านล่าง -