メインコンテンツへスキップ
見出し画像

RTX 4090でgpt-oss-20bをLoRAファインチューニングしてOllamaに持っていった記録

    はじめに

    2026年9月時点の備忘録。

    個人開発しているシステムでローカルLLMを使っていて、いくつかのモデルを実際の利用条件に近い形で比較したあと、最終的に20BクラスのモデルをLoRAでファインチューニングし、GGUFへ変換してOllamaから呼び出すところまで試した。

    何を作っているのか、どんな業務データを扱っているのかについては、この記事では伏せる。

    この記事で残したいのは、

    何を作っているかではなく、ローカルLLMのモデル選定からファインチューニング、デプロイ、評価までで何を試して、どこで詰まり、どう直したか

    という部分。

    いわゆる「ファインチューニング入門」というより、自分向けの作業ログに近い。

    半年後に同じ問題を踏んだとき、

    これ前にもやった気がするけど、どう直したっけ?

    となるのを避けるために残しておく。


    この記事の前提

    ここに書いているモデル評価や速度は、すべて

    自分の環境・自分の入力形式・自分の利用方法で観測した結果

    である。

    一般的なLLM性能の優劣を示すものではない。

    今回の用途は、おおまかにいうと、

    比較的長い入力を読む
    ↓
    複数の根拠や値の関係を追う
    ↓
    条件に従って判断する
    ↓
    決められた構造化形式で回答する

    というもの。

    同じモデルでも、

    • prompt

    • context length

    • quantization

    • reasoning設定

    • runtime

    • GPU

    • 出力長

    • タスク内容

    が変われば、結果は当然変わると思う。

    なので、以下は、

    自分の用途では何が起きたか

    という記録として読んでもらえればと思う。


    この記事中のコマンドについて

    記事中には実行コマンドも載せるが、実際のコマンドをそのまま公開しているわけではない。

    以下は削除または一般化している。

    プロジェクト名
    リポジトリ名
    ローカルの絶対パス
    ユーザー名
    内部CLI名
    実データ名
    評価対象の識別子
    UUID
    内部schema
    業務固有のprompt

    そのため、

    train_lora.py
    evaluate.py
    .\data\train.jsonl

    のような名前は説明用。

    一方で、

    • 使用モデル

    • LoRA設定

    • ライブラリversion

    • converterの主要option

    • 実際に遭遇した代表的なエラー

    • 問題を解決した考え方

    については、可能な範囲で実際の検証内容に合わせている。

    完全なコピペ用手順ではなく、

    自分がどう問題を切り分けたかを残すための再現用例

    として載せている。


    検証環境

    検証時点:

    2026-09-28

    ハードウェア:

    OS      : Windows 11
    GPU     : NVIDIA GeForce RTX 4090
    VRAM    : 24 GB class
    CPU     : AMD Ryzen 9 9950X3D
    RAM     : 64 GB class
    CUDA    : 12.8

    学習時に固定していた主なライブラリ:

    unsloth            2026.9.11
    unsloth-zoo        2026.9.7
    bitsandbytes       0.50.2
    torch              2.9.1+cu128
    transformers       4.57.6
    peft               0.18.0
    accelerate         1.12.0
    trl                0.24.0
    xformers           0.0.33.post2
    triton-windows     3.5.1.post24

    推論・変換周辺:

    Ollama client : 0.34.4
    llama.cpp      : build b11193-4e7481175

    学習対象:

    unsloth/gpt-oss-20b-unsloth-bnb-4bit

    学習時はmodel revisionも固定した。

    093fba6992ef5a7152481afec0bdfca1ac486998

    この手の話はversionが変わると普通に挙動が変わる。

    特に今回は、

    • bitsandbytesのAPI

    • Unslothのメモリ処理

    • llama.cppのconverter

    • Ollamaのmodel runtime

    あたりに依存する問題を踏んだので、versionは残しておいた方がよいと感じた。


    まず複数のモデルを試した

    ファインチューニングを始める前に、いくつかのローカルLLMを実際の利用条件に近い入力で試した。

    厳密なベンチマークではない。

    同じ系統の実データ相当入力を与え、

    • 正常に完了するか

    • どれくらい時間がかかるか

    • 比較対象を正しく扱えるか

    • 指示したルールを守れるか

    • structured outputまで完了できるか

    を見ていた。

    結果はこんな感じだった。

    モデルeffort時間自分の用途での結果Qwen3.8 27BLOW約212秒成功。比較・根拠の扱いは比較的良好gpt-oss 20BMEDIUM約29秒成功。ただし比較期間の混同ありQwen3.5 9BLOW約132秒LengthFinishReasonErrorQwen3 14BLOW約43〜45秒指定した判断・出力ルールへの違反Gemma 4 12BLOW約167秒LengthFinishReasonErrorGemma 4 26BLOW約58秒LengthFinishReasonErrorGemma 4 31B QATLOW300秒超timeout

    ここでいう時間は、モデルそのものの標準ベンチマークではない。

    あくまで自分のアプリケーション相当の処理を実行したときの観測値。


    LengthFinishReasonError について

    Qwen3.5 9B、Gemma 4 12B、Gemma 4 26Bでは、

    LengthFinishReasonError

    が発生した。

    単純に、

    モデルが何も答えられなかった

    という意味ではない。

    今回使っていた呼び出し経路では、モデルが指定された生成長の範囲内で正常終了せず、length側のfinish reasonになった場合にエラーとして扱われる。

    なのでこの記事では、

    出力が長かった

    とだけ丸めず、後から調査しやすいように例外名そのものを残しておく。

    モデル自身の最大context長なのか、API/client側の生成上限なのか、こちらで指定したmax outputなのかは別問題なので、そこは区別したい。


    Qwen3.5 9B

    9Bクラスならかなり軽いのでは、と期待して試した。

    ただ、自分の条件では、

    約132秒

    かかった。

    さらに最終的に、

    LengthFinishReasonError

    になった。

    今回の用途では、回答の途中にある程度の分析が入り、その後structured outputまで生成する必要がある。

    モデルサイズが小さいからといって、

    必ず短時間で回答が完了する

    わけではないことが分かった。

    この時点では有力候補には残さなかった。


    Qwen3 14B

    こちらは速度面ではかなり良かった。

    約43〜45秒

    程度。

    これはかなり魅力的だった。

    ただし、実際の出力を見ると、自分がpromptで指定した判断ルールや出力上の制約に違反するケースがあった。

    今回必要だったのは、自然な回答だけではない。

    例えば、

    比較条件を守る
    根拠が足りないときに断定しない
    指定した出力形式を守る

    といったことも重要だった。

    そのため、速度は良かったものの、この時点では候補から外した。


    Gemma 4 12B

    Gemma系も試した。

    12Bでは、

    約167秒

    かかった。

    最終的には、

    LengthFinishReasonError

    になった。

    少なくとも今回の長めの入力とreasoningを含む用途では、

    12Bだから十分軽い

    という結果にはならなかった。


    Gemma 4 26B

    26Bでは、

    約58秒

    だった。

    ここは少し面白かった。

    12Bより大きいのに、今回の観測では26Bの方が短時間で進んだ。

    モデルサイズだけで実際の処理時間を予想するのは難しいと感じたところ。

    速度だけを見れば約1分なので悪くない。

    ただしこちらも、

    LengthFinishReasonError

    になり、必要な回答を最後まで正常終了できなかった。


    Gemma 4 31B QAT

    31BのQAT版も試した。

    こちらは、

    300秒超

    まで待ったところでtimeout。

    少なくとも、

    RTX 4090
    +
    今回のruntime
    +
    今回の長めの入力

    という条件では、繰り返し呼ぶ用途には厳しかった。


    Qwen3.8 27B

    品質重視の候補として最後まで残ったのがQwen3.8 27B。

    代表的な比較では、

    effort  : LOW
    latency : 約212秒
    result  : SUCCESS

    だった。

    別の実行でも100秒台後半から200秒程度になることが多かった。

    かなり遅い。

    一方、自分が重要視していた、

    比較対象を揃える
    入力された根拠を追う
    値の関係を取り違えない
    回答内部の矛盾を抑える

    といった部分は比較的良かった。

    そのため、

    本番で毎回使うには遅いが、教師回答候補を作るなら使える

    と考えた。

    現在は、

    teacher / reference

    寄りの役割として扱っている。


    gpt-oss 20B

    一方で速度面でかなり目立ったのが、

    gpt-oss:20b

    だった。

    代表的な実行では、

    effort  : MEDIUM
    latency : 約29秒
    result  : SUCCESS

    だった。

    ほかの実行でも、

    約20〜30秒

    程度に収まることが多かった。

    Qwen3.8 27Bが約212秒だったことを考えると、かなり大きな差。

    複数回LLMを呼ぶシステムでは、この差は重要だった。

    ただし問題もあった。

    ある評価ケースで、本来比較すべき期間ではなく別の期間の値を使って判断してしまった。

    業務内容を伏せて一般化すると、

    本来比較するべきデータA

    ではなく、

    別条件のデータB

    を比較対象として選んでしまったようなケース。

    文章としては自然。

    JSONも正常。

    それでも根拠関係としては間違っている。

    これは今回の用途ではかなり困る。


    比較して見えてきたこと

    ざっくり整理すると、自分の環境ではこうだった。

    Qwen3.5 9B
      → 思ったほど速くない
      → LengthFinishReasonError
    
    Qwen3 14B
      → 速度は良い
      → ただしルール遵守に問題
    
    Gemma 4 12B
      → 遅め
      → LengthFinishReasonError
    
    Gemma 4 26B
      → 約1分
      → LengthFinishReasonError
    
    Gemma 4 31B QAT
      → 自分の条件では重い
      → timeout
    
    Qwen3.8 27B
      → 遅い
      → 比較・根拠の扱いは比較的良い
    
    gpt-oss 20B
      → かなり速い
      → 比較・根拠対応のミスが残る

    ここで方針がかなり明確になった。

    自分が欲しいのは、

    Qwen3.8 27Bのような根拠の扱い
    +
    gpt-oss 20Bの速度

    に近いもの。

    もちろん、ファインチューニングすれば簡単にその中間が作れるとは思っていない。

    ただ、gpt-oss側の失敗を見ると、

    そもそも能力がまったく足りない

    というより、

    自分の用途で特に守ってほしい比較方法や根拠の扱いを外す

    タイプのミスが目立った。

    それなら、

    gpt-oss 20Bの速度を残したまま、自分の用途特有の作法をLoRAで補正できないか

    を試す価値はありそうだった。

    これが今回ファインチューニングを始めた理由。


    何を学習させたいのか

    今回の目的は新しい知識を覚えさせることではない。

    どちらかというと、

    仕事のやり方を覚えてもらうこと

    だった。

    例えば、

    新しい根拠と古い状態が矛盾したら、新しい根拠を優先する
    
    比較する場合は条件を揃える
    
    違う種類の値を混ぜない
    
    比較には両側の根拠を使う
    
    根拠が足りなければ無理に断定しない
    
    指定されたstructured outputを守る

    といったもの。

    「もっと万能に賢くする」というより、

    この用途で間違えてほしくないところを教える

    イメージに近い。


    教師データもLLMで作る

    教師データを全部人間で書くのは大変。

    そこで、

    品質重視のモデル
    ↓
    教師回答候補を生成
    ↓
    機械的チェック
    ↓
    人間レビュー
    ↓
    ACCEPT / REJECT

    という流れにした。

    ここで重要だったのが、

    教師モデルの回答をそのまま正解扱いしないこと。

    実際、教師側も間違った。

    文章はかなり自然なのに、比較に使っている値を見ると条件がズレているケースがあった。

    そこで、

    PENDING
    ACCEPTED
    REJECTED

    のようなreview状態を持たせ、人間が確認した回答だけ学習対象にした。

    LLMを教師にしても、

    Teacher Output = Ground Truth

    ではない。

    ここは実際に作ってみてかなり重要だと感じた。


    TRAIN / VALIDATION / HOLDOUTを先に分けた

    学習する前に、

    TRAIN
    VALIDATION
    HOLDOUT

    を分離した。

    特にHOLDOUTは学習には絶対使わない。

    あとで、

    Base Model
    vs
    Fine-tuned Model

    を比較するためだけに使う。

    結果的にこれはかなり役立った。

    後で書くが、1-stepだけ学習したモデルはHOLDOUTでむしろbase modelより悪い回答をした。

    評価データを分けていなければ、

    Fine-tuningしたからなんとなく良くなった気がする

    で終わっていたかもしれない。


    RTX 4090で20Bをどう学習するか

    対象は20Bクラス。

    VRAMは24GB。

    普通にフルファインチューニングするのは現実的ではない。

    そこで、

    4bit量子化 + LoRA

    で試した。

    今回の設定:

    Quantization:
      NF4
      double quantization
    
    LoRA:
      rank    = 8
      alpha   = 16
      dropout = 0
    
    Target:
      q_proj
      k_proj
      v_proj
      o_proj
    
    Optimizer:
      AdamW8bit
    
    Batch:
      1

    最初から本学習はしない

    最初に確認したかったのは品質ではなく、

    optimizer stepが本当に1回通るか

    だった。

    いわゆるsmoke test。

    目標は、

    model load
    ↓
    LoRA injection
    ↓
    forward
    ↓
    backward
    ↓
    gradient validation
    ↓
    optimizer.step()
    ↓
    adapter save
    ↓
    model release
    ↓
    fresh base reload
    ↓
    adapter reload

    まで。

    これが通らない状態で教師データを大量に作っても意味がない。


    1-step LoRA学習

    記事用に一般化すると、実行内容はこんなイメージ。

    $env:UNSLOTH_CE_LOSS_N_CHUNKS="16"
    
    python train_lora.py `
      --model "unsloth/gpt-oss-20b-unsloth-bnb-4bit" `
      --dataset ".\data\train.jsonl" `
      --output-dir ".\output\adapter" `
      --lora-rank 8 `
      --lora-alpha 16 `
      --lora-dropout 0 `
      --target-modules "q_proj,k_proj,v_proj,o_proj" `
      --batch-size 1 `
      --max-steps 1

    train_lora.py は説明用。

    実際には、

    • split確認

    • training sampleの検証

    • masking確認

    • gradient確認

    • adapter保存

    • fresh reload

    などを含むプロジェクト専用経路を使っている。


    その前にいくつかハマった

    1 step通るまでにも別々の問題が出た。


    bitsandbytes 0.50.2とAdamW8bit

    既存コードでは AdamW8bit に、

    block_wise=...

    を渡していた。

    しかし今回固定していた、

    bitsandbytes 0.50.2

    では、この引数をそのconstructorが受け付けなかった。

    そこでoptimizer自体は変えず、

    サポートされていない引数だけ削除

    した。

    こういう問題はversion情報がないと、後で読むと意味が分からなくなる。


    tokenizerの特殊tokenでもハマった

    学習対象はassistant response部分だけにしたかった。

    概念的には、

    system    → loss対象外
    user      → loss対象外
    assistant → loss対象

    という形。

    ところが実tokenizerを使うと、こちらが想定していた特殊tokenの扱いと実際の定義が一致していなかった。

    つまり、

    all_special_tokens を見れば、chat template内の制御tokenを全部把握できる

    という前提が間違っていた。

    実際のtoken列を確認してmask処理を修正した。


    Unslothのfused cross entropyで止まる

    次に出たのが、

    Unsloth:
    No or negligible GPU memory available for fused cross entropy.

    というエラー。

    実際のCUDA OOMというより、

    Unsloth側の自動memory budget判定で止まる

    状態だった。

    ローカル実装を追って、chunk数を明示できることを確認。

    $env:UNSLOTH_CE_LOSS_N_CHUNKS="16"

    とした。

    するとforwardを抜けてbackwardへ進んだ。

    最終的には、この環境では 16 をdefaultとして扱うところまで検証した。

    ただしこれは、

    RTX 4090なら16

    という意味ではない。

    あくまで、

    Windows 11
    RTX 4090
    CUDA 12.8
    Unsloth 2026.9.11
    unsloth-zoo 2026.9.7
    今回のmodel
    今回の入力

    で確認できた値。

    将来のversionでは変わる可能性が高い。


    次はWindowsのTriton cache pathで落ちた

    forwardを越えたあと、backward中にTritonのcache書き込みで失敗した。

    原因はWindows上の深いcache path。

    そこでcompile cache用ディレクトリを短くした。

    記事用の例:

    $env:TORCHINDUCTOR_CACHE_DIR="C:\llm-cache\i"
    $env:TRITON_CACHE_DIR="C:\llm-cache\t"
    $env:UNSLOTH_COMPILE_LOCATION="C:\llm-cache\u"

    実際に使用したパスは別のもの。

    要点は、

    Windowsで深いproject path配下にcompiler cacheを置かない

    ことだった。


    1 optimizer stepまで通った

    最終的に、

    MODEL_LOAD          PASSED
    ADAPTER_INJECTION   PASSED
    FORWARD             PASSED
    BACKWARD            PASSED
    GRADIENT_VALIDATION PASSED
    OPTIMIZER_STEP      PASSED
    ADAPTER_SAVE        PASSED
    RELEASE             PASSED
    FRESH_RELOAD        PASSED
    ADAPTER_RELOAD      PASSED

    まで通った。

    これで、

    このWindows + RTX 4090 + pinned stackでは、20B modelに対する量子化LoRAの実optimizer stepが実行できる

    ことを確認できた。


    学習できたのに推論でCUDA OOM

    次にadapterを読み込んで、代表的な長めの入力で推論した。

    すると、

    torch.OutOfMemoryError
    
    Tried to allocate 16.50 GiB

    で落ちた。

    状態としては、

    TRAINING  : SUCCESS
    SAVE      : SUCCESS
    RELOAD    : SUCCESS
    INFERENCE : CUDA OOM

    だった。

    最初は、

    max_new_tokensが多すぎる?

    と思った。

    しかしtraceを見ると、

    generate()
    ↓
    GptOssModel
    ↓
    self attention
    ↓
    softmax
    ↓
    CUDA OOM

    となっていた。

    生成後半ではなく、

    長い入力を処理するprefill段階

    で巨大なメモリ確保が発生していた。

    そのため、

    max_new_tokensを減らす

    だけで解決するタイプではなさそうだった。


    Unslothでの推論を追うのをやめた

    ここで目的を整理した。

    自分がやりたいのは、

    Unslothで推論すること

    ではない。

    Unslothは学習のために使っている。

    本来のローカル推論runtimeはOllama。

    それなら、

    Unsloth長文推論を無理に成立させる

    より、

    保存できたLoRA adapterをOllamaへ持っていく

    方が自然。

    ここから作業内容が、

    training debugging

    から、

    model deployment

    に変わった。


    PEFT LoRAをGGUFへ変換する

    学習後にできるのはPEFT形式のadapter。

    概ね、

    adapter_config.json
    adapter_model.safetensors

    というもの。

    Ollama側で使いたいのはGGUF。

    そこで、

    PEFT LoRA
    ↓
    LoRA GGUF

    への変換を試した。

    使ったのはllama.cppの、

    convert_lora_to_gguf.py

    失敗その1:outtype自動判定

    最初はdtypeを自動判定させた。

    匿名化した例:

    python .\llama.cpp\convert_lora_to_gguf.py `
      ".\output\adapter" `
      --base-model-id "openai/gpt-oss-20b" `
      --outfile ".\output\adapter.gguf"

    すると、

    AttributeError:
    LoraTorchTensor has no attribute dim

    で失敗。

    adapter tensorを確認するとF32だった。

    そこで自動判定をやめ、

    --outtype f32

    を明示した。


    失敗その2:学習用4bit modelをbaseとして渡した

    次に、

    学習に使った4bit modelをそのままbaseに指定すればよいのでは?

    と考えた。

    イメージ:

    python .\llama.cpp\convert_lora_to_gguf.py `
      ".\output\adapter" `
      --base ".\models\gpt-oss-20b-bnb4" `
      --outtype f32 `
      --outfile ".\output\adapter.gguf"

    しかし、

    NotImplementedError:
    Quant method is not yet supported: 'bitsandbytes'

    となった。

    ここで分かったのは、

    LoRA tensorのshapeや名前が壊れているわけではない

    ということ。

    converterがbitsandbytes量子化済みbase weightを処理しようとして失敗していた。


    修正:base weightではなくmodel configを使う

    必要なのはarchitectureやtensor mapping情報。

    量子化済みbase weightそのものではなかった。

    そこで、

    --base

    でローカル4bit modelを渡すのをやめ、

    --base-model-id openai/gpt-oss-20b

    を使った。

    修正後:

    python .\llama.cpp\convert_lora_to_gguf.py `
      ".\output\adapter" `
      --base-model-id "openai/gpt-oss-20b" `
      --outtype f32 `
      --outfile ".\output\adapter.gguf"

    これで変換成功。

    生成されたLoRA GGUFは約16MB。


    いきなり12GB級modelをマージしない

    adapter.gguf ができたので、すぐにベースGGUFへ永久マージすることもできる。

    ただし、もしadapter側に問題があれば、大きなmodel fileを作り直すだけ無駄になる。

    そこでまず、

    runtime上でLoRAを後付けして動くか

    を確認することにした。


    Ollama内部blobをllama.cppへ渡して失敗

    すでにOllamaには gpt-oss:20b がある。

    そのmodel blobをそのままllama.cppから使えないか試した。

    すると、

    unknown model architecture: 'gptoss'

    となった。

    これはLoRAのshape errorではない。

    Ollama内部のGPT-OSS表現と、upstream llama.cppが直接期待する標準GGUF表現が違っていた。

    つまり、

    Ollamaで読めるGGUF
    =
    そのままupstream llama.cppでも読めるGGUF

    ではなかった。

    そこで標準的なllama.cpp互換GGUFを別途用意した。

    ggml-org/gpt-oss-20b-GGUF
    gpt-oss-20b-MXFP4.gguf

    標準GGUF + LoRA GGUFで確認

    匿名化した例:

    .\llama-cli.exe `
      -m ".\models\gpt-oss-20b-MXFP4.gguf" `
      --lora ".\output\adapter.gguf" `
      -p "This is a deterministic test prompt." `
      --temp 0 `
      --seed 1

    これで、

    base model load
    LoRA load
    tensor mapping
    dimension check
    generation

    まで成功した。


    「ロードできた」だけでは足りない

    LoRAを指定して生成できても、

    adapterが実際には何も影響していない

    可能性は残る。

    そこで、

    同一prompt
    同一temperature
    同一seed

    で、

    Base
    Base + LoRA

    を比較した。

    1 optimizer stepしか学習していないため、scale 1.0では見た目上同じ出力になるケースもあった。

    そこで診断目的だけでscaleを大きくした。

    .\llama-cli.exe `
      -m ".\models\gpt-oss-20b-MXFP4.gguf" `
      --lora-scaled ".\output\adapter.gguf:8" `
      -p "This is a deterministic test prompt." `
      --temp 0 `
      --seed 1

    scaleを8まで上げると出力に変化が出た。

    これで、

    loaderに受理されているだけではなく、adapterが実際にmodel outputへ影響している

    ことを確認できた。

    8 はあくまで診断用。

    productionで使う値ではない。


    LoRAをベースGGUFへ永久マージ

    adapter効果まで確認できたので、永久マージ。

    使ったのは、

    llama-export-lora

    匿名化例:

    .\llama-export-lora.exe `
      -m ".\models\gpt-oss-20b-MXFP4.gguf" `
      --lora ".\output\adapter.gguf" `
      -o ".\output\gpt-oss-20b-finetuned.gguf"

    merge scaleは1.0。

    生成されたmerged GGUFは約12.7GB。

    その後、

    .\llama-cli.exe `
      -m ".\output\gpt-oss-20b-finetuned.gguf" `
      -p "This is a deterministic test prompt." `
      --temp 0 `
      --seed 1

    として、LoRAを別途指定せず単体generationできることも確認した。

    これで、

    PEFT LoRA
    ↓
    LoRA GGUF
    ↓
    runtime load
    ↓
    adapter effect確認
    ↓
    permanent merge
    ↓
    standalone merged GGUF

    までつながった。


    Ollamaへimport

    次はOllama。

    最小構成ならModelfileは、

    FROM ./gpt-oss-20b-finetuned.gguf

    として、

    ollama create my-gpt-oss-ft:20b -f .\Modelfile

    確認:

    ollama show my-gpt-oss-ft:20b

    実行:

    ollama run my-gpt-oss-ft:20b

    model loadもgenerationも成功した。

    これで終わりかと思った。


    Harmonyの制御tokenがそのまま出てきた

    出力を見ると、

    <|channel|>analysis<|message|>...
    <|start|>assistant<|channel|>final<|message|>...

    のような制御tokenがそのまま表示された。

    最初は、

    mergeでweightsを壊した?

    と思った。

    しかしllama.cppでは正常にgenerationできている。

    そこでstockの gpt-oss:20b と、新しく作ったmodelのModelfileを比較した。

    ollama show gpt-oss:20b --modelfile
    ollama show my-gpt-oss-ft:20b --modelfile

    すると、違いはweightsだけではなかった。

    stock modelにはGPT-OSS用の、

    TEMPLATE
    PARSER
    RENDERER
    PARAMETER

    などの設定が入っている。

    新しく作ったmodelはgeneric template。

    つまり、

    weightsは動いている。

    runtime contractを失っていた。


    修正:元のModelfileを引き継いでFROMだけ変える

    stock modelのModelfileをベースにした。

    概念的には、

    ollama show gpt-oss:20b --modelfile

    で設定を取得。

    そのうち、

    FROM ...

    だけを、

    FROM ./gpt-oss-20b-finetuned.gguf

    へ変更。

    GPT-OSS固有のtemplate / parser / renderer等は維持した。

    その状態で、

    ollama create my-gpt-oss-ft-harmony:20b `
      -f .\Modelfile.finetuned

    実行。

    ollama run my-gpt-oss-ft-harmony:20b

    今度はrawなHarmony制御tokenが表示されず、stock modelと同じ形で利用できた。


    「モデル」はweightsだけではなかった

    今回かなり実感したところ。

    始める前は、

    Fine-tuning
    =
    weightsを書き換えること

    という認識が強かった。

    実際のdeploymentでは、

    weights
    tokenizer
    chat template
    generation prefix
    parser
    renderer
    runtime parameters

    まで含めて動作が決まる。

    特にreasoning modelでは、

    weightsは正しいのにruntime設定が違うから出力がおかしい

    ということが普通に起きる。


    最後に既存アプリ相当の経路から呼ぶ

    Ollama単体で動いたので、最後に実際のアプリケーション相当の経路へ接続した。

    実コマンドにはプロジェクト固有名やデータ識別子が含まれるため、記事用には一般化する。

    python evaluate.py `
      --model "my-gpt-oss-ft-harmony:20b" `
      --case ".\evaluation\holdout-case.json" `
      --diagnostic-only

    同じHOLDOUT入力を、

    Base gpt-oss:20b

    と、

    1-step Fine-tuned gpt-oss:20b

    の両方に渡した。


    Base vs 1-step Fine-tuned

    ある一致条件の比較では、

    Base model
    
    input tokens  : 8,784
    output tokens : 3,207
    latency       : 20.750 sec

    対して、

    1-step Fine-tuned model
    
    input tokens  : 8,784
    output tokens : 2,929
    latency       : 20.356 sec

    だった。

    約0.4秒だけtuned側が速い。

    ただし、

    Fine-tuningで高速化した

    とは考えていない。

    測定回数が少なく、差も小さい。

    自分としては、

    速度はほぼ同じ

    という扱い。


    品質はむしろ悪化した

    重要なのはこっち。

    1-step tuned modelは、

    structured output
    schema validation
    Ollama integration
    application integration

    すべて正常だった。

    しかし内容に矛盾があった。

    一般化すると、

    項目A : 増加
    項目B : 増加
    項目C : 変化なし

    と自分で判定しているのに、summaryでは、

    すべて増加した

    と書いた。

    同じ入力に対するbase modelは、

    項目Cを除いて増加した

    と正しくまとめていた。

    つまり、このHOLDOUTケースでは、

    1-step Fine-tuned版の方が悪かった。


    でもこの結果は別に失敗ではない

    今回の1-step checkpointは、品質改善のための本学習ではない。

    確認したかったのは、

    教師データ
    ↓
    training
    ↓
    adapter
    ↓
    GGUF
    ↓
    runtime validation
    ↓
    merge
    ↓
    Ollama
    ↓
    application
    ↓
    Baseとの同条件比較

    が最後まで成立すること。

    そこは確認できた。

    さらに、

    tuned modelがbaseより悪化した場合、それを評価で検出できる

    ことも確認できた。

    これはむしろ重要だった。


    「学習できた」と「良くなった」は別

    今回の作業で一番整理されたのはこれかもしれない。

    training commandが終了した
    ≠
    品質が改善した

    同様に、

    adapterをloaderが受理した
    ≠
    adapterがmodelへ影響している

    さらに、

    Ollamaでgenerationできた
    ≠
    stock modelと同じruntime contractで動いている

    さらに、

    同じschemaを返した
    ≠
    中身が正しい

    全部別の話。

    今回だけでも、

    Training feasibility
    
    Masking correctness
    
    Adapter save / reload
    
    GGUF conversion
    
    LoRA runtime load
    
    Adapter effect
    
    Permanent merge
    
    Standalone merged-model load
    
    Ollama import
    
    Prompt/output runtime contract
    
    Application integration
    
    HOLDOUT quality evaluation

    くらいに分かれた。

    「Fine-tuning」という一言で呼んでいたけれど、かなり広かった。


    Chain of Thoughtは学習していない

    今回SFTに使うデータは概念的に、

    system prompt
    user input
    assistant final output

    だけ。

    隠れたreasoning traceを復元して教師データにしたりはしていない。

    maskも、

    system tokens        → -100
    user tokens          → -100
    generation prefix    → -100
    assistant completion → supervised

    という形。

    assistantの最終回答だけをloss対象にしている。

    ここもgenericなresponse-only trainingをそのまま使うのではなく、

    実際のchat templateとtoken列を確認する

    のが大事だった。


    現時点でのモデルの使い分け

    2026年9月時点では、自分の環境だと、

    品質重視の教師・reference
            ↓
    Qwen3.8 27B
    
    速度重視のdeployment候補
            ↓
    gpt-oss 20B
    
    その中間を狙う実験
            ↓
    gpt-oss 20B + LoRA

    という形で考えている。

    ほかのモデルについても、

    Qwen3.5 9B
    Qwen3 14B
    Gemma 4 12B
    Gemma 4 26B
    Gemma 4 31B QAT

    を試したが、今回の用途・環境では、

    • finish reason

    • timeout

    • latency

    • instruction adherence

    などの理由で最終候補には残らなかった。

    ここは重要で、

    モデルサイズや公開ベンチマークだけでは、自分の用途に合うか分からなかった。

    実際の入力を、自分が使うruntimeで流してみるのが一番早かった。


    次にやること

    次は1件・1 stepのsmokeではなく、教師データを数十件規模まで増やしてpilot trainingする予定。

    見る項目は、

    狙った種類のミスが減るか
    
    元々できていたことを壊さないか
    
    HOLDOUTでも改善するか
    
    structured output成功率が落ちないか
    
    latencyを維持できるか
    
    長いcontextでも安定するか

    あたり。

    特に、

    TRAINでは改善
    HOLDOUTでは悪化

    は普通にあり得ると思っている。

    なのでbase modelとの比較は続ける。


    今回分かったこと

    始める前は、

    データを作る
    ↓
    trainする
    ↓
    賢くなる

    くらいのイメージだった。

    実際は、

    複数モデルを比較する
    
    ↓
    何を改善したいか決める
    
    ↓
    教師データを作る
    
    ↓
    教師データを疑う
    
    ↓
    評価データを隔離する
    
    ↓
    token maskingを確認する
    
    ↓
    GPUでforwardする
    
    ↓
    backwardで落ちる
    
    ↓
    version差分で落ちる
    
    ↓
    Windowsのcache pathで落ちる
    
    ↓
    optimizer stepを通す
    
    ↓
    adapterを保存する
    
    ↓
    推論したらOOMする
    
    ↓
    目的を思い出してUnsloth推論を追うのをやめる
    
    ↓
    LoRAをGGUFに変換する
    
    ↓
    converterで落ちる
    
    ↓
    base modelの指定方法を変える
    
    ↓
    llama.cppでadapterを検証する
    
    ↓
    本当にadapterが効いているか確認する
    
    ↓
    巨大なGGUFへマージする
    
    ↓
    Ollamaへ入れる
    
    ↓
    chat templateでハマる
    
    ↓
    stock runtime contractを復元する
    
    ↓
    実アプリ相当の条件でbaseと比較する
    
    ↓
    Fine-tuned版が普通に退化する

    だった。

    思っていた以上に、

    機械学習というよりソフトウェアエンジニアリングだった。


    最後に

    今回一番の収穫は、

    ファインチューニングしたモデルができたこと

    ではない気がしている。

    それより、

    ファインチューニングしたモデルを、元モデルと同じ条件で評価できるところまでパイプラインを作れたこと

    の方が大きい。

    学習しただけでは、本当に良くなったか分からない。

    デプロイできただけでも分からない。

    同じHOLDOUTをbaseとtunedへ渡して、

    良くなった
    変わらない
    悪くなった

    を見られて、ようやく実験できる。

    そして少なくとも自分の環境では、

    RTX 4090一枚で20Bクラスの量子化LoRA学習を実行し、PEFT adapterをGGUFへ変換し、マージしてOllamaから動かすところまではできた。

    ただし、

    できることと、やる価値があることは別。

    これから教師データを増やしてみて、本当に狙ったミスを減らせるのかを見ていく。

    うまくいくかもしれないし、結局base modelをそのまま使う方が良いという結論になるかもしれない。

    それも含めて、しばらく試してみようと思う。

    あなたへのおすすめ