خودکار تحقیق کے ساتھ اپنے LLM تجربات کو چلانے کے لیے AI ایجنٹ کیسے بنایا جائے۔

اندریج کارپاتھی کو چند ماہ قبل رہا کیا گیا تھا۔ خودکار تحقیقات. یہ ایک اوپن سورس پائتھون ٹول ہے جو AI ایجنٹوں کو ایک GPU پر تجربات چلانے کی اجازت دیتا ہے جب کہ صارفین پیچھے بیٹھ کر نتائج کا انتظار کرتے ہیں۔

حال ہی میں، میں نے ٹویٹر پر لوگوں کو یہ بحث کرتے ہوئے دیکھا ہے کہ آیا AI ایجنٹس اپنا نظام خود بنا سکتے ہیں۔ "ملین ڈالر کا آئیڈیا” یا کسی چیز کے بارے میں کھلا پنجہ. تاہم، ایسے ذخیرے موجود ہیں جہاں آپ ایک حقیقی GPT ٹریننگ سیٹ اپ کسی ایجنٹ کے حوالے کر سکتے ہیں اور ان سے اپنی تحقیق خود کرنے کو کہہ سکتے ہیں۔

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

12 نانو چیٹ بیس لائن کی گہرائی میں (مزید "گہرائی” کا مطلب بعد میں)، میں نے کارپتھی کو تقریباً دو دن چلنے دیا۔ تقریباً 700 تجربات سے، ایجنٹ نے تقریباً 20 تبدیلیاں دریافت کیں جنہوں نے اصل میں ماڈل کو بہتر کیا، اور یہ تبدیلیاں ایک دوسرے کے ساتھ اوورلیپ ہوئیں۔

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

انڈیکس

شرطیں

یہ مضمون اس مخزن کی مکمل واک تھرو ہے۔ مقصد آخر کار یہ سمجھنا ہے کہ خودکار تحقیق کیا ہے اور اسے اپنے کمپیوٹر پر کیسے چلایا جائے۔

آپ کو پہلے سے ML تحقیقی تجربے کی ضرورت نہیں ہے، لیکن اگر آپ ایسا کرتے ہیں، تو میں نے جو گہرے حصے لکھے ہیں وہ زیادہ معنی خیز ہوں گے۔ GPUs جیسے GPU، VRAM اور H100/A100/4090 کا بنیادی علم کافی ہے۔ لیکن پریشان نہ ہوں، میں نے ان تمام اصطلاحات کی وضاحت کے لیے ذیل میں متن کا حوالہ دیا ہے جو میرے خیال میں ابتدائی افراد کو سمجھنا چاہیے۔

خودکار تفتیش کیا ہے؟

سیدھے الفاظ میں، خودکار تحقیق صرف ایک مخصوص خیال ہے جو صفائی کے ساتھ انجام دیا جاتا ہے۔ ایک چھوٹا لیکن حقیقت پسندانہ LLM ٹریننگ سیٹ اپ لیں، اسے ایک Python فائل میں محفوظ کریں، اور AI ایجنٹ کو اس فائل میں ترمیم کرنے دیں۔

ایجنٹ فائل چلاتا ہے اور کھوئے ہوئے مواد کو پڑھتا ہے۔ زبان کے ماڈل کی تربیت کرتے وقت، "نقصان” صرف ایک عدد ہوتا ہے جس سے اندازہ ہوتا ہے کہ ماڈل متن کے اگلے حصے کی کتنی بری طرح پیش گوئی کرتا ہے۔ زیادہ نمبر کا مطلب ہے ناقص اندازہ، اور 0 کے قریب نمبر کا مطلب تقریباً مکمل اندازہ ہے۔

ٹریننگ ایک ماڈل کے لاکھوں اندرونی وزن کو کم کرنے کا عمل ہے تاکہ اس تعداد کو کم کیا جا سکے۔ لہذا جب کوئی ایجنٹ کہتا ہے کہ وہ "نقصان پڑھتے ہیں”، تو اس کا مطلب ہے کہ وہ اس اسکور کو دیکھتے ہیں تاکہ یہ تعین کیا جا سکے کہ ان کی تبدیلیوں نے مدد کی یا نقصان پہنچایا۔

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

بہاؤ اوپر سے نیچے کی طرف اس طرح جاتا ہے: ایک انسان (آپ) ایک پلے بک لکھتا ہے (ایک مارک ڈاؤن فائل جسے program.md کہتے ہیں) جو قواعد کی وضاحت کرتی ہے۔ AI ایجنٹ اس پلے بک کو پڑھتا ہے اور تجربہ لوپ شروع کرتا ہے۔

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

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

ذخیرہ اس طرح رکھا گیا ہے کہ بالکل ایک نوب ہے جسے ایجنٹ موڑ سکتا ہے۔ آپ نئے پیکجز انسٹال نہیں کر سکتے یا ڈیٹا کو لوڈ کرنے یا نقصان کی پیمائش کرنے کا طریقہ تبدیل نہیں کر سکتے۔ یہ سب جان بوجھ کر بند کر دیا گیا ہے۔ صرف وہی فائلیں جن میں ایجنٹ ترمیم کرتے ہیں: train.py یہ ماڈل آرکیٹیکچر، آپٹیمائزر، بیچ سائز، سیکھنے کی شرح، اور خود ٹریننگ لوپ کی ساخت پر مشتمل ہے۔

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

یہ کیوں اہمیت رکھتا ہے۔

اسے صرف ایک اور ایجنٹ ڈیمو کے طور پر پڑھنا پرکشش ہے۔ لیکن ایسا نہیں ہے۔ وجہ میٹرکس میں ہے۔ اس میٹرک کو val_bpb کہا جاتا ہے، جس کا مطلب ہے توثیق بٹس فی بائٹ۔ یہ اسکور کرنے کا ایک مخصوص طریقہ ہے کہ ایک ماڈل متن کی کتنی اچھی طرح پیش گوئی کرتا ہے جس نے تربیت کے دوران کبھی نہیں دیکھا ("توثیق” سیٹ)۔

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

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

جب ہم کہتے ہیں کہ اس ریپوزٹری میں ڈیفالٹ ماڈل "تقریباً 1.00 bpb تک پہنچ جاتا ہے”، تو ہمارا مطلب ہے کہ 5 منٹ کے لیے ڈیفالٹ بیئر بونز ٹریننگ اسکرپٹ کو چلانے کے نتیجے میں ماڈل اس میٹرک کے لیے تقریباً 1.00 کا سکور پیدا کرے گا، جیسا کہ توثیق کے متن پر ماپا جاتا ہے۔ یہ آپ کی ابتدائی لائن ہے۔

وہاں سے، 0.005bpb (تقریباً 0.995 پوائنٹس) کی بہتری ایک چھوٹی لیکن حقیقی جیت ہے، اور وہ قسم جو ایجنٹوں کو اکثر ملتی ہے۔ 0.05 کی بہتری (0.95 کے قریب اسکور) بہت بڑی ہوگی۔ یہ ایک چھلانگ ہے جو عام طور پر صرف بہت بڑے ماڈلز یا زیادہ لمبی ٹریننگ رنز کے ساتھ حاصل کی جاسکتی ہے۔ لہذا تعداد چھوٹی لگ سکتی ہے، لیکن اس پیمانے پر، فی ہزار کے حصے واقعی اہم ہیں.

یہاں یہ ہے کہ اس مخصوص نمبر کو بہتر بنانا کیوں ضروری ہے: ایجنٹ مصنوعی لیڈر بورڈز کا پیچھا نہیں کر رہا ہے جو محققین نے گیم کھیلنے کے سالوں میں بنائے ہیں۔ 2019 میں GPT-2 کے بعد سے، تمام بڑے لینگویج ماڈلز اسی قسم کے تصدیقی نقصان کے وکر کو کم کر رہے ہیں جس پر انہیں تربیت دی گئی تھی۔

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

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

کارپیتھی نے تقریباً 20 ایڈجسٹمنٹس کا اطلاق کیا جو ایجنٹ نے چھوٹی گہرائی-12 ماڈل میں بڑی گہرائی-24 ماڈل میں دریافت کیں۔ صاف ستھرا اسٹیک کرنے کا مطلب ہے بیک وقت دو چیزیں۔ بہتری اضافی تھی (تمام 20 کو آن کرنے سے ایک دوسرے کو منسوخ کرنے کے بجائے انفرادی فوائد کا مجموعہ ملا)۔ اور منتقل (چھوٹے ماڈل میں پائے جانے والے فوائد اب بھی بڑے ماڈل میں نظر آتے ہیں)۔

یہ اس بات کی علامت ہے کہ ایجنٹ کو تربیت میں حقیقی بصیرت ملی ہے، نہ کہ صرف ایک خوش قسمت خصوصیت جو صرف ایک خاص پیمانے پر مدد کرتی ہے۔ مل کر، ہم نے کارپتھی کے "GPT-2 کا وقت” بینچ مارک کو 2.02 گھنٹے سے کم کر کے 1.80 گھنٹے کر دیا۔ یہ کوڈ پر تقریباً 11% اسپیڈ اپ ہے جسے وہ پہلے ہی کافی عرصے سے خود کو ٹوئیک کر رہا ہے۔

ایک اور اہم چیز بجٹ ہے۔ ہر تجربہ بالکل 5 منٹ تک چلتا ہے، زیادہ نہیں، کم نہیں۔ یہ آپ کو فی گھنٹہ تقریباً 12 تجربات، یا 8 گھنٹے کے نیند کے چکر میں تقریباً 100 تجربات فراہم کرتا ہے۔

ریپوزٹری نیویگیشن

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

صرف تین فائلیں اہم ہیں اور اس پر منحصر ہے کہ ان میں کون ترمیم کرتا ہے۔

train.py وہ فائل ہے جس میں ایجنٹ نے ترمیم کی ہے۔ اس میں جی پی ٹی ماڈل، ایک آپٹیمائزر، اور ٹریننگ لوپ ہے، اور اس میں موجود ہر چیز منصفانہ گیم ہے۔
ready.py فکسڈ بیسڈ ہے لہذا چلتے وقت کوئی بھی اس میں ترمیم نہیں کرسکتا۔ ڈیٹا ڈاؤن لوڈ کریں، ٹوکنائزر کو تربیت دیں، اور اپنے میٹرکس کی وضاحت کریں۔
program.md ایک فائل ہے جسے انسانوں نے ایڈٹ کیا ہے۔ یہ قواعد کی ایک پلے بک ہے جس پر ایجنٹ عمل کرتا ہے۔

باقی فائلیں (README.md, pyproject.toml, uv.lock, .gitignore, .python-version, analyze.ipynb نوٹ بک، اور Progress.png امیج) پلمبنگ اور دستاویزات ہیں جن پر عمل درآمد کے دوران نہ تو صارف اور نہ ہی ایجنٹ کو چھونے کی ضرورت ہے۔

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

یہ بالکل کیا ہے؟ `val_bpb`?

مزید جانے سے پہلے، یہ سمجھنا مددگار ہوگا کہ val_bpb کیا ہے۔ اگر آپ نے LLM کے دیگر مضامین پڑھے ہیں، تو آپ نے شاید اس طرح کی اصطلاحات دیکھی ہوں گی: "شرمندگی” یا "کراس اینٹروپی نقصان” اسے پھینک دیا گیا۔

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

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

کراس اینٹروپی نقصان نیٹ میں اس کی پیمائش کرتا ہے۔ nat وہ اکائی ہے جو آپ کو حاصل ہوتی ہے جب آپ لوگارتھم کو بیس 2 کے بجائے e (قدرتی لوگارتھم) پر لیتے ہیں۔ یہ مختلف پیمانے پر "حیرت انگیز” کی اتنی ہی مقدار کی پیمائش کرتا ہے (1 نیٹ تقریباً 1.44 بٹس ہے)۔ نقصان کو 2 کے فطری لوگارتھم سے تقسیم کرنے سے نیٹ کو بٹس میں تبدیل کیا جاتا ہے، جو کہ ایک بٹ فی بائٹ کنورژن ہے۔

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

ایک کامل ماڈل 0 کے قریب ہونا چاہیے، لیکن ایک بے ترتیب ماڈل کے لیے تقریباً 8 بٹس فی بائٹ کی ضرورت ہوگی (چونکہ ایک بائٹ 8 بٹس ہے)۔

کارپتی نے سادہ کراس اینٹروپی کے بجائے bpb کا انتخاب کرنے کی وجہ یہ ہے کہ bpb الفاظ کے سائز سے آزاد. اگر ایجنٹ ٹوکنائزر یا الفاظ کو تبدیل کرنے کا فیصلہ کرتا ہے، تو کراس اینٹروپی نقصان بالکل مختلف ہوگا یہاں تک کہ ایک ہی ماڈل کے معیار کے لیے۔ بٹس فی بائٹ اس کو معمول پر لاتے ہیں، لہذا 8192 کے الفاظ کے ساتھ گہرائی 8 ماڈل اور 16384 کے الفاظ کے ساتھ گہرائی 12 ماڈل براہ راست موازنہ کر سکتے ہیں۔

فنکشن جو اس کا حساب لگاتا ہے، تخمینہ_bpb، ready.py میں ہے، جسے ایجنٹ ترمیم نہیں کر سکتا۔ آپ صرف train.py تک رسائی حاصل کر سکتے ہیں۔ چونکہ میٹرک کی تعریفیں ایک فائل میں ہیں جس میں ایجنٹ ترمیم نہیں کر سکتا، اسکور کو خاموشی سے تبدیل کر کے اسکور کو کم نہیں کیا جا سکتا جس طرح اسکور کا حساب لگایا جاتا ہے۔ اسکورنگ کے اصول تمام تجربات میں یکساں رہتے ہیں، موازنہ کو ایماندار بناتے ہیں۔

5 منٹ کا اصول

خودکار تحقیق کے پاس ایک ڈیزائن کا انتخاب ہے جو اس کے اپنے حصے کا مستحق ہے۔ کیونکہ یہ وہ انتخاب ہے جو حقیقت میں یہ سب کام کرتا ہے۔ تمام تجربات وال کلاک ٹریننگ ٹائم کے بالکل 5 منٹ تک چلتے ہیں، قطع نظر اس کے کہ ایجنٹ کیا کر رہا ہے۔

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

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

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

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

H100 اور A100 NVIDIA ڈیٹا سینٹر GPUs ہیں، جبکہ RTX 4090 ایک اعلی درجے کا صارف کارڈ ہے۔ رفتار اور یادداشت میں بہت فرق ہوتا ہے، اور یہی بات ہے۔ 5 منٹ کے مقررہ بجٹ پر، تیز کارڈز زیادہ ڈیٹا پر کارروائی کرتے ہیں اور کم val_bpb تک پہنچ جاتے ہیں۔ لہذا، آپ ایک GPU کے اسکور کا دوسرے GPU کے اسکور سے براہ راست موازنہ نہیں کر سکتے۔

لیکن ایک سمجھوتہ ہے۔ چونکہ بجٹ وال کلاک ہوتے ہیں، لہذا آپ کو H100 پر جو val_bpb ملتا ہے اس کا موازنہ براہ راست اس val_bpb سے نہیں ہوتا جو آپ 4090 یا A100 پر حاصل کرتے ہیں۔ سسٹم کو بہترین ماڈل تلاش کرنے کے لیے ڈیزائن کیا گیا ہے۔ مخصوص کمپیوٹنگ پلیٹ فارمز کے لیے آپ 5 منٹ میں عالمی معیار نہیں بن سکتے۔

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

اب آئیے ہر فائل کو قریب سے دیکھیں۔

1۔ `prepare.py`

اس فائل کو کوئی نہیں چھوتا، لیکن سب کچھ اس پر منحصر ہے۔ یہ تین اہم کام انجام دیتا ہے:

پہلا کام ڈیٹا ڈاؤن لوڈ کرنا ہے۔ تربیتی کارپس ClimbMix-400B ہے، جو ایک اعلیٰ معیار کا ویب ڈیٹاسیٹ ہے جس کی میزبانی HuggingFace پر کی گئی ہے اور اسے 6,543 پارکیٹ شارڈز کے ساتھ ملایا گیا ہے۔ بنیادی طور پر prepare.py آپ ان میں سے صرف 10 ڈاؤن لوڈ کرتے ہیں (تقریباً چند گیگا بائٹس) جو کہ 5 منٹ میں ہزاروں تجربات کرنے کے لیے کافی ہے۔

بالکل آخری شارڈ ہمیشہ توثیق سیٹ کے طور پر ڈاؤن لوڈ اور پن کیا جاتا ہے۔ اینکرنگ اہم ہے کیونکہ ہر تجربہ (تبدیلیوں سے قطع نظر) کا اندازہ آپ کے پاس موجود ڈیٹا کے عین مطابق کیا جاتا ہے۔

دوسرا کام ٹوکنائزر کو تربیت دینا ہے۔ ریپو استعمال کرتا ہے: زنگ آلود تربیتی ڈیٹا کے نمونوں سے 8,192 ٹوکنز کی ذخیرہ الفاظ سیکھنے کے لیے بائٹ پیئر انکوڈنگ کا تیز رفتار نفاذ۔ نتائج ٹک ٹوکن سے مطابقت رکھنے والی انکوڈنگ میں برآمد کیے جاتے ہیں، جو PyTorch کے ساتھ نیچے کی طرف صاف انضمام فراہم کرتے ہیں۔ میرے پاس اس طرح کی ایک چھوٹی پری کمپیوٹیڈ لک اپ ٹیبل بھی ہے: token_bytes.pt یہ ہر ٹوکن ID کو UTF-8 بائٹ کی لمبائی میں نقشہ بناتا ہے۔ یہ وہی ہے جو بی پی بی کے حساب کتاب کو ایماندار بناتا ہے۔

تیسرا کام مندرجہ ذیل سہولیات فراہم کرنا ہے۔ train.py رن ٹائم پر حاصل کیا گیا۔ ڈیٹا لوڈر ایک دلچسپ ہے۔ یہ وہی کرتا ہے جو اسے کہتے ہیں۔ سب سے زیادہ مناسب پیکیجنگ: بیچ میں ہر قطار ایک خاص BOS (سلسلہ کا آغاز) ٹوکن کے ساتھ شروع ہوتی ہے، اور لوڈر لالچ سے ایسی دستاویزات کا انتخاب کرکے قطار کو بھرتا ہے جو باقی جگہ پر فٹ ہوں۔ صرف اس صورت میں جب دستاویز میں کچھ بھی فٹ نہیں ہوتا ہے تو یہ خلا کو پُر کرنے کے لیے دستیاب مختصر ترین دستاویز کو تراشے گا۔

نتیجے کے طور پر، بغیر کسی پیڈنگ کے 100٪ استعمال حاصل کیا گیا۔ یہ طویل دستاویزات کو تراشنے اور مختصر دستاویزات کو پیڈ کرنے کے سادہ انداز سے کہیں زیادہ تیز ہے۔ سب سے اوپر مسلسل prepare.py یہ جان بوجھ کر آسان ہے۔ تین نمبر اور ترتیب کی لمبائی مجموعی تجرباتی معاہدے کی وضاحت کرتی ہے۔

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

2. `train.py`

یہ ایجنٹ کے پاس فائل ہے۔ اسے قدرتی طور پر چار حصوں میں تقسیم کیا گیا ہے: ماڈل، آپٹیمائزر (میٹرکس وزن کے لیے Muon، ایمبیڈنگز اور اسکیلر پیرامیٹرز کے لیے ایڈم ڈبلیو)، ہائپر پیرامیٹر، اور ٹریننگ لوپ۔ ہم ہر حصے کو یہ سمجھنے کے مقصد کے ساتھ دیکھیں گے کہ وہ کیوں موجود ہیں۔

یہ ماڈل کافی حد تک جدید GPT ہے، شروع سے لکھا گیا ہے جس میں PyTorch اور Flash Attention 3 کرنل کے علاوہ کوئی لائبریری انحصار نہیں ہے۔ اگر آپ نے جی پی ٹی کے دیگر نفاذ کو پڑھا ہے تو، اعلیٰ سطح کا ڈھانچہ مانوس نظر آئے گا: ٹوکن ایمبیڈنگز، ٹرانسفارمر بلاک اسٹیک، نارملائزیشن لیئرز، اور لکیری ہیڈز جو دوبارہ لغوی لاگٹس میں پروجیکٹ کرتے ہیں۔

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

لوپ خود مختصر ہے اور پڑھنے میں تقریباً خوشگوار ہے۔ کنکال مندرجہ ذیل ہے:

while True:
    # accumulate gradient over micro-batches to hit TOTAL_BATCH_SIZE
    for micro_step in range(grad_accum_steps):
        with autocast_ctx:
            loss = model(x, y)
        loss = loss / grad_accum_steps
        loss.backward()
        x, y, epoch = next(train_loader)

    # update LR / momentum / weight decay based on time elapsed
    progress = min(total_training_time / TIME_BUDGET, 1.0)
    # ... set group["lr"], group["momentum"], group["weight_decay"] ...

    optimizer.step()
    model.zero_grad(set_to_none=True)

    # log step metrics
    # ...

    if step > 10 and total_training_time >= TIME_BUDGET:
        break

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

دوسرا، لوپ میں تیزی سے ناکامی کی جانچ ہوتی ہے۔ اگر نقصان پھٹ جاتا ہے یا NaN تک پہنچ جاتا ہے، تو یہ "FAIL” پرنٹ کرتا ہے اور باہر نکل جاتا ہے۔ ایجنٹ پھر تنازعات کی جانچ کرتا ہے اور ان کو لاگ کرتا ہے۔ یہ ان ایجنٹوں کے خلاف دفاع ہے جو نمایاں طور پر مختلف کام انجام دیتے ہیں۔

تیسرا، لوپ ختم ہونے کے بعد، ایک ہی آخری کال ہوتی ہے: evaluate_bpb ایک منظم خلاصہ پھر stdout پر پرنٹ کیا جاتا ہے۔

یہ خلاصہ ٹریننگ اسکرپٹ اور ایجنٹ کے درمیان پورا API ہے۔

---
val_bpb:          0.997900
training_seconds: 300.1
total_seconds:    325.9
peak_vram_mb:     45060.2
mfu_percent:      39.80
total_tokens_M:   499.6
num_steps:        953
num_params_M:     50.3
depth:            8

یہ وہی ہے جو grep نکالتا ہے اور ایجنٹ پڑھتا ہے۔ پورا تجرباتی معاہدہ اس سادہ متن کی سات سطروں پر مشتمل ہے۔

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

Hyperparameters نیچے کے قریب واضح طور پر نشان زد حصے میں واقع ہیں۔ train.pyتبصرہ کہتا ہے "اس میں خود ترمیم کریں، CLI جھنڈوں کی ضرورت نہیں ہے۔” وہ درج ذیل ہیں:

# Model architecture
ASPECT_RATIO = 64       # model_dim = depth * ASPECT_RATIO
HEAD_DIM = 128          # target head dimension for attention
WINDOW_PATTERN = "SSSL" # sliding window pattern: L=full, S=half context

# Optimization
TOTAL_BATCH_SIZE = 2**19 # ~524K tokens per optimizer step
EMBEDDING_LR = 0.6
UNEMBEDDING_LR = 0.004
MATRIX_LR = 0.04
SCALAR_LR = 0.5
WEIGHT_DECAY = 0.2
ADAM_BETAS = (0.8, 0.95)
WARMUP_RATIO = 0.0
WARMDOWN_RATIO = 0.5
FINAL_LR_FRAC = 0.0

# Model size
DEPTH = 8
DEVICE_BATCH_SIZE = 128

یہاں سب کچھ جان بوجھ کر سچائی کا واحد نقطہ ہے۔ ماڈل کا طول و عرض گہرائی ہے (depth × 64سر کے طول و عرض سے گول)۔ سروں کی تعداد ماڈل کے طول و عرض سے شمار کی جاتی ہے۔ اس کا مطلب ہے کہ ایک ایجنٹ صرف ایک نمبر تبدیل کر سکتا ہے۔ DEPTHماڈل خود کو مستقل طور پر ترازو کرتا ہے۔

اس قسم کی "ماڈل اسکیلنگ کے لیے ایک نوب” پیرامیٹرائزیشن بالکل وہی ہے جو تلاش کی جگہ کو قابل عمل بناتی ہے۔

3. `program.md`

program.md یہ تینوں فائلوں میں سے سب سے مختصر ہے اور قابل اعتراض طور پر سب سے اہم ہے۔ یہ وہ فائل ہے جس میں ہم ترمیم کرتے ہیں اور اس میں وہ سب کچھ ہوتا ہے جس کے بارے میں ہمیں جاننے کی ضرورت ہوتی ہے کہ ایجنٹ چلانے کے دوران کیسے برتاؤ کرتا ہے۔

ساخت program.md تحقیقی سیشن کے لائف سائیکل کی عکاسی کرتا ہے۔ یہ اس طرح کھلتا ہے: ترتیب، لانچ ٹیگ سے اتفاق کریں اور گٹ برانچ بنائیں۔ autoresearch/دائرہ کار میں فائل کو پڑھتا ہے، چیک کرتا ہے کہ آیا ڈیٹا موجود ہے، اور نتیجے میں آنے والی فائل کو شروع کرتا ہے۔ اس کے بعد ہم تجرباتی اصولوں کی وضاحت کرتے ہیں، جیسے کہ ایجنٹ کیا کر سکتا ہے اور کیا ترمیم نہیں کر سکتا، VRAM کی نرم رکاوٹیں، اور، اہم طور پر، ایک سادگی کا معیار کہ، باقی تمام چیزیں برابر، آسان ہونا بہتر ہے۔

ایک 0.001bpb بہتری جو ہیکی کوڈ کی 20 لائنوں کا اضافہ کرتی ہے رکھنے کے قابل نہیں ہے۔ 0.001bpb بہتری ہٹا دیں 20 تاریں یقینی طور پر رکھنے کے قابل ہیں۔

پھر اصل لوپ آتا ہے. ایجنٹ کو اس کا استعمال کرتے ہوئے تربیت چلانے کی ہدایت کی جاتی ہے: uv run train.py > run.log 2>&1 اور اسے کبھی استعمال نہ کریں۔ tee متبادل طور پر، آؤٹ پٹ کو سٹریم کریں کیونکہ یہ ایجنٹ کی سیاق و سباق کی ونڈو کو اوور فلو کر دے گا۔ آپ کو یہ استعمال کرتے ہوئے میٹرکس نکالنے کے لیے بھی کہا جائے گا: grep "^val_bpb:|^peak_vram_mb:" run.logصرف ایک یا دو اہم سطریں فراہم کریں۔

اگر grep کچھ پیدا نہیں کرتا ہے، تو یہ چلنا بند کر دیتا ہے اور ایجنٹ کو لاگ کی آخری 50 لائنیں پڑھنے اور مسئلہ کو حل کرنے کی کوشش کرنے کا اشارہ کرتا ہے (لیکن اسے کچھ کوششوں کے بعد ترک کر دینا چاہیے اور آگے بڑھنا چاہیے)۔ تمام تجربات کے نتائج درج کیے گئے ہیں: results.tsv.

فیصلہ کرنے کا اصول سادہ ہے۔ اگر val_bpb بہتر ہوتا ہے (کم ہوتا ہے)، تو ایجنٹ عہد کو برقرار رکھے گا اور برانچ کو آگے بڑھائے گا۔ اگر کوئی بہتری نہیں ہے تو، ایجنٹ کو متحرک کیا جاتا ہے. git reset عہد کو منسوخ کریں۔ اگر کوئی تنازعہ ہوتا ہے، تو ایجنٹ اسے لاگ کرتا ہے اور کچھ اور کرنے کی کوشش کرتا ہے۔

آخری پیراگراف program.md یہ وہی ہے جو خود کار تحقیق کرتا ہے کہ یہ کیا ہے. اس کا ایک عنوان ہے۔ کبھی نہیں روکنا. ایجنٹ کو واضح طور پر ہدایت کی جاتی ہے کہ وہ انسان (صارف) سے نہ پوچھے کہ کیا اسے آگے بڑھنا چاہیے، کسی اجازت کی درخواست نہ کرے، اور تصدیق کے لیے توقف نہ کرے۔ جب ایجنٹوں کے خیالات ختم ہو جاتے ہیں، تو انہیں مزید سوچنا پڑتا ہے، ناکامیوں کو دیکھنا پڑتا ہے، گمشدہ ٹکڑوں کو جوڑنا پڑتا ہے، اور مزید بنیادی تبدیلیوں کی کوشش کرنی پڑتی ہے۔

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

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

کوئی تربیت 5 منٹ سے زیادہ نہیں رہتی ہے۔ ایجنٹ کبھی بھی 5 منٹ کی نئی مشقیں شروع کرنے سے باز نہیں آتے۔

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

سیٹ اپ گائیڈ

ہم فرض کرتے ہیں کہ ہمارے پاس ان تجربات کو چلانے کے لیے کافی VRAM کے ساتھ ایک واحد NVIDIA GPU ہے۔ 24GB سے اوپر کی کوئی بھی چیز ڈیفالٹ سیٹنگز کے ساتھ کام کرے گی۔ چھوٹے GPUs کو کچھ موافقت کی ضرورت ہوتی ہے، جس کا ہم بعد میں احاطہ کریں گے۔

مرحلہ 1: uv انسٹال کریں، Python پروجیکٹ مینیجر جسے Repo استعمال کرتا ہے۔

uv pip سے بہت تیز ہے اور ورچوئل ماحول کو شفاف طریقے سے ہینڈل کرتا ہے۔ انسٹال کرنے کے بعد، ریپوزٹری کو کلون کریں اور انحصار انسٹال کریں۔

curl -LsSf https://astral.sh/uv/install.sh | sh

git clone https://github.com/karpathy/autoresearch.git
cd autoresearch
uv sync

اگر آپ ایسا کرتے ہیں۔ .venv pyTorch، Flash Attention، Rustbpe، tiktoken، pyarrow اور چند دیگر پیکجز انسٹال کرتا ہے۔ PyTorch CUDA 12.8 وہیل انڈیکس سے درآمد کیا گیا ہے، لہذا یقینی بنائیں کہ آپ کا ڈرائیور اس کی حمایت کرتا ہے۔

مرحلہ 2: ڈیٹا کی تیاری چلائیں۔

یہ 10 ClimbMix شارڈز اور ایک توثیق شارڈ ڈاؤن لوڈ کرے گا اور ٹوکنائزر کو تربیت دے گا۔

uv run prepare.py

عام کنکشن پر، اس میں تقریباً 2 منٹ لگتے ہیں۔ اگر آپ کے پاس ڈسک کی محدود جگہ ہے، تو آپ پاس کر سکتے ہیں۔ --num-shards 4 چھوٹے ڈاؤن لوڈز کے لیے۔ ڈیٹا اور ٹوکنائزرز کیش کیے گئے ہیں۔ ~/.cache/autoresearch/.

مرحلہ 3: دستی تربیتی تجربہ چلائیں۔

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

uv run train.py

تقریباً 5 منٹ کی تربیت اور حتمی تشخیص پاس کرنے کے بعد، آپ کو مندرجہ ذیل سمری بلاک ملے گا: val_bpb مطبوعہ۔ یہ آپ کی بنیادی لائن ہے۔

مرحلہ 4: ریپو ایجنٹ کو بھیجیں۔

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

Have a look at program.md and let's kick off a new experiment.
Let's do the setup first.

ایجنٹ آپ کو پڑھ کر سنائے گا۔ program.mdسیٹ اپ کے مراحل سے گزریں (خودکار تحقیقی شاخیں بنانا اور شروع کرنا)۔ results.tsv) تصدیق کریں اور چلنا شروع کریں۔ اس مقام سے، آپ اسے اسی طرح چھوڑ سکتے ہیں۔ واپس آؤ اور اسے چیک کرو results.tsv آٹو ریسرچ برانچ سے گٹ لاگز۔

چھوٹے GPUs کے لیے خودکار شعاع ریزی ایڈجسٹمنٹ

پہلے سے طے شدہ ترتیب H100 فرض کرتی ہے۔ اگر آپ کے پاس 4090، 3090، یا 80GB سے کم VRAM والی کوئی بھی چیز ہے، تو آپ کو فون کا سائز کم کرنا ہوگا۔

سب سے پہلے، ترتیب کی لمبائی کو مختصر کریں. MAX_SEQ_LEN = 2048 کو prepare.py یہ سب سے بڑا VRAM لیور ہے کیونکہ توجہ چوکور طریقے سے پھیلائی جاتی ہے۔ چھوٹے GPUs اور bumps پر 512 یا 256 آزمائیں۔ DEVICE_BATCH_SIZE کو train.py یہ تھوڑا سا معاوضہ دیتا ہے۔ ان دونوں کی پیداوار ٹوکن فی ڈیلیوری پاس ہے۔
گہرائی کو کم کریں: DEPTH = 8 کو train.py ماڈل سائز کے لیے ماسٹر نوب۔ چھوٹے GPUs پر 4 تک نیچے جانے سے ماڈل کی جہت خود بخود کم ہو جاتی ہے۔
ونڈو پیٹرن کو تبدیل کریں۔ WINDOW_PATTERN = "SSSL" کرنل کے نفاذ پر منحصر ہے، یہ بینڈڈ اٹینشن کا استعمال کرتا ہے، جو H100 پر تیز لیکن صارف GPUs پر سست ہو سکتا ہے۔ صرف "L" (ہمیشہ پوری احتیاط کے ساتھ) چھوٹے کارڈز پر اکثر آسان اور تیز ہوتا ہے۔
کل بیچ سائز کو کم کریں۔ TOTAL_BATCH_SIZE = 2**19 تقریباً 524K ٹوکن فی اصلاحی مرحلہ۔ چھوٹے GPUs پر، شروع کرنے کے لیے 2^14 (~16K) پر جائیں۔
ڈیٹا سیٹس کو تبدیل کرنے پر غور کریں۔ climbMix ایک مشکل اور وسیع ویب کارپس ہے۔ چھوٹے ماڈلز میں، نقصان کے منحنی خطوط شور ہوتے ہیں اور بی پی بی نمبروں کی تشریح کرنا مشکل ہوتا ہے۔ کارپتھی اپنے TinyStories-GPT4-Clean ڈیٹاسیٹ کی سفارش کرتا ہے، خاص طور پر چھوٹے پیمانے کے تجربات کے لیے۔ چونکہ متن کی حد (مضمون) کم ہے، ایک چھوٹا ماڈل دراصل 5 منٹ سے بھی کم وقت میں مستقل مواد تیار کرنا سیکھ سکتا ہے۔

پہلے سے ہی کئی کمیونٹی فورک موجود ہیں جنہوں نے صارفین کی GPU ٹیوننگ کی ہے، جو ریپوزٹری میں readme.md فائل میں مل سکتی ہے۔

اصل میں ایجنٹوں نے کیا دریافت کیا۔

یہ بتانا کہ لوپ کیسے کام کرتا ہے ایک چیز ہے، لیکن یہ دیکھنا کہ یہ کیا پیدا کرتا ہے۔ کارپتی نے اس کے بارے میں ٹویٹر پر اپنی گہرائی کے 12 رن کے دوران کھولا۔ ایجنٹ نے تقریباً 20 تبدیلیاں دریافت کیں جن سے توثیق کے نقصان میں بہتری آئی، ان سبھی کو گہرائی 24 میں منتقل کر دیا گیا۔

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

اگرچہ ان میں سے کسی نے بھی سرخیاں نہیں بنائیں، ان سب نے 0.001 اور 0.005 بیس پوائنٹس فی بلین کے درمیان بہتری پیدا کی۔

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

حتمی خیالات

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

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

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

ایک اور سوال ہے۔ انسانوں کا کردار کیا ہے؟. ایک بار جب ایجنٹ تجربہ کر لیتا ہے، انسانی شراکت تلاش کی جگہ اور قواعد کی تشکیل کی طرف بڑھ جاتی ہے۔ وہ کیا ہے program.md ہوں یہ ایک بہت اچھا پیش نظارہ ہے کہ لوپ خودکار ہونے پر تحقیق کیسی نظر آئے گی۔

آج کے لیے اتنا ہی ہے۔ اگلے مضمون میں ملتے ہیں!