LoRAの仕組み｜numpyで自作して全パラメータ学習と忘却を実測

この記事で実際に動かしたもの：numpy だけで書いた文字単位の小さな Transformer（2層・幅96・381,888パラメータ）を、手書きの逆伝播で RJC の技術記事の本文から事前学習し、別の分野（AI・データ系の記事に載っているコードと実行結果）に合わせ直すときの全パラメータ学習と LoRA を、同じ条件で学習・計測しました。勾配はすべて数値微分と照合しています。

大きな言語モデルを自社の文書や特定の作業に合わせたいとき、全部の重みを学習し直すと、重みと同じ数の勾配と最適化の状態をメモリに置くことになり、学習後のモデルもまるごと1つ分の容量になります。LoRA は「重みそのものは動かさず、差分だけを小さな形で持つ」ことで、この重さを減らします。

flowchart TD
    X[入力 x] --> W[事前学習の重み W0<br>凍結・d×k]
    X --> A[A を学習<br>k次元→r次元]
    A --> B[B を学習・初期値0<br>r次元→d次元]
    B --> S[α/r 倍]
    W --> P((足す))
    S --> P
    P --> H[出力 h]

よく調べられることの答えを先にまとめます。

確認環境：Ubuntu 24.04.5 LTS（Intel Xeon 2.10GHz・2コア・メモリ8GB、ほかの作業と同時に動いている共有のマシン）の上で、Python 3.13.18 と numpy 2.5.3（OpenBLAS 0.3.34、スレッド数1に固定）だけを使いました。PyTorch・PEFT などの深層学習ライブラリは使っていません。言語モデルはデコーダのみの Transformer（Pre-LN・学習する位置埋め込み・ReLU の MLP・バイアスなしの線形層）で、順伝播・逆伝播・Adam をすべて自分で書き、数値微分で勾配を確かめました。データは RJC の技術記事247本の本文を読み取り専用で使い、分野A（AI 以外の記事217本の日本語の文章、コードは除く）で事前学習し、分野B（AI・データ系の記事30本に載っているコードと実行結果）に合わせ直しました。学習は事前学習480ステップ（79.9秒）と、合わせ直し13通り（合計143.4秒）で、合計223.3秒です。学習済みの公開モデルの重みや LLM の API には接続していないため、文章の質については主張しません。測ったのは損失・パラメータ数・時間・容量です。LoRA の式と主張は Hu et al.（2021）、QLoRA は Dettmers et al.（2023）の原論文、PEFT の引数は Hugging Face の公式ドキュメントで確かめました。図は mermaid で描画を確かめています（確認日 2026年11月4日）。

LoRAとは（凍結した重みに低ランクの差分を足す）

この節では、LoRA が何を学習し、何を学習しないのか、ほかの方法と比べてどこが違うのかが分かります。

LoRA は、事前学習した重み行列 W0 を凍結し、学習で生じる変化 ΔW を「ランク r の行列」に制限して、ΔW = BA の B と A だけを学習する方法です。Hu et al. の原論文（2021）は、Transformer の重み行列に LoRA を入れ、GPT-3 175B で Adam による全パラメータ学習と比べて、学習するパラメータを1万分の1、GPU のメモリを3分の1にできたと報告しています。

原論文は、ほかの方法の弱点として、アダプタ層（層の間に小さな層を差し込む方法）は推論のときに追加の計算が入り遅延が増えること、プレフィックスチューニング（入力の前に学習する埋め込みを足す方法）は最適化が難しく、使える系列長が減ることを挙げています。LoRA は重みに足し込めるので、推論の遅延が増えないことを利点にしています。

なお、LoRA は「ファインチューニングの1つのやり方」です。社内の文書を答えに使うだけなら、検索して文脈に入れる RAG で済む場面も多く、どちらを選ぶかは関連記事「RAGとファインチューニングの違いと使い分け判断基準の早見表」で扱っています。この記事は、LoRA そのものの仕組みを自作して確かめることに絞ります。

LoRAの式と行列の形・学習するパラメータ数

この節では、LoRA の式の各記号と行列の形、ランクと対象の層から学習するパラメータ数を計算する方法が分かります。

原論文の式は、入力を列ベクトル x として次の形です。

h = W0 x + ΔW x = W0 x + B A x
  W0 : d × k   （凍結）
  B  : d × r   （学習。初期値 0）
  A  : r × k   （学習。初期値はランダムなガウス分布）
  r  : min(d, k) よりずっと小さい
さらに ΔW x を α / r 倍する（α は定数）

実装では入力を行ベクトル（バッチ×次元）で持つことが多いので、手元のコードでは y = xW0 + (α/r)·(xA)B と書き、A を（入力次元×r）、B を（r×出力次元）の形にしました。転置しているだけで、A がランダム・B が0という役割は原論文と同じです。

学習するパラメータ数は、1つの行列あたり r×(d_in + d_out) です。全パラメータ学習の d_in×d_out と比べると、正方行列（d×d）なら 2r/d の割合になります。手元のモデル（幅96・2層）と、幅4096・32層の大きなモデルで計算すると次のとおりです。

手元のモデルは語彙の埋め込みと出力層の割合が大きい（合わせて約15万パラメータ）ため、割合が大きめに出ます。大きなモデルほど、LoRA の割合は小さくなります。

numpyで小さな言語モデルとLoRAを自作する（実験の作り方）

この節では、実験に使ったモデル・データ・学習の条件と、LoRA を線形層に組み込むコードが分かります。

最初は「AI の記事の文章」と「それ以外の記事の文章」の2分野で試しましたが、事前学習後の損失の差が0.10しかなく、合わせ直しても忘却がほとんど見えませんでした。文字単位の小さなモデルにとっては、どちらも同じ日本語の技術文書だからです。そこで分野Bを、同じ AI・データ系の記事に載っているコードと実行結果にしました。実際の LoRA でも、日本語の文書のモデルをコードに合わせる、のように分野の差が大きいほど、ここで測るような差がはっきり出ます。

LoRA を組み込むのは線形層の順伝播と逆伝播だけです。手元のコード（lm.py）の該当部分を抜き出します。

def lin(self, x, name, cache):          # x: (N, d_in)
    y = x @ self.p[name]                 # 凍結した W0
    if name in self.lora and not self.merged:
        A, B = self.lora[name]['A'], self.lora[name]['B']
        xa = x @ A                       # (N, r)
        y = y + self.scale[name] * (xa @ B)   # scale = alpha / r
        cache[name + '#xa'] = xa
    cache[name + '#x'] = x
    return y

def lin_backward(self, dy, name, cache, G, train_base):
    x = cache[name + '#x']
    dx = dy @ self.p[name].T
    if train_base:                       # 全パラメータ学習のときだけ dW0 を計算する
        G[name] = x.T @ dy
    if name in self.lora and not self.merged:
        A, B, s = self.lora[name]['A'], self.lora[name]['B'], self.scale[name]
        dyB = dy @ B.T                   # (N, r)
        G[name + '.B'] = s * cache[name + '#xa'].T @ dy
        G[name + '.A'] = s * x.T @ dyB
        dx = dx + s * dyB @ A.T
    return dx

ポイントは2つです。1つ目は、凍結した W0 の勾配 x.T @ dy を計算しないこと。2つ目は、入力側への勾配 dx は LoRA でも全部計算すること。前の層の LoRA を学習するには、後ろの層から勾配を流す必要があるからです。この2点が、後で見る「1ステップの時間はあまり減らない」理由になります。

numpy の配列の扱いの基本は関連記事「ニューラルネットワークとは｜仕組み・学習・AttentionをNumPyで実演」で扱っています。

逆伝播を自作して数値微分で勾配を確かめる

この節では、手書きの逆伝播が正しいことを、数値微分（中心差分）と照合して確かめる方法と結果が分かります。

逆伝播を手で書いたら、学習を回す前に、勾配を数値微分と比べます。パラメータを1つだけ ±ε（ε=10⁻⁶）動かして損失の差から傾きを出し、逆伝播の値との相対誤差 |a−n| / (|a|+|n|) を見ます。float32 では丸めの誤差が大きいので、小さなモデル（語彙17・幅8・2層・2ヘッド・文脈6）を float64 で作って調べました。LoRA の B は0のままだと A の勾配が0になって比べられないので、検査のときだけ B にも値を入れています。

$ OPENBLAS_NUM_THREADS=1 python3 gradcheck.py
parameter     shape checked   max rel err
E           (17, 8)      12      1.06e-08
P            (6, 8)      12      7.33e-08
0.Wq         (8, 8)      12      1.40e-08
0.Wk         (8, 8)      12      2.78e-08
0.Wv         (8, 8)      12      8.03e-09
0.Wo         (8, 8)      12      3.89e-09
0.W1        (8, 32)      12      2.12e-07
1.W2        (32, 8)      12      2.21e-08
1.ln2_g        (8,)       8      8.08e-08
lnf_b          (8,)       8      1.55e-09
Wout        (8, 17)      12      5.22e-08
0.Wq.A       (8, 3)      12      2.91e-08
0.Wq.B       (3, 8)      12      5.19e-08
0.Wv.A       (8, 3)      12      7.89e-09
0.Wv.B       (3, 8)      12      6.24e-08
1.W1.A       (8, 3)      12      1.97e-08
1.W1.B      (3, 32)      12      7.01e-09
Wout.A       (8, 3)      12      5.03e-08
Wout.B      (3, 17)      12      4.39e-08
worst 2.12e-07

19種類のパラメータすべてで相対誤差は2.12×10⁻⁷以下でした。逆に、わざと間違えると数値ははっきり変わります。A の勾配で α/r（この検査では 6/3=2）を掛け忘れると、相対誤差は0.333になりました（|2−1|/(2+1) と同じ値）。

scale 2.0
analytic(correct)         -1.6591123193446883e-05
numeric                   -1.659117287999834e-05
analytic(scale forgotten) -8.295561596723441e-06   rel err 0.3333346643383179

Bを0で初期化する理由（初期化3通りの実測）

この節では、B を0・A をランダムにする理由と、ほかの初期化にしたときに何が起きるかが分かります。

B を0にすると、学習の最初で ΔW = BA = 0 になり、LoRA を入れたモデルの出力は元のモデルと完全に一致します。原論文も「A はランダムなガウス分布、B は0で初期化し、学習の最初で ΔW = BA は0」と書いています。PEFT の公式ドキュメントでも、既定（init_lora_weights=True）は B を0にし、A は Kaiming-uniform で初期化すると説明しています。

では、A も0にしたらどうなるか、両方ランダムにしたらどうなるかを、同じ事前学習済みモデル（q・v、r=8、α=8、学習率3×10⁻³）で30ステップずつ学習して比べました。

勾配の式を見ると理由が分かります。dB = s·(xA)ᵀ·dy なので、A がランダムなら B=0 でも dB は0になりません。一方 dA = s·xᵀ·(dy·Bᵀ) なので、B=0 の最初の1ステップでは dA=0 です。最初は B だけが動き、B が0でなくなってから A も動き出します。両方0だと dA も dB も0のままで、何ステップ学習しても変わりませんでした（小さなモデルで dA・dB の最大値が両方0.0）。

両方ランダムにすると、学習を始める前から事前学習の性能を壊してしまいます。手元では分野Aの損失が3.41から3.99に上がり、30ステップ後も原論文の初期化より分野Aが0.21悪いままでした。

全パラメータ学習とLoRAの比較（損失・忘却・学習時間）

この節では、同じ事前学習済みモデルを分野Bに合わせ直したとき、全パラメータ学習と LoRA で、覚える量・忘れる量・時間・容量がどう違うかが分かります。

全パラメータ学習は学習率を3通り、LoRA は q・v（r=8）と全線形層（r=8）を、すべて120ステップで学習しました。最適化は Adam（重み減衰なし）、LoRA の学習率は3×10⁻³、α=8 です。

表だけを見ると「LoRA は忘れにくい」ように見えます。LoRA の q・v は分野Aの悪化が+0.190で、全パラメータ学習（学習率1×10⁻³）の+0.495より小さいからです。しかし、全パラメータ学習の学習率を1×10⁻⁴に下げると、忘却は LoRA とほぼ同じ+0.172で、分野Bは LoRA の2倍（−0.356）下がりました。この小さな実験では、LoRA は「同じだけ覚えて忘れにくい」のではなく、「覚える量も忘れる量も小さい」という結果でした。

理由の1つは、LoRA が触れない部分にあります。分野Bはコードなので、出てくる文字の頻度そのものが分野Aと違います。全パラメータ学習は出力層と埋め込みも動かせますが、q・v の LoRA は注意の計算しか変えられません。対象を全線形層に広げると分野Bは−0.267まで下がり、そのぶん忘却も+0.284に増えました。「どれだけ変えられるか」と「どれだけ壊すか」が一緒に動いています。

1ステップ（順伝播・逆伝播・Adam）の時間は、学習の途中の記録では共有のマシンの負荷で74〜123msとぶれたため、別に交互に25回ずつ測りました。

$ OPENBLAS_NUM_THREADS=1 python3 steptime.py
full              79.7 ms/step  (median of 22)
qv_r8             66.8 ms/step  (median of 22)
qv_r32            69.3 ms/step  (median of 22)
all_r8            75.0 ms/step  (median of 22)
qv_r8(dW too)     79.6 ms/step  (median of 22)

LoRA（q・v、r=8）は全パラメータ学習より16％速いだけでした。最後の行は、同じ LoRA で凍結した重みの勾配 x.T @ dy も（捨てるのに）計算した場合で、全パラメータ学習と同じ79.6msに戻ります。LoRA で減る計算は「凍結した重みの勾配」と「その重みの Adam の更新」で、順伝播と、入力側へ流す勾配の計算は減りません。原論文も GPT-3 175B で学習の処理量が25％上がったと報告しており、何十倍も速くなるわけではありません。

LoRAのランクrの決め方（1〜32の実測と特異値）

この節では、ランク r を変えたときに損失と忘却がどう変わるか、低いランクで済む理由を ΔW の特異値で確かめた結果が分かります。

q・v に入れる LoRA の r を1〜32で変え、α=8・学習率3×10⁻³・120ステップで学習しました。ΔW の大きさは、0層目の Wq の (α/r)·AB のフロベニウスノルムです。

パラメータが32倍になっても、分野Bの損失は0.04しか変わりませんでした。同じ6,144前後のパラメータでも、q・v の r=8 より、全線形層に入れた r=8（27,648）の方がずっと効いています（3.557 と 3.468）。原論文の Table 6 も、Wq と Wv に入れる場合は r=1 で足りたと報告し、Wq だけに入れる場合はもっと大きい r が要ったとしています。ただし原論文は、事前学習と違う言語の作業のように、小さい r ではうまくいかない作業もありうると注意しています。

低いランクで済む理由を、全パラメータ学習で生じた ΔW の特異値で確かめました。特異値の2乗の合計のうち、上位 k 個が占める割合です（96×96 の行列なので最大96個）。

$ OPENBLAS_NUM_THREADS=1 python3 svd.py
energy % in top-k singular values (k=1,4,8,16 of 96)
  ΔW full_1e-3  0.Wq: [19.5, 58.9, 79.7, 93.4]
  ΔW full_1e-3  0.Wv: [12.2, 40.5, 60.7, 82.6]
  ΔW full_3e-4  0.Wq: [21.0, 61.3, 82.6, 94.9]
  ΔW full_3e-4  0.Wv: [18.0, 48.0, 69.3, 88.6]
  ΔW full_1e-4  0.Wq: [23.2, 66.2, 86.8, 96.4]
  ΔW full_1e-4  0.Wv: [25.3, 58.7, 79.8, 93.5]
  random gaussian 96x96 : [3.8, 14.5, 26.9, 46.7]
  W0 itself 0.Wq        : [15.5, 45.7, 67.3, 81.5]

全部の重みを自由に動かした場合でも、Wq の変化の8割前後は上位8方向に集まっていました。ランダムな行列なら27％です。学習で必要な変化がもともと少数の方向に偏っているので、最初からランクを制限しても失うものが小さい、というのが LoRA の前提で、手元のモデルでもその傾向が見えました。

原論文の7.3節は、ΔW が W0 のどの方向を強めたかを ||ΔW|| ÷ ||Uᵀ W0 V||（U・V は ΔW の上位 r 個の特異ベクトル）で調べ、r=4 で約21.5倍、r=64 で約2倍と報告しています。手元で同じ計算をすると、r=8 で4.0倍、r=32 で1.5倍で、r が小さいほど大きいという向きは同じでした。r=8 の ||Uᵀ W0 V|| は1.021で、ランダムな方向の0.425より大きく、ΔW は W0 にもともとある方向と関係していました。ただし r=1 では0.032とランダムな方向（0.077）より小さく、1方向だけでは比べ方として安定しませんでした。

手元の結果と原論文・公式の既定値から、設定を決める順番をまとめます。

1. 1q・v、r=8、α=8 で始める原論文の主な対象の層と、PEFT の既定値（r=8・lora_alpha=8）
2. 2新しい分野と元の分野の両方で評価する新しい分野の損失だけでは忘却が見えない
3. 3足りなければ対象を全線形層に広げる手元では分野Bの損失が0.089下がった
4. 4学習率とステップ数で「覚える・忘れる」を調整するα を固定しておけば、調整するのは学習率だけになる
5. 5最後に r を上げて比べる手元では r=1〜32 の差が0.040

alpha（lora_alpha）とα/rのスケールの意味

この節では、α と α/r のスケールが何を調整しているのか、α を固定したまま r を変えた場合と α を r に比例させた場合の違いが分かります。

LoRA は ΔWx を α/r 倍します。原論文は、Adam で学習するなら α の調整は学習率の調整とほぼ同じで、α は最初に試した r と同じ値にして調整しなかったと書いています。α/r で割る理由は、r を変えたときに学習率などを調整し直す手間を減らすためです。

Adam は各パラメータを学習率くらいずつ動かすので、r が大きいほど BA の和の項が増え、ΔW が大きくなりがちです。α を固定して r で割ると、これが打ち消されます。r=2 と r=32 で、α を8に固定した場合と、α/r を4にそろえた場合を比べました。

α を8に固定すると、r を16倍にしても ΔW の大きさは5.29から3.77とほぼ同じ範囲に収まり、忘却も+0.19前後で変わりませんでした。α/r を4にそろえる（α を r に比例させる）と、r=32 の ΔW は10.18まで大きくなり、忘却は+0.392と2倍になりました。α を r に合わせて大きくするのは、学習率を上げるのとほぼ同じで、r を変えたら学習率も見直すことになります。

PEFT の既定値は r=8・lora_alpha=8 で、use_rslora=True にするとスケールが lora_alpha/√r になると公式ドキュメントに書かれています。大きな r を使うときの別のスケールの付け方ですが、この記事では手元の比較を α/r に絞りました。

LoRAを入れる層（q・vだけか全線形層か）

この節では、Transformer のどの線形層に LoRA を入れるかで結果がどう変わるか、論文と公式の既定値と合わせて分かります。

原論文は、注意の重み（Wq・Wk・Wv・Wo）だけに LoRA を入れ、MLP は凍結しました。GPT-3 で学習するパラメータを1,800万に固定した比較では、Wq と Wv の両方に入れるのが全体として最も良く、Wq だけ・Wk だけに全部を使うと明らかに悪かったと報告しています（Table 5）。一方 QLoRA の論文は、大きなモデルで全パラメータ学習の性能に並ぶには、Transformer ブロックの全線形層に LoRA を入れる必要があったとしています。

手元では、全線形層に広げると q・v の r=32（24,576パラメータ）より分野Bがよく下がりました。パラメータを増やすなら、r を上げるより対象の層を広げる方が効いた、という結果です。ただし忘却も大きくなるので、元の分野の性能を保ちたい場合は、評価で確かめながら決めます。

PEFT で同じ設定を書くと次のようになります。この環境では PyTorch を入れていないため動かしておらず、引数は公式ドキュメントで確かめた範囲です。

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=8,                          # 既定値 8
    lora_alpha=8,                 # 既定値 8（スケールは lora_alpha / r）
    target_modules="all-linear",  # 出力層を除く全線形層
    lora_dropout=0.0,             # 既定値 0.0
)
model = get_peft_model(model, config)   # model は事前学習済みのモデル
model.print_trainable_parameters()

Hugging Face のモデルの読み込み方は関連記事「Hugging Face transformers入門｜pipelineとタスク一覧」で扱っています。

マージ後の推論速度（重みに足し込む・外す）

この節では、学習した LoRA を重みに足し込んだとき出力が変わらないこと、推論の速さが元のモデルと同じになること、外して元に戻せることが分かります。

学習が終わったら W = W0 + (α/r)·BA を計算して W0 と置き換えれば、推論は元のモデルと同じ行列の掛け算だけになります。原論文はこれを「全パラメータ学習したモデルと比べて推論の遅延が増えない」利点として挙げ、別の作業に切り替えるときは BA を引いて W0 に戻し、別の B'A' を足せばよいとしています。手元で、学習した q・v（r=8）と全線形層（r=8）のアダプタを足し込み、外しました。

$ OPENBLAS_NUM_THREADS=1 python3 merge.py all_r8
adapter=all_r8 matrices=12 lora_params=27648
max |logits(unmerged) - logits(merged)| = 3.815e-06  (float32)
val loss B: base=3.7351 unmerged=3.4679 merged=3.4679
forward ms (16x64 tokens, median of 40, interleaved): base=17.12 unmerged=21.27 merged=18.06
after unmerge: max |W - W0| = 1.490e-08
max |logits(after unmerge) - logits(base)| = 3.338e-06
adapter.npz bytes 116470 fullmodel.npz bytes 1533614

足し込まずに LoRA の経路を通すと、全線形層では順伝播が24％遅くなりました。足し込んだ後は元のモデルとの差が3〜5％で、3つを交互に40回測った中央値でも共有のマシンの揺れの範囲です。足し込む前後の出力の差は最大3.8×10⁻⁶（float32 の丸めの範囲）で、評価の損失は小数4桁まで同じでした。外した後の重みの差は1.49×10⁻⁸で、元のモデルに戻っています。

PEFT では、merge_and_unload() が足し込んだモデルを返し（その場で書き換えるのではないので戻り値を使う）、あとで外したい場合は merge_adapter() と unmerge_adapter() を使うと公式ドキュメントに書かれています。量子化した土台に足し込む場合は、量子化の誤差が乗るので、足し込んだ後のモデルで評価し直します。量子化した重みの扱いは関連記事「llama.cppとは｜使い方・ビルド・GGUF量子化とllama-server」で扱っています。

LoRAで減るメモリ・減らないメモリとQLoRA

この節では、LoRA で学習のメモリのどこが減り、どこが減らないのか、QLoRA が土台の重みをどう小さくしたのかが、原論文の数字と試算で分かります。

学習のメモリは、おおまかに「重み」「勾配」「最適化の状態（Adam なら1パラメータに2つ）」「逆伝播のために取っておく途中の値（活性）」の4つです。LoRA で減るのは、凍結した重みの勾配と最適化の状態です。重みそのものと活性は減りません。手元のモデル（float32）で数えると次のとおりです。

大きなモデルで試算すると、70億パラメータを float32 の重み・勾配・Adam の2つで持つと1パラメータ16バイトで約112GB（活性を除く）になります。LoRA で土台を bf16（2バイト）で凍結すると土台は約14GBで、q・v・r=8 の LoRA（4,194,304パラメータ）は16バイトずつでも約67MBです。この試算は手元の計算で、実際の量はライブラリの持ち方や活性で変わります。必要な GPU のメモリの見積もり方は関連記事「VRAMとは｜確認方法・必要量の目安とLLMの計算式をPythonで解説」で扱っています。

原論文は GPT-3 175B で、学習の VRAM が1.2TBから350GBに、保存する差分が約350GBから35MBに（r=4、Wq・Wv のみ）なったと報告しています。

QLoRA は、LoRA で残った「土台の重み」を4bitにして小さくする方法です。Dettmers et al. の原論文（2023）は、65B のモデルを48GBの GPU 1枚で、16bit の全パラメータ学習の性能を保ったまま学習できたとし、65B の学習に要るメモリを780GB超から48GB未満にしたと書いています。原論文の要素は次の3つです。

計算は、4bitで持った重みを bf16 に戻してから入力と掛け、そこに bf16 の LoRA の項を足す形です（原論文の式5）。学習するのは LoRA の A・B だけで、4bit の重みは凍結したまま勾配を流します。原論文は、7B の LLaMA で4bit の土台が5,048MB、LoRA のパラメータが26MBなのに対し、LoRA の入力側の勾配（活性）が567MBになったと示し、活性が大きな割合を占めることにも触れています。また、全線形層に LoRA を入れた場合は、r などの LoRA の設定は性能にほとんど影響しなかったと書いています。

QLoRA はこの環境では動かしていません（4bit の量子化と GPU 用のライブラリが要るため）。ここに書いた数字はすべて原論文の報告値です。

よくあるエラー・つまずき（自作するときの原文つき）

この節では、LoRA を自作したり設定したりするときに出たエラーと、結果がおかしいときの原因が分かります。

1つ目・4つ目は、手元でわざと起こして原文と数値を確かめたものです。5つ目は実際に起きたもので、numpy 2 の型の決まり（NumPy のスカラーは型を持ったまま計算に入る）によります。注意のスケール 1/√(ヘッド次元) を np.sqrt で作っていたため、注意の行列から先が float64 で計算されていました。これを直し、3次元の配列の行列積を2次元に並べ直す変更と合わせると、1ステップが0.33秒から0.11秒になりました（幅64・2層での測定）。

LoRAか全パラメータ学習か（判断表）

この節では、LoRA を選ぶか全パラメータ学習を選ぶか、LoRA を使うならどの設定から始めるかを判断する材料が分かります。

LoRA で始めるときに確かめることを並べます。

よくある質問

この節では、LoRA についてよく聞かれることへの答えが分かります。

Q. LoRA は何の略ですか。

Low-Rank Adaptation の略で、日本語では「低ランク適応」と訳されます。原論文の題名は「LoRA: Low-Rank Adaptation of Large Language Models」（Hu et al., 2021）です。

Q. LoRA とファインチューニングは別のものですか。

LoRA はファインチューニングの方法の1つです。全部の重みを学習するのが全パラメータ学習（フルファインチューニング）で、LoRA は重みを凍結して差分だけを学習します。

Q. ランク r はいくつから始めればよいですか。

PEFT の既定値は r=8 です。原論文は q・v なら r=1 で足りた作業があったと報告し、手元でも r=1〜32 の差は小さいものでした。r を上げるより、対象の層と学習率を先に比べる方が効果が見えやすいです。

Q. lora_alpha はどう決めますか。

原論文は α を最初に試した r と同じにして調整していません。α は学習率に近い働きをするので、α を固定して学習率で調整すると、r を変えたときの見直しが少なくなります。

Q. LoRA なら元の性能は落ちませんか。

落ちます。手元では分野Aの損失が+0.16〜+0.28悪くなりました。全パラメータ学習も学習率を下げれば同じくらいの忘却に抑えられ、そのときは新しい分野をより多く覚えました。元の分野の評価も一緒に見ることが要ります。

Q. LoRA で学習は何倍速くなりますか。

手元では1ステップが16％速くなっただけでした。凍結した重みの勾配は省けますが、順伝播と入力側へ流す勾配は省けないからです。原論文の GPT-3 175B の報告も、学習の処理量が25％上がったという数字です。大きく減るのはメモリと保存の容量です。

Q. 推論は遅くなりますか。

足し込めば遅くなりません。足し込まずに LoRA の経路を通すと、手元では全線形層で24％遅くなりました。用途ごとに切り替えたい場合は、足し込まずに使うか、足し込みと取り外しを繰り返します。

Q. QLoRA と LoRA の違いは何ですか。

学習するもの（A・B）は同じで、土台の重みの持ち方が違います。QLoRA は土台を4bit（NF4）で凍結して持ち、計算のときに bf16 に戻します。原論文は65B を48GBの GPU 1枚で学習できたと報告しています。

Q. A をランダムにするのはなぜですか。B をランダムにしてはいけないのですか。

どちらか一方が0なら ΔW=0 で始められます。原論文は B を0、A をランダムにしています。A まで0にすると勾配が0で学習が進まず、両方ランダムにすると始める前から元の性能を壊します（手元で+0.57）。

Q. numpy だけで LoRA を試す意味はありますか。

大きなモデルの性能は分かりませんが、式・初期化・スケール・マージの性質は規模によらず同じなので、ライブラリの設定の意味を数字で確かめられます。手で書いた逆伝播は、数値微分と照合してから使います。

まとめ

この節では、記事全体の要点が分かります。

1. LoRA は h = W0x + (α/r)·BAx の B と A だけを学習する。学習するパラメータは1行列あたり r×(d_in+d_out)。手元の q・v・r=8 で全体の1.6％、アダプタの容量は1.7％だった。
2. B=0・A ランダムで始めると、学習前の出力が元のモデルと完全に一致する。両方0だと勾配が0で動かず、両方ランダムだと元の性能を壊した（+0.57）。
3. 手元の実験では、LoRA は覚える量も忘れる量も小さかった。全パラメータ学習を学習率1×10⁻⁴にすると、LoRA と同じ忘却で分野Bが2倍下がった。元の分野の評価も一緒に見る。
4. r は1〜32で差が小さく、対象の層を広げる方が効いた。全パラメータ学習の ΔW も8割前後が上位8方向に集まっていた。α を r に比例させると学習率を上げたのと同じになる。
5. 足し込めば推論の速さは元と同じで、外せば元に戻る。減るのは勾配・最適化の状態・保存の容量で、1ステップの時間は16％しか減らない。土台まで小さくするのが QLoRA（NF4・Double Quantization・Paged Optimizers）。

参考・出典

この節では、この記事で根拠にした論文と公式ドキュメントが分かります（確認日 2026年11月4日）。

• Edward J. Hu ほか「LoRA: Low-Rank Adaptation of Large Language Models」2021：https://arxiv.org/abs/2106.09685
• Tim Dettmers ほか「QLoRA: Efficient Finetuning of Quantized LLMs」2023：https://arxiv.org/abs/2305.14314
• Hugging Face PEFT 公式ドキュメント「LoRA」（LoraConfig・merge_and_unload）：https://huggingface.co/docs/peft/package_reference/lora
• NumPy 公式ドキュメント：https://numpy.org/doc/stable/

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。