نیورل نیٹ ورکس کی وضاحت: نیورل نیٹ ورکس کیا ہیں اور انہیں ازگر میں کیسے بنایا جائے؟

کیا آپ نے کبھی سوچا ہے کہ کمپیوٹر کس طرح ہاتھ سے لکھے ہوئے نمبروں کو پہچان سکتے ہیں، یہ پیش گوئی کر سکتے ہیں کہ آیا کوئی ای میل سپیم ہے، ویڈیوز تجویز کر سکتے ہیں، یا جملوں کو سمجھ سکتے ہیں؟

بہت سے جدید AI نظام اعصابی نیٹ ورک.

اب نام اس کی آواز کو اس سے کہیں زیادہ پیچیدہ بنا سکتا ہے۔ آپ سوچ سکتے ہیں کہ اسے بنانے کے لیے ایڈوانس کیلکولس، ایک بہت بڑا کمپیوٹر، اور کوڈ کی ہزاروں لائنوں کی ضرورت ہوگی۔

تم ایسے نہیں ہو۔

سب سے بنیادی سطح پر، نیورل نیٹ ورک ایک ریاضیاتی ماڈل ہے جو کچھ نمبروں کو بطور ان پٹ لیتا ہے، ان نمبروں پر حساب لگاتا ہے، پیشین گوئی کرتا ہے، جانچتا ہے کہ وہ پیشین گوئی درست جواب سے کتنی دور ہے، اور پھر اگلی بار تھوڑا بہتر نتیجہ حاصل کرنے کے لیے خود کو ایڈجسٹ کرتا ہے۔

اس ٹیوٹوریل میں، ہم Python اور NumPy کا استعمال کرتے ہوئے اسے خود بنائیں گے۔

یہاں ہم کیا احاطہ کریں گے:

آئیے ایک مصنوعی نیوران سے شروع کریں اور پھر آہستہ آہستہ ایک مکمل نیورل نیٹ ورک بنائیں۔ آخر تک، آپ سمجھ جائیں گے کہ وزن اور تعصب کیا ہیں، ایکٹیویشن کا فنکشن کیا ہے، نیٹ ورک غلطیوں سے کیسے سیکھتا ہے، بیک پروپیگیشن اور گراڈینٹ ڈیسنٹ کا اصل مطلب کیا ہے، اور یہ تمام ٹکڑے ایک ساتھ کیسے فٹ ہوتے ہیں۔

ساتھ چلنے کے لیے آپ کو جدید مشین لرننگ جاننے کی ضرورت نہیں ہے۔ کچھ بنیادی ازگر اور الجبرا مددگار ثابت ہوں گے۔ لیکن میں اس اہم ریاضی کی وضاحت کروں گا جب ہم آگے بڑھیں گے۔

1. نیورل نیٹ ورک کیا ہے؟

آئیے ایک سادہ مثال کے ساتھ شروع کرتے ہیں۔

تصور کریں کہ آپ کمپیوٹر چاہتے ہیں کہ یہ پیش گوئی کرے کہ آیا کوئی طالب علم امتحان پاس کرے گا۔

ہم آپ کے کمپیوٹر کو درج ذیل معلومات فراہم کر سکتے ہیں:

• جس وقت طالب علم پڑھتا تھا۔

• مکمل ہونے والی مشقوں کی تعداد

• پچھلے ٹیسٹ سکور

مثال کے طور پر:

Study Hours = 5 Practice Questions = 80 Previous Score = 82

آپ یہ بھی جان سکتے ہیں کہ طالب علم واقعی پاس ہوا یا نہیں۔

Passed = 1

اس طرح کی بہت سی مثالیں دیکھنے کے بعد، آپ چاہتے ہیں کہ کمپیوٹر پیٹرن سیکھے۔

شاید جو طلباء زیادہ پڑھتے ہیں وہ بہتر گریڈ حاصل کرتے ہیں۔ ہوسکتا ہے کہ آپ کے پچھلے ٹیسٹ کے اسکور کارآمد ہوں۔ مشق کے مسائل بھی مددگار ثابت ہوسکتے ہیں۔

ان تمام اصولوں کو خود لکھنے کے بجائے، آپ نیورل نیٹ ورک کی مثالیں دے سکتے ہیں اور اسے تعلقات سیکھنے دیں۔

بنیادی خیال یہ ہے:

پیشن گوئی ہو سکتی ہے: 0.92

اگر آپ گزرنے کے امکان کی پیشن گوئی کرتے ہیں، تو اسے گزرنے کے تقریباً 92% امکان سے تعبیر کیا جا سکتا ہے۔

اہم بات یہ ہے کہ ہم نے نیٹ ورک کو نہیں بتایا…

"مطالعہ کا وقت اہم ہے، اور پچھلے درجات کچھ زیادہ اہم ہیں۔”

اس کے بجائے، نیٹ ورک اس طرح نمبر سیکھتا ہے: وزن اس بات کا تعین کریں کہ کتنے مختلف ان پٹ پیشین گوئی کو متاثر کرتے ہیں۔

2. انہیں نیورل نیٹ ورک کیوں کہا جاتا ہے؟

یہ نام حیاتیاتی دماغ سے آیا ہے۔

آپ کے دماغ میں ایسے نیوران ہوتے ہیں جو سگنل وصول کرتے ہیں، معلومات پر کارروائی کرتے ہیں اور دوسرے نیوران تک سگنل منتقل کرتے ہیں۔

مصنوعی اعصابی نیٹ ورک مصنوعی دماغ نہیں۔. وہ حیاتیاتی نیوران کی طرح بالکل کام نہیں کرتے۔ تاہم، یہ نام بہت سے سادہ پروسیسنگ یونٹس کو جوڑنے کے عمومی خیال سے متاثر ہے۔

ایک انتہائی آسان مصنوعی نیوران اس طرح نظر آئے گا:

ایک نیوران ایک نمبر حاصل کرتا ہے، کچھ ریاضیاتی عمل کرتا ہے، اور دوسرا نمبر پیدا کرتا ہے۔

ان میں سے بہت سے مصنوعی نیوران کو جوڑ کر ایک نیورل نیٹ ورک بنتا ہے۔

3. نیورل نیٹ ورک کے تین اہم حصے

ایک سادہ اعصابی نیٹ ورک کو تین قسم کی تہوں میں تقسیم کیا جا سکتا ہے۔

1. ان پٹ پرت

2. پوشیدہ پرت

3. آؤٹ پٹ پرت

آئیے ہر ایک پر ایک نظر ڈالیں۔

ان پٹ پرت

ان پٹ پرت میں وہ معلومات ہوتی ہے جو ہم نیٹ ورک کو فراہم کرتے ہیں۔

طالب علم کی مثال میں، تین ان پٹ ہو سکتے ہیں:

Input 1 = Study Hours
Input 2 = Practice Questions
Input 3 = Previous Score

تو ایک طالب علم کا ان پٹ یہ ہوگا:

[5, 80, 82]

نیٹ ورک ضروری طور پر یہ نہیں سمجھتا ہے کہ ان نمبروں کا مطلب ہے "مطالعہ کے اوقات” یا "ٹیسٹ سکور”۔ نیٹ ورک کے ریاضیاتی حصے کے لیے، یہ صرف اعداد ہیں۔

یاد رکھنے کے لیے یہاں کچھ اہم خیالات ہیں:

عصبی نیٹ ورک نمبروں کے ساتھ کام کرتے ہیں۔

تصاویر، متن، آڈیو، اور دیگر معلومات کو بالآخر اعداد کے طور پر پیش کرنے کی ضرورت ہوتی ہے اس سے پہلے کہ اعصابی نیٹ ورک ان پر کارروائی کر سکے۔

پوشیدہ پرت

ان پٹ پرت کے بعد ایک پوشیدہ پرت آتی ہے۔

نیٹ ورکس ہیں:

پوشیدہ پرت میں نیوران ہوتے ہیں جو ان پٹ پر حساب کتاب کرتے ہیں۔

نیٹ ورک میں ایک پوشیدہ پرت یا متعدد پوشیدہ پرتیں ہوسکتی ہیں۔

جب ایک نیٹ ورک کی متعدد پرتیں ہوتی ہیں، تو ہم اکثر گہرے اعصابی نیٹ ورک.

آؤٹ پٹ پرت

آؤٹ پٹ پرت حتمی نتیجہ پیدا کرتی ہے۔

سادہ ہاں/نہیں سوالات کے لیے، جواب کا اظہار اس طرح کیا جا سکتا ہے:

0 = No
1 = Yes

مثال کے طور پر:

0.12 → probably No
0.91 → probably Yes

ایک سے زیادہ زمروں کے مسائل کے لیے، آؤٹ پٹ میں متعدد نمبرز شامل ہو سکتے ہیں۔

Cat  = 0.05
Dog  = 0.90
Bird = 0.05

سب سے بڑی قدر "کتے” کے ساتھ منسلک ہے، لہذا ماڈل کتے کی پیشن گوئی کرتا ہے.

4. نیوران کیا ہے؟

اب آئیے ایک نیوران پر زوم ان کریں۔

فرض کریں کہ ایک نیوران تین ان پٹ حاصل کرتا ہے۔

x₁
x₂
x₃

ہر ان پٹ میں ایک متعلقہ ہے۔ وزن:

w₁
w₂
w₃

نیوران ہر ان پٹ کو اس کے وزن سے ضرب دیتا ہے اور نتائج کو شامل کرتا ہے۔

بھی تعصب.

مساوات یہ ہے:

z = x₁w₁ + x₂w₂ + x₃w₃ + b

اگر یہ مساوات خوفزدہ نظر آتی ہے، تو فکر نہ کریں۔

بنیادی طور پر:

input × weight
+
input × weight
+
input × weight
+
bias

آئیے حقیقی نمبر استعمال کریں۔

فرض کریں:

x₁ = 2
x₂ = 3
x₃ = 4

w₁ = 0.5
w₂ = 0.2
w₃ = 0.8

b = 1

پھر:

z = (2 × 0.5) + (3 × 0.2) + (4 × 0.8) + 1

ہر حصے کا حساب لگائیں۔

2 × 0.5 = 1.0
3 × 0.2 = 0.6
4 × 0.8 = 3.2

اب اسے شامل کریں۔

z = 1.0 + 0.6 + 3.2 + 1
z = 5.8

نیوران کی طرف سے تیار 5.8.

لیکن یہ ابھی ختم نہیں ہوا۔

5. وزن کیا ہے؟

وزن کنٹرول کرتا ہے کہ ان پٹ نیوران کو کتنی مضبوطی سے متاثر کرتا ہے۔

تصور کریں:

x = 5

اگر وزن ہے:

w = 2

پھر:

x × w = 5 × 2
      = 10

تاہم، اگر وزن ہے:

w = 0.1

پھر:

x × w = 5 × 0.1
      = 0.5

ایک ہی ان پٹ نے بہت مختلف نتائج پیدا کیے کیونکہ وزن تبدیل کر دیا گیا تھا۔

وزن کو ایک والیوم نوب کے طور پر سوچیں۔

بڑے مثبت وزن ان پٹ کو مضبوط مثبت اثر بناتے ہیں۔ اگر وزن 0 کے قریب ہے، تو ان پٹ پر بہت کم اثر پڑے گا۔ منفی وزن نتائج کو مخالف سمت میں دھکیل سکتا ہے۔

نیٹ ورک تربیت کے دوران یہ وزن سیکھتا ہے۔

6. تعصب کیا ہے؟

تعصب ایک اور نمبر ہے جو نیوران کے حساب میں شامل ہوتا ہے۔

تعصب کے بغیر ہمیں درج ذیل نتائج حاصل ہوں گے:

z = x₁w₁ + x₂w₂ + x₃w₃

تعصب کی صورت میں:

z = x₁w₁ + x₂w₂ + x₃w₃ + b

ایک اور نمبر کیوں شامل کریں؟ کیونکہ یہ نیوران کو زیادہ لچک دیتا ہے۔

اس کے بارے میں سوچیں جیسے نیوران کے حساب کے نقطہ آغاز کو ایڈجسٹ کرنا۔

نیٹ ورک تربیت کے دوران تعصبات اسی طرح سیکھتا ہے جس طرح یہ وزن سیکھتا ہے۔

تو جب آپ دیکھتے ہیں:

weights + bias

آپ کچھ پیرامیٹرز کو دیکھ رہے ہیں جو سیکھنے کے دوران نیورل نیٹ ورک تبدیل ہو سکتا ہے۔

7. ہمیں ایکٹیویشن فنکشن کی ضرورت کیوں ہے؟

اس مقام پر، نیوران وزنی رقم کا حساب لگا سکتا ہے۔

z = x₁w₁ + x₂w₂ + ... + b

تاہم، عصبی نیٹ ورکس کو سادہ وزنی رقم سے زیادہ پیچیدہ تعلقات سیکھنے چاہئیں۔

یہ وہیں ہے۔ ایکٹیویشن فنکشن براہ کرم اندر آئیں۔ ایکٹیویشن فنکشن نیوران کی کمپیوٹیڈ ویلیو لیتا ہے اور اسے تبدیل کرتا ہے۔

ایک عام ایکٹیویشن فنکشن ہے: دوبارہ شروع کریں. ReLU کا مطلب ہے: ترمیم شدہ لکیری آلہ.

مساوات یہ ہے:

ReLU(x) = max(0, x)

سیدھے الفاظ میں:

• اگر نمبر مثبت ہے تو اسے اسی طرح رکھیں۔

• اگر نمبر منفی ہے تو اسے 0 سے بدل دیں۔

مثال کے طور پر:

ReLU(-5) = 0
ReLU(-2) = 0
ReLU(0)  = 0
ReLU(3)  = 3
ReLU(10) = 10

ازگر میں:

def relu(x):
    return max(0, x)

NumPy arrays کے ساتھ آپ استعمال کر سکتے ہیں:

def relu(x):
    return np.maximum(0, x)

ایکٹیویشن کے افعال اہم ہیں کیونکہ یہ ملٹی لیئر نیورل نیٹ ورکس کو مزید پیچیدہ پیٹرن سیکھنے کی اجازت دیتے ہیں۔

8. ازگر میں اپنا پہلا نیوران بنانا

آئیے ریاضی کو Python میں تبدیل کریں۔

پہلے، NumPy درآمد کریں۔

import numpy as np

NumPy نمبرز، اری، ویکٹرز اور میٹرکس کے ساتھ کام کرنے کے لیے ٹولز فراہم کرتا ہے۔

اب آئیے ان پٹ بناتے ہیں۔

x = np.array([2, 3, 4])

یہ مندرجہ ذیل تین اقدار پر مشتمل ایک صف بناتا ہے:

[2, 3, 4]

اب ہم وزن بناتے ہیں۔

weights = np.array([0.5, 0.2, 0.8])

ہر ان پٹ کے لیے ایک وزن ہے۔

x₁ = 2    w₁ = 0.5
x₂ = 3    w₂ = 0.2
x₃ = 4    w₃ = 0.8

اگلا ہم ایک تعصب بناتے ہیں۔

bias = 1

اب وزنی رقم کا حساب لگائیں۔

z = np.dot(x, weights) + bias

np.dot() پہلے بیان کردہ ضرب اور اضافے کی کارروائیوں کو انجام دیتا ہے۔

اس صورت میں:

np.dot(x, weights)

یہ مندرجہ ذیل ہے:

(2 × 0.5) + (3 × 0.2) + (4 × 0.8)

یہ درج ذیل ہے:

4.8

پھر ہم تعصب شامل کرتے ہیں۔

4.8 + 1 = 5.8

اب ReLU اپلائی کریں:

output = np.maximum(0, z)

سے z ہے 5.8ReLU اسے بغیر کسی تبدیلی کے چھوڑ دیتا ہے۔

output = 5.8

آخر میں:

print(output)

پرنٹس:

5.8

تو پورا نیوران ہے:

import numpy as np

x = np.array([2, 3, 4])
weights = np.array([0.5, 0.2, 0.8])
bias = 1

z = np.dot(x, weights) + bias
output = np.maximum(0, z)

print(output)

ہم نے ابھی ایک چھوٹا مصنوعی نیوران بنایا ہے۔

9. ایک نیوران سے ایک تہہ تک

سب سے زیادہ دلچسپ مسائل کے لئے، ایک نیوران کافی نہیں ہے.

اس کے بجائے، ہم متعدد نیوران کو ایک ساتھ جوڑ سکتے ہیں۔

مثال کے طور پر:

نیوران اکٹھے ہوتے ہیں۔ فرش.

ایک چھوٹا نیورل نیٹ ورک اس طرح نظر آئے گا:

Input Layer
     ↓
Hidden Layer
     ↓
Output Layer

ایک تہہ میں موجود کوئی بھی نیوران اپنی پیداوار اگلی تہہ میں موجود نیوران کو بھیج سکتا ہے۔

یہ وہ جگہ ہے جہاں اعصابی نیٹ ورک بہت زیادہ طاقتور بننا شروع کرتے ہیں۔

10. نیورل نیٹ ورک دراصل کیسے سیکھتے ہیں؟

اب تک ہم نے دستی طور پر وزن کا انتخاب کیا ہے۔

0.5
0.2
0.8

لیکن حقیقی عصبی نیٹ ورک صحیح وزن کو جاننے کے ساتھ شروع نہیں ہوتے ہیں۔

اس کے بجائے، ہم وزن کے ساتھ شروع کرتے ہیں جو عام طور پر چھوٹی بے ترتیب قدروں سے شروع ہوتے ہیں۔

اس کے بعد یہ مندرجہ ذیل سائیکل سے گزرتا ہے:

Make a prediction
       ↓
Compare prediction with correct answer
       ↓
Measure the error
       ↓
Figure out how to change the weights
       ↓
Update the weights
       ↓
Try again

یہ عمل بار بار ہوتا ہے، نیٹ ورک بتدریج اپنے پیرامیٹرز کو ایڈجسٹ کرتا ہے تاکہ تربیت کے ڈیٹا پر بہتر پیشین گوئیاں کی جاسکیں۔

آئیے ہر ایک حصے کو توڑتے ہیں۔

11. پیشین گوئیاں اور نقصانات

فرض کریں کہ صحیح جواب ہے:

1

لیکن ہمارے نیٹ ورک نے پیش گوئی کی ہے:

0.3

پیشن گوئی ہدف کے بہت قریب نہیں ہے۔

ہمیں یہ اندازہ لگانے کے لیے ایک طریقہ درکار ہے کہ یہ کتنا غلط ہے۔ وہ کیا ہے نقصان کی تقریب کرو

نقصان کا فنکشن پیشین گوئی اور درست جواب لیتا ہے اور ایک عدد تیار کرتا ہے جو ماڈل کی غلطی کو ظاہر کرتا ہے۔

ایک سادہ مثال کے طور پر ہم مربع ایرر استعمال کر سکتے ہیں۔

Loss = (prediction - actual)²

ہمارے نمبر استعمال کریں:

Loss = (0.3 - 1)²

پہلا:

0.3 - 1 = -0.7

پھر اسے مربع کریں۔

(-0.7)² = 0.49

تو:

Loss = 0.49

عام طور پر، چھوٹے نقصان کا مطلب ہے کہ آپ کی پیشین گوئی آپ کے ہدف کے قریب ہے۔

حقیقی عصبی نیٹ ورکس میں، مختلف مسائل مختلف نقصان کے افعال استعمال کرتے ہیں۔ بائنری کراس اینٹروپی عام طور پر بائنری درجہ بندی کے لیے استعمال ہوتی ہے۔

12. میلان کیا ہے؟

اب ہمیں ایک مسئلہ درپیش ہے۔

میں جانتا ہوں کہ میری پیشین گوئی غلط ہے، لیکن میں وزن کیسے تبدیل کروں؟

یہ جگہ میلان مفید ہو جاتا ہے۔ گریڈینٹ ہمیں بتاتا ہے کہ پیرامیٹر کو تبدیل کرنے سے نقصان کیسے متاثر ہوتا ہے۔

اسے ایک پہاڑی پر کھڑے ہونے کی طرح سوچیں۔ تصور کریں کہ آپ کا مقصد سب سے کم مقام تک پہنچنا ہے۔ اگر آپ جانتے ہیں کہ کونسی سمت اوپر کی طرف ڈھلوان ہے، تو آپ مخالف سمت میں جا سکتے ہیں اور نیچے کی طرف جا سکتے ہیں۔

اعصابی نیٹ ورک کی تربیت اسی طرح کے خیال پر کام کرتی ہے۔ ہم اپنا نقصان کم کرنا چاہتے ہیں۔ میلان اس بارے میں معلومات فراہم کرتا ہے کہ پیرامیٹر کو کس سمت منتقل ہونا چاہیے۔

13. تدریجی نزول کیا ہے؟

تدریجی نزول میلان کا استعمال کرتے ہوئے نیٹ ورک کے پیرامیٹرز کو ایڈجسٹ کرنے کا عمل۔

اپ ڈیٹ کا آسان اصول درج ذیل ہے:

new weight = old weight - learning rate × gradient

ازگر میں:

weight = weight - learning_rate * gradient

کہ سیکھنے کی شرح اپ ڈیٹ سائز کو کنٹرول کرتا ہے۔

مثال کے طور پر:

learning_rate = 0.01

اگر سیکھنے کی شرح بہت زیادہ ہے، تو نیٹ ورک بڑی تبدیلیاں کر سکتا ہے، ممکنہ طور پر کسی اچھے حل کا فیصلہ کرنے کے بجائے ادھر ادھر کود پڑتا ہے۔

اگر یہ بہت چھوٹا ہے تو سیکھنے میں کافی وقت لگ سکتا ہے۔

اس لیے تربیت میں پیرامیٹر اپ ڈیٹس تلاش کرنا شامل ہے جو ماڈل کو عمل کو غیر مستحکم کیے بغیر کم نقصان کی طرف لے جاتے ہیں۔

14. بیک پروپیگیشن کیا ہے؟

اب بھی ایک اہم سوال باقی ہے۔

اگر آپ کے عصبی نیٹ ورک میں ہزاروں یا لاکھوں وزن ہیں، تو آپ کیسے اندازہ لگا سکتے ہیں کہ کون سے وزن نے خرابی کو جنم دیا؟

یہ وہیں ہے۔ بیک پروپیگیشن بیک پروپیگیشن نیٹ ورک کے ذریعے پیچھے کی طرف کام کر کے پیرامیٹر کے میلان کا حساب لگاتا ہے۔

اس طرح کے نیٹ ورک کا تصور کریں:

Input
  ↓
Hidden Layer
  ↓
Output
  ↓
Loss

آگے بڑھنے کے دوران، معلومات مندرجہ ذیل طور پر منتقل ہوتی ہے:

Input → Hidden Layer → Output

بیک پروپیگیشن کے دوران، تدریجی معلومات کو پیچھے کی طرف منتقل کیا جاتا ہے۔

Loss → Output → Hidden Layer → Input

نیٹ ورک ان گریڈینٹس کا استعمال اس بات کا تعین کرنے کے لیے کرتا ہے کہ وزن اور تعصبات کو کس طرح تبدیل ہونا چاہیے۔

اصلی نیورل نیٹ ورک بناتے وقت، آپ عام طور پر ان تمام مشتقات کا حساب ہاتھ سے نہیں لگاتے ہیں۔ PyTorch جیسی لائبریریاں خود بخود اس کا حساب لگا سکتی ہیں۔

تاہم، بنیادی خیال کو سمجھنا ضروری ہے۔

بیک پروپیگیشن اس بات کا حساب لگاتا ہے کہ کس طرح پیرامیٹرز نے خرابی میں حصہ ڈالا، اور گریڈینٹ ڈیسنٹ اس معلومات کو پیرامیٹرز کو اپ ڈیٹ کرنے کے لیے استعمال کرتا ہے۔

15. مکمل سیکھنے کا چکر

اب ہم سب کچھ ایک ساتھ رکھ سکتے ہیں۔

مزید خاص طور پر:

Give the network data
          ↓
Calculate a prediction
          ↓
Compare it with the correct answer
          ↓
Calculate the loss
          ↓
Calculate gradients
          ↓
Update weights and biases
          ↓
Repeat

تربیتی ڈیٹا کے ذریعے اکثر ایک مکمل منتقلی ہوتی ہے۔ اوقات.

مثال کے طور پر:

Epoch 1 → Loss: 0.82
Epoch 2 → Loss: 0.61
Epoch 3 → Loss: 0.43
Epoch 4 → Loss: 0.29
Epoch 5 → Loss: 0.18

یہ تعداد صرف مثالیں ہیں، لیکن مثالی طور پر تربیت کی ترقی کے ساتھ ساتھ نقصان کم ہوتا جائے گا۔

16. آئیے شروع سے ایک نیورل نیٹ ورک بنائیں

مبارک ہو! اب آپ عصبی نیٹ ورکس کی بنیادی باتوں کو سمجھتے ہیں۔ اب ان خیالات کو ایک ساتھ رکھنے کا وقت آگیا ہے۔

ہم صرف اس کا استعمال کرتے ہوئے ایک چھوٹا نیورل نیٹ ورک بنائیں گے:

Python + NumPy

ہمارا نیٹ ورک مندرجہ ذیل کلاسک مشین لرننگ کے مسائل سیکھتا ہے: XOR.

XOR ایک منطقی آپریشن ہے جو دو ان پٹ لیتا ہے۔

قواعد درج ذیل ہیں:

0 XOR 0 → 0
0 XOR 1 → 1
1 XOR 0 → 1
1 XOR 1 → 0

اس کا مطلب ہے کہ آؤٹ پٹ ہے: 1 بالکل ان پٹ میں سے ایک ہے 1.

تو ہمارا تربیتی ڈیٹا یہ ہے:

X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

صحیح جواب ہے:

y = np.array([
    [0],
    [1],
    [1],
    [0]
])

ہم چاہتے ہیں کہ ہمارا نیورل نیٹ ورک اس طرز کو سیکھے۔

17. نیٹ ورک کے فن تعمیر کو سمجھیں۔

ہمارے نیٹ ورک میں شامل ہیں:

2 input neurons
       ↓
4 hidden neurons
       ↓
1 output neuron

دو ان پٹ ہر XOR مثال میں دو نمبروں کی نمائندگی کرتے ہیں۔

چار پوشیدہ نیوران نیٹ ورک کو XOR تعلقات کو سیکھنے کے لیے کافی لچک دیتے ہیں۔

آؤٹ پٹ نیوران ان کے درمیان ایک عدد پیدا کرتا ہے: 0 اور 1.

18. ڈیٹا کی ترتیبات

آئیے اپنا Python پروگرام شروع کرتے ہیں۔

import numpy as np

NumPy درآمد کریں۔ ہم ارے، میٹرکس ضرب، اور ریاضی کی کارروائیوں کے لیے NumPy استعمال کریں گے۔

اگلا:

X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

X چار تربیتی مثالیں شامل ہیں۔

ہر قطار ایک مثال ہے۔

[0, 0]
[0, 1]
[1, 0]
[1, 1]

اب صحیح جواب بنائیں۔

y = np.array([
    [0],
    [1],
    [1],
    [0]
])

پہلی قطار X پہلی صف سے مماثل ہے۔ y.

تو:

[0, 0] → 0
[0, 1] → 1
[1, 0] → 1
[1, 1] → 0

19. وزن اور تعصب پیدا کرنا

اب ہمیں نیٹ ورک کے پیرامیٹرز کی ضرورت ہے۔

پہلا:

np.random.seed(42)

یہ بے ترتیب نمبروں کو دوبارہ پیدا کرنے کے قابل بناتا ہے۔

اس لائن کے بغیر، جب بھی پروگرام چلایا جائے گا نیٹ ورک کو مختلف بے ترتیب ابتدائی وزن ملے گا۔

اب پہلی پرت کے لیے وزن بنائیں۔

W1 = np.random.randn(2, 4)

کیوں (2, 4)?

کیونکہ:

تو W1 ہمیں ہر ان پٹ کو ہر پوشیدہ نیوران سے جوڑنے والے وزن کی ضرورت ہے۔

ہیں:

2 × 4 = 8

وزن

اگلا:

b1 = np.zeros((1, 4))

یہ کل چار تعصبات پیدا کرتا ہے، ہر پوشیدہ نیوران کے لیے ایک۔

اب دوسری پرت:

W2 = np.random.randn(4, 1)

چونکہ 4 پوشیدہ نیوران اور 1 آؤٹ پٹ نیوران ہیں، ہمیں ضرورت ہے:

4 × 1 = 4

وزن

آخر میں:

b2 = np.zeros((1, 1))

یہ آؤٹ پٹ نیوران کو ایک تعصب فراہم کرتا ہے۔

تو ہمارے نیٹ ورک کے پیرامیٹرز ہیں:

W1 → input-to-hidden weights
b1 → hidden-layer biases

W2 → hidden-to-output weights
b2 → output-layer bias

20. سگمائیڈ فنکشن

ہمارا آؤٹ پٹ ایک امکان کی نمائندگی کرتا ہے، لہذا ہم چاہتے ہیں کہ یہ درمیان میں ہو۔ 0 اور 1.

ہم ہیں سگمائڈ فنکشن.

مساوات یہ ہے:

sigmoid(x) = 1 / (1 + e⁻ˣ)

ازگر میں:

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

آئیے دیکھتے ہیں کہ یہ کیا کرتا ہے:

sigmoid(-5) ≈ 0.007
sigmoid(0)  = 0.5
sigmoid(5)  ≈ 0.993

اس سے کوئی فرق نہیں پڑتا ہے کہ ان پٹ کتنا بڑا یا چھوٹا ہے، نتیجہ ان کے درمیان رہے گا: 0 اور 1.

یہ مفید ہے جب آؤٹ پٹ امکانات کی نمائندگی کرتا ہے۔

21. آگے پھیلانا

اب آپ نیٹ ورک پر ڈیٹا بھیج سکتے ہیں۔ اسے کہتے ہیں۔ آگے کی تبلیغ.

پہلے ہم چھپی ہوئی تہوں کا حساب لگاتے ہیں۔

z1 = X @ W1 + b1

یہاں ایک نئی علامت ہے۔

@

ازگر میں @ میٹرکس ضرب انجام دیتا ہے۔

آپ اس کے بارے میں سوچ سکتے ہیں کہ ایک ساتھ کئی وزنی رقمیں کرنا۔

ہر نیوران کو دستی طور پر گننے کے بجائے:

input × weight + input × weight + bias

NumPy ان سب کا ایک ساتھ حساب لگا سکتا ہے۔

نتائج درج ذیل جگہ پر محفوظ کیے گئے ہیں: z1.

اگلا:

a1 = np.tanh(z1)

یہاں ہم tanh چالو کرنے کی تقریب پوشیدہ پرتوں کے لیے۔

Tanh ان پٹ کو ایک قدر میں تبدیل کرتا ہے: -1 اور 1.

آپ یہاں tanh کیوں استعمال کرتے ہیں؟

اس کی وجہ یہ ہے کہ XOR ایسی چیز نہیں ہے جسے ایک سادہ لکیری حساب سے حل کیا جا سکے۔ نان لائنر ایکٹیویشن چھپی ہوئی تہوں میں پیٹرن سیکھنے کے لیے درکار لچک فراہم کرتی ہے۔

اب ہم آؤٹ پٹ لیئر کا حساب لگاتے ہیں۔

z2 = a1 @ W2 + b2

یہ پوشیدہ پرتوں کا آؤٹ پٹ لیتا ہے اور وزن کے دوسرے سیٹ کا استعمال کرتے ہوئے انہیں یکجا کرتا ہے۔

آخر میں:

a2 = sigmoid(z2)

اب a2 ہماری پیشین گوئیاں شامل ہیں۔

مثال کے طور پر، تربیت سے پہلے، نیٹ ورک درج ذیل نتائج پیدا کر سکتا ہے:

0.52
0.61
0.48
0.55

یہ پیشین گوئیاں ابھی کارآمد نہیں ہیں، لیکن متوقع ہیں۔ نیٹ ورک نے ابھی تک کچھ نہیں سیکھا ہے۔

22. نقصان کا حساب

اب ہمیں یہ اندازہ لگانے کی ضرورت ہے کہ یہ پیشین گوئیاں کتنی اچھی ہیں۔

بائنری درجہ بندی کے لیے، استعمال کریں: بائنری کراس اینٹروپییہ ایک نقصان کا فنکشن ہے جو بائنری درجہ بندی کے لیے مشین لرننگ میں استعمال ہوتا ہے۔ ایک ایسے ماڈل کی کارکردگی کی پیمائش کرتا ہے جس کا آؤٹ پٹ 0 اور 1 کے درمیان امکانی قدر ہے۔

فارمولا ہے:

Loss = -mean(
    y × log(prediction)
    +
    (1 - y) × log(1 - prediction)
)

یہ پچھلی مربع غلطی کی مثال کے مقابلے میں بہت زیادہ پیچیدہ لگتا ہے، لیکن آپ کو فارمولہ کو یاد کرنے کی ضرورت نہیں ہے۔

ازگر میں:

loss = -np.mean(
    y * np.log(a2 + 1e-8) +
    (1 - y) * np.log(1 - a2 + 1e-8)
)

کہ 1e-8 یہ بہت چھوٹی تعداد ہے۔

یہ مسائل کو روکتا ہے جب: a2 ناقابل یقین حد تک قریب ہونا 0 یا 1اس کی وجہ یہ ہے کہ بالکل 0 کا لوگارتھم لینا غلط ہے۔

تربیت کے ابتدائی مراحل میں، نقصانات نسبتاً زیادہ ہوں گے۔ لیکن جیسا کہ نیٹ ورک سیکھتا ہے، ہم چاہتے ہیں کہ یہ سکڑ جائے۔

23. کوڈ کا بیک پروپیگیشن

اب ہمارے پروگرام کا سب سے زیادہ ریاضیاتی حصہ آتا ہے۔

ہمیں ڈھلوان کا حساب لگانے کی ضرورت ہے۔

کے ساتھ شروع کریں:

dz2 = a2 - y

یہ سگمائیڈ + بائنری کراس اینٹروپی مجموعہ کے لیے آؤٹ پٹ لیئر کی پری ایکٹیویشن ویلیو کے لیے نقصان کا درجہ دیتا ہے۔

اگلا:

dW2 = (a1.T @ dz2) / len(X)

یہ ڈھلوان کا حساب لگائے گا۔ W2.

کہ .T اس کا مطلب ہے ٹرانسپوزیشن۔

ہماری پوشیدہ پرت کی پیداوار میں 4 نیوران ہیں۔ dz2 آؤٹ پٹ پرت میں خرابیوں کی نشاندہی کرتا ہے۔ میٹرکس ضرب ان کو جوڑ کر یہ تعین کرتی ہے کہ آؤٹ پٹ میں چھپا ہوا ہر وزن نقصان کو کیسے متاثر کرتا ہے۔

ہم مندرجہ ذیل تقسیم کرتے ہیں:

len(X)

اس کی وجہ یہ ہے کہ ہمارے پاس 4 تربیتی مثالیں ہیں اور ہم اوسط گریڈینٹ کا حساب لگا رہے ہیں۔

اب ہم آؤٹ پٹ بائیس ڈھلوان کا حساب لگاتے ہیں۔

db2 = np.mean(dz2, axis=0, keepdims=True)

یہ آؤٹ پٹ تعصب کی اوسط ڈھلوان کا حساب لگاتا ہے۔

اگلا:

da1 = dz2 @ W2.T

یہ میلان کی معلومات کو آؤٹ پٹ لیئر سے پوشیدہ پرت کی طرف پیچھے کی طرف منتقل کرتا ہے۔

اب ہمیں tanh ایکٹیویشن فنکشن کے مشتق کی وضاحت کرنے کی ضرورت ہے۔

تانہ کا مشتق اس طرح لکھا جا سکتا ہے:

1 - tanh(x)²

کیونکہ ہمارے پاس پوشیدہ پرت کی ایکٹیویٹ ویلیو پہلے ہی موجود ہے۔ a1آپ اسے اس طرح لکھ سکتے ہیں:

dz1 = da1 * (1 - a1**2)

یہ ہمیں بتاتا ہے کہ چھپی ہوئی پرت کی پری ایکٹیویشن ویلیو نے نقصان کو کیسے متاثر کیا۔

اب ہم پہلی پرت کے وزن کے لیے گریڈینٹ کا حساب لگاتے ہیں۔

dW1 = (X.T @ dz1) / len(X)

اور پوشیدہ پرت تعصب:

db1 = np.mean(dz1, axis=0, keepdims=True)

اس مقام پر ہمارے پاس تمام قابل تربیت پیرامیٹرز کے گریڈینٹ ہیں۔

24. وزن کی تازہ کاری

اب ہم تدریجی نزول کا استعمال کرتے ہیں۔

پہلا:

W2 -= learning_rate * dW2

یہ دوسری پرت کے وزن کو اپ ڈیٹ کرتا ہے۔

کہ -= طریقہ:

W2 = W2 - learning_rate * dW2

پھر:

b2 -= learning_rate * db2

آؤٹ پٹ تعصب کو اپ ڈیٹ کریں۔

اور:

W1 -= learning_rate * dW1

پہلی پرت کے وزن کو اپ ڈیٹ کریں۔

آخر میں:

b1 -= learning_rate * db1

پوشیدہ پرت تعصب کو اپ ڈیٹ کریں۔

یہ اپ ڈیٹس دراصل نیٹ ورک کو سیکھنے کی اجازت دیتے ہیں۔

25. مکمل NumPy نیورل نیٹ ورک

اب ہم سب کچھ ایک ساتھ باندھتے ہیں۔

import numpy as np

# 1. Training data

X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

y = np.array([
    [0],
    [1],
    [1],
    [0]
])

# 2. Initialize parameters

np.random.seed(42)

W1 = np.random.randn(2, 4)
b1 = np.zeros((1, 4))

W2 = np.random.randn(4, 1)
b2 = np.zeros((1, 1))

learning_rate = 0.1

# 3. Activation functions

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

# 4. Training

for epoch in range(10000):

    # Forward propagation

    z1 = X @ W1 + b1
    a1 = np.tanh(z1)

    z2 = a1 @ W2 + b2
    a2 = sigmoid(z2)

    # Calculate loss

    loss = -np.mean(
        y * np.log(a2 + 1e-8) +
        (1 - y) * np.log(1 - a2 + 1e-8)
    )

    # Backpropagation

    dz2 = a2 - y

    dW2 = (a1.T @ dz2) / len(X)
    db2 = np.mean(dz2, axis=0, keepdims=True)

    da1 = dz2 @ W2.T

    dz1 = da1 * (1 - a1**2)

    dW1 = (X.T @ dz1) / len(X)
    db1 = np.mean(dz1, axis=0, keepdims=True)

    # Update parameters

    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2

    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1

    # Display progress

    if epoch % 1000 == 0:
        print(f"Epoch {epoch}, Loss: {loss:.4f}")

آئیے اوپر سے نیچے تک پروگرام کو دیکھتے ہیں۔

پورے کوڈ کی لائن بہ لائن وضاحت

NumPy درآمد کریں:

import numpy as np

ہم NumPy درآمد کرتے ہیں کیونکہ ہمارا نیٹ ورک صف اور میٹرکس آپریشنز کے ساتھ کام کرتا ہے۔

ان پٹ تیار کریں۔

X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

ہر قطار ایک XOR مثال ہے۔

4 مثالیں ہیں، ہر مثال میں 2 ان پٹ ویلیوز کے ساتھ۔

تو شکل ہے۔ X am:

4 × 2

جواب بنائیں

y = np.array([
    [0],
    [1],
    [1],
    [0]
])

چار درست جوابات ہیں، ہر قطار میں ایک۔ X.

بے ترتیب ابتداء کو دوبارہ پیدا کرنے کے قابل بنانا

np.random.seed(42)

اس کی وجہ سے NumPy ہر بار ایک ہی ابتدائی بے ترتیب قدر پیدا کرے گا۔

نمبر 42 یہ کوئی خاص بات نہیں ہے۔ آپ ایک مختلف نمبر استعمال کر سکتے ہیں۔

پہلا وزن میٹرکس بنائیں

W1 = np.random.randn(2, 4)

یہ ایک میٹرکس بناتا ہے جس میں بے ترتیب نمبر ہوتے ہیں۔

شکل 2*4 ہے۔

اس میں 2 ان پٹ اور 4 پوشیدہ نیوران ہیں۔

اپنا پہلا تعصب بنائیں

b1 = np.zeros((1, 4))

یہ چار صفر پیدا کرتا ہے۔

[0, 0, 0, 0]

ہر پوشیدہ نیوران کا ایک تعصب ہوتا ہے۔

دوسرا وزن میٹرکس بنائیں

W2 = np.random.randn(4, 1)

4 پوشیدہ نیوران اور 1 آؤٹ پٹ نیوران ہیں۔

لہذا:

4 × 1

آپ کو وزن کی ضرورت ہے۔

آؤٹ پٹ تعصب پیدا کریں۔

b2 = np.zeros((1, 1))

آؤٹ پٹ پرت میں ایک نیوران ہے، لہذا ہمیں ایک تعصب کی ضرورت ہے۔

سیکھنے کی شرح کا تعین کرنا

learning_rate = 0.1

یہ کنٹرول کرتا ہے کہ گریڈیئنٹ ہر اپ ڈیٹ کو کس حد تک متاثر کرتا ہے۔

سگمائڈ نسل

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

یہ آؤٹ پٹ کو درمیان کی قدر میں بدل دیتا ہے۔ 0 اور 1.

ٹریننگ لوپ شروع کریں۔

for epoch in range(10000):

یہ Python کو تربیتی عمل کو 10,000 بار دہرانے کو کہتا ہے۔

ہر تکرار اعصابی نیٹ ورک کے ذریعے پورے ٹریننگ ڈیٹاسیٹ سے گزرنے کا ایک دور ہے۔

پوشیدہ پرت کے حساب کتاب

z1 = X @ W1 + b1

یہ چاروں پوشیدہ نیورونز اور چار تربیتی مثالوں کے لیے ایک وزنی رقم کا حساب کتاب کرتا ہے۔

tanh کی درخواست

a1 = np.tanh(z1)

یہ پوشیدہ پرت پر ایک غیر لکیری ایکٹیویشن فنکشن کا اطلاق کرتا ہے۔

آؤٹ پٹ پرت کا حساب کتاب

z2 = a1 @ W2 + b2

یہ پوشیدہ پرت سے قدریں لیتا ہے اور آؤٹ پٹ نیوران کے وزنی مجموعہ کا حساب لگاتا ہے۔

سگمائڈ ایپلی کیشن

a2 = sigmoid(z2)

یہ آؤٹ پٹ کو امکانات میں تبدیل کرتا ہے: 0 اور 1.

نقصان کا حساب

loss = -np.mean(
    y * np.log(a2 + 1e-8) +
    (1 - y) * np.log(1 - a2 + 1e-8)
)

اس سے اندازہ ہوتا ہے کہ پیشین گوئی درست جواب سے کتنی مختلف ہے۔

نچلی اقدار کا مطلب عام طور پر بہتر پیشین گوئیاں ہیں۔

آؤٹ پٹ ڈھلوان کا حساب کتاب

dz2 = a2 - y

یہ آؤٹ پٹ پرت کو اپ ڈیٹ کرنے کے لیے درکار گریڈینٹ کا حساب لگاتا ہے۔

دوسری پرت کے وزن کے میلان کو اپ ڈیٹ کریں۔

dW2 = (a1.T @ dz2) / len(X)

یہ اس بات کا تعین کرتا ہے کہ پوشیدہ پرت کو آؤٹ پٹ پرت سے جوڑنے والے ہر وزن نے نقصان میں کس طرح تعاون کیا۔

آؤٹ پٹ تعصب ڈھال اپ ڈیٹ

db2 = np.mean(dz2, axis=0, keepdims=True)

یہ آؤٹ پٹ تعصب کی اوسط ڈھلوان کا حساب لگاتا ہے۔

پوشیدہ پرت پر واپس جائیں۔

da1 = dz2 @ W2.T

یہ میلان کی معلومات کو آؤٹ پٹ پرت کے ذریعے پیچھے کی طرف منتقل کرتا ہے۔

تنہ تفریق کا اطلاق کریں۔

dz1 = da1 * (1 - a1**2)

یہ tanh ایکٹیویشن فنکشن کے اثر کی وضاحت کرتا ہے۔

پہلی پرت کے میلان کا حساب لگائیں۔

dW1 = (X.T @ dz1) / len(X)

یہ اس بات کا تعین کرتا ہے کہ ان پٹ میں پوشیدہ وزن نے نقصان میں کس طرح تعاون کیا۔

پھر:

db1 = np.mean(dz1, axis=0, keepdims=True)

پوشیدہ پرت کے تعصب کے لیے گریڈینٹ کا حساب لگائیں۔

پیرامیٹر اپ ڈیٹ

W2 -= learning_rate * dW2
b2 -= learning_rate * db2

W1 -= learning_rate * dW1
b1 -= learning_rate * db1

یہ چار لائنیں ہیں جہاں نیٹ ورک جو کچھ سیکھتا ہے اسے تبدیل کرتا ہے۔

میلان آپ کو بتاتا ہے کہ کس سمت میں جانا ہے، اور سیکھنے کی شرح حرکت کے سائز کا تعین کرتی ہے۔

نقصان دہ پرنٹنگ

if epoch % 1000 == 0:
    print(f"Epoch {epoch}, Loss: {loss:.4f}")

کہ % آپریٹر بقیہ تقسیم کے بعد دیتا ہے۔

تو:

epoch % 1000 == 0

ہر 1,000 عہدوں پر درست۔

اس کا مطلب ہے کہ ہم کسی چیز کو 10,000 بار پرنٹ نہیں کرتے ہیں۔ اس کے بجائے، درج ذیل اپ ڈیٹس کبھی کبھار فراہم کیے جاتے ہیں:

Epoch 0, Loss: ...
Epoch 1000, Loss: ...
Epoch 2000, Loss: ...
...

جب تربیت مناسب طریقے سے کی جاتی ہے، تو نقصانات عام طور پر کم ہو جاتے ہیں۔

26. نیٹ ورک ٹیسٹ

تربیت کے بعد، نیٹ ورک کو پیشن گوئی کرنے کے لیے استعمال کیا جا سکتا ہے۔

z1 = X @ W1 + b1
a1 = np.tanh(z1)

z2 = a1 @ W2 + b2
predictions = sigmoid(z2)

print(predictions)

نیٹ ورک کو اس کے قریب اقدار پیدا کرنی چاہئیں:

[[0],
 [1],
 [1],
 [0]]

اصل قیمت شاید درست نہیں ہوگی۔ 0 اور 1.

آپ کو اس طرح کے نتائج بھی مل سکتے ہیں:

[[0.01],
 [0.98],
 [0.99],
 [0.02]]

یہ ٹھیک ہے

نیٹ ورک امکانات پیدا کر رہا ہے۔

ہم ان امکانات کو کلاسوں میں تبدیل کرنے کے لیے ایک حد استعمال کر سکتے ہیں۔

classes = (predictions >= 0.5).astype(int)

print(classes)

نتائج درج ذیل ہیں:

[[0],
 [1],
 [1],
 [0]]

ہمارے نیٹ ورک نے XOR پیٹرن سیکھا۔

27. پوشیدہ پرت کی ضرورت کیوں تھی؟

آپ سوچ رہے ہوں گے کہ آپ دو ان پٹ کو براہ راست آؤٹ پٹ سے کیوں نہیں جوڑ سکتے ہیں۔

وجہ یہ ہے کہ XOR ایسی چیز نہیں ہے جو ایک لکیری پرت کی نمائندگی کر سکتی ہے۔

پوشیدہ پرتیں اضافی تبدیلیاں فراہم کرتی ہیں جو نیٹ ورک کو مزید پیچیدہ تعلقات سیکھنے کی اجازت دیتی ہیں۔

یہ نیورل نیٹ ورکس کے سب سے اہم آئیڈیاز میں سے ایک ہے۔ دوسرے لفظوں میں، نیٹ ورک کو ضروری نہیں کہ وہ ایک بڑا اصول سیکھے۔ اس کے بجائے، مختلف پرتیں قدم بہ قدم معلومات کو تبدیل کر سکتی ہیں۔

تصویر کی شناخت کے نظام کے لیے، آپ درج ذیل آسان عمل کا تصور کر سکتے ہیں:

اصلی عصبی نیٹ ورک لفظی طور پر ‘کناروں’، ‘شکلوں’ اور ‘آبجیکٹس’ کی صاف ستھری تہیں نہیں بناتے ہیں۔ یہ صرف ایک وجدان ہے کہ کس طرح تیزی سے پیچیدہ تاثرات متعدد تہوں کے ذریعے ابھر سکتے ہیں۔

28. بڑے نیورل نیٹ ورکس میں کیا ہوتا ہے؟

ہم نے جو نیٹ ورک بنایا ہے وہ چھوٹا ہے۔ جدید نیورل نیٹ ورکس میں لاکھوں، اربوں، یا اس سے زیادہ پیرامیٹرز ہوسکتے ہیں۔

آسان نیٹ ورک اس طرح لگتا ہے:

ہر کنکشن کا اپنا وزن ہو سکتا ہے۔

نیٹ ورک کے جتنے زیادہ نیوران اور کنکشن ہوتے ہیں، اتنے ہی زیادہ پیرامیٹرز اسے سیکھنے کی ضرورت پڑسکتی ہے۔

لہذا، بڑے ماڈلز کو کمپیوٹنگ پاور اور میموری کی خاصی مقدار کی ضرورت ہوتی ہے۔

لیکن بنیادی عمل کو یاد رکھیں:

Input
 ↓
Calculations
 ↓
Prediction
 ↓
Loss
 ↓
Gradients
 ↓
Parameter Updates

نیٹ ورک کا سائز ڈرامائی طور پر تبدیل ہوتا ہے، لیکن بنیادی تربیت کا خیال وہی رہتا ہے۔

29. کیا مجھے شروع سے نیورل نیٹ ورک بنانا چاہیے؟

نہیں شروع سے نیورل نیٹ ورک بنانا سیکھنے کے لیے مفید ہے کیونکہ یہ آپ کو یہ سمجھنے کی اجازت دیتا ہے کہ لائبریری کے نیچے کیا ہو رہا ہے۔

تاہم، حقیقی دنیا کی مشین لرننگ ایپلی کیشنز بناتے وقت، آپ عام طور پر تمام گریڈیئنٹس کو دستی طور پر شمار نہیں کرتے ہیں۔

یہ وہ جگہ ہے جہاں مشین لرننگ فریم ورک کام میں آتا ہے۔ عام طور پر استعمال ہونے والی Python لائبریریوں میں شامل ہیں:

• NumPy

• پائی ٹارچ

• ٹینسر فلو

• سخت

• سیکھنا

گہری سیکھنے کے لیے پائی ٹارچ یہ سب سے زیادہ استعمال ہونے والے فریم ورک میں سے ایک ہے۔ یہ خود بخود میلان کا حساب لگا سکتا ہے اور تربیت میں شامل بہت سے ریاضی کے کاموں کو سنبھال سکتا ہے۔

30. PyTorch کے ساتھ ایک ہی نیٹ ورک کی تعمیر

آئیے دیکھتے ہیں کہ PyTorch کے ساتھ نیٹ ورک کتنا چھوٹا ہوسکتا ہے۔

پہلی تنصیب:

pip install torch

پھر اسے درآمد کریں۔

import torch
import torch.nn as nn

اب ماڈل بناتے ہیں۔

model = nn.Sequential(
    nn.Linear(2, 4),
    nn.Tanh(),
    nn.Linear(4, 1),
    nn.Sigmoid()
)

آئیے اس کا تجزیہ کرتے ہیں۔

nn.Linear(2, 4)

ایک پرت بنائیں جو 2 ان پٹ لیتی ہے اور 4 آؤٹ پٹ تیار کرتی ہے۔

یہ ہماری پوشیدہ پرت ہے۔

اگلا:

nn.Tanh()

tanh ایکٹیویشن فنکشن کا اطلاق کریں۔

پھر:

nn.Linear(4, 1)

چار پوشیدہ نیوران کو ایک آؤٹ پٹ نیوران سے جوڑیں۔

آخر میں:

nn.Sigmoid()

آؤٹ پٹ کو درمیان کی قدر میں تبدیل کرتا ہے۔ 0 اور 1.

تو فن تعمیر یہ ہے:

2 inputs
   ↓
4 hidden neurons
   ↓
Tanh
   ↓
1 output neuron
   ↓
Sigmoid

نوٹ کریں کہ یہ NumPy نفاذ سے کتنا چھوٹا ہے۔

اس کی وجہ یہ ہے کہ PyTorch ہمارے لیے بہت سارے حسابات ہینڈل کرتا ہے۔

31. PyTorch کے ساتھ نیٹ ورک کی تربیت

پہلے تربیتی ڈیٹا بنائیں:

X = torch.tensor([
    [0., 0.],
    [0., 1.],
    [1., 0.],
    [1., 1.]
])

y = torch.tensor([
    [0.],
    [1.],
    [1.],
    [0.]
])

اعشاریہ اہم ہے کیونکہ نیورل نیٹ ورک عام طور پر فلوٹنگ پوائنٹ نمبرز کے ساتھ کام کرتے ہیں۔

اب ماڈل بناتے ہیں۔

model = nn.Sequential(
    nn.Linear(2, 4),
    nn.Tanh(),
    nn.Linear(4, 1),
    nn.Sigmoid()
)

اگلا، ہم نقصان کی تقریب کا انتخاب کرتے ہیں.

loss_function = nn.BCELoss()

BCELoss بائنری کراس اینٹروپی نقصان کا حساب لگائیں۔

اب آپٹیمائزر بنائیں:

optimizer = torch.optim.Adam(
    model.parameters(),
    lr=0.01
)

ایڈم ایک اصلاحی الگورتھم ہے جو تربیت کے دوران ماڈل کے پیرامیٹرز کو اپ ڈیٹ کرتا ہے۔

model.parameters() یہ آپٹیمائزر کو بتاتا ہے کہ کن اقدار کو اپ ڈیٹ کرنے کی ضرورت ہے۔

lr=0.01 سیکھنے کی شرح طے کریں۔

اب آپ تربیت کر سکتے ہیں:

for epoch in range(5000):

    predictions = model(X)

    loss = loss_function(predictions, y)

    optimizer.zero_grad()

    loss.backward()

    optimizer.step()

    if epoch % 500 == 0:
        print(
            f"Epoch {epoch}, Loss: {loss.item():.4f}"
        )

آئیے اہم حصوں کو دیکھتے ہیں۔

پہلا:

predictions = model(X)

تربیت کا ڈیٹا پھر نیٹ ورک پر منتقل کیا جاتا ہے۔

پھر:

loss = loss_function(predictions, y)

اپنے جوابات کے ساتھ اپنی پیشین گوئیوں کا موازنہ کریں۔

اگلا:

optimizer.zero_grad()

پچھلے تربیتی مراحل سے میلان کو صاف کرتا ہے۔

پھر:

loss.backward()

بیک پروپیگیشن کا استعمال کرتے ہوئے خود بخود میلان کا حساب لگائیں۔

آخر میں:

optimizer.step()

اس گریڈینٹ کا استعمال کرتے ہوئے ماڈل کے پیرامیٹرز کو اپ ڈیٹ کریں۔

یہ وہی بنیادی تربیتی عمل ہے جسے NumPy کا استعمال کرتے ہوئے دستی طور پر لاگو کیا جاتا ہے۔ فرق یہ ہے کہ PyTorch بہت سارے حسابات ہینڈل کرتا ہے۔

32. NumPy بمقابلہ PyTorch

تو ہم نے دو بار نیٹ ورک کیوں بنایا؟ ٹھیک ہے، کیونکہ دونوں ورژن مختلف چیزیں سکھاتے ہیں۔

وزن، تعصب، آگے بڑھنے، NumPy کا استعمال کرتے ہوئے
نقصان، میلان، بیک پروپیگیشن اور پیرامیٹر اپ ڈیٹ۔ اس سے حرکیات کو دیکھنا آسان ہو جاتا ہے۔

PyTorch آپ کو ایک ہی عام خیال کو بہت کم کوڈ کے ساتھ لکھنے کی اجازت دیتا ہے کیونکہ فریم ورک آپ کے لئے زیادہ تر حساب کتاب کو سنبھالتا ہے۔

آپ اسے اس طرح سوچ سکتے ہیں:

ایک بار جب آپ یہ جان لیں کہ NumPy ورژن کیسے کام کرتا ہے، PyTorch ورژن بہت کم پراسرار ہو جاتا ہے۔

33. گہری تعلیم کیا ہے؟

آپ نے شاید یہ اصطلاح سنی ہو گی۔ گہری سیکھنے. ڈیپ لرننگ مشین لرننگ کا ایک ذیلی سیٹ ہے جو نیورل نیٹ ورک کی متعدد پرتوں کا استعمال کرتا ہے۔

مثال کے طور پر:

Input
  ↓
Layer 1
  ↓
Layer 2
  ↓
Layer 3
  ↓
Layer 4
  ↓
Output

لفظ "گہری” سے مراد نیٹ ورک کی گہرائی، یا اس میں شامل پرتوں کی تعداد ہے۔

ایسا کوئی جادوئی نقطہ نہیں ہے جس پر ایک نیورل نیٹ ورک اچانک ذہین ہو جائے۔ تہوں کو شامل کرنے سے ماڈل کو ان پٹ کو مفید نمائندگی میں تبدیل کرنے کے مزید مواقع ملتے ہیں۔

34. نیورل نیٹ ورک کہاں استعمال ہوتے ہیں؟

نیورل نیٹ ورک مختلف شعبوں میں استعمال ہوتے ہیں۔ یہاں کچھ مثالیں ہیں…

کمپیوٹر وژن

عصبی نیٹ ورک تصاویر پر کارروائی کر سکتے ہیں۔

مثال کے طور پر:

Image
  ↓
Neural Network
  ↓
Prediction

اسے تصویر کی درجہ بندی اور آبجیکٹ کا پتہ لگانے جیسے کاموں کے لیے استعمال کیا جا سکتا ہے۔

قدرتی زبان کی پروسیسنگ

عصبی نیٹ ورک بھی متن پر کارروائی کر سکتے ہیں۔

مثال کے طور پر:

Text
  ↓
Neural Network
  ↓
Prediction

جدید زبان کے ماڈل متن پر کارروائی اور تخلیق کرنے کے لیے اعصابی نیٹ ورکس کا استعمال کرتے ہیں۔

آواز کی شناخت

نیورل نیٹ ورک آڈیو پر کارروائی کرنے اور بولی جانے والی زبان کو متن میں تبدیل کرنے میں مدد کر سکتے ہیں۔

Audio
  ↓
Neural Network
  ↓
Words

سفارش کا نظام

اعصابی نیٹ ورک آپ کو صارف کے رویے کے نمونے سیکھنے اور یہ پیش گوئی کرنے میں مدد کر سکتے ہیں کہ کون سا مواد یا مصنوعات کسی کے لیے مفید ہو سکتی ہیں۔

AI پیدا کرنا

متن، تصاویر، آڈیو، کوڈ، ویڈیو، اور بہت کچھ بنانے کے لیے بڑے پیمانے پر اعصابی نیٹ ورک بھی استعمال کیے جا سکتے ہیں۔

یہ سسٹم ہمارے بنائے ہوئے چھوٹے XOR نیٹ ورکس سے کہیں زیادہ پیچیدہ ہیں، لیکن وہ اب بھی ڈیٹا سے پیرامیٹرز سیکھنے کے اسی عمومی خیال پر انحصار کرتے ہیں۔

35. ایک تصویر میں پورا عمل

اب تک ہم نے بہت کچھ کور کیا ہے۔

مکمل تربیتی کورس درج ذیل ہے:

Data
   ↓
Neural Network
   ↓
Prediction
   ↓
Loss
  ↓
Backpropagation
  ↓
Update Parameters
  ↓
Repeat

تربیت کے بعد، سیکھے گئے پیرامیٹرز کو نئے ڈیٹا پر پیشین گوئیاں کرنے کے لیے استعمال کیا جاتا ہے۔

New Data
   ↓
Trained Neural Network
   ↓
Prediction

یہ نیورل نیٹ ورک کی تربیت کا بنیادی خیال ہے۔

36. یاد رکھنے کا سب سے اہم خیال

یہ ٹھیک ہے اگر آپ کو اس ٹیوٹوریل میں موجود تمام مساواتیں یاد نہیں ہیں۔

ان تصورات کے ساتھ شروع کریں۔

ان پٹ

یہ وہ نمبر ہے جو ہم نیٹ ورک کو فراہم کرتے ہیں۔

x₁, x₂, x₃...

وزن

ایک عدد جو اس بات کا تعین کرتا ہے کہ ان پٹ نیوران کو کتنی مضبوطی سے متاثر کرتا ہے۔

w₁, w₂, w₃...

تعصب

یہ ایک اضافی قدر ہے جو نیوران کو زیادہ لچک دیتی ہے۔

b

ایکٹیویشن فنکشن

ایک فنکشن جو نیوران آؤٹ پٹ کو تبدیل کرتا ہے اور نیٹ ورک کو غیر لکیری پیٹرن سیکھنے کی اجازت دیتا ہے۔

مثالوں میں شامل ہیں:

ReLU
Tanh
Sigmoid

آگے کی تبلیغ

ان پٹ سے آؤٹ پٹ تک ڈیٹا بھیجیں۔

Input → Hidden Layers → Output

نقصان

اندازہ لگاتا ہے کہ پیشین گوئی درست جواب سے کتنا مختلف ہے۔

بیک پروپیگیشن

نیٹ ورک کے ذریعے پیچھے کی طرف کام کرکے گریڈینٹ کا حساب لگائیں۔

تدریجی نزول

ہم نیٹ ورک کے پیرامیٹرز کو اپ ڈیٹ کرنے کے لیے اس میلان کا استعمال کرتے ہیں۔

اور سیکھنے کے پورے عمل کا خلاصہ اس طرح کیا جا سکتا ہے:

Predict
   ↓
Measure Error
   ↓
Calculate Gradients
   ↓
Update Parameters
   ↓
Repeat

37. مجھے آگے کیا سیکھنا چاہیے؟

اگر آپ Python میں نیورل نیٹ ورک سیکھنا جاری رکھنا چاہتے ہیں، تو آپ کو پیچیدہ تحقیقی مقالوں میں سیدھا غوطہ لگانے کی ضرورت نہیں ہے۔

سیکھنے کے کچھ مفید راستوں میں شامل ہیں:

Python
  ↓
NumPy
  ↓
Basic Linear Algebra
  ↓
Probability & Statistics
  ↓
Machine Learning Basics
  ↓
Neural Networks
  ↓
PyTorch
  ↓
Deep Learning
  ↓
Computer Vision / NLP / Generative AI

آپ چھوٹے منصوبے بنا کر بھی سیکھ سکتے ہیں۔

مثال کے طور پر:

1. XOR چھانٹنے والا

2. گھر کی قیمت کا پیشن گو

3. ہاتھ سے لکھا ہندسوں کی درجہ بندی کرنے والا

4. سادہ تصویر کا درجہ بندی کرنے والا

5. سپیم پیغام کی درجہ بندی کرنے والا

6. عصبی نیٹ ورک ریاضی کے افعال سیکھنا

اس منصوبے کو بہت بڑا ہونا ضروری نہیں ہے۔ ایک چھوٹا پروجیکٹ جسے آپ پوری طرح سمجھتے ہیں اکثر اس بڑے پروجیکٹ سے زیادہ کارآمد ہوتا ہے جس کے کوڈ کو آپ نے سمجھے بغیر کاپی کر لیا تھا۔

آخری راستہ

اعصابی نیٹ ورک خوفناک لگ سکتے ہیں کیونکہ جدید AI میں استعمال ہونے والے سسٹمز میں بہت زیادہ پیرامیٹرز شامل ہو سکتے ہیں۔

لیکن بنیادی خیال بہت چھوٹا ہے۔

اعصابی نیٹ ورک نمبروں کو ان پٹ کے طور پر لیتے ہیں، انہیں وزن اور تعصبات کا استعمال کرتے ہوئے یکجا کرتے ہیں، ریاضی کے افعال کو لاگو کرتے ہیں، پیشین گوئیاں پیدا کرتے ہیں، اندازہ لگاتے ہیں کہ پیشین گوئیاں کتنی غلط ہیں، اور پھر پیرامیٹرز کو ایڈجسٹ کرتے ہیں۔

سائیکل مندرجہ ذیل ہے:

Input
  ↓
Weighted Calculations
  ↓
Activation Functions
  ↓
Prediction
  ↓
Loss
  ↓
Gradients
  ↓
Parameter Updates
  ↓
Repeat

یہی بنیاد ہے۔

اس ٹیوٹوریل میں بنایا گیا XOR نیٹ ورک جدید AI میں استعمال ہونے والے نیورل نیٹ ورکس کے مقابلے چھوٹا ہے۔ لیکن جو خیالات آپ نے ابھی سیکھے ہیں (پیرامیٹر، پرتیں، ایکٹیویشن فنکشنز، فارورڈ پروپیگیشن، نقصان، بیک پروپیگیشن، گریڈیئنٹس، اور اصلاح) وہ بنیادی آئیڈیاز ہیں جو گہری سیکھنے میں بار بار ظاہر ہوتے ہیں۔

اگلی بار جب آپ سنیں گے کہ ایک AI ماڈل میں لاکھوں یا اربوں پیرامیٹرز ہیں، تب بھی یہ زبردست لگ سکتا ہے۔

لیکن اس سارے پیمانے کے نیچے، بنیادی سیکھنے کا لوپ اب بھی واقف ہے۔

1. پیشین گوئی کریں۔

2. غلطی کی پیمائش کریں۔

3. بہتر بنانے کا طریقہ معلوم کریں۔

4. پیرامیٹرز کو اپ ڈیٹ کریں۔

5. براہ کرم دوبارہ کوشش کریں۔

یہ نیورل نیٹ ورکس کا بنیادی خیال ہے۔

کوڈنگ کا مزہ لیں اور سیکھتے رہیں!