آموزش هوش مصنوعی با پایتون - شبکه‌های عصبی

شبکه‌های عصبی، دستگاه‌های محاسباتی موازی هستند که با هدف ایجاد یک مدل رایانه‌ای از مغز طراحی شده‌اند. هدف اصلی از این کار، توسعه سیستمی است که بتواند وظایف محاسباتی مختلف را سریع‌تر از سیستم‌های سنتی انجام دهد. این وظایف شامل تشخیص و طبقه‌بندی الگوها، تقریب، بهینه‌سازی و خوشه‌بندی داده‌ها هستند.

شبکه‌های عصبی مصنوعی (ANN) چیستند؟

شبکه عصبی مصنوعی (ANN) یک سیستم محاسباتی کارآمد است که ایده اصلی آن از شباهت میان این سیستم و شبکه‌های عصبی زیستی گرفته شده است. شبکه‌های عصبی مصنوعی با نام‌های دیگری مانند سیستم‌های عصبی مصنوعی، سیستم‌های پردازش توزیع‌شده موازی و سیستم‌های اتصال‌گرا نیز شناخته می‌شوند. شبکه عصبی مصنوعی از مجموعه بزرگی از واحدها تشکیل شده است که طبق الگویی مشخص به یکدیگر متصل شده‌اند تا امکان برقراری ارتباط میان آن‌ها فراهم شود. این واحدها که به آن‌ها گره‌ها یا نورون‌ها نیز گفته می‌شود، پردازشگرهای ساده‌ای هستند که به‌صورت موازی عمل می‌کنند.

هر نورون از طریق یک پیوند ارتباطی به نورون دیگری متصل می‌شود. هر پیوند ارتباطی دارای یک وزن است که اطلاعات مربوط به سیگنال ورودی را در خود نگه می‌دارد. این اطلاعات برای حل یک مسئله خاص توسط نورون‌ها بسیار مفید هستند؛ زیرا وزن معمولاً سیگنالی را که منتقل می‌شود تقویت یا مهار می‌کند. هر نورون دارای وضعیت داخلی خاصی است که سیگنال فعال‌سازی نامیده می‌شود. سیگنال‌های خروجی که پس از ترکیب سیگنال‌های ورودی و اعمال قانون فعال‌سازی تولید می‌شوند، ممکن است به واحدهای دیگر ارسال شوند.

اگر می‌خواهید شبکه‌های عصبی را به‌صورت دقیق مطالعه کنید، می‌توانید از طریق پیوند زیر به مطالعه آن بپردازید: شبکه عصبی مصنوعی.

نصب بسته‌های کاربردی

برای ایجاد شبکه‌های عصبی در پایتون، می‌توانیم از یک بسته قدرتمند مخصوص شبکه‌های عصبی به نام NeuroLab استفاده کنیم. این بسته، کتابخانه‌ای از الگوریتم‌های پایه شبکه‌های عصبی است که پیکربندی‌های انعطاف‌پذیر شبکه و الگوریتم‌های یادگیری را برای پایتون فراهم می‌کند. می‌توانید این بسته را با استفاده از دستور زیر در خط فرمان نصب کنید:

pip install NeuroLab

اگر از محیط آناکوندا استفاده می‌کنید، برای نصب NeuroLab از دستور زیر استفاده کنید:

conda install -c labfabulous neurolab

ساخت شبکه‌های عصبی

در این بخش، با استفاده از بسته NeuroLab چند شبکه عصبی را در پایتون ایجاد می‌کنیم.

طبقه‌بند مبتنی بر پرسپترون

پرسپترون‌ها اجزای سازنده شبکه‌های عصبی مصنوعی هستند. اگر می‌خواهید درباره پرسپترون اطلاعات بیشتری کسب کنید، می‌توانید از طریق پیوند زیر مطالعه کنید: شبکه عصبی مصنوعی

در ادامه، مراحل اجرای کد پایتون برای ساخت یک طبقه‌بند ساده مبتنی بر پرسپترون در شبکه عصبی را مشاهده می‌کنید:

بسته‌های موردنیاز را مطابق نمونه زیر وارد کنید:

import matplotlib.pyplot as plt
import neurolab as nl

مقادیر ورودی را وارد کنید. توجه داشته باشید که این مثال مربوط به یادگیری نظارت‌شده است؛ بنابراین باید مقادیر هدف را نیز مشخص کنید.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [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. ]])

اکنون این چهار ستون را به دو ستون داده و دو ستون برچسب تقسیم کنید:

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 یک شبکه عصبی با دو لایه پنهان بسازید. در لایه پنهان اول ده نورون، در لایه پنهان دوم شش نورون و در لایه خروجی یک نورون قرار دهید.

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()

در نتیجه اجرای دستورات بالا، می‌توانید نمودارهای زیر را مشاهده کنید: