مشین لرننگ ماڈل کیا ہے اور اسے کیسے بنایا جائے؟

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

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

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

شرطیں

اس ٹیوٹوریل کی پیروی کرنے کے لیے آپ کو مشین لرننگ کے کسی سابقہ ​​تجربے کی ضرورت نہیں ہے۔ جیسے جیسے ہم ترقی کرتے ہیں، ہم ہر مشین لرننگ کا تصور متعارف کرائیں گے۔

تاہم، اگر آپ کو Python کی بنیادی سمجھ ہے، تو آپ کو سبق کی پیروی کرنا آسان ہوگا۔ آپ کو اس کے ساتھ آرام دہ ہونا چاہئے:

• متغیرات بنانا اور استعمال کرنا

• ازگر کی فہرست کے آپریشن

• بنیادی باتیں لکھنا if/else اعلان

• فنکشن کال

• Python پروگرام پڑھنا اور چلانا

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

آپ کے پاس یہ بھی ہونا چاہیے:

• ازگر اپنے کمپیوٹر پر انسٹال کریں۔

• ٹیکسٹ ایڈیٹر یا کوڈ ایڈیٹر جیسے VS کوڈ

• ٹرمینل یا کمانڈ پرامپٹ

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

آپ یہ مت کرو مشین لرننگ، اسکِٹ لرن، شماریات، یا جدید ریاضی کی پیشگی معلومات درکار ہے۔ میں قدم بہ قدم مشین لرننگ کے تصورات اور کوڈ کی وضاحت کروں گا۔

کیا سیکھنا ہے۔

مقصد صرف کوڈ کو کام کرنا نہیں ہے۔ ہم سمجھیں گے کہ ہر اہم لائن کیا کرتی ہے، اس کی ضرورت کیوں ہے، اور اصل میں پردے کے پیچھے کیا ہو رہا ہے۔

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

مشین لرننگ ماڈل کیا ہے؟

مشین لرننگ ماڈل ایک ایسا پروگرام ہے جو ڈیٹا سے پیٹرن سیکھتا ہے۔

تعریف جان بوجھ کر آسان ہے۔

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

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

مثال کے طور پر، فرض کریں کہ آپ کسی طالب علم کے بارے میں ماڈل کی معلومات فراہم کرنا چاہتے ہیں۔

وقت کا مطالعہ کیا	ٹیسٹ
1	ناکام
2	ناکام
3	ناکام
4	پاس
5	پاس
6	پاس

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

ہم ان اصولوں کو پروگرام میں واضح طور پر نہیں لکھتے ہیں۔ ماڈل مثالوں سے تعلقات سیکھتا ہے۔

یہ مشین لرننگ کا بنیادی خیال ہے۔

مشین لرننگ بمقابلہ روایتی پروگرامنگ

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

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

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

Data + Rules → Answer

آپ یہ بھی لکھ سکتے ہیں:

hours = 5

if hours >= 4:
    print("Likely to pass")
else:
    print("Likely to fail")

یہاں ہم نے واضح طور پر قاعدہ بنایا ہے۔

hours >= 4

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

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

Examples + Correct Answers → Machine Learning Model

ماڈل ان مثالوں میں مفید نمونوں کی نشاندہی کرتا ہے۔

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

New Data + Trained Model → Prediction

فرق سمجھنے کے لئے سب سے اہم تصورات میں سے ایک ہے۔

"تربیت” کا کیا مطلب ہے؟

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

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

آپ ان کی مثال دیتے ہیں:

1 hour → Fail
2 hours → Fail
3 hours → Fail
5 hours → Pass
6 hours → Pass

کافی مثالوں کو دیکھنے کے بعد، آپ کو پیٹرن نظر آنا شروع ہو جائیں گے۔

مشین لرننگ ٹریننگ اسی طرح کام کرتی ہے۔

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

لفظ تربیت یہ لاجواب لگتا ہے، لیکن بنیادی خیال یہ ہے کہ ماڈل کی مثالیں فراہم کی جائیں اور انہیں مفید نمونے سیکھنے دیں۔

ڈیٹا سیٹ کیا ہے؟

ڈیٹا سیٹ محض ڈیٹا کا مجموعہ ہے۔

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

فرض کریں کہ آپ کے پاس درج ذیل آؤٹ پٹ ہے:

hours = [1, 2, 3, 4, 5, 6, 7, 8]

اور:

results = [0, 0, 0, 1, 1, 1, 1, 1]

یہاں ہم ٹیسٹ کے نتائج کی نمائندگی کرنے کے لیے نمبر استعمال کرتے ہیں۔

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

0 = Fail
1 = Pass

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

1 hour → Fail
2 hours → Fail
3 hours → Fail
4 hours → Pass
5 hours → Pass
6 hours → Pass
7 hours → Pass
8 hours → Pass

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

خصوصیات اور لیبل کیا ہیں؟

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

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

کوئی راستہ نہیں برانڈ یہ وہ جواب ہے جس کی ہم ماڈل پیش گوئی کرنا چاہتے ہیں۔

ہماری مثال میں:

Hours studied → Feature
Pass/fail → Label

ہر طالب علم کے بارے میں اضافی معلومات رکھنے سے آپ کو کئی کام کرنے کی اجازت ملتی ہے، جیسے:

Hours studied
Previous exam score
Homework completion rate
Attendance

اس کے بعد ماڈل پیشن گوئی کرنے کے لیے ان تمام خصوصیات کا استعمال کر سکتا ہے:

Pass or fail

لہذا آپ اس کے بارے میں اس طرح سوچ سکتے ہیں: فنکشن اشارہ ہے۔ لیبلز جواب ہیں۔

ہم کس قسم کی مشین لرننگ استعمال کر رہے ہیں؟

ہماری مثال میں زیر نگرانی سیکھنے. زیر نگرانی سیکھنے کا مطلب ہے ایک ایسے ماڈل کو تربیت دینا جس کے لیے آپ پہلے سے ہی صحیح جواب جانتے ہوں۔

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

Hours studied: 2
Correct answer: Fail

اور:

Hours studied: 6
Correct answer: Pass

ماڈل تربیت کے دوران ان پٹ اور درست آؤٹ پٹ دونوں کی تصدیق کرتا ہے۔

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

مشین لرننگ کی دیگر اقسام ہیں، بشمول کمک سیکھنا، لیکن زیر نگرانی لرننگ شروع کرنے کے لیے ایک اچھی جگہ ہے کیونکہ بنیادی ورک فلو کو سمجھنا آسان ہے۔

ہم اصل میں کیا تعمیر کرنے جا رہے ہیں؟

ہم مندرجہ ذیل Python پروگرام بنائیں گے:

1. ایک چھوٹا ڈیٹاسیٹ بنائیں۔

2. جوابات سے الگ ان پٹ۔

3. ڈیٹا کو ٹریننگ اور ٹیسٹ ڈیٹا میں تقسیم کریں۔

4. مشین لرننگ ماڈل بنائیں۔

5. ماڈل کو تربیت دیں۔

6. جانچ کریں کہ یہ کتنی اچھی کارکردگی کا مظاہرہ کرتا ہے۔

7. ماڈل کو نئی معلومات فراہم کرتا ہے۔

8. پیشین گوئیاں کرنے کے لیے اپنا ماڈل استعمال کریں۔

ہمارا آخری پروگرام ہے۔ فیصلے کے درخت کی درجہ بندی کرنے والا پر scikit-learn لائبریری

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

ایک سادہ مثال میں، ماڈل مندرجہ ذیل سے ملتا جلتا پیٹرن سیکھ سکتا ہے:

Did the student study enough hours?
        ↓
      Yes → Pass
      No  → Fail

حقیقی فیصلے کے درخت بہت زیادہ پیچیدہ ہوسکتے ہیں، لیکن یہ بنیادی خیال دیتا ہے.

اب تعمیر شروع کرتے ہیں!

مرحلہ 1: ازگر انسٹال کریں۔

ساتھ چلنے کے لیے آپ کو اپنے کمپیوٹر پر Python انسٹال کرنے کی ضرورت ہوگی۔

آپ چیک کر سکتے ہیں کہ آیا Python پہلے سے ہی انسٹال ہے چل کر:

python --version

آپ کو مندرجہ ذیل کی طرح کچھ دیکھنا چاہئے:

Python 3.12.0

عین مطابق ورژن کا مثال سے مماثل نہیں ہے۔

مرحلہ 2: ایک پروجیکٹ فولڈر بنائیں

ایک فولڈر بنائیں جس کا نام ہے:

machine-learning-model

اس فولڈر کے اندر، ایک فائل بنائیں جس کا نام ہے:

model.py

ہمارا پروجیکٹ آخر کار اس طرح نظر آئے گا:

machine-learning-model/
└── model.py

مرحلہ 3: اسکیٹ لرن انسٹال کریں۔

ہم Python نامی ایک لائبریری استعمال کریں گے۔ سیکھنا.

scikit-learn بہت سے مشین لرننگ الگورتھم اور ٹولز فراہم کرتا ہے لہذا آپ کو ریاضی کی مساوات میں ہر چیز کو خود لاگو کرنے کی ضرورت نہیں ہے۔

استعمال کرتے ہوئے انسٹال کریں:

pip install scikit-learn

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

مرحلہ 4: ماڈل درآمد کریں۔

کھلا model.py اور پھر لکھیں:

from sklearn.tree import DecisionTreeClassifier

یہ لائن ہے۔ DecisionTreeClassifier یہ اسکیٹ لرن کی کلاس ہے۔

یہ ڈھانچہ:

from sklearn.tree

اس کا مطلب ہے کہ آپ scikit-learn کے ٹری ماڈیول سے کچھ حاصل کر رہے ہیں۔

پھر:

import DecisionTreeClassifier

اس کا مطلب ہے کہ ہم فیصلہ کن درخت کی درجہ بندی کرنے والا استعمال کرنا چاہتے ہیں۔

اسے درآمد کرنے کے بعد، آپ اس کا استعمال کرتے ہوئے مشین لرننگ ماڈل بنا سکتے ہیں:

model = DecisionTreeClassifier()

متغیر:

model

ہمارے مشین لرننگ ماڈل کی نمائندگی کرتا ہے۔

اس وقت، ماڈل نے کچھ نہیں سیکھا ہے۔ یہ بنیادی طور پر ایک خالی ماڈل ہے جو تربیتی ڈیٹا کا انتظار کر رہا ہے۔

مرحلہ 5: ڈیٹاسیٹ بنائیں

اب آئیے اپنے ماڈل سے سیکھنے کے لیے ایک مثال بنائیں۔

شامل کریں:

hours = [1, 2, 3, 4, 5, 6, 7, 8]

یہ فہرست بتاتی ہے کہ ہر طالب علم نے کتنے گھنٹے مطالعہ کیا۔

پھر:

results = [0, 0, 0, 1, 1, 1, 1, 1]

یہ فہرست بتاتی ہے کہ آیا ہر طالب علم پاس ہوا یا ناکام۔

یاد رکھیں:

0 = Fail
1 = Pass

چنانچہ پہلے طالب علم نے ایک گھنٹہ مطالعہ کیا اور فیل ہوگیا۔

چوتھے کے طالب علم نے 4 گھنٹے مطالعہ کیا اور پاس ہو گیا۔

آٹھویں کے طالب علم نے 8 گھنٹے مطالعہ کیا اور پاس کیا۔

اب ہمارے پاس ایک مثال ہے جس سے ہمارا ماڈل سیکھ سکتا ہے۔

مرحلہ 6: سمجھیں کہ ڈیٹا کا ڈھانچہ کیوں اہم ہے۔

یہاں کچھ اہم تفصیلات ہیں: مشین لرننگ لائبریریاں عام طور پر ان پٹ ڈیٹا کو ایک خاص طریقے سے ترتیب دینے کی توقع کرتی ہیں۔

ہمارے hours یہ فہرست ہے:

[1, 2, 3, 4, 5, 6, 7, 8]

تاہم، scikit-learn کی توقع ہے کہ خصوصیات کو دو جہتی ڈھانچے میں پیش کیا جائے گا۔

کیوں

اس کی وجہ یہ ہے کہ مشین لرننگ ڈیٹا سیٹ میں متعدد خصوصیات شامل ہو سکتی ہیں۔

درج ذیل ڈیٹاسیٹ کا تصور کریں:

Hours Studied | Attendance | Previous Score
2             | 80%        | 65
5             | 95%        | 82
7             | 98%        | 91

ہر قطار ایک مثال کی نمائندگی کرتی ہے۔

ہر کالم ایک خصوصیت کی نمائندگی کرتا ہے۔

لہذا، ہمارے موجودہ ماڈل میں صرف ایک خصوصیت ہے، لیکن ہمیں اسے دو جہتی ڈیٹا سیٹ کے طور پر پیش کرنے کی ضرورت ہے۔

آپ گھریلو فہرستوں کا استعمال کرکے یہ کر سکتے ہیں۔

X = [
    [1],
    [2],
    [3],
    [4],
    [5],
    [6],
    [7],
    [8]
]

ہر داخلی فہرست ایک طالب علم کی نمائندگی کرتی ہے۔

پہلے طالب علم کے پاس ہے:

[1]

اس کا مطلب ہے کہ میں نے ایک گھنٹے تک مطالعہ کیا۔

دوسرا یہ ہے:

[2]

وغیرہ

بڑے خط X یہ فیچر ڈیٹا کے لیے ایک عام اصول ہے۔

اب آئیے ایک لیبل بناتے ہیں۔

y = [0, 0, 0, 1, 1, 1, 1, 1]

چھوٹا خط y عام طور پر ہدف یا لیبل اقدار کے لیے استعمال ہوتا ہے۔

اب ہمارے پاس مندرجہ ذیل نتیجہ ہے:

X = [
    [1],
    [2],
    [3],
    [4],
    [5],
    [6],
    [7],
    [8]
]

y = [0, 0, 0, 1, 1, 1, 1, 1]

آپ سوچ سکتے ہیں X جیسے:

یہاں ایک اشارہ ہے۔

اور y جیسے:

صحیح جواب ہے:

مرحلہ 7: اپنا ڈیٹا تقسیم کریں۔

ہم بالکل وہی مثالیں استعمال کرتے ہوئے اپنے ماڈل کی تربیت اور جانچ نہیں کرنا چاہتے۔

یہ کچھ ایسا ہی ہے جیسے کسی طالب علم کو وہی سوال دینا جو وہ امتحان میں دیکھے گا اور کہے گا:

"واہ، آپ نے 100% درست کہا۔ آپ نے بہت اچھا کام کیا۔”

ہم نے واقعی جانچ نہیں کی کہ انہوں نے کیا سیکھا۔

اس کے بجائے، ہم مندرجہ ذیل ڈیٹا سیٹ کو الگ کرتے ہیں:

• تربیت کے اعداد و شمار

• ٹیسٹ ڈیٹا

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

اسپلٹ فنکشن حاصل کریں۔

from sklearn.model_selection import train_test_split

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

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.25,
    random_state=42
)

اس ایک لائن میں بہت کچھ چل رہا ہے، تو آئیے اسے کھولتے ہیں۔

train_test_split()

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

ہم اسے فراہم کرتے ہیں:

X

اس میں ہماری خصوصیات شامل ہیں:

پھر:

y

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

دعویٰ:

test_size=0.25

اس کا مطلب ہے کہ آپ کو جانچ کے لیے تقریباً 25% ڈیٹا کی ضرورت ہوگی۔

باقی 75% تربیت کے لیے استعمال ہوتا ہے۔

random_state=42

ڈیٹا کو تصادفی طور پر تقسیم کیا جاتا ہے۔

بے ترتیب پن کو کنٹرول کیے بغیر متعدد بار پروگرام چلانے کے نتیجے میں ہر بار مختلف تقسیم ہو سکتی ہے۔

ماحول:

random_state=42

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

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

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

random_state=10

یہ بھی کام کرتا ہے۔

ہم ہیں 42 اس کی وجہ یہ ہے کہ یہ عام مثالی اقدار ہیں۔

چار متغیرات

یہ فنکشن ڈیٹا کے چار ٹکڑے لوٹاتا ہے۔

X_train
X_test
y_train
y_test

X_train ماڈل کی تربیت کے لیے استعمال ہونے والی خصوصیات پر مشتمل ہے۔

y_train تربیتی مثالوں کے جوابات شامل ہیں۔

X_test ماڈل کی جانچ کے لیے استعمال ہونے والی خصوصیات پر مشتمل ہے۔

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

مرحلہ 8: ماڈل بنائیں

اب ہم فیصلہ سازی کا درخت بناتے ہیں۔

model = DecisionTreeClassifier()

یہ ایک ماڈل آبجیکٹ بنائے گا۔

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

مرحلہ 9: ماڈل کو تربیت دیں۔

اب ہم اصل میں ماڈل سکھانے کی لائن پر پہنچتے ہیں۔

model.fit(X_train, y_train)

یہ مشین لرننگ کی سب سے اہم لائنوں میں سے ایک ہے۔

کہ .fit() طریقہ ہمارے فراہم کردہ ڈیٹا کا استعمال کرتے ہوئے ماڈل کو تربیت دیتا ہے۔

ہم اسے پیش کرتے ہیں:

X_train

اس میں مثالیں شامل ہیں۔

پھر:

y_train

درست جوابات شامل ہیں۔

ماڈل کو ایسے نمونے ملتے ہیں جو خصوصیات کو لیبل سے جوڑتے ہیں۔

ہمارے معاملے میں ہم اس کے درمیان تعلق تلاش کرنا چاہتے ہیں:

Hours studied

اور:

Pass/fail

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

یہ ہے جو اب سمجھنا ضروری ہے:

model.fit(X_train, y_train)

طریقہ:

درج ذیل مثالوں اور جوابات سے معلوم کریں۔

مرحلہ 10: پیشین گوئی کریں۔

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

فرض کریں ایک طالب علم نے 5 گھنٹے مطالعہ کیا۔

ہم لکھ سکتے ہیں:

prediction = model.predict([[5]])

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

[[5]]

بجائے:

[5]

بیرونی فہرست مثالوں کے مجموعہ کی نمائندگی کرتی ہے۔ اندرونی فہرست ایک مثال کے فنکشن کی نمائندگی کرتی ہے۔

چونکہ ماڈل میں ایک خصوصیت ہے، مثال میں ایک قدر ہے۔

[5]

تو:

[[5]]

طریقہ:

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

ماڈل ایک پیشن گوئی واپس کرتا ہے۔

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

print(prediction)

آپ دیکھ سکتے ہیں:

[1]

یاد رکھیں:

1 = Pass
0 = Fail

تو ماڈل نے پیش گوئی کی کہ طالب علم پاس ہو جائے گا۔

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

پیشن گوئی:

1

خاص طور پر دوستانہ نہیں۔

ہم لکھ سکتے ہیں:

if prediction[0] == 1:
    print("The model predicts: Pass")
else:
    print("The model predicts: Fail")

آئیے ایک نظر ڈالتے ہیں:

prediction[0]

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

[1]

کہ [0] پہلی چیز حاصل کریں۔

Python 0 سے فہرست کی پوزیشنوں کی گنتی شروع کرتا ہے۔

تو:

prediction[0]

طریقہ:

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

پھر:

if prediction[0] == 1:

چیک کریں کہ آیا ماڈل پیش گوئی کرتا ہے۔ 1.

اگر ایسا ہے تو، یہ پرنٹ کرتا ہے:

The model predicts: Pass

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

The model predicts: Fail

مرحلہ 12: ماڈل کی جانچ کریں۔

آپ کو صرف ایک پیشین گوئی نہیں کرنی چاہئے اور یہ فرض نہیں کرنا چاہئے کہ آپ کا ماڈل اچھا ہے۔

ہمیں اس کا جائزہ لینے کی ضرورت ہے۔

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

predictions = model.predict(X_test)

اب:

predictions

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

آپ ان پیشین گوئیوں کا موازنہ کر سکتے ہیں:

y_test

حقیقی جوابات شامل ہیں۔

scikit-learn ایک درستگی کا فنکشن فراہم کرتا ہے۔

from sklearn.metrics import accuracy_score

پھر:

accuracy = accuracy_score(y_test, predictions)

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

اگر آپ کا ماڈل ملتا ہے:

8 out of 10

اگر درست ہے تو درستگی یہ ہے:

0.8

آپ اسے فی صد میں تبدیل کر سکتے ہیں۔

print(f"Model accuracy: {accuracy * 100:.2f}%")

کہ * 100 تبدیلی:

0.8

میں:

80

کہ:

:.2f

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

تو آؤٹ پٹ ہو گا:

Model accuracy: 80.00%

درستگی کے بارے میں بہت اہم انتباہ

درستگی مفید ہے، لیکن یہ آپ کو آپ کے ماڈل کے بارے میں سب کچھ نہیں بتاتی ہے۔

ایک نایاب بیماری کو دریافت کرنے کی کوشش کا تصور کریں۔

فرض کریں:

99 people are healthy
1 person is sick

ایک خوفناک ماڈل آسانی سے پیش گوئی کر سکتا ہے:

Everyone is healthy.

یہ 99% درست ہوگا۔

لیکن یہ اس میں مکمل طور پر ناکام ہوجاتا ہے جس کی ہم اصل میں پرواہ کرتے ہیں: بیمار لوگوں کی شناخت۔

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

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

مرحلہ 13: یہ سب ایک ساتھ ڈالنا

ہمارے مکمل ابتدائی مشین لرننگ پروگراموں میں شامل ہیں:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score


# Dataset
X = [
    [1],
    [2],
    [3],
    [4],
    [5],
    [6],
    [7],
    [8]
]

y = [
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1
]


# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.25,
    random_state=42
)


# Create the machine learning model
model = DecisionTreeClassifier()


# Train the model
model.fit(X_train, y_train)


# Make predictions on the test data
predictions = model.predict(X_test)


# Calculate accuracy
accuracy = accuracy_score(y_test, predictions)


print(f"Model accuracy: {accuracy * 100:.2f}%")


# Make a prediction for a new student
hours_studied = [[5]]

prediction = model.predict(hours_studied)


# Display the prediction
if prediction[0] == 1:
    print("The model predicts: Pass")
else:
    print("The model predicts: Fail")

اوپر سے نیچے تک پورا کوڈ پڑھیں

پہلی تین سطریں:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

اپنی ضرورت کے اوزار حاصل کریں۔

پھر:

X = [
    [1],
    [2],
    [3],
    [4],
    [5],
    [6],
    [7],
    [8]
]

فیچر ڈیٹا تیار کریں۔

پھر:

y = [
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1
]

ایک لیبل بنائیں۔

اگلا:

X_train, X_test, y_train, y_test = train_test_split(...)

ڈیٹا سیٹ کو ٹریننگ ڈیٹا اور ٹیسٹ ڈیٹا میں تقسیم کریں۔

پھر:

model = DecisionTreeClassifier()

ایک ماڈل بنائیں۔

اگلا:

model.fit(X_train, y_train)

اسے تربیت دیں۔

پھر:

predictions = model.predict(X_test)

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

اگلا:

accuracy = accuracy_score(y_test, predictions)

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

آخر میں:

prediction = model.predict([[5]])

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

یہ پورا مشین لرننگ ورک فلو ہے۔

اصل میں ماڈل کے اندر کیا ہو رہا ہے؟

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

جب ہم چلاتے ہیں:

model.fit(X_train, y_train)

فیصلے کا درخت صرف اگلے جملے کو یاد رکھنے کے بارے میں نہیں ہے۔

4 hours = Pass

تربیتی مثالوں کا تجزیہ کریں اور انہیں تقسیم کرنے کے مفید طریقے تلاش کریں۔

مثال کے طور پر، آپ کو درج ذیل سے ملتا جلتا اصول مل سکتا ہے:

Is hours studied <= 3.5?

پھر:

Predict Fail

ورنہ:

Predict Pass

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

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

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

Is study time <= 3.5?

       Yes
        ↓
    Predict Fail

       No
        ↓
Is attendance <= 80%?

       Yes
        ↓
    Predict Fail

       No
        ↓
    Predict Pass

ایک بار پھر، آپ کا اصل کوڈ ان اصولوں کو دستی طور پر نہیں بناتا ہے۔

الگورتھم یہ تربیتی ڈیٹا سے سیکھتا ہے۔

"سیکھنے" کا واقعی کیا مطلب ہے؟

یہ مشین لرننگ کے سب سے زیادہ غلط فہمی والے پہلوؤں میں سے ایک ہے۔

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

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

لہذا "سیکھنا" ایک آسان لفظ ہے جب:

ہم ڈیٹا میں کارآمد نمونوں کو حاصل کرنے کے لیے ماڈل کو ٹیون کرنے کے لیے الگورتھم استعمال کرتے ہیں۔

پیرامیٹرز کیا ہیں؟

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

مثال کے طور پر، ایک سادہ لکیری ماڈل میں:

y = mx + b

ماڈل اس کے لیے اقدار سیکھ سکتا ہے:

m
b

یہ قدریں ان پٹ اور آؤٹ پٹ کے درمیان تعلق کا تعین کرتی ہیں۔

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

اہم خیال یہ ہے کہ ماڈل کے رویے کو ان اقدار کے ذریعے کنٹرول کیا جاتا ہے جو تربیت کے دوران سیکھی یا ایڈجسٹ کی جاتی ہیں۔

پیرامیٹرز اور ہائپر پیرامیٹر

یہ دونوں اصطلاحات الجھنا آسان ہیں۔

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

فیصلہ کن درختوں کے لیے، آپ وضاحت کر سکتے ہیں:

model = DecisionTreeClassifier(
    max_depth=3
)

یہاں:

max_depth=3

یہ ایک ہائپر پیرامیٹر ہے۔

ہم الگورتھم بتا رہے ہیں:

فیصلہ کن درختوں کو تین سطحوں سے زیادہ گہرائی تک بڑھنے نہ دیں۔

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

جیسے جیسے آپ مزید جدید ماڈلز بناتے ہیں، یہ امتیاز تیزی سے اہم ہوتا جاتا ہے۔

ہمیں تربیت اور جانچ کے ڈیٹا کی ضرورت کیوں ہے؟

تصور کریں کہ آپ ریاضی کے امتحان کے لیے پڑھ رہے ہیں۔

استاد آپ کو مشق کے 10 مسائل بتائے گا، اور آپ تمام 10 جوابات حفظ کر لیں گے۔

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

کیا یہ ثابت ہوتا ہے کہ آپ ریاضی کو سمجھتے ہیں؟ کوئی راستہ نہیں ہو سکتا ہے آپ نے محض ایک مثال حفظ کر لی ہو۔

مشین لرننگ میں بھی ایسا ہی مسئلہ ہے۔ اوور فٹنگ. ایک ماڈل نئے ڈیٹا کو سنبھالنے میں اچھے ہونے کے بغیر ڈیٹا کی تربیت میں بہت اچھا بن سکتا ہے۔

اس لیے ہم چند مثالیں الگ رکھ رہے ہیں۔ ماڈل تربیت کے دوران ٹیسٹ کی مثالیں نہیں دیکھ سکتا۔ پھر ہم پوچھ سکتے ہیں:

کیا ماڈل عام کر سکتا ہے کہ اس نے ان معاملات میں کیا سیکھا ہے جو اس نے پہلے کبھی نہیں دیکھا؟

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

اوور فٹنگ کیا ہے؟

اوور فٹنگ اس وقت ہوتی ہے جب ماڈل خاص طور پر تربیتی ڈیٹا کو سیکھتا ہے۔

اپنے ماڈل کو ایک بہت چھوٹا ڈیٹا سیٹ دینے کا تصور کریں۔ عام نمونوں کو سیکھنے کے بجائے:

More studying tends to increase the chance of passing.

آپ مخصوص مثالوں کو مؤثر طریقے سے حفظ کر سکتے ہیں۔

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

وہ ماڈل جو تربیتی ڈیٹا پر اچھی کارکردگی کا مظاہرہ کرتے ہیں لیکن ان دیکھے ڈیٹا پر خراب کارکردگی کا مظاہرہ کرتے ہیں اکثر اوور فٹنگ ہوتے ہیں۔

انڈر فٹنگ کیا ہے؟

انڈر فٹنگ بنیادی طور پر اس کے برعکس ہے۔ ماڈل بہت آسان ہے اور ڈیٹا میں اہم پیٹرن کیپچر نہیں کر سکتا۔

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

یہ ماڈل کو کافی مفید معلومات فراہم نہیں کرتا ہے اور تربیت اور ٹیسٹ کے اعداد و شمار دونوں پر خراب کارکردگی کا باعث بن سکتا ہے۔

اچھی مشین لرننگ میں ایسے ماڈلز کو تلاش کرنا شامل ہے جو مفید نمونوں کو سیکھنے کے لیے کافی پیچیدہ ہیں، لیکن اتنے پیچیدہ نہیں کہ وہ صرف تربیتی مثالوں کو یاد رکھیں۔

ہمارا ڈیٹاسیٹ حقیقی مشین لرننگ ڈیٹاسیٹ کیوں نہیں ہے۔

ہماری آٹھ مثالیں جان بوجھ کر چھوٹی ہیں۔

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

مثال کے طور پر، آپ جمع کر سکتے ہیں:

10,000 students

خصوصیات میں شامل ہیں:

Hours studied
Attendance
Homework completion
Previous scores
Sleep duration

میرے پاس درج ذیل لیبل ہیں:

Passed

اس کے بعد ماڈل ہزاروں مثالوں سے سیکھ سکتا ہے۔

ہمارا چھوٹا ڈیٹا سیٹ مفید ہے کیونکہ یہ ہمیں عمل کے ہر حصے کو سمجھنے کی اجازت دیتا ہے۔

مرحلہ 14: مزید خصوصیات شامل کریں۔

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

اپنے مطالعے کا وقت صرف کرنے کے بجائے، آئیے فرض کریں:

Hours studied
Attendance

ہم ہر طالب علم کی نمائندگی اس طرح کر سکتے ہیں:

X = [
    [2, 70],
    [3, 75],
    [4, 80],
    [5, 85],
    [6, 90],
    [7, 95]
]

اب ہر قطار دو فنکشنز پر مشتمل ہے۔

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

[5, 85]

طریقہ:

5 hours studied
85% attendance

ہمارے لیبل اب بھی اس طرح نظر آ سکتے ہیں:

y = [0, 0, 1, 1, 1, 1]

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

ہم اسے اسی طرح تربیت دے سکتے ہیں:

model.fit(X_train, y_train)

فرق یہ ہے کہ ماڈل میں اب ایک کی بجائے دو خصوصیات ہیں۔

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

ہم کہتے ہیں کہ آپ درج ذیل طالب علم کے نتائج کی پیشن گوئی کرنا چاہتے ہیں:

Studied for 5 hours
Had 90% attendance

اس کا اظہار ہم اس طرح کرتے ہیں:

new_student = [[5, 90]]

پھر:

prediction = model.predict(new_student)

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

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

جب آپ کے پاس سینکڑوں خصوصیات ہوں تو کیا ہوتا ہے؟

وہی بنیادی تصورات لاگو ہوتے ہیں۔

اس کا استعمال کرتے ہوئے مکان کی قیمت کی پیش گوئی کا تصور کریں:

Number of bedrooms
Square footage
Number of bathrooms
Location
Age of house
Garage size
Lot size
Distance to school

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

House price

بنیادی ڈھانچہ وہی رہتا ہے۔

Features → Model → Prediction

مشکل حصہ مفید ڈیٹا کا انتخاب، ایک مناسب الگورتھم کا انتخاب، ڈیٹا کو صاف کرنا، ماڈل کا جائزہ لینا، اور اس بات کو یقینی بنانا ہے کہ ماڈل ٹریننگ ڈیٹا سیٹ سے باہر اچھی کارکردگی کا مظاہرہ کرے۔

رجعت کیا ہے؟

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

Pass
Fail

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

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

Spam / Not Spam
Cat / Dog
Fraud / Not Fraud
Pass / Fail

رجعت مختلف ہے۔ نمبروں کی پیش گوئی کریں۔

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

House price = $425,000

یا:

Temperature = 82.4°F

یا:

Sales = $17,500

تو ایک مفید امتیاز یہ ہے:

Classification → Predict a category

Regression → Predict a number

رجعت کی سادہ مثال

scikit-learn مندرجہ ذیل ماڈل فراہم کرتا ہے: LinearRegression.

درآمد کریں:

from sklearn.linear_model import LinearRegression

ایک ماڈل بنائیں:

model = LinearRegression()

پھر ٹرین۔

model.fit(X_train, y_train)

اور اس طرح کی پیشین گوئی کریں:

prediction = model.predict([[5]])

ورک فلو تقریباً ایک جیسا ہے۔

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

عام مشین لرننگ ورک فلو

زیادہ تر ابتدائی مشین سیکھنے کے منصوبوں کے بارے میں مندرجہ ذیل ترتیب کو استعمال کرنے کے بارے میں سوچا جا سکتا ہے:

1. ڈیٹا اکٹھا کرنا

ایسی مثالیں حاصل کریں جو اس مسئلے سے متعلقہ ہوں جسے آپ حل کرنے کی کوشش کر رہے ہیں۔

2. ڈیٹا کی صفائی

کسی بھی گمشدہ، غلط، ڈپلیکیٹ، یا متضاد معلومات کو درست کریں۔

3. فنکشن منتخب کریں۔

وہ معلومات منتخب کریں جو آپ اپنے ماڈل میں استعمال کرنا چاہتے ہیں۔

4. ایک ماڈل منتخب کریں۔

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

5. ڈیٹا ڈویژن

علیحدہ تربیت اور جانچ کی مثالیں۔

6. ٹرین

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

7. تشخیص

پیمائش کرتا ہے کہ ماڈل کتنی اچھی کارکردگی کا مظاہرہ کرتا ہے۔

8. بہتری

ڈیٹا، فیچرز، ماڈلز یا ہائپر پیرامیٹر تبدیل کریں۔

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

نئے ڈیٹا پر تربیت یافتہ ماڈل استعمال کریں۔

10. تقسیم

اگر ماڈل کارآمد ہے تو اسے اپنی درخواست میں ضم کریں۔

یہ ورک فلو مخصوص الگورتھم کے نام یاد کرنے سے کہیں زیادہ اہم ہے۔

مشین لرننگ کا اطلاق حقیقی دنیا کی ایپلی کیشنز پر کیسے ہوتا ہے۔

ایک تربیت یافتہ ماڈل عام طور پر پوری درخواست نہیں ہے۔

فرض کریں کہ آپ یہ اندازہ لگانے کے لیے ایک ماڈل بنانا چاہتے ہیں کہ آیا ای میل اسپام ہے۔ آخر میں، آپ پیدا کر سکتے ہیں:

Email
 ↓
Backend
 ↓
Machine Learning Model
 ↓
Prediction
 ↓
User Interface

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

اسی خیال پر لاگو ہوتا ہے:

Recommendation systems
Fraud detection
Search engines
AI assistants
Image classification
Demand forecasting
Customer analytics

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

اس کے بعد مجھے کیا سیکھنے کی ضرورت ہے؟

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

NumPy سیکھیں۔

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

پانڈا سیکھو

پانڈا ڈیٹاسیٹس کے ساتھ کام کرنے کے لیے بہت مفید ہے۔

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

import pandas as pd

آپ CSV فائلیں لوڈ کر سکتے ہیں۔

data = pd.read_csv("students.csv")

اسے چیک کریں:

print(data.head())

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

ڈیٹا ویژولائزیشن سیکھیں۔

Matplotlib جیسی لائبریریاں آپ کو اپنے ڈیٹا کو دیکھنے میں مدد کر سکتی ہیں۔ مثال کے طور پر، آپ یہ دیکھنا چاہیں گے کہ آیا آپ کے ٹیسٹ کے اسکور بڑھتے ہیں جیسے جیسے آپ کے مطالعہ کا وقت بڑھتا ہے۔

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

مزید الگورتھم جانیں۔

ایک بار جب آپ فیصلہ کن درختوں کو سمجھ لیں، تو اس پر ایک نظر ڈالیں:

Linear Regression
Logistic Regression
Random Forests
K-Nearest Neighbors
Support Vector Machines
Gradient Boosting
Neural Networks

آپ کو سب کچھ یاد کرنے کی ضرورت نہیں ہے۔

اس بات کو سمجھنے پر توجہ مرکوز کریں کہ ہر الگورتھم کس قسم کے مسئلے کو حل کرنے کے لیے ڈیزائن کیا گیا ہے اور اس میں کون سے مفروضے یا تجارتی نقصانات شامل ہیں۔

ریاضی سیکھیں

آپ شروع سے تمام مساوات اخذ کیے بغیر مفید مشین لرننگ ایپلی کیشنز بنا سکتے ہیں۔

تاہم، اگر آپ مشین لرننگ کو گہرائی سے سمجھنا چاہتے ہیں، تو ریاضی تیزی سے قیمتی ہوتی جاتی ہے۔

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

Algebra
Functions
Probability
Statistics
Linear Algebra
Calculus

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

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

برقرار رکھنے کے لئے ذہنی ماڈل

مشین لرننگ سیکھتے وقت، اصطلاحات کو ہر چیز کو اس سے زیادہ پیچیدہ نہ ہونے دیں۔

آسان ترین سطح پر، مشین لرننگ کے بارے میں اس طرح سوچیں:

مثالیں ہیں، ہر ایک میں درج ذیل معلومات ہیں: خصوصیت. کچھ مثالوں کے بھی معلوم جوابات ہیں، جیسے: لیبل.

ہم یہ مثالیں اپنے سیکھنے کے الگورتھم میں فراہم کرتے ہیں۔ الگورتھم ایک ماڈل بناتا ہے جو نمونوں کو نمونوں میں پکڑتا ہے۔

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

کوڈ میں بنیادی ورک فلو مندرجہ ذیل ہے:

model = SomeMachineLearningModel()

model.fit(X_train, y_train)

predictions = model.predict(X_test)

تین حصوں کا ڈھانچہ یاد رکھنے کے قابل ہے۔

model = ...

ایک ماڈل بنائیں۔

model.fit(...)

ماڈل کو تربیت دیں۔

model.predict(...)

تربیت یافتہ ماڈل استعمال کریں۔

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

حتمی خیالات

مشین لرننگ ماڈل کمپیوٹر کے اندر جادوئی دماغ نہیں ہیں۔ یہ ایک الگورتھم کے ذریعہ تخلیق کردہ ایک ریاضیاتی ماڈل ہے جو ڈیٹا سے پیٹرن سیکھتا ہے۔

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

روایتی پروگرامنگ کا استعمال کرتے ہوئے، آپ واضح طور پر لکھ سکتے ہیں:

if hours >= 4:
    result = "Pass"

مشین لرننگ مندرجہ ذیل مثال فراہم کرتا ہے:

1 hour → Fail
2 hours → Fail
3 hours → Fail
4 hours → Pass
5 hours → Pass

سیکھنے کے الگورتھم کو مفید نمونے تلاش کرنے دیں۔

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

ان بنیادی باتوں کو سمجھنے کے بعد، درج ذیل اصطلاحات استعمال کی جاتی ہیں: تربیت، خصوصیت، لیبل، درجہ بندی، واپسی، اوور فٹنگاور ماڈل اسے بے ترتیب AI الفاظ کے مجموعہ کی طرح آواز دینا بند کریں اور اسے ایک مربوط خیال میں فٹ کرنا شروع کریں۔

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

مبارک کوڈنگ!