오픈소스 LLM 생태계 완전 가이드: 2026년 모델, 도구, 배포 전략

Multi-Head Attention (MHA):
Q heads: 32    K heads: 32    V heads: 32
KV cache: 2 × 32 × seq_len × d_head

Grouped Query Attention (GQA):
Q heads: 32    K heads: 8    V heads: 8
KV cache: 2 × 8 × seq_len × d_head   (4× 감소!)

Multi-Query Attention (MQA):
Q heads: 32    K heads: 1    V heads: 1
KV cache: 2 × 1 × seq_len × d_head   (32× 감소, 품질 다소 저하)

# MoE 레이어 개념 (단순화)
class MoELayer:
    def __init__(self, num_experts=8, top_k=2, d_model=4096, d_ff=14336):
        self.experts = [FeedForward(d_model, d_ff) for _ in range(num_experts)]
        self.router = nn.Linear(d_model, num_experts)
        self.top_k = top_k  # 토큰당 top_k 전문가만 활성화

    def forward(self, x):
        # 라우터가 top-k 전문가 선택
        logits = self.router(x)
        weights, indices = logits.topk(self.top_k)
        weights = F.softmax(weights, dim=-1)

        # 선택된 전문가 출력의 가중 합
        output = sum(
            weights[:, i] * self.experts[indices[:, i]](x)
            for i in range(self.top_k)
        )
        return output

KV cache size = 2 × num_layers × num_kv_heads × head_dim × seq_len × dtype_bytes

예시: Llama 3.1 8B, fp16, 128K 컨텍스트
= 2 × 32 × 8 × 128 × 131072 × 2 bytes
= ~17.2 GB (KV 캐시만)

# 설치 (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# 모델 대화형 실행
ollama run llama3.1:8b

# 특정 양자화 실행
ollama run llama3.1:70b-instruct-q4_K_M

# 실행 없이 다운로드만
ollama pull mistral:7b

# 설치된 모델 목록
ollama list

# API 서버로 실행 (OpenAI 호환!)
ollama serve  # localhost:11434에서 시작

from openai import OpenAI

# 로컬 Ollama 연결
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # 필요하지만 무시됨
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "트랜스포머를 간단히 설명해줘."}]
)
print(response.choices[0].message.content)

# 빌드
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DLLAMA_CUDA=ON  # CUDA GPU 지원
cmake --build build --config Release -j

# GGUF 모델 다운로드 (예시)
# Hugging Face에서: bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# 추론 실행
./build/bin/llama-cli \
  -m models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
  -n 512 \
  --prompt "트랜스포머의 어텐션 메커니즘을 설명해."

# OpenAI 호환 서버로 실행
./build/bin/llama-server \
  -m models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -c 4096 \
  -ngl 35  # GPU에 올릴 레이어 수

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "meta-llama/Meta-Llama-3.1-8B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",          # 사용 가능한 GPU에 자동 분산
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "트랜스포머 아키텍처란 무엇인가요?"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to(model.device)

with torch.no_grad():
    outputs = model.generate(
        input_ids,
        max_new_tokens=512,
        temperature=0.7,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id,
    )

response = tokenizer.decode(outputs[0][input_ids.shape[-1]:], skip_special_tokens=True)
print(response)

# 설치
pip install vllm

# 서버 시작 (단일 GPU)
python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Meta-Llama-3.1-8B-Instruct \
  --dtype bfloat16 \
  --max-model-len 32768 \
  --port 8000

# 텐서 병렬처리로 다중 GPU (4개 GPU)
python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Meta-Llama-3.1-70B-Instruct \
  --dtype bfloat16 \
  --tensor-parallel-size 4 \
  --max-model-len 32768 \
  --port 8000

# 양자화 적용 (AWQ)
python -m vllm.entrypoints.openai.api_server \
  --model TheBloke/Llama-3-70B-Instruct-AWQ \
  --quantization awq \
  --dtype float16 \
  --tensor-parallel-size 2

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "PagedAttention이란 무엇인가요?"}],
    max_tokens=256,
    temperature=0.7,
)
print(response.choices[0].message.content)

# 스트리밍
with client.chat.completions.stream(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "RAG를 자세히 설명해줘."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Dockerfile
FROM vllm/vllm-openai:latest

ENV HUGGING_FACE_HUB_TOKEN=""

CMD ["--model", "meta-llama/Meta-Llama-3.1-8B-Instruct", \
     "--dtype", "bfloat16", \
     "--max-model-len", "16384"]

docker run --gpus all \
  -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=hf_xxx \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  my-vllm-server

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "meta-llama/Meta-Llama-3.1-8B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# LoRA 설정
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,               # 적응 행렬의 랭크
    lora_alpha=32,      # 스케일링 팩터
    lora_dropout=0.05,
    target_modules=[    # 적응할 레이어
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    bias="none",
)

peft_model = get_peft_model(model, lora_config)
peft_model.print_trainable_parameters()
# trainable params: 83,886,080 || all params: 8,114,474,240 || trainable%: 1.03%

from transformers import BitsAndBytesConfig
from peft import prepare_model_for_kbit_training

# 4비트 양자화 설정
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

# k비트 학습 준비 (레이어 정규화를 fp32로 캐스팅 등)
model = prepare_model_for_kbit_training(model)

# 양자화된 모델 위에 LoRA 적용
peft_model = get_peft_model(model, lora_config)

from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

dataset = load_dataset("your-org/your-dataset", split="train")

def format_example(example):
    return {
        "text": f"<|user|>\n{example['instruction']}\n<|assistant|>\n{example['output']}"
    }

dataset = dataset.map(format_example)

trainer = SFTTrainer(
    model=peft_model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=SFTConfig(
        output_dir="./checkpoints",
        num_train_epochs=3,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        warmup_ratio=0.03,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_steps=100,
        dataset_text_field="text",
        max_seq_length=2048,
    ),
)

trainer.train()
trainer.model.save_pretrained("./fine-tuned-model")

from peft import PeftModel

# 베이스 모델 로드
base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="cpu"
)

# LoRA 가중치 로드 및 병합
model = PeftModel.from_pretrained(base_model, "./fine-tuned-model")
merged_model = model.merge_and_unload()

# 병합된 모델 저장 (표준 HF 형식, vLLM 등과 호환)
merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

from huggingface_hub import list_models, model_info

# 모델 검색
models = list_models(
    filter="text-generation",
    sort="downloads",
    direction=-1,
    limit=10
)
for m in models:
    print(m.id, m.downloads)

# 모델 정보 조회
info = model_info("meta-llama/Meta-Llama-3.1-8B-Instruct")
print(info.tags)
print(info.cardData)

Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
│                            │
└─ 모델명                    └─ 양자화 방식

주요 양자화 접미사:
Q4_K_M  - 4비트, 품질/속도 균형 (대부분의 경우 권장)
Q5_K_M  - 5비트, 더 높은 품질, 더 많은 메모리
Q6_K    - 6비트, 준무손실, 높은 메모리
Q8_0    - 8비트, 사실상 무손실
Q2_K    - 2비트, 매우 낮은 품질, 매우 적은 메모리
IQ4_XS  - 4비트 "중요도 양자화", Q4_K_M보다 좋은 품질

# Space API로 호출하기
from gradio_client import Client

client = Client("meta-llama/Llama-3.1-8B-Instruct")
result = client.predict(
    message="트랜스포머 어텐션 메커니즘 설명해줘",
    api_name="/chat"
)
print(result)

from transformers import AutoModelForCausalLM, GPTQConfig

# 1회성 양자화 (캘리브레이션 데이터 필요)
quantization_config = GPTQConfig(
    bits=4,
    dataset="c4",
    block_size=128
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3.1-8B-Instruct",
    quantization_config=quantization_config,
    device_map="auto"
)

model.save_pretrained("./llama-3.1-8b-gptq")

# 설치
pip install autoawq

# 양자화
python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = 'meta-llama/Meta-Llama-3.1-8B-Instruct'
quant_path = './llama-3.1-8b-awq'

model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)

quant_config = {'zero_point': True, 'q_group_size': 128, 'w_bit': 4, 'version': 'GEMM'}
model.quantize(tokenizer, quant_config=quant_config)

model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)
print('양자화 완료')
"

# 위의 QLoRA 섹션에서 이미 보여준 방식
# load_in_4bit=True인 BitsAndBytesConfig 사용
# NF4 양자화가 QLoRA 파인튜닝에 가장 적합

                 ┌──────────────────────┐
                 │  작업이 무엇인가요?   │
                 └──────────┬───────────┘
                            │
          ┌─────────────────┼─────────────────┐
          ▼                 ▼                 ▼
    코드 생성          다국어 처리        일반 대화
          │                │                  │
    Qwen2.5-Coder     Qwen2.5 / Llama    Llama 3.1 8B
    DeepSeek-Coder    / Mistral NeMo     Mistral 7B
    CodeGemma                            Gemma 2 9B

          │
          ▼
   로컬 실행이
   필요한가요?
          │
    ┌─────┴─────┐
    │예         │아니오
    ▼           ▼
 RAM 충분?  vLLM 사용
    │       + Llama 70B
  ┌─┴──┐    또는 405B
  │    │
 <=8GB >8GB
  │    │
 8B   70B
 Q4   Q4_K_M

def route_request(request: dict) -> str:
    """요구 사항에 따라 오픈소스 또는 독점 모델로 라우팅."""

    # 민감한 데이터는 항상 오픈소스 사용
    if request.get("contains_pii") or request.get("confidential"):
        return "local_llama_70b"

    # 대용량 단순 작업은 오픈소스 사용
    if request.get("task_type") in ["classification", "extraction", "summarization"]:
        if request.get("volume") == "high":
            return "local_llama_8b"

    # 복잡한 추론이나 멀티모달은 독점 모델 사용
    if request.get("requires_vision") or request.get("complexity") == "high":
        return "gpt_4o"

    # 기본값: 비용 절감을 위해 로컬 모델
    return "local_llama_70b"