ప్రతి కొన్ని నెలలకు ఒకసారి ఓపెన్-సోర్స్ కమ్యూనిటీ మరొక AI ఫ్రేమ్వర్క్ను సృష్టిస్తుంది. వాటిలో చాలా వరకు బరువైన C++ కెర్నల్స్ చుట్టూ Python బైండింగ్స్ను చుట్టడం లేదా అబ్స్ట్రాక్షన్ లేయర్లను (abstraction layers) ఎంత ఎక్కువగా పేర్చతాయంటే, వాటి రన్టైమ్ బరువు అవి అందించే మోడల్స్ కంటే ఎక్కువగా ఉంటుంది. CatAI దీనికి విరుద్ధమైన దిశలో వెళ్తుంది. ఇది పూర్తిగా C++ లో వ్రాయబడిన నేటివ్ AI ఇంజిన్, దీనిని టెన్సర్ మ్యాథ్ (tensor math) నుండి పైకి నిర్మించారు. కేవలం PyTorch పైన మరొక ఫ్రెండ్లీ స్కిన్ను సృష్టించడం దీని ఉద్దేశ్యం కాదు. హార్డ్వేర్ బౌండరీ నుండి ప్రారంభించి, ప్రతి బైట్ మెమరీని మరియు ప్రతి కంప్యూట్ సైకిల్ను పూర్తిగా నియంత్రించడమే దీని లక్ష్యం.
ఇంకో ఇంజిన్ ఎందుకు?
మీరు ఇప్పటికే ఏదైనా ప్రొడక్షన్లోకి పంపినట్లయితే, ఆ బాధ మీకు తెలుసు. ఒక స్టాండర్డ్ డీప్-లెర్నింగ్ స్టాక్ను కంటైనర్లోకి తీసుకురావడమే, దాని ఇమేజ్ పరిమాణం మల్టిపుల్ గిగాబైట్లకు పెరిగిపోవడం చూడవచ్చు. డిపెండెన్సీలు ఒకదానితో ఒకటి పోరాడుతాయి. Python ఇంటర్ప్రెటర్ లేటెన్సీని (latency) పెంచుతుంది. CUDA లేదా CPUకి ఆప్స్ను (ops) రూట్ చేసే డిస్పాచర్, డజన్ల కొద్దీ నెస్టెడ్ ఫ్రేమ్వర్క్లలో కలిసిపోయిన తర్వాత ప్రొఫైల్ చేయడం అసాధ్యమైన సూక్ష్మమైన ఓవర్హెడ్ను కలిగిస్తుంది. ఎడ్జ్ డివైజ్లు, ఎంబెడెడ్ రోబోటిక్స్ లేదా లేటెన్సీ-సెన్సిటివ్ బ్యాకెండ్ల కోసం, ఈ పన్ను (tax) నిజంగా భారమే. ఒక ప్యూర్ C++ ఇంజిన్ మధ్యవర్తిని తొలగిస్తుంది. ఇది గార్బేజ్ కలెక్షన్ (garbage collection), గ్లోబల్ ఇంటర్ప్రెటర్ లాక్ (global interpreter lock) మరియు భాషల మధ్య సీరియలైజేషన్ (serialization) వంటివి లేకుండా, నేరుగా ఆపరేటింగ్ సిస్టమ్ మరియు సిలికాన్తో మాట్లాడుతుంది.
CatAI దీనిని ఒక రాజీగా కాకుండా, ఒక ఫీచర్గా పరిగణిస్తుంది. ఈ ప్రాజెక్ట్ను C++ లో మొదటి నుండి (from scratch) వ్రాయడానికి కారణం, టెన్సర్లు RAMలో ఎలా ఉంటాయి, అవి క్యాచీ హైరార్కీల (cache hierarchies) ద్వారా ఎలా కదులుతాయి మరియు త్రెడ్స్ (threads) ద్వారా కెర్నల్స్ ఎలా షెడ్యూల్ చేయబడతాయో ఖచ్చితంగా నిర్ణయించాలని రచయిత కోరుకోవడం. అది మసోకిజం కాదు. పరిమితమైన హార్డ్వేర్ నుండి పనితీరును (performance) గరిష్టంగా పొందాలనుకున్నప్పుడు, ప్రవర్తన (behavior) ఊహించదగినదిగా (predictable) ఉంటుందని హామీ ఇవ్వడానికి ఉన్న ఏకైక మార్గం ఇదే.
"From Scratch" అంటే నిజంగా ఏమిటి?
చాలా ఆధునిక ఫ్రేమ్వర్క్లలో, టెన్సర్ మ్యాథ్ అనేది cuDNN, oneMKL, లేదా MPS వంటి వెండర్ లైబ్రరీలలో చేసే అస్పష్టమైన కాల్స్ (opaque calls) ద్వారా నిర్వహించబడుతుంది. వేగంగా డెలివరీ చేయడానికి ఇది సరిగ్గా ఉండవచ్చు, కానీ ఇది ఆపరేషన్ యొక్క మెకానిక్స్ను దాచిపెడుతుంది. CatAI తన స్వంత కోర్ టెన్సర్ మ్యాథ్ మరియు మెమరీ లేఅవుట్లను రాస్తోంది. అంటే మల్టీ-డైమెన్షనల్ అర్రేలను కలిగి ఉండే ప్రాథమిక డేటా స్ట్రక్చర్లను రూపొందించడం, స్ట్రైడ్స్ (strides) మరియు ఆఫ్సెట్స్ (offsets) ఎలా లెక్కించాలో ఎంచుకోవడం, మరియు యాక్సెస్ ప్యాటర్న్ను బట్టి డేటాను row-major, column-major, లేదా కస్టమ్ టైల్డ్ ఫార్మాట్లలో నిల్వ చేయాలా అని నిర్ణయించడం అని అర్థం.
ఇది లోతైన సిస్టమ్స్ వర్క్. మీరు ఒక మ్యాట్రిక్స్-మల్టిప్లై కెర్నల్ను స్వయంగా రాసినప్పుడు, మీరు torch.matmul గురించి ఆలోచించడం మానేసి, L1 క్యాచీ లైన్స్, రిజిస్టర్ ప్రెజర్ మరియు లూప్ టైలింగ్ (loop tiling) గురించి ఆలోచించడం ప్రారంభిస్తారు. టార్గెట్ CPU యొక్క SIMD వెడల్పు ఆధారంగా మీరు 32x32 టైల్స్ కోసం లేదా 64x64 టైల్స్ కోసం బ్లాక్ చేస్తారో నిర్ణయిస్తారు. AVX-512 లోడ్స్ క్యాచీ లైన్స్ను దాటకుండా ఉండటానికి మీరు అలోకేషన్లను 64-బైట్ బౌండరీలకు అలైన్ చేస్తారు. టెన్సర్ స్టోరేజ్ కోసం std::vector సరైన కంటైనరా, లేదా ఒక కస్టమ్ అరీనా అలోకేటర్ (custom arena allocator) మీకు మెరుగైన లోకాలిటీని మరియు మొత్తం ఇన్ఫరెన్స్ గ్రాఫ్ అంతటా జీరో ఫ్రాగ్మెంటేషన్ను ఇస్తుందా అని మీరు ప్రశ్నిస్తారు.
మెమరీ లేఅవుట్ కూడా అంతే కీలకం. ఛానల్స్-లాస్ట్ (channels-last) ఇమేజ్ డేటాను ఛానల్స్-ఫస్ట్ (channels-first) ప్యాటర్న్లో యాక్సెస్ చేస్తే, ఒక సాధారణ n-డైమెన్షనల్ అర్రే పనితీరును దెబ్బతీస్తుంది. CatAIలో, ఈ లేఅవుట్లు ఎక్స్పోర్ట్ సమయంలో రన్ అయ్యే గ్రాఫ్ ఆప్టిమైజర్ ద్వారా నిర్వహించబడే పక్కా పనులలా కాకుండా, ప్రాథమిక అంశాలుగా (first-class citizens) ఉంటాయి.
ఆప్టిమైజేషన్ మైండ్సెట్
మీరు నానో సెకన్లను లెక్కించడం ప్రారంభించే వరకు బేర్-మెటల్ ఆప్టిమైజేషన్ (Bare-metal optimization) అనేది ఒక బజ్ వర్డ్ లాగా అనిపిస్తుంది. అంటే ఇంటర్మీడియట్ ఫలితాలు ఎప్పుడూ CPU రిజిస్టర్లు లేదా L1 క్యాచీని వదిలి వెళ్ళకుండా ఆపరేషన్లను ఫ్యూజ్ (fuse) చేయడం. అంటే లేయర్-నార్మ్ (layer-norm) తర్వాత GELUని ఒకే కెర్నల్గా అమలు చేయడం, తద్వారా DRAMకి చేసే పూర్తి రౌండ్-ట్రిప్ను ఆదా చేయడం. అంటే OpenMP డిఫాల్ట్లపై ఆధారపడకుండా మీ స్వంత త్రెడ్ పూల్ను వ్రాయడం, ఎందుకంటే మీ వర్క్లోడ్ బరస్టీ (bursty)గా ఉంటుందని మరియు ప్రతి ఫార్వర్డ్ పాస్ వద్ద రన్టైమ్ త్రెడ్స్ను సృష్టించడం మరియు కలపడం (spawning and joining) మీరు కోరుకోవడం లేదు.
అసెంబ్లీని ఎప్పుడు రాయకూడదో అర్థం చేసుకోవడం కూడా ఇందులో భాగమే. కొన్నిసార్లు హ్యాండ్-రిటెన్ ఇంట్రిన్సిక్స్ (intrinsics) కంటే కంపైలర్ లూప్ను మెరుగ్గా వెక్టరైజ్ చేస్తుంది. ఇక్కడ క్రమశిక్షణ అంటే కొలత: ప్రొఫైల్ చేయండి, ఊహించండి, ఒక వేరియబుల్ను మార్చండి, మరియు మళ్ళీ ప్రొఫైల్ చేయండి. ఈ ఇంజిన్ ఆ కష్టాన్ని ఆస్వాదించే వ్యక్తులచే నిర్మించబడుతోంది. ఒక బ్యాచ్ నుండి రెండు మిల్లీసెకన్లను తగ్గించడానికి మీరు ఎప్పుడైనా ఒక కన్వల్యూషన్ లూప్ను తిరిగి వ్రాసి ఉంటే, మీకు ఇప్పటికే ఈ సంస్కృతి అర్థమై ఉంటుంది.
మాకు ఎవరు కావాలి
ఇది ఒక్కరి పని కాదు. సున్నా నుండి బ్యాకెండ్ను నిర్మించడానికి ఒకే మెదడులో అరుదుగా కలిసే విభిన్న నైపుణ్యాలు అవసరం. మీరు ఇది చదువుతూ ఇందులో చేరాలని ఆలోచిస్తుంటే, మీరు ఇక్కడ సరిపోవచ్చు:
C++ డెవలపర్లు - ఆధునిక ప్రమాణాల గురించి అవగాహన ఉండి, టెంప్లేట్లు (templates) ఎప్పుడు కంపైలేషన్ బ్లోట్ (compilation bloat) కలిగిస్తాయో తెలిసినవారు. అవసరమైనప్పుడు రా పాయింటర్లు (raw pointers) మరియు తగినప్పుడు స్మార్ట్ పాయింటర్లను (smart pointers) ఉపయోగించడంలో మీకు నైపుణ్యం ఉండాలి, అలాగే సింటాక్స్ షుగర్ (syntax sugar) కంటే బైనరీ సైజ్ (binary size) గురించి కూడా మీరు శ్రద్ధ వహించాలి.
గణిత నిపుణులు (Math experts) - నాన్-స్టాండర్డ్ యాక్టివేషన్ల కోసం బ్యాక్వర్డ్-పాస్ గ్రేడియంట్స్ను (backward-pass gradients) డెరివ్ చేయగలగాలి, మిక్స్డ్-ప్రిసిషన్ ట్రైనింగ్లో (mixed-precision training) నంబరికల్ స్టెబిలిటీని విశ్లేషించగలగాలి మరియు అల్గారిథమ్లు కోడ్గా మారకముందే వాటిని ఆప్టిమైజ్ చేయగలగాలి. ఒకవేళ లాగ్-సమ్-ఎక్స్ (log-sum-exp) ట్రిక్ ఎందుకు ముఖ్యమో మీరు వివరించగలిగితే, మీరు సరైన మానసిక స్థితిలో ఉన్నట్లే.
లో-లెవల్ మెమరీ స్పెషలిస్టులు - అలోకేటర్లు (allocators), పేజ్ ఫాల్ట్స్ (page faults) మరియు NUMA టోపాలజీ (NUMA topology) గురించి ఆలోచించేవారు. గ్రాఫ్ ఎగ్జిక్యూషన్ కోసం ఇంజిన్కు మెమరీ పూల్స్ (memory pools), కెర్నల్స్ కోసం స్క్రాచ్ బఫర్లు (scratch buffers) మరియు టెన్సర్ స్టోరేజీని (tensor storage) లీక్ లేదా ఫ్రాగ్మెంటేషన్ లేకుండా ట్రైనింగ్ స్టెప్స్ అంతటా తిరిగి ఉపయోగించే వ్యూహాలు అవసరం.
సిస్టమ్స్ ఇంజనీర్లు - ఒక తప్పుగా చేసిన syscall మొత్తం ట్రైనింగ్ లూప్ను నిలిపివేస్తుందని అర్థం చేసుకునేవారు. షెడ్యూలింగ్ (Scheduling), I/O మరియు సింక్రొనైజేషన్ ప్రిమిటివ్స్ (synchronization primitives) గణితాన్ని కలిపి ఉంచే గ్లూ వంటివి.
మీరు ఈ నాలుగు రంగాలలో ప్రపంచ స్థాయి నిపుణులు కావాల్సిన అవసరం లేదు. చాలా మంది కంట్రిబ్యూటర్లు ఒకే ఒక కెర్నల్ లేదా ఒక అలోకేటర్తో ప్రారంభించి, ఆర్కిటెక్చర్ స్థిరపడే కొద్దీ మిగిలిన వాటిని నేర్చుకుంటారు.
Architecture and Custom Math
బ్యాకెండ్ లాజిక్ సహకారంతో నిర్మించబడుతోంది, అది ఆర్కిటెక్చర్ చర్చలతో మొదలవుతుంది. ఇంజిన్ స్టాటిక్ కంప్యూటేషన్ గ్రాఫ్ను (static computation graph) ఉపయోగిస్తుందా, అంటే రన్టైమ్ కంటే ముందే మొత్తం మోడల్ నిర్వచించబడి మరియు ఆప్టిమైజ్ చేయబడుతుందా? లేదా ఆటోమేటిక్ డిఫరెన్షియేషన్ కోసం టేప్తో కూడిన ఈగర్ ఎగ్జిక్యూషన్ను (eager execution) సపోర్ట్ చేస్తుందా? ఆటోడిఫ్ (autodiff) ఎలా సూచించబడుతుంది—ఆపరేటర్ ఓవర్లోడింగ్ (operator overloading), సోర్స్ ట్రాన్స్ఫర్మేషన్ (source transformation), లేదా గ్రాఫ్ IR? ఈ నిర్ణయాలే మిగిలినవన్నీ నిర్ణయిస్తాయి.
కస్టమ్ న్యూరల్ నెట్ మ్యాథ్ అంటే కేవలం స్టాండర్డ్ లేయర్లను మళ్ళీ రాయడం మాత్రమే కాదు. కొత్త వాటిని కనిపెట్టే స్వేచ్ఛ అని అర్థం. మీకు నాన్-స్టాండర్డ్ స్పార్స్ కెర్నల్ (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 స్టాక్ ఒక బ్లాక్ బాక్స్ (black box) లాగా మారిపోయింది. మనం ఫ్రేమ్వర్క్లను మ్యాజిక్ ఉపకరణాలలాగా చూస్తాము: డేటా లోపలికి వెళ్తుంది, మోడల్ బయటకు వస్తుంది, మరియు డిప్లాయ్మెంట్ సమయంలో ఆ అస్పష్టత మనల్ని ఇబ్బంది పెట్టదని ఆశిస్తాము. CatAI ఆ సౌకర్యాన్ని తిరస్కరిస్తుంది. దీనిని నిర్మించడం నెమ్మదిగా ఉంటుంది. మీరు ఎక్కువ కోడ్ రాయాల్సి ఉంటుంది, ఎక్కువ సెగ్ఫాల్ట్లను (segfaults) డీబగ్ చేయాల్సి ఉంటుంది, మరియు హై-లెవల్ ఫ్రేమ్వర్క్లు మీ నుండి దాచే ఊహలను తిరిగి ఆలోచించాల్సి ఉంటుంది. కానీ మెషిన్ ఎందుకు అలా ప్రవర్తిస్తుందో కూడా మీరు అర్థం చేసుకుంటారు. హార్డ్వేర్ను విస్మరించి అబ్స్ట్రాక్ట్ చేయడానికి అందరూ పోటీ పడుతున్న ఈ పరిశ్రమలో, నేరుగా మెటల్ను తాకడం (touching the metal) వల్ల నిజమైన విలువ ఉంటుంది. APIలను పిలిచే వ్యక్తికి మరియు సిస్టమ్లను నిర్మించే వ్యక్తికి మధ్య ఉన్న తేడా ఆ అవగాహనయే.