स्थानीय एलएलएम मॉडलों का बेंचमार्क

प्रोजेक्ट का गिटहब रिपॉज़िटरी

पृष्ठभूमि

मैंने एलएलएम स्पीड बेंचमार्क (LLMSB) अपने अंशकालिक इंजीनियरिंग इंटर्न के समय में Anarchy (YC W23) में बनाया। LLMSB एक बेंचमार्किंग उपकरण है, जो एक एलएलएम मॉडल के प्रदर्शन का आकलन करता है। यह एक एलएलएम मॉडल को लोड करने और चलाने के लिए HuggingFace की transformers लाइब्रेरी का उपयोग करता है और यह मापता है:

  • कुल रनटाइम
  • प्रति सेकंड टोकन
  • सामान्य हार्डवेयर विनिर्देश
  • सीपीयू उपयोग (वर्तमान आवृत्ति और समय के साथ कोर के उपयोग का %)
  • रैम उपयोग (समय के साथ रैम और स्वैप)
  • जीपीयू उपयोग (लोड, मेमोरी उपयोग, और समय के साथ तापमान)

यहाँ codellama-13b-oasst-sft-v10 मॉडल का एक बेंचमार्क रन का उदाहरण है, जो एक H100 पर चल रहा है। मेरे पास व्यक्तिगत रूप से एक Nvidia RTX 2070 Ti है, जिसमें 8 GB VRAM है। दुर्भाग्य से, अधिकांश आधुनिक एलएलएम मॉडलों के लिए, 8 GB VRAM किसी मॉडल के साथ इंटरफेस करने के लिए पर्याप्त नहीं है। इसी कारण, मैंने कुछ मॉडलों पर अपने बेंचमार्क चलाने के लिए जीपीयू(s) को “किराए” पर लेने हेतु RunPod का उपयोग किया।

यह LLMSB की पृष्ठभूमि/उत्पत्ति कथा थी। चूँकि यह परियोजना ओपन-सोर्स है, आप कोड यहाँ देख सकते हैं। नीचे, मैंने रिपॉज़िटरी से README शामिल किया है, यदि आप उसे देखना चाहें।

बारे में

🚧 एलएलएम स्पीड बेंचमार्क (LLMSB) वर्तमान में बीटा (v0) में है। कृपया इसे उत्पादन में उपयोग न करें, या इसे अपने जोखिम पर उपयोग करें। हम अभी भी कुछ खामियों को दूर कर रहे हैं और कार्यक्षमता में सुधार कर रहे हैं। यदि आपको कोई बग मिलता है या आपके पास सुझाव हैं, तो कृपया उन्हें ISSUES के तहत रिपोर्ट करें। आपकी प्रतिक्रिया अमूल्य है!

एलएलएम स्पीड बेंचमार्क (LLMSB) एक बेंचमार्किंग उपकरण है, जो विभिन्न हार्डवेयर प्लेटफार्मों पर एलएलएम मॉडलों के प्रदर्शन का आकलन करता है। इसका अंतिम लक्ष्य एक व्यापक डेटासेट संकलित करना है, जो विभिन्न प्रणालियों पर एलएलएम मॉडलों के प्रदर्शन का विवरण देता है, जिससे उपयोगकर्ता अपने प्रोजेक्ट्स के लिए सही एलएलएम मॉडल(s) को अधिक प्रभावी ढंग से चुन सकें।

सीमाएँ

LLMSB v0 पर है, इसलिए इसमें सीमाएँ हैं:

  • इसे केवल डेबियन-आधारित ऑपरेटिंग सिस्टमों पर चलाने के लिए डिज़ाइन किया गया है, यानी इसे Windows पर चलाने के लिए डिज़ाइन नहीं किया गया है। इसका कारण यह है कि LLMSB नीचे की ओर मेट्रिक्स इकट्ठा करने के लिए neofetch और nvidia-smi का उपयोग करता है और फ़ाइलपाथ लॉजिक यूनिक्स ऑपरेटिंग सिस्टमों पर आधारित है।
  • मेट्रिक्स रिकॉर्ड किए जाने के तरीके के कारण, मेट्रिक्स कलेक्टर को एक संग्रह करने में 1 सेकंड तक लग सकता है। इसका मतलब है कि, सबसे तेज़ स्थिति में, हम हर 1 सेकंड में हार्डवेयर मेट्रिक्स एकत्र कर सकते हैं।
  • LLMSB केवल मॉडल लोड और चलाने के लिए HuggingFace का उपयोग करता है। यह अभी के लिए काम करता है, लेकिन लक्ष्य यह है कि LLMSB केवल HuggingFace ही नहीं, बल्कि कई फ्रेमवर्क्स का समर्थन करे।
  • वर्तमान में, सभी मॉडल run_llm() फ़ंक्शन में प्रस्तुत लॉजिक के माध्यम से चलाए जाते हैं, जो src/hf.py में स्थित है, जहाँ AutoTokenizer() और AutoModelForCausalLM() फ़ंक्शनों का उपयोग मॉडल लोड और चलाने के लिए किया जाता है। यह काम करता है, लेकिन यह सीमित करता है कि हम विशिष्ट मॉडलों को कैसे कॉन्फ़िगर/अनुकूलित कर सकते हैं। यह जानते हुए, लक्ष्य प्रत्येक लोकप्रिय मॉडल के लिए अलग-अलग क्लासेज़ बनाना और HuggingFace की मॉडल-विशिष्ट क्लासेज़, जैसे LlamaTokenizer और LlamaForCausalLM, का उपयोग करना है।
  • LLMSB केवल सामान्य, उच्च-स्तरीय मेट्रिक्स एकत्र करता है। भविष्य में, हम निम्न-स्तरीय मेट्रिक्स एकत्र करना चाहेंगे। हमें लगता है कि यह आंशिक रूप से Pytorch के porfiler wrapper का उपयोग करके किया जा सकता है।

नमूना आउटपुट

22 नवंबर, 2023

LLMSB को RunPod के माध्यम से एक L40 और H100 जीपीयू पर चलाया/परीक्षण किया गया था। उन बेंचमार्क्स में llama-2-7b-hf, codellama-13b-oasst-sft-v10, और mpt-7b मॉडलों का परीक्षण किया गया था। परिणाम यहाँ देखें। यदि कोई त्रुटियाँ/समस्याएँ दिखाई दें, तो कृपया उन्हें ISSUES में रिपोर्ट करें।

सेटअप

  1. पायथन वातावरण बनाएं और सक्रिय करें:

    python3 -m venv env
source env/bin/activate

  2. पैकेज निर्भरताएँ स्थापित करें (APT का उपयोग करके):

    apt -y update
apt install -y vim
apt install -y neofetch

  3. पायथन निर्भरताएँ स्थापित करें:

    pip3 install transformers
pip3 install psutil
pip3 install gputil
pip3 install tabulate
pip3 install sentencepiece
pip3 install protobuf

  4. Pytorch स्थापित करें

    # CUDA 12.1 का उपयोग करते हुए, Linux के लिए pytorch का stable build स्थापित करें:
pip3 install torch torchvision torchaudio

  5. LLM-VM स्थापित करें:

    pip install llm-vm

  6. (वैकल्पिक) यदि आप LLAMA जैसे मॉडल उपयोग कर रहे हैं, तो आपको एक HuggingFace एक्सेस टोकन की आवश्यकता होगी। अपना एक्सेस टोकन यहाँ सेटअप करें, फिर निम्न कमांड चलाकर अपने टोकन को अपनी कंसोल में सहेजें:

    huggingface-cli login

कैसे चलाएँ

  1. सेटअप अनुभाग में सूचीबद्ध चरणों को पूरा करें।

  2. अपने सेट को कॉन्फ़िगर करने के लिए, आपको निम्न पैरामीटरों के साथ एक json फ़ाइल बनानी होगी (यहाँ एक उदाहरण है):

    • नोट: हर फ्रेमवर्क समान पैरामीटरों का समर्थन नहीं करता
    {
  "model": "bigscience/bloom-560m",   # मॉडल का HuggingFace पर पथ/रिपो (https://huggingface.co/models)
  "prompt": "Hello World!",           # वह प्रॉम्प्ट जिसे आप एलएलएम मॉडल में इनपुट करना चाहते हैं
  "device": "cuda:0",                 # वह डिवाइस जिस पर आप एलएलएम मॉडल चलाना चाहते हैं (GPU/CPU)
  "max_length": 50,                   # जनरेट किए गए टोकनों की अधिकतम लंबाई
  "temperature": 0.9,                 # एलएलएम मॉडल के लिए तापमान मान
  "top_k": 50,                        # एलएलएम मॉडल के लिए टॉप-के मान
  "top_p": 0.9,                       # एलएलएम मॉडल के लिए टॉप-पी मान
  "num_return_sequences": 1,          # मॉडल के स्वतंत्र रूप से चलाए गए उदाहरणों की संख्या
  "time_delay": 0,                    # मेट्रिक्स-कलेक्टर प्रत्येक इंटरेशन पर प्रतीक्षा करेगा वाला समय विलंब (सेकंड)
  "model_start_pause": 1,             # परीक्षण एलएलएम मॉडल चलाने से पहले प्रतीक्षा करेगा वाला समय (सेकंड)
  "model_end_pause": 1                # एलएलएम मॉडल के चलना समाप्त होने के बाद परीक्षण प्रतीक्षा करेगा वाला समय (सेकंड),
  "framework": "llm-vm"               # उस फ्रेमवर्क/लाइब्रेरी का नाम जिसका उपयोग आप मॉडल चलाने के लिए करना चाहते हैं
}

  3. पिछले चरण में आपके द्वारा बनाई गई कॉन्फ़िग फ़ाइल के पथ का उपयोग करते हुए, बेंचमार्क शुरू करने के लिए निम्न चलाएँ (कोई एक विकल्प चुनें):

    # एक बेंचमार्क चलाएँ
python3 run.py --config ./configs/llmvm_test.json

# एक से अधिक बेंचमार्क चलाएँ (इस मामले में 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. जब बेंचमार्क चलना समाप्त हो जाए, तो अंतिम परिणामों को एक फ़ाइल में देखें, जो कुछ इस तरह दिखनी चाहिए:

    report_2023-11-25_05:55:04.207515_utc_1ffc4fa7-3aa9-4878-b874-1ff445e1ff8a.json

RunPod सेट अप करना:

  1. RunPod सेटअप करें, अपना ssh प्रमाणपत्र/कुंजी सेटअप करें, और एक pod चलाएँ। आप अपने pod(s) को RunPod के Console Page पर एक्सेस कर सकते हैं।

  2. “Connect” बटन पर क्लिक करके ssh कनेक्शन जानकारी प्राप्त करें। यह जानकारी कुछ इस तरह दिखनी चाहिए:

    ssh root&12.345.678.90 -p 12345 -i ~/.ssh/id_example

    • यह कमांड इस प्रकार फ़ॉर्मेट की जाएगी:

      ssh <user>@<ip-address> -p <port> -i <local-path-to-ssh-cert>

  3. चरण #2 में दिए गए कमांड का उपयोग करके, आप pod में ssh कर सकेंगे और RunPod pod में आपने जो जीपीयू चुना है, उसका उपयोग कर सकेंगे।

  4. यदि आप pod से अपने स्थानीय मशीन पर कोई फ़ाइल कॉपी करना चाहते हैं, तो आप इस प्रारूप में कमांड चलाएँगे (यह चरण #2 में दिखाए गए वेरिएबल्स का संदर्भ देता है):

    scp -P <port> -i <local-path-to-ssh-cert> <user>@<ip-address>:<path-to-file-in-pod> <path-to-local-directory>

    • यहाँ ऐसे कमांड का एक उदाहरण है:

      scp -P 12345 -i ~/.ssh/id_example <user>@<ip-address>:/root/test.txt /home/user1/Downloads/

  5. जब आप pod के साथ काम समाप्त कर लें, तो उसे बंद कर दें या उसे रोक दें। लेकिन चेतावनी: यदि आप उसे रोकते हैं, तो भी आपसे शुल्क लिया जाएगा, बस बहुत कम।

शानदार स्रोत: