స్థానిక LLM మోడళ్ల బెంచ్‌మార్క్

ప్రాజెక్ట్ GitHub రిపోజిటరీ

నేపథ్య కథ

నేను Anarchy (YC W23) వద్ద పార్ట్-టైమ్ ఇంజినీరింగ్ ఇంటర్న్‌గా పనిచేసిన సమయంలో LLM Speed Benchmark (LLMSB)ను రూపొందించాను. LLMSB అనేది LLM మోడల్ పనితీరును అంచనా వేయడానికి ఉపయోగించే బెంచ్‌మార్కింగ్ సాధనం. ఇది LLM మోడల్‌ను లోడ్ చేసి నడపడానికి HuggingFace యొక్క transformers లైబ్రరీని ఉపయోగిస్తుంది మరియు ఇవి కొలుస్తుంది:

  • మొత్తం రన్‌టైమ్
  • సెకనుకు టోకెన్లు
  • సాధారణ హార్డ్‌వేర్ వివరాలు
  • CPU వినియోగం (ప్రస్తుత ఫ్రీక్వెన్సీ మరియు కాలక్రమేణా కోర్ల వినియోగ శాతం)
  • RAM వినియోగం (కాలక్రమేణా RAM మరియు స్వాప్)
  • GPU వినియోగం (కాలక్రమేణా లోడ్, మెమరీ వినియోగం మరియు ఉష్ణోగ్రత)

ఇక్కడ codellama-13b-oasst-sft-v10 మోడల్‌ను H100పై నడిపిన బెంచ్‌మార్క్ రన్‌కు ఒక ఉదాహరణ ఉంది. నా వద్ద వ్యక్తిగతంగా 8 GB VRAM కలిగిన Nvidia RTX 2070 Ti ఉంది. దురదృష్టవశాత్తూ, చాలా ఆధునిక LLM మోడళ్లకు, మోడల్‌తో ఇంటర్‌ఫేస్ చేయడానికి 8 GB VRAM సరిపోదు. అందువల్ల, కొన్ని మోడళ్లపై నా బెంచ్‌మార్క్‌లను నడపడానికి GPU(లను) “అద్దెకు” తీసుకోవడానికి RunPodను ఉపయోగించాను.

ఇది LLMSB యొక్క నేపథ్య కథ/ఆవిర్భావ కథ. ఈ ప్రాజెక్ట్ ఓపెన్-సోర్స్ కావడంతో, మీరు కోడ్‌ను ఇక్కడ చూడవచ్చు. మీరు పరిశీలించాలనుకుంటే, రిపోజిటరీలోని READMEను క్రింద చేర్చాను.

గురించి

🚧 LLM Speed Benchmark (LLMSB) ప్రస్తుతం బీటా (v0) దశలో ఉంది. దయచేసి దీన్ని ప్రొడక్షన్‌లో ఉపయోగించవద్దు, లేదా మీ స్వంత ప్రమాదంలో ఉపయోగించండి. మేము ఇప్పటికీ కొన్ని సమస్యలను పరిష్కరిస్తూ, కార్యాచరణను మెరుగుపరుస్తున్నాము. మీకు ఏవైనా బగ్‌లు ఎదురైతే లేదా సూచనలు ఉంటే, దయచేసి వాటిని ISSUES కింద నివేదించండి. మీ అభిప్రాయం అమూల్యమైనది!

LLM Speed Benchmark (LLMSB) అనేది వివిధ హార్డ్‌వేర్ ప్లాట్‌ఫారమ్‌లపై LLM మోడళ్ల పనితీరును అంచనా వేయడానికి ఉపయోగించే బెంచ్‌మార్కింగ్ సాధనం. వివిధ సిస్టమ్‌లపై LLM మోడళ్ల పనితీరును వివరించే సమగ్ర డేటాసెట్‌ను రూపొందించడం దీని అంతిమ లక్ష్యం. దీని ద్వారా వినియోగదారులు తమ ప్రాజెక్ట్‌లకు సరైన LLM మోడల్(లను) మరింత సమర్థవంతంగా ఎంచుకోగలుగుతారు.

పరిమితులు

LLMSB v0లో ఉంది, కాబట్టి దీనికి కొన్ని పరిమితులు ఉన్నాయి:

  • ఇది Debian ఆధారిత ఆపరేటింగ్ సిస్టమ్‌లపై మాత్రమే నడిచేలా రూపొందించబడింది; అంటే Windowsపై నడిచేలా రూపొందించబడలేదు. ఎందుకంటే LLMSB వెనుకభాగంలో మెట్రిక్‌లను సేకరించడానికి neofetch మరియు nvidia-smiలను ఉపయోగిస్తుంది, అలాగే ఫైల్‌పాత్ లాజిక్ Unix ఆపరేటింగ్ సిస్టమ్‌లపై ఆధారపడి ఉంటుంది.
  • మెట్రిక్‌లు నమోదు చేయబడే విధానం కారణంగా, మెట్రిక్‌ల కలెక్టర్‌కు ఒక సేకరణ చేయడానికి 1 సెకను వరకు పట్టవచ్చు. అంటే, అత్యంత వేగంగా మనం ప్రతి 1 సెకనుకూ హార్డ్‌వేర్ మెట్రిక్‌లను సేకరించగలం.
  • మోడళ్లను లోడ్ చేసి నడపడానికి LLMSB కేవలం HuggingFaceను మాత్రమే ఉపయోగిస్తుంది. ప్రస్తుతానికి ఇది పనిచేస్తుంది, కానీ HuggingFaceకే పరిమితం కాకుండా, అనేక ఫ్రేమ్‌వర్క్‌లకు LLMSB మద్దతు ఇవ్వాలన్నది లక్ష్యం.
  • ప్రస్తుతం, అన్ని మోడళ్లూ src/hf.pyలో ఉన్న run_llm() ఫంక్షన్‌లో చూపిన లాజిక్‌ ద్వారా నడపబడుతున్నాయి. ఇందులో మోడల్‌ను లోడ్ చేసి నడపడానికి AutoTokenizer() మరియు AutoModelForCausalLM() ఫంక్షన్‌లు ఉపయోగించబడతాయి. ఇది పనిచేస్తుంది, కానీ నిర్దిష్ట మోడళ్లను ఎలా కాన్ఫిగర్/ఆప్టిమైజ్ చేయగలమో దానిపై పరిమితి విధిస్తుంది. దీన్ని దృష్టిలో ఉంచుకుని, ప్రతి ప్రముఖ మోడల్‌ కోసం ప్రత్యేక క్లాస్‌లను సృష్టించి, దాని బదులుగా LlamaTokenizer మరియు LlamaForCausalLM వంటి HuggingFace యొక్క మోడల్-నిర్దిష్ట క్లాస్‌లను ఉపయోగించాలన్నది లక్ష్యం.
  • LLMSB సాధారణ, ఉన్నత-స్థాయి మెట్రిక్‌లను మాత్రమే సేకరిస్తుంది. భవిష్యత్తులో, తక్కువ-స్థాయి మెట్రిక్‌లను సేకరించాలని మేము కోరుకుంటున్నాము. ఇది కొంతవరకు Pytorch యొక్క porfiler wrapperను ఉపయోగించడం ద్వారా సాధ్యమవుతుందని మేము భావిస్తున్నాము.

నమూనా అవుట్‌పుట్‌లు

నవంబర్ 22, 2023

LLMSB RunPod ద్వారా L40 మరియు H100 GPUలపై నడిపి/పరీక్షించబడింది. ఆ బెంచ్‌మార్క్‌లలో llama-2-7b-hf, codellama-13b-oasst-sft-v10, మరియు mpt-7b మోడళ్లను పరీక్షించారు. ఫలితాలను ఇక్కడ చూడండి. ఏవైనా లోపాలు/సమస్యలు కనిపిస్తే, దయచేసి వాటిని 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ను ఇన్‌స్టాల్ చేయండి

    # install pytorch stable build, for linux, using CUDA 12.1:
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",   # the model's path/repo on HuggingFace (https://huggingface.co/models)
  "prompt": "Hello World!",           # the prompt you want to input into the LLM model
  "device": "cuda:0",                 # the device you want to run the LLM model on (GPU/CPU)
  "max_length": 50,                   # the maximun length of the generated tokens
  "temperature": 0.9,                 # temperatue value for the LLM model
  "top_k": 50,                        # top-k value for the LLM model
  "top_p": 0.9,                       # top-p value for the LLM model
  "num_return_sequences": 1,          # the number of independently ran instances of the model
  "time_delay": 0,                    # the time delay (seconds) the metrics-collecter will wait per interation
  "model_start_pause": 1,             # the time (seconds) the test will wait BEFORE running the LLM model
  "model_end_pause": 1                # the time (seconds) the test will wait AFTER the LLM model is done running,
  "framework": "llm-vm"               # the name of the framework/library you want to use to run the model
}

  3. మునుపటి దశలో మీరు సృష్టించిన కాన్ఫిగ్ ఫైల్ పాత్‌ను ఉపయోగించి, బెంచ్‌మార్క్‌ను ప్రారంభించడానికి కింది వాటిలో ఒక ఎంపికను అమలు చేయండి:

    # run one benchmark
python3 run.py --config ./configs/llmvm_test.json

# run more then one benchmark (in this case 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 సర్టిఫికేట్/కీని సెటప్ చేసి, ఒక పాడ్‌ను నడుపుతూ ఉండేలా చేయండి. మీరు RunPod కన్సోల్ పేజీలో మీ పాడ్(ల)ను యాక్సెస్ చేయవచ్చు.

  2. 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. మీరు పాడ్‌తో పని పూర్తి చేసిన తర్వాత, దాన్ని షట్‌డౌన్ చేయండి లేదా పాజ్ చేయండి. అయితే హెచ్చరిక: మీరు దాన్ని పాజ్ చేసినా కూడా ఛార్జీలు వస్తూనే ఉంటాయి, కేవలం చాలా తక్కువగా ఉంటాయి.

గొప్ప వనరులు: