Token Lab検索

TRANSFORMERS / FROM SCRATCH

バイトから訓練済み Transformer へ:言語モデルをゼロから作る

CPU で動く一式:バイト符号化、因果注意力、損失、AdamW、保存、生成。実行可能な Python と限界を解説。

出典とバージョン
この記事の目次

1. 何を作り、言語モデルは何を学ぶのか

「node 107: status is」を補完する運用コンソールを考えます。因果 Transformer を組み立て、全重みをランダム初期化し、独自の合成コーパスで訓練して、チェックポイント保存とバイト生成まで進めます。事前学習重み、外部データセット、モデル API は不要です。PyTorch のテンソル、自動微分、最適化器を使うので、ゼロからとは構造と訓練処理の実装を意味し、GPU カーネルの開発ではありません。

学習から生成までの全体像

小さい画面では横にスクロールするか、原寸の図を開いてください。 原寸図を見る

学習から生成までの全体像. ウィンドウ抽出前に学習用と検証用の文書を分ける。重みを更新するのは学習損失だけで、検証は固定したパラメータを観測する。チェックポイントから生成器へ重みを渡し、生成時は重みを変えずに入力列を伸ばす。付属の CPU 教材に対応する図であり、本番配信基盤ではない。
ウィンドウ抽出前に学習用と検証用の文書を分ける。重みを更新するのは学習損失だけで、検証は固定したパラメータを観測する。チェックポイントから生成器へ重みを渡し、生成時は重みを変えずに入力列を伸ばす。付属の CPU 教材に対応する図であり、本番配信基盤ではない。

言語モデルは、それまでのトークンに条件付けた次トークン分布を推定します。重みは統計的規則を表し、検証済み事実のデータベースではありません。134,912 パラメータのモデルは CPU で動き、大規模モデルの計算骨格を学べますが、汎用アシスタントや指示追従モデルではありません。状態文の構文を学ぶことと、どのノードが忙しいかを知ることは別です。

行列とベクトルの積、確率分布、連鎖律が前提です。行列積は特徴を混合し、softmax はスコアを確率に変換し、連鎖律は誤差を各層へ伝えます。不慣れなら末尾の基礎教材から始めてください。

2. 環境とプロジェクトを準備する

完全なプロジェクトを新しいディレクトリへ展開する。tiny_lm.py はモデル・コーパス・学習・検証を含み、generate.py は隣に置く推論入口である。各関数を再実装するときの参照に使う。本文の抜粋は実コードであり、無条件に連結する独立プログラムではない。

測定環境は Linux、Python 3.12、PyTorch 2.5.1 CPU。仮想環境で固定版を入れる。導入時にソフトウェアを取得するが、学習は内蔵の独自データだけを使い、API や GPU は不要。他の環境では対応する公式 wheel が必要で、数値が多少異なり得る。

出力 tiny.pt は設定・重み・最適化器・ステップ・乱数状態を保存する。まず構成法を学び、次に別プロセスで読む。学習・検証・生成コマンドは末尾の実践で実行する。開始時に事前学習重みは不要。

プロジェクト ZIP を取得

unzip from-zero-lm.zip -d tokenlab-lm
cd tokenlab-lm
python3.12 -m venv .venv
. .venv/bin/activate
python -m pip install torch==2.5.1 --index-url https://download.pytorch.org/whl/cpu

3. 文書から教師データへ

コーパスは 120 文書で、偶数 ID は ready、奇数は busy です。窓を作る前に 0–99 を訓練、100–119 を検証へ分けます。同じ文書の窓が両方へ混ざることを防ぎますが、両集合は同じ構文を持ちます。したがって測るのは狭い合成分布内の補間です。

UTF-8 バイトなら語彙 でトークナイザー訓練が不要です。「Hi」は [72,105]、漢字は通常複数バイトになります。バイト単位と BPE 単位の perplexity は直接比較できません。実データでは利用許諾、機密除去、正規化、分割間重複除去、文書台帳が必要です。--text の時系列 90/10 バイト分割は簡易機能にすぎません。

T+1 バイトから先頭 T を入力、末尾 T を正解にします。[65,66,67,10] なら [65,66,67] → [66,67,10]。バッチ形状は [B,T] です。連結した文書の改行を窓がまたぐため、不適切な場合は文書境界と損失マスクを追加します。

データ契約を実装する

学習ループの前に tiny_lm.py の corpus() と batch() を実装する。corpus() は 2 つのバイト列を返し、batch() は選んだ分割だけを torch.long の ID に変換する。T+1 バイトが必要なので、N バイトの有効な開始位置は 0 から N−T−1 の N−T 個。各サンプルは長さ 32 の入力と正解を返し、16 件なら両方 [16,32] となる。同じ乱数生成器を使い続け、毎回シードを初期化しない。

実装の抜粋 · 実行には完全なプロジェクトを使用

def corpus():
    # Original synthetic sentences. Split document IDs BEFORE window extraction.
    docs = [f'node {i:03d}: status is {"ready" if i % 2 == 0 else "busy"}.\n' for i in range(120)]
    return ''.join(docs[:100]).encode(), ''.join(docs[100:]).encode()

def batch(raw, generator, size=16):
    data=torch.tensor(list(raw), dtype=torch.long)
    t=CFG['context']
    starts=torch.randint(len(data)-t, (size,), generator=generator)
    return torch.stack([data[i:i+t] for i in starts]), torch.stack([data[i+1:i+t+1] for i in starts])

分割は統計上の境界である。--text を使う前にコーパスを整え、各分割を 32 バイト超にする。この実装は文書を連結し、文書単位のマスクや重複除去は行わない。コーパスを増やすと分布だけでなく各文章の抽出頻度も変わる。

1 つの列から 3 つの予測対象へ

小さい画面では横にスクロールするか、原寸の図を開いてください。 原寸図を見る

1 つの列から 3 つの予測対象へ. 教材図では既定の T=32 ではなく T=3 を使う。4 バイトを取り、正解列を 1 つ後ろへずらす。2 番目では A と B から C を予測する。C は正解であり、その予測に使える入力ではない。因果マスクにより未来の情報を漏らさず、3 位置の損失を並列計算できる。
教材図では既定の T=32 ではなく T=3 を使う。4 バイトを取り、正解列を 1 つ後ろへずらす。2 番目では A と B から C を予測する。C は正解であり、その予測に使える入力ではない。因果マスクにより未来の情報を漏らさず、3 位置の損失を並列計算できる。

4. 注意力は因果境界を持つ重み付き読み出し

実装は 列、 位置、幅 、 ヘッドで、各ヘッドは 16 特徴を持つ。Q,K,V を一括射影して各 [B,H,T,16] に分けます。QKᵀ は [B,H,T,T]、√16=4 で割ります。独立で分散 1 の特徴という近似では点積分散が 16 になるためです。学習後の独立性を保証する説明ではありません。

softmax の前に未来のキー j>i を −∞ にし、キー方向で正規化して V を掛けます。縮尺済みスコア [0,log 3] は確率 [0.25,0.75]。値 [2,0] と [0,4] なら結果は [0.5,3]。最初の位置では第 2 キーを隠すので [2,0] です。実装は安定した softmax を使い、バッチ方向では正規化しません。

4 個の [T,16] を [T,64] に結合して射影します。スコアだけで 65,536 個の float32、各層 256 KiB です。密な注意力は T の二乗に比例し、他の射影コストもあります。FlashAttention や KV キャッシュは未実装です。注意力重みは混合係数であって因果説明の証明ではありません。

ヘッドの分割と結合を追う

QKV 投影は [16,32,64] を [16,32,192] に変え、chunk で幅 64 の 3 テンソルに分ける。[16,32,4,16] に reshape し、時間とヘッドの軸を交換して [16,4,32,16] にする。スコアは [16,4,32,32]。最後の軸は key なので softmax(dim=-1) は query ごとの参照位置を正規化する。三角マスクはバッチとヘッドへ broadcast され、保存される buffer だが最適化対象ではない。

実装の抜粋 · 実行には完全なプロジェクトを使用

class Attention(nn.Module):
    def __init__(self, width, heads, context):
        super().__init__()
        assert width % heads == 0
        self.heads, self.dim = heads, width // heads
        self.qkv = nn.Linear(width, 3 * width)
        self.out = nn.Linear(width, width)
        self.register_buffer('mask', torch.ones(context, context, dtype=torch.bool).tril())

    def forward(self, x):
        b, t, c = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q, k, v = [a.view(b, t, self.heads, self.dim).transpose(1, 2) for a in (q, k, v)]
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.dim)
        scores = scores.masked_fill(~self.mask[:t, :t], float('-inf'))
        mixed = scores.softmax(dim=-1) @ v
        return self.out(mixed.transpose(1, 2).contiguous().view(b, t, c))

集約後の [16,4,32,16] を転置し、contiguous にして幅 64 へ結合する。転置を省くと時間と特徴が混ざる。分母はヘッド次元の √16=4 で、モデル幅の √64=8 ではない。softmax 後の単純なゼロ化は確率総和を減らすため、正規化前にマスクする。

因果注意: マスクから加重ベクトルへ

小さい画面では横にスクロールするか、原寸の図を開いてください。 原寸図を見る

因果注意: マスクから加重ベクトルへ. 行は query、列は key の位置で、softmax 前に上三角をマスクする。2 行目の教材スコア [0, ln 3, −∞] は [0.25, 0.75, 0] になる。value が [2,0] と [0,4] なら出力は [0.5,3]。3 番目は寄与しない。これは説明用に選んだ数値で、訓練モデルの測定値ではない。
行は query、列は key の位置で、softmax 前に上三角をマスクする。2 行目の教材スコア [0, ln 3, −∞] は [0.25, 0.75, 0] になる。value が [2,0] と [0,4] なら出力は [0.5,3]。3 番目は寄与しない。これは説明用に選んだ数値で、訓練モデルの測定値ではない。

5. デコーダーの全テンソルを追う

、、、、 とします。[256,64] の埋め込み表から [16,32,64] を得て、学習する位置表 [32,64] をバッチ方向に共有して加算します。位置情報がなければ順序を十分に表現できません。

各 pre-norm ブロックは LayerNorm(X) の注意力出力を残差加算し、その新状態を正規化して前向きネットワークを適用します。各位置で 64→256、GELU、256→64 と変換します。注意力は位置を混ぜ、前向き層は特徴を変換します。残差は深さを通る直接経路を残しますが、最適化を万能にするものではありません。

最終 LayerNorm と独立した [64,256] 射影で logits [16,32,256] を得ます。入出力重みは共有しません。バイアス等込みで 134,912 パラメータ、float32 の重みだけで 539,648 バイトです。勾配、Adam の状態、活性は別途必要です。

LayerNorm は各 token の D 特徴で平均と分散を求め、学習する倍率とバイアスを適用します。他サンプルや未来を混ぜません。GELU は非線形性を加えます。式は列ベクトルで ,D]、,4D]。Python は入力行に転置重みを掛けます。

依存順にデコーダーを組み立てる

Attention、Block、TinyLM の順で実装する。nn.Module が子層を登録するため parameters() と state_dict() は重みを追跡できる。ID は embedding の行番号であり、数値の大小として計算するものではない。位置 embedding が同じバイトの位置を区別する。残差加算には分岐の出力が入力と同じ [B,T,D] である必要がある。2 ブロックの後、線形ヘッドが 64 特徴を 256 の未正規化スコアに変える。

実装の抜粋 · 実行には完全なプロジェクトを使用

class Block(nn.Module):
    def __init__(self, c):
        super().__init__()
        d=c['width']
        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = Attention(d, c['heads'], c['context'])
        self.ff = nn.Sequential(nn.Linear(d, 4*d), nn.GELU(), nn.Linear(4*d, d))

    def forward(self, x):
        x = x + self.attn(self.n1(x))
        return x + self.ff(self.n2(x))

class TinyLM(nn.Module):
    def __init__(self, cfg=CFG):
        super().__init__()
        self.cfg = cfg
        self.tokens = nn.Embedding(cfg['vocab'], cfg['width'])
        self.positions = nn.Embedding(cfg['context'], cfg['width'])
        self.blocks = nn.Sequential(*[Block(cfg) for _ in range(cfg['layers'])])
        self.norm = nn.LayerNorm(cfg['width'])
        self.head = nn.Linear(cfg['width'], cfg['vocab'], bias=False)
        self.apply(self.init)

    @staticmethod
    def init(m):
        if isinstance(m, (nn.Linear, nn.Embedding)):
            nn.init.normal_(m.weight, std=.02)
            if getattr(m, 'bias', None) is not None: nn.init.zeros_(m.bias)

    def forward(self, ids):
        if ids.ndim != 2 or not 0 < ids.shape[1] <= self.cfg['context']:
            raise ValueError('Expected [batch, time], 1 <= time <= context')
        x = self.tokens(ids) + self.positions(torch.arange(ids.shape[1], device=ids.device))
        return self.head(self.norm(self.blocks(x)))

生成と再読込で CFG を共通の定義にする。幅・語彙・層数の変更は重み形状を変えるため、旧チェックポイントをそのまま使えるとは限らない。forward は 32 位置超を拒否する。文脈拡張には位置表とマスクの変更に加え、注意メモリの二次増加も考慮する。

独自参考図:破線はパラメータ更新。生成は保存重みを使い最適化しません。
独自参考図:破線はパラメータ更新。生成は保存重みを使い最適化しません。 原寸図を見る
段階入力 → 出力境界
埋め込み[B,T] → [B,T,D]; T≤32
Q / K / V[B,T,D] → [B,H,T,D/H]64 ÷ 4 = 16
注意力[B,H,T,T] × [B,H,T,D/H]j≤i
出力射影[B,T,D] → [B,T,V]134,912 パラメータ
損失[BT,V] + [BT] → scalarnats / byte

6. 損失・勾配・更新ループ

teacher forcing では各位置に実際の先行バイトを渡します。logits [B,T,V] を [BT,V]、正解を [BT] にして、生の logits を cross_entropy に渡します。先に softmax してはいけません。正解確率 0.25 の損失は − nats。平均はサンプリング方法に依存します。

各ステップで旧勾配を消去し、損失計算、逆伝播、全体勾配ノルムを 1 に制限、AdamW 更新を行います。一次・二次モーメントで更新幅を調整し、重み減衰は別に適用します。教材では全パラメータを減衰させますが、正規化やバイアスを除外する配方もあり、実験条件として明記すべきです。

公称最大学習率は 0.002 で、20 ステップの warmup と、終端で 10% に近づく余弦係数を掛け合わせます。重み、モーメント、設定、ステップ、乱数状態を保存します。再読込は確認しますが resume コマンドは未実装で、完全再開にはスケジュールとデータ順序も復元する必要があります。

交差エントロピーの logit 微分は pᵢ−1[。正解確率が低いと負の勾配になり、降下法で logit が上がります。一様分布は nats/byte。AdamW は制限済み g、m/v、β、β、ε⁸、λ、学習率 η を使います。LayerNorm の β とは別です。

出力層を分離すると、h は正規化済み [D,1]、保存重み W は [V,D]、 は [V,1] である。ᵧ を求め、外積 ghᵀ が重み勾配、Wᵀg が隠れ表現へ戻る誤差になる。自動微分はブロックと embedding へ続く。平均損失は BT 位置の寄与を平均するため、1 位置の微分はバッチ全体の勾配ではない。

1 回の更新から学習ループへ

毎回新しいバッチを取り、学習率を設定し、勾配を消去する。loss() は 16×32 位置を 256 クラスの 512 サンプルへ展開する。backward() は parameter.grad に累積し、opt.step() が重みを更新するため、意図的な累積以外は旧勾配を消す。300 ステップで処理する 153,600 位置には重複があり、固有バイト数や epoch 数ではない。

実装の抜粋 · 実行には完全なプロジェクトを使用

def loss(model, x, y):
    logits=model(x)
    return F.cross_entropy(logits.reshape(-1, CFG['vocab']), y.reshape(-1))
opt=torch.optim.AdamW(model.parameters(),lr=.002,weight_decay=.01)
    before=heldout_loss(model,val)
    for step in range(args.steps):
        model.train();x,y=batch(train,generator)
        lr=.002*min((step+1)/20,1)*(.1+.9*.5*(1+math.cos(math.pi*step/args.steps)))
        for group in opt.param_groups:group['lr']=lr
        opt.zero_grad(set_to_none=True);value=loss(model,x,y)
        if not torch.isfinite(value):raise RuntimeError('nonfinite loss')
        value.backward();nn.utils.clip_grad_norm_(model.parameters(),1.0);opt.step()

スケジュールは warmup と cosine の積で、warmup 中も cosine が進むため実際の最大値は 0.002 より少し小さい。重みと最適化器状態は別に保存する。勾配そのものは学習済みモデルではない。保存状態は再開実装に使えるが、本教材の生成は重みだけを読み、連続学習との完全一致は実装しない。

予測誤差から重み更新へ

小さい画面では横にスクロールするか、原寸の図を開いてください。 原寸図を見る

予測誤差から重み更新へ. 簡略化した出力層は特徴 h=2、2 クラス、正解 y=0 とする。勾配は正解 logit を上げ、他方を下げる。計算を見せるため学習率 0.1 の SGD を使うが、実装は勾配制限と AdamW である。手計算例であり、実測や検証損失の毎回の減少保証ではない。
簡略化した出力層は特徴 h=2、2 クラス、正解 y=0 とする。勾配は正解 logit を上げ、他方を下げる。計算を見せるため学習率 0.1 の SGD を使うが、実装は勾配制限と AdamW である。手計算例であり、実測や検証損失の毎回の減少保証ではない。

7. チェックポイントから文章生成へ

空でないプロンプトの末尾 32 バイトを使い、最終位置の logits を取得します。正の温度で割り、top-k だけ残して正規化し、1 バイトをサンプリングして繰り返します。EOS ではなく固定生成長で停止します。低温度は分布を鋭くしますが、事実性を保証しません。

切り出すたびに学習位置を 0…31 に戻し、古い内容を忘れます。窓全体の再計算は明快ですが高コストです。KV キャッシュには位置の一貫性と無効化が必要で、位置をリセットしながら単純追加しても同じ出力にはなりません。

不完全な UTF-8 は置換文字になります。ASCII コーパスでは問題が減ります。実用アシスタントには広い適法データ、容量、指示学習、運用基盤、安全性検証が別途必要です。この小型モデルで Agent を確実に制御することもできないため、別のローカル指示モデル用アダプターを用意します。

別プロセスで重みを読み込む

generate.py を tiny_lm.py と同じ場所に置く。main ガードにより import で学習は始まらない。CPU に読み、保存 config で構築し、model 状態を入れて eval にする。初期化も乱数を使うため、構築後に採択用シードを再設定する。学習成果と推論入口を分離し、同じ環境で比較できる。

実装の抜粋 · 実行には完全なプロジェクトを使用

"""Generate from a trusted checkpoint without retraining."""
import argparse,torch
from tiny_lm import TinyLM
p=argparse.ArgumentParser();p.add_argument('checkpoint');p.add_argument('--prompt',default='node 10');p.add_argument('--seed',type=int,default=42)
a=p.parse_args();torch.set_num_threads(1);torch.manual_seed(a.seed)
s=torch.load(a.checkpoint,map_location='cpu',weights_only=True)
m=TinyLM(s['config']);m.load_state_dict(s['model']);m.eval()
torch.manual_seed(a.seed)
print(m.generate(a.prompt))

学習後に python generate.py tiny.pt --prompt "node 10" を実行する。入力と新しい 80 バイトを返す CLI であり、HTTP API や指示学習、Agent プロトコルはない。制限と待ち行列を備えるサービスは今後の拡張となる。weights_only は由来を保証しないため、信頼するチェックポイントだけを使う。

自己回帰生成: 1 バイトずつ追加

小さい画面では横にスクロールするか、原寸の図を開いてください。 原寸図を見る

自己回帰生成: 1 バイトずつ追加. 各反復で同じ固定重みを使い、最後の位置の logits から次のバイトを選ぶ。図は C と改行が選ばれたと仮定した例で、実際の生成結果の予測ではない。32 バイトを超えると次の順伝播は末尾 32 バイトのみを使い、学習位置をリセットする。注意は再計算され、KV キャッシュはない。
各反復で同じ固定重みを使い、最後の位置の logits から次のバイトを選ぶ。図は C と改行が選ばれたと仮定した例で、実際の生成結果の予測ではない。32 バイトを超えると次の順伝播は末尾 32 バイトのみを使い、学習位置をリセットする。注意は再計算され、KV キャッシュはない。

8. 実践・検証・面接演習

形状、未来からの非干渉、長さ制限、1 重みの有限差分、保存後 logits 一致を確認します。比較はデータ、分割、seed、更新数、検証手順を固定し、bigram、1/2 ブロック、未訓練/訓練済みを用います。損失と偶奇正解率を別々に、3 seed 以上で報告。マスク除去は漏洩実演であり有効な競合モデルではありません。自前データは許諾と分割を先に確認します。

完全な実装とコマンド

プロジェクト ZIP を取得

python tiny_lm.py --steps 300 --output tiny.pt
python generate.py tiny.pt --prompt 'node 10'
# Optional: your own licensed UTF-8 text, after data preparation
# python tiny_lm.py --text corpus.txt --steps 300 --output own.pt
tiny_lm.py

tiny_lm.py

"""Original Token Lab byte-level causal LM. Python 3.12 / torch 2.5.1 CPU.
Run: python tiny_lm.py --steps 300 --output tiny.pt
No pretrained weights, downloads, model API or third-party dataset.
"""
import argparse
import math
from pathlib import Path
import torch
from torch import nn
from torch.nn import functional as F

CFG = dict(vocab=256, context=32, width=64, heads=4, layers=2)

class Attention(nn.Module):
    def __init__(self, width, heads, context):
        super().__init__()
        assert width % heads == 0
        self.heads, self.dim = heads, width // heads
        self.qkv = nn.Linear(width, 3 * width)
        self.out = nn.Linear(width, width)
        self.register_buffer('mask', torch.ones(context, context, dtype=torch.bool).tril())

    def forward(self, x):
        b, t, c = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)
        q, k, v = [a.view(b, t, self.heads, self.dim).transpose(1, 2) for a in (q, k, v)]
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.dim)
        scores = scores.masked_fill(~self.mask[:t, :t], float('-inf'))
        mixed = scores.softmax(dim=-1) @ v
        return self.out(mixed.transpose(1, 2).contiguous().view(b, t, c))

class Block(nn.Module):
    def __init__(self, c):
        super().__init__()
        d=c['width']
        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = Attention(d, c['heads'], c['context'])
        self.ff = nn.Sequential(nn.Linear(d, 4*d), nn.GELU(), nn.Linear(4*d, d))

    def forward(self, x):
        x = x + self.attn(self.n1(x))
        return x + self.ff(self.n2(x))

class TinyLM(nn.Module):
    def __init__(self, cfg=CFG):
        super().__init__()
        self.cfg = cfg
        self.tokens = nn.Embedding(cfg['vocab'], cfg['width'])
        self.positions = nn.Embedding(cfg['context'], cfg['width'])
        self.blocks = nn.Sequential(*[Block(cfg) for _ in range(cfg['layers'])])
        self.norm = nn.LayerNorm(cfg['width'])
        self.head = nn.Linear(cfg['width'], cfg['vocab'], bias=False)
        self.apply(self.init)

    @staticmethod
    def init(m):
        if isinstance(m, (nn.Linear, nn.Embedding)):
            nn.init.normal_(m.weight, std=.02)
            if getattr(m, 'bias', None) is not None: nn.init.zeros_(m.bias)

    def forward(self, ids):
        if ids.ndim != 2 or not 0 < ids.shape[1] <= self.cfg['context']:
            raise ValueError('Expected [batch, time], 1 <= time <= context')
        x = self.tokens(ids) + self.positions(torch.arange(ids.shape[1], device=ids.device))
        return self.head(self.norm(self.blocks(x)))

    @torch.no_grad()
    def generate(self, prompt, count=80, temperature=.8, top_k=20):
        if not prompt or temperature <= 0 or not 1 <= top_k <= self.cfg['vocab']:
            raise ValueError('Nonempty prompt, positive temperature, valid top_k required')
        self.eval()
        ids = torch.tensor([list(prompt.encode('utf-8'))], dtype=torch.long)
        for _ in range(count):
            logits = self(ids[:, -self.cfg['context']:])[:, -1, :] / temperature
            threshold = logits.topk(top_k).values[:, -1:]
            logits = logits.masked_fill(logits < threshold, float('-inf'))
            ids = torch.cat((ids, torch.multinomial(logits.softmax(-1), 1)), dim=1)
        return bytes(ids[0].tolist()).decode('utf-8', errors='replace')

def corpus():
    # Original synthetic sentences. Split document IDs BEFORE window extraction.
    docs = [f'node {i:03d}: status is {"ready" if i % 2 == 0 else "busy"}.\n' for i in range(120)]
    return ''.join(docs[:100]).encode(), ''.join(docs[100:]).encode()

def batch(raw, generator, size=16):
    data=torch.tensor(list(raw), dtype=torch.long)
    t=CFG['context']
    starts=torch.randint(len(data)-t, (size,), generator=generator)
    return torch.stack([data[i:i+t] for i in starts]), torch.stack([data[i+1:i+t+1] for i in starts])

def loss(model, x, y):
    logits=model(x)
    return F.cross_entropy(logits.reshape(-1, CFG['vocab']), y.reshape(-1))

@torch.no_grad()
def heldout_loss(model, raw):
    model.eval()
    data=torch.tensor(list(raw),dtype=torch.long)
    total, count=0.,0
    for i in range(0,len(data)-1,CFG['context']):
        t=min(CFG['context'],len(data)-1-i)
        x,y=data[i:i+t][None,:],data[i+1:i+t+1][None,:]
        total += loss(model,x,y).item()*t
        count += t
    return total/count

def checks(model):
    model.eval()
    x=torch.arange(12)[None,:]
    changed=x.clone();changed[:,7:]=200
    with torch.no_grad():
        a,b=model(x),model(changed)
    assert a.shape == (1,12,256)
    assert torch.allclose(a[:,:7],b[:,:7],atol=1e-6), 'future leak'
    try:model(torch.zeros(1,33,dtype=torch.long))
    except ValueError:pass
    else:raise AssertionError('context overflow accepted')
    # One coordinate of the readout gradient, central finite difference.
    target=torch.arange(1,13)[None,:]
    model.zero_grad(set_to_none=True)
    loss(model,x,target).backward()
    analytical=model.head.weight.grad[1,0].item()
    original=model.head.weight[1,0].item();eps=.01
    with torch.no_grad():
        model.head.weight[1,0]=original+eps;plus=loss(model,x,target).item()
        model.head.weight[1,0]=original-eps;minus=loss(model,x,target).item()
        model.head.weight[1,0]=original
    assert abs(analytical-(plus-minus)/(2*eps))<.002, 'gradient mismatch'

def main():
    p=argparse.ArgumentParser();p.add_argument('--steps',type=int,default=300)
    p.add_argument('--output',default='tiny.pt');p.add_argument('--text',help='Optional owned UTF-8 corpus; chronological 90/10 split')
    args=p.parse_args()
    if args.steps<1:raise ValueError('steps must be positive')
    torch.set_num_threads(1);torch.manual_seed(42);torch.use_deterministic_algorithms(True)
    generator=torch.Generator().manual_seed(123)
    train,val=corpus()
    if args.text:
        raw=Path(args.text).read_text(encoding='utf-8').encode();cut=int(.9*len(raw));train,val=raw[:cut],raw[cut:]
    if min(len(train),len(val))<=CFG['context']:raise ValueError('each split must exceed context')
    model=TinyLM();checks(model)
    opt=torch.optim.AdamW(model.parameters(),lr=.002,weight_decay=.01)
    before=heldout_loss(model,val)
    for step in range(args.steps):
        model.train();x,y=batch(train,generator)
        lr=.002*min((step+1)/20,1)*(.1+.9*.5*(1+math.cos(math.pi*step/args.steps)))
        for group in opt.param_groups:group['lr']=lr
        opt.zero_grad(set_to_none=True);value=loss(model,x,y)
        if not torch.isfinite(value):raise RuntimeError('nonfinite loss')
        value.backward();nn.utils.clip_grad_norm_(model.parameters(),1.0);opt.step()
    after=heldout_loss(model,val)
    torch.save({'config':CFG,'model':model.state_dict(),'optimizer':opt.state_dict(),
                'step':args.steps,'rng':torch.get_rng_state(),'batch_rng':generator.get_state()},args.output)
    saved=torch.load(args.output,weights_only=True);restored=TinyLM(saved['config']);restored.load_state_dict(saved['model']);restored.eval();model.eval()
    probe=torch.tensor([[1,2,3]])
    assert torch.equal(model(probe),restored(probe)), 'checkpoint mismatch'
    checks(model)
    print(f'parameters={sum(p.numel() for p in model.parameters())}')
    print(f'validation_nats_per_byte: {before:.6f} -> {after:.6f}')
    print(f'validation_perplexity_per_byte={math.exp(after):.6f}')
    print('checks: shapes, causal mask, context bound, gradient, checkpoint passed')
    if not args.text and args.steps>=300:assert after<before, 'synthetic learning failed'
    torch.manual_seed(42);print('sample='+repr(model.generate('node 10')))

if __name__=='__main__':main()
generate.py

generate.py

"""Generate from a trusted checkpoint without retraining."""
import argparse,torch
from tiny_lm import TinyLM
p=argparse.ArgumentParser();p.add_argument('checkpoint');p.add_argument('--prompt',default='node 10');p.add_argument('--seed',type=int,default=42)
a=p.parse_args();torch.set_num_threads(1);torch.manual_seed(a.seed)
s=torch.load(a.checkpoint,map_location='cpu',weights_only=True)
m=TinyLM(s['config']);m.load_state_dict(s['model']);m.eval()
torch.manual_seed(a.seed)
print(m.generate(a.prompt))

観測結果と検証の限界

Python 3.12、PyTorch 2.5.1+cpu、1 スレッド、初期化 seed 42、バッチ seed 123、300 更新で実行。損失は 5.575623→0.546086 nats/byte、perplexity は 1.726483。合成データの測定で自然言語ベンチマークではありません。生成 node 046 は偶数なのに busy で、低損失は規則獲得の証明ではありません。検証は 32 バイトごとに文脈をリセットし token 数で重み付け。環境差による微差はあり得ます。

parameters=134912
validation_nats_per_byte: 5.575623 -> 0.546086
validation_perplexity_per_byte=1.726483
checks: shapes, causal mask, context bound, gradient, checkpoint passed
sample='node 107: status is busy.\nnode 046: status is busy.\nnode 096: status is ready.\nnode 081'

初回実行後の問題切り分け

症状意味次の操作
ModuleNotFoundError: torch実行中の Python に依存がない。.venv を有効化し、python -m pip --version と sys.executable を比較して同じ Python で導入する.
重みがない・形状が合わない学習未完了・パス誤り・設定変更。--output のパスと保存 config を使い、形状エラーを無視しない。構造変更後は再学習する。
低損失でも状態が誤るバイト予測と規則の正解率は別。偶奇規則の正解率を別に測り、学習条件と入力を固定して比較する。

独自の練習問題:企業の実際の面接ではありません

各問 1–5 点:1 用語、2 正確な定義、3 具体例の追跡、4 失敗と対策、5 公平な比較と証拠の限界。コードだけでは満点ではありません。

1. 因果マスクを外すと優秀に見えるのはなぜ?

ヒント

ずらした正解の位置を見る。

解答と分析

次バイトが入力の未来に存在します。参照すると漏洩です。未来を変更しても過去 logits は変わってはいけません。

2. perplexity 1.73 が助手能力を証明しない理由は?

ヒント

コーパス、単位、生成失敗を見る。

解答と分析

反復構文のバイト perplexity で正確性ではありません。node 046 は規則違反。独立タスクと分布で評価します。

3. 幅 64 と 128 を同じ更新数で公平に比べられる?

ヒント

データ量と計算量を分ける。

解答と分析

同じ更新数はデータ量を揃えても FLOPs は揃えません。射影は約 D²。データ固定と計算予算固定を区別します。

4. 重みだけでは正確に訓練再開できない理由は?

ヒント

次更新を左右する状態を追う。

解答と分析

モーメント、スケジュール、乱数、データ位置が影響します。教材は読込まで。再開追加時は連続実行と比較します。

前提知識を理解する

手法を支える共通の基礎を復習し、算例と確認問題で理解の不足を見つけます。

ニューラルネットワークは関数の合成です。入力 X の形状 [B,d] は、B 個の例がそれぞれ d 個の特徴を持つことを表します。[d,h] の重み W を掛けると、各例について h 個の加重和が得られ、[h] のバイアスが各行に加わります。

一つの出力要素を手計算し、内側の次元が一致する理由を説明できることが出発点です。活性化関数が非線形性を加えます。アフィン層だけを重ねても全体はアフィン変換のままです。

ここは例を行に並べる規約です。後の一例を列にする規約では重みは [h,d] で、この行列の転置になります。同じ写像を表しています。

解答を見る前に考える

微分は局所的な変化への感度です。連鎖律は「予測に対する損失の感度」と「重みに対する予測の感度」を結びます。、、予測=w×x、損失=(予測−y)²/2 とします。 で損失と微分を求め、学習率 0.1 での新しい重みを予測してください。

段階的な解説

予測は 2、損失は 0.5 です。二つの微分は −1 と 2 なので、dL/ です。更新後の重みは 1.2、予測は 2.4、損失は 0.18 になります。逆伝播は微分を計算し、最適化器は更新方法を決めます。この区別がデバッグの基礎です。

実践とのつながり

XOR はこの計算を隠れ表現に拡張します。(0,0) と (1,1) のラベルは 0、残りの二点は 1 で、一本の直線では分離できません。非線形層で表現を変えると、最後の線形分類器で分離できます。これは特徴学習の小さな例であり、大規模モデルの能力を示す実験ではありません。

理解を示すには

各段階の形状を書き、滑らかな点で中心差分と解析勾配を比較してください。差分幅を変えて丸め誤差も調べます。同じデータと予算で線形・非線形モデルを比較します。XOR の四行を記憶することは汎化の証拠ではありません。汎化には別の留保課題や分割が必要です。

完全な Python 例を実行

Python 3.10+・標準ライブラリのみ・決定的計算で乱数シード不要・通信なし。保存して下のコマンドを実行します。教育用の確認で、モデルの性能評価ではありません。

Python をダウンロード · neural.py
python3 neural.py
# Python 3.10+; standard library; deterministic; no network.
from math import isclose

def loss(w):
    return (w * 2.0 - 3.0) ** 2 / 2

w, learning_rate = 1.0, 0.1
gradient = (w * 2.0 - 3.0) * 2.0
h = 1e-5
numeric = (loss(w + h) - loss(w - h)) / (2 * h)
assert isclose(gradient, numeric, abs_tol=1e-8)
w_new = w - learning_rate * gradient
assert isclose(w_new, 1.2)
assert isclose(loss(w_new), 0.18)
assert loss(w_new) < loss(w)
print("gradient=-2.0; weight=1.2; loss=0.18")

期待する出力

gradient=-2.0; weight=1.2; loss=0.18

前提を復習 →

基礎解説更新:

追加チュートリアル・論文・実装資料

資料確認:2026年11月10日。実装、例、図は独自教材です。リンクは補助学習であり、推奨認定や元モデルの再現証明ではありません。論文日付と本記事日付は別です。

  1. Nano AI · Build a language modelhttps://nano-ai.tech/articles/

    推論から訓練へ学ぶ中国語のモジュール教材。

  2. Nano AI · GPT from scratchhttps://nano-ai.tech/articles/llm-from-scratch/

    GPT-2 推論の再構築と、ランダム初期化訓練の違いを比較。

  3. Andrej Karpathy · Neural Networks: Zero to Herohttps://karpathy.ai/zero-to-hero.html

    逆伝播と段階的な言語モデルで基礎を補う。

  4. Sebastian Raschka · LLMs from scratchhttps://github.com/rasbt/LLMs-from-scratch

    構造・訓練・適応を深める書籍の実装資料。

  5. Andrej Karpathy · nanoGPThttps://github.com/karpathy/nanoGPT

    小型教材の後に実用訓練コードを読む。必要資源は異なる。

  6. Attention Is All You Needhttps://arxiv.org/abs/1706.03762

    原論文と decoder-only 簡略化を比較。初稿 2017-06-12、v7 2023-08-02。

    PDF · https://arxiv.org/pdf/1706.03762v7

  7. OpenAI · Language Models are Unsupervised Multitask Learners (2019)https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf

    GPT-2 の歴史的報告。能力を教材モデルへ転用して解釈しない。

  8. PyTorch · cross_entropyhttps://docs.pytorch.org/docs/main/generated/torch.nn.functional.cross_entropy.html

    API 資料は main。実行コードは別途 PyTorch 2.5.1+cpu で固定・確認。

  9. PyTorch · AdamWhttps://docs.pytorch.org/docs/main/generated/torch.optim.AdamW.html

    API 資料は main。実行コードは別途 PyTorch 2.5.1+cpu で固定・確認。

目的を持って動画を見る

視聴 → 説明 → 実装 → 検証

外部の英語動画です。字幕と公開状況はYouTubeが管理します。再生を選んだ後だけYouTubeへ接続し、実験入力は送信しません。

次の学習

因果マスクを検証し、キャッシュ有無の出力を比較してから速度を測る。

実装と検証 → · 学習ルートへ →

予測・検証・根拠の記録

解答を開く前に結果を予測し、演習後に差異と応用テストを記録します。端末内に保存し、言語版間で共有します。

記録を開く/書き出す/消去する →

数学的確認の範囲は授業ごとに記録されています。論文の実証再現の証明ではありません。疑問点はメモに記録してください。 確認範囲