オープンソース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枚）
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

# 一回限りの量子化（キャリブレーションデータが必要）
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"