LLM गति बेंचमार्क

प्रोजेक्ट का GitHub रेपो

पृष्ठभूमि

मैंने LLM Speed Benchmark (LLMSB) को अपने पार्ट‑टाइम इंजीनियरिंग इंटर्नशिप के दौरान Anarchy (YC W23) में बनाया था। LLMSB एक बेंचमार्किंग टूल है जो LLM मॉडल के प्रदर्शन का मूल्यांकन करता है। यह HuggingFace की transformers लाइब्रेरी का उपयोग करके मॉडल को लोड और चलाता है और यह मापता है:

  • कुल रनटाइम
  • टोकन प्रति सेकंड
  • सामान्य हार्डवेयर स्पेसिफिकेशन
  • CPU उपयोग (वर्तमान फ़्रीक्वेंसी और कोर उपयोग % समय के साथ)
  • RAM उपयोग (RAM और स्वैप समय के साथ)
  • GPU उपयोग (लोड, मेमोरी उपयोग, और तापमान समय के साथ)

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

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

परिचय

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

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

सीमाएँ

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

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

नमूना आउटपुट

22 नवंबर, 2023

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

सेटअप

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

    python3 -m venv env
source env/bin/activate

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

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

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

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

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

    # linux के लिए CUDA 12.1 के साथ स्थिर बिल्ड स्थापित करें:
pip3 install torch torchvision torchaudio

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

    pip install llm-vm

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

    huggingface-cli login

कैसे चलाएँ

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

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

    • नोट: हर फ्रेमवर्क समान पैरामीटर सपोर्ट नहीं करता
    {
  "model": "bigscience/bloom-560m",   # HuggingFace पर मॉडल का पाथ/रेपो (https://huggingface.co/models)
  "prompt": "Hello World!",           # वह प्रॉम्प्ट जिसे आप LLM मॉडल में इनपुट करना चाहते हैं
  "device": "cuda:0",                 # वह डिवाइस जिस पर आप LLM मॉडल चलाना चाहते हैं (GPU/CPU)
  "max_length": 50,                   # उत्पन्न टोकनों की अधिकतम लंबाई
  "temperature": 0.9,                 # मॉडल के लिए तापमान मान
  "top_k": 50,                        # मॉडल के लिए top‑k मान
  "top_p": 0.9,                       # मॉडल के लिए top‑p मान
  "num_return_sequences": 1,          # मॉडल की स्वतंत्र रूप से चलने वाली इंस्टेंस की संख्या
  "time_delay": 0,                    # मेट्रिक्स‑कलेक्टर प्रत्येक इटरशन पर कितना समय (सेकंड) इंतजार करेगा
  "model_start_pause": 1,             # टेस्ट को LLM मॉडल चलाने से पहले कितना समय (सेकंड) इंतजार करना है
  "model_end_pause": 1                # टेस्ट को LLM मॉडल समाप्त होने के बाद कितना समय (सेकंड) इंतजार करना है,
  "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 प्रमाणपत्र/की सेट करें, और एक पॉड चलाएँ। आप अपने पॉड(s) को RunPod की कंसोल पेज पर एक्सेस कर सकते हैं।

  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 में दिए गए कमांड का उपयोग करके आप पॉड में SSH कर सकते हैं और उस RunPod पॉड में चयनित GPU का उपयोग कर सकते हैं।

  4. यदि आप पॉड से अपनी स्थानीय मशीन पर कोई फ़ाइल कॉपी करना चाहते हैं, तो आप इस फ़ॉर्मेट में कमांड चलाएँगे (यह चरण #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. पॉड के साथ काम समाप्त करने के बाद, इसे बंद कर दें या पॉज़ कर दें। लेकिन सावधान रहें, यदि आप इसे पॉज़ करते हैं तो भी आपसे शुल्क लिया जाएगा, लेकिन बहुत कम।

उत्कृष्ट स्रोत: