양자화(Quantization): 모델 다이어트의 기술

양자화(Quantization): 모델 다이어트의 기술#

들어가며: 700억 파라미터 모델을 내 노트북에서?#

Hugging Face Hub에서 최신 언어 모델을 발견했을 때의 설렘을 기억하시나요? "Llama-3-70B-Instruct"와 같은 강력한 모델을 다운로드하려고 보니, 파일 크기가 140GB에 육박합니다. 이 모델을 메모리에 올리려면 최소 140GB의 RAM이나 VRAM이 필요하다는 계산이 나옵니다. 최고 사양의 워크스테이션이나 클라우드 인스턴스가 없다면 사실상 그림의 떡입니다.

바로 이 지점에서 Llama.cpp의 진정한 마법, 양자화(Quantization)가 등장합니다. 양자화는 거대한 모델을 "다이어트"시켜 누구나 자신의 컴퓨터에서 강력한 AI를 실행할 수 있게 만드는 핵심 기술입니다. 마치 초고화질 원본 동영상(RAW)을 화질 저하를 최소화하면서 휴대폰에서도 볼 수 있는 MP4 파일로 변환하는 것과 같습니다.

이번 챕터에서는 양자화의 개념적 이해부터 시작해, Llama.cpp가 제공하는 다양한 양자화 레벨의 특징과 장단점을 비교하고, 최종적으로 여러분이 직접 원하는 모델을 양자화하는 실습까지 진행합니다. 이 챕터를 마치고 나면, 여러분은 모델의 크기와 성능 사이에서 최적의 균형점을 찾는 전문가가 될 것입니다.

---

1. 양자화란 무엇이며 왜 필수적인가?#

핵심 개념: 숫자의 정밀도 낮추기#

컴퓨터 과학의 가장 기본적인 원리 중 하나는 숫자를 표현하는 데 사용하는 비트(bit) 수가 많을수록 더 정밀하고 넓은 범위의 수를 나타낼 수 있다는 것입니다. 인공지능 모델, 특히 LLM의 가중치(weights)는 대부분 32비트 부동소수점(32-bit Floating Point, FP32) 형식으로 저장됩니다.

• FP32 (Full Precision): 하나의 숫자를 표현하는 데 32비트(4바이트)를 사용합니다. 매우 높은 정밀도를 가져 모델의 원래 성능을 100% 보장하지만, 그만큼 많은 저장 공간과 메모리를 차지합니다.

양자화는 바로 이 숫자의 정밀도를 의도적으로 낮추는 과정입니다. 예를 들어, FP32로 표현된 숫자를 8비트 정수(INT8)나 4비트 정수(INT4)로 변환하는 것입니다.

• FP32 (32비트): 3.1415926535... 와 같이 매우 정밀한 소수를 표현. (4바이트)
• INT8 (8비트): -128부터 127까지의 256개 정수 중 하나로 표현. (1바이트)
• INT4 (4비트): -8부터 7까지의 16개 정수 중 하나로 표현. (0.5바이트)

물론 단순히 소수점을 버리는 방식은 아닙니다. 원래의 부동소수점 값 범위를 정수 값 범위로 "매핑(mapping)"하고, 나중에 계산에 사용할 때 다시 원래 값으로 근사하여 복원하기 위한 **스케일링 팩터(scaling factor)**와 제로 포인트(zero point) 같은 추가 정보를 함께 저장합니다.

쉽게 비유하자면:

• FP32는 수백만 가지 색상을 표현할 수 있는 전문가용 RAW 이미지 파일입니다. 파일 크기는 매우 크지만, 색상 정보의 손실이 전혀 없습니다.

• 양자화된 모델(예: INT4)은 웹에 올리기 위해 압축된 JPEG 파일과 같습니다. 사람의 눈이 잘 인지하지 못하는 색상 정보를 일부 제거하여 파일 크기를 획기적으로 줄였습니다. 대부분의 상황에서 원본과 큰 차이를 느끼기 어렵지만, 극도로 확대하면 미세한 화질 저하가 보일 수 있습니다.

양자화가 필수적인 세 가지 이유#

Llama.cpp를 사용하고 로컬 AI를 구축하려는 개발자에게 양자화는 선택이 아닌 필수입니다. 그 이유는 다음과 같습니다.

1. 압도적인 메모리 사용량 감소 (Reduced Memory Usage)

이것이 가장 직접적이고 강력한 장점입니다. 모델의 각 가중치가 차지하는 바이트 수가 줄어들기 때문에 전체 모델 크기가 극적으로 감소합니다.

70억(7B) 파라미터 모델을 예로 들어보겠습니다.

정밀도 (Precision)	파라미터 당 바이트	전체 모델 크기 (계산)	결과
FP32	4 bytes	7,000,000,000 * 4 bytes	약 28 GB
FP16	2 bytes	7,000,000,000 * 2 bytes	약 14 GB
Q8_0 (INT8)	~1.1 bytes (메타데이터 포함)	7,000,000,000 * 1.1 bytes	약 7.7 GB
Q4_K_M (INT4)	~0.56 bytes (메타데이터 포함)	7,000,000,000 * 0.56 bytes	약 3.9 GB
Q2_K (INT2)	~0.33 bytes (메타데이터 포함)	7,000,000,000 * 0.33 bytes	약 2.3 GB

보시다시피, FP32 모델은 28GB의 VRAM/RAM이 필요하여 일반적인 데스크톱에서는 실행조차 어렵습니다. 하지만 Q4_K_M으로 양자화하면 4GB 미만으로 줄어들어 8GB RAM을 가진 노트북이나 라즈베리 파이에서도 실행 가능한 수준이 됩니다.

2. 놀라운 추론 속도 향상 (Increased Inference Speed)

양자화는 단순히 모델을 작게 만드는 것에서 그치지 않고, 추론 속도도 빠르게 만듭니다. 여기에는 두 가지 주요 원인이 있습니다.

• 메모리 대역폭(Memory Bandwidth) 부담 감소: 모델이 작아진다는 것은 CPU/GPU가 메모리(RAM/VRAM)에서 데이터를 읽어오는 양이 줄어든다는 의미입니다. 현대 컴퓨팅에서 연산 속도 자체보다 메모리에서 데이터를 가져오는 속도가 병목인 경우가 많으므로, 이는 전체 추론 시간을 단축시키는 데 결정적인 역할을 합니다.
• 정수 연산의 효율성: 대부분의 CPU 아키텍처는 부동소수점 연산보다 정수 연산을 더 빠르고 효율적으로 처리하도록 설계되었습니다. 특히 AVX2, NEON과 같은 SIMD(Single Instruction, Multiple Data) 명령어셋을 활용하면 여러 개의 정수 연산을 한 번의 명령으로 처리할 수 있어 성능이 크게 향상됩니다. Llama.cpp는 이러한 CPU 최적화를 극단적으로 활용하도록 설계되었습니다.

3. 접근성 향상 및 새로운 가능성 (Improved Accessibility & New Opportunities)

이 두 가지 장점이 결합되어 로컬 AI의 "민주화"를 이끌어냅니다.

• 일반 사용자: 고가의 GPU 없이도 자신의 데스크톱이나 노트북에서 개인 정보 보호를 유지하며 강력한 챗봇, 코딩 어시스턴트, 문서 요약기 등을 사용할 수 있습니다.
• 개발자: 서버 비용 부담 없이 애플리케이션에 AI 기능을 내장할 수 있습니다. 예를 들어, 오프라인 환경에서도 작동하는 문서 편집기, 게임 NPC, 스마트 비서 등을 개발할 수 있습니다.
• 엣지 컴퓨팅: 라즈베리 파이, Jetson Nano, 심지어 스마트폰과 같은 저전력 엣지 디바이스에 LLM을 배포하여 실시간 로컬 처리가 필요한 IoT 기기나 로봇을 만들 수 있습니다.

피할 수 없는 트레이드오프: 성능 저하 (Perplexity)#

물론 양자화에는 대가가 따릅니다. 숫자의 정밀도를 낮추는 과정에서 정보의 손실이 발생하며, 이는 모델의 성능 저하로 이어질 수 있습니다. 모델의 성능을 측정하는 대표적인 지표 중 하나는 펄플렉서티(Perplexity, PPL)입니다. PPL은 모델이 다음 단어를 얼마나 잘 예측하는지를 나타내는 척도로, 값이 낮을수록 성능이 좋음을 의미합니다.

양자화를 강하게 할수록(즉, 더 적은 비트를 사용할수록) 모델 크기와 속도 면에서 이득을 보지만, PPL은 점차 높아집니다.

(이미지: 양자화 레벨이 낮아질수록(예: Q8 -> Q4 -> Q2) 모델 크기는 줄지만, Perplexity는 증가하는 관계를 보여주는 그래프)

하지만 다행히도 Llama.cpp 커뮤니티의 지속적인 연구 덕분에 최신 양자화 기법(특히 K-Quants)은 성능 저하를 최소화하면서도 높은 압축률을 달성하는 데 성공했습니다. 많은 경우, Q5_K_M이나 Q4_K_M 레벨에서는 원본 모델과 거의 차이를 느끼기 어려운 답변 품질을 보여줍니다.

이제 어떤 양자화 방법들이 있는지, 그리고 여러분의 목적에 맞는 최적의 레벨은 무엇인지 자세히 알아보겠습니다.

---

2. Q2_K, Q4_K_M, Q8_0... 나에게 맞는 퀀텀 레벨 찾기#

Llama.cpp는 매우 다양한 양자화 방법을 제공하며, 처음 접하는 사용자는 Q4_K_M, Q5_0, Q8_K 등 알쏭달쏭한 이름에 혼란을 느낄 수 있습니다. 이 작명 규칙을 이해하면 모델을 선택하는 것이 훨씬 쉬워집니다.

Llama.cpp 양자화 작명 규칙 해부#

모델 이름은 보통 다음과 같은 구조로 이루어집니다: Q<Bits>_<Type>_<Size>

1. Q: Quantized의 약자로, 양자화된 모델임을 의미합니다.
2. <Bits> (숫자: 2, 3, 4, 5, 6, 8): 가중치(weight) 당 평균적으로 사용되는 비트 수를 나타냅니다. 이 숫자가 작을수록 모델 파일이 작아지고 빨라지지만, 품질 저하의 가능성이 커집니다.
3. <Type> (문자: 0, 1, K): 양자화 방식의 종류를 나타냅니다.
   • _0: 가장 초기에 사용된 레거시 방식입니다. 예를 들어 Q4_0, Q5_0.
   • _1: _0 방식보다 약간 개선된 레거시 방식입니다. 예를 들어 Q4_1, Q5_1.
   • _K: K-Quants라 불리는 최신이자 가장 권장되는 방식입니다. 거의 모든 면에서 이전 방식들보다 우수합니다. K-Quants는 가중치를 256개 또는 128개의 블록으로 묶어(이를 'K-Blocks'라 함) 양자화를 수행하는데, 이 과정에서 중요한 가중치에 더 높은 정밀도를 할당하는 등 정교한 기법을 사용하여 품질 손실을 최소화합니다. 특별한 이유가 없다면 항상 _K 버전을 선택하는 것이 좋습니다.
4. <Size> (문자: S, M, L): K-Quants 방식 내에서 사용되는 블록 크기(Block Size)를 의미합니다.
   • _S: Small. 가장 작은 블록 크기를 사용합니다. 이론적으로는 가장 미세한 조정을 통해 품질이 가장 좋을 수 있지만, 메타데이터가 약간 더 커져 파일 크기가 미세하게 증가합니다.
   • _M: Medium. 중간 크기의 블록을 사용하며, 크기와 품질 사이의 가장 좋은 균형을 제공하는 경우가 많습니다.
   • _L: Large. 가장 큰 블록 크기를 사용합니다. 파일 크기가 가장 작아지지만, 품질 저하가 약간 더 발생할 수 있습니다.

주요 양자화 레벨 비교: 당신의 선택을 위한 완벽 가이드#

이제 실제 사용 사례와 함께 주요 양자화 레벨을 상세히 비교해 보겠습니다. 모든 크기와 메모리 사용량은 70억(7B) 파라미터 모델 기준으로 계산되었습니다.

양자화 레벨 (Quant Level)	평균 비트 수 (bpw)	파일 크기 (7B 모델)	RAM/VRAM 요구량 (7B 모델)	품질 (vs FP16)	추천 사용 사례
FP16	16.00	~14.0 GB	~15.0 GB	기준 (손실 없음)	연구, 미세조정(Fine-tuning), 고사양 GPU(24GB+) 환경.
Q8_0	8.06	~7.7 GB	~8.5 GB	최상 (거의 손실 없음)	품질이 최우선이고 16GB VRAM/RAM을 가진 시스템. 가장 안전한 양자화 선택지.
Q6_K	6.57	~6.2 GB	~7.0 GB	매우 우수	고품질과 효율성의 탁월한 균형. 12GB+ VRAM/RAM 환경에서 최상의 경험 제공.
Q5_K_M	5.57	~5.1 GB	~6.0 GB	우수 (균형 잡힘)	많은 사용자들이 "스위트 스팟"으로 꼽는 레벨. 8GB VRAM/RAM 환경에 이상적.
Q5_K_S	5.64	~5.2 GB	~6.1 GB	우수 (Q5_K_M보다 미세하게 좋음)	Q5_K_M보다 약간의 품질 향상을 원할 때 선택. 크기 차이는 미미.
Q4_K_M	4.57	~4.1 GB	~5.0 GB	좋음 (가장 대중적인 선택)	"국민 양자화 레벨". 크기, 속도, 품질의 밸런스가 가장 뛰어남. 8GB RAM 노트북, 데스크톱의 표준.
Q4_K_S	4.64	~4.2 GB	~5.1 GB	좋음 (Q4_K_M보다 미세하게 좋음)	Q4_K_M보다 약간의 품질 향상을 원하지만, 메모리가 매우 제한적이지는 않을 때.
Q3_K_L	3.57	~3.2 GB	~4.0 GB	보통 (실용적)	4GB RAM의 라즈베리 파이 등 매우 제한적인 환경. 품질 저하가 느껴지기 시작함.
Q3_K_M	3.82	~3.4 GB	~4.3 GB	보통 (Q3_K_L보다 약간 좋음)	메모리는 부족하지만 가능한 품질을 지키고 싶을 때.
Q2_K	2.82	~2.5 GB	~3.3 GB	실험적 (품질 저하 눈에 띔)	모델을 실행하는 것 자체가 목표인 초저사양 환경. 창의적인 작업보다는 단순 작업에 적합.

참고: RAM/VRAM 요구량은 모델 자체의 크기 외에 컨텍스트(프롬프트, 대화 기록) 처리를 위한 추가 메모리(kv cache)를 고려하여 약간 더 크게 산정되었습니다.

나에게 맞는 레벨을 찾는 의사결정 트리#

어떤 레벨을 선택해야 할지 아직도 고민된다면, 아래의 순서도를 따라가 보세요.

graph TD
    A[내 시스템의 가용 RAM/VRAM은?] --> B{16GB 이상}
    B -- Yes --> C{품질이 최우선인가?}
    C -- Yes --> D[Q8_0 또는 Q6_K]
    C -- No --> E[Q5_K_M: 빠르고 충분히 좋음]

    B -- No --> F{8GB ~ 12GB}
    F --> G{코딩이나 논리적 추론이 중요한가?}
    G -- Yes --> H[Q5_K_M 또는 Q6_K]
    G -- No --> I[Q4_K_M: 최고의 만능 선택지]

    F -- No --> J{4GB ~ 6GB}
    J --> K{어떻게든 실행하는 것이 목표인가?}
    K -- Yes --> L[Q3_K_L 또는 Q3_K_M]
    K -- No --> M[Q4_K_M: 약간 느릴 수 있지만 품질은 더 좋음]

    J -- No --> N{4GB 미만}
    N --> O[Q3_K 또는 Q2_K]

    style D fill:#c9ffc9,stroke:#333,stroke-width:2px
    style E fill:#c9ffc9,stroke:#333,stroke-width:2px
    style H fill:#c9ffc9,stroke:#333,stroke-width:2px
    style I fill:#c9ffc9,stroke:#333,stroke-width:2px
    style L fill:#c9ffc9,stroke:#333,stroke-width:2px
    style M fill:#c9ffc9,stroke:#333,stroke-width:2px
    style O fill:#c9ffc9,stroke:#333,stroke-width:2px

핵심 요약:

"무엇을 써야 할지 전혀 모르겠다면, Q4_K_M으로 시작하세요."

Q4_K_M은 Llama.cpp 생태계에서 사실상의 표준으로 통하며, 대부분의 사용 사례에서 만족스러운 결과를 제공합니다. 먼저 Q4_K_M을 사용해보고, "품질이 조금 아쉬운데 메모리는 여유 있네" 싶으면 Q5_K_M이나 Q6_K로 올라가고, "메모리가 너무 부족해서 버벅인다" 싶으면 Q3_K_M으로 내려가는 방식으로 자신만의 최적점을 찾아보세요.

---

3. quantize 도구 활용 실습#

이제 이론을 배웠으니 직접 모델을 양자화해볼 시간입니다. Llama.cpp는 quantize라는 강력한 CLI(Command-Line Interface) 도구를 제공합니다. 이 실습에서는 Hugging Face에 있는 원본 모델을 다운로드받아 GGUF FP16 형식으로 변환한 뒤, 우리가 원하는 다양한 레벨로 양자화하는 전체 과정을 따라 해 보겠습니다.

실습 목표#

• mistralai/Mistral-7B-Instruct-v0.2 모델을 기준으로,
• 원본 모델을 F16 GGUF 파일로 변환합니다.
• F16 GGUF 파일을 Q4_K_M, Q8_0 두 가지 레벨로 양자화합니다.
• 파일 크기가 얼마나 줄어드는지 눈으로 확인하고, 양자화된 모델을 실행해봅니다.

Step 0: 사전 준비#

이 실습을 진행하려면 Llama.cpp가 여러분의 시스템에 성공적으로 빌드되어 있어야 합니다. (Chapter 2 참조)

1. Llama.cpp 소스 코드 클론 및 빌드:

   아직 Llama.cpp를 빌드하지 않았다면 터미널에서 다음 명령을 실행하세요.

# 1. 저장소 클론
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# 2. 빌드 (macOS/Linux)
make

# 2. 빌드 (Windows with CMake)
# CMake, Git, C++ 컴파일러(VS 2019+)가 설치되어 있어야 합니다.
mkdir build
cd build
cmake ..
cmake --build . --config Release

빌드가 성공하면 llama.cpp 디렉토리(또는 build/bin/Release 디렉토리)에 main, quantize 등의 실행 파일이 생성됩니다.

1. Python 환경 및 라이브러리 설치:

   Hugging Face 모델을 GGUF로 변환하기 위해 convert.py 스크립트를 사용해야 합니다. 이를 위해 Python과 몇 가지 라이브러리가 필요합니다.

# Python 가상환경 생성 및 활성화 (권장)
python3 -m venv venv
source venv/bin/activate  # macOS/Linux
# venv\Scripts\activate   # Windows

# 필요한 라이브러리 설치
pip install -r requirements.txt

Step 1: 원본 Hugging Face 모델 다운로드#

양자화를 하려면 먼저 양자화할 "재료"가 되는 원본 모델이 필요합니다. 보통 FP32나 FP16 형태의 모델을 다운로드합니다. 여기서는 Git LFS(Large File Storage)를 사용하여 Mistral-7B 모델을 다운로드하겠습니다.

# Git LFS가 설치되어 있어야 합니다. (없다면 'git lfs install' 실행)

# 저장소를 클론할 models 디렉토리 생성
mkdir models
cd models

# Hugging Face에서 모델 파일 다운로드
git clone https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2

cd .. # 다시 llama.cpp 루트 디렉토리로 이동

다운로드가 완료되면 models/Mistral-7B-Instruct-v0.2 디렉토리에 모델 파일들(*.safetensors, config.json 등)이 위치하게 됩니다.

Step 2: GGUF F16 형식으로 변환하기#

quantize 도구는 GGUF 파일을 입력으로 받습니다. 따라서 Hugging Face 형식의 모델을 먼저 GGUF로 변환해야 합니다. 이때, 양자화의 "베이스캠프"가 되는 FP16 (16비트 부동소수점) 형식으로 변환하는 것이 일반적입니다.

convert.py 스크립트를 사용하여 변환을 수행합니다.

# 가상환경이 활성화된 상태에서 실행합니다.

python convert.py models/Mistral-7B-Instruct-v0.2 \
  --outfile models/mistral-7b-instruct-v0.2.f16.gguf \
  --outtype f16

• models/Mistral-7B-Instruct-v0.2: 다운로드한 원본 모델 디렉토리 경로.
• --outfile models/mistral-7b-instruct-v0.2.f16.gguf: 출력될 GGUF 파일의 이름과 경로.
• --outtype f16: 출력 타입을 16비트 부동소수점(FP16)으로 지정.

이 과정은 시스템 사양에 따라 몇 분 정도 소요될 수 있습니다. 완료되면 models 디렉토리에 약 14.4GB 크기의 mistral-7b-instruct-v0.2.f16.gguf 파일이 생성된 것을 확인할 수 있습니다.

Step 3: quantize 도구로 양자화 실행!#

드디어 핵심 단계입니다. 방금 생성한 f16.gguf 파일을 quantize 도구의 입력으로 사용하여 원하는 레벨로 양자화하겠습니다.

기본 사용법:

./quantize [입력 파일] [출력 파일] [양자화 레벨]

1. Q4_K_M 레벨로 양자화하기

가장 대중적인 Q4_K_M 레벨부터 만들어 보겠습니다.

# macOS/Linux
./quantize models/mistral-7b-instruct-v0.2.f16.gguf \
         models/mistral-7b-instruct-v0.2.q4_k_m.gguf \
         Q4_K_M

# Windows (build 디렉토리에서)
# .\bin\Release\quantize.exe ..\..\models\mistral-7b-instruct-v0.2.f16.gguf ..\..\models\mistral-7b-instruct-v0.2.q4_k_m.gguf Q4_K_M

터미널에 각 레이어(tensor)가 처리되는 로그가 출력되고, 잠시 후 양자화가 완료됩니다.

2. Q8_0 레벨로 양자화하기

이번에는 고품질 버전인 Q8_0 레벨도 만들어 봅시다. 입력 파일은 동일하게 f16.gguf를 사용합니다.

# macOS/Linux
./quantize models/mistral-7b-instruct-v0.2.f16.gguf \
         models/mistral-7b-instruct-v0.2.q8_0.gguf \
         Q8_0

# Windows (build 디렉토리에서)
# .\bin\Release\quantize.exe ..\..\models\mistral-7b-instruct-v0.2.f16.gguf ..\..\models\mistral-7b-instruct-v0.2.q8_0.gguf Q8_0

Step 4: 결과 확인 및 테스트#

이제 models 디렉토리를 확인하여 우리의 "모델 다이어트"가 얼마나 성공적이었는지 봅시다.

ls -lh models/mistral-7b-instruct-v0.2.*.gguf

터미널 출력은 다음과 비슷할 것입니다:

-rw-r--r-- 1 user staff  14.4G  5 24 10:30 models/mistral-7b-instruct-v0.2.f16.gguf
-rw-r--r-- 1 user staff   4.1G  5 24 10:35 models/mistral-7b-instruct-v0.2.q4_k_m.gguf
-rw-r--r-- 1 user staff   7.7G  5 24 10:40 models/mistral-7b-instruct-v0.2.q8_0.gguf

놀랍지 않나요?

• 원본 14.4GB 파일이
• Q4_K_M에서는 4.1GB로 (약 71% 감소)
• Q8_0에서는 7.7GB로 (약 46% 감소)

극적으로 줄어들었습니다. 이제 이 모델들은 일반 노트북에서도 충분히 실행 가능한 크기가 되었습니다.

마지막으로, 새로 만든 모델이 잘 작동하는지 main 프로그램을 이용해 테스트해 봅시다.

# Q4_K_M 모델 테스트
./main -m models/mistral-7b-instruct-v0.2.q4_k_m.gguf \
       -p "Building a local AI with Llama.cpp is " \
       -n 128

• -m: 사용할 모델 파일 경로
• -p: 초기 프롬프트
• -n: 생성할 최대 토큰 수

모델이 로드되고 프롬프트에 이어 "fun", "exciting", "a great way to..." 와 같은 문장을 생성한다면 성공적으로 양자화가 완료된 것입니다! Q8_0 모델도 동일한 방식으로 테스트해 볼 수 있습니다.

고급 팁: 여러 레벨 동시 양자화 자동화#

만약 여러 양자화 레벨을 한 번에 만들고 싶다면, 셸 스크립트의 for 반복문을 사용하면 매우 편리합니다.

#!/bin/bash

# 변환할 양자화 레벨 목록
QUANT_LEVELS="Q2_K Q3_K_M Q4_K_M Q5_K_M Q6_K Q8_0"

# 기본 모델 파일 경로
BASE_MODEL="models/mistral-7b-instruct-v0.2.f16.gguf"
OUTPUT_PREFIX="models/mistral-7b-instruct-v0.2"

# 각 레벨에 대해 반복 실행
for level in $QUANT_LEVELS; do
    # 소문자로 변환하여 파일명에 사용 (예: q4_k_m)
    level_lower=$(echo "$level" | tr '[:upper:]' '[:lower:]')
    output_file="${OUTPUT_PREFIX}.${level_lower}.gguf"

    echo "=================================================="
    echo "Quantizing to ${level} -> ${output_file}"
    echo "=================================================="

    ./quantize "${BASE_MODEL}" "${output_file}" "${level}"

    if [ $? -eq 0 ]; then
        echo "Successfully created ${output_file}"
    else
        echo "Error quantizing to ${level}"
        exit 1
    fi
done

echo "All quantization levels processed."

이 스크립트를 quantize_all.sh와 같은 이름으로 저장하고 chmod +x quantize_all.sh로 실행 권한을 준 뒤 ./quantize_all.sh를 실행하면, 목록에 있는 모든 레벨의 GGUF 파일이 자동으로 생성됩니다.