Llama2.c: शुद्ध C फ़ाइल में Llama 2 inference

 (github.com/karpathy)
1 पॉइंट द्वारा GN⁺ 2023-07-24 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • llama2.c एक “fullstack” training·inference solution है, जो PyTorch से Llama 2 LLM architecture को train करता है और एक साधारण C फ़ाइल run.c से inference चलाता है
  • इसका मुख्य फोकस minimalism और simplicity है, और यह Llama 2 architecture को hardcode करके dependency-free शुद्ध C inference फ़ाइल के रूप में बनाया गया एक शैक्षणिक implementation है
  • यह इस दृष्टिकोण से TinyStories आधारित example model प्रदान करता है कि बहुत छोटे LLM भी यदि domain पर्याप्त रूप से संकीर्ण हो तो मजबूत performance दे सकते हैं
    • 15M parameter model लगभग 60MB download है और make run के बाद ./run stories15M.bin से चलाया जा सकता है
    • 42M और 110M parameter model भी दिए गए हैं, और 110M model को GPT-1 के समान आकार का बताया गया है
  • Meta के Llama 2 model का neural network architecture भी समान है, इसलिए inference संभव है, लेकिन checkpoint को Meta के निर्देशों के अनुसार प्राप्त करने के बाद export.py से llama2.c format में convert करना होगा
    • अभी run.c केवल fp32 inference करता है, इसलिए 7B से बड़े model को प्रोडक्टिव तरीके से load करना मुश्किल होने की संभावना है
    • 13B या उससे बड़े model अभी pointer arithmetic में integer overflow के कारण काम नहीं करते, और यह अभी तक ठीक नहीं किया गया है
  • int8 quantized inference runq.c में implemented है, और Q8_0 तरीके से matmul में भाग लेने वाले weights को quantize किया जाता है, जबकि activation values को runtime पर dynamic quantization·dequantization किया जाता है
    • Llama 2 7B fp32 export 26GB फ़ाइल बनाता है, और version 2 quantized export 6.7GB फ़ाइल बनाता है
    • लेखक के environment में OpenMP 64-thread के आधार पर fp32 4.6 tok/s और int8 14 tok/s पर चला, जिससे checkpoint size 4 गुना कम और लगभग 3 गुना speedup मिला
  • उपयोग का तरीका C inference execution, prompt input, temperature और top-p sampling control, chat mode execution, और custom tokenizer specification से बना है
    • example execution का format ./run stories42M.bin -t 0.8 -n 256 -i "One day, Lily met a Shoggoth" है
    • chat model को ./run llama2_7b_chat.bin -m chat की तरह -m chat flag से चलाया जाता है
    • custom tokenizer को tokenizer.py से .bin format में export करने के बाद -z flag से specify किया जाता है
  • Hugging Face पर Llama 2 architecture का उपयोग करने वाले model को export.py के --hf flag से .bin फ़ाइल में export किया जा सकता है
  • training flow में TinyStories download·pre-tokenization, train.py execution, model export, और फिर C inference शामिल है
    • फिलहाल दिया गया default TinyStories example ही उपलब्ध एकमात्र dataset example है
    • custom tokenizer training के लिए sentencepiece का उपयोग होता है, और उदाहरण के तौर पर --vocab_size=4096 setting इस्तेमाल की जाती है
  • performance-related build को make run, make runfast, make runomp में बांटा गया है, और OpenMP build matmul और attention के भीतर #pragma omp parallel for को enable करके loop work को कई processor में विभाजित करता है
  • platform build instructions Windows, Centos 7, Amazon Linux 2018, और Mac के लिए दिए गए हैं
    • Windows में build_msvc.bat या make win64 का उपयोग होता है
    • Centos 7 और Amazon Linux 2018 में make rungnu या make runompgnu का उपयोग होता है
    • Mac पर OpenMP build के लिए brew का clang install करने के बाद make runomp CC=/opt/homebrew/opt/llvm/bin/clang का उपयोग होता है
  • testing के लिए pytest और C test make testcc दिए गए हैं, और test_all.py C और Python में 200-step forward चलाकर ज्ञात expected output से तुलना करता है
  • project का लक्ष्य 2 आसान-पढ़ने योग्य .py training files और C inference code से बना एक सरल reference implementation बनाए रखना है, और यह complex framework या बहुत सारे options की दिशा में नहीं जाता
  • लाइसेंस MIT है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2023-07-24
Hacker News की राय

  • HN पर यह आया तो काफ़ी दिलचस्प लगा :) असली checkpoint को MacBook Air M1 पर -O3 के साथ compile करने पर उम्मीद से कहीं तेज़ 100 tok/s मिला, इसलिए अब एक बड़ा 44M मॉडल train किया जा रहा है
    फिर भी लगता है कि इसे interactive तौर पर चलाया जा सकेगा, और शायद 7B Llama मॉडल तक पहुँचना भी संभव हो सकता है

    • nanoGPT में थोड़ा बदलाव करके TinyStories के GPT-4 generated 2GB डेटा पर 12M मॉडल को pretrain करके देखा, और नतीजे काफ़ी चौंकाने वाले थे
      बाद में इसे Wikipedia पर थोड़ा adapt किया, तो यह smoothed n-gram मॉडल से कहीं ज़्यादा समझदार और उससे भी छोटा, लेकिन काफ़ी भरोसेमंद बकवास-जनरेटर बन गया। लगता है छोटे LLM कई क्षेत्रों में mainstream बनेंगे, और अगला लक्ष्य Llama2 7B को 10~100M तक छोटा करना है, बिना उसे बहुत ज़्यादा बेवकूफ़ बनाए
    • हमेशा की तरह यह काम प्रेरणादायक है। एक शुरुआती सवाल है: बिना किसी चमकदार GPU वाले सामान्य Linux server पर किसी शौकिया web app में जोड़ने लायक सही आकार का LLM चलाने का सबसे व्यावहारिक रास्ता क्या होगा
      Linode जैसी जगह से GPU instance किराए पर लेना सामान्य web app server से बहुत महँगा पड़ता है, तो जानना चाहता हूँ कि क्या यह पूरी तरह अव्यावहारिक क्षेत्र है, या यह तरीका या कोई और तरीका वास्तव में काम का हो सकता है
    • छोटे Llama-2 मॉडल और छोटे GPT-2 मॉडल की relative quality/performance पर कोई शुरुआती राय है क्या
    • जानना चाहता हूँ कि क्या Python की जगह pure C trainer भी बनाया जा सकता है
    • यह भी जानना चाहता हूँ कि इन मॉडलों को घर के हार्डवेयर, M1, या cloud में से कहाँ train किया जा रहा है

  • llama.cpp के लिए मशहूर Georgi Gerganov का Emscripten के साथ browser में चलने वाला एक version है: https://ggerganov.com/llama2.c/
    चल रही Twitter thread यहाँ है: https://twitter.com/ggerganov/status/1683174252990660610
    मूल काम और यह दोनों ही सच में शानदार हैं, और भले ही यह बहुत छोटे मॉडल के साथ किया गया proof of concept हो, फिर भी local-first LLM खास तौर पर दिलचस्प है। local inference के साथ web app बन सकने का विचार बहुत अच्छा है
    अगर यह optimization, छोटे मॉडल पर शोध, partial download, और WebGPU के उपयोग तक आगे बढ़ता है, तो यह private local LLM-आधारित apps बनाने के नए तरीकों की शुरुआत बन सकता है। top-end GPU वाले बड़े cluster पर host किए गए LLM जैसी क्षमता पाना मुश्किल होगा, लेकिन इस तरीके से खुलने वाले use cases बहुत हैं

    • पहले लिंक में काफ़ी अजीब output आया। शुरुआत में यह एक ठीक-ठाक परीकथा जैसा लगता है, लेकिन फिर typo बढ़ने लगते हैं और बात बिखर जाती है, और बीच में विदेशी भाषाएँ तथा technical/programming terms घुलने लगते हैं
      उदाहरण के लिए, यह “Once upon a time...” से शुरू होकर Lily और Timmy की कहानी जैसा दिखता है, फिर “Butterfly would pauseWhy”, “TextField”, querySelector, HttpRequest और कई भाषाओं के टुकड़ों के साथ पूरी तरह टूटे हुए output में बदल जाता है

  • जिन लोगों को दिलचस्पी हो, उनके लिए Rust version भी है। release mode में लगभग 106 tokens/second मिलता है
    https://github.com/garrisonhess/llama2.c/blob/517a1a3e487f31...

    • एक और Rust version भी है। इसमें पिछले महीने से जिस candle ML library पर काम हो रहा है, उसका उपयोग किया गया है, और यह browser में भी चल सकता है: https://laurentmazare.github.io/candle-llama2/index.html
      non-web version GPU को पूरी तरह support करता है, लेकिन बिल्कुल minimal नहीं है
    • जैसा Rust में अक्सर दिखता है, कभी-कभी लोग जो पहले से मौजूद है उसे सिर्फ इसलिए जस का तस port कर देते हैं कि वह किया जा सकता है, और उससे कोई खास फ़ायदा नहीं मिलता
      कभी-कभी इससे project को बेहतर बनाने की community की कोशिशें बिखर भी जाती हैं

  • लगता है बहुत लोग यह नहीं समझते कि यह कदम कितना साहसी है
    Andrej, OpenAI(MSFT) से बड़ा compensation लेते हुए भी, Apple, Facebook, और उससे भी महत्वपूर्ण open source movement की मदद कर रहे हैं। फिर भी उन्हें हटाना आसान नहीं होगा, क्योंकि उसके बाद वे सीधे Tesla या xAI जा सकते हैं

  • लगता है Llama-2 में creative काम के लिए इस्तेमाल करना मुश्किल हो जाने जितनी safety filtering है: https://i.imgur.com/GFY0wSL.png

    • मेरी निजी राय में, “safety” के नाम पर filtering इतनी ज़्यादा है कि यह उल्टा 180 डिग्री घूमकर घृणित या नकारात्मक stereotypes को मज़बूत करने तक जा सकती है: https://i.imgur.com/xkzXrPK.png और https://i.imgur.com/3HQ8FqL.png
      हालाँकि यह व्यवहार कुछ हद तक सिर्फ तब reproduce हुआ जब इसे Llama2-70b-chat TGI Hugging Face में दूसरे message के रूप में भेजा गया, इसलिए हो सकता है prompting के तरीके में कुछ अजीब बात हो जो ऐसा व्यवहार करा रही हो। मैं अभी खुद मॉडल चलाकर इसकी और जाँच नहीं कर पाया हूँ
    • अगर pretrained model उपलब्ध हो, तो instruct/chat मॉडल न इस्तेमाल करना बेहतर है
      Chat/instruct मॉडल third-party users को वितरित करने में आसान होते हैं, prompt सरल होता है, और इनमें safety guardrails होते हैं, लेकिन खुद इस्तेमाल करने के लिए ये pretrained मॉडल की तुलना में सच में बहुत कमतर हैं। इस मामले में Llama 2, OpenAI से बेहतर स्थिति में हो सकता है, क्योंकि OpenAI ने GPT-3 pretrained मॉडल को हटा दिया है और आगे सिर्फ chat मॉडल देने की दिशा में जाता दिख रहा है
    • कल्पना करें, Casca और Brutus, Caesar को छुरा घोंपने के बजाय उसकी संभावित power abuse और तानाशाही प्रवृत्तियों पर उससे विनम्रता से आमने-सामने बात करते हैं
    • ज़रूरत से ज़्यादा filtering पूरी llama-2 लाइन में नहीं, बल्कि Llama-2 chat में है
    • “ethical AI” वाले लोगों को किनारे करना चाहिए। यह दिन-ब-दिन साफ़ होता जा रहा है कि वे सच में बहुत परेशान करने वाले हैं
      मुझे safety scissors नहीं चाहिए। जो चीज़ें उनके अपने server पर चलती हैं, उन पर रोक लगाना ठीक है, लेकिन ऐसा मॉडल नहीं देना चाहिए जिसे मैं अपने कंप्यूटर पर अपनी मर्ज़ी से बदल और इस्तेमाल न कर सकूँ

  • Andrej ने इसके बारे में ज़्यादा विस्तार से यहाँ पोस्ट किया है: https://twitter.com/karpathy/status/1683143097604243456?s=46...

  • संदर्भ के लिए, अगर आपकी ऐसे विषयों में रुचि है, तो यह कोड WASI SDK के साथ साफ़-सुथरे तरीके से build हो जाता है और बिना किसी बदलाव के Wasm runtime में चल जाता है

  • जिज्ञासा है कि neural network चलाने के लिए वास्तव में कितनी memory चाहिए
    क्या डिस्क से शुरुआत में सिर्फ़ पहली दो layers पढ़कर, सभी nodes के activation values निकालकर, फिर पहली layer को हटा देना, उसके बाद तीसरी layer पढ़कर फिर से गणना करना और दूसरी layer को हटा देना—क्या इतना काफ़ी होगा? अगर हाँ, तो क्या memory में सिर्फ़ दो layers रखने भर की क्षमता होना पर्याप्त है?

    • Hugging Face के TheBloke ने लोकप्रिय models के quantized versions के हिसाब से memory requirements को दस्तावेज़ित किया है: https://huggingface.co/TheBloke
      सार यह है कि maximum RAM quantization method पर निर्भर करता है, और मोटे तौर पर 7B model के लिए 4~8GB, 13B model के लिए 8~15GB, 30B model के लिए 13~33GB, और 70B model के लिए 31~75GB की range है
    • पढ़कर खुद हटाने की ज़रूरत नहीं है। पूरे network को mmap कर दीजिए और operating system को इसे संभालने दीजिए
    • यह संभव है, लेकिन ऐसा करने पर आप disk bandwidth से सीमित हो जाएंगे
    • मेरी समझ में O(N²) transformer inference में सभी activation values को cache करना पड़ता है

  • अभी अचानक यह विचार आया: आज के LLM probability distribution लौटाते हैं, फिर एक random sampler उसमें से एक चुनकर output में जोड़ता है, और यह प्रक्रिया दोहराई जाती है
    इसकी जगह क्या ऐसा हो सकता है कि random process distribution का अनुमान लगाने वाले N tokens चुने, फिर LLM से N नई distributions बनवाई जाएँ, और उसके बाद उन्हें किसी तरीके से मिलाकर उस संयुक्त distribution से फिर N tokens चुने जाएँ?

    • यह काफ़ी हद तक beam search जैसा लगता है, और वास्तव में यह एक आम generation technique है: https://en.wikipedia.org/wiki/Beam_search
      उदाहरण https://huggingface.co/docs/transformers/internal/generation... में देखे जा सकते हैं
    • यह शोध के लायक दिशा लगती है, लेकिन शायद 2 tokens से काफ़ी आगे तक generate करना होगा। जैसे 20 tokens आगे देखना, लेकिन LLM को N^20 बार चलाना तो नहीं चाहेंगे, इसलिए शायद अगले 20-token combinations में से लगभग 200 representative samples चुनना बेहतर होगा
      हालांकि यह कैसे किया जाए, पता नहीं
    • मैं नया हूँ, लेकिन यह विचार मुझे पसंद आया। जवाब नहीं पता, पर इस पर experiment किया जा सकता है, और संभव है कि किसी researcher ने पहले ही इसे आज़माया हो
      बेशक, हर token generation पर N गुना computation लगेगा। आप top N चुन सकते हैं, या ज़रूरत हो तो logits पर temperature adjustment लगाकर N samples ले सकते हैं

  • क्या यह educational purpose के लिए है? llama.cpp और इस project की सफलता देखकर लगता है कि industry, PyTorch, TensorFlow, ONNX Runtime जैसे general-purpose frameworks की बजाय, जारी होने वाले हर model के लिए अलग source code रखने की दिशा में जा रही है

    • यह पूरी तरह educational लगता है
      और नहीं। नाम के विपरीत llama.cpp सिर्फ़ llama को support नहीं करता। यह पूरी तरह custom भी नहीं है, बल्कि ज़्यादा general ggml tensor library/framework के ऊपर बना है
    • frameworks के अंदर भी हर model के लिए अलग source code होता है। models, framework के building blocks को जोड़कर बने custom code होते हैं; वे सिर्फ़ framework से अपने-आप नहीं बन जाते। exploratory research की प्रकृति ही ऐसी है
      लेकिन जब कोई अच्छा काम करने वाला model मिल जाता है, तो उसके सुधार अक्सर framework के अगले versions में शामिल हो जाते हैं। इसी वजह से TensorFlow में CNN, GRU, TransformerEncoder जैसे building blocks आए, और साथ ही सामान्यता से कुछ समझौता करके speed पाने वाली specific hardware implementations भी बनीं
    • यह single-threaded है, इसलिए इसे educational मानना सही है