Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

Model bahasa besar (LLM) open-source terus berkembang pesat. Dengan banyaknya model fine-tuned yang tersedia di Hugging Face, muncul teknik menarik yang memungkinkan kita menggabungkan beberapa model menjadi satu model baru tanpa perlu training ulang. Teknik ini disebut model merging, dan MergeKit adalah toolkit paling populer untuk melakukannya.

MergeKit, yang dikembangkan oleh Arcee AI, memungkinkan kita menggabungkan dua atau lebih model transformer dengan berbagai metode seperti SLERP, TIES, DARE, dan linear merge. Hasilnya adalah model baru yang menggabungkan kemampuan dari model-model sumber tanpa membutuhkan GPU untuk training.

Dalam tutorial ini, kita akan mempelajari cara menggunakan MergeKit dari instalasi hingga membuat model merged yang siap digunakan.

Mengapa Model Merging?

Sebelum masuk ke teknik, penting untuk memahami mengapa model merging menjadi populer:

Instalasi MergeKit

Prasyarat

• Python 3.10 atau lebih baru
• RAM minimal 16 GB (tergantung ukuran model)
• Disk space yang cukup untuk menyimpan model (setiap model 7B membutuhkan sekitar 14 GB dalam fp16)

Instalasi dari PyPI

pip install mergekit

Instalasi dari Source (Rekomendasi)

Untuk mendapatkan fitur terbaru:

git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e .

Jika ingin menggunakan fitur evolusi (evolutionary merge):

pip install -e ".[evolve]"

Verifikasi Instalasi

mergekit-yaml --help

Jika command ini menampilkan opsi bantuan, instalasi berhasil.

Konsep Dasar Model Merging

Arsitektur yang Didukung

MergeKit mendukung model-model berbasis transformer, termasuk:

• LLaMA dan turunannya (Mistral, Qwen, dll.)
• GPT-NeoX
• Phi
• Gemma
• StableLM
• Dan arsitektur lain yang kompatibel

Metode Merge yang Tersedia

MergeKit menyediakan beberapa metode merge:

| Metode | Deskripsi | Kapan Digunakan |

|--------|-----------|-----------------|

| Linear | Weighted average sederhana dari weight model | Baseline, cepat, mudah dipahami |

| SLERP | Spherical Linear Interpolation | Merge 2 model dengan transisi halus |

| TIES | TrIm, Elect, and merGe | Mengurangi interferensi antar task |

| DARE | Drop And REscale | Mirip TIES dengan pendekatan berbeda |

| Passthrough | Menggabungkan layer secara berurutan | Membuat model "frankenmerge" yang lebih besar |

| Model Stock | Geometric merge di weight space | Merge yang lebih robust |

Membuat Konfigurasi Merge Pertama

MergeKit menggunakan file YAML untuk mendefinisikan konfigurasi merge. Mari mulai dengan contoh sederhana.

Linear Merge (Weighted Average)

Buat file linear-merge.yml:

mergemethod: linear
dtype: float16
models:
model: NousResearch/Hermes-2-Pro-Mistral-7B
    parameters:

      weight: 0.6
model: teknium/OpenHermes-2.5-Mistral-7B
    parameters:

      weight: 0.4

mergekit-yaml linear-merge.yml ./output-linear-merge --cuda --lazy-unpickle

mergemethod: slerp
dtype: float16
basemodel: NousResearch/Hermes-2-Pro-Mistral-7B

parameters:
  t: 0.5
models:
model: NousResearch/Hermes-2-Pro-Mistral-7B
model: teknium/OpenHermes-2.5-Mistral-7B

mergekit-yaml slerp-merge.yml ./output-slerp-merge --cuda

mergemethod: ties
dtype: float16
basemodel: mistralai/Mistral-7B-v0.1

parameters:
  density: 0.5
  normalize: true
models:
model: NousResearch/Hermes-2-Pro-Mistral-7B
    parameters:

      weight: 1.0
      density: 0.5
model: teknium/OpenHermes-2.5-Mistral-7B
    parameters:

      weight: 0.5
      density: 0.5

• density: Proporsi parameter yang dipertahankan (0.0-1.0). Nilai lebih rendah berarti lebih banyak parameter yang di-trim.
• normalize: Normalisasi weight setelah merge.
• basemodel: Model referensi untuk menghitung delta weight.

mergekit-yaml ties-merge.yml ./output-ties-merge --cuda

DARE Merge

DARE (Drop And REscale) mirip TIES tetapi menggunakan random dropping. Buat file dare-merge.yml:

mergemethod: dareties
dtype: float16
basemodel: mistralai/Mistral-7B-v0.1

parameters:
  normalize: true
models:
model: NousResearch/Hermes-2-Pro-Mistral-7B
    parameters:

      weight: 1.0
      density: 0.6
model: teknium/OpenHermes-2.5-Mistral-7B
    parameters:

      weight: 0.5
      density: 0.6

mergekit-yaml dare-merge.yml ./output-dare-merge --cuda

mergemethod: passthrough
dtype: float16
slices:
sources:
model: NousResearch/Hermes-2-Pro-Mistral-7B
        layerrange: [0, 16]

sources:
model: teknium/OpenHermes-2.5-Mistral-7B
        layerrange: [8, 24]

sources:
model: NousResearch/Hermes-2-Pro-Mistral-7B
        layerrange: [16, 32]

mergekit-yaml franken-merge.yml ./output-franken-merge --cuda

mergemethod: slerp
dtype: float16
basemodel: NousResearch/Hermes-2-Pro-Mistral-7B

parameters:
  t:
filter: selfattn
      value: [0.0, 0.3, 0.5, 0.7, 1.0]

filter: mlp
      value: [1.0, 0.7, 0.5, 0.3, 0.0]

value: 0.5
models:

model: NousResearch/Hermes-2-Pro-Mistral-7B
model: teknium/OpenHermes-2.5-Mistral-7B

Konfigurasi ini menggunakan gradient yang berbeda untuk attention layers dan MLP layers, memberikan kontrol granular atas proses merge.

Merge dengan Tokenizer Kustom

Jika model yang di-merge memiliki tokenizer berbeda:

mergemethod: linear
dtype: float16
tokenizersource: union
models:
model: modelA

    parameters:

      weight: 0.5
model: modelB
    parameters:

      weight: 0.5

Opsi tokenizersource:

mergemethod: slerp
dtype: float16
basemodel: /path/to/local/model-a

parameters:
  t: 0.5
models:
model: /path/to/local/model-a
model: /path/to/local/model-b

from transformers import AutoModelForCausalLM, AutoTokenizer

modelpath = "./output-slerp-merge"
tokenizer = AutoTokenizer.frompretrained(modelpath)
model = AutoModelForCausalLM.frompretrained(

    modelpath,
    torchdtype="auto",

    devicemap="auto"
)

prompt = "Jelaskan konsep machine learning dalam 3 kalimat:"
inputs = tokenizer(prompt, returntensors="pt").to(model.device)

outputs = model.generate(inputs, maxnewtokens=200, temperature=0.7)

print(tokenizer.decode(outputs[0], skipspecialtokens=True))

pip install lm-eval

lmeval --model hf \
  --modelargs pretrained=./output-slerp-merge \

  --tasks hellaswag,arceasy,mmlu \
  --batchsize 8

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

def generateresponse(modelpath, prompt, maxtokens=200):
    tokenizer = AutoTokenizer.frompretrained(modelpath)
    model = AutoModelForCausalLM.frompretrained(

        modelpath, torchdtype=torch.float16, devicemap="auto"
    )
    inputs = tokenizer(prompt, returntensors="pt").to(model.device)

    outputs = model.generate(inputs, maxnewtokens=maxtokens, temperature=0.7)
    return tokenizer.decode(outputs[0], skipspecialtokens=True)

testprompts = [

    "Write a Python function to calculate fibonacci numbers:",
    "Explain quantum computing to a 5-year-old:",
    "What are the best practices for database indexing?",
]

models = {
    "Model A": "NousResearch/Hermes-2-Pro-Mistral-7B",
    "Merged": "./output-slerp-merge",
}

for prompt in testprompts:
    print(f"\nPrompt: {prompt}")
    print("=" * 60)
    for name, path in models.items():
        response = generateresponse(path, prompt)

        print(f"\n[{name}]:")
        print(response)

from huggingfacehub import HfApi

api = HfApi()

api.createrepo(

    repoid="username/my-merged-model",
    repotype="model",

    private=False
)

api.uploadfolder(
    folderpath="./output-slerp-merge",

    repoid="username/my-merged-model",
    repotype="model",

)

huggingface-cli upload username/my-merged-model ./output-slerp-merge

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

python converthftogguf.py ../output-slerp-merge --outfile merged-model.gguf --outtype f16

Untuk quantisasi (mengurangi ukuran file):

./llama-quantize merged-model.gguf merged-model-Q4KM.gguf Q4KM

Level quantisasi populer:

• Q4KM: Keseimbangan antara ukuran dan kualitas (rekomendasi)
• Q5KM: Kualitas lebih tinggi, file lebih besar
• Q80: Kualitas hampir setara fp16, file besar

RuntimeError: CUDA out of memory

RuntimeError: Incompatible architectures

Jika model memiliki vocabulary berbeda, gunakan tokenizersource: union atau pilih tokenizer dari salah satu model.

Kesimpulan

MergeKit adalah toolkit yang sangat berguna untuk membuat model LLM kustom tanpa perlu training. Dengan memahami berbagai metode merge dan parameter yang tersedia, kita bisa bereksperimen dan menemukan kombinasi optimal untuk kebutuhan spesifik.

Beberapa poin penting yang perlu diingat:

• Mulai dengan metode sederhana (linear atau SLERP) sebelum mencoba yang lebih kompleks
• Selalu evaluasi model hasil merge secara menyeluruh
• Dokumentasikan setiap eksperimen untuk reproducibility
• Model merged terbaik biasanya menggabungkan model yang memiliki kelebihan di area berbeda

Dengan teknik model merging dan MergeKit, Anda bisa membuat model AI yang disesuaikan dengan kebutuhan tanpa biaya training yang mahal. Selamat bereksperimen!