فلیئر کیا ہے؟
فلیئر ایک مقامی inference سرور ہے جو خاص طور پر NVIDIA SM120 اور SM121 GPUs کے لیے تیار کیا گیا ہے۔ یہ طویل گفتگوؤں، کوڈنگ ایجنٹس، اور ایسے کاموں کو ہدف بناتا ہے جن میں ٹولز کو بار بار استعمال کیا جاتا ہے۔ اس کا بنیادی مقصد ورک اسٹیشن اور کمپیکٹ سسٹم کے وسائل کو مؤثر طور پر استعمال کرتے ہوئے متن کی تیاری کو جواب دہ رکھنا ہے۔
ان serving پلیٹ فارمز کے برعکس جو وسیع مطابقت کو ترجیح دیتے ہیں، فلیئر منتخب ماڈلز، ہارڈویئر، kernels، اور deployment patterns کے گرد بنائے گئے ایک مرکوز contract کا استعمال کرتا ہے۔ یہ محدود دائرہ ماڈل کی تیاری، memory management، scheduling، اور execution کو باہم مربوط انداز میں ڈیزائن کرنے کی اجازت دیتا ہے۔
فلیئر اس وقت سب سے زیادہ موزوں ہے جب اس کے معاون model recipes، پہلے سے تیار کردہ capacities، اور NVIDIA ہارڈویئر کی ضروریات آپ کے مقامی workload سے مطابقت رکھتی ہوں۔
آرکیٹیکچر کیسے کام کرتا ہے
فلیئر ماڈل کی تیاری اور runtime serving کو دو بنیادی اجزا میں تقسیم کرتا ہے: Ignition اور Helios۔
Ignition: build-time ماڈل کی تیاری
Ignition معیاری Python machine-learning ecosystem میں کام کرتا ہے۔ یہ ماڈلز لوڈ کرنے، kernels کو tune کرنے، forward passes compile کرنے، اور CUDA graphs capture کرنے کے لیے PyTorch، Transformers، اور FlashInfer/b12x استعمال کرتا ہے۔
اس کا نتیجہ ایک تیار شدہ runtime package ہوتا ہے۔ Compilation اور CUDA graph capture serving شروع ہونے سے پہلے مکمل ہو جاتے ہیں، اس لیے production runtime کو تیاری کے یہ مراحل انجام دینے کی ضرورت نہیں ہوتی۔
Helios: Rust پر مبنی serving
Helios وہ Rust runtime ہے جو Ignition کے تیار کردہ package کو serve کرتا ہے۔ یہ Python کے بغیر چلتا ہے اور scheduling، cache storage، request handling، اور runtime resources کی واضح ملکیت کا ذمہ دار ہے۔
Model recipe
-> Ignition preparation
-> kernel tuning and forward compilation
-> CUDA graph capture
-> runtime package
-> Helios servingیہ حد ماڈل development کو مانوس Python tools سے مربوط رکھتی ہے، جبکہ serving runtime کو مختصر اور مرکوز رکھتی ہے۔
اہم خصوصیات
- مرکوز NVIDIA support: فلیئر accelerators کی وسیع رینج کے بجائے NVIDIA SM120 اور SM121 GPUs کے لیے تیار کیا گیا ہے۔
- Build time پر Python: ماڈل کی تیاری PyTorch، Transformers، اور FlashInfer/b12x استعمال کرتی ہے۔
- Runtime پر Rust: Helios Python کے بغیر تیار شدہ packages کو serve کرتا ہے۔
- Serving سے پہلے optimization: Kernel tuning، forward compilation، اور CUDA graph capture requests serve ہونے سے پہلے مکمل ہو جاتے ہیں۔
- واضح memory planning: Buffers اور execution capacities کی پہلے سے منصوبہ بندی کی جاتی ہے۔
- مکمل conversation state: فلیئر recurrent state اور KV caches کو درست reuse، branching، اور resumption کے لیے ایک متحد conversation state سمجھتا ہے۔
- Recipe-driven ماڈل support: Model recipes ماڈل computation کی وضاحت کرتی ہیں اور ضرورت کے مطابق layouts یا execution کو مخصوص بناتی ہیں۔
- مقامی workload پر توجہ: یہ نظام مقامی مشینوں پر طویل sessions، coding agents، اور بار بار tool use کے لیے بنایا گیا ہے۔
ضروریات اور setup
فلیئر استعمال کرنے کی کوشش سے پہلے تصدیق کریں کہ آپ کا environment اس کے دانستہ طور پر محدود دائرہ کار سے مطابقت رکھتا ہے۔
- GPU architecture کی تصدیق کریں۔ فلیئر NVIDIA SM120 اور SM121 GPUs کو ہدف بناتا ہے۔ README دیگر GPU architectures کے لیے support کا دعویٰ نہیں کرتا۔
- معاون model recipe منتخب کریں۔ فلیئر universal model compatibility کا وعدہ نہیں کرتا۔ ماڈل کو دستیاب recipe اور اس کے متوقع dataflow سے مطابقت رکھنی چاہیے۔
- Runtime capacities کی منصوبہ بندی کریں۔ اپنی متوقع conversations اور requests کے لیے درکار buffer اور execution capacities متعین کریں۔
- Python build environment تیار کریں۔ ماڈل کی تیاری کے دوران Ignition کو PyTorch، Transformers، اور FlashInfer/b12x درکار ہوتے ہیں۔
- Model package تیار کریں۔ ماڈل لوڈ کرنے، kernels tune کرنے، forward execution compile کرنے، اور CUDA graphs capture کرنے کے لیے Ignition استعمال کریں۔
- Helios کے ساتھ serve کریں۔ تیاری مکمل ہونے کے بعد حاصل شدہ runtime package کو Rust serving runtime فراہم کریں۔
README میں installation commands، dependency versions، یا launch flags فراہم نہیں کیے گئے۔ مستند طریقۂ کار کے لیے repository کی model preparation and serving guide کی پیروی کریں۔ Configuration کی تفصیلات کے لیے CLI guide استعمال کریں۔
بنیادی استعمال کا workflow
فلیئر کا بنیادی workflow پہلے preparation اور پھر serving پر مشتمل ہے۔ درج ذیل مثال conceptual ہے، قابلِ اجرا CLI syntax نہیں، کیونکہ README مخصوص commands کی وضاحت نہیں کرتا۔
مرحلہ 1: مطابقت رکھنے والا ماڈل منتخب کریں
ایسے ماڈل سے شروع کریں جسے Flare recipe میں شامل کیا گیا ہو۔ Recipes ماڈل computation کی مالک ہوتی ہیں اور اس وقت canonical model implementations کو دوبارہ استعمال کر سکتی ہیں جب ان کا dataflow موزوں ہو۔ جہاں مختلف layouts یا execution behavior درکار ہو، recipe ان حصوں کو مخصوص بناتی ہے۔
مرحلہ 2: مطلوبہ capacities طے کریں
اس workload کا اندازہ لگائیں جسے تیار شدہ package کو support کرنا ہوگا۔ Conversation length، concurrent execution کی ضروریات، cache use، recurrent state، اور بار بار ہونے والی tool interactions کو مدنظر رکھیں۔ فلیئر توقع کرتا ہے کہ اہم buffers اور capacities کی serving سے پہلے منصوبہ بندی کی جائے گی۔
مرحلہ 3: Runtime package بنائیں
Ignition کے ذریعے preparation process چلائیں۔ اس مرحلے پر فلیئر مہنگا setup work انجام دینے کے لیے Python ecosystem استعمال کرتا ہے۔
Input:
supported model recipe
model parameters
planned execution capacities
Ignition performs:
model loading
kernel tuning
forward compilation
CUDA graph capture
Output:
prepared runtime packageمرحلہ 4: Helios شروع کریں
تیار کردہ پیکیج کو پیش کرنے کے لیے Helios کو ترتیب دیں۔ Helios کو پیش کرنے والے رن ٹائم میں Python کی ضرورت کے بغیر درخواستوں کی پروسیسنگ، شیڈولنگ، اور کیش اسٹوریج سنبھالتا ہے۔ حقیقی ترتیب کے اختیارات اور لانچ انٹرفیس کے لیے CLI دستاویزات سے رجوع کریں۔
مرحلہ 5: مطلوبہ ورک لوڈ آزمائیں
حقیقت پسندانہ طویل گفتگوؤں، کوڈنگ ایجنٹ سیشنز، اور ٹول کے استعمال کے انداز کے ساتھ Flare کی جانچ کریں۔ ایک مختصر مصنوعی پرامپٹ شاید وہی اسٹیٹ مینجمنٹ، میموری ٹریفک، یا شیڈولنگ رویہ ظاہر نہ کرے جس کے لیے Flare بنایا گیا ہے۔
گفتگو کی حالت کو سمجھنا
Flare گفتگو کی حالت کو صرف KV کیش سے زیادہ سمجھتا ہے۔ جب کوئی ماڈل recurrent state بھی استعمال کرے، تو اس حالت کو کیش کے ساتھ ہم وقت رہنا چاہیے۔ Flare ان عناصر کو مجموعی اکائی کے طور پر منظم کرتا ہے، تاکہ دوبارہ استعمال، شاخ بندی، اور بحالی جیسی کارروائیوں میں مکمل گفتگو درست طور پر برقرار رہے۔
یہ ڈیزائن ایجنٹس کے لیے خاص طور پر اہم ہے۔ کوئی ایجنٹ ٹول کے نتیجے کے لیے رک سکتا ہے، متبادل راستوں کا جائزہ لیتے ہوئے شاخ بنا سکتا ہے، یا پہلے کے سیشن کو دوبارہ شروع کر سکتا ہے۔ ماڈل کی حالت کے صرف ایک حصے کو برقرار رکھنے سے تسلسل کا رویہ غلط ہو سکتا ہے۔
اعلیٰ درجے کی تجاویز
اپنی حقیقی مطلوبہ گنجائش کے لیے تیاری کریں
چونکہ عمل درآمد کی گنجائشیں اور بفرز پہلے سے طے کیے جاتے ہیں، اس لیے تیاری کے انتخاب براہِ راست اس بات پر اثرانداز ہوتے ہیں کہ کیا پیش کیا جا سکتا ہے۔ یہ فرض نہ کریں کہ ہر سیاقی لمبائی، ہم وقتی سطح، یا ماڈل کی ترتیب کے لیے ایک ہی پیکیج موزوں ہے۔ پروجیکٹ کی دستاویزات میں دیے گئے گنجائش کے اصولوں پر عمل کریں۔
کمپائلیشن کو پیش کرنے کے راستے سے باہر رکھیں
پروڈکشن سروس شروع کرنے سے پہلے Ignition کو کرنل ٹیوننگ، فارورڈ کمپائلیشن، اور CUDA گراف کیپچر مکمل کرنے دیں۔ یہ علیحدگی Flare کے ڈیزائن کا بنیادی حصہ ہے، محض اختیاری بہتری نہیں۔
حالت کو ایک جامع اکائی سمجھیں
گفتگو کے دوبارہ استعمال، شاخ بندی، یا بحالی کو نافذ کرتے وقت Flare کی زیرِ انتظام مکمل حالت برقرار رکھیں۔ ایسی انٹیگریشنز بنانے سے گریز کریں جو یہ فرض کریں کہ KV کیش ہمیشہ ماڈل کی واحد مستقل حالت ہے۔
ترکیبات کو ماڈل کی حد کے طور پر استعمال کریں
ماڈل سے متعلق حساب کتاب کو ماڈل کی ترکیبات میں رکھیں اور شیڈولنگ، درخواستوں کی ہینڈلنگ، اور کیش اسٹوریج رن ٹائم کے سپرد کریں۔ یہ ذمہ داریوں کی Flare کی تقسیم کے مطابق ہے اور مشترکہ رن ٹائم کو اپنے بنیادی کام پر مرکوز رکھنے میں مدد دیتی ہے۔
اپنے حقیقی ورک لوڈ کے مطابق بینچ مارک کریں
Rust وسائل کی واضح ملکیت فراہم کرتا ہے، لیکن صرف عمل درآمد کی زبان زیادہ انفیرنس کارکردگی کی ضمانت نہیں دیتی۔ GPU حساب، میموری ٹریفک، شیڈولنگ، ماڈل کا ڈھانچہ، اور ورک لوڈ کی ساخت بدستور اہم ہیں۔
وسیع تر ماڈل، ہارڈویئر، یا تعیناتی کی معاونت کے لیے Flare کا vLLM سے موازنہ کریں۔ دونوں نظام CUDA گراف استعمال کر سکتے ہیں، لیکن دائرۂ کار اور ڈیزائن کے بارے میں ان کے سمجھوتے مختلف ہیں۔ عین اسی ماڈل، گفتگو کے انداز، گنجائش، اور مشین پر بینچ مارک کریں جسے آپ تعینات کرنے کا ارادہ رکھتے ہیں۔
ڈیزائن کی دستاویزات پڑھیں
یہ سمجھنے کے لیے کہ رن ٹائم، ماڈل کی ترکیبات، حالت کا انتظام، اور شیڈولنگ کی حدود اس طرح کیوں ترتیب دی گئی ہیں، ریپوزٹری کی بنیادی ڈیزائن کی دستاویزات سے رجوع کریں۔
نتیجہ
Flare NVIDIA SM120 اور SM121 GPUs پر منتخب ماڈلز کے لیے ایک مخصوص مقامی انفیرنس راستہ فراہم کرتا ہے۔ Ignition مانوس Python ٹولز کے ساتھ بہتر بنائے گئے رن ٹائم پیکیجز تیار کرتا ہے، جبکہ Helios انہیں ایک مختصر Rust رن ٹائم کے ذریعے پیش کرتا ہے۔ اس کا بہترین استعمال ایسے منصوبہ بند مقامی ورک لوڈ میں ہے جس میں طویل گفتگوئیں، کوڈنگ ایجنٹس، بار بار ٹول کا استعمال، اور میموری و گفتگو کی حالت کا واضح انتظام شامل ہو۔