AI กับ Python - Neural Networks

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

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

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

เซลล์ประสาททุกเซลล์เชื่อมต่อกับเซลล์ประสาทอื่น ๆ ผ่านทาง connection link. ลิงค์เชื่อมต่อแต่ละลิงค์เกี่ยวข้องกับน้ำหนักที่มีข้อมูลเกี่ยวกับสัญญาณอินพุต นี่เป็นข้อมูลที่มีประโยชน์ที่สุดสำหรับเซลล์ประสาทในการแก้ปัญหาโดยเฉพาะเนื่องจากweightโดยปกติจะกระตุ้นหรือยับยั้งสัญญาณที่กำลังสื่อสาร เซลล์ประสาทแต่ละเซลล์มีสถานะภายในซึ่งเรียกว่าactivation signal. สัญญาณเอาท์พุตซึ่งเกิดขึ้นหลังจากรวมสัญญาณอินพุตและกฎการเปิดใช้งานอาจถูกส่งไปยังหน่วยอื่น

หากคุณต้องการที่จะศึกษาเครือข่ายประสาทในรายละเอียดแล้วคุณสามารถทำตามลิงค์ - โครงข่ายประสาทเทียม

การติดตั้งแพ็คเกจที่เป็นประโยชน์

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

pip install NeuroLab

หากคุณใช้สภาพแวดล้อม Anaconda ให้ใช้คำสั่งต่อไปนี้เพื่อติดตั้ง NeuroLab -

conda install -c labfabulous neurolab

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

ในส่วนนี้ให้เราสร้างเครือข่ายประสาทเทียมใน Python โดยใช้แพ็คเกจ NeuroLab

ตัวจำแนกตาม Perceptron

Perceptrons เป็นส่วนประกอบสำคัญของ ANN หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับ Perceptron คุณสามารถไปที่ลิงค์ - artificial_neural_network

ต่อไปนี้คือการดำเนินการตามขั้นตอนของรหัส Python สำหรับการสร้างตัวจำแนกตาม Perceptron ของเครือข่ายประสาทเทียม -

นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -

import matplotlib.pyplot as plt
import neurolab as nl

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

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

สร้างเครือข่ายด้วย 2 อินพุตและ 1 เซลล์ประสาท -

net = nl.net.newp([[0, 1],[0, 1]], 1)

ตอนนี้ฝึกเครือข่าย ที่นี่เราใช้กฎเดลต้าในการฝึกอบรม

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

ตอนนี้ให้เห็นภาพผลลัพธ์และพล็อตกราฟ -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

คุณสามารถดูกราฟต่อไปนี้แสดงความคืบหน้าของการฝึกโดยใช้เมตริกข้อผิดพลาด -

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

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

นำเข้าแพ็คเกจที่มีประโยชน์ดังที่แสดง -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

โหลดชุดข้อมูลดังนี้ -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

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

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

ตอนนี้แยกสี่คอลัมน์ออกเป็น 2 คอลัมน์ข้อมูลและ 2 ป้ายกำกับ -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

พล็อตข้อมูลอินพุตโดยใช้คำสั่งต่อไปนี้ -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

ตอนนี้กำหนดค่าต่ำสุดและสูงสุดสำหรับแต่ละมิติดังที่แสดงไว้ที่นี่ -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

จากนั้นกำหนดจำนวนเซลล์ประสาทในชั้นผลลัพธ์ดังนี้ -

nn_output_layer = labels.shape[1]

ตอนนี้กำหนดเครือข่ายประสาทชั้นเดียว -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

ฝึกโครงข่ายใยประสาทด้วยจำนวนยุคและอัตราการเรียนรู้ดังที่แสดง -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

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

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

ตอนนี้ใช้จุดข้อมูลทดสอบในลักษณนามด้านบน -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

คุณสามารถดูผลการทดสอบดังที่แสดงไว้ที่นี่ -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

คุณสามารถดูกราฟต่อไปนี้เป็นผลลัพธ์ของโค้ดที่กล่าวถึงจนถึงตอนนี้ -

เครือข่ายประสาทหลายชั้น

ในตัวอย่างนี้เรากำลังสร้างเครือข่ายประสาทเทียมแบบหลายชั้นที่ประกอบด้วยเลเยอร์มากกว่าหนึ่งชั้นเพื่อดึงรูปแบบพื้นฐานในข้อมูลการฝึกอบรม เครือข่ายประสาทหลายชั้นนี้จะทำงานเหมือนรีเครสเซอร์ เราจะสร้างจุดข้อมูลตามสมการ: y = 2x ² +8

นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

สร้างจุดข้อมูลตามสมการที่กล่าวถึงข้างต้น -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

ตอนนี้จัดรูปแบบชุดข้อมูลนี้ใหม่ดังนี้ -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

แสดงภาพและพล็อตชุดข้อมูลอินพุตโดยใช้คำสั่งต่อไปนี้ -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

ตอนนี้สร้างเครือข่ายประสาทที่มีสองชั้นที่ซ่อนอยู่ด้วย neurolab ด้วย ten เซลล์ประสาทในชั้นแรกที่ซ่อนอยู่ six ในเลเยอร์ที่ซ่อนอยู่ที่สองและ one ในเลเยอร์เอาต์พุต

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

ตอนนี้ใช้อัลกอริธึมการฝึกไล่ระดับสี -

neural_net.trainf = nl.train.train_gd

ตอนนี้ฝึกอบรมเครือข่ายโดยมีเป้าหมายในการเรียนรู้จากข้อมูลที่สร้างขึ้นด้านบน -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

ตอนนี้เรียกใช้เครือข่ายประสาทบนจุดข้อมูลการฝึกอบรม -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

ตอนนี้งานพล็อตและการสร้างภาพ -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

ตอนนี้เราจะวางแผนผลลัพธ์จริงกับผลลัพธ์ที่คาดการณ์ไว้ -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

จากคำสั่งข้างต้นคุณสามารถสังเกตกราฟดังที่แสดงด้านล่าง -