ส่วนนี้มีลิงก์ไปยังบทความจาก RuNet เกี่ยวกับโครงข่ายประสาทเทียม บทความหลายบทความเขียนด้วยภาษาต้นฉบับที่มีชีวิตชีวาและเข้าใจได้ดีมาก อย่างไรก็ตาม ส่วนใหญ่จะพิจารณาเฉพาะการออกแบบขั้นพื้นฐานและเรียบง่ายที่สุดเท่านั้น ที่นี่คุณจะพบลิงก์ไปยังวรรณกรรมเกี่ยวกับโครงข่ายประสาทเทียม หนังสือเรียนและหนังสือตามที่ควรจะเป็นเขียนด้วยภาษาเชิงวิชาการหรือภาษาที่คล้ายกันและมีตัวอย่างเชิงนามธรรมที่คลุมเครือของการสร้างโครงข่ายประสาทเทียม การฝึกอบรม ฯลฯ ควรระลึกไว้เสมอว่าคำศัพท์ในบทความต่างๆ นั้น "ลอย" เท่าที่จะทำได้ จะเห็นได้จากความคิดเห็นต่อบทความ ด้วยเหตุนี้ในช่วงแรกอาจมี “เรื่องยุ่งๆ ในหัว”

• วิธีที่เกษตรกรชาวญี่ปุ่นคัดแยกแตงกวาโดยใช้การเรียนรู้เชิงลึกและ TensorFlow
• โครงข่ายประสาทเทียมในรูปภาพ: จากเซลล์ประสาทเดี่ยวไปจนถึงสถาปัตยกรรมเชิงลึก
• ตัวอย่างของโปรแกรมโครงข่ายประสาทเทียมที่มีซอร์สโค้ดในภาษา C++
• การใช้งานโครงข่ายประสาทเทียมชั้นเดียว - เพอร์เซปตรอนสำหรับปัญหาการจำแนกประเภทยานพาหนะ
• ดาวน์โหลดหนังสือเกี่ยวกับโครงข่ายประสาทเทียม สุขภาพดี!
• เทคโนโลยีตลาดหุ้น: ความเข้าใจผิด 10 ประการเกี่ยวกับโครงข่ายประสาทเทียม
• อัลกอริทึมสำหรับการฝึกโครงข่ายประสาทเทียมแบบหลายชั้นโดยใช้วิธีการแพร่กระจายกลับ

โครงข่ายประสาทเทียมใน Python

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

เทนเซอร์โฟลว์

ออบเจ็กต์กลางของ TensorFlow คือกราฟการไหลของข้อมูลที่แสดงถึงการคำนวณ จุดยอดของกราฟแสดงถึงการดำเนินการ และขอบแสดงถึงเทนเซอร์ (เทนเซอร์) ( อาร์เรย์หลายมิติซึ่งเป็นพื้นฐานของ TensorFlow) กราฟการไหลของข้อมูลโดยรวมคือ คำอธิบายแบบเต็มการคำนวณที่ดำเนินการภายในเซสชันและดำเนินการบนอุปกรณ์ (CPU หรือ GPU) เช่นเดียวกับระบบสมัยใหม่อื่นๆ สำหรับการคำนวณทางวิทยาศาสตร์และ การเรียนรู้ของเครื่อง TensorFlow มี API ที่ได้รับการบันทึกไว้อย่างดีสำหรับ Python โดยที่เทนเซอร์จะแสดงเป็นอาร์เรย์ NumPy ndarray ที่คุ้นเคย TensorFlow ทำการคำนวณโดยใช้ C++ ที่ได้รับการปรับให้เหมาะสมสูงสุด และยังรองรับ API ดั้งเดิมสำหรับ C และ C++ อีกด้วย

• ข้อมูลเบื้องต้นเกี่ยวกับการเรียนรู้ของเครื่องด้วยเทนเซอร์โฟลว์ จนถึงขณะนี้มีเพียงบทความแรกจากสี่บทความที่ประกาศเท่านั้นที่ได้รับการตีพิมพ์
• TensorFlow น่าผิดหวัง การเรียนรู้เชิงลึกของ Google ขาด "ความลึก"
• ข้อมูลสรุปการเรียนรู้ของเครื่อง: การจัดประเภทข้อความด้วยโครงข่ายประสาทเทียมและ TensorFlow
• ไลบรารีการเรียนรู้ของเครื่อง Google TensorFlow – ความประทับใจครั้งแรกและการเปรียบเทียบกับการใช้งานของเราเอง

การติดตั้ง tensorflow มีการอธิบายไว้อย่างดีในบทความในลิงค์แรก อย่างไรก็ตาม Python 3.6.1 ได้รับการเผยแพร่แล้ว มันจะไม่สามารถใช้มันได้ อย่างน้อยกำมะถันในขณะนี้ (06/03/2017) ต้องใช้เวอร์ชัน 3.5.3 ซึ่งสามารถดาวน์โหลดได้ ด้านล่างฉันจะให้ลำดับที่เหมาะกับฉัน (แตกต่างจากบทความจาก Habr เล็กน้อย) ยังไม่ชัดเจนว่าทำไม แต่ Python 64- บิตถูกสร้างขึ้นมาเพื่อ โปรเซสเซอร์เอเอ็มดีดังนั้นทุกสิ่งทุกอย่างจะอยู่ภายใต้มัน หลังจากติดตั้ง Phyton อย่าลืมตั้งค่าการเข้าถึงแบบเต็มสำหรับผู้ใช้หากติดตั้ง Python สำหรับทุกคน

pip ติดตั้ง -- อัปเกรด pip
pip ติดตั้ง -U pip setuptools
ติดตั้ง pip3 -- อัปเกรด tensorflow
ติดตั้ง pip3 -- อัปเกรด tensorflow-gpu
pip install matplotlib /*ดาวน์โหลด 8.9 MB และไฟล์ขนาดเล็กอีกสองสามไฟล์ */
pip ติดตั้ง jupyter

"Naked Python" อาจดูไม่น่าสนใจ ดังนั้น ด้านล่างนี้คือคำแนะนำในการติดตั้งในสภาพแวดล้อมของ Anaconda นี่เป็นงานสร้างทางเลือก ไพธอนแล้วรวมเข้ากับมัน

ไซต์นี้มีเวอร์ชันใหม่สำหรับ Python 3.6 อีกครั้ง ซึ่งผลิตภัณฑ์ใหม่ของ Google ยังไม่รองรับ ดังนั้นฉันจึงนำเวอร์ชันก่อนหน้าจากไฟล์เก็บถาวรทันทีคือ Anaconda3-4.2.0 - เหมาะสม อย่าลืมทำเครื่องหมายในช่องลงทะเบียน Python 3.5 โดยเฉพาะก่อนที่จะติดตั้ง Anaconda ควรปิดเทอร์มินัลจะดีกว่า ไม่เช่นนั้น PATH ที่ล้าสมัยจะยังคงใช้งานได้ต่อไป อย่าลืมเปลี่ยนสิทธิ์การเข้าถึงของผู้ใช้ ไม่เช่นนั้นจะไม่มีอะไรทำงาน

conda สร้าง -n เทนเซอร์โฟลว์
เปิดใช้งานเทนเซอร์โฟลว์
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*ดาวน์โหลดจากอินเทอร์เน็ต 19.4 MB จากนั้น 7 , 7 MB และอีก 0.317 MB*/
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-1.1.0-cp35-cp35m-win_amd64.whl /*ดาวน์โหลด 48.6 MB */

สกรีนช็อตของหน้าจอการติดตั้ง: ทุกอย่างเป็นไปด้วยดีใน ​​Anaconda

ในทำนองเดียวกันสำหรับไฟล์ที่สอง

โดยสรุป: เพื่อให้ทั้งหมดนี้ใช้งานได้คุณต้องติดตั้งแพ็คเกจ CUDA Toolkits จาก NVIDEA (ในกรณี การใช้งาน GPU). เวอร์ชันที่รองรับปัจจุบันคือ 8.0 คุณจะต้องดาวน์โหลดและแตกไลบรารี cuDNN v5.1 ลงในโฟลเดอร์ CUDA แต่ไม่ใช่เวอร์ชันที่ใหม่กว่า! หลังจากการยักย้ายเหล่านี้ TensorFlow จะทำงาน

ธีอาโน

• โครงข่ายประสาทเทียมที่เกิดซ้ำในโค้ด 10 บรรทัดประเมินผลตอบรับจากผู้ชมในตอนใหม่ของ "Star Wars"

แพ็คเกจ Theano รวมอยู่ใน PyPI ของ Python เอง โดยตัวมันเองมันมีขนาดเล็ก - 3.1 MB แต่ดึงการพึ่งพาอีก 15 MB - scipy หากต้องการติดตั้งอย่างหลัง คุณต้องมีโมดูล lapack... โดยทั่วไปการติดตั้งแพ็คเกจ theano บน Windows จะหมายถึง "การเต้นรำกับแทมบูรีน" ด้านล่างนี้ฉันจะพยายามแสดงลำดับการดำเนินการเพื่อให้แพ็คเกจทำงานได้

เมื่อใช้อนาคอนดา "การเต้นรำกับแทมบูรีน" ระหว่างการติดตั้งนั้นไม่เกี่ยวข้อง คำสั่งก็เพียงพอแล้ว:

conda ติดตั้ง theano

และกระบวนการจะเกิดขึ้นโดยอัตโนมัติ อย่างไรก็ตาม แพ็คเกจ GCC ก็ถูกโหลดเช่นกัน

Scikit-เรียนรู้

ภายใต้ Python 3.5.3 มากกว่านั้นเท่านั้น เวอร์ชันต้น 0.17.1 ซึ่งคุณสามารถรับได้ มีตัวติดตั้งปกติ อย่างไรก็ตาม มันจะไม่ทำงานโดยตรงบน Windows - คุณต้องมีไลบรารี scipy

การติดตั้งแพ็คเกจตัวช่วย

เพื่อให้ทั้งสองแพ็คเกจข้างต้นใช้งานได้ (เรากำลังพูดถึง Phyton แบบ "เปลือย") คุณต้องทำตามขั้นตอนเบื้องต้น

วิทย์

ในการเปิดตัว Scikit-Learn และ Theano ดังที่เห็นได้ชัดจากข้างต้น คุณจะต้อง "เต้นรำกับแทมบูรีน" สิ่งแรกที่ยานเดกซ์มอบให้เราคือคลังความรู้แม้ว่าจะเป็นภาษาอังกฤษ แต่เป็นทรัพยากร stackoverflow.com ซึ่งเราจะพบลิงก์ไปยังไฟล์เก็บถาวรที่ยอดเยี่ยมของแพ็คเกจ Python ที่มีอยู่เกือบทั้งหมดที่คอมไพล์สำหรับ Windows - lfd.uci.edu

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

pip install --upgrade --ignore-installed http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
pip ติดตั้ง -- อัปเกรด --ignore-insalled http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/scipy-0.19.0-cp35-cp35m-win_amd64.whl
pip --upgrade --ignore แพนด้าที่ติดตั้ง
pip ติดตั้ง -- อัปเกรด -- ละเว้นการติดตั้ง matplotlib

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

ลาแพค/บลาส

ไลบรารีระดับต่ำที่เกี่ยวข้องทั้งสองนี้ ซึ่งเขียนด้วยภาษา Fortran จำเป็นสำหรับการติดตั้งแพ็คเกจ Theano Scikit-Learn ยังสามารถทำงานกับโปรแกรมที่ติดตั้ง "ซ่อน" ในแพ็คเกจอื่น ๆ ไว้แล้ว (ดูด้านบน) จริงๆ แล้ว หากติดตั้ง Theano เวอร์ชัน 0.17 จากไฟล์ exe ก็จะใช้งานได้เช่นกัน อย่างน้อยก็ในอนาคอนด้า อย่างไรก็ตาม ห้องสมุดเหล่านี้สามารถพบได้บนอินเทอร์เน็ตเช่นกัน ตัวอย่างเช่น . งานสร้างล่าสุดเพิ่มเติม เพื่อให้แพ็คเกจสำเร็จรูปทำงานได้ รุ่นก่อนหน้ามันเหมาะ. การสร้างแพ็คเกจใหม่จะต้องมีเวอร์ชันใหม่

ควรสังเกตว่าใน Anaconda บิลด์ใหม่ทั้งหมด แพ็คเกจ Theano ได้รับการติดตั้งง่ายกว่ามาก - ด้วยคำสั่งเดียว แต่บอกตามตรงว่าฉันไม่สนใจ ที่เวทีนี้(ศูนย์) การควบคุมโครงข่ายประสาทเทียม ฉันชอบ TensorFlow มากกว่า แต่ยังไม่เป็นมิตรกับ Python เวอร์ชันใหม่

การเขียนโปรแกรม

• การแปล

เป็นบทความเกี่ยวกับอะไร?

โดยส่วนตัวแล้ว ฉันเรียนรู้ได้ดีที่สุดด้วยโค้ดเล็กๆ น้อยๆ ที่ฉันสามารถเล่นได้ ในบทช่วยสอนนี้ เราจะเรียนรู้อัลกอริธึมการเผยแพร่กลับโดยใช้โครงข่ายประสาทเทียมขนาดเล็กที่ใช้ใน Python เป็นตัวอย่าง

ให้ฉันรหัส!

X = np.array([ ,,, ]) y = np.array([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 สำหรับ j ใน xrange(60000): l1 = 1/(1+np.exp(-(np.dot(X,syn0)))) l2 = 1/(1+np. ประสบการณ์(-(np.dot(l1,syn1)))) l2_delta = (y - l2)*(l2*(1-l2)) l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1 )) syn1 += l1.T.dot(l2_delta) syn0 += X.T.dot(l1_delta)

บีบอัดเกินไป? มาแบ่งมันออกเป็นส่วนๆ ที่ง่ายกว่ากัน

ส่วนที่ 1: โครงข่ายประสาทเทียมของเล่นขนาดเล็ก

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

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

ในกรณีที่ง่ายที่สุด Backpropagation จะคำนวณสถิติที่คล้ายกันเพื่อสร้างแบบจำลอง มาลองกัน.

โครงข่ายประสาทเทียมในสองชั้น

นำเข้าตัวเลขเป็น np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x )) # ชุดข้อมูลอินพุต X = np.array([ , , , ]) # ข้อมูลเอาต์พุต y = np.array([]).T # ทำ ตัวเลขสุ่มเฉพาะเจาะจงมากขึ้น np.random.seed(1) # เริ่มต้นน้ำหนักแบบสุ่มด้วยค่าเฉลี่ย 0 syn0 = 2*np.random.random((3,1)) - 1 สำหรับ iter ใน xrange(10,000): # การแพร่กระจายไปข้างหน้า l0 = X l1 = nonlin(np.dot(l0,syn0)) # เราผิดยังไง? l1_error = y - l1 # คูณสิ่งนี้ด้วยความชันของ sigmoid # ตามค่าใน l1 l1_delta = l1_error * nonlin(l1,True) # !!! # อัปเดตน้ำหนัก syn0 += np.dot(l0.T,l1_delta) # !!! พิมพ์ "ผลลัพธ์หลังการฝึก:" พิมพ์ l1

ผลลัพธ์หลังการฝึก: [[ 0.00966449] [ 0.00786506] [ 0.99358898] [ 0.99211957]]

ตัวแปรและคำอธิบาย

"*" - การคูณแบบองค์ประกอบ - เวกเตอร์สองตัวที่มีขนาดเท่ากันคูณค่าที่สอดคล้องกัน และผลลัพธ์จะเป็นเวกเตอร์ที่มีขนาดเท่ากัน
"-" – การลบเวกเตอร์ตามองค์ประกอบ
x.dot(y) – ถ้า x และ y เป็นเวกเตอร์ ผลลัพธ์ที่ได้จะเป็นผลคูณสเกลาร์ หากสิ่งเหล่านี้คือเมทริกซ์ ผลลัพธ์ก็คือการคูณเมทริกซ์ ถ้าเมทริกซ์เป็นเพียงหนึ่งในนั้น แสดงว่ามันเป็นการคูณเวกเตอร์กับเมทริกซ์

• เปรียบเทียบ l1 หลังจากการวนซ้ำครั้งแรกและหลังครั้งล่าสุด
• ดูฟังก์ชันนอนลิน
• ดูว่า l1_error เปลี่ยนแปลงอย่างไร
• parse line 36 - รวบรวมส่วนผสมลับหลักไว้ที่นี่ (ทำเครื่องหมาย!!!)
• แยกบรรทัด 39 - เครือข่ายทั้งหมดกำลังเตรียมการอย่างแม่นยำสำหรับการดำเนินการนี้ (ทำเครื่องหมาย!!!)

มาแจกแจงโค้ดทีละบรรทัด

นำเข้าตัวเลขเป็น np

นำเข้า numpy ซึ่งเป็นไลบรารีพีชคณิตเชิงเส้น การเสพติดเพียงอย่างเดียวของเรา

Def nonlin(x,deriv=False):

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

ถ้า(มา==จริง):

ฟังก์ชันนี้ยังสามารถสร้างอนุพันธ์ของซิกมอยด์ได้ (deriv=True) นี่เป็นหนึ่งในคุณสมบัติที่เป็นประโยชน์ของมัน หากเอาต์พุตของฟังก์ชันเป็นตัวแปร out อนุพันธ์ก็จะเป็น out * (1-out) มีประสิทธิภาพ.

X = np.อาร์เรย์([ , …

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

Y = np.อาร์เรย์([]).T

เตรียมข้อมูลเอาต์พุต ".T" – ฟังก์ชันการถ่ายโอน หลังจากการแปล เมทริกซ์ y จะมี 4 แถวและมี 1 คอลัมน์ เช่นเดียวกับข้อมูลอินพุต แต่ละแถวคือตัวอย่างการฝึก และแต่ละคอลัมน์ (ในกรณีของเรา) คือโหนดเอาต์พุต ปรากฎว่าเครือข่ายมีอินพุต 3 อันและเอาต์พุต 1 อัน

Np.สุ่ม.เมล็ด(1)

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

Syn0 = 2*np.random.random((3,1)) – 1

เมทริกซ์น้ำหนักเครือข่าย syn0 หมายถึง "ไซแนปส์ศูนย์" เนื่องจากเรามีเพียงสองชั้น คือ อินพุตและเอาต์พุต เราจึงจำเป็นต้องมีเมทริกซ์น้ำหนักตัวเดียวที่จะเชื่อมต่อพวกมันเข้าด้วยกัน มิติของมันคือ (3, 1) เนื่องจากเรามี 3 อินพุตและ 1 เอาต์พุต กล่าวอีกนัยหนึ่ง l0 มีขนาด 3 และ l1 มีขนาด 1 เนื่องจากเรากำลังเชื่อมต่อโหนดทั้งหมดใน l0 กับโหนดทั้งหมดใน l1 เราจึงจำเป็นต้องมีเมทริกซ์มิติ (3, 1)

โปรดทราบว่าค่าเริ่มต้นจะเริ่มต้นแบบสุ่มและค่าเฉลี่ยเป็นศูนย์ มีทฤษฎีที่ค่อนข้างซับซ้อนอยู่เบื้องหลังเรื่องนี้ สำหรับตอนนี้เราจะถือว่านี่เป็นคำแนะนำเท่านั้น โปรดทราบด้วยว่าโครงข่ายประสาทเทียมของเราเป็นเมทริกซ์แบบนี้ เรามี "เลเยอร์" l0 และ l1 แต่สิ่งเหล่านี้เป็นค่าชั่วคราวตามชุดข้อมูล เราไม่เก็บไว้ การฝึกอบรมทั้งหมดถูกเก็บไว้ใน syn0

สำหรับ iter ใน xrange(10,000):

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

เลเยอร์แรก l0 เป็นเพียงข้อมูล X มีตัวอย่างการฝึกอบรม 4 ตัวอย่าง เราจะดำเนินการทั้งหมดพร้อมกัน ซึ่งเรียกว่าการฝึกอบรมแบบกลุ่ม รวมแล้วเรามี 4 อัน เส้นที่แตกต่างกัน l0 แต่คุณสามารถคิดว่ามันเป็นตัวอย่างการฝึกอบรมอย่างหนึ่ง - ในขั้นตอนนี้มันไม่สำคัญ (คุณสามารถโหลดได้ 1,000 หรือ 10,000 รายการโดยไม่มีการเปลี่ยนแปลงรหัสใด ๆ )

L1 = ไม่ใช่ลิน(np.dot(l0,syn0))

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

มีสองขั้นตอนต่อบรรทัด อันแรกทำการคูณเมทริกซ์ของ l0 และ syn0 อันที่สองส่งเอาต์พุตผ่านซิกมอยด์ ขนาดของพวกเขามีดังนี้:

(4 x 3) จุด (3 x 1) = (4 x 1)

การคูณเมทริกซ์กำหนดให้มิติตรงกลางสมการต้องเท่ากัน เมทริกซ์สุดท้ายมีจำนวนแถวเท่ากันกับเมทริกซ์แรก และจำนวนคอลัมน์เท่ากับเมทริกซ์ที่สอง

เราโหลดตัวอย่างการฝึกอบรม 4 ตัวอย่างและมีการเดา 4 ครั้ง (เมทริกซ์ 4x1) แต่ละเอาต์พุตสอดคล้องกับการเดาของเครือข่ายสำหรับอินพุตที่กำหนด

L1_error = y - l1

เนื่องจาก l1 มีการเดา เราจึงสามารถเปรียบเทียบความแตกต่างกับความเป็นจริงได้โดยการลบ l1 ออกจากคำตอบที่ถูกต้อง y l1_error เป็นเวกเตอร์ของจำนวนบวกและลบที่แสดงลักษณะของเครือข่าย "พลาด"

และนี่คือส่วนผสมลับ บรรทัดนี้จะต้องแยกวิเคราะห์ทีละชิ้น

ส่วนที่หนึ่ง: อนุพันธ์

นลิน(l1,จริง)

L1 แสดงถึงจุดทั้งสามนี้ และโค้ดจะสร้างความชันของเส้นที่แสดงด้านล่าง โปรดทราบว่าสำหรับค่าขนาดใหญ่ เช่น x=2.0 (จุดสีเขียว) และค่าที่น้อยมาก เช่น x=-1.0 (สีม่วง) เส้นจะมีความชันเล็กน้อย มุมที่ใหญ่ที่สุดที่จุด x=0 (สีน้ำเงิน) สิ่งนี้สร้างความแตกต่างอย่างมาก โปรดทราบว่าอนุพันธ์ทั้งหมดมีตั้งแต่ 0 ถึง 1

นิพจน์แบบเต็ม: อนุพันธ์ถ่วงน้ำหนักคลาดเคลื่อน

L1_delta = l1_error * nonlin(l1,จริง)

ในทางคณิตศาสตร์มีวิธีการที่แม่นยำกว่า แต่ในกรณีของเราวิธีนี้ก็เหมาะสมเช่นกัน l1_error คือเมทริกซ์ (4,1) nonlin(l1,True) ส่งคืนเมทริกซ์ (4,1) ที่นี่เราคูณพวกมันทีละองค์ประกอบ และที่เอาต์พุต เราก็จะได้เมทริกซ์ (4,1), l1_delta ด้วย

ด้วยการคูณอนุพันธ์ด้วยข้อผิดพลาด เราจะลดข้อผิดพลาดของการคาดการณ์ที่ทำขึ้นด้วยความมั่นใจในระดับสูง หากความชันของเส้นมีขนาดเล็ก แสดงว่าเครือข่ายมีค่าที่มากหรือน้อยมาก หากการคาดเดาของเครือข่ายใกล้กับศูนย์ (x=0, y=0.5) แสดงว่าไม่มีความมั่นใจเป็นพิเศษ เราอัปเดตการคาดการณ์ที่ไม่แน่นอนเหล่านี้และปล่อยให้การคาดการณ์ที่มีความมั่นใจสูงเพียงอย่างเดียวโดยการคูณด้วยค่าที่ใกล้กับศูนย์

Syn0 += np.dot(l0.T,l1_delta)

เราพร้อมที่จะอัพเดตเครือข่าย ลองดูตัวอย่างการฝึกอบรมหนึ่งตัวอย่าง ในนั้นเราจะอัปเดตน้ำหนัก อัพเดทน้ำหนักซ้ายสุด (9.5)

Weight_update = input_value * l1_delta

สำหรับน้ำหนักซ้ายสุดจะเป็น 1.0 * l1_delta คงจะเพิ่มแค่ 9.5 เพียงเล็กน้อยเท่านั้น ทำไม เพราะคำทำนายค่อนข้างมั่นใจอยู่แล้วและการทำนายก็ถูกต้องตามความเป็นจริง ข้อผิดพลาดเล็กๆ น้อยๆ และความลาดเอียงของเส้นเล็กน้อยหมายถึงการอัปเดตที่มีขนาดเล็กมาก

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

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

อินพุต เอาต์พุต 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 0

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

ส่วนที่ 2: งานที่ยากขึ้น

อินพุต เอาต์พุต 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

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

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

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

กลยุทธ์

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

อินพุต (l0) น้ำหนักที่ซ่อนอยู่ (l1) เอาต์พุต (l2) 0 0 1 0.1 0.2 0.5 0.2 0 0 1 1 0.2 0.6 0.7 0.1 1 1 0 1 0.3 0.2 0.3 0.9 1 1 1 1 1 0.2 0.1 0.3 0.8 0

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

โครงข่ายประสาทเทียมสามชั้น

นำเข้าตัวเลขเป็น np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # สุ่มเริ่มต้นน้ำหนัก โดยเฉลี่ย - 0 syn0 = 2*np.random สุ่ม ((3,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 สำหรับ j ใน xrange(60000): # ไปข้างหน้าผ่านเลเยอร์ 0, 1 และ 2 l0 = X l1 = nonlin(np.dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # เราคิดผิดเกี่ยวกับค่าที่ต้องการมากแค่ไหน? l2_error = y - l2 if (j% 10,000) == 0: print "Error:" + str(np.mean(np.abs(l2_error))) # คุณควรเคลื่อนที่ไปทางไหน? # ถ้าเรามั่นใจในการทำนายก็ไม่จำเป็นต้องเปลี่ยนมากนัก l2_delta = l2_error*nonlin(l2,deriv=True) # ค่าของ l1 ส่งผลต่อข้อผิดพลาดใน l2 มากน้อยเพียงใด? l1_error = l2_delta.dot(syn1.T) # เราควรเคลื่อนที่ไปในทิศทางใดเพื่อไปยัง l1? # ถ้าเรามั่นใจในการทำนายก็ไม่ต้องเปลี่ยนมาก l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot (l1_เดลต้า)

ข้อผิดพลาด:0.496410031903 ข้อผิดพลาด:0.00858452565325 ข้อผิดพลาด:0.00578945986251 ข้อผิดพลาด:0.00462917677677 ข้อผิดพลาด:0.00395876528027 ข้อผิดพลาด:0.00351012256786

ตัวแปรและคำอธิบาย

X คือเมทริกซ์ของชุดข้อมูลอินพุต สตริง - ตัวอย่างการฝึกอบรม
y – เมทริกซ์ของชุดข้อมูลเอาท์พุต สตริง - ตัวอย่างการฝึกอบรม
l0 – เลเยอร์เครือข่ายแรกที่กำหนดโดยข้อมูลอินพุต
l1 – เลเยอร์ที่สองของเครือข่ายหรือเลเยอร์ที่ซ่อนอยู่
l2 คือชั้นสุดท้าย นี่คือสมมติฐานของเรา ในขณะที่คุณฝึกฝนคุณควรเข้าใกล้คำตอบที่ถูกต้องมากขึ้น
syn0 – ชั้นแรกของน้ำหนัก Synapse 0 รวม l0 กับ l1
syn1 – ชั้นที่สองของน้ำหนัก Synapse 1 รวม l1 กับ l2
l2_error – ข้อผิดพลาดของเครือข่ายในแง่ปริมาณ
l2_delta – ข้อผิดพลาดของเครือข่าย ขึ้นอยู่กับความเชื่อมั่นของการทำนาย เกือบจะเหมือนกับข้อผิดพลาด ยกเว้นการคาดการณ์ที่มั่นใจ
l1_error – โดยการชั่งน้ำหนัก l2_delta ด้วยน้ำหนักจาก syn1 เราจะคำนวณข้อผิดพลาดในเลเยอร์ตรงกลาง/ที่ซ่อนอยู่
l1_delta – ข้อผิดพลาดของเครือข่ายจาก l1 ปรับขนาดตามความเชื่อมั่นของการคาดการณ์ เกือบจะเหมือนกับ l1_error ยกเว้นการคาดการณ์ที่มั่นใจ

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

L1_error = l2_delta.dot(syn1.T)

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

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

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

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

• เคราสคืออะไร?
• การวิเคราะห์ความรู้สึกคืออะไร?
• ชุดข้อมูล IMDB
• การสำรวจข้อมูล
• การเตรียมข้อมูล
• การสร้างโมเดลและการฝึกอบรม

เคราสคืออะไร?

Keras เป็นไลบรารี Python แบบโอเพ่นซอร์ส รหัสแหล่งที่มาซึ่งทำให้ง่ายต่อการสร้างโครงข่ายประสาทเทียม ไลบรารีนี้เข้ากันได้กับ Microsoft Cognitive Toolkit, Theano และ MXNet Tensorflow และ Theano เป็นเฟรมเวิร์กเชิงตัวเลขของ Python ที่ใช้บ่อยที่สุดสำหรับการพัฒนาอัลกอริธึมการเรียนรู้เชิงลึก แต่ใช้งานได้ค่อนข้างยาก

ประเมินความนิยมของกรอบการเรียนรู้ของเครื่องใน 7 หมวดหมู่

ในทางกลับกัน Keras มอบวิธีที่ง่ายและสะดวกในการสร้างโมเดลการเรียนรู้เชิงลึก François Chollet ผู้สร้างมันได้พัฒนามันขึ้นมาเพื่อเพิ่มความเร็วและลดความซับซ้อนของกระบวนการสร้างโครงข่ายประสาทเทียมให้มากที่สุดเท่าที่จะเป็นไปได้ เขามุ่งเน้นไปที่ความสามารถในการขยาย, ความเป็นโมดูลาร์, ความเรียบง่าย และการรองรับ Python Keras สามารถใช้กับ GPU และ CPU; รองรับทั้ง Python 2 และ Python 3 Keras Googleได้มีส่วนสนับสนุนอย่างมากต่อการนำการเรียนรู้เชิงลึกไปใช้ในเชิงพาณิชย์ และเนื่องจากมีอัลกอริธึมการเรียนรู้เชิงลึกที่ล้ำสมัย ซึ่งก่อนหน้านี้ไม่เพียงแต่ไม่สามารถเข้าถึงได้ แต่ยังใช้งานไม่ได้อีกด้วย

การวิเคราะห์ความรู้สึก (Sentiment Analysis) คืออะไร?

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

ตัวอย่างระดับการวิเคราะห์ความรู้สึก

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

ชุดข้อมูล IMDb

รีวิวบน IMDb

ชุดข้อมูล IMDb ประกอบด้วยบทวิจารณ์ภาพยนตร์ 50,000 รายการจากผู้ใช้ โดยมีป้ายกำกับว่าเป็นบวก (1) และลบ (0)

• บทวิจารณ์จะได้รับการประมวลผลล่วงหน้า และแต่ละรายการจะถูกเข้ารหัสด้วยลำดับดัชนีคำเป็นจำนวนเต็ม
• คำในบทวิจารณ์จะถูกจัดทำดัชนีตามความถี่โดยรวมของคำเหล่านั้นที่ปรากฏในชุดข้อมูล ตัวอย่างเช่น จำนวนเต็ม "2" จะเข้ารหัสคำที่ใช้บ่อยเป็นอันดับสอง
• บทวิจารณ์ 50,000 รายการแบ่งออกเป็นสองชุด: 25,000 รายการสำหรับการฝึกอบรม และ 25,000 รายการสำหรับการทดสอบ

ชุดข้อมูลนี้สร้างขึ้นโดยนักวิจัยจากมหาวิทยาลัยสแตนฟอร์ด และนำเสนอในรายงานปี 2554 ซึ่งมีความแม่นยำในการทำนายถึง 88.89% ชุดข้อมูลยังใช้เป็นส่วนหนึ่งของการแข่งขันชุมชน Keggle "ถุงคำพบกับถุงป๊อปคอร์น"ในปี 2011.

การนำเข้าการอ้างอิงและการดึงข้อมูล

เริ่มต้นด้วยการนำเข้าการขึ้นต่อกันที่จำเป็นเพื่อประมวลผลข้อมูลล่วงหน้าและสร้างแบบจำลอง

%matplotlib การนำเข้าแบบอินไลน์ matplotlib นำเข้า matplotlib.pyplot เป็น plt นำเข้า numpy เป็น np จาก keras.utils นำเข้า to_categorical จากโมเดลการนำเข้า keras จากเลเยอร์การนำเข้า keras

มาโหลดชุดข้อมูล IMDb ซึ่งมีอยู่แล้วใน Keras กัน เนื่องจากเราไม่ต้องการให้ข้อมูลการฝึกอบรมและการทดสอบ 50/50 เราจะรวมข้อมูลนี้ทันทีหลังจากโหลดเพื่อแยกในภายหลัง ในอัตราส่วน 80/20:

จาก keras.datasets นำเข้า imdb (training_data, training_targets), (testing_data, การทดสอบ_เป้าหมาย) = imdb.load_data(num_words=10000) data = np.concatenate((training_data, การทดสอบ_data), axis=0) targets = np.concatenate((training_targets , การทดสอบ_เป้าหมาย), แกน=0)

การสำรวจข้อมูล

มาศึกษาชุดข้อมูลของเรากัน:

Print("Categories:", np.unique(targets)) print("จำนวนคำที่ไม่ซ้ำ:", len(np.unique(np.hstack(data)))) หมวดหมู่: จำนวนคำที่ไม่ซ้ำ: 9998 length = print ("Average Review length:", np.mean(length)) print("Standard Deviation:", round(np.std(length))) ความยาวรีวิวเฉลี่ย: 234.75892 Standard Deviation: 173.0

คุณจะเห็นว่าข้อมูลทั้งหมดแบ่งออกเป็นสองประเภท: 0 หรือ 1 ซึ่งแสดงถึงความรู้สึกของการรีวิว ชุดข้อมูลทั้งหมดประกอบด้วยคำที่ไม่ซ้ำกัน 9998 คำ ขนาดบทวิจารณ์โดยเฉลี่ยคือ 234 คำ โดยมีค่าเบี่ยงเบนมาตรฐาน 173 คำ

มาดูวิธีเรียนรู้ง่ายๆ กัน:

พิมพ์ ("ป้ายกำกับ:" เป้าหมาย) ป้ายกำกับ: พิมพ์ 1 ครั้ง (ข้อมูล)

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

Index = imdb.get_word_index() Reverse_index = dict([(value, key) for (key, value) in index.items()]) decoded = " ".join() print(decoded) # หนังเรื่องนี้เป็นการคัดเลือกนักแสดงที่ยอดเยี่ยมมาก สถานที่ ทิวทัศน์ เรื่องราว ทิศทาง ทุกคนเหมาะกับบทที่พวกเขาเล่นจริงๆ และคุณคงนึกภาพออกว่าการได้อยู่ที่นั่น โรเบิร์ต # เป็นนักแสดงที่น่าทึ่งและตอนนี้เป็นผู้กำกับคนเดียวกัน # พ่อมาจากเกาะสก็อตแลนด์เดียวกันกับตัวฉันเอง ฉันชอบความจริงที่ว่ามี การเชื่อมโยงที่แท้จริงกับภาพยนตร์เรื่องนี้ คำพูดที่เฉียบแหลมตลอดทั้งเรื่องนั้นยอดเยี่ยมมาก มันยอดเยี่ยมมากจนฉันซื้อภาพยนตร์เรื่องนี้ทันทีที่ออกฉายในราคา # และอยากจะแนะนำให้ทุกคนดู และการตกปลาด้วยแมลงก็น่าทึ่งจริงๆ ร้องไห้ที่ ตอนจบมันเศร้ามากและคุณรู้ไหมว่าพวกเขาพูดอะไรถ้าคุณร้องไห้ในภาพยนตร์มันคงจะดีและนี่ก็เป็น # สำหรับเด็กน้อยสองคนที่รับบทเป็น # ของนอร์แมนและพอล พวกเขาเป็นเด็กที่เก่งมาก ฉันคิดว่าออกจาก # รายการแล้ว เพราะว่าดาราที่รับบทเป็นพวกเขาที่โตเป็นผู้ใหญ่แล้วถือเป็นโปรไฟล์ที่ยิ่งใหญ่ของหนังทั้งเรื่อง แต่เด็กๆ เหล่านี้น่าทึ่งและควรได้รับการยกย่องในสิ่งที่พวกเขาทำ คุณไม่คิดว่าเรื่องราวทั้งหมดจะน่ารักมากเพราะมันเป็นเรื่องจริงและเป็นของใครบางคน ชีวิตหลังจากทุกสิ่งที่แบ่งปันกับเราทุกคน

การเตรียมข้อมูล

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

Def vectorize (ลำดับ, มิติ = 10,000): ผลลัพธ์ = np.zeros ((len (ลำดับ), มิติ)) สำหรับ i, ลำดับในการแจกแจง (ลำดับ): ผลลัพธ์ = 1 ส่งคืนผลลัพธ์ data = vectorize (ข้อมูล) เป้าหมาย = np อาร์เรย์ (เป้าหมาย) .astype ("float32")

มาแบ่งชุดข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบกัน ชุดฝึกอบรมจะประกอบด้วย 40,000 บทวิจารณ์ ชุดทดสอบจะประกอบด้วย 10,000 บทวิจารณ์

Test_x = ข้อมูล [:10000] test_y = เป้าหมาย [:10000] train_x = ข้อมูล train_y = เป้าหมาย

การสร้างโมเดลและการฝึกอบรม

ตอนนี้คุณสามารถสร้างโครงข่ายประสาทเทียมอย่างง่ายได้แล้ว เริ่มต้นด้วยการกำหนดประเภทของโมเดลที่เราต้องการสร้าง Keras มีโมเดลสองประเภท: API ตามลำดับและฟังก์ชัน

จากนั้นคุณจะต้องเพิ่มเลเยอร์อินพุต เลเยอร์ที่ซ่อนอยู่ และเอาต์พุต เพื่อป้องกันไม่ให้มีการติดตั้งมากเกินไป เราจะใช้ข้อยกเว้นระหว่างพวกเขา ( "ออกกลางคัน"). โปรดทราบว่าคุณควรใช้อัตราการยกเว้นระหว่าง 20% ถึง 50% เสมอ แต่ละชั้นใช้ฟังก์ชัน "หนาแน่น"เพื่อเชื่อมต่อชั้นต่างๆ เข้าด้วยกันอย่างสมบูรณ์ เราจะใช้เลเยอร์ที่ซ่อนอยู่ "เรลู"เพราะสิ่งนี้มักจะนำไปสู่ผลลัพธ์ที่น่าพึงพอใจเสมอ อย่ากลัวที่จะทดลองใช้ฟังก์ชันการเปิดใช้งานอื่นๆ ที่เลเยอร์เอาท์พุต เราใช้ฟังก์ชัน sigmoid ที่ทำให้ค่าปกติใหม่ในช่วงตั้งแต่ 0 ถึง 1 โปรดทราบว่าเราตั้งค่าขนาดขององค์ประกอบชุดข้อมูลอินพุตเป็น 10,000 เนื่องจากบทวิจารณ์ของเรามีขนาดมากถึง 10,000 จำนวนเต็ม เลเยอร์อินพุตยอมรับองค์ประกอบที่มีขนาด 10,000 และเอาท์พุตองค์ประกอบที่มีขนาด 50

สุดท้าย ให้ Keras พิมพ์คำอธิบายสั้นๆ ของโมเดลที่เราเพิ่งสร้างขึ้น

# อินพุต - เลเยอร์ model.add(layers.Dense(50, การเปิดใช้งาน = "relu", input_shape=(10000,))) # ซ่อน - เลเยอร์ model.add(layers.Dropout(0.3, noise_shape=None, seed=None) ) model.add (layers.Dense (50, การเปิดใช้งาน = "relu") model.add (layers.Dropout (0.2, noise_shape = ไม่มี, เมล็ด = ไม่มี)) model.add (layers.Dense (50, การเปิดใช้งาน = "relu ")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() _________________________________________________________________ เลเยอร์ (ประเภท) พารามิเตอร์รูปร่างเอาท์พุต # ======= ================================================== === ========หนาแน่น_1 (หนาแน่น) (ไม่มี, 50) 500050 _________________________________________________________________ dropout_1 (กลางคัน) (ไม่มี, 50) 0 _________________________________________________________________หนาแน่น_2 (หนาแน่น) (ไม่มี, 50) 2550 _________________________________________________________________ dropout_2 (กลางคัน) (ไม่มี , 50) 0 _________________________________________________________________ หนาแน่น_3 (หนาแน่น) (ไม่มี, 50) 2550 _________________________________________________________________ หนาแน่น_4 (หนาแน่น) (ไม่มี, 1) 51 ============= =========== =========================== พารามิเตอร์ทั้งหมด: 505,201 พารามิเตอร์ที่ฝึกได้: 505,201 พารามิเตอร์ที่ไม่สามารถฝึกได้ : 0 _________________________________________________________________________________

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

Model.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"])

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

ผลลัพธ์ = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) ฝึกกับตัวอย่าง 40,000 ตัวอย่าง ตรวจสอบกับตัวอย่าง 10,000 ตัวอย่าง ยุค 1/2 40000/40000 [======= =======================] - 5 วินาที 129us/ขั้นตอน - ขาดทุน: 0.4051 - ตามมาตรฐาน: 0.8212 - val_loss: 0.2635 - val_acc: 0.8945 ยุค 2/2 40000 /40000 [============================] - 4s 90us/ขั้นตอน - ขาดทุน: 0.2122 - ตามมาตรฐาน: 0.9190 - val_loss: 0.2598 - val_acc: 0.8950

มาประเมินประสิทธิภาพของโมเดลกัน:

พิมพ์ (np.mean(results.history["val_acc"])) 0.894750000536

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

รหัสรุ่นที่สมบูรณ์ได้รับด้านล่าง:

นำเข้า numpy เป็น np จาก keras.utils import to_categorical จาก keras โมเดลนำเข้าจาก keras เลเยอร์นำเข้าจาก keras.datasets import imdb (training_data, training_targets), (testing_data, Testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate( (training_data, การทดสอบ_ข้อมูล), แกน = 0) เป้าหมาย = np.concatenate ((training_targets, การทดสอบ_เป้าหมาย), แกน = 0) def vectorize (ลำดับ, มิติ = 10,000): ผลลัพธ์ = np.zeros ((len (ลำดับ), มิติ) ) สำหรับ i ลำดับในการแจกแจง (ลำดับ): ผลลัพธ์ = 1 ส่งคืนผลลัพธ์ data = vectorize(data) targets = np.array(targets).astype("float32") test_x = data[:10000] test_y = targets[:10000 ] train_x = data train_y = targets model = models.Sequential() # Input - Layers model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add( layer.Dropout (0.3, noise_shape = ไม่มี, เมล็ด = ไม่มี)) model.add (layers.Dense (50, การเปิดใช้งาน = "relu")) model.add (layers.Dropout (0.2, noise_shape = ไม่มี, เมล็ด = ไม่มี) ) model.add(layers.Dense(50, activation = "relu")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # รวบรวมโมเดลโมเดล คอมไพล์ (เครื่องมือเพิ่มประสิทธิภาพ = "adam", loss = "binary_crossentropy", metrics = ["ความแม่นยำ"]) ผลลัพธ์ = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print( "ทดสอบความแม่นยำ:", np.mean(results.history["val_acc"]))

ผลลัพธ์

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

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

โมเดลนี้ (พร้อมการแก้ไขเล็กน้อย) สามารถนำไปใช้กับปัญหาการเรียนรู้ของเครื่องอื่นๆ ได้

โครงข่ายประสาทเทียม (ANN) เป็นแบบจำลองทางคณิตศาสตร์ เช่นเดียวกับการใช้งานซอฟต์แวร์หรือฮาร์ดแวร์ ที่สร้างขึ้นบนหลักการขององค์กรและการทำงานของโครงข่ายประสาทเทียมทางชีวภาพ - เครือข่ายของเซลล์ประสาทของสิ่งมีชีวิต

ANN คือระบบที่เชื่อมต่อและโต้ตอบกัน โปรเซสเซอร์ที่เรียบง่าย(เซลล์ประสาทเทียม)

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

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

• เดนไทรต์- รับผิดชอบในการรวบรวมสัญญาณที่เข้ามา
• โสม- รับผิดชอบในการประมวลผลหลักและการสรุปสัญญาณ
• แอกซอน- มีหน้าที่ในการส่งสัญญาณไปยังเดนไดรต์อื่น

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

เซลล์ประสาทชีวภาพเป็นระบบที่ซับซ้อน แบบจำลองทางคณิตศาสตร์ซึ่งยังสร้างไม่เสร็จทั้งหมด มีการแนะนำแบบจำลองหลายแบบ ซึ่งแตกต่างกันไปในความซับซ้อนในการคำนวณและความคล้ายคลึงกับเซลล์ประสาทจริง สิ่งที่สำคัญที่สุดอย่างหนึ่งคือเซลล์ประสาทที่เป็นทางการ (FN) แม้จะมีความเรียบง่ายของฟังก์ชันการทำงาน แต่เครือข่ายที่สร้างขึ้นจากเซลล์ประสาทดังกล่าวสามารถสร้างฟังก์ชันหลายมิติตามที่ต้องการได้ที่เอาต์พุต (ที่มา: Zaentsev I.V. โครงข่ายประสาทเทียม: โมเดลพื้นฐาน)

เซลล์ประสาทประกอบด้วยตัวบวกถ่วงน้ำหนักและองค์ประกอบที่ไม่เชิงเส้น การทำงานของเซลล์ประสาทถูกกำหนดโดยสูตร:

เซลล์ประสาทมีหลายอินพุต xและสัญญาณเอาท์พุตหนึ่งอัน ออก. พารามิเตอร์ของเซลล์ประสาทที่กำหนดการทำงานของมันคือ: เวกเตอร์ของน้ำหนัก ว, ระดับขีดจำกัด θ และประเภทของฟังก์ชันการเปิดใช้งาน เอฟ.

โครงข่ายประสาทเทียมดึงดูดความสนใจเนื่องจากความสามารถดังต่อไปนี้:

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

คุณสมบัติหลักของโครงข่ายประสาทเทียม ได้แก่ :

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

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

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

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

อัลกอริทึมสำหรับการแก้ปัญหาโดยใช้เพอร์เซปตรอนหลายชั้น(ที่มา: Zaentsev IV โครงข่ายประสาทเทียม: โมเดลพื้นฐาน)

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

อัลกอริธึมโซลูชันทั่วไป:

1. กำหนดความหมายที่ใส่เข้าไปในองค์ประกอบของเวกเตอร์อินพุต x. เวกเตอร์อินพุตจะต้องมีเงื่อนไขที่เป็นทางการของปัญหา เช่น ข้อมูลทั้งหมดที่จำเป็นในการรับคำตอบ
2. เลือกเวกเตอร์เอาท์พุต ยในลักษณะที่ส่วนประกอบต่างๆ มีคำตอบที่สมบูรณ์สำหรับงาน
3. เลือกประเภทของความไม่เชิงเส้นในเซลล์ประสาท (ฟังก์ชันการเปิดใช้งาน) ในกรณีนี้ขอแนะนำให้คำนึงถึงลักษณะเฉพาะของงานด้วยเพราะว่า ทางเลือกที่ดีจะช่วยลดเวลาการฝึกอบรม
4. เลือกจำนวนเลเยอร์และเซลล์ประสาทในเลเยอร์
5. กำหนดช่วงของการเปลี่ยนแปลงอินพุต เอาท์พุต น้ำหนัก และระดับเกณฑ์ โดยคำนึงถึงชุดค่าของฟังก์ชันการเปิดใช้งานที่เลือก
6. กำหนดค่าเริ่มต้นให้กับน้ำหนักและระดับเกณฑ์และ พารามิเตอร์เพิ่มเติม(เช่น ความชันของฟังก์ชันการเปิดใช้งาน หากมีการปรับระหว่างการฝึก) ค่าเริ่มต้นไม่ควรมีขนาดใหญ่เพื่อให้เซลล์ประสาทไม่อิ่มตัว (ในส่วนแนวนอนของฟังก์ชันการเปิดใช้งาน) มิฉะนั้นการเรียนรู้จะช้ามาก ค่าเริ่มต้นไม่ควรเล็กเกินไปเพื่อให้เอาต์พุตของเซลล์ประสาทส่วนใหญ่ไม่เท่ากับศูนย์ มิฉะนั้นการเรียนรู้ก็จะช้าลงเช่นกัน
7. ดำเนินการฝึกอบรมเช่น เลือกพารามิเตอร์เครือข่ายเพื่อแก้ไขปัญหา วิธีที่ดีที่สุด. เมื่อการฝึกอบรมเสร็จสิ้น เครือข่ายก็พร้อมที่จะแก้ไขปัญหาประเภทที่ได้รับการฝึกอบรม
8. ส่งเงื่อนไขปัญหาไปยังอินพุตเครือข่ายในรูปแบบของเวกเตอร์ x. คำนวณเวกเตอร์เอาท์พุต ยซึ่งจะให้แนวทางแก้ไขปัญหาอย่างเป็นทางการ

ปัญหาที่ต้องแก้ไข

แก้ไขปัญหาโดยใช้โครงข่ายประสาทเทียม ()

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

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

การประมาณฟังก์ชัน. สมมติว่ามีตัวอย่างการฝึก ((x1,y1), (x2,y2)..., (xn,yn)) (คู่ข้อมูลอินพุต-เอาต์พุต) ที่สร้างขึ้นโดยฟังก์ชันที่ไม่รู้จัก (x) ซึ่งเสียหายจากสัญญาณรบกวน ปัญหาการประมาณคือการหาค่าประมาณของฟังก์ชันที่ไม่รู้จัก (x) การประมาณฟังก์ชันเป็นสิ่งจำเป็นในการแก้ปัญหาการสร้างแบบจำลองทางวิศวกรรมและวิทยาศาสตร์มากมาย

การทำนาย/การพยากรณ์. ให้ตัวอย่างที่แยกกัน n (y(t1), y(t2)..., y(tn)) ได้รับในช่วงเวลาต่อเนื่องกัน t1, t2,..., tn ภารกิจคือการทำนายค่าของ y(tn+1) ในอนาคต tn+1 การคาดการณ์/การคาดการณ์มีผลกระทบอย่างมากต่อการตัดสินใจในด้านธุรกิจ วิทยาศาสตร์ และเทคโนโลยี การทำนายราคาหุ้นและการพยากรณ์อากาศเป็นการประยุกต์ใช้เทคนิคการทำนาย/พยากรณ์ทั่วไป

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

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

ควบคุม. ลองพิจารณาดู ระบบไดนามิกระบุโดยเซต (u(t), y(t)) โดยที่ u(t) คือการดำเนินการควบคุมอินพุต และ y(t) คือเอาต์พุตของระบบ ณ เวลา t ในระบบควบคุมด้วย โมเดลอ้างอิงเป้าหมายของการควบคุมคือการคำนวณการกระทำอินพุต u(t) เพื่อให้ระบบเป็นไปตามวิถีที่ต้องการซึ่งกำหนดโดยแบบจำลองอ้างอิง ตัวอย่างคือการควบคุมเครื่องยนต์อย่างเหมาะสมที่สุด

ประเภทของสถาปัตยกรรม

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

การจำแนกประเภทของโครงข่ายประสาทเทียมตามสถาปัตยกรรมแสดงในรูปด้านล่าง

การจำแนกประเภทที่คล้ายกัน แต่ขยายออกไปเล็กน้อย

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

ตารางเปรียบเทียบ การรับรู้หลายชั้นและ เครือข่าย RBF

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

ค่าของอนุพันธ์นั้นแสดงออกมาได้ง่าย ๆ ผ่านฟังก์ชันนั่นเอง การคำนวณอนุพันธ์ที่รวดเร็วช่วยให้การเรียนรู้เร็วขึ้น

เส้นโค้งเกาส์เซียน

ใช้ในกรณีที่การตอบสนองของเซลล์ประสาทควรสูงสุดสำหรับค่า NET เฉพาะบางค่า

โมดูล Python สำหรับโครงข่ายประสาทเทียม

ตัวอย่างง่ายๆ

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

# encoding=utf8 นำเข้าคลาสสุ่ม NN: def __init__(self, Threshold, size): """ ตั้งค่าพารามิเตอร์เริ่มต้น """ self.threshold = Threshold self.size = size self.init_weight() def init_weight(self) : """ เริ่มต้นเมทริกซ์น้ำหนักด้วยข้อมูลสุ่ม """ self.weights = [ for j in xrange(self.size)] def check(self, example): """ อ่านสัญญาณเอาท์พุตสำหรับภาพตัวอย่าง ถ้า vsum > self.threshold เราสามารถสรุปได้ว่าตัวอย่างมีรูปนกนางนวล """ vsum = 0 สำหรับ i ใน xrange(self.size): สำหรับ j ใน xrange(self.size): vsum += self .weights[i][j] * ตัวอย่าง[i][j] if vsum > self.threshold: return True else: return False def สอน(ตนเอง, ตัวอย่าง): """ การฝึกโครงข่ายประสาทเทียม """ สำหรับฉัน ใน xrange(self.size): สำหรับ j ใน xrange(self.size): self.weights[i][j] += ตัวอย่าง[i][j] nn = NN(20, 6) # ฝึกโครงข่ายประสาทเทียม tsample1 = [ , , , , , , ] nn.สอน(tsample1) tsample2 = [ , , , , , , , ] nn.สอน(tsample2) tsample3 = [ , , , , , , , ] nn.สอน(tsample3) tsample4 = [ , , , , , , , ] nn.teach(tsample4) # มาดูกันว่า Neural Network ทำอะไรได้บ้าง # มาส่งภาพนกนางนวลซึ่งใกล้เคียงกับภาพที่การรับรู้รู้กันดีกว่า wsample1 = [ , , , , , , ] พิมพ์ u"seagull" ถ้า nn.check(wsample1) มิฉะนั้น u"UFO" # ส่งภาพที่ไม่รู้จัก wsample2 = [ , , , , , , ] พิมพ์ u"seagull" if nn.check(wsample2) else u"UFO" # เราจะส่งภาพของนกนางนวลซึ่งมีความคล้ายคลึงกับภาพที่ Perceptron รู้จักโดยประมาณ wsample3 = [ , , , , , , ] พิมพ์ u"seagull" ถ้า nn.check(wsample3) อย่างอื่น u"UFO"