جاوا اسکرپٹ میں ارتقائی خودکار ڈرائیونگ کار بنائیں، تربیت دیں اور جانچیں

یہ منصوبہ کیا کرتا ہے

self-driving-car سادہ JavaScript میں لکھی گئی خودکار ڈرائیونگ کی ایک مختصر simulation ہے۔ ایک چھوٹا neural network ارتقا کے ذریعے سیکھتا ہے کہ خم دار تین لین والی شاہراہ پر گاڑی کیسے چلانی ہے، اپنی لین میں رہنا ہے، ٹریفک کے لیے بریک لگانی ہے، اشارہ دینا ہے، آہستہ گاڑیوں کو اوورٹیک کرنا ہے، اور مناسب وقت پر دائیں جانب واپس آنا ہے۔

درست رویہ دکھانے والا کوئی مثالی ڈرائیور موجود نہیں۔ اس کے بجائے، ہر نسل میں neural networks کی ایک آبادی کو اسی سڑک پر بھیجا جاتا ہے۔ جو networks زیادہ فاصلہ طے کرتے ہیں انہیں زیادہ fitness اسکور ملتے ہیں اور وہ اگلی نسل کے والدین بنتے ہیں۔

اس منصوبے میں تقریباً 1,300 لائنوں پر مشتمل ES modules شامل ہیں، جو سڑک، گاڑی کی physics، perception، ٹریفک، neural network، genetic algorithm، planner، rendering، اور user interface کا احاطہ کرتے ہیں۔ runtime dependencies موجود نہیں ہیں، اور browser اور Node.js دونوں میں یہی simulation modules چلتے ہیں۔

آپ live demo کھول کر pretrained ڈرائیور کو دیکھ سکتے ہیں، browser میں ایک آبادی کو evolve کر سکتے ہیں، یا خود گاڑی چلا سکتے ہیں۔

ڈرائیونگ سسٹم کیسے کام کرتا ہے

simulation ہر سیکنڈ میں 60 steps کی مقررہ رفتار سے آگے بڑھتی ہے۔ ہر step پر گاڑی قریبی لینز کو scan کرتی ہے، مشاہدات کو neural network کے 19 inputs میں تبدیل کرتی ہے، اور دو outputs پیدا کرتی ہے: pedal command اور مطلوبہ لین۔

Perception اور Neural Network

یہ network camera pixels یا فاصلے کی خام شعاعوں پر کارروائی نہیں کرتا۔ اسے ایسی منظم معلومات ملتی ہیں جیسی perception stack کسی driving planner کو فراہم کر سکتا ہے:

• کیا بائیں، موجودہ، اور دائیں لینز موجود ہیں۔
• ہر متعلقہ لین میں آگے اور پیچھے موجود قریب ترین گاڑی۔
• ہر gap کتنی تیزی سے کم ہو رہا ہے۔
• سیکھنے والی گاڑی کی موجودہ رفتار۔
• اگلے 100 meters میں سب سے تیز curve۔
• lane-change planner کی موجودہ حالت۔

اس architecture کی ساخت 19 · 12 · 8 · 2 ہے، یہ tanh activations استعمال کرتا ہے، اور اس میں 362 weights ہیں۔ ایک output pedal کو کنٹرول کرتا ہے۔ دوسرا output لین منتخب کرتا ہے: +0.5 سے زیادہ قدر بائیں لین کی درخواست کرتی ہے، جبکہ -0.5 سے کم قدر دائیں لین کی درخواست کرتی ہے۔

Planner اور Vehicle Model

neural network یہ فیصلہ کرتا ہے کہ کب اور کہاں حرکت کرنی ہے، لیکن براہِ راست steering نہیں کرتا۔ ہاتھ سے لکھا گیا planner لین کی درخواست کو ایک محفوظ، ہموار maneuver میں تبدیل کرتا ہے۔ یہ 0.7 seconds تک signal دیتا ہے، ہدف لین کو check کرتا ہے، 2.6 seconds تک quintic S-curve کی پیروی کرتا ہے، اور planned path کو track کرنے کے لیے pure-pursuit steering استعمال کرتا ہے۔

اگر کوئی دوسری گاڑی گاڑی کے برابر آ جائے یا اس کے blind spot میں داخل ہونے والی ہو، تو planner signal جاری رکھتا ہے اور gap کھلنے کا انتظار کرتا ہے۔ signaling phase کے دوران request چھوڑنے سے maneuver منسوخ ہو جاتا ہے۔

گاڑی خود SI units میں kinematic bicycle model استعمال کرتی ہے۔ اس کے parameters ایک family hatchback سے مشابہ ہیں: لمبائی 4.4 meters، 0 سے 100 km/h تک 9.8 seconds، زیادہ سے زیادہ رفتار 115 km/h، اور 8 m/s² تک braking۔ دستیاب cornering grip یہ محدود کرتی ہے کہ گاڑی bend کتنی تیزی سے لے سکتی ہے۔

Traffic، Fitness، اور Evolution

پسِ منظر کی ٹریفک Intelligent Driver Model کی پیروی کرتی ہے۔ گاڑیوں کی مطلوبہ رفتار 61 اور 94 km/h کے درمیان ہوتی ہے، وہ بائیں جانب سے اوورٹیک کرتی ہیں، گزرنے کے بعد دائیں جانب واپس آتی ہیں، لین بدلنے سے پہلے signal دیتی ہیں، اور سیکھنے والی گاڑی کے ردِعمل میں حرکت کرتی ہیں۔

Fitness بنیادی طور پر طے کیے گئے meters کی تعداد ہے۔ اگر گاڑی crash ہو جائے یا سڑک پر آگے بڑھنے والی کسی سست line کی زد میں آ جائے تو اس کے 300 points کم ہو جاتے ہیں۔ دائیں جانب کی لین واضح طور پر خالی ہونے کے باوجود بائیں لین میں گزارے گئے ہر second کے لیے بھی چار meters کم کیے جاتے ہیں۔ اوورٹیک کرنے کا کوئی براہِ راست reward نہیں ہے؛ گزرنا اس لیے مفید بنتا ہے کہ اس سے گاڑی زیادہ فاصلہ طے کر سکتی ہے۔

Evolution میں چار بنیادی techniques استعمال ہوتی ہیں:

• Elitism: command-line training میں بہترین چار networks بغیر تبدیلی کے اگلی نسل میں منتقل ہوتے ہیں۔
• Tournament selection: مضبوط networks کے والدین بننے کا امکان زیادہ ہوتا ہے۔
• BLX-0.25 crossover: offspring بنانے کے لیے والدین کے weights کو blend کیا جاتا ہے۔
• Gaussian mutation: mutation rate اور magnitude، 40-generation half-life کے ساتھ کم ہوتے جاتے ہیں۔

Installation اور Local Setup

repository کو clone کریں اور اس کا local static server شروع کریں:

git clone https://github.com/Stxqq/self-driving-car.git
cd self-driving-car
npm run serve

serve command، port 5101 پر Python HTTP server شروع کرتا ہے۔ اپنے browser میں http://localhost:5101 کھولیں۔

انسٹال کرنے کے لیے کوئی packages نہیں ہیں۔ کوئی بھی static web server اس منصوبے کو host کر سکتا ہے، لیکن صفحہ براہِ راست file:// کے ذریعے کھولنے سے کام نہیں کرے گا، کیونکہ browsers اس context میں ES modules کو محدود کرتے ہیں۔

test اور command-line scripts کے لیے Node.js 22 یا اس سے نیا ورژن درکار ہے۔ test suite اس command کے ساتھ چلائیں:

npm test

Browser Interface استعمال کرنا

Pretrained Driver دیکھیں

watch experience استعمال کر کے shipped network کو ٹریفک میں گاڑی چلاتے ہوئے دیکھیں۔ صفحہ اس کے inputs، outputs، planned route، lane-change state، اور vehicle statistics کو دکھاتا ہے۔ نیلی ribbon planner کے تیار کردہ path کی نمائندگی کرتی ہے۔

Manual Drive کریں

Drive mode میں آپ اسی planner کو برقرار رکھتے ہوئے neural network کی جگہ خود کنٹرول سنبھالتے ہیں۔ گاڑی 70 km/h پر cruise control کے ساتھ شروع ہوتی ہے۔

• set speed بڑھانے کے لیے ↑ کو دبائے رکھیں۔
• بریک لگانے اور set speed کم کرنے کے لیے ↓ دبائیں۔
• بائیں جانب lane change کی درخواست کے لیے ← دبائیں۔
• دائیں جانب lane change کی درخواست کے لیے → دبائیں۔

network card یہ دکھانا جاری رکھتا ہے کہ pretrained brain کیا کرتا، جس سے یہ mode آپ کے فیصلوں کا اس کے فیصلوں سے موازنہ کرنے کے لیے مفید بن جاتا ہے۔

Browser میں Train کریں

ٹرین موڈ بے ترتیب نیٹ ورک وزن کے ساتھ 60 گاڑیاں شروع کرتا ہے۔ ہر نسل کے دوران تمام گاڑیاں ایک ہی سڑک استعمال کرتی ہیں، اور پہلے 15 نسلوں میں ٹریفک بتدریج شامل ہوتی ہے۔ ابتدائی راؤنڈ 45 سیکنڈ سے شروع ہوتے ہیں۔ جب کوئی گاڑی اختتام تک زندہ رہتی ہے تو بعد کے راؤنڈز کی مدت نصف کے حساب سے بڑھتی ہے، یہاں تک کہ زیادہ سے زیادہ مدت پانچ منٹ ہو جائے۔

براؤزر ٹریننگ تیزی سے لین میں رہنے اور پیروی کرنے کا رویہ دریافت کر لیتی ہے، لیکن اوورٹیک کرنا کہیں زیادہ مشکل ہے۔ پروجیکٹ میں بیان کیے گئے ٹیسٹوں سے معلوم ہوا کہ بے ترتیب طور پر شروع کی گئی آبادیوں نے عموماً نسل 15 تک فی کلومیٹر صرف 0.1 سے 0.5 لین تبدیلیاں کیں۔ اصل پہلے سے تربیت یافتہ ڈرائیور کو فائدہ مند لین تبدیلیاں پیدا کرنے سے پہلے 200 کی آبادی کے ساتھ تقریباً 170 نسلوں کی ضرورت پڑی۔

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

کمانڈ لائن سے ٹریننگ

کمانڈ لائن ٹریننگ ورکر تھریڈز میں بغیر گرافیکل انٹرفیس کے چلتی ہے۔ درج ذیل مثال 120 نیٹ ورکس کی آبادی کو 10 نسلوں تک تربیت دیتی ہے اور ہر نیٹ ورک کو 60 سیکنڈ کے ایپی سوڈز میں تین مخصوص بیج والی سڑکوں پر جانچتی ہے:

node scripts/train.mjs --generations 10 --population 120 --seeds 3 --seconds 60

بطور ڈیفالٹ، نتیجے میں بننے والا دماغ runs/brain.json میں لکھا جاتا ہے۔ اس طرح تجربات بھیجے گئے نیٹ ورک src/brains/pretrained.json سے الگ رہتے ہیں۔

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

کارآمد ٹریننگ اختیارات

• --density ٹریفک کی مقدار تبدیل کرتا ہے۔
• --resume --out سے متعین راستے پر موجود دماغ سے شروع کرتا ہے اور زیادہ ہلکی تبدیلیاں استعمال کرتا ہے۔
• --generations ارتقائی راؤنڈز کی تعداد متعین کرتا ہے۔
• --population ہر نسل میں جانچے جانے والے دماغوں کی تعداد متعین کرتا ہے۔
• --seeds استعمال کیے جانے والے سڑک کے بیجوں کی تعداد متعین کرتا ہے۔
• --seconds ہر ایپی سوڈ کی مدت مقرر کرتا ہے۔

بھیجے گئے دماغ کے لیے استعمال کیا گیا ٹریننگ عمل scripts/curriculum.sh میں درج ہے۔ یہ مکمل ٹریفک میں دو منٹ کے ایپی سوڈز سے شروع ہو کر زیادہ سڑکوں پر پانچ منٹ کے ایپی سوڈز تک بڑھتا ہے، پھر دائیں جانب رہنے کی باریک تربیت کے مرحلے پر ختم ہوتا ہے۔ پروجیکٹ کی دستاویزات کے مطابق، اس نصاب کو 14 کور والے لیپ ٹاپ پر تقریباً ایک گھنٹہ لگا۔

تربیت یافتہ دماغ کی جانچ

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

node scripts/evaluate.mjs --seeds 9001,9002,9003,9004,9005

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

بھیجے گئے دماغ کے بجائے کسی برآمد شدہ یا نئے تربیت یافتہ نیٹ ورک کی جانچ کے لیے اس کی JSON فائل --brain کے ساتھ دیں:

node scripts/evaluate.mjs --brain runs/brain.json --seeds 9001,9002,9003

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

npm run evaluate -- --write

یہ کمانڈ scripts/results.json لکھتی ہے، جسے براؤزر انٹرفیس بھی پڑھتا ہے۔

شائع شدہ نتائج کو سمجھنا

بھیجے گئے 362 وزن والے نیٹ ورک کو مکمل ٹریفک میں 30 الگ رکھے گئے بیجوں پر پانچ منٹ تک جانچا گیا۔ اس نے 6.90 کلومیٹر کا اوسط فاصلہ، 7.23 کلومیٹر کا درمیانی فاصلہ، اور 87 کلومیٹر فی گھنٹہ کی اوسط رفتار حاصل کی۔ 30 میں سے 28 رنز پانچ منٹ بعد بھی فعال تھے، اور گاڑی نے فی کلومیٹر اوسطاً 5.1 لین تبدیلیاں کیں۔

پروجیکٹ اس نظام کا موازنہ ایک پہلے کے ورژن سے کرتا ہے جو 14 شعاعی سینسرز سے براہ راست اسٹیئرنگ کرتا تھا۔ اس پرانے نیٹ ورک نے اوسطاً 4.05 کلومیٹر اور 56 کلومیٹر فی گھنٹہ حاصل کیا، جبکہ 30 میں سے 20 رنز پانچ منٹ بعد بھی فعال تھے۔ یہ موازنہ ایک کنٹرول شدہ معیار نہیں ہے کیونکہ ٹریفک ماڈل بھی تبدیل ہوا تھا، لیکن یہ واضح کرتا ہے کہ سیکھی ہوئی فیصلہ سازی کو منصوبہ بند اسٹیئرنگ سے الگ کرنے سے اوورٹیکنگ دریافت کرنا کیوں آسان ہوا۔

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

اعلیٰ درجے کی تجاویز

اوورفٹنگ کم کرنے کے لیے متعدد بیج استعمال کریں

ایک سڑک پر اچھی کارکردگی دکھانے والا دماغ دوسری سڑک پر ناکام ہو سکتا ہے۔ ٹریننگ کے بیجوں کی تعداد بڑھائیں اور توثیق اور حتمی جانچ کے لیے الگ بیج محفوظ رکھیں۔ بغیر گرافیکل انٹرفیس والا ٹرینر ہر دماغ کو اس کی سڑک پر اکیلے جانچتا ہے کیونکہ ٹریفک سیکھنے والی گاڑی پر ردعمل ظاہر کرتی ہے؛ اس سے ایک امیدوار کا رویہ دوسرے امیدوار کے اسکور کو تبدیل نہیں کرتا۔

دوبارہ شروع کریں، ابتدا سے نہیں

اگر تربیت یافتہ دماغ پہلے ہی لین میں رہتا ہے اور ٹریفک سے بچتا ہے تو --resume یا براؤزر کا پہلے سے تربیت یافتہ اختیار استعمال کریں۔ بے ترتیب وزن سے شروع کرنا ابتدا سے ارتقا کا مشاہدہ کرنے کے لیے موزوں ہے، لیکن پیچیدہ اوورٹیکنگ رویے کے لیے کہیں زیادہ نسلوں اور بڑی آبادیوں کی ضرورت پڑ سکتی ہے۔

مشکل بتدریج بڑھائیں

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

تعین پذیری برقرار رکھیں

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

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

• src/sim/ میں سڑک، کار، ادراک، منصوبہ ساز، ٹریفک، دنیا، دماغ اور ارتقا کا کوڈ موجود ہے، جس میں DOM انحصارات شامل نہیں ہیں۔
• src/render/ میں کینوس اسٹیج، نیٹ ورک ویژولائزیشن، جسمانی ساخت کا ڈسپلے اور چارٹ موجود ہیں۔
• src/ui/ میں واچ، ٹرین اور ڈرائیو سیشنز، اسٹوریج اور کی بورڈ ہینڈلنگ موجود ہے۔
• src/brains/ میں پہلے سے تربیت یافتہ نیٹ ورک موجود ہے۔
• scripts/ میں تربیت، نصاب، جانچ اور نتائج کی فائلیں موجود ہیں۔
• test/ میں Node.js ٹیسٹس موجود ہیں، جن میں محفوظ رکھے گئے ری پلے چیکس بھی شامل ہیں۔

نتیجہ

یہ پروجیکٹ ظاہر کرتا ہے کہ ایک بہت چھوٹا نیورل نیٹ ورک کس طرح اعلیٰ سطح کے ڈرائیونگ فیصلے سیکھ سکتا ہے، جب کہ ایک روایتی منصوبہ ساز درست اسٹیئرنگ اور لین تبدیل کرنے کے عمل کو سنبھالتا ہے۔ پہلے براؤزر ڈیمو چلائیں، دستی اور نیورل فیصلوں کا موازنہ کریں، پھر اپنے دماغوں کو تربیت دینے اور جانچنے کے لیے Node.js اسکرپٹس استعمال کریں۔ اس کا انحصار سے پاک نفاذ اور متعین simulation اسے ارتقائی سیکھنے، گاڑیوں کے ماڈلز، ٹریفک کے رویے اور منصوبہ بندی کے مطالعے کے لیے ایک عملی کوڈ بیس بھی بناتے ہیں۔