Cloud APIs வசதியாக இருக்கும் வரை மட்டுமே; அவை வசதியற்றதாக மாறும் போது சிக்கல்கள் தொடங்கும். உங்கள் மாதாந்திர கட்டணம் படிப்படியாக உயர்கிறது. விலை மாற்றங்கள் உங்கள் பட்ஜெட்டைப் பாதிக்கிறது. மேலும், எங்கோ ஒரு சிறிய விதிகளில் (fine print), உங்கள் ரகசியத் தரவுகள் (proprietary data) வேறொருவரின் மாடலுக்குப் பயிற்சியளிக்கப் பயன்படுத்தப்படுகின்றன. இந்தத் தடைகள் காரணமாக, அதிகப்படியான டெவலப்பர்கள் உள்ளூர் AI workstations-களை உருவாக்கத் தொடங்கியுள்ளனர். நீங்கள் வன்பொருளை (hardware) ஒருமுறை வாங்கினால் போதும், முழுமையான கட்டுப்பாட்டைப் பெறலாம், மேலும் உங்கள் இயந்திரத்திலிருந்து எந்தத் தரவு வெளியேற வேண்டும் என்பதை நீங்களே தீர்மானிக்கலாம்.
இந்த வாரம் அந்த மாற்றத்தை இன்னும் நடைமுறைக்குச் சாத்தியமாக்கும் மூன்று முக்கிய முன்னேற்றங்களைக் கொண்டு வந்துள்ளது: உங்கள் நிதித் தரவுகளை உங்கள் வீட்டிலேயே பாதுகாக்கும் ஒரு Dockerized trading assistant, NVIDIA GPUs-களை உங்கள் கட்டுப்பாட்டிற்குள் கொண்டு வருவதற்கான ஒரு எளிய வழிகாட்டி, மற்றும் ரோபோ கற்றலை (robot learning) சாதாரண டெஸ்க்டாப்பிற்குள் கொண்டு வரும் Hugging Face-ன் புதிய வெளியீடு.
Docker மூலம் உங்கள் வர்த்தகத் தரவை உள்ளூரிலேயே வைத்திருங்கள்
ஒரு டெவலப்பர் வர்த்தகப் பணிகளுக்காகவே (trading workflows) பிரத்யேகமாக உருவாக்கப்பட்ட TradingSpy என்ற உள்ளூர் AI ஆராய்ச்சி உதவியாளரை வெளியிட்டுள்ளார். சந்தை தரவுகளையும் (market data) தனிப்பட்ட கண்காணிப்புப் பட்டியல்களையும் (watchlists) ஒரு தொலைதூர முனையத்திற்கு (remote endpoint) அனுப்பாமல், உங்கள் சொந்த வன்பொருளில் ஒரு Docker container உள்ளே அனைத்தையும் இயக்கலாம்.
நிதித் தரவுகள் மிகவும் முக்கியமானவை. முடிந்தவரை உங்கள் போர்ட்ஃபோலியோ அமைப்பு (portfolio composition), வர்த்தகக் குறிப்புகள் மற்றும் வரலாற்று நிலைகள் (historical positions) ஆகியவற்றை மூன்றாம் தரப்பு API வழியாக அனுப்பக்கூடாது. மாடலை உள்ளூரிலேயே இயக்குவதன் மூலம் அந்தத் தேவையற்ற வெளிப்பாட்டை (exposure) முற்றிலும் தவிர்க்கலாம். Container இன்ஃபரன்ஸ் (inference) பணிகளைக் கவனித்துக் கொள்ளும், மேலும் உங்கள் மூல தரவுகள் (raw brokerage data) உங்கள் கணினியை விட்டு வெளியேற வேண்டிய அவசியமே இல்லை.
Python machine learning திட்டங்களில் ஏற்படும் சிக்கலான dependency பிரச்சனைகளையும் Docker தீர்க்கிறது. வர்த்தகத் தொகுப்புகள் (trading stacks) பெரும்பாலும் pandas போன்ற தரவு நூலகங்கள் (data libraries), தொழில்நுட்ப பகுப்பாய்வு கருவிகள் (technical analysis toolkits) மற்றும் GPU-accelerated inference engines ஆகியவற்றைத் தங்களுக்குள் கலந்து வைத்திருக்கும். தனிமைப்படுத்தல் (isolation) இல்லையென்றால், ஒரு திட்டம் CUDA 11.8-ஐக் கோரும், மற்றொன்று 12.1-ஐக் கோரும், இதனால் உங்கள் அடிப்படை அமைப்பு முரண்பட்ட environment variables-களின் களஞ்சியமாக மாறிவிடும். Docker ஒவ்வொரு dependency graph-ஐயும் அதன் சொந்த image-க்குள் பூட்டி வைக்கிறது. நீங்கள் அதை ஒருமுறை உருவாக்கினால் போதும், அது ஒரு headless Ubuntu server, WSL2 கொண்ட Windows 11 desktop அல்லது ஒரு சிறிய homelab NAS ஆகியவற்றில் ஒரே மாதிரியாக இயங்கும். உங்கள் கோப்புகள் உங்கள் filesystem-லேயே இருக்கும்படி, உள்ளூர் தரவு கோப்பகங்களை (local data directories) container-க்குள் bind-mount கூட செய்யலாம், இதனால் இயங்கும் சூழல் (execution environment) சுத்தமாக இருக்கும்.
இதில் ஒரு செலவு சார்ந்த வாதமும் உள்ளது. Cloud LLM APIs ஒவ்வொரு token-க்கும் கட்டணம் வசூலிக்கின்றன. நீங்கள் நூற்றுக்கணக்கான பங்குகளை (tickers) ஆய்வு செய்து, விலை மாற்றங்கள், செய்திச் சுருக்கங்கள் மற்றும் தொழில்நுட்பக் குறிகாட்டிகளை (technical indicators) ஒரு மாடலுக்கு உள்ளீடு செய்தால், அந்த அழைப்புகள் (calls) மிக வேகமாகப் பெருகும். உள்ளூர் மாடலுக்குத் தொடர்ச்சியான கட்டணம் ஏதும் இல்லை. GPU-விற்கான ஆரம்பச் செலவு ஒருமுறை மட்டுமே ஏற்படும்; ஆனால் API கட்டணம் ஒவ்வொரு மாதமும் உங்கள் பணத்தைப் பாதிக்கும்.
NVIDIA GPU சூழல்களைப் புரிந்துகொள்ளுதல்
Cloud APIs-லிருந்து உள்ளூர் NVIDIA கார்டிற்கு மாறுவது என்பது PyTorch-ஐ நிறுவி .to('cuda') என்று அழைப்பது போன்ற எளிமையான விஷயம் அல்ல. இதில் கற்றுக்கொள்ள வேண்டிய விஷயங்கள் அதிகம் உள்ளன; அதைச் சரியாகப் புரிந்துகொள்வதுதான் ஒரு பொழுதுபோக்கு ஸ்கிரிப்டிற்கும் (hobby script) ஒரு நம்பகமான workstation-க்கும் இடையிலான வேறுபாடாகும்.
Cloud APIs வன்பொருளை மறைத்துவிடுகின்றன. நீங்கள் JSON அனுப்புகிறீர்கள், JSON பெறுகிறீர்கள். ஆனால் உள்ளூரில், நீங்களே systems administrator. உங்களுக்குச் சரியான driver, இணக்கமான CUDA toolkit மற்றும் உங்கள் GPU architecture-க்காகத் தொகுக்கப்பட்ட (compiled) PyTorch build தேவைப்படும். பின்னர், containers-களுக்கான nvidia-docker runtime-ஐத் தயார் செய்வது அல்லது bare metal-இல் LD_LIBRARY_PATH-ஐ நிர்வகிப்பது என அதை உங்கள் runtime-உடன் இணைக்க வேண்டும். ஒவ்வொரு அடுக்கிலும் (layer) பொருந்தக்கூடிய பதிப்பு (version tuple) இருக்க வேண்டும்; அது பொருந்தவில்லை என்றால், விடுபட்ட நூலகங்கள் (missing libraries) அல்லது இயங்காத சாதனங்கள் (uninitialized devices) பற்றிய புரியாத பிழைகள் (cryptic errors) உங்களுக்குக் கிடைக்கும்.
இதற்கான பலன் நேரடி வன்பொருள் கட்டுப்பாடு ஆகும். GPU memory என்பது ஒரு நிலையான எல்லை (hard ceiling) என்பதை நீங்கள் உணர்வீர்கள். OS-ஆல் swap மற்றும் page செய்யக்கூடிய system RAM போலல்லாமல், VRAM தீர்ந்து போனால், அது பொதுவாக training job செயலிழப்பதற்கோ அல்லது inference batch உடனடியாகத் தோல்வியடைவதற்கோ வழிவகுக்கும். அந்தத் தட்டுப்பாடு, batch sizing, mixed-precision training மற்றும் memory profiling ஆகியவற்றைப் பற்றி நீங்கள் சிந்திக்கத் தூண்டும். கணக்கீட்டை (compute) ஒரு முடிவற்ற வசதியாகக் கருதாமல், நீங்கள் நிர்வகிக்கும் ஒரு வரையறுக்கப்பட்ட வளமாக (finite resource) கருதத் தொடங்குவீர்கள்.
இந்த வாரம் பிரபலமாகி வரும் ஒரு பயனுள்ள வழிகாட்டி, enterprise மற்றும் consumer GPUs ஆகிய இரண்டையும் ஒரே வகையாகக் கருதுகிறது. நீங்கள் datacenter-grade A100 அல்லது consumer RTX 4070 ஆகியவற்றைப் பயன்படுத்தினாலும், அடிப்படை விஷயங்கள் மாறாது. இரண்டுமே ஒரே CUDA programming model-ஐச் சார்ந்துள்ளன. இரண்டுமே tensors-களைத் தெளிவாக (explicitly) சாதனத்திற்கு (device) மாற்ற வேண்டும் என்று கோருகின்றன. நீங்கள் ஒரு பன்னிரண்டு-கிகாபைட் கார்டில் பதினான்கு-கிகாபைட் மாடலை ஒதுக்க முயன்றால், இரண்டுமே உங்களைத் தண்டிக்கும். அந்தப் பாடங்கள் அனைத்தும் பொருந்தும். உங்கள் டெஸ்க்டாப்பில் உள்ள கார்டைப் பயன்படுத்தி ஒரு முன்மாதிரியை (prototype) உருவாக்கிவிட்டு, பின்னர் பெரிய வன்பொருளுக்கு (larger iron) மாறும்போது அதே உகப்பாக்க மனநிலையை (optimization mindset) நீங்கள் பயன்படுத்தலாம்.
LeRobot v0.6.0 ரோபாட்டிக்ஸ் தொழில்நுட்பத்தை உங்கள் டெஸ்க்டாப்பிற்கு கொண்டு வருகிறது
Hugging Face, LeRobot-ன் பதிப்பு 0.6.0-ஐ வெளியிட்டுள்ளது. இது சாட்பாட்கள் (chatbots) மற்றும் படங்களை உருவாக்கும் கருவிகளுக்குப் (image generators) பின்னால் உள்ள அதே Transformers மற்றும் Diffusers நூலகங்களை முற்றிலும் மாறுபட்ட ஒரு பணிக்காக, அதாவது ரோபோ கற்றலுக்காக (robot learning) மறுபயன்பாடு செய்யும் ஒரு கட்டமைப்பாகும். அடுத்த வார்த்தையையோ அல்லது பிக்சலையோ கணிப்பதற்குப் பதிலாக, இந்த மாடல் ஒரு கேமரா காட்சி (camera feed) மற்றும் ஒரு மொழித் தூண்டுதலைக் (language instruction) கொண்டு அடுத்த மோட்டார் செயல்பாட்டை (motor action) கணிக்கிறது.
மோஷன்-கேப்சர் அறைகள் (motion-capture rooms) மற்றும் தொழில்துறை GPU தொகுப்புகளைக் கொண்ட, அதிக நிதி வசதி உடைய ஆய்வகங்களுக்கு மட்டுமே உரிய ஒரு துறையாக ரோபாட்டிக்ஸ் நீண்டகாலமாக இருந்து வந்தது. LeRobot அந்தத் தடையை உடைக்கிறது. பதிப்பு 0.6.0 நீங்கள் ரோபோட்டிக் கொள்கைகளை (robotic policies) எவ்வாறு வடிவமைப்பது, பயிற்றுவிப்பது மற்றும் மதிப்பீடு செய்வது என்பதை எளிமையாக்குகிறது. நீங்கள் சிமுலேஷனில் (simulation) முன்மாதிரிகளை உருவாக்கலாம், கொள்கை கட்டமைப்பை (policy architecture) மேம்படுத்தலாம், பின்னர் ஆயிரக்கணக்கான வரிகள் கொண்ட குறைந்த நிலை கட்டுப்பாட்டு குறியீடுகளை (low-level control code) எழுதாமலேயே ஒரு உண்மையான ரோபோ கை அல்லது மொபைல் பேஸிற்கு (mobile base) மாற்றலாம்.
இந்த வெளியீட்டை குறிப்பிடத்தக்கதாக மாற்றுவது என்னவென்றால், இது நுகர்வோர் GPUs-ஐ இலக்காகக் கொண்டுள்ளது. பரிசோதனை செய்ய உங்களுக்கு ஒரு சர்வர் ரேக் (server rack) தேவையில்லை. ஒரு உயர்தர நுகர்வோர் கார்டு (high-end consumer card), உண்மையான கிரிப்பர்கள் (grippers) மற்றும் ரோபோ கைகளுக்கும் பொருந்தக்கூடிய கொள்கைகளை பயிற்றுவிக்க முடியும். open-weight மாடல்கள் கிளவுடிலிருந்து (cloud) வெளியேறி இயற்பியல் வன்பொருளுக்குள் (physical hardware) நுழைகின்றன என்பதற்கான தெளிவான அறிகுறி இதுவாகும். அந்த வெயிட்டுகள் (weights) உங்கள் டிரைவிலேயே இருக்கும். ஒரு API-க்கு நெட்வொர்க் வழியாகச் சென்று திரும்பாமலேயே ரோபோ கட்டளைகளைப் பெறுகிறது. நிஜ உலகில் நகரும் ஒன்றை நீங்கள் கட்டுப்படுத்தும்போது, லேட்டன்சி (latency) மற்றும் தனியுரிமை (privacy) நன்மைகளைத் தவிர்க்க முடியாது.
இது மென்பொருள் மற்றும் வன்பொருளுக்கு இடையிலான எல்லையைப் பற்றிய உங்கள் சிந்தனையையும் மாற்றுகிறது. ரோபோட்டிக் கொள்கைகள் முன்பு ஆய்வுக் கட்டுரைகளில் மட்டுமே இருந்தன. இப்போது அவை நீங்கள் குளோன் (clone) செய்யக்கூடிய, உங்கள் சொந்த மோஷன் தரவுகளில் (motion data) ஃபைன்-டியூன் (fine-tune) செய்யக்கூடிய மற்றும் உங்களிடம் உள்ள வன்பொருளில் பயன்படுத்தக்கூடிய (deploy) களஞ்சியங்களில் (repositories) உள்ளன.
உண்மையான வெற்றி என்பது கட்டுப்பாட்டில் உள்ளது
ஒரு உள்ளூர் AI stack-ஐ உருவாக்குவது என்பது கொள்கை ரீதியாக கிளவுடை நிராகரிப்பதைப் பற்றியது அல்ல. இது நீங்கள் எதற்கு முக்கியத்துவம் கொடுக்கிறீர்கள் என்பதைப் பொறுத்து, உங்கள் கணக்கீடு (compute) எங்கு நடக்க வேண்டும் என்பதைத் தேர்ந்தெடுப்பதைப் பற்றியது. நீங்கள் மாடல்களை உள்ளூரிலேயே (locally) இயக்கும்போது, உங்கள் தரவு உங்கள் டிரைவிலேயே இருக்கும். உங்கள் செலவுகள் கணிக்க முடியாத மாதாந்திர கட்டணத்திலிருந்து நிலையான வன்பொருள் முதலீடாக மாறுகின்றன. மேலும் CUDA-வை டீபக் (debugging) செய்தல், VRAM-ஐ ப்ரொஃபைல் (profiling) செய்தல், பணிப்பாய்வுகளை (workflows) கன்டெய்னரைஸ் (containerizing) செய்தல் போன்ற திறன்களை நீங்கள் பெறுகிறீர்கள்—இது உங்களை ஒரு API பயனராக மட்டுமல்லாமல், ஒரு சிஸ்டம்ஸ் இன்ஜினியராகவும் (systems engineer) மாற்றுகிறது.
கருவிகள் தயாராக உள்ளன. மாடல்கள் நுகர்வோர் கார்டுகளில் பொருந்துவதற்குத் தேவையான அளவில் சிறியதாக உள்ளன. நீங்கள் அந்த stack-ஐ சொந்தமாக வைத்திருக்க விரும்புகிறீர்களா அல்லது தொடர்ந்து வாடகைக்கு எடுக்க விரும்புகிறீர்களா என்பது மட்டுமே எஞ்சியிருக்கும் கேள்வி.