ਲੋਕਲ LLM ਮਾਡਲਾਂ ਦਾ ਬੈਂਚਮਾਰਕ

ਪ੍ਰੋਜੈਕਟ ਦਾ GitHub ਰੇਪੋ

ਪਿਛੋਕੜ

ਮੈਂ LLM Speed Benchmark (LLMSB) ਆਪਣੀ ਨੌਕਰੀ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਇੰਜੀਨੀਅਰਿੰਗ ਇੰਟਰਨ ਦੇ ਤੌਰ ‘ਤੇ Anarchy (YC W23) ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਬਣਾਇਆ ਸੀ। LLMSB ਇੱਕ ਬੈਂਚਮਾਰਕਿੰਗ ਟੂਲ ਹੈ ਜੋ LLM ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਮਾਪਦਾ ਹੈ। ਇਹ HuggingFace ਦੀਆਂ transformers ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ LLM ਮਾਡਲ ਨੂੰ ਲੋਡ ਅਤੇ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਇਹ ਮਾਪਦਾ ਹੈ:

  • ਕੁੱਲ ਰਨਟਾਈਮ
  • ਟੋਕਨ ਪ੍ਰਤੀ ਸਕਿੰਟ
  • ਜਨਰਲ ਹਾਰਡਵੇਅਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ
  • CPU ਉਪਯੋਗ (ਮੌਜੂਦਾ ਫ੍ਰੀਕਵੈਂਸੀ & ਕੋਰਾਂ ਦੀ ਉਪਯੋਗਤਾ % ਸਮੇਂ ਦੇ ਨਾਲ)
  • ਰੈਮ ਉਪਯੋਗ (ਰੈਮ & ਸਵੈਪ ਸਮੇਂ ਦੇ ਨਾਲ)
  • GPU ਉਪਯੋਗ (ਲੋਡ, ਮੈਮੋਰੀ ਉਪਯੋਗਤਾ, ਅਤੇ ਤਾਪਮਾਨ ਸਮੇਂ ਦੇ ਨਾਲ)

ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਇੱਕ ਬੈਂਚਮਾਰਕ ਰਨ ਦੀ ਲਈ ਮਾਡਲ codellama-13b-oasst-sft-v10 ਜੋ H100 ‘ਤੇ ਚੱਲ ਰਿਹਾ ਸੀ। ਮੇਰੇ ਕੋਲ ਨਿੱਜੀ ਤੌਰ ‘ਤੇ ਇੱਕ Nvidia RTX 2070 Ti ਹੈ, ਜਿਸ ਵਿੱਚ 8 GB VRAM ਹੈ। ਦੁਖ ਦੀ ਗੱਲ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ ਆਧੁਨਿਕ LLM ਮਾਡਲਾਂ ਲਈ 8 GB VRAM ਮਾਡਲ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਨਹੀਂ ਹੁੰਦਾ। ਇਸ ਲਈ, ਮੈਂ ਕੁਝ ਮਾਡਲਾਂ ‘ਤੇ ਆਪਣੇ ਬੈਂਚਮਾਰਕ ਚਲਾਉਣ ਲਈ GPU(s) “ਕਿਰਾਏ” ‘ਤੇ ਲੈਣ ਲਈ RunPod ਦੀ ਵਰਤੋਂ ਕੀਤੀ।

ਇਹ LLMSB ਦੀ ਪਿਛੋਕੜ/ਉਤਪੱਤੀ ਕਹਾਣੀ ਸੀ। ਪ੍ਰੋਜੈਕਟ open-source ਹੈ, ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਇੱਥੇ ਵੇਖ ਸਕਦੇ ਹੋ। ਹੇਠਾਂ, ਮੈਂ ਰੇਪੋ ਤੋਂ README ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਚੈੱਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।

ਬਾਰੇ

🚧 LLM Speed Benchmark (LLMSB) ਇਸ ਵੇਲੇ ਬੀਟਾ (v0) ਵਿੱਚ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਇਸਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਵਰਤੋਂ ਨਾ ਕਰੋ, ਜਾਂ ਆਪਣੀ ਜੋਖਮ ‘ਤੇ ਵਰਤੋਂ ਕਰੋ। ਅਸੀਂ ਹਾਲੇ ਕੁਝ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਠੀਕ ਕਰ ਰਹੇ ਹਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਲਟੀ ਨੂੰ ਸੁਧਾਰ ਰਹੇ ਹਾਂ। ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਬੱਗ ਨੂੰ ਦੇਖੋ ਜਾਂ ਕਿਸੇ ਸੁਝਾਅ ਹੋਵੇ, ਕਿਰਪਾ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ISSUES ਵਿੱਚ ਰਿਪੋਰਟ ਕਰੋ। ਤੁਹਾਡਾ ਫੀਡਬੈਕ ਬੇਹੱਦ ਕੀਮਤੀ ਹੈ!

LLM Speed Benchmark (LLMSB) ਇੱਕ ਬੈਂਚਮਾਰਕਿੰਗ ਟੂਲ ਹੈ ਜੋ ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ ਪਲੇਟਫਾਰਮਾਂ ‘ਤੇ LLM ਮਾਡਲਾਂ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਮਾਪਣ ਲਈ ਹੈ। ਇਸ ਦਾ ਅੰਤਿਮ ਲਕੜੀ ਇਹ ਹੈ ਕਿ ਵੱਖ-ਵੱਖ ਸਿਸਟਮਾਂ ‘ਤੇ LLM ਮਾਡਲਾਂ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਡੇਟਾਸੈੱਟ ਤਿਆਰ ਕਰਨਾ, ਤਾਂ ਜੋ ਯੂਜ਼ਰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਸਹੀ LLM ਮਾਡਲ(ਆਂ) ਨੂੰ ਜ਼ਿਆਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਚੁਣ ਸਕਣ।

ਸੀਮਾਵਾਂ

LLMSB v0 ‘ਤੇ ਹੈ, ਇਸ ਲਈ ਇਸ ਦੀਆਂ ਕੁਝ ਸੀਮਾਵਾਂ ਹਨ:

  • ਸਿਰਫ Debian ਆਧਾਰਿਤ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ‘ਤੇ ਚੱਲਾਉਣ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਦੂਜੀ ਸ਼ਰਤ ਇਹ ਹੈ ਕਿ ਇਹ Windows ‘ਤੇ ਚੱਲਾਉਣ ਲਈ ਡਿਜ਼ਾਈਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿ LLMSB ਹੇਠਾਂ ਮੈਟਰਿਕਸ ਇਕੱਠਾ ਕਰਨ ਲਈ neofetch ਅਤੇ nvidia-smi ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਫਾਈਲਪਾਥ ਲਾਜਿਕ ਯੂਨਿਕਸ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ‘ਤੇ ਆਧਾਰਿਤ ਹੈ।
  • ਜਿਵੇਂ ਕਿ ਮੈਟਰਿਕਸ ਰਿਕਾਰਡ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਮੈਟਰਿਕਸ ਕਲੇਕਟਰ ਨੂੰ ਇਕ ਕਲੇਕਸ਼ਨ ਕਰਨ ਵਿੱਚ ਲਗਭਗ 1 ਸਕਿੰਟ ਲੱਗ ਸਕਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕੇ ਨਾਲ ਅਸੀਂ ਹਰ 1 ਸਕਿੰਟ ‘ਤੇ ਹਾਰਡਵੇਅਰ ਮੈਟਰਿਕਸ ਇਕੱਠੇ ਕਰ ਸਕਦੇ ਹਾਂ।
  • LLMSB ਸਿਰਫ HuggingFace ਨੂੰ ਮਾਡਲ ਲੋਡ ਅਤੇ ਚਲਾਉਣ ਲਈ ਵਰਤਦਾ ਹੈ। ਇਹ ਹੁਣ ਲਈ ਚੱਲਦਾ ਹੈ, ਪਰ ਲਕੜੀ ਇਹ ਹੈ ਕਿ LLMSB ਨੂੰ ਇੱਕ ਤੋਂ ਵੱਧ ਫਰੇਮਵਰਕਾਂ ਲਈ ਸਹਾਇਤਾ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ, ਸਿਰਫ HuggingFace ਹੀ ਨਹੀਂ।
  • ਇਸ ਵੇਲੇ, ਸਾਰੇ ਮਾਡਲ src/hf.py ਵਿੱਚ ਮੌਜੂਦ run_llm() ਫੰਕਸ਼ਨ ਵਿੱਚ ਦਿੱਖਾਈ ਦੇਣ ਵਾਲੀ ਲੌਜਿਕ ਰਾਹੀਂ ਚਲਾਏ ਜਾਂਦੇ ਹਨ, ਜਿੱਥੇ 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 ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ। ਨਤੀਜੇ ਵੇਖੋ ਇੱਥੇ। ਜੇ ਕਿਸੇ ਤਰ੍ਹਾਂ ਦੀਆਂ ਗਲਤੀਆਂ/ਮਸਲੇ ਨੋਟਿਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਕਿਰਪਾ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ 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 ਇੰਸਟਾਲ ਕਰੋ

    # 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. ਪਿਛਲੇ ਕਦਮ ਵਿੱਚ ਬਣਾਈ ਗਈ config ਫਾਈਲ ਦੇ ਪਾਥ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਬenchਮਾਰਕ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਚੁਣੋ ਅਤੇ ਚਲਾਓ (ਇੱਕ ਵਿਕਲਪ ਚੁਣੋ):

    # 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. ਬenchਮਾਰਕ ਦੇ ਚਲ ਕੇ ਖਤਮ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਅੰਤਿਮ ਨਤੀਜੇ ਇੱਕ ਫਾਇਲ ਵਿੱਚ ਚੈਕ ਕਰੋ ਜੋ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈ:

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

RunPod ਸੈਟਅੱਪ:

  1. RunPod ਸੈੱਟਅੱਪ ਕਰੋ, ਆਪਣਾ ssh ਸਰਟੀ/ਕੁੰਜੀ ਸੈਟ ਕਰੋ, ਅਤੇ ਇੱਕ ਪੋਡ ਚਲਾਓ। ਤੁਸੀਂ ਆਪਣੇ ਪੋਡ(ਸ) ਨੂੰ RunPod ਦਾ ਕਨਸੋਲ ਪੇਜ ‘ਤੇ ਐਕਸੈਸ ਕਰ ਸਕਦੇ ਹੋ।

  2. SSH ਕੁਨੈਕਸ਼ਨ ਇੰਫੋ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ “Connect” ਬਟਨ ‘ਤੇ ਕਲਿੱਕ ਕਰੋ। ਇਹ ਜਾਣਕਾਰੀ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

    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. ਜਦੋਂ ਤੁਸੀਂ ਪੋਡ ਨਾਲ ਕੰਮ ਮੁਕੰਮਲ ਕਰ ਲਵੋ, ਤਾਂ ਉਸਨੂੰ ਸ਼ਟਡਾਊਨ ਜਾਂ ਪੌਜ਼ ਕਰੋ। ਪਰ ਚੇਤਾਵਨੀ: ਜੇ ਤੁਸੀਂ ਪੌਜ਼ ਕਰਦੇ ਹੋ ਤਾਂ ਵੀ ਤੁਹਾਨੂੰ ਚਾਰਜ ਕੀਤਾ ਜਾਵੇਗਾ, ਸਿਰਫ਼ ਬਹੁਤ ਘੱਟ।

ਸ਼ਾਨਦਾਰ ਸਰੋਤ: