Cloud APIs जोपर्यंत सोयीस्कर आहेत तोपर्यंत ठीक आहेत, पण जेव्हा त्या सोयीस्कर राहत नाहीत तेव्हा समस्या सुरू होतात. तुमचा मासिक खर्च वाढत जातो. किमतीतील बदल तुमच्या बजेटवर परिणाम करतात. आणि कुठेतरी बारीक अक्षरातील अटींमध्ये (fine print), तुमचा मालकीचा डेटा दुसऱ्या कोणाचे तरी मॉडेल प्रशिक्षित करण्यासाठी वापरला जात असतो. ही अडचण अधिक डेव्हलपर्सना स्थानिक (local) AI वर्कस्टेशन्स तयार करण्यासाठी प्रवृत्त करत आहे. तुम्ही एकदाच हार्डवेअर खरेदी करता, संपूर्ण स्टॅकवर तुमचा ताबा असतो आणि तुमच्या मशीनमधून नेमका कोणता डेटा बाहेर जाईल हे तुम्ही स्वतः ठरवू शकता.

या आठवड्यात तीन ठोस घडामोडी घडल्या आहेत ज्या या बदलाला अधिक व्यावहारिक बनवतात: एक Dockerized ट्रेडिंग असिस्टंट जो तुमचा आर्थिक डेटा घरीच सुरक्षित ठेवतो, NVIDIA GPUs स्वतःच्या नियंत्रणाखाली आणण्यासाठी एक सोपी मार्गदर्शिका, आणि Hugging Face कडून एक नवीन रिलीज जो रोबोट लर्निंगला सामान्य डेस्कटॉपच्या आवाक्यात आणतो.

Docker सह तुमचा ट्रेडिंग डेटा स्थानिक (Local) ठेवा

एका डेव्हलपरने TradingSpy लाँच केले आहे, जो विशेषतः ट्रेडिंग वर्कफ्लोसाठी बनवलेला एक स्थानिक AI रिसर्च असिस्टंट आहे. मार्केट डेटा आणि वैयक्तिक वॉचलिस्ट रिमोट एंडपॉइंटवर पाठवण्याऐवजी, तुम्ही सर्व काही तुमच्या स्वतःच्या हार्डवेअरवर Docker कंटेनरमध्ये चालवू शकता.

आर्थिक डेटा अत्यंत संवेदनशील असतो. शक्य असल्यास, तुमच्या पोर्टफोलिओची रचना, ट्रेडिंग नोट्स आणि ऐतिहासिक पोझिशन्स (historical positions) कोणत्याही थर्ड-पार्टी API द्वारे पाठवल्या जाऊ नयेत. मॉडेल स्थानिक पातळीवर चालवल्यामुळे हा धोका पूर्णपणे टळतो. कंटेनर इन्फरन्स (inference) हाताळतो आणि तुमचा मूळ ब्रोकरेज डेटा कधीही तुमच्या मशीनच्या बाहेर जात नाही.

Docker पायथन मशीन लर्निंग प्रोजेक्ट्समध्ये उद्भवणाऱ्या गुंतागुंतीच्या डिपेंडन्सी (dependency) समस्या देखील सोडवते. ट्रेडिंग स्टॅक्समध्ये अनेकदा pandas सारख्या डेटा लायब्ररी, टेक्निकल अनालिसिस टूलकिट्स आणि GPU-अॅक्सिलरेटेड इन्फरन्स इंजिन्सचे मिश्रण असते. आयसोलेशनशिवाय (isolation), एका प्रोजेक्टला CUDA 11.8 लागते, तर दुसऱ्याला 12.1 लागते, आणि तुमचे मूळ सिस्टम परस्परविरोधी एन्व्हायरनमेंट व्हेरिएबल्सचे (environment variables) स्मशान बनू शकते. Docker प्रत्येक डिपेंडन्सी ग्राफला त्याच्या स्वतःच्या इमेजमध्ये लॉक करते. तुम्ही ते एकदा तयार करता आणि ते हेडलेस Ubuntu सर्व्हर, WSL2 सह Windows 11 डेस्कटॉप किंवा लहान होमलॅब NAS वर अगदी सारख्याच पद्धतीने चालते. तुम्ही तुमच्या स्थानिक डेटा डिरेक्टरीज कंटेनरमध्ये 'bind-mount' देखील करू शकता, जेणेकरून तुमची फाईल्स तुमच्या फाईलसिस्टमवर राहतील आणि एक्झिक्यूशन एन्व्हायरनमेंट स्वच्छ राहील.

येथे खर्चाचा मुद्दा देखील आहे. क्लाउड LLM APIs प्रति टोकन शुल्क आकारतात. जर तुम्ही शेकडो टिकर्सवर प्री-मार्केट स्कॅन करत असाल, मॉडेलमध्ये प्राईस ॲक्शन, न्यूज समरी आणि टेक्निकल इंडिकेटर्स फीड करत असाल, तर हे कॉल्स वेगाने वाढतात. स्थानिक मॉडेलसाठी कोणताही मीटर चालू नसतो. GPU चा सुरुवातीचा खर्च एकदाच लागतो; पण API बिल दरमहा त्रासदायक ठरते.

NVIDIA GPU एन्व्हायरनमेंट्स समजून घेणे

क्लाउड APIs कडून स्थानिक NVIDIA कार्डकडे वळणे हे केवळ PyTorch इंस्टॉल करणे आणि .to('cuda') कॉल करणे इतके सोपे नाही. यासाठी बराच सराव आणि शिकण्याची गरज असते, आणि हे समजून घेणे तुम्हाला एका साध्या छंदातून (hobby script) एका विश्वासार्ह वर्कस्टेशनकडे घेऊन जाते.

क्लाउड APIs हार्डवेअर लपवून ठेवतात. तुम्ही JSON पाठवता आणि तुम्हाला JSON मिळते. स्थानिक पातळीवर, तुम्ही स्वतः सिस्टम ॲडमिनिस्ट्रेटर असता. तुम्हाला योग्य ड्रायव्हर, सुसंगत CUDA टूलकिट आणि तुमच्या GPU आर्किटेक्चरसाठी कंपाईल केलेले PyTorch बिल्ड आवश्यक असते. त्यानंतर तुम्हाला ते तुमच्या रनटाइममध्ये जोडावे लागते, मग ते कंटेनरसाठी nvidia-docker रनटाइम कॉन्फिगर करणे असो किंवा 'bare metal' वर LD_LIBRARY_PATH व्यवस्थापित करणे असो. प्रत्येक लेयरमध्ये एक व्हर्जन टपल (version tuple) असते जे एकमेकांशी जुळले पाहिजे, आणि जेव्हा ते जुळत नाही, तेव्हा तुम्हाला लायब्ररी गहाळ असल्याबद्दल किंवा अनइनिशियलाइज्ड डिव्हाइसेसबद्दल गूढ एरर्स (cryptic errors) मिळतात.

याचे फळ म्हणजे थेट हार्डवेअर नियंत्रण. तुम्हाला समजते की GPU मेमरी ही एक मर्यादा (hard ceiling) आहे. सिस्टम RAM च्या उलट, जिथे OS स्वॅप आणि पेजिंग करू शकते, तिथे VRAM संपणे म्हणजे सहसा ट्रेनिंग जॉब क्रॅश होणे किंवा इन्फरन्स बॅच त्वरित फेल होणे असा होतो. ही मर्यादा तुम्हाला बॅच साइजिंग, मिक्स्ड-प्रिसिजन ट्रेनिंग आणि मेमरी प्रोफाइलिंग याबद्दल विचार करण्यास भाग पाडते. तुम्ही कम्प्युटला (compute) एक अनंत युटिलिटी मानण्याऐवजी एक मर्यादित संसाधन म्हणून हाताळायला सुरुवात करता.

या आठवड्यात चर्चेत असलेली एक उपयुक्त मार्गदर्शिका एंटरप्राइझ आणि कन्झ्युमर GPUs ला एकाच श्रेणीत मानते. तुम्ही डेटासेंटर-ग्रेड A100 वापरत असाल किंवा कन्झ्युमर RTX 4070, मूलभूत गोष्टी बदलत नाहीत. दोन्ही एकाच CUDA प्रोग्रामिंग मॉडेलवर अवलंबून आहेत. दोन्हीमध्ये तुम्हाला टेन्सर्स (tensors) स्पष्टपणे डिव्हाइसवर हलवावे लागतात. जर तुम्ही १२-गीगाबाइटच्या कार्डवर १४-गीगाबाइटचे मॉडेल लोड करण्याचा प्रयत्न केला, तर दोन्हीमध्ये तुम्हाला सारखीच शिक्षा (error) मिळते. हे धडे उपयोगाचे आहेत. तुम्ही तुमच्या डेस्कटॉपवरील कार्डवर प्रोटोटाइप तयार करू शकता आणि नंतर मोठ्या हार्डवेअरवर स्केल करताना अगदी तेच ऑप्टिमायझेशन माइंडसेट वापरू शकता.

LeRobot v0.6.0 रोबोटिक्स तुमच्या डेस्कवर आणते

Hugging Face ने LeRobot चे version 0.6.0 रिलीज केले आहे, जे एक असे framework आहे जे चॅटबॉट्स आणि इमेज जनरेटर्सच्या मागे असलेल्या Transformers आणि Diffusers लायब्ररीचा वापर एका अतिशय वेगळ्या कार्यासाठी करते: रोबोट लर्निंग. पुढचा शब्द किंवा पिक्सेलचा अंदाज घेण्याऐवजी, हे मॉडेल कॅमेरा फीड आणि भाषिक सूचना (language instruction) मिळाल्यावर पुढची मोटर कृती (motor action) वर्तवते.

Robotics हे दीर्घकाळ मोशन-कॅप्चर रूम्स आणि इंडस्ट्रियल GPUs च्या क्लस्टर्सचा वापर करू शकणाऱ्या मोठ्या निधी असलेल्या लॅब्ससाठी राखीव असलेले क्षेत्र वाटत होते. LeRobot या अडथळ्याला कमी करत आहे. Version 0.6.0 मुळे तुम्ही रोबोटिक पॉलिसीज कशा डिझाइन, ट्रेन आणि इव्हॅल्युएट करता हे सोपे होते. तुम्ही सिम्युलेशनमध्ये प्रोटोटाइप तयार करू शकता, पॉलिसी आर्किटेक्चरवर काम करू शकता आणि त्यानंतर हजारो ओळींचा लो-लेव्हल कंट्रोल कोड न लिहिता प्रत्यक्ष रोबोटिक आर्म किंवा मोबाईल बेसवर ते वापरू शकता.

या रिलीजचे वैशिष्ट्य म्हणजे हे कन्झ्युमर GPUs साठी बनवले आहे. प्रयोग करण्यासाठी तुम्हाला सर्व्हर रॅकची गरज नाही. एक सिंगल हाय-एंड कन्झ्युमर कार्ड अशा पॉलिसीज ट्रेन करू शकते ज्या प्रत्यक्ष ग्रिपर्स आणि आर्म्सवर लागू होतात. हे एक स्पष्ट संकेत आहे की ओपन-वेट मॉडेल्स आता क्लाउडमधून बाहेर पडून फिजिकल हार्डवेअरमध्ये येत आहेत. हे वेट्स तुमच्या ड्राइव्हवर राहतात. रोबोटला API कडे नेटवर्क राउंड-ट्रिप न करता थेट कमांड्स मिळतात. जेव्हा तुम्ही प्रत्यक्ष जगात हालचाल करणाऱ्या गोष्टी नियंत्रित करत असता, तेव्हा लॅटन्सी आणि प्रायव्हसीचे फायदे दुर्लक्षित करणे कठीण असते.

यामुळे सॉफ्टवेअर आणि हार्डवेअरमधील सीमारेषेबद्दलचा तुमचा दृष्टिकोनही बदलतो. रोबोटिक पॉलिसीज पूर्वी फक्त रिसर्च पेपर्समध्ये असायच्या. आता त्या अशा रिपॉझिटरीजमध्ये आहेत ज्या तुम्ही क्लोन करू शकता, तुमच्या स्वतःच्या मोशन डेटावर फाईन-ट्यून करू शकता आणि तुमच्या मालकीच्या हार्डवेअरवर तैनात (deploy) करू शकता.

खरा विजय म्हणजे नियंत्रण

लोकल AI स्टॅक तयार करणे म्हणजे तत्त्वानुसार क्लाउडचा त्याग करणे नव्हे. तर तुम्हाला कशाची किंमत आहे, यावर आधारित तुमचे कम्प्युट कुठे होईल हे निवडणे होय. जेव्हा तुम्ही मॉडेल्स स्थानिक पातळीवर चालवता, तेव्हा तुमचा डेटा तुमच्या ड्राइव्हवर राहतो. तुमचे खर्च अनपेक्षित मासिक शुल्काकडून स्थिर हार्डवेअर गुंतवणुकीकडे वळतात. आणि तुम्ही CUDA डीबग करणे, VRAM प्रोफाइलिंग करणे, वर्कफ्लो कंटेनरायझ करणे यांसारखी कौशल्ये आत्मसात करता, जी तुम्हाला केवळ एक API उपभोक्ता न ठेवता एक सिस्टम्स इंजिनिअर बनवतात.

साधने तयार आहेत. मॉडेल्स कन्झ्युमर कार्ड्सवर बसण्याइतकी लहान आहेत. आता फक्त एकच प्रश्न उरला आहे की तुम्हाला हा स्टॅक स्वतःचा ठेवायचा आहे की तो भाड्याने घेत राहणे आहे.