Llama.cpp, GGUF 포맷, 그리고 양자화(Quantization)

오늘은 LLM(Large Language Model) 인퍼런스에서 모델 사이즈를 줄이고 더 빠르게 추론하기 위한 방법론 중 가장 인기가 많은 양자화(Quantization)에 대해 다루겠습니다. 양자화는 모델의 크기를 축소하고 추론 속도를 향상시키는 기술로, 특히 LLM에서 효과적입니다.

양자화는 모델의 가중치와 활성화를 저비트(bit) 정밀도로 변환하여 메모리 사용량을 줄이고 계산 속도를 높이는 방법입니다. 예를 들어, 32비트 부동소수점 수치를 8비트 정수로 변환하면 메모리 사용량이 약 4분의 1로 감소하고, 계산 속도도 크게 향상됩니다. 이는 특히 하드웨어 자원이 제한된 환경에서 매우 유용합니다.

이전 블로그 글에서 양자화에 대한 기본적인 개념과 다양한 기법을 다루었으니, 자세한 내용을 알고 싶다면 해당 글을 참고하시기 바랍니다. 

LLM 인퍼런스 훑어보기 (6) - quantization

 

오늘은 llama.cpp와 이에서 제공하는 양자화(Quantization) 기법들에 대해 다뤄보겠습니다.

 

---

 

llama.cpp

GitHub - ggerganov/llama.cpp: LLM inference in C/C++

 

llama.cpp는 C++로 작성된 오픈 소스 소프트웨어 라이브러리로, Llama와 같은 다양한 대규모 언어 모델(LLM)의 인퍼런스를 수행합니다. 이 라이브러리는 범용 텐서 라이브러리인 ggml과 함께 공동 개발되었습니다.

llama.cpp는 Georgi Gerganov에 의해 순수 C++로 개발되었으며, 의존성이 없습니다. 이러한 접근 방식의 장점은 CUDA와 같은 하드웨어 의존적인 닫힌 소스 라이브러리에 의존하는 다른 인퍼런스 라이브러리와 달리 더 다양한 하드웨어에서 실행될 수 있다는 점입니다. 현재 GitHub에서 55천 개의 스타를 보유하고 있습니다. Georgi Gerganov는 이전에 OpenAI의 음성 인식 모델인 Whisper를 구현한 whisper.cpp라는 유사한 라이브러리를 개발한 바 있습니다.

llama.cpp는 초기에는 CPU에서만 실행할 수 있었지만, 이제는 Vulkan과 SYCL을 포함한 다양한 백엔드를 통해 GPU에서도 실행할 수 있습니다. 이러한 백엔드는 GGML 텐서 라이브러리를 구성하며, 이는 모델별 프론트엔드 코드인 llama.cpp에서 사용됩니다. llama.cpp는 GGUF라는 자체 모델 포맷을 지원하며, 이전에는 GGML 포맷으로 불렸습니다.

llama.cpp는 실시간 양자화 대신 사전 양자화를 지원합니다. 이로 인해 모델을 보다 효율적으로 사용할 수 있으며, 특히 전문 하드웨어가 없는 사용자들에게 인기를 끌고 있습니다. 또한, Android 기기에서도 CPU만으로 실행할 수 있어 사용자층이 넓습니다.

 

 

GGUF 파일 포맷

GGUF 파일 포맷은 텐서와 메타데이터를 저장하는 바이너리 포맷입니다. GGUF 파일은 주로 PyTorch와 같은 다른 머신 러닝 라이브러리에서 개발된 모델을 변환하여 생성됩니다. GGUF의 주요 목적은 llama.cpp와 다른 ggml 프로젝트에서 모델 파일을 쉽게 그리고 빠르게 로드할 수 있도록 하는 것입니다.

이 포맷은 이전에 사용되던 파일 포맷들을 대체하기 위해 만들어졌습니다. 이전 포맷들은 아키텍처 메타데이터를 포함하지 않아 소프트웨어 확장이 어려웠고, 역호환성 문제가 있었습니다. GGUF는 이러한 문제를 해결하여 모델 파일의 확장성과 호환성을 높였습니다.

GGUF는 safetensors와 같은 텐서 전용 파일 포맷과 달리 텐서와 표준화된 메타데이터 세트를 모두 인코딩합니다. 이로 인해 모델의 로딩 및 저장 과정이 더욱 효율적이고 체계적으로 이루어집니다. 

 

https://github.com/ggerganov/ggml/blob/master/docs/gguf.md

 

위 이미지는 GGUF 포맷을 소개하기 위한 자료입니다. GGUF 파일 포맷은 텐서와 메타데이터를 저장하는 바이너리 형식으로, 모델을 빠르게 로드하고 저장할 수 있도록 최적화되었습니다. 이 포맷은 GGML 및 다른 실행기와 함께 사용하도록 설계되었습니다.

GGUF 파일은 다음과 같은 구조를 가지고 있습니다:

• GGUF 매직 넘버 (4 bytes): "0x47 0x47 0x55 0x46"로, "GGUF"를 나타냅니다.
• GGUF 버전 (4 bytes): 현재 버전은 3입니다.
• 텐서 수 (8 bytes): 파일에 포함된 텐서의 수를 나타내는 UINT64 값입니다.
• 메타데이터 키-값 쌍의 수 (8 bytes): 메타데이터 키-값 쌍의 수를 나타내는 UINT64 값입니다.
• 메타데이터: 모델의 아키텍처, 이름, 컨텍스트 길이, 파일 타입, 토크나이저 정보 등을 포함합니다.
• 텐서 정보: 텐서의 이름, 차원 수, 차원, 타입, 오프셋 등을 포함합니다.

이 외의 파일의 나머지 부분은 텐서 데이터로 구성됩니다:

GGUF 포맷은 다양한 양자화 타입을 지원하여 메모리 사용량을 줄이고 속도를 향상시킬 수 있습니다. 또한, float32, float16, bfloat16과 같은 일반적인 부동소수점 데이터 타입과 여러 양자화된 정수 타입(1.5-bit, 2-bit, 3-bit, 4-bit, 5-bit, 6-bit, 8-bit)을 지원합니다.

 

 

예시) Llama 3 모델 

이러한 GGUF 포맷을 이용하여 Meta의 Llama3 모델을 변환해보고, llama.cpp로 얼마나 효율적으로 추론이 가능한지 확인해보겠습니다.

 

모델 다운로드

우선 아래를 실행하여 Llama3 모델을 다운받습니다.

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="meta-llama/Meta-Llama-3-8B-Instruct",
    local_dir="models/meta-llama--meta-llama-3-8b-instruct",
    token=MY_HUGGINGFACE_TOKEN,
    local_dir_use_symlinks=False,
    ignore_patterns=["original/*"],
)

 

llama.cpp 초기화

llama.cpp 레포를 로컬에 클론한 뒤, 빌드합니다. 

$ git clone https://github.com/ggerganov/llama.cpp.git
$ cd llama.cpp

$ make -j

 

GGUF 변환

이 후, 앞서 다운로드 받은 Llama-3-8B-Instruct 모델을 gguf 포맷으로 변환합니다. 변환은 convert-hf-to-gguf.py 를 실행하여 진행할 수 있습니다.

$ python convert-hf-to-gguf.py --help
usage: convert-hf-to-gguf.py [-h] [--vocab-only] [--awq-path AWQ_PATH] [--outfile OUTFILE] [--outtype {f32,f16,bf16,q8_0,auto}] [--bigendian] [--use-temp-file] [--no-lazy] [--model-name MODEL_NAME] [--verbose] model

Convert a huggingface model to a GGML compatible file

positional arguments:
  model                 directory containing model file

options:
  -h, --help            show this help message and exit
  --vocab-only          extract only the vocab
  --awq-path AWQ_PATH   Path to scale awq cache file
  --outfile OUTFILE     path to write to; default: based on input. {ftype} will be replaced by the outtype.
  --outtype {f32,f16,bf16,q8_0,auto}
                        output format - use f32 for float32, f16 for float16, bf16 for bfloat16, q8_0 for Q8_0, auto for the highest-fidelity 16-bit float type depending on the first loaded tensor type
  --bigendian           model is executed on big endian machine
  --use-temp-file       use the tempfile library while processing (helpful when running out of memory, process killed)
  --no-lazy             use more RAM by computing all outputs before writing (use in case lazy evaluation is broken)
  --model-name MODEL_NAME
                        name of the model
  --verbose             increase output verbosity

 

위의 옵션 중에 --outtype 옵션은 output format을 말하며 f32, f16, bf16, q8_0, auto를 지원합니다. 해당 argument를 입력하면 아래와 같이 매핑되어 ftype을 지정합니다.

ftype_map: dict[str, gguf.LlamaFileType] = {
    "f32": gguf.LlamaFileType.ALL_F32,
    "f16": gguf.LlamaFileType.MOSTLY_F16,
    "bf16": gguf.LlamaFileType.MOSTLY_BF16,
    "q8_0": gguf.LlamaFileType.MOSTLY_Q8_0,
    "auto": gguf.LlamaFileType.GUESSED,
}

 

다시 본론으로 돌아와서 GGUF 변환을 계속 진행합니다. 각 자료형에 대해서 아래와 같이 변환을 진행할 수 있습니다.

# f32
$ python convert-hf-to-gguf.py \
  models/meta-llama--meta-llama-3-8b-instruct \
  --outtype f32
  
# f16
$ python convert-hf-to-gguf.py \
  models/meta-llama--meta-llama-3-8b-instruct \
  --outtype f16
  
# bf16
$ python convert-hf-to-gguf.py \
  models/meta-llama--meta-llama-3-8b-instruct \
  --outtype bf16
  
# q8_0
$ python convert-hf-to-gguf.py \
  models/meta-llama--meta-llama-3-8b-instruct \
  --outtype q8_0

 

네 가지 유형을 모두 convert 해보면 각각의 파일 사이즈가 서로 다른 것을 확인할 수 있습니다. f32 모델의 경우에는 30GB, f16과 bf16은 15GB, 그리고 q8_0 파일 유형은 8GB 였습니다.

$ ls -alh *.gguf | awk -v OFS='\t' '{print $5, $9}'
15G     ggml-model-bf16.gguf
15G     ggml-model-f16.gguf
30G     ggml-model-f32.gguf
8.0G    ggml-model-q8_0.gguf

 

converting이 잘 되었는지 확인해보기 위해 예제를 실행해봅니다. 제가 수행한 환경은 Apple M1 Pro 장비와 32GB 메모리로 구성되어 있습니다. 32GB로는 f32를 연산하기에 부족하므로 f16 모델을 아래 코드로 인퍼런스 합니다.

$ ./main \
	-m models/meta-llama--meta-llama-3-8b-instruct/ggml-model-f16.gguf \
	-p "Building a website can be done in 10 simple steps:\nStep 1:" \
	-n 400 \
	-e \
	--log-disable

# 생성 결과
Building a website can be done in 10 simple steps:
Step 1: Plan Your Website
Before you start building your website, you need to plan it out. Decide what your website will be about, what features you want to include, and what kind of content you will need. This will help you stay focused and ensure that your website turns out the way you want it to.
Step 2: Choose a Domain Name
Your domain name is the address of your website. Choose a domain name that is easy to remember, relevant to your content, and available. You can check if a domain name is available by using a domain name registrar such as GoDaddy or Namecheap.
Step 3: Choose a Web Host
Your web host is where your website will be stored. Choose a web host that is reliable, has good customer support, and offers the features you need. Some popular web hosts include Bluehost, HostGator, and SiteGround.
Step 4: Design Your Website
Designing your website involves creating the look and feel of your site. You can use a website builder like WordPress or Wix, or hire a web designer to create a custom design for you.
Step 5: Build Your Website
Once you have designed your website, you need to build it. This involves creating the pages and content for your site. You can use a website builder like WordPress or Wix to make it easy to build your site.
Step 6: Add Content to Your Website
Content is what makes your website interesting and informative. Add text, images, videos, and other media to your website to make it engaging and informative.
Step 7: Optimize Your Website for Search Engines
Search engines like Google help people find your website by indexing it and displaying it in search results. Optimize your website for search engines by using keywords, meta tags, and other SEO techniques.
Step 8: Launch Your Website
Once your website is built and optimized, it's time to launch it. Launching your website involves making it live and

 

hellaswag 벤치마크 측정

GitHub - rowanz/hellaswag: HellaSwag: Can a Machine _Really_ Finish Your Sentence?

 

hellaswag 테스트는 모델의 추론 성능을 평가하는 데 사용되는 표준적인 벤치마크입니다. 이 테스트를 통해 모델이 다양한 상황에서 얼마나 정확하게 문맥을 이해하고 예측할 수 있는지 확인할 수 있습니다. HuggingFace의 Open LLM Leaderboard에는 이 hellaswag 벤치마크 결과를 포함합니다.

Open LLM Leaderboard - a Hugging Face Space by HuggingFaceH4

 

hellawag 테스트를 하기 위해서는 우선 hellaswag data를 다운받아야 합니다. 저는 공식 레포에서 다운받기 보다는 미리 txt로 변환해둔 파일을 다운받아 사용했습니다. 해당 파일은 https://github.com/klosax/hellaswag_text_data 레포에서 다운 가능합니다.

hellaswag_val_full.txt를 다운받았다면, perplexity를 실행하여 테스트를 진행합니다. 아래 명령어를 실행하면 400개의 랜덤한 task를 선택하여 hellaswag test를 진행합니다.

$ ./perplexity \
    -m models/meta-llama--meta-llama-3-8b-instruct/ggml-model-f16.gguf \
    --hellaswag \
    -f models/hellaswag_val_full.txt

hellaswag_score : loaded 10042 tasks from prompt.
================================= is_spm = 0
hellaswag_score : selecting 400 randomized tasks.
hellaswag_score : calculating hellaswag score over selected tasks.

task    acc_norm
1       0.00000000
2       50.00000000
3       66.66666667
...
398     74.87437186
399     74.93734336
400     75.00000000

llama_print_timings:        load time =    1543.26 ms
llama_print_timings:      sample time =       0.00 ms /     1 runs   (    0.00 ms per token,      inf tokens per second)
llama_print_timings: prompt eval time =  265772.98 ms / 66030 tokens (    4.03 ms per token,   248.45 tokens per second)
llama_print_timings:        eval time =       0.00 ms /     1 runs   (    0.00 ms per token,      inf tokens per second)
llama_print_timings:       total time =  271281.57 ms / 66031 tokens

 

f32를 제외한 f16, q8_0의 hellaswag 점수는 아래와 같이 측정되었습니다.

	f16	q8_0
Hellaswag	75.00	75.00
Prompt Eval Time (ms/tok)	4.03	4.32

 

 

Quantize

llama.cpp는 앞서 말씀드렸듯이 다양한 양자화 전략을 제공합니다. 이번에는 위에서 convert한 GGUF 모델 파일을 quantize하여 성능을 측정해봅니다. 모델 양자화는 다음과 같은 명령어를 실행하여 진행합니다.

$ ./quantize \
	models/meta-llama--meta-llama-3-8b-instruct/ggml-model-f16.gguf \
	Q4_0

 

Q4_0으로 양자화한 모델의 경우에는 파일 크기가 4.3G로 다른 유형들과 달리 더 작은 크기를 갖습니다.

$ ls -alh *.gguf | awk -v OFS='\t' '{print $5, $9}'
4.3G    ggml-model-Q4_0.gguf
15G     ggml-model-bf16.gguf
15G     ggml-model-f16.gguf
30G     ggml-model-f32.gguf
8.0G    ggml-model-q8_0.gguf

 

두번째 인자로 전달하는 Q4_0의 경우에는 양자화 종류를 의미합니다. llama.cpp에서 현재 지원하는 quantization type은 굉장히 많고, 아래와 같습니다.

class GGMLQuantizationType(IntEnum):
    F32     = 0
    F16     = 1
    Q4_0    = 2
    Q4_1    = 3
    Q5_0    = 6
    Q5_1    = 7
    Q8_0    = 8
    Q8_1    = 9
    Q2_K    = 10
    Q3_K    = 11
    Q4_K    = 12
    Q5_K    = 13
    Q6_K    = 14
    Q8_K    = 15
    IQ2_XXS = 16
    IQ2_XS  = 17
    IQ3_XXS = 18
    IQ1_S   = 19
    IQ4_NL  = 20
    IQ3_S   = 21
    IQ2_S   = 22
    IQ4_XS  = 23
    I8      = 24
    I16     = 25
    I32     = 26
    I64     = 27
    F64     = 28
    IQ1_M   = 29
    BF16    = 30

 

GGML_QUANT_SIZES 딕셔너리는 각 양자화 유형(GGMLQuantizationType)에 대한 (block size, type size)를 미리 정의해둔 것을 확인할 수 있습니다.

# Items here are (block size, type size)
QK_K = 256
GGML_QUANT_SIZES: dict[GGMLQuantizationType, tuple[int, int]] = {
    GGMLQuantizationType.F32:     (1, 4),
    GGMLQuantizationType.F16:     (1, 2),
    GGMLQuantizationType.Q4_0:    (32, 2 + 16),
    GGMLQuantizationType.Q4_1:    (32, 2 + 2 + 16),
    GGMLQuantizationType.Q5_0:    (32, 2 + 4 + 16),
    GGMLQuantizationType.Q5_1:    (32, 2 + 2 + 4 + 16),
    GGMLQuantizationType.Q8_0:    (32, 2 + 32),
    GGMLQuantizationType.Q8_1:    (32, 4 + 4 + 32),
    GGMLQuantizationType.Q2_K:    (256, 2 + 2 + QK_K // 16 + QK_K // 4),
    GGMLQuantizationType.Q3_K:    (256, 2 + QK_K // 4 + QK_K // 8 + 12),
    GGMLQuantizationType.Q4_K:    (256, 2 + 2 + QK_K // 2 + 12),
    GGMLQuantizationType.Q5_K:    (256, 2 + 2 + QK_K // 2 + QK_K // 8 + 12),
    GGMLQuantizationType.Q6_K:    (256, 2 + QK_K // 2 + QK_K // 4 + QK_K // 16),
    GGMLQuantizationType.Q8_K:    (256, 4 + QK_K + QK_K // 8),
    GGMLQuantizationType.IQ2_XXS: (256, 2 + QK_K // 4),
    GGMLQuantizationType.IQ2_XS:  (256, 2 + QK_K // 4 + QK_K // 32),
    GGMLQuantizationType.IQ3_XXS: (256, 2 + QK_K // 4 + QK_K // 8),
    GGMLQuantizationType.IQ1_S:   (256, 2 + QK_K // 8 + QK_K // 16),
    GGMLQuantizationType.IQ4_NL:  (32, 2 + 16),
    GGMLQuantizationType.IQ3_S:   (256, 2 + QK_K // 4 + QK_K // 8 + QK_K // 32 + 4),
    GGMLQuantizationType.IQ2_S:   (256, 2 + QK_K // 4 + QK_K // 16),
    GGMLQuantizationType.IQ4_XS:  (256, 2 + 2 + QK_K // 2 + QK_K // 64),
    GGMLQuantizationType.I8:      (1, 1),
    GGMLQuantizationType.I16:     (1, 2),
    GGMLQuantizationType.I32:     (1, 4),
    GGMLQuantizationType.I64:     (1, 8),
    GGMLQuantizationType.F64:     (1, 8),
    GGMLQuantizationType.IQ1_M:   (256, QK_K // 8 + QK_K // 16  + QK_K // 32),
    GGMLQuantizationType.BF16:    (1, 2),
}

 

 

테스트 결과

전체적으로 테스트해본 결과는 아래와 같습니다:

QuantizationType	HellaSwag	Size	Promp Eval Time (ms/tok)
F16	75.00	15G	4.03
Q8_0	75.00	8.0G	4.32
Q4_0	74.75	4.3G	4.71
Q4_1	74.75	4.8G	4.25
Q5_0	74.50	5.2G	5.07
Q5_1	75.75	5.7G	5.05
Q2_K	70.50	3.0G	4.77
Q3_K	73.75	3.7G	5.10
Q4_K	74.75	4.6G	4.94
Q5_K	75.75	5.3G	5.80
Q6_K	74.75	6.1G	5.35
IQ2_XXS	60.75	2.2G	4.95
IQ2_XS	68.25	2.4G	4.91
IQ3_XXS	73.25	3.0G	4.92
IQ1_S	42.00	1.9G	4.80
IQ4_NL	74.50	4.4G	5.27
IQ3_S	74.75	3.4G	5.06
IQ2_S	70.75	2.6G	4.93
IQ4_XS	74.75	4.1G	5.22
IQ1_M	50.50	2.0G	4.89

 

위 데이터는 여러 가지 QuantizationType의 성능과 메모리 사용량을 비교한 표입니다. QuantizationType은 모델의 양자화 방식을 의미하며, 이는 모델의 크기와 성능에 큰 영향을 미칩니다

이 표에는 각 QuantizationType별로 HellaSwag 점수, 모델 크기(Size), 그리고 토큰당 평가 시간(Promp Eval Time)이 포함되어 있습니다. HellaSwag 점수는 모델의 성능을 나타내며, 숫자가 클수록 성능이 더 좋음을 의미합니다. 모델 크기는 GigaByte 단위로 표시되어 있으며, 크기가 클수록 메모리 사용량이 많아집니다. 마지막으로, 토큰당 평가 시간은 모델이 하나의 토큰을 평가하는 데 걸리는 시간을 밀리초(ms) 단위로 나타냅니다.

F16 모델은 가장 큰 크기(15G)를 가지며, HellaSwag 점수가 75.00으로 높은 성능을 보입니다. 이 모델의 토큰당 평가 시간은 4.03ms입니다. Q8_0 모델도 같은 HellaSwag 점수(75.00)를 가지지만, 크기는 8.0G로 더 작습니다. 그러나 평가 시간은 약간 더 긴 4.32ms입니다.

Q4_0과 Q4_1 모델은 비슷한 성능을 보이지만, Q4_1 모델이 약간 더 빠른 평가 시간을 가집니다. Q5_0 모델은 성능이 조금 떨어지지만, Q5_1 모델은 가장 높은 HellaSwag 점수(75.75)를 기록합니다. Q2_K 모델은 가장 작은 크기(3.0G)를 가지지만, 성능은 다른 모델들보다 낮습니다.

다양한 IQ 모델들도 포함되어 있으며, 각 모델은 크기와 성능, 평가 시간에서 차이를 보입니다. 예를 들어, IQ2_XXS 모델은 가장 작은 크기(2.2G)를 가지지만, 성능은 60.75로 비교적 낮습니다. 반면, IQ4_XS 모델은 크기가 4.1G로 상대적으로 작으면서도 HellaSwag 점수가 74.75로 높은 성능을 보입니다.

이 데이터는 모델의 양자화 방식이 성능과 메모리 사용량, 평가 시간에 어떻게 영향을 미치는지를 보여줍니다. 이를 통해 사용자들은 자신들의 필요에 맞는 모델을 선택할 수 있습니다. 예를 들어, 메모리가 제한된 환경에서는 더 작은 크기의 모델을 선택할 수 있으며, 높은 성능이 필요한 경우 더 큰 모델을 고려할 수 있습니다.

 

위 이미지는 다양한 QuantizationType 모델의 HellaSwag 점수와 모델 크기(Size) 간의 상관성을 시각화한 산점도입니다. 이 그래프를 통해 각 모델의 성능과 메모리 사용량을 한눈에 비교할 수 있습니다.

먼저, X축은 모델의 크기(GigaByte)이며, Y축은 HellaSwag 점수를 나타냅니다. HellaSwag 점수는 모델의 성능을 의미하며, 숫자가 높을수록 성능이 좋습니다. 각 점은 특정 QuantizationType 모델을 나타내며, 해당 모델의 크기와 성능을 표시합니다.

가장 큰 모델인 F16은 15G의 크기와 75.00의 높은 HellaSwag 점수를 기록하고 있습니다. 이는 큰 메모리 사용량을 요구하지만 높은 성능을 제공함을 보여줍니다. 반면, Q2_K와 같은 작은 모델들은 상대적으로 낮은 HellaSwag 점수를 보여주지만, 메모리 사용량이 적습니다.

Q5_1 모델은 크기(5.7G) 대비 가장 높은 HellaSwag 점수(75.75)를 나타내며, 효율적인 성능을 제공하는 것으로 보입니다. 또한, Q4_1, Q4_K, Q5_K와 같은 모델들도 비교적 작은 크기(4~6G)에 비해 높은 성능을 보여줍니다.

IQ 시리즈 모델들은 대체로 낮은 HellaSwag 점수를 기록하고 있으며, 특히 IQ1_S 모델은 42.00의 가장 낮은 점수를 보입니다. 이는 작은 모델들이 성능 면에서 제한적일 수 있음을 나타냅니다.

이 그래프는 사용자가 메모리 용량과 성능 간의 트레이드오프를 고려하여 적절한 모델을 선택할 수 있도록 도와줍니다. 예를 들어, 메모리가 제한된 환경에서는 작은 크기의 모델을 선택해야 하며, 성능이 중요한 경우 더 큰 모델을 고려해야 합니다. 이를 통해 사용자들은 자신들의 요구에 맞는 최적의 모델을 선택할 수 있습니다.

 

 

추가로..

llama-3에 대해서 MMLU로 분석해주신 고마운 글이 있어서 같이 참고하시면 좋을 것 같습니다.

GitHub - matt-c1/llama-3-quant-comparison: Comparison of the output quality of quantization methods, using Llama 3, transformers

 

위 레포에서는 Llama-3 70B와 7B 모델 둘 모두에서 양자화에 따른 MMLU 정확도를 측정했습니다. 측정 결과를 요약하자면 아래와 같습니다:

 

이에서 살펴볼 수 있듯이, Llama3 모델은 MMLU와 HellaSwag 모두에서 Q4 수준까지는 큰 성능 하락이 없었습니다.

 

 

마무리

Llama3 모델을 llama.cpp를 활용하여 GGUF 포맷의 사전 양자화된 모델로 변환하는 방법을 알아보았습니다. 이 과정에서 다양한 양자화 기법을 사용하여 HellaSwag 점수와 모델 크기에 대한 분포를 확인했습니다.

분석 결과와 MMLU의 결과도 함께 고려했을 때, Q4 수준까지는 모델 성능에 큰 저하가 없음을 확인할 수 있었습니다. 또한, Q4와 Q5 수준의 양자화가 메모리를 가장 절약하면서도 성능을 유지할 수 있는 최적의 선택으로 보입니다.