ایجاد یک شبکه عصبی از ابتدا در پایتون

این اولین مقاله از سری مقالات است روی “ایجاد یک شبکه عصبی از ابتدا در پایتون”.

معرفی

آیا تا به حال فکر کرده اید که چگونه ربات های چت مانند سیری، الکسا و کورتانا می توانند به سوالات کاربران پاسخ دهند؟ یا اینکه چگونه خودروهای خودران قادر به رانندگی بدون کمک انسانی هستند؟ همه این محصولات فانتزی یک ویژگی مشترک دارند: هوش مصنوعی (AI). این هوش مصنوعی است که آنها را قادر می سازد تا چنین وظایفی را بدون نظارت یا کنترل توسط انسان انجام دهند. اما این سوال باقی می ماند: “هوش مصنوعی چیست؟” پاسخ ساده به این سوال این است: “هوش مصنوعی ترکیبی از الگوریتم های پیچیده از حوزه های مختلف ریاضی مانند جبر، حساب دیفرانسیل و انتگرال، و احتمال و آمار است.”

در این مقاله به بررسی یک شبکه عصبی مصنوعی ساده می پردازیم که یکی از عناصر اصلی سازنده هوش مصنوعی است. انواع مختلفی از یک شبکه عصبی مصنوعی وجود دارد که برای حل یک مشکل خاص اختصاص داده شده است. برای مثال شبکه های عصبی کانولوشنال معمولا برای مشکلات تشخیص تصویر در حالی که شبکه های عصبی مکرر برای حل مسائل توالی استفاده می شود.

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

مشکل

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

شخص	سیگار کشیدن	چاقی	ورزش	دیابتی
شخص 1	0	1	0	1
شخص 2	0	0	1	0
شخص 3	1	0	0	0
شخص 4	1	1	0	1
شخص 5	1	1	1	1

در جدول بالا پنج ستون داریم: فرد، سیگاری، چاقی، ورزش و دیابتی. در اینجا 1 به درست و 0 به نادرست اشاره دارد. به عنوان مثال، فرد اول مقادیر 0، 1، 0 دارد که به این معنی است که فرد سیگار نمی کشد، چاق است و ورزش نمی کند. فرد دیابتی نیز هست.

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

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

راه حل

ما یک شبکه عصبی بسیار ساده با یک لایه ورودی و یک لایه خروجی ایجاد خواهیم کرد. قبل از نوشتن هر کد واقعی، اجازه دهید ابتدا ببینیم که شبکه عصبی ما در تئوری چگونه اجرا خواهد شد.

نظریه شبکه عصبی

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

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

شبکه عصبی که می‌خواهیم ایجاد کنیم، نمایش بصری زیر را دارد.

یک شبکه عصبی در دو مرحله اجرا می شود: Feed Forward و Back Propagation. در مورد هر دوی این مراحل به تفصیل صحبت خواهیم کرد.

فید فوروارد

در بخش فید فوروارد یک شبکه عصبی، پیش‌بینی‌ها بر اساس انجام می‌شوند روی مقادیر در گره های ورودی و وزن ها. اگر به شبکه عصبی در شکل بالا نگاه کنید، می بینید که ما در مجموعه داده سه ویژگی داریم: سیگار کشیدن، چاقی و ورزش، بنابراین در لایه اول سه گره داریم که به آن لایه ورودی نیز می گویند. ما نام ویژگی های خود را با متغیر جایگزین کرده ایم x، برای کلیت در شکل بالا.

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

مراحل زیر در مرحله پیشخور شبکه عصبی اجرا می شود:

مرحله 1: (محاسبه حاصل ضرب نقطه بین ورودی ها و وزن ها)

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

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

از نظر ریاضی، در مرحله 1، محاسبه زیر را انجام می دهیم:

$$
XW = x1w1 + x2w2 + x3w3 + b
$$

مرحله 2: (نتیجه مرحله 1 را از طریق یک تابع فعال سازی منتقل کنید)

نتیجه مرحله 1 می تواند مجموعه ای از هر مقدار باشد. با این حال، در خروجی ما مقادیر به صورت 1 و 0 را داریم. ما می خواهیم خروجی ما در قالب یکسان باشد. برای انجام این کار ما نیاز به یک عملکرد فعال سازی، که مقادیر ورودی را بین 1 و 0 له می کند. یکی از این تابع های فعال سازی است سیگموئید تابع.

تابع سیگموئید وقتی ورودی 0 باشد 0.5 برمی گرداند. اگر ورودی یک عدد مثبت بزرگ باشد، مقداری نزدیک به 1 برمی گرداند. در صورت منفی بودن ورودی، تابع سیگموئید مقداری نزدیک به صفر خروجی می دهد.

از نظر ریاضی، تابع سیگموئید را می توان به صورت زیر نشان داد:

$$
\theta_{XW} = \frac{\mathrm{1} }{\mathrm{1} + e^{-XW} }
$$

بیایید سعی کنیم تابع سیگموئید را رسم کنیم:

input = np.linspace(-10, 10, 100)

def sigmoid(x):
    return 1/(1+np.exp(-x))

from matplotlib import pyplot as plt
plt.plot(input, sigmoid(input), c="r")

در اسکریپت بالا، ابتدا به صورت تصادفی 100 نقطه با فاصله خطی بین -10 و 10 ایجاد می کنیم. برای انجام این کار، از linspace روش از کتابخانه NumPy. در مرحله بعد، ما را تعریف می کنیم sigmoid تابع. در نهایت از matplotlib کتابخانه برای رسم مقادیر ورودی در برابر مقادیر بازگردانده شده توسط sigmoid تابع. خروجی به شکل زیر است:

می بینید که اگر ورودی یک عدد منفی باشد، خروجی نزدیک به صفر است، در غیر این صورت اگر ورودی مثبت باشد خروجی نزدیک به 1 است. با این حال، خروجی همیشه بین 0 و 1 است. این همان چیزی است که ما می خواهیم.

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

انتشار پشت

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

اصل کار یک شبکه عصبی ساده است. ما با اجازه دادن به شبکه پیش‌بینی تصادفی در مورد خروجی شروع می‌کنیم. سپس خروجی پیش بینی شده شبکه عصبی را با خروجی واقعی مقایسه می کنیم. در مرحله بعد، وزن‌ها و سوگیری‌های خود را به‌گونه‌ای تنظیم می‌کنیم که خروجی پیش‌بینی‌شده ما به خروجی واقعی نزدیک‌تر شود، که اساساً به عنوان “آموزش شبکه عصبی” شناخته می‌شود.

در قسمت back propagation الگوریتم خود را آموزش می دهیم. بیایید نگاهی به مراحل مربوط به بخش انتشار پس بیاندازیم.

مرحله 1: (محاسبه هزینه)

اولین قدم در بخش انتشار برگشتی، یافتن «هزینه» پیش‌بینی‌ها است. هزینه پیش بینی را می توان به سادگی با یافتن تفاوت بین خروجی پیش بینی شده و خروجی واقعی محاسبه کرد. هر چه این تفاوت بیشتر باشد، هزینه آن بیشتر خواهد بود.

چندین راه دیگر برای یافتن هزینه وجود دارد، اما ما از آن استفاده خواهیم کرد خطای میانگین مربعات تابع هزینه. تابع هزینه به سادگی تابعی است که هزینه پیش بینی های داده شده را پیدا می کند.

تابع هزینه میانگین مربعات خطا را می توان به صورت ریاضی به صورت زیر نشان داد:

$$
MSE =
\frac{\mathrm{1} }{\mathrm{n}}
\sum\nlimits_{i=1}^{n}
(پیش بینی شده – مشاهده شده)^{2}
$$

اینجا n تعداد مشاهدات است.

مرحله 2: (به حداقل رساندن هزینه)

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

برای به حداقل رساندن هزینه، باید مقادیر وزن و بایاس را پیدا کنیم که تابع هزینه کمترین مقدار ممکن را برمی گرداند. هرچه هزینه کمتر باشد، پیش‌بینی‌های ما صحیح‌تر است.

این یک مشکل بهینه سازی جایی که باید پیدا کنیم حداقل عملکرد.

برای یافتن مینیمم یک تابع، می توانیم از عبارت استفاده کنیم شیب مناسب الگوریتم الگوریتم نزول گرادیان را می توان به صورت ریاضی به صورت زیر نشان داد:

$$ تکرار \ تا \ همگرایی: \begin{Bmatrix} w_j := w_j – \alpha \frac{\partial }{\partial w_j} J(w_0,w_1 ……. w_n) \end{Bmatrix} …………. (1) $$

اینجا در معادله بالا، J تابع هزینه است. اساساً آنچه معادله فوق می گوید این است: مشتق جزئی تابع هزینه را با توجه به هر وزن و بایاس پیدا کنید و نتیجه را از مقادیر وزن موجود کم کنید تا مقادیر وزنی جدید بدست آورید.

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

از سوی دیگر، اگر با افزایش وزن، بهای تمام شده کاهش یابد، یک مقدار منفی برمی گردد که از منفی به منفی مثبت، به وزن موجود اضافه می شود.

در معادله 1 می بینیم که یک نماد آلفا وجود دارد که در گرادیان ضرب می شود. به این میزان یادگیری می گویند. نرخ یادگیری سرعت یادگیری الگوریتم ما را مشخص می کند. برای جزئیات بیشتر در مورد چگونگی تعریف نرخ یادگیری، بررسی کنید این مقاله .

ما باید اجرای معادله 1 را برای تمام وزن ها و بایاس ها تکرار کنیم تا زمانی که هزینه به سطح مطلوب به حداقل برسد. به عبارت دیگر، ما باید به اجرای معادله 1 ادامه دهیم تا زمانی که چنین مقادیری را برای بایاس و وزن به دست آوریم، که برای آنها تابع هزینه مقداری نزدیک به صفر برمی گرداند.

و تقریباً همین است. اکنون زمان اجرای آنچه تاکنون مطالعه کرده ایم است. ما یک شبکه عصبی ساده با یک لایه ورودی و یک خروجی در پایتون ایجاد خواهیم کرد.

پیاده سازی شبکه عصبی در پایتون

بیایید ابتدا مجموعه ویژگی های خود و برچسب های مربوطه را ایجاد کنیم. اسکریپت زیر را اجرا کنید:

import numpy as np
feature_set = np.array(((0,1,0),(0,0,1),(1,0,0),(1,1,0),(1,1,1)))
labels = np.array(((1,0,0,1,1)))
labels = labels.reshape(5,1)

در اسکریپت بالا مجموعه ویژگی های خود را ایجاد می کنیم. این شامل پنج رکورد است. به طور مشابه، ما یک را ایجاد کردیم labels مجموعه ای که حاوی برچسب های مربوط به هر رکورد در مجموعه ویژگی است. برچسب ها پاسخ هایی هستند که ما سعی داریم با شبکه عصبی پیش بینی کنیم.

گام بعدی این است که پارامترهای هایپر را برای شبکه عصبی خود تعریف کنیم. برای این کار اسکریپت زیر را اجرا کنید:

np.random.seed(42)
weights = np.random.rand(3,1)
bias = np.random.rand(1)
lr = 0.05

در اسکریپت بالا ما از random.seed به طوری که هر زمان که اسکریپت اجرا می شود می توانیم همان مقادیر تصادفی را بدست آوریم.

در مرحله بعد، وزن های خود را با اعداد تصادفی توزیع شده اولیه مقداردهی می کنیم. از آنجایی که سه ویژگی در ورودی داریم، بردار سه وزن داریم. سپس مقدار بایاس را با یک عدد تصادفی دیگر مقدار دهی اولیه می کنیم. در نهایت نرخ یادگیری را 0.05 قرار دادیم.

در مرحله بعد، باید تابع فعال سازی و مشتق آن را تعریف کنیم (در یک لحظه توضیح خواهم داد که چرا باید مشتق فعال سازی را پیدا کنیم). تابع فعال سازی ما تابع سیگموئید است که قبلا به آن پرداختیم.

اسکریپت پایتون زیر این تابع را ایجاد می کند:

def sigmoid(x):
    return 1/(1+np.exp(-x))

و روشی که مشتق تابع سیگموئید را محاسبه می کند به صورت زیر تعریف می شود:

def sigmoid_der(x):
    return sigmoid(x)*(1-sigmoid(x))

مشتق تابع سیگموئید به سادگی است sigmoid(x) * sigmoid(1-x).

اکنون ما آماده ایم شبکه عصبی خود را آموزش دهیم که قادر به پیش بینی چاق بودن یا نبودن یک فرد باشد.

به اسکریپت زیر نگاه کنید:

for epoch in range(20000):
    inputs = feature_set

    
    XW = np.dot(feature_set, weights) + bias

    
    z = sigmoid(XW)


    
    error = z - labels

    print(error.sum())

    
    dcost_dpred = error
    dpred_dz = sigmoid_der(z)

    z_delta = dcost_dpred * dpred_dz

    inputs = feature_set.T
    weights -= lr * np.dot(inputs, z_delta)

    for num in z_delta:
        bias -= lr * num

از این کد نترسید. خط به خط توضیح می دهم.

در مرحله اول تعداد دوره ها را تعریف می کنیم. یک دوره اساساً تعداد دفعاتی است که می خواهیم الگوریتم را آموزش دهیم روی داده های ما ما الگوریتم را آموزش خواهیم داد روی داده های ما 20000 بار من این عدد را آزمایش کردم و متوجه شدم که خطا پس از 20000 تکرار تقریباً به حداقل می رسد. می توانید با شماره دیگری امتحان کنید. هدف نهایی به حداقل رساندن خطا است.

سپس مقادیر را از the ذخیره می کنیم feature_set به input متغیر. سپس خط زیر را اجرا می کنیم:

XW = np.dot(feature_set, weights) + bias

در اینجا حاصل ضرب نقطه ورودی و بردار وزن را پیدا کرده و بایاس را به آن اضافه می کنیم. این مرحله 1 از بخش فید فوروارد است.

در این خط:

z = sigmoid(XW)

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

اکنون زمان شروع مجدد انتشار است. متغیر z شامل خروجی های پیش بینی شده است. اولین مرحله از انتشار به عقب، یافتن خطا است. ما این کار را در خط زیر انجام می دهیم:

error = z - labels

سپس ما print خطا روی صفحه نمایش

اکنون زمان اجرای مرحله 2 پس انتشار است که اصل این کد است.

ما می دانیم که تابع هزینه ما این است:

$$
MSE = \frac{\mathrm{1} }{\mathrm{n}} \sum\nolimits_{i=1}^{n} (پیش‌بینی شده – مشاهده شده)^{2}
$$

ما باید این تابع را با توجه به هر وزن متمایز کنیم. ما استفاده خواهیم کرد قانون زنجیره ای تمایز به این منظور. فرض کنید “d_cost” مشتق تابع هزینه ما با توجه به وزن “w” باشد، می توانیم از قانون زنجیره ای برای یافتن این مشتق استفاده کنیم، همانطور که در زیر نشان داده شده است:

$$ \frac {d\_cost}{dw} = \frac {d\_cost}{d\_pred} \, \frac {d\_pred}{dz}, \frac {dz}{dw} $$

اینجا،

$$ \frac {d\_cost}{d\_pred} $$

را می توان به صورت زیر محاسبه کرد:

$$ 2 (پیش بینی شده – مشاهده شده) $$

در اینجا، 2 ثابت است و بنابراین می توان آن را نادیده گرفت. این اساساً خطایی است که قبلاً محاسبه کرده ایم. در کد، می توانید خط زیر را مشاهده کنید:

dcost_dpred = error 

بعد باید پیدا کنیم:

$$ \frac {d\_pred}{dz} $$

در اینجا “d_pred” به سادگی تابع سیگموئید است و ما آن را با توجه به محصول نقطه ورودی “z” متمایز کرده ایم. در اسکریپت اینطور تعریف می شود:

dpred_dz = sigmoid_der(z) 

در نهایت باید پیدا کنیم:

$$ \frac {d\_z}{dw} $$

ما آن را میدانیم:

$$ z = x1w1 + x2w2 + x3w3 + b $$

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

slope = input x dcost_dpred x dpred_dz

به سه خط زیر توجه کنید:

z_delta = dcost_dpred * dpred_dz
inputs = feature_set.T
weights -= lr * np.dot(inputs, z_delta)

در اینجا ما آن را داریم z_delta متغیر، که شامل حاصل ضرب dcost_dpred و dpred_dz . به جای حلقه زدن از طریق هر رکورد و ضرب کردن ورودی در مربوطه z_delta، ماتریس ویژگی ورودی را جابجا می کنیم و آن را در ضرب می کنیم z_delta. در نهایت متغیر نرخ یادگیری را ضرب می کنیم lr با مشتق برای افزایش سرعت همگرایی.

سپس از طریق هر مقدار مشتق حلقه زدیم و مقادیر بایاس خود را به روز می کنیم، همچنین در این اسکریپت نشان داده شده است:

هنگامی که حلقه شروع می شود، خواهید دید که خطای کل شروع به کاهش می کند مانند شکل زیر:

0.001700995120272485
0.001700910187124885
0.0017008252625468727
0.0017007403465365955
0.00170065543909367
0.0017005705402162556
0.0017004856499031988
0.0017004007681529695
0.0017003158949647542
0.0017002310303364868
0.0017001461742678046
0.0017000613267565308
0.0016999764878018585
0.0016998916574025129
0.00169980683555691
0.0016997220222637836
0.0016996372175222992
0.0016995524213307602
0.0016994676336875778
0.0016993828545920908
0.0016992980840424554
0.0016992133220379794
0.0016991285685766487
0.0016990438236577712
0.0016989590872797753
0.0016988743594415108
0.0016987896401412066
0.0016987049293782815

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

اکنون می‌توانید ارزش یک نمونه را پیش‌بینی کنید. بیایید فرض کنیم سابقه بیماری داریم که سیگار می کشد، چاق نیست و ورزش نمی کند. بیایید دریابیم که آیا او احتمالاً دیابتی است یا خیر. ویژگی ورودی به این صورت خواهد بود: (1،0،0).

اسکریپت زیر را اجرا کنید:

single_point = np.array((1,0,0))
result = sigmoid(np.dot(single_point, weights) + bias)
print(result)

در خروجی مشاهده خواهید کرد:

(0.00707584)

می توانید ببینید که فرد احتمالاً دیابتی نیست زیرا مقدار آن بسیار نزدیک به 0 از 1 است.

حالا بیایید فرد دیگری را که سیگار نمی کشد، چاق است و ورزش نمی کند، آزمایش کنیم. بردار ویژگی ورودی (0،1،0) خواهد بود. این اسکریپت را اجرا کنید:

single_point = np.array((0,1,0))
result = sigmoid(np.dot(single_point, weights) + bias)
print(result)

در خروجی مقدار زیر را مشاهده خواهید کرد:

(0.99837029)

می بینید که مقدار بسیار نزدیک به 1 است که به احتمال زیاد به دلیل چاقی فرد است.

منابع

آیا می خواهید درباره ایجاد شبکه های عصبی برای حل مشکلات پیچیده بیشتر بدانید؟ اگر چنین است، سعی کنید منابع دیگری مانند این دوره آنلاین را بررسی کنید:

یادگیری عمیق AZ: شبکه های عصبی مصنوعی دستی

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

نتیجه

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

شبکه های عصبی مصنوعی واقعی بسیار پیچیده تر، قدرتمندتر هستند و از چندین لایه پنهان و چندین گره در لایه پنهان تشکیل شده اند. چنین شبکه های عصبی قادر به شناسایی مرزهای تصمیم واقعی غیرخطی هستند. روش ایجاد یک شبکه عصبی چند لایه از ابتدا در پایتون را در مقاله آینده توضیح خواهم داد.