ഓരോ കുറച്ചു മാസത്തിലും ഓപ്പൺ സോഴ്സ് കമ്മ്യൂണിറ്റി പുതിയൊരു AI ഫ്രെയിംവർക്ക് പുറത്തിറക്കുന്നു. അവയിൽ ഭൂരിഭാഗവും ഭാരമേറിയ C++ കേർണലുകൾക്ക് ചുറ്റും Python ബൈൻഡിംഗുകൾ നൽകുന്നവയാണ്, അല്ലെങ്കിൽ അവയുടെ റൺടൈം മാത്രം അവ സേവിക്കുന്ന മോഡലുകളേക്കാൾ വലുതാകുന്ന രീതിയിൽ അബ്സ്ട്രാക്ഷൻ ലെയറുകൾ അടുക്കിവെച്ചിരിക്കുന്നു. CatAI ഇതിന് വിപരീത ദിശയിലാണ് നീങ്ങുന്നത്. ഇത് പൂർണ്ണമായും C++-ൽ എഴുതപ്പെട്ട ഒരു നേറ്റീവ് AI എഞ്ചിനാണ്, ടെൻസർ മാത്തമാറ്റിക്സ് (tensor math) അടിസ്ഥാനമാക്കി മുകളിലേക്ക് നിർമ്മിച്ചതാണ്. PyTorch-ന് മുകളിൽ മറ്റൊരു സൗഹൃദപരമായ സ്കിൻ (skin) നിർമ്മിക്കുക എന്നതല്ല ഇതിന്റെ ലക്ഷ്യം. ഹാർഡ്വെയർ അതിർത്തി മുതൽ മെമ്മറിയുടെ ഓരോ ബൈറ്റും കമ്പ്യൂട്ടിന്റെ ഓരോ സൈക്കിളും നിയന്ത്രിക്കുക എന്നതാണ് ഇതിന്റെ ലക്ഷ്യം.
എന്തുകൊണ്ട് മറ്റൊരു എഞ്ചിൻ?
നിങ്ങൾ എന്തെങ്കിലും പ്രൊഡക്ഷനിലേക്ക് എത്തിച്ചിട്ടുണ്ടെങ്കിൽ, ആ പ്രയാസം നിങ്ങൾക്ക് അറിയാമായിരിക്കും. ഒരു സ്റ്റാൻഡേർഡ് ഡീപ്പ് ലേണിംഗ് സ്റ്റാക്ക് ഒരു കണ്ടെയ്നറിലേക്ക് മാറ്റുമ്പോൾ അതിന്റെ ഇമേജ് വലിപ്പം പല ജിബി (gigabytes) ആയി കൂടുന്നത് കാണാം. ഡിപെൻഡൻസികൾ (Dependencies) പരസ്പരം തടസ്സമുണ്ടാക്കുന്നു. Python ഇന്റർപ്രെറ്റർ ലേറ്റൻസി (latency) വർദ്ധിപ്പിക്കുന്നു. CUDA അല്ലെങ്കിൽ CPU-ലേക്ക് ഓപ്പറേഷനുകൾ റൂട്ട് ചെയ്യുന്ന ഡിസ്പാച്ചർ (dispatcher), ഡസൻ കണക്കിന് നെസ്റ്റഡ് ഫ്രെയിംവർക്കുകൾക്കുള്ളിൽ മറഞ്ഞുപോകുമ്പോൾ പ്രൊഫൈൽ ചെയ്യാൻ കഴിയാത്ത വിധം ചെറിയ ഓവർഹെഡ് (overhead) ഉണ്ടാക്കുന്നു. എഡ്ജ് ഡിവൈസുകൾ (edge devices), എംബഡഡ് റോബോട്ടിക്സ്, അല്ലെങ്കിൽ ലേറ്റൻസിക്ക് പ്രാധാന്യമുള്ള ബാക്കെൻഡുകൾ എന്നിവയ്ക്ക് ഈ ആഘാതം വലുതാണ്. ഒരു പ്യുവർ C++ എഞ്ചിൻ ഈ ഇടനിലക്കാരനെ ഒഴിവാക്കുന്നു. ഗാർബേജ് കളക്ഷനോ (garbage collection), ഗ്ലോബൽ ഇന്റർപ്രെറ്റർ ലോക്കോ (global interpreter lock), ഭാഷകൾ തമ്മിലുള്ള സെരിയലൈസേഷൻ (serialization) പ്രക്രിയകളോ ഇല്ലാതെ ഇത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തോടും സിലിക്കണുമായും നേരിട്ട് സംവദിക്കുന്നു.
CatAI ഇതിനെ ഒരു വിട്ടുവീഴ്ചയായിട്ടല്ല, മറിച്ച് ഒരു സവിശേഷതയായിട്ടാണ് കാണുന്നത്. ടെൻസറുകൾ RAM-ൽ എങ്ങനെ നിലനിൽക്കുന്നുവെന്നും, അവ എങ്ങനെ കാഷെ ഹൈരാർക്കികളിലൂടെ (cache hierarchies) നീങ്ങുന്നുവെന്നും, ത്രെഡുകളിലുടനീളം കേർണലുകൾ എങ്ങനെ ഷെഡ്യൂൾ ചെയ്യുന്നുവെന്നും കൃത്യമായി തീരുമാനിക്കാൻ ആഗ്രഹിക്കുന്നതുകൊണ്ടാണ് ഈ പ്രോജക്റ്റ് C++-ൽ ആദ്യം മുതൽ (from scratch) എഴുതുന്നത്. ഇത് വെറുമൊരു സ്വയം കഷ്ടപ്പെടലല്ല. പരിമിതമായ ഹാർഡ്വെയറിൽ നിന്ന് പരമാവധി പെർഫോമൻസ് എടുക്കുമ്പോൾ പ്രവൃത്തികൾ മുൻകൂട്ടി പ്രവചിക്കാവുന്നതാണെന്ന് ഉറപ്പാക്കാനുള്ള ഏക മാർഗ്ഗമാണിത്.
"From Scratch" എന്നാൽ യഥാർത്ഥത്തിൽ എന്താണ് അർത്ഥമാക്കുന്നത്?
മിക്ക ആധുനിക ഫ്രെയിംവർക്കുകളിലും, ടെൻസർ മാത്തമാറ്റിക്സ് cuDNN, oneMKL, അല്ലെങ്കിൽ MPS പോലുള്ള വെണ്ടർ ലൈബ്രറികളിലേക്കുള്ള അജ്ഞാതമായ കോളുകളിലൂടെയാണ് (opaque calls) കൈകാര്യം ചെയ്യുന്നത്. വേഗത്തിൽ വികസിപ്പിക്കാൻ ഇത് നല്ലതാണെങ്കിലും, ഇത് പ്രവർത്തനത്തിന്റെ യഥാർത്ഥ രീതികളെ മറച്ചുവെക്കുന്നു. CatAI അതിന്റെ സ്വന്തം കോർ ടെൻസർ മാത്തമാറ്റിക്സും മെമ്മറി ലേഔട്ടുകളും എഴുതുകയാണ്. ഇതിനർത്ഥം മൾട്ടി-ഡൈമൻഷണൽ അറേകൾ (multi-dimensional arrays) സൂക്ഷിക്കുന്ന അടിസ്ഥാന ഡാറ്റാ സ്ട്രക്ചറുകൾ രൂപകൽപ്പന ചെയ്യുക, സ്ട്രൈഡുകളും (strides) ഓഫ്സെറ്റുകളും (offsets) എങ്ങനെ കണക്കാക്കണം എന്ന് തീരുമാനിക്കുക, ആക്സസ് പാറ്റേൺ അനുസരിച്ച് ഡാറ്റ റോ-മേജർ (row-major), കോളം-മേജർ (column-major), അല്ലെങ്കിൽ കസ്റ്റം ടൈൽഡ് (custom tiled) ഫോർമാറ്റുകളിൽ സൂക്ഷിക്കണോ എന്ന് തീരുമാനിക്കുക എന്നിവയാണ്.
ഇത് ആഴത്തിലുള്ള സിസ്റ്റംസ് വർക്ക് (systems work) ആണ്. നിങ്ങൾ ഒരു മാട്രിക്സ്-മൾട്ടിപ്ലൈ കേർണൽ (matrix-multiply kernel) നേരിട്ട് എഴുതുമ്പോൾ, torch.matmul എന്നതിനെക്കുറിച്ചല്ല, മറിച്ച് L1 cache lines, register pressure, loop tiling എന്നിവയെക്കുറിച്ചാണ് നിങ്ങൾ ചിന്തിക്കുന്നത്. ടാർഗെറ്റ് CPU-യുടെ SIMD വീതി അനുസരിച്ച് 32x32 ടൈലുകൾക്ക് വേണ്ടിയാണോ അതോ 64x64 ടൈലുകൾക്ക് വേണ്ടിയാണോ ബ്ലോക്ക് ചെയ്യേണ്ടതെന്ന് നിങ്ങൾ തീരുമാനിക്കുന്നു. AVX-512 ലോഡുകൾ കാഷെ ലൈനുകൾ മറികടക്കാതിരിക്കാൻ നിങ്ങൾ അലോക്കേഷനുകൾ 64-ബൈറ്റ് അതിർത്തികളിലേക്ക് ക്രമീകരിക്കുന്നു. ടെൻസർ സ്റ്റോറേജിന് std::vector ശരിയായ കണ്ടെയ്നർ ആണോ, അതോ ഒരു കസ്റ്റം അരീന അലോക്കേറ്റർ (custom arena allocator) മികച്ച ലോക്കാലിറ്റിയും ഇൻഫറൻസ് ഗ്രാഫിലുടനീളം സീറോ ഫ്രാഗ്മെന്റേഷനും (zero fragmentation) നൽകുമോ എന്ന് നിങ്ങൾ പരിശോധിക്കുന്നു.
മെമ്മറി ലേഔട്ടും ഒരുപോലെ നിർണ്ണായകമാണ്. ചാനൽസ്-ലാസ്റ്റ് (channels-last) ഇമേജ് ഡാറ്റ ചാനൽസ്-ഫസ്റ്റ് (channels-first) പാറ്റേണിൽ ആക്സസ് ചെയ്താൽ ഒരു സാധാരണ n-ഡൈമൻഷണൽ അറേ പെർഫോമൻസിനെ തകർക്കും. CatAI-യിൽ, ഈ ലേഔട്ടുകൾ എക്സ്പോർട്ട് സമയത്ത് പ്രവർത്തിക്കുന്ന ഒരു ഗ്രാഫ് ഒപ്റ്റിമൈസറിലൂടെ കൈകാര്യം ചെയ്യുന്ന വെറും ചിന്തകളല്ല, മറിച്ച് അവ പ്രധാനപ്പെട്ട ഘടകങ്ങളാണ് (first-class citizens).
ഒപ്റ്റിമൈസേഷൻ മൈൻഡ്സെറ്റ്
നാനോസെക്കൻഡുകൾ എണ്ണാൻ തുടങ്ങുന്നത് വരെ 'ബെയർ-മെറ്റൽ ഒപ്റ്റിമൈസേഷൻ' (Bare-metal optimization) എന്നത് വെറുമൊരു വാക്ക് മാത്രമാണ്. ഇടക്കാല ഫലങ്ങൾ (intermediate results) ഒരിക്കലും CPU രജിസ്റ്ററുകളിൽ നിന്നോ L1 കാഷെയിൽ നിന്നോ പുറത്തുപോകാത്ത രീതിയിൽ ഓപ്പറേഷനുകൾ ഫ്യൂസ് (fuse) ചെയ്യുക എന്നാണ് ഇതിനർത്ഥം. ഒരു ലെയർ-നോം (layer-norm) കഴിഞ്ഞു വരുന്ന GELU ഒരു സിംഗിൾ കേർണലായി നടപ്പിലാക്കുക വഴി DRAM-ലേക്കുള്ള ഒരു റൗണ്ട് ട്രിപ്പ് ഒഴിവാക്കാം. OpenMP ഡിഫോൾട്ടുകളെ ആശ്രയിക്കുന്നതിന് പകരം സ്വന്തമായി ഒരു ത്രെഡ് പൂൾ (thread pool) എഴുതുക എന്നാണ് ഇതിനർത്ഥം, കാരണം നിങ്ങളുടെ വർക്ക് ലോഡ് പെട്ടെന്ന് മാറുന്നതാണെന്നും ഓരോ ഫോർവേഡ് പാസിലും (forward pass) ത്രെഡുകൾ സൃഷ്ടിക്കുന്നതും കൂട്ടുന്നതും ഒഴിവാക്കണമെന്നും നിങ്ങൾക്കറിയാം.
എപ്പോഴാണ് അസംബ്ലി (assembly) എഴുതാത്തത് എന്ന് മനസ്സിലാക്കുക എന്നതും ഇതിൽ ഉൾപ്പെടുന്നു. ചിലപ്പോൾ കൈകൊണ്ട് എഴുതിയ ഇൻട്രിൻസിക്സിനേക്കാൾ (intrinsics) നന്നായി കംപൈലർ ഒരു ലൂപ്പിനെ വെക്റ്ററൈസ് ചെയ്തേക്കാം. അളക്കുക എന്നതാണ് ഇതിലെ അച്ചടക്കം: പ്രൊഫൈൽ ചെയ്യുക, അനുമാനം നടത്തുക, ഒരു വേരിയബിൾ മാറ്റുക, വീണ്ടും പ്രൊഫൈൽ ചെയ്യുക. ഈ കഠിനാധ്വാനം ആസ്വദിക്കുന്ന ആളുകളാണ് ഈ എഞ്ചിൻ നിർമ്മിക്കുന്നത്. ഒരു ബാച്ചിൽ നിന്ന് രണ്ട് മില്ലിസെക്കൻഡ് കുറയ്ക്കുന്നതിനായി ഒരു കൺവല്യൂഷൻ ലൂപ്പ് (convolution loop) വീണ്ടും എഴുതി ഒരു ഉച്ചസമയം ചെലവഴിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇതിന്റെ സംസ്കാരം മനസ്സിലാകും.
ഞങ്ങൾക്ക് ആരെയാണ് ആവശ്യം?
ഇതൊരു ഒരാൾ മാത്രം ചെയ്യുന്ന പ്രവൃത്തിയല്ല. പൂജ്യത്തിൽ നിന്ന് ഒരു ബാക്കെൻഡ് നിർമ്മിക്കാൻ ഒരു വ്യക്തിയിൽ തന്നെ അപൂർവ്വമായി കാണപ്പെടുന്ന വ്യത്യസ്തമായ കഴിവുകൾ ആവശ്യമാണ്. നിങ്ങൾ ഇത് വായിക്കുകയും ഇതിൽ പങ്കുചേരാൻ ആഗ്രഹിക്കുകയും ചെയ്യുന്നുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അനുയോജ്യമായ മേഖലകൾ ഇവയാണ്:
C++ ഡെവലപ്പർമാർ - ആധുനിക മാനദണ്ഡങ്ങൾ (modern standards) അറിയുന്നവരും എന്നാൽ ടെംപ്ലേറ്റുകൾ കംപൈലേഷൻ ബ്ലോട്ട് (compilation bloat) ഉണ്ടാക്കുന്നത് എപ്പോഴാണെന്ന് തിരിച്ചറിയുന്നവരും. ആവശ്യമുള്ളപ്പോൾ റോ പോയിന്ററുകളും (raw pointers) അനുയോജ്യമായപ്പോൾ സ്മാർട്ട് പോയിന്ററുകളും (smart pointers) ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് താല്പര്യമുണ്ടായിരിക്കണം, കൂടാതെ സിന്റാക്സ് ഷുഗറിനെ (syntax sugar) പോലെ തന്നെ ബൈനറി സൈസിനെയും (binary size) നിങ്ങൾ പരിഗണിക്കുന്നുണ്ടായിരിക്കണം.
ഗണിത വിദഗ്ധർ (Math experts) - നോൺ-സ്റ്റാൻഡേർഡ് ആക്ടിവേഷനുകൾക്കായി (non-standard activations) ബാക്ക്വേർഡ്-പാസ്സ് ഗ്രേഡിയന്റുകൾ (backward-pass gradients) കണ്ടെത്താനും, മിക്സഡ്-പ്രസിഷൻ ട്രെയിനിംഗിലെ (mixed-precision training) നമ്പറിക്കൽ സ്റ്റെബിലിറ്റിയെക്കുറിച്ച് (numerical stability) ചിന്തിക്കാനും, കോഡായി മാറുന്നതിന് മുമ്പ് തന്നെ അൽഗോരിതങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യാനും കഴിയുന്നവർ. ഒരു log-sum-exp ട്രിക്ക് എന്തിനാണ് പ്രസക്തമെന്ന് നിങ്ങൾക്ക് വിശദീകരിക്കാൻ കഴിയുമെങ്കിൽ, നിങ്ങൾ ശരിയായ മാനസികാവസ്ഥയിലാണ്.
ലോ-ലെവൽ മെമ്മറി സ്പെഷ്യലിസ്റ്റുകൾ (Low-level memory specialists) - അലോക്കേറ്ററുകൾ (allocators), പേജ് ഫോൾട്ടുകൾ (page faults), NUMA ടോപ്പോളജി (NUMA topology) എന്നിവയെക്കുറിച്ച് ചിന്തിക്കുന്നവർ. ഗ്രാഫ് എക്സിക്യൂഷന് മെമ്മറി പൂളുകളും (memory pools), കേർണലുകൾക്കായി (kernels) സ്ക്രാച്ച് ബഫറുകളും (scratch buffers), മെമ്മറി ലീക്കോ ഫ്രാഗ്മെന്റേഷനോ ഇല്ലാതെ ട്രെയിനിംഗ് സ്റ്റെപ്പുകൾക്കിടയിൽ ടെൻസർ സ്റ്റോറേജ് (tensor storage) വീണ്ടും ഉപയോഗിക്കാനുള്ള തന്ത്രങ്ങളും ഈ എൻജിന് ആവശ്യമാണ്.
സിസ്റ്റംസ് എഞ്ചിനീയർമാർ (Systems engineers) - തെറ്റായ ഒരു സിസ്റ്റം കോൾ (syscall) ഒരു ട്രെയിനിംഗ് ലൂപ്പിനെ മുഴുവൻ തടസ്സപ്പെടുത്തുന്നത് എങ്ങനെയാണെന്ന് മനസ്സിലാക്കുന്നവർ. ഷെഡ്യൂളിംഗ് (Scheduling), I/O, സിൻക്രണൈസേഷൻ പ്രിമിറ്റീവുകൾ (synchronization primitives) എന്നിവയാണ് ഗണിതത്തെ ഒന്നിച്ച് ചേർത്തുനിർത്തുന്ന കണ്ണികൾ.
ഈ നാല് മേഖലകളിലും നിങ്ങൾ ലോകോത്തര വിദഗ്ധനാകേണ്ടതില്ല. മിക്ക സംഭാവനക്കാരും ഒരു കേർണലോ (kernel) അല്ലെങ്കിൽ ഒരു അലോക്കേറ്ററോ (allocator) കൈകാര്യം ചെയ്തുകൊണ്ട് തുടങ്ങുകയും ആർക്കിടെക്ചർ കൂടുതൽ വ്യക്തമാകുന്നതോടെ ബാക്കിയുള്ളവ പഠിക്കുകയും ചെയ്യും.
ആർക്കിടെക്ചറും കസ്റ്റം മാത്തും (Architecture and Custom Math)
ബാക്കെൻഡ് ലോജിക് (backend logic) എല്ലാവരും ചേർന്ന് നിർമ്മിച്ചുകൊണ്ടിരിക്കുകയാണ്, അത് ആർക്കിടെക്ചർ സംബന്ധമായ ചർച്ചകളിൽ നിന്നാണ് തുടങ്ങുന്നത്. റൺടൈമിന് മുമ്പ് തന്നെ മുഴുവൻ മോഡലും നിർവചിക്കുകയും ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യുന്ന ഒരു സ്റ്റാറ്റിക് കമ്പ്യൂട്ടേഷൻ ഗ്രാഫ് (static computation graph) ആയിരിക്കുമോ എൻജിൻ ഉപയോഗിക്കുക? അതോ ഓട്ടോമാറ്റിക് ഡിഫറൻഷ്യേഷനായി (automatic differentiation) ഒരു ടേപ്പും ഉപയോഗിച്ചുള്ള ഈഗർ എക്സിക്യൂഷൻ (eager execution) പിന്തുണയ്ക്കുമോ? autodiff എങ്ങനെയായിരിക്കും പ്രതിനിധീകരിക്കുക—ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് (operator overloading), സോഴ്സ് ട്രാൻസ്ഫോർമേഷൻ (source transformation), അതോ ഒരു ഗ്രാഫ് IR ആണോ? ഈ തീരുമാനങ്ങളാണ് മറ്റെല്ലാറ്റിനെയും രൂപപ്പെടുത്തുന്നത്.
കസ്റ്റം ന്യൂറൽ നെറ്റ് മാത്ത് (Custom neural net math) എന്നത് നിലവിലുള്ള ലെയറുകൾ വീണ്ടും നിർമ്മിക്കുന്നതിനേക്കാൾ ഉപരിയാണ്. പുതിയവ കണ്ടുപിടിക്കാനുള്ള സ്വാതന്ത്ര്യം കൂടിയാണത്. നോൺ-സ്റ്റാൻഡേർഡ് സ്പാർസ് കേർണലുള്ള (non-standard sparse kernel) ഒരു കൺവല്യൂഷൻ വേരിയന്റോ അല്ലെങ്കിൽ സാഹിത്യത്തിൽ പേര് ലഭിക്കാത്ത ഒരു ആക്ടിവേഷൻ ഫംഗ്ഷനോ നിങ്ങൾക്ക് വേണമെന്നുണ്ടെങ്കിൽ, നിങ്ങൾ C++ ഫോർവേഡ്, ബാക്ക്വേർഡ് പാസുകൾ എഴുതി അവ നേരിട്ട് എൻജിനിൽ ഘടിപ്പിക്കാം. അവിടെ പോരാടാൻ ഒരു പൈത്തൺ API ഇല്ല, മോങ്കി-പാച്ചിംഗ് (monkey-patching) ആവശ്യമില്ല. ഗണിതം തന്നെയാണ് കോഡ്, കോഡ് തന്നെയാണ് ഇന്റർഫേസ്.
എങ്ങനെ പങ്കാളിയാകാം (How to Get Involved)
ഇത് നിങ്ങൾക്ക് താൽപ്പര്യമുള്ളതാണെങ്കിൽ, പ്രോജക്റ്റിന്റെ പൂർണ്ണമായ വിവരങ്ങളും നിലവിലെ റോഡ്മാപ്പും (roadmap) രചയിതാവിന്റെ Dev.to പോസ്റ്റിൽ വിശദമായി രേഖപ്പെടുത്തിയിട്ടുണ്ട്. നിങ്ങൾക്ക് അതിന്റെ പ്രത്യേകതകൾ വായിക്കാനും ഇതുവരെ എന്തൊക്കെ നിർമ്മിച്ചു എന്ന് കാണാനും എവിടെയാണ് സഹായം ആവശ്യമെന്ന് കൃത്യമായി മനസ്സിലാക്കാനും കഴിയും.
Project details: https://dev.to/banana_cool/building-a-native-c-ai-engine-catai-from-scratch-looking-for-collaborators-l8m
ഉടൻ തന്നെ ഒരു പുൾ റിക്വസ്റ്റ് (pull request) നൽകാൻ താല്പര്യമില്ലാത്തവർക്കും, ഗ്രൂപ്പിൽ ജോയിൻ ചെയ്യാനും ചോദ്യങ്ങൾ ചോദിക്കാനും പ്രോജക്റ്റിന്റെ പുരോഗതി അറിയാനും ഒരു ടെലിഗ്രാം ഗ്രൂപ്പ് ഉണ്ട്.
Community: https://t.me/GyaanSetuAi
യഥാർത്ഥ പാഠം (The Real Takeaway)
ആധുനിക AI സ്റ്റാക്ക് ഒരു ബ്ലാക്ക് ബോക്സ് ആയി മാറിയിരിക്കുന്നു. ഫ്രെയിംവർക്കുകളെ മാന്ത്രിക ഉപകരണങ്ങളെപ്പോലെയാണ് നമ്മൾ കാണുന്നത്: ഡാറ്റ നൽകുന്നു, മോഡൽ ലഭിക്കുന്നു, ഡിപ്ലോയ്മെന്റ് സമയത്ത് ഈ അവ്യക്തത നമ്മളെ കുടുക്കില്ല എന്ന് നമ്മൾ പ്രത്യാശിക്കുന്നു. CatAI ആ സുഖസൗകര്യങ്ങളെ നിരസിക്കുന്നു. ഇത്തരത്തിൽ നിർമ്മിക്കുന്നത് സാവധാനത്തിലായിരിക്കും. നിങ്ങൾ കൂടുതൽ കോഡ് എഴുതേണ്ടി വരും, കൂടുതൽ segfaults ഡിബഗ് ചെയ്യേണ്ടി വരും, ഉയർന്ന തലത്തിലുള്ള ഫ്രെയിംവർക്കുകൾ നിങ്ങളിൽ നിന്ന് മറച്ചുവെക്കുന്ന അനുമാനങ്ങളെക്കുറിച്ച് വീണ്ടും ചിന്തിക്കേണ്ടി വരും. എന്നാൽ മെഷീൻ എന്തുകൊണ്ടാണ് ഇപ്രകാരം പ്രവർത്തിക്കുന്നത് എന്ന് നിങ്ങൾക്ക് മനസ്സിലാക്കാൻ സാധിക്കും. ഹാർഡ്വെയറിനെ അബ്സ്ട്രാക്റ്റ് (abstract) ചെയ്യാൻ എല്ലാവരും മത്സരിക്കുന്ന ഈ വ്യവസായത്തിൽ, നേരെ വിപരീത ദിശയിൽ സഞ്ചരിക്കാനും ഹാർഡ്വെയറിനെ നേരിട്ട് സ്പർശിക്കാനും (touching the metal) വലിയ മൂല്യമുണ്ട്. API വിളിക്കുന്ന ഒരാളിൽ നിന്നും സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്ന ഒരാളിൽ നിന്നും ഒരാളെ വേർതിരിക്കുന്നത് ഈ അറിവാണ്.