हम एक CPU की सीमाओं को कितना आगे बढ़ा सकते हैं?

हम एक CPU की सीमाओं को कितना आगे बढ़ा सकते हैं?

वर्षों से, "डीप लर्निंग चलाएं" का जवाब एक ही रहा है: एक GPU खरीदें। लेकिन यह जवाब एक मौलिक सवाल को नजरअंदाज करता है — हम उस हार्डवेयर का वास्तव में कितना उपयोग कर रहे हैं, और कितना फ्रेमवर्क ओवरहेड पर बर्बाद कर रहे हैं?

बाहरी लाइब्रेरीज़ के ब्लोटवेयर से मुक्त होकर और अधिकतम दक्षता के साथ हार्डवेयर की पूरी शक्ति का उपयोग करने के लिए, मैं अपनी इंजीनियरिंग यात्रा और ओपन-सोर्स प्रोजेक्ट साझा कर रहा हूं: pdefa (hasnard/pdefa)।

pdefa क्या है?

pdefa एक डीप लर्निंग इन्फरेंस इंजन है जिसे मैंने C++20 और AVX2 SIMD आर्किटेक्चर का उपयोग करके शुरू से बनाया है, ताकि मॉडलों को सीधे CPU पर चलाया जा सके — कोई GPU आवश्यक नहीं, कोई भारी रनटाइम नहीं, एक भी इन्फरेंस चलाने से पहले सुलझाने के लिए कोई निर्भरता ट्री नहीं।

मेरी मुख्य प्रेरणा सरल थी: यह अनुभव करना कि सिस्टम संसाधनों को पूर्ण दक्षता के साथ कैसे प्रबंधित किया जा सकता है, और इस अल्ट्रा-लाइटवेट आर्किटेक्चर को AGPL-3.0 लाइसेंस के तहत पारिस्थितिकी तंत्र में लाना, वास्तविक ओपन-सोर्स दर्शन के प्रति बिना समझौता किए सच्चा रहना।

आखिर CPU इन्फरेंस की परवाह क्यों करें?

क्योंकि अधिकांश वास्तविक दुनिया की तैनातियों में समर्पित GPU का विलासिता नहीं है। एज डिवाइस, एम्बेडेड सिस्टम, CI पाइपलाइन, छोटे VPS इंस्टेंस, फैक्ट्री-फ्लोर मशीनें, और अकादमिक क्लस्टर सभी CPU पर चलते हैं। उन वातावरणों में, फ्रेमवर्क ओवरहेड का हर मेगाबाइट और हर अनावश्यक निर्भरता एक लागत है — मेमोरी में, स्टार्टअप समय में, तैनाती जटिलता में।

एक 300 MB का फ्रेमवर्क जो एक दर्जन साझा लाइब्रेरीज़ खींचता है, "मुफ्त" नहीं है। यह एक कर है जो आप हर तैनाती पर चुकाते हैं।

प्रमुख तकनीकी विशेषताएं:

*- अल्ट्रा-लाइटवेट आकार
संकलित नेटिव बाइनरी केवल 320 KB है। मेगाबाइट्स में ब्लोट नहीं, पहले इंस्टॉल करने के लिए कोई रनटाइम नहीं — बस इन्फरेंस चलाने के लिए जो आवश्यक है।

*- शून्य बाहरी निर्भरताएं
Python इंटरफेस केवल अंतर्निहित ctypes मॉड्यूल पर निर्भर करता है। कोई pip install नहीं, कोई संस्करण संघर्ष नहीं, कोई वर्चुअल एनवायरनमेंट जिम्नास्टिक्स नहीं।

*- हार्डवेयर अनुकूलन
AVX2 निर्देश सेट का उपयोग करके वेक्टरकृत प्रसंस्करण क्षमता को अधिकतम करता है और थ्रेड संख्या पर सीधा नियंत्रण देता है — ताकि आप इसे उस सटीक CPU पर ट्यून कर सकें जिस पर आप चला रहे हैं।

*- व्यापक आर्किटेक्चर समर्थन
YOLO (v8 से v12), ResNet, MobileNet, EfficientNet, और DeepLabV3 आर्किटेक्चर को तुरंत चलाने में सक्षम।

*- अंतर्निहित छवि प्रसंस्करण
इसका अपना PNG/JPEG लोडर और एक अंतर्निहित YOLO पोस्ट-प्रोसेसिंग एल्गोरिदम है, जो OpenCV जैसी भारी लाइब्रेरीज़ की आवश्यकता को पूरी तरह से बायपास करता है।

*- लचीला रूपांतरण वर्कफ़्लो
अपने मौजूदा PyTorch मॉडलों को मानक ONNX प्रारूप में निर्यात करें, फिर इंजन के अंतर्निहित कनवर्टर का उपयोग करके उन्हें pdefa के कस्टम, कम-विलंबता .engine प्रारूप में सहजता से अनुवाद करें।

विकास रोडमैप:

मैं जल्द ही pytorchtoengine टूल जारी करूंगा, जो PyTorch उपयोगकर्ताओं को ONNX मध्यवर्ती चरण को पूरी तरह से बायपास करने और मॉडलों को सीधे इंजन के मूल प्रारूप में परिवर्तित करने की अनुमति देगा। एक कम छलांग, डीबग करने के लिए एक कम चीज।

यह किसके लिए है:

मुझे आशा है कि यह संसाधन-सीमित सर्वर, एज डिवाइस, या हल्के सिस्टम के साथ काम करने वाले डेवलपर्स के लिए एक शक्तिशाली विकल्प के रूप में काम करेगा — कोई भी जिसने कभी सोचा हो "मुझे बस इस मॉडल को चलाना है, मुझे इसके लिए पूरे पारिस्थितिकी तंत्र की आवश्यकता नहीं है।"

यहां से कहां जाएं:

रिपॉजिटरी खुली है। कोड आर्किटेक्चर पर प्रतिक्रिया वास्तव में स्वागत है — विशेष रूप से उन लोगों से जिन्होंने समान सिस्टम बनाए हैं या समान दीवारों से टकराए हैं। और अगर यह आपके साथ प्रतिध्वनित होता है, तो एक स्टार परियोजना का समर्थन करने में बहुत मदद करता है।

Github

$code = @'
 import pdefa
 import cv2

 model = pdefa.load('D:/PROJE/yolov8s.engine')
 img_path = 'D:/PROJE/bus.jpg'
 boxes = model(img_path, conf_thres=0.75)
 img = cv2.imread(img_path)

 class_names = {0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 5: 'bus', 7: 'truck'}

 for b in boxes:
    cls = int(b['cls'])
    conf = b['conf']
    x1, y1 = int(b['x1']), int(b['y1'])
    x2, y2 = int(b['x2']), int(b['y2'])

    names_attr = getattr(model, 'names', {})
    cls_name = class_names.get(cls, names_attr.get(cls, f'cls_{cls}'))

    label = f'{cls_name} {conf:.2f}'

   cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
   cv2.putText(img, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2, cv2.LINE_AA)

print(f'{cls_name} | conf={conf:.3f} | box=[{x1}, {y1}, {x2}, {y2}]')

cv2.imwrite('D:/PROJE/output_bus.png', img)
'@