diff --git a/KOREAN_MODEL_DESIGN.md b/KOREAN_MODEL_DESIGN.md
new file mode 100644
index 0000000000000000000000000000000000000000..d62b9ec0954131c96e541fd3b512944010dabacf
--- /dev/null
+++ b/KOREAN_MODEL_DESIGN.md
@@ -0,0 +1,44 @@
+# KAWK-50M 한국어 전용 설계
+
+KAWK-50M은 Supra 계열의 규모와 BASE→장문맥 CPT 개발 순서만 참고한다.
+영어 모델의 vocabulary, 층 배분, 데이터 비율 및 평가 방식을 복제하지 않는다.
+
+## 모델과 토크나이저
+
+- Llama 계열 decoder-only Transformer
+- 51,542,528 parameters
+- 한국어 SentencePiece Unigram vocabulary 20,000
+- 14 layers, hidden size 512, SwiGLU intermediate size 1,408
+- attention heads 8, KV heads 4
+- tied input/output embeddings
+- BASE context 1,024, long-context CPT 5,120
+- NFC 완성형 한글과 byte fallback 사용
+
+32K 영어 vocabulary 대신 한국어 20K vocabulary를 사용해 절약한 embedding
+parameter를 14개 Transformer layer에 배분한다. 한국어 문서 안에 자연스럽게
+등장하는 영문·숫자는 유지하지만 영어·코드·수학 전용 문서는 학습하지 않는다.
+
+## 복구 BASE 학습
+
+이전 23B 학습은 label 이중 시프트 오류가 있었으므로 총 학습량으로 계산하지
+않는다. 올바른 `labels = input_ids` objective로 복구한 100M 체크포인트에서:
+
+1. 한국어 일반 문서 1B 추가 학습
+2. 겹치지 않는 sample 구간에서 한국어 일반 문서 5B 추가 학습
+3. 각 단계에서 loss, UTF-8 byte loss, 한국어 생성 샘플 평가
+
+각 단계가 이전 단계보다 개선되지 않으면 자동으로 다음 학습을 중단한다.
+
+## 한국어 장문맥 CPT
+
+- 총 3B tokens, sequence length 5,120
+- 한국어 일반 BASE 문서 2.9B
+- 한국어 RAG 문서 50M
+- 한국어 대화 문서 50M
+- ChatML 원문은 `지침`, `사용자`, `도우미` 역할명으로 평문화
+- 영어·코드·수학·reasoning 전용 source 제외
+
+RoPE는 언어별 장치가 아니다. KAWK에서는 1,024 이하 위치의 분포를 압축하지
+않고 `max_position_embeddings=5120`, `rope_theta=10000`으로 전체 가중치 CPT를
+수행한다. 최종 평가는 한국어 validation 문서에서 1,024-token 위치 구간별
+loss를 측정해 뒤쪽 문맥의 성능 붕괴를 별도로 확인한다.
diff --git a/configs/cpt_fixed_ko_3b_5k_5090.yaml b/configs/cpt_fixed_ko_3b_5k_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2ac6be6f591849315d409f4a65e388165648557d
--- /dev/null
+++ b/configs/cpt_fixed_ko_3b_5k_5090.yaml
@@ -0,0 +1,35 @@
+model_config: configs/model_50m_5k.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bins:
+    - data/tokenized-v2-cpt-3b/base/*.bin
+    - data/tokenized-v2-cpt-3b/structured/*.bin
+  validation_bin: data/tokenized-v2-cpt-3b/validation.bin
+  sequence_length: 5120
+  sample_offset: 0
+
+training:
+  output_dir: runs/kawk50m-fixed-ko-cpt-3b-5k-5090
+  seed: 4242
+  precision: bf16
+  per_device_batch_size: 4
+  gradient_accumulation_steps: 6
+  max_tokens: 3000000000
+  max_steps: null
+  learning_rate: 1.5e-4
+  min_learning_rate: 1.5e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 50
+  eval_every: 1000
+  eval_batches: 20
+  save_every: 5000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/cpt_v2_3b_5k_5090.yaml b/configs/cpt_v2_3b_5k_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d2bea89bcdd8d69751a370bc9c823cf0ee98e358
--- /dev/null
+++ b/configs/cpt_v2_3b_5k_5090.yaml
@@ -0,0 +1,34 @@
+model_config: configs/model_50m_5k.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bins:
+    - data/tokenized-v2-cpt-3b/base/*.bin
+    - data/tokenized-v2-cpt-3b/structured/*.bin
+  validation_bin: data/tokenized-v2-cpt-3b/validation.bin
+  sequence_length: 5120
+
+training:
+  output_dir: runs/kawk-1.5-50m-v2-cpt-3b-5090
+  seed: 4242
+  precision: bf16
+  per_device_batch_size: 4
+  gradient_accumulation_steps: 6
+  max_tokens: 3000000000
+  max_steps: null
+  learning_rate: 2.0e-4
+  min_learning_rate: 2.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 250
+  eval_batches: 20
+  save_every: 1000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+  gradient_checkpointing: false
diff --git a/configs/model_50m.yaml b/configs/model_50m.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..87447445898691fe6d4255578fffb34a011e36c6
--- /dev/null
+++ b/configs/model_50m.yaml
@@ -0,0 +1,20 @@
+model:
+  vocab_size: 20000
+  hidden_size: 512
+  intermediate_size: 1408
+  num_hidden_layers: 14
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  max_position_embeddings: 1024
+  hidden_act: silu
+  rms_norm_eps: 1.0e-6
+  rope_theta: 10000.0
+  attention_bias: false
+  mlp_bias: false
+  tie_word_embeddings: true
+  bos_token_id: 1
+  eos_token_id: 2
+  pad_token_id: 3
+  initializer_range: 0.02
+  expected_parameters: 51542528
+
diff --git a/configs/model_50m_5k.yaml b/configs/model_50m_5k.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ff968c610bb683987554021f9c8d8b0ec6a69968
--- /dev/null
+++ b/configs/model_50m_5k.yaml
@@ -0,0 +1,19 @@
+model:
+  vocab_size: 20000
+  hidden_size: 512
+  intermediate_size: 1408
+  num_hidden_layers: 14
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  max_position_embeddings: 5120
+  hidden_act: silu
+  rms_norm_eps: 1.0e-6
+  rope_theta: 10000.0
+  attention_bias: false
+  mlp_bias: false
+  tie_word_embeddings: true
+  bos_token_id: 1
+  eos_token_id: 2
+  pad_token_id: 3
+  initializer_range: 0.02
+  expected_parameters: 51542528
diff --git a/configs/pretrain_100m_5090.yaml b/configs/pretrain_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..63dfbfa2978bffba28007daf7baad1a00ac0307c
--- /dev/null
+++ b/configs/pretrain_100m_5090.yaml
@@ -0,0 +1,32 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-pilot
+
+data:
+  train_bin: data/tokenized-pilot/train.bin
+  validation_bin: data/tokenized-pilot/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_5b.yaml b/configs/pretrain_5b.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1f7ee48f2b795d4d464b423fb467ac3236c38fdd
--- /dev/null
+++ b/configs/pretrain_5b.yaml
@@ -0,0 +1,32 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k
+
+data:
+  train_bin: data/tokenized/train.bin
+  validation_bin: data/tokenized/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-5b
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 8
+  gradient_accumulation_steps: 16
+  max_tokens: 5000000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 500
+  eval_batches: 50
+  save_every: 1000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_5b_5090.yaml b/configs/pretrain_5b_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..874fb161a0eb6817b8ae8669dad79b022c2948b8
--- /dev/null
+++ b/configs/pretrain_5b_5090.yaml
@@ -0,0 +1,31 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-pilot
+
+data:
+  train_bin: data/tokenized-5b/train.bin
+  validation_bin: data/tokenized-5b/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-5b-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 5000000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 500
+  eval_batches: 50
+  save_every: 1000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/configs/pretrain_fixed_recovery_100m_5090.yaml b/configs/pretrain_fixed_recovery_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f8a4d1a49dc94df8298f6e9cf8c7494476b916b0
--- /dev/null
+++ b/configs/pretrain_fixed_recovery_100m_5090.yaml
@@ -0,0 +1,32 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bin: data/tokenized-v2b-100m/train.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-fixed-recovery-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_fixed_recovery_1b_5090.yaml b/configs/pretrain_fixed_recovery_1b_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ed93a6f87de5d5fd280d67c28792364be384f1c3
--- /dev/null
+++ b/configs/pretrain_fixed_recovery_1b_5090.yaml
@@ -0,0 +1,35 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bins:
+    - data/tokenized-v2-20b/initial/*.bin
+    - data/tokenized-v2-20b/stream/part-*/*.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+  sample_offset: 0
+
+training:
+  output_dir: runs/kawk50m-fixed-recovery-1b-5090
+  seed: 142
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 1000000000
+  max_steps: null
+  learning_rate: 3.0e-4
+  min_learning_rate: 3.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 50
+  eval_every: 500
+  eval_batches: 20
+  save_every: 2000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_fixed_recovery_plus5b_5090.yaml b/configs/pretrain_fixed_recovery_plus5b_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..0cfe9155095eda92be86cdc4991c6cbc71dca46e
--- /dev/null
+++ b/configs/pretrain_fixed_recovery_plus5b_5090.yaml
@@ -0,0 +1,35 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bins:
+    - data/tokenized-v2-20b/initial/*.bin
+    - data/tokenized-v2-20b/stream/part-*/*.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+  sample_offset: 976640
+
+training:
+  output_dir: runs/kawk50m-fixed-recovery-6b-5090
+  seed: 142
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 5000000000
+  max_steps: null
+  learning_rate: 2.0e-4
+  min_learning_rate: 2.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 100
+  eval_every: 2000
+  eval_batches: 20
+  save_every: 5000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_fixed_scratch_100m_5090.yaml b/configs/pretrain_fixed_scratch_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..20229e1ed5ab0f3b219dd919beee39d329fd1639
--- /dev/null
+++ b/configs/pretrain_fixed_scratch_100m_5090.yaml
@@ -0,0 +1,32 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bin: data/tokenized-v2b-100m/train.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-fixed-scratch-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
+
diff --git a/configs/pretrain_smoke.yaml b/configs/pretrain_smoke.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b0efb670c212abd6e4f5c9797612b11228756b3a
--- /dev/null
+++ b/configs/pretrain_smoke.yaml
@@ -0,0 +1,31 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k
+
+data:
+  train_bin: data/tokenized/train.bin
+  validation_bin: data/tokenized/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-smoke
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 2
+  gradient_accumulation_steps: 2
+  max_tokens: null
+  max_steps: 5
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 1
+  eval_every: 5
+  eval_batches: 2
+  save_every: 5
+  save_final: true
+  torch_compile: false
+
diff --git a/configs/pretrain_v2_100m_5090.yaml b/configs/pretrain_v2_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b3ca8cce6861a4139c1f40dc69f9841cfbd4f40c
--- /dev/null
+++ b/configs/pretrain_v2_100m_5090.yaml
@@ -0,0 +1,31 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v2
+
+data:
+  train_bin: data/tokenized-v2-100m/train.bin
+  validation_bin: data/tokenized-v2-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-v2-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/configs/pretrain_v2_20b_5090.yaml b/configs/pretrain_v2_20b_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..09ad0a7c45ce7371fdad245b8644e25298db59cb
--- /dev/null
+++ b/configs/pretrain_v2_20b_5090.yaml
@@ -0,0 +1,33 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bins:
+    - data/tokenized-v2-20b/initial/*.bin
+    - data/tokenized-v2-20b/stream/part-*/*.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-v2-20b-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 20000000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 20
+  eval_every: 1000
+  eval_batches: 20
+  save_every: 20000
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/configs/pretrain_v2b_100m_5090.yaml b/configs/pretrain_v2b_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f1d58c37c57cdb12eaa8b210ec1edb55df37e19c
--- /dev/null
+++ b/configs/pretrain_v2b_100m_5090.yaml
@@ -0,0 +1,31 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bin: data/tokenized-v2b-100m/train.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-v2b-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/configs/pretrain_v2c_100m_5090.yaml b/configs/pretrain_v2c_100m_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1f750e0cc61746d0ce3850e0228a98ca215bf596
--- /dev/null
+++ b/configs/pretrain_v2c_100m_5090.yaml
@@ -0,0 +1,31 @@
+model_config: configs/model_50m.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_bin: data/tokenized-5b/train.bin
+  validation_bin: data/tokenized-v2b-100m/validation.bin
+  sequence_length: 1024
+
+training:
+  output_dir: runs/kawk50m-v2c-100m-5090
+  seed: 42
+  precision: bf16
+  per_device_batch_size: 32
+  gradient_accumulation_steps: 4
+  max_tokens: 100000000
+  max_steps: null
+  learning_rate: 6.0e-4
+  min_learning_rate: 6.0e-5
+  warmup_ratio: 0.02
+  weight_decay: 0.1
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 10
+  eval_every: 100
+  eval_batches: 20
+  save_every: 250
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/configs/sft_ko_80m_5k_5090.yaml b/configs/sft_ko_80m_5k_5090.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..41b66f7757829b162bd06ac7574adeed5689c66f
--- /dev/null
+++ b/configs/sft_ko_80m_5k_5090.yaml
@@ -0,0 +1,35 @@
+model_config: configs/model_50m_5k.yaml
+tokenizer_dir: artifacts/tokenizer-20k-v3
+
+data:
+  train_prefixes:
+    - data/sft-ko-v1/chat/train
+    - data/sft-ko-v1/rag/train
+  validation_prefixes:
+    - data/sft-ko-v1/chat/validation
+    - data/sft-ko-v1/rag/validation
+  sequence_length: 5120
+
+training:
+  output_dir: runs/kawk50m-ko-instruct-v1-5090
+  seed: 5150
+  precision: bf16
+  per_device_batch_size: 4
+  gradient_accumulation_steps: 6
+  epochs: 2.0
+  max_steps: null
+  learning_rate: 5.0e-5
+  min_learning_rate: 5.0e-6
+  warmup_ratio: 0.03
+  weight_decay: 0.01
+  adam_beta1: 0.9
+  adam_beta2: 0.95
+  adam_eps: 1.0e-8
+  max_grad_norm: 1.0
+  log_every: 20
+  eval_every: 200
+  eval_batches: 20
+  save_every: 500
+  save_final: true
+  torch_compile: true
+  compile_mode: default
diff --git a/kawk50m/__init__.py b/kawk50m/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5aeb51fe423b9a52968010fa378ac2e6648ea1d1
--- /dev/null
+++ b/kawk50m/__init__.py
@@ -0,0 +1,4 @@
+"""Utilities for training the KAWK50M Korean language model."""
+
+__version__ = "0.1.0"
+
diff --git a/kawk50m/binary_dataset.py b/kawk50m/binary_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0f0ea78bf1c41aa68b2716c0e3a7f09819e0d93
--- /dev/null
+++ b/kawk50m/binary_dataset.py
@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import math
+import glob
+from bisect import bisect_right
+from collections.abc import Sequence
+from pathlib import Path
+
+import numpy as np
+import torch
+
+
+class PackedTokenDataset:
+    """Read fixed-length Hugging Face causal-LM samples from uint16 streams.
+
+    Labels intentionally mirror ``input_ids`` because causal language-model
+    heads such as ``LlamaForCausalLM`` perform the one-token label shift inside
+    their loss function.
+    """
+
+    def __init__(
+        self,
+        path: str | Path | Sequence[str | Path],
+        sequence_length: int,
+    ) -> None:
+        if sequence_length <= 0:
+            raise ValueError("sequence_length must be positive")
+        raw_paths = [path] if isinstance(path, (str, Path)) else list(path)
+        resolved: set[Path] = set()
+        for raw_path in raw_paths:
+            value = str(raw_path)
+            matches = [Path(item) for item in glob.glob(value)]
+            if matches:
+                resolved.update(item.resolve() for item in matches if item.is_file())
+            else:
+                candidate = Path(raw_path)
+                if candidate.is_file():
+                    resolved.add(candidate.resolve())
+        self.paths = sorted(resolved)
+        if not self.paths:
+            raise FileNotFoundError(f"No token binaries found for: {raw_paths}")
+        self.path = self.paths[0]
+        self.sequence_length = sequence_length
+        self.token_streams = [
+            np.memmap(item, mode="r", dtype=np.uint16) for item in self.paths
+        ]
+        sequence_counts = [
+            max(0, (len(tokens) - 1) // self.sequence_length)
+            for tokens in self.token_streams
+        ]
+        self.sequence_offsets: list[int] = []
+        running_total = 0
+        for count in sequence_counts:
+            running_total += count
+            self.sequence_offsets.append(running_total)
+        self.num_sequences = running_total
+        if self.num_sequences == 0:
+            raise ValueError(
+                f"{self.paths} need at least {self.sequence_length + 1} tokens"
+            )
+        self._affine_cache: dict[int, tuple[int, int]] = {}
+
+    def __len__(self) -> int:
+        return self.num_sequences
+
+    def sequence(self, index: int) -> np.ndarray:
+        if not 0 <= index < self.num_sequences:
+            raise IndexError(index)
+        stream_index = bisect_right(self.sequence_offsets, index)
+        previous_offset = (
+            self.sequence_offsets[stream_index - 1] if stream_index > 0 else 0
+        )
+        local_index = index - previous_offset
+        start = local_index * self.sequence_length
+        return np.asarray(
+            self.token_streams[stream_index][
+                start : start + self.sequence_length + 1
+            ],
+            dtype=np.int64,
+        )
+
+    def _affine_parameters(self, epoch: int, seed: int) -> tuple[int, int]:
+        cache_key = (seed << 32) ^ epoch
+        if cache_key in self._affine_cache:
+            return self._affine_cache[cache_key]
+        rng = np.random.default_rng(seed + epoch * 1_000_003)
+        multiplier = int(rng.integers(1, max(self.num_sequences, 2)))
+        while math.gcd(multiplier, self.num_sequences) != 1:
+            multiplier += 1
+            if multiplier >= self.num_sequences:
+                multiplier = 1
+        offset = int(rng.integers(0, self.num_sequences))
+        self._affine_cache[cache_key] = (multiplier, offset)
+        return multiplier, offset
+
+    def training_batch(
+        self,
+        *,
+        micro_step: int,
+        batch_size: int,
+        rank: int,
+        world_size: int,
+        seed: int,
+        sample_offset: int = 0,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        if sample_offset < 0:
+            raise ValueError("sample_offset must be non-negative")
+        global_batch_size = batch_size * world_size
+        first_ordinal = (
+            sample_offset
+            + micro_step * global_batch_size
+            + rank * batch_size
+        )
+        rows: list[np.ndarray] = []
+        for local_index in range(batch_size):
+            ordinal = first_ordinal + local_index
+            epoch, position = divmod(ordinal, self.num_sequences)
+            multiplier, offset = self._affine_parameters(epoch, seed)
+            sequence_index = (multiplier * position + offset) % self.num_sequences
+            rows.append(self.sequence(sequence_index))
+        return self._to_tensors(rows, device)
+
+    def evaluation_batch(
+        self,
+        *,
+        batch_index: int,
+        batch_size: int,
+        rank: int,
+        world_size: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        first = (batch_index * world_size + rank) * batch_size
+        rows = [
+            self.sequence((first + offset) % self.num_sequences)
+            for offset in range(batch_size)
+        ]
+        return self._to_tensors(rows, device)
+
+    @staticmethod
+    def _to_tensors(
+        rows: list[np.ndarray], device: torch.device
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        batch = torch.from_numpy(np.stack(rows, axis=0))
+        inputs = batch[:, :-1].to(device=device, dtype=torch.long, non_blocking=True)
+        labels = inputs.clone()
+        return inputs, labels
diff --git a/kawk50m/chat.py b/kawk50m/chat.py
new file mode 100644
index 0000000000000000000000000000000000000000..960de78674d6f461984424f0cd308a9b54dfc9d6
--- /dev/null
+++ b/kawk50m/chat.py
@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+
+CHATML_BLOCK_RE = re.compile(
+    r"<\|im_start\|>\s*(system|user|assistant)\s*\n?(.*?)<\|im_end\|>",
+    re.IGNORECASE | re.DOTALL,
+)
+
+ROLE_HEADERS = {
+    "system": "### 지침:\n",
+    "user": "### 사용자:\n",
+    "assistant": "### 도우미:\n",
+}
+
+KOREAN_CHAT_TEMPLATE = """{{ bos_token }}{% for message in messages %}{% if message['role'] == 'system' %}### 지침:
+{{ message['content'] }}
+
+{% elif message['role'] == 'user' %}### 사용자:
+{{ message['content'] }}
+
+{% elif message['role'] == 'assistant' %}### 도우미:
+{{ message['content'] }}{{ eos_token }}
+
+{% endif %}{% endfor %}{% if add_generation_prompt %}### 도우미:
+{% endif %}"""
+
+
+def parse_chatml(text: str) -> list[tuple[str, str]]:
+    if not isinstance(text, str):
+        return []
+    return [
+        (role.casefold(), content.strip())
+        for role, content in CHATML_BLOCK_RE.findall(text)
+        if content.strip()
+    ]
+
+
+def format_generation_prompt(
+    user_text: str,
+    *,
+    system_text: str | None = None,
+) -> str:
+    sections: list[str] = []
+    if system_text:
+        sections.append(ROLE_HEADERS["system"] + system_text.strip())
+    sections.append(ROLE_HEADERS["user"] + user_text.strip())
+    sections.append(ROLE_HEADERS["assistant"])
+    return "\n\n".join(sections)
+
+
+def _encode(tokenizer: Any, text: str) -> list[int]:
+    return list(
+        tokenizer(
+            text,
+            add_special_tokens=False,
+            return_attention_mask=False,
+            return_token_type_ids=False,
+        )["input_ids"]
+    )
+
+
+def _encode_context_block(
+    tokenizer: Any,
+    role: str,
+    content: str,
+) -> list[int]:
+    result = _encode(tokenizer, ROLE_HEADERS[role] + content.strip())
+    if role == "assistant":
+        result.append(int(tokenizer.eos_token_id))
+    result.extend(_encode(tokenizer, "\n\n"))
+    return result
+
+
+def build_assistant_examples(
+    blocks: Sequence[tuple[str, str]],
+    tokenizer: Any,
+    *,
+    max_length: int,
+    min_prompt_tokens: int = 32,
+) -> Iterable[tuple[list[int], list[int]]]:
+    """Yield one assistant-only-loss example for every assistant turn.
+
+    Earlier assistant turns remain masked context. The current assistant response
+    and its EOS token are supervised. Long prompts are cropped from the left so
+    the most recent user request and assistant header are retained.
+    """
+
+    if max_length <= min_prompt_tokens + 2:
+        raise ValueError("max_length is too small for an SFT example")
+    if tokenizer.bos_token_id is None or tokenizer.eos_token_id is None:
+        raise ValueError("Tokenizer must define BOS and EOS token IDs")
+
+    context_ids = [int(tokenizer.bos_token_id)]
+    for role, content in blocks:
+        if role not in ROLE_HEADERS or not content.strip():
+            continue
+        if role != "assistant":
+            context_ids.extend(_encode_context_block(tokenizer, role, content))
+            continue
+
+        assistant_header = _encode(tokenizer, ROLE_HEADERS["assistant"])
+        prompt_ids = context_ids + assistant_header
+        response_ids = _encode(tokenizer, content.strip())
+        response_budget = max_length - min_prompt_tokens - 1
+        if len(response_ids) > response_budget:
+            response_ids = response_ids[:response_budget]
+        target_ids = response_ids + [int(tokenizer.eos_token_id)]
+        prompt_budget = max_length - len(target_ids)
+        prompt_tail = prompt_ids[-prompt_budget:]
+        input_ids = prompt_tail + target_ids
+        loss_mask = [0] * len(prompt_tail) + [1] * len(target_ids)
+        if response_ids and len(input_ids) <= max_length:
+            yield input_ids, loss_mask
+
+        context_ids.extend(_encode_context_block(tokenizer, role, content))
diff --git a/kawk50m/checkpoint.py b/kawk50m/checkpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..89c199f18afcf1c3c67800ef10015521e57ca8cb
--- /dev/null
+++ b/kawk50m/checkpoint.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import os
+import random
+import uuid
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+
+def resolve_checkpoint(resume: str | Path, output_dir: str | Path) -> Path:
+    if str(resume).lower() != "latest":
+        path = Path(resume)
+    else:
+        latest_file = Path(output_dir) / "latest_checkpoint.txt"
+        if not latest_file.is_file():
+            raise FileNotFoundError(
+                f"Cannot resume latest: {latest_file} does not exist"
+            )
+        stored = latest_file.read_text(encoding="utf-8").strip()
+        path = Path(stored)
+        if not path.is_absolute():
+            path = Path(output_dir) / path
+    if not (path / "model").is_dir() or not (path / "trainer_state.pt").is_file():
+        raise FileNotFoundError(f"Invalid checkpoint directory: {path}")
+    return path.resolve()
+
+
+def capture_rng_state() -> dict[str, Any]:
+    state: dict[str, Any] = {
+        "python": random.getstate(),
+        "numpy": np.random.get_state(),
+        "torch": torch.get_rng_state(),
+    }
+    if torch.cuda.is_available():
+        state["cuda"] = torch.cuda.get_rng_state_all()
+    return state
+
+
+def restore_rng_state(state: dict[str, Any]) -> None:
+    random.setstate(state["python"])
+    np.random.set_state(state["numpy"])
+    torch.set_rng_state(state["torch"])
+    if torch.cuda.is_available() and "cuda" in state:
+        torch.cuda.set_rng_state_all(state["cuda"])
+
+
+def load_training_state(path: Path) -> dict[str, Any]:
+    try:
+        return torch.load(path, map_location="cpu", weights_only=False)
+    except TypeError:
+        return torch.load(path, map_location="cpu")
+
+
+def save_checkpoint(
+    *,
+    output_dir: Path,
+    step: int,
+    model: Any,
+    tokenizer: Any,
+    optimizer: torch.optim.Optimizer,
+    scheduler: Any,
+    training_config: dict[str, Any],
+    world_size: int,
+) -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    final_path = output_dir / f"checkpoint-{step:08d}"
+    if final_path.exists():
+        return final_path
+
+    temporary_path = output_dir / f".checkpoint-{step:08d}-{uuid.uuid4().hex}.tmp"
+    temporary_path.mkdir(parents=False, exist_ok=False)
+    try:
+        model.save_pretrained(
+            temporary_path / "model",
+            safe_serialization=True,
+            max_shard_size="2GB",
+        )
+        tokenizer.save_pretrained(temporary_path / "tokenizer")
+        state = {
+            "step": step,
+            "world_size": world_size,
+            "optimizer": optimizer.state_dict(),
+            "scheduler": scheduler.state_dict(),
+            "rng": capture_rng_state(),
+            "training_config": training_config,
+        }
+        torch.save(state, temporary_path / "trainer_state.pt")
+        with (temporary_path / "state_summary.json").open(
+            "w", encoding="utf-8"
+        ) as handle:
+            json.dump(
+                {"step": step, "world_size": world_size},
+                handle,
+                ensure_ascii=False,
+                indent=2,
+            )
+            handle.write("\n")
+        os.replace(temporary_path, final_path)
+    except BaseException:
+        # Preserve a failed temporary checkpoint for inspection rather than deleting it.
+        raise
+
+    latest_temp = output_dir / ".latest_checkpoint.tmp"
+    latest_temp.write_text(final_path.name + "\n", encoding="utf-8")
+    os.replace(latest_temp, output_dir / "latest_checkpoint.txt")
+    return final_path
+
diff --git a/kawk50m/cli.py b/kawk50m/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc85009923abfb2eced5ed005e2fc73a40f285bf
--- /dev/null
+++ b/kawk50m/cli.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import sys
+
+
+def configure_utf8_stdio() -> None:
+    """Make Korean/emoji CLI output reliable on legacy Windows code pages."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is not None:
+            reconfigure(encoding="utf-8", errors="replace")
+
diff --git a/kawk50m/config.py b/kawk50m/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff5eb650fdf4c6fbc62365bdd628a6519a89ba8f
--- /dev/null
+++ b/kawk50m/config.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from transformers import LlamaConfig
+
+
+def load_yaml(path: str | Path) -> dict[str, Any]:
+    config_path = Path(path)
+    with config_path.open("r", encoding="utf-8") as handle:
+        data = yaml.safe_load(handle)
+    if not isinstance(data, dict):
+        raise ValueError(f"YAML root must be a mapping: {config_path}")
+    return data
+
+
+def _positive_int(value: Any, name: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ValueError(f"{name} must be a positive integer, got {value!r}")
+    return value
+
+
+def build_llama_config(
+    model_data: dict[str, Any],
+    *,
+    tokenizer_vocab_size: int | None = None,
+) -> tuple[LlamaConfig, int | None]:
+    """Validate a model mapping and return a Hugging Face LlamaConfig."""
+    if "model" in model_data:
+        model_data = model_data["model"]
+    if not isinstance(model_data, dict):
+        raise ValueError("model configuration must be a mapping")
+
+    values = dict(model_data)
+    expected_parameters = values.pop("expected_parameters", None)
+
+    required = (
+        "vocab_size",
+        "hidden_size",
+        "intermediate_size",
+        "num_hidden_layers",
+        "num_attention_heads",
+        "num_key_value_heads",
+        "max_position_embeddings",
+    )
+    for name in required:
+        values[name] = _positive_int(values.get(name), name)
+
+    if values["hidden_size"] % values["num_attention_heads"] != 0:
+        raise ValueError("hidden_size must be divisible by num_attention_heads")
+    if values["num_attention_heads"] % values["num_key_value_heads"] != 0:
+        raise ValueError(
+            "num_attention_heads must be divisible by num_key_value_heads"
+        )
+    if tokenizer_vocab_size is not None and values["vocab_size"] != tokenizer_vocab_size:
+        raise ValueError(
+            "Tokenizer/model vocabulary mismatch: "
+            f"tokenizer={tokenizer_vocab_size}, model={values['vocab_size']}"
+        )
+
+    config = LlamaConfig(**values)
+    return config, expected_parameters
+
+
+def count_unique_parameters(model: Any) -> int:
+    """Count parameters without double-counting tied tensors."""
+    seen: set[int] = set()
+    total = 0
+    for parameter in model.parameters():
+        pointer = parameter.untyped_storage().data_ptr()
+        if pointer not in seen:
+            seen.add(pointer)
+            total += parameter.numel()
+    return total
+
diff --git a/kawk50m/io.py b/kawk50m/io.py
new file mode 100644
index 0000000000000000000000000000000000000000..6eadfed683f32e0523b4a2bc80dc13c436086ab2
--- /dev/null
+++ b/kawk50m/io.py
@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import gzip
+import json
+from collections.abc import Iterator, Sequence
+from pathlib import Path
+from typing import Any, TextIO
+import glob
+
+
+SUPPORTED_SUFFIXES = (".jsonl", ".jsonl.gz", ".txt", ".txt.gz")
+
+
+def discover_paths(inputs: Sequence[str | Path]) -> list[Path]:
+    found: set[Path] = set()
+    for raw_input in inputs:
+        raw = str(raw_input)
+        path = Path(raw)
+        if path.is_dir():
+            for candidate in path.rglob("*"):
+                if candidate.is_file() and any(
+                    str(candidate).lower().endswith(suffix)
+                    for suffix in SUPPORTED_SUFFIXES
+                ):
+                    found.add(candidate.resolve())
+            continue
+        matches = [Path(item) for item in glob.glob(raw, recursive=True)]
+        if matches:
+            found.update(item.resolve() for item in matches if item.is_file())
+        elif path.is_file():
+            found.add(path.resolve())
+    return sorted(found)
+
+
+def open_text(path: Path) -> TextIO:
+    if path.name.lower().endswith(".gz"):
+        return gzip.open(path, "rt", encoding="utf-8", errors="replace")
+    return path.open("r", encoding="utf-8", errors="replace")
+
+
+def iter_documents(
+    paths: Sequence[Path],
+    *,
+    text_field: str = "text",
+    txt_mode: str = "line",
+) -> Iterator[dict[str, Any]]:
+    if txt_mode not in {"line", "document"}:
+        raise ValueError("txt_mode must be 'line' or 'document'")
+
+    for path in paths:
+        lower_name = path.name.lower()
+        source_default = path.name.removesuffix(".gz")
+        if lower_name.endswith((".jsonl", ".jsonl.gz")):
+            with open_text(path) as handle:
+                for line_number, line in enumerate(handle, start=1):
+                    if not line.strip():
+                        continue
+                    try:
+                        row = json.loads(line)
+                    except json.JSONDecodeError as error:
+                        raise ValueError(
+                            f"Invalid JSON at {path}:{line_number}: {error}"
+                        ) from error
+                    if not isinstance(row, dict):
+                        raise ValueError(
+                            f"Expected a JSON object at {path}:{line_number}"
+                        )
+                    text = row.get(text_field)
+                    if not isinstance(text, str):
+                        continue
+                    yield {
+                        "id": row.get("id", f"{path.name}:{line_number}"),
+                        "text": text,
+                        "source": row.get("source", source_default),
+                        "url": row.get("url"),
+                        "license": row.get("license"),
+                    }
+            continue
+
+        if lower_name.endswith((".txt", ".txt.gz")):
+            with open_text(path) as handle:
+                if txt_mode == "document":
+                    text = handle.read()
+                    if text.strip():
+                        yield {
+                            "id": path.name,
+                            "text": text,
+                            "source": source_default,
+                            "url": None,
+                            "license": None,
+                        }
+                else:
+                    for line_number, line in enumerate(handle, start=1):
+                        if line.strip():
+                            yield {
+                                "id": f"{path.name}:{line_number}",
+                                "text": line.rstrip("\n"),
+                                "source": source_default,
+                                "url": None,
+                                "license": None,
+                            }
+
+
+class ShardedJsonlWriter:
+    def __init__(
+        self,
+        output_dir: Path,
+        split: str,
+        *,
+        documents_per_shard: int,
+    ) -> None:
+        self.output_dir = output_dir
+        self.split = split
+        self.documents_per_shard = documents_per_shard
+        self.document_count = 0
+        self.shard_index = -1
+        self._handle: TextIO | None = None
+
+    def _open_next(self) -> None:
+        if self._handle is not None:
+            self._handle.close()
+        self.shard_index += 1
+        path = self.output_dir / f"{self.split}-{self.shard_index:05d}.jsonl"
+        self._handle = path.open("w", encoding="utf-8", newline="\n")
+
+    def write(self, row: dict[str, Any]) -> None:
+        if self._handle is None or self.document_count % self.documents_per_shard == 0:
+            self._open_next()
+        assert self._handle is not None
+        self._handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")))
+        self._handle.write("\n")
+        self.document_count += 1
+
+    def close(self) -> None:
+        if self._handle is not None:
+            self._handle.close()
+            self._handle = None
+
+    def __enter__(self) -> "ShardedJsonlWriter":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
diff --git a/kawk50m/sft_dataset.py b/kawk50m/sft_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb2d6d15ee498c9a8cfd136b1e8bb268e8b23ccf
--- /dev/null
+++ b/kawk50m/sft_dataset.py
@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from pathlib import Path
+
+import numpy as np
+import torch
+
+
+class SFTPackedDataset:
+    """Memory-map fixed-length input IDs and assistant-only loss masks."""
+
+    def __init__(
+        self,
+        prefixes: str | Path | Sequence[str | Path],
+        sequence_length: int,
+    ) -> None:
+        if sequence_length <= 0:
+            raise ValueError("sequence_length must be positive")
+        raw_prefixes = (
+            [prefixes] if isinstance(prefixes, (str, Path)) else list(prefixes)
+        )
+        self.sequence_length = sequence_length
+        self.inputs: list[np.memmap] = []
+        self.masks: list[np.memmap] = []
+        self.sequence_offsets: list[int] = []
+        running_total = 0
+        for raw_prefix in raw_prefixes:
+            prefix = Path(raw_prefix)
+            input_path = Path(str(prefix) + ".input_ids.bin")
+            mask_path = Path(str(prefix) + ".loss_mask.bin")
+            if not input_path.is_file() or not mask_path.is_file():
+                raise FileNotFoundError(
+                    f"Missing SFT pair: {input_path} and {mask_path}"
+                )
+            input_stream = np.memmap(input_path, mode="r", dtype=np.uint16)
+            mask_stream = np.memmap(mask_path, mode="r", dtype=np.uint8)
+            if len(input_stream) != len(mask_stream):
+                raise ValueError(f"Input/mask length mismatch for {prefix}")
+            if len(input_stream) % sequence_length != 0:
+                raise ValueError(f"SFT data is not record-aligned: {prefix}")
+            records = len(input_stream) // sequence_length
+            if records == 0:
+                raise ValueError(f"SFT data contains no records: {prefix}")
+            self.inputs.append(input_stream)
+            self.masks.append(mask_stream)
+            running_total += records
+            self.sequence_offsets.append(running_total)
+        if not self.inputs:
+            raise ValueError("At least one SFT data prefix is required")
+        self.num_sequences = running_total
+        self._affine_cache: dict[tuple[int, int], tuple[int, int]] = {}
+
+    def __len__(self) -> int:
+        return self.num_sequences
+
+    def _locate(self, index: int) -> tuple[int, int]:
+        if not 0 <= index < self.num_sequences:
+            raise IndexError(index)
+        previous = 0
+        for stream_index, end in enumerate(self.sequence_offsets):
+            if index < end:
+                return stream_index, index - previous
+            previous = end
+        raise IndexError(index)
+
+    def sequence(self, index: int) -> tuple[np.ndarray, np.ndarray]:
+        stream_index, local_index = self._locate(index)
+        start = local_index * self.sequence_length
+        stop = start + self.sequence_length
+        return (
+            np.asarray(self.inputs[stream_index][start:stop], dtype=np.int64),
+            np.asarray(self.masks[stream_index][start:stop], dtype=np.bool_),
+        )
+
+    def _affine_parameters(self, epoch: int, seed: int) -> tuple[int, int]:
+        key = (epoch, seed)
+        if key in self._affine_cache:
+            return self._affine_cache[key]
+        rng = np.random.default_rng(seed + epoch * 1_000_003)
+        multiplier = int(rng.integers(1, max(self.num_sequences, 2)))
+        while math.gcd(multiplier, self.num_sequences) != 1:
+            multiplier += 1
+            if multiplier >= self.num_sequences:
+                multiplier = 1
+        offset = int(rng.integers(0, self.num_sequences))
+        self._affine_cache[key] = (multiplier, offset)
+        return multiplier, offset
+
+    def training_batch(
+        self,
+        *,
+        micro_step: int,
+        batch_size: int,
+        rank: int,
+        world_size: int,
+        seed: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        global_batch_size = batch_size * world_size
+        first = micro_step * global_batch_size + rank * batch_size
+        indices = []
+        for local_index in range(batch_size):
+            ordinal = first + local_index
+            epoch, position = divmod(ordinal, self.num_sequences)
+            multiplier, offset = self._affine_parameters(epoch, seed)
+            indices.append((multiplier * position + offset) % self.num_sequences)
+        return self._to_tensors(indices, device)
+
+    def evaluation_batch(
+        self,
+        *,
+        batch_index: int,
+        batch_size: int,
+        rank: int,
+        world_size: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        first = (batch_index * world_size + rank) * batch_size
+        indices = [
+            (first + local_index) % self.num_sequences
+            for local_index in range(batch_size)
+        ]
+        return self._to_tensors(indices, device)
+
+    def _to_tensors(
+        self,
+        indices: list[int],
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        rows = [self.sequence(index) for index in indices]
+        inputs = torch.from_numpy(np.stack([row[0] for row in rows]))
+        masks = torch.from_numpy(np.stack([row[1] for row in rows]))
+        inputs = inputs.to(device=device, dtype=torch.long, non_blocking=True)
+        masks = masks.to(device=device, dtype=torch.bool, non_blocking=True)
+        labels = inputs.clone()
+        labels.masked_fill_(~masks, -100)
+        return inputs, labels
diff --git a/kawk50m/text.py b/kawk50m/text.py
new file mode 100644
index 0000000000000000000000000000000000000000..20fc1cedcf79840874c1a96077c1411fdc3dfa70
--- /dev/null
+++ b/kawk50m/text.py
@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import hashlib
+import html
+import math
+import re
+import unicodedata
+from dataclasses import asdict, dataclass
+
+
+HANGUL_RE = re.compile(r"[가-힣]")
+LATIN_RE = re.compile(r"[A-Za-z]")
+CJK_RE = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]")
+URL_RE = re.compile(r"(?:https?://|www\.)\S+", re.IGNORECASE)
+EMAIL_RE = re.compile(r"\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b")
+PHONE_RE = re.compile(r"(?<!\d)(?:\+?82[- ]?)?0?1[016789][ -]?\d{3,4}[ -]?\d{4}(?!\d)")
+RRN_RE = re.compile(r"(?<!\d)\d{6}[ -]?[1-4]\d{6}(?!\d)")
+SCRIPT_STYLE_RE = re.compile(
+    r"<(?:script|style)\b[^>]*>.*?</(?:script|style)>",
+    re.IGNORECASE | re.DOTALL,
+)
+HTML_TAG_RE = re.compile(r"<[^>\n]{1,500}>")
+MULTISPACE_RE = re.compile(r"[ \t]{2,}")
+MANY_NEWLINES_RE = re.compile(r"\n{3,}")
+CODE_LINE_RE = re.compile(
+    r"^\s*(?:"
+    r"(?:def|class|import|from|function|const|let|var|public|private)\s+"
+    r"|#include\b|package\s+\w+|using\s+namespace\b"
+    r"|[{}[\];]{2,}|</?\w+[^>]*>"
+    r")"
+)
+CODE_MATH_CHARS = frozenset("{}[]<>=+*/\\^_|~`$")
+WORD_RE = re.compile(r"[가-힣A-Za-z0-9]+")
+LIST_LINE_RE = re.compile(
+    r"^\s*(?:[-*•·▪◦▶▷■□]|(?:\d+|[가-힣A-Za-z])[.)])\s+"
+)
+BOILERPLATE_RE = re.compile(
+    r"(?:로그인|회원가입|개인정보\s*처리방침|이용약관|전체\s*메뉴|"
+    r"장바구니|상품\s*후기|배송\s*조회|쿠폰|고객\s*센터|"
+    r"무단\s*전재|재배포\s*금지|관련\s*기사|실시간\s*뉴스)"
+)
+REPEATED_CHARACTER_RE = re.compile(r"(.)\1+")
+NON_CONTENT_RE = re.compile(r"[\W_]+", re.UNICODE)
+
+
+@dataclass(slots=True)
+class FilterConfig:
+    min_chars: int = 300
+    max_chars: int = 100_000
+    min_hangul_chars: int = 50
+    min_hangul_letter_ratio: float = 0.70
+    min_hangul_visible_ratio: float = 0.55
+    max_digit_ratio: float = 0.08
+    max_symbol_ratio: float = 0.15
+    max_url_per_word: float = 0.01
+    min_unique_line_ratio: float = 0.70
+    min_unique_word_ratio: float = 0.20
+    max_short_line_ratio: float = 0.50
+    max_list_line_ratio: float = 0.25
+    max_table_line_ratio: float = 0.10
+    max_boilerplate_hits_per_1k: float = 1.5
+    max_repeated_character_run: int = 20
+    max_code_line_ratio: float = 0.25
+    max_code_math_char_ratio: float = 0.15
+    min_quality_score: float = 0.70
+    strip_html: bool = True
+    mask_pii: bool = True
+
+
+@dataclass(slots=True)
+class TextMetrics:
+    characters: int
+    visible_characters: int
+    hangul_characters: int
+    latin_characters: int
+    cjk_characters: int
+    digit_characters: int
+    symbol_characters: int
+    hangul_letter_ratio: float
+    hangul_visible_ratio: float
+    digit_ratio: float
+    symbol_ratio: float
+    url_per_word: float
+    unique_line_ratio: float
+    unique_word_ratio: float
+    short_line_ratio: float
+    list_line_ratio: float
+    table_line_ratio: float
+    boilerplate_hits_per_1k: float
+    repeated_character_run: int
+    code_line_ratio: float
+    code_math_char_ratio: float
+
+    def to_dict(self) -> dict[str, int | float]:
+        return asdict(self)
+
+
+def normalize_text(
+    text: str,
+    *,
+    strip_html: bool = True,
+    mask_pii: bool = True,
+) -> str:
+    if not isinstance(text, str):
+        raise TypeError(f"text must be str, got {type(text).__name__}")
+
+    text = unicodedata.normalize("NFC", text)
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = text.replace("\u00a0", " ").replace("\u200b", "")
+    text = text.replace("\u200c", "").replace("\u200d", "")
+    text = "".join(
+        character
+        for character in text
+        if character in "\n\t" or unicodedata.category(character) != "Cc"
+    )
+
+    if strip_html:
+        text = SCRIPT_STYLE_RE.sub(" ", text)
+        text = HTML_TAG_RE.sub(" ", text)
+        text = html.unescape(text)
+
+    if mask_pii:
+        text = EMAIL_RE.sub("<EMAIL>", text)
+        text = PHONE_RE.sub("<PHONE>", text)
+        text = RRN_RE.sub("<RRN>", text)
+
+    lines = [MULTISPACE_RE.sub(" ", line).strip() for line in text.splitlines()]
+    text = "\n".join(line for line in lines if line)
+    text = MANY_NEWLINES_RE.sub("\n\n", text)
+    return text.strip()
+
+
+def measure_text(text: str) -> TextMetrics:
+    visible = [character for character in text if not character.isspace()]
+    hangul_count = len(HANGUL_RE.findall(text))
+    latin_count = len(LATIN_RE.findall(text))
+    cjk_count = len(CJK_RE.findall(text))
+    digit_count = sum(character.isdigit() for character in visible)
+    symbol_count = sum(
+        unicodedata.category(character).startswith(("P", "S"))
+        for character in visible
+    )
+    letter_count = hangul_count + latin_count + cjk_count
+    lines = [line for line in text.splitlines() if line.strip()]
+    words = text.split()
+    content_words = WORD_RE.findall(text.casefold())
+    code_lines = sum(bool(CODE_LINE_RE.search(line)) for line in lines)
+    code_math_count = sum(character in CODE_MATH_CHARS for character in visible)
+    short_lines = sum(len(line.strip()) < 20 for line in lines)
+    list_lines = sum(bool(LIST_LINE_RE.search(line)) for line in lines)
+    table_lines = sum(line.count("|") >= 2 for line in lines)
+    boilerplate_hits = len(BOILERPLATE_RE.findall(text))
+    repeated_runs = [
+        len(match.group(0)) for match in REPEATED_CHARACTER_RE.finditer(text)
+    ]
+
+    return TextMetrics(
+        characters=len(text),
+        visible_characters=len(visible),
+        hangul_characters=hangul_count,
+        latin_characters=latin_count,
+        cjk_characters=cjk_count,
+        digit_characters=digit_count,
+        symbol_characters=symbol_count,
+        hangul_letter_ratio=hangul_count / max(letter_count, 1),
+        hangul_visible_ratio=hangul_count / max(len(visible), 1),
+        digit_ratio=digit_count / max(len(visible), 1),
+        symbol_ratio=symbol_count / max(len(visible), 1),
+        url_per_word=len(URL_RE.findall(text)) / max(len(words), 1),
+        unique_line_ratio=len(set(lines)) / max(len(lines), 1),
+        unique_word_ratio=len(set(content_words)) / max(len(content_words), 1),
+        short_line_ratio=short_lines / max(len(lines), 1),
+        list_line_ratio=list_lines / max(len(lines), 1),
+        table_line_ratio=table_lines / max(len(lines), 1),
+        boilerplate_hits_per_1k=boilerplate_hits * 1000 / max(len(text), 1),
+        repeated_character_run=max(repeated_runs, default=1),
+        code_line_ratio=code_lines / max(len(lines), 1),
+        code_math_char_ratio=code_math_count / max(len(visible), 1),
+    )
+
+
+def rejection_reason(
+    text: str,
+    config: FilterConfig,
+    *,
+    metrics: TextMetrics | None = None,
+) -> str | None:
+    metrics = metrics or measure_text(text)
+    if metrics.characters < config.min_chars:
+        return "too_short"
+    if metrics.characters > config.max_chars:
+        return "too_long"
+    if metrics.hangul_characters < config.min_hangul_chars:
+        return "too_little_hangul"
+    if metrics.hangul_letter_ratio < config.min_hangul_letter_ratio:
+        return "low_hangul_letter_ratio"
+    if metrics.hangul_visible_ratio < config.min_hangul_visible_ratio:
+        return "low_hangul_visible_ratio"
+    if metrics.digit_ratio > config.max_digit_ratio:
+        return "digit_heavy"
+    if metrics.symbol_ratio > config.max_symbol_ratio:
+        return "symbol_heavy"
+    if metrics.repeated_character_run > config.max_repeated_character_run:
+        return "repeated_character_run"
+    if metrics.url_per_word > config.max_url_per_word:
+        return "too_many_urls"
+    if (
+        len(text.splitlines()) >= 5
+        and metrics.unique_line_ratio < config.min_unique_line_ratio
+    ):
+        return "repeated_lines"
+    if len(WORD_RE.findall(text)) >= 100 and (
+        metrics.unique_word_ratio < config.min_unique_word_ratio
+    ):
+        return "low_unique_word_ratio"
+    if (
+        len(text.splitlines()) >= 8
+        and metrics.short_line_ratio > config.max_short_line_ratio
+    ):
+        return "short_line_heavy"
+    if (
+        len(text.splitlines()) >= 8
+        and metrics.list_line_ratio > config.max_list_line_ratio
+    ):
+        return "list_heavy"
+    if (
+        len(text.splitlines()) >= 4
+        and metrics.table_line_ratio > config.max_table_line_ratio
+    ):
+        return "table_heavy"
+    if metrics.boilerplate_hits_per_1k > config.max_boilerplate_hits_per_1k:
+        return "boilerplate_heavy"
+    if (
+        len(text.splitlines()) >= 4
+        and metrics.code_line_ratio > config.max_code_line_ratio
+    ):
+        return "code_heavy"
+    if metrics.code_math_char_ratio > config.max_code_math_char_ratio:
+        return "code_or_math_heavy"
+    if quality_score(metrics, config) < config.min_quality_score:
+        return "low_quality_score"
+    return None
+
+
+def quality_score(metrics: TextMetrics, config: FilterConfig) -> float:
+    """Return a conservative 0..1 heuristic used for corpus auditing."""
+    hangul_score = min(
+        1.0,
+        metrics.hangul_visible_ratio
+        / max(config.min_hangul_visible_ratio * 1.5, 1e-9),
+    )
+    digit_score = max(
+        0.0,
+        1.0
+        - metrics.digit_ratio / max(config.max_digit_ratio * 2.0, 1e-9),
+    )
+    symbol_score = max(
+        0.0,
+        1.0
+        - metrics.symbol_ratio / max(config.max_symbol_ratio * 2.0, 1e-9),
+    )
+    line_score = min(1.0, metrics.unique_line_ratio)
+    word_score = min(1.0, metrics.unique_word_ratio / 0.50)
+    score = (
+        0.35 * hangul_score
+        + 0.20 * digit_score
+        + 0.15 * symbol_score
+        + 0.15 * line_score
+        + 0.15 * word_score
+    )
+    return max(0.0, min(1.0, score))
+
+
+def near_duplicate_signature(text: str, *, sketch_size: int = 4) -> str:
+    """Build a bottom-k paragraph/chunk sketch for conservative near deduplication."""
+    if sketch_size <= 0:
+        raise ValueError("sketch_size must be positive")
+
+    canonical_blocks: list[str] = []
+    for paragraph in re.split(r"\n+", text):
+        canonical = NON_CONTENT_RE.sub("", paragraph.casefold())
+        if len(canonical) < 40:
+            continue
+        if len(canonical) <= 320:
+            canonical_blocks.append(canonical)
+            continue
+        for start in range(0, len(canonical), 240):
+            chunk = canonical[start : start + 320]
+            if len(chunk) >= 80:
+                canonical_blocks.append(chunk)
+
+    if not canonical_blocks:
+        canonical = NON_CONTENT_RE.sub("", text.casefold())
+        canonical_blocks = [
+            canonical[start : start + 320]
+            for start in range(0, len(canonical), 240)
+            if len(canonical[start : start + 320]) >= 40
+        ]
+
+    fingerprints = sorted(
+        {
+            hashlib.blake2b(
+                block.encode("utf-8"), digest_size=8, person=b"kawk-v2"
+            ).hexdigest()
+            for block in canonical_blocks
+        }
+    )
+    length_bucket = int(math.log2(max(len(text), 1)) * 4)
+    selected = fingerprints[:sketch_size]
+    return f"{length_bucket}:" + ":".join(selected)
+
+
+def canonical_hash(text: str) -> str:
+    canonical = " ".join(text.casefold().split())
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def split_for_hash(
+    document_hash: str,
+    *,
+    validation_ratio: float,
+    test_ratio: float,
+    seed: int,
+) -> str:
+    if validation_ratio < 0 or test_ratio < 0:
+        raise ValueError("split ratios must be non-negative")
+    if validation_ratio + test_ratio >= 1:
+        raise ValueError("validation_ratio + test_ratio must be less than 1")
+    digest = hashlib.blake2b(
+        f"{seed}:{document_hash}".encode("ascii"), digest_size=8
+    ).digest()
+    value = int.from_bytes(digest, "big") / 2**64
+    if value < test_ratio:
+        return "test"
+    if value < test_ratio + validation_ratio:
+        return "validation"
+    return "train"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2b521ac12a4fb35f886b31693fbb2de3006a1c3e
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kawk50m"
+version = "0.1.0"
+description = "Korean-first 50M parameter Llama pretraining toolkit"
+requires-python = ">=3.10"
+dependencies = [
+  "torch>=2.4,<3",
+  "transformers>=4.48,<5",
+  "sentencepiece>=0.2,<1",
+  "protobuf>=4.25,<7",
+  "PyYAML>=6,<7",
+  "numpy>=1.26,<3",
+  "safetensors>=0.4,<1",
+  "tqdm>=4.66,<5",
+]
+
+[tool.setuptools.packages.find]
+include = ["kawk50m*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
diff --git a/reports/fixed-ko-cpt-3b-5k/byte-evaluation.json b/reports/fixed-ko-cpt-3b-5k/byte-evaluation.json
new file mode 100644
index 0000000000000000000000000000000000000000..4f7cdcab3de3299baf1e3b72e9dac894147b0874
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/byte-evaluation.json
@@ -0,0 +1,17 @@
+{
+  "checkpoint": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+  "tokenizer": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415/tokenizer",
+  "inputs": [
+    "/workspace/KAWK50M/data/clean-v2-full/validation-00000.jsonl"
+  ],
+  "documents": 500,
+  "characters": 792512,
+  "utf8_bytes": 1888545,
+  "predicted_tokens": 418575,
+  "context_length": 5120,
+  "token_nll": 2.8587026298034006,
+  "token_perplexity": 17.438887560946455,
+  "nats_per_character": 1.5098590977423163,
+  "bits_per_utf8_byte": 0.9140910746909807,
+  "note": "Compare bits_per_utf8_byte only when checkpoints are evaluated on the exact same ordered raw-text documents."
+}
diff --git a/reports/fixed-ko-cpt-3b-5k/evaluation.json b/reports/fixed-ko-cpt-3b-5k/evaluation.json
new file mode 100644
index 0000000000000000000000000000000000000000..6387ebf26ea86273414e09ee11dafaa9ed33e705
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/evaluation.json
@@ -0,0 +1,30 @@
+{
+  "checkpoint": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+  "tokenizer": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415/tokenizer",
+  "validation_loss": 2.8582549810409548,
+  "validation_perplexity": 17.431082811534903,
+  "evaluated_tokens": 409600,
+  "samples": [
+    {
+      "prompt": "대한민국의 수도는",
+      "continuation": "그 자체로 하나의 문화유산과 문화역사를 품고 있다.\n그 중에서도 ‘조선왕조실록’은 조선왕조실록을 대표하는 자료로써, 역사적 사실을 간직한 역사의 현장이며, 그 유적들이 현대에 이르러서는 더욱 획기적으로 발전하고 있는 것으로 평가되고 있다. 특히 1970년대에 들어와서 그 실황이 확증되면서 6.25전쟁으로 인해 유포된 조선왕조실록이 다시 활기를 되찾게 되었다. 이렇듯 조선왕조실록은 현재도 계속되고 있으며, 13세기 전반부터 18세기 후반까지 그 유물이 수집되어져 오고 있다.\n그러나 이러한 사실들은 아직까지 제대로 보고된 바가 없다. 다만 일부 자료만이 3D영상자료로 대체될 뿐이며, 그 중에서도 현재의 유물들은 모두 ‘한국사’라는 책자에서 확인가능하다.",
+      "full_text": "대한민국의 수도는그 자체로 하나의 문화유산과 문화역사를 품고 있다.\n그 중에서도 ‘조선왕조실록’은 조선왕조실록을 대표하는 자료로써, 역사적 사실을 간직한 역사의 현장이며, 그 유적들이 현대에 이르러서는 더욱 획기적으로 발전하고 있는 것으로 평가되고 있다. 특히 1970년대에 들어와서 그 실황이 확증되면서 6.25전쟁으로 인해 유포된 조선왕조실록이 다시 활기를 되찾게 되었다. 이렇듯 조선왕조실록은 현재도 계속되고 있으며, 13세기 전반부터 18세기 후반까지 그 유물이 수집되어져 오고 있다.\n그러나 이러한 사실들은 아직까지 제대로 보고된 바가 없다. 다만 일부 자료만이 3D영상자료로 대체될 뿐이며, 그 중에서도 현재의 유물들은 모두 ‘한국사’라는 책자에서 확인가능하다."
+    },
+    {
+      "prompt": "오늘 아침에 일어나서",
+      "continuation": "13일 동안 잠을 잘 수가 없었다. 그런데 새벽에 일어나서 내가 잠이 안 들어 잠들기가 쉽지 않았다. 새벽에 일어나서 10분 정도 자고 일어나면 일어나기 어려울 정도의 피곤함이 몰려왔다. 그래서 나는 새벽에 일어나서 15분 정도 자는 것으로 새벽에 일어날 수 있는 시간을 잡으려 했다. 그리고 4시쯤에 일어나서 2시간 정도 자고 일어나니 잠이 안 들었다. 아침에 일어나서 15분 정도 자고 일어나니 피곤함이 싹 사라져 있었다.\n그런데 새벽에 일어난 것이 너무너무 힘들었다. 아침에 일어나서 10분 정도 자고 일어나니 피곤함도 많이 사라졌다. 밤에 일어나서 잠을 못 잤는데 새벽에 일어나서 10분 정도 자고 일어나니 피곤함도 많이 사라졌다. 그래서 7월의 마지막 주말에는 낮잠을 잔다고 생각했는데, 오늘도 잠을 못",
+      "full_text": "오늘 아침에 일어나서13일 동안 잠을 잘 수가 없었다. 그런데 새벽에 일어나서 내가 잠이 안 들어 잠들기가 쉽지 않았다. 새벽에 일어나서 10분 정도 자고 일어나면 일어나기 어려울 정도의 피곤함이 몰려왔다. 그래서 나는 새벽에 일어나서 15분 정도 자는 것으로 새벽에 일어날 수 있는 시간을 잡으려 했다. 그리고 4시쯤에 일어나서 2시간 정도 자고 일어나니 잠이 안 들었다. 아침에 일어나서 15분 정도 자고 일어나니 피곤함이 싹 사라져 있었다.\n그런데 새벽에 일어난 것이 너무너무 힘들었다. 아침에 일어나서 10분 정도 자고 일어나니 피곤함도 많이 사라졌다. 밤에 일어나서 잠을 못 잤는데 새벽에 일어나서 10분 정도 자고 일어나니 피곤함도 많이 사라졌다. 그래서 7월의 마지막 주말에는 낮잠을 잔다고 생각했는데, 오늘도 잠을 못"
+    },
+    {
+      "prompt": "인공지능 언어 모델은",
+      "continuation": "딥러닝을 사용하여 컴퓨터가 학습한 패턴의 모델을 학습하는 모델이다.\n이 모델은 여러 사람이 사용하는 컴퓨터에 의존하지 않고, 사용자가 입력한 데이터와 기계학습 알고리즘이 서로 상호 작용할 수 있는 학습 환경인 딥러닝을 기반으로 한다.\n* **예시:** A는 “아무도 없는 환경에서 10만 개의 데이터 세트를 분석하고, 9억 개의 데이터를 학습하고 있습니다.”\n**[요약]**\n해당 모델은 AI가 학습한 패턴을 머신 러닝으로 학습하여, 컴퓨터가 학습한 패턴의 모델을 학습할 때 발생하는 문제나 코딩 오류를 사전에 방지한다. 또한 학습된 데이터셋을 분석하여 학습 모델을 훈련할 수 있다.",
+      "full_text": "인공지능 언어 모델은딥러닝을 사용하여 컴퓨터가 학습한 패턴의 모델을 학습하는 모델이다.\n이 모델은 여러 사람이 사용하는 컴퓨터에 의존하지 않고, 사용자가 입력한 데이터와 기계학습 알고리즘이 서로 상호 작용할 수 있는 학습 환경인 딥러닝을 기반으로 한다.\n* **예시:** A는 “아무도 없는 환경에서 10만 개의 데이터 세트를 분석하고, 9억 개의 데이터를 학습하고 있습니다.”\n**[요약]**\n해당 모델은 AI가 학습한 패턴을 머신 러닝으로 학습하여, 컴퓨터가 학습한 패턴의 모델을 학습할 때 발생하는 문제나 코딩 오류를 사전에 방지한다. 또한 학습된 데이터셋을 분석하여 학습 모델을 훈련할 수 있다."
+    },
+    {
+      "prompt": "비가 내리는 날에는",
+      "continuation": "햇빛이 반사되어 차분한 오후의 분위기를 연출한다.\n[경기도민일보 인천=김용국기자] 인천 남동구는 지난 12일 관내 사회복지시설을 대상으로 아동학대 예방과 위기청소년 지원에 대한 인식 제고를 위한 ‘아동학대 예방교육’을 실시했다.이번 교육은 아동학대 예방을 위해 가정 내 아동학대를 인식하고 아동학대 사례관리 및 상담사례 공유, 아동보호자 상담 및 보호조치 방법 등을 안내하는 내용으로 진행됐다.이날 교육을 받은 한 아동복지시설은 “아이들에게 도움을 주기 위해 아동학대가 의심될 때, ‘아빠는 엄마다’라는 말을 하는 경우가 많다”며 “언제든지 아동을 찾을 수 있도록 가정 내 아동학대 예방을 위한 지속적인 관심을 가져주시길 바란다”라고 전했다.",
+      "full_text": "비가 내리는 날에는햇빛이 반사되어 차분한 오후의 분위기를 연출한다.\n[경기도민일보 인천=김용국기자] 인천 남동구는 지난 12일 관내 사회복지시설을 대상으로 아동학대 예방과 위기청소년 지원에 대한 인식 제고를 위한 ‘아동학대 예방교육’을 실시했다.이번 교육은 아동학대 예방을 위해 가정 내 아동학대를 인식하고 아동학대 사례관리 및 상담사례 공유, 아동보호자 상담 및 보호조치 방법 등을 안내하는 내용으로 진행됐다.이날 교육을 받은 한 아동복지시설은 “아이들에게 도움을 주기 위해 아동학대가 의심될 때, ‘아빠는 엄마다’라는 말을 하는 경우가 많다”며 “언제든지 아동을 찾을 수 있도록 가정 내 아동학대 예방을 위한 지속적인 관심을 가져주시길 바란다”라고 전했다."
+    }
+  ],
+  "note": "This is a base-model continuation evaluation, not instruction QA."
+}
diff --git a/reports/fixed-ko-cpt-3b-5k/final_checkpoint.txt b/reports/fixed-ko-cpt-3b-5k/final_checkpoint.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d2ba0911903ac85b32176a4a515f5ca92867f2a
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/final_checkpoint.txt
@@ -0,0 +1 @@
+runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415
diff --git a/reports/fixed-ko-cpt-3b-5k/gate.json b/reports/fixed-ko-cpt-3b-5k/gate.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7fa6a083b86cd1dc37d84edddf643ac85dab5fe
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/gate.json
@@ -0,0 +1,7 @@
+{
+  "passed": true,
+  "candidate_loss": 2.8582549810409548,
+  "baseline_loss": null,
+  "loss_improvement": null,
+  "sample_count": 4
+}
diff --git a/reports/fixed-ko-cpt-3b-5k/position-bucket-evaluation.json b/reports/fixed-ko-cpt-3b-5k/position-bucket-evaluation.json
new file mode 100644
index 0000000000000000000000000000000000000000..eda24d14b17413c052c2da0396a5b1e900f07179
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/position-bucket-evaluation.json
@@ -0,0 +1,46 @@
+{
+  "checkpoint": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+  "validation_bin": "/workspace/KAWK50M/data/tokenized-v2-cpt-3b/validation.bin",
+  "sequence_length": 5120,
+  "bucket_size": 1024,
+  "evaluated_tokens": 102380,
+  "loss": 2.9305559042446037,
+  "perplexity": 18.738044160189084,
+  "buckets": [
+    {
+      "start_position": 1,
+      "end_position": 1024,
+      "tokens": 20480,
+      "loss": 2.9409491062164306,
+      "perplexity": 18.933807981996924
+    },
+    {
+      "start_position": 1025,
+      "end_position": 2048,
+      "tokens": 20480,
+      "loss": 2.8075664043426514,
+      "perplexity": 16.56954553925456
+    },
+    {
+      "start_position": 2049,
+      "end_position": 3072,
+      "tokens": 20480,
+      "loss": 2.9897894978523256,
+      "perplexity": 19.88149695324014
+    },
+    {
+      "start_position": 3073,
+      "end_position": 4096,
+      "tokens": 20480,
+      "loss": 2.9651451110839844,
+      "perplexity": 19.397517832091484
+    },
+    {
+      "start_position": 4097,
+      "end_position": 5119,
+      "tokens": 20460,
+      "loss": 2.9493477531425647,
+      "perplexity": 19.093495993155035
+    }
+  ]
+}
diff --git a/reports/fixed-ko-cpt-3b-5k/train.log b/reports/fixed-ko-cpt-3b-5k/train.log
new file mode 100644
index 0000000000000000000000000000000000000000..4829ef1f1ae87a46ca7cc89260c5d12f6033c66f
--- /dev/null
+++ b/reports/fixed-ko-cpt-3b-5k/train.log
@@ -0,0 +1,532 @@
+{
+  "parameters": 51542528,
+  "device": "cuda:0",
+  "world_size": 1,
+  "sequence_length": 5120,
+  "training_sample_offset": 0,
+  "tokens_per_optimizer_step": 122880,
+  "max_steps": 24415,
+  "planned_tokens": 3000115200,
+  "start_step": 0,
+  "initialized_from": "/workspace/KAWK50M/runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147",
+  "precision": "bf16",
+  "compile": true
+}
+{"step": 1, "max_steps": 24415, "train_loss": 8.144108, "learning_rate": 3.0737704918032784e-07, "grad_norm": 65.61449432373047, "tokens_seen": 122880, "tokens_per_second": 36373}
+{"step": 50, "max_steps": 24415, "train_loss": 5.261077, "learning_rate": 1.5368852459016393e-05, "grad_norm": 2.527670383453369, "tokens_seen": 6144000, "tokens_per_second": 115796}
+{"step": 100, "max_steps": 24415, "train_loss": 4.557536, "learning_rate": 3.073770491803279e-05, "grad_norm": 2.5450265407562256, "tokens_seen": 12288000, "tokens_per_second": 115654}
+{"step": 150, "max_steps": 24415, "train_loss": 3.998088, "learning_rate": 4.610655737704918e-05, "grad_norm": 2.4517602920532227, "tokens_seen": 18432000, "tokens_per_second": 115644}
+{"step": 200, "max_steps": 24415, "train_loss": 3.411813, "learning_rate": 6.147540983606557e-05, "grad_norm": 1.9274886846542358, "tokens_seen": 24576000, "tokens_per_second": 115607}
+{"step": 250, "max_steps": 24415, "train_loss": 3.153503, "learning_rate": 7.684426229508196e-05, "grad_norm": 1.9783965349197388, "tokens_seen": 30720000, "tokens_per_second": 115566}
+{"step": 300, "max_steps": 24415, "train_loss": 3.199131, "learning_rate": 9.221311475409836e-05, "grad_norm": 1.3728467226028442, "tokens_seen": 36864000, "tokens_per_second": 115581}
+{"step": 350, "max_steps": 24415, "train_loss": 3.044291, "learning_rate": 0.00010758196721311473, "grad_norm": 1.6034692525863647, "tokens_seen": 43008000, "tokens_per_second": 115596}
+{"step": 400, "max_steps": 24415, "train_loss": 3.029246, "learning_rate": 0.00012295081967213115, "grad_norm": 1.4586750268936157, "tokens_seen": 49152000, "tokens_per_second": 115629}
+{"step": 450, "max_steps": 24415, "train_loss": 2.942982, "learning_rate": 0.00013831967213114753, "grad_norm": 0.9969210028648376, "tokens_seen": 55296000, "tokens_per_second": 115644}
+{"step": 500, "max_steps": 24415, "train_loss": 3.001114, "learning_rate": 0.00014999991621632118, "grad_norm": 1.1246283054351807, "tokens_seen": 61440000, "tokens_per_second": 115624}
+{"step": 550, "max_steps": 24415, "train_loss": 2.900805, "learning_rate": 0.00014999776345312908, "grad_norm": 1.0763027667999268, "tokens_seen": 67584000, "tokens_per_second": 115617}
+{"step": 600, "max_steps": 24415, "train_loss": 2.919337, "learning_rate": 0.00014999270164066104, "grad_norm": 0.8842090368270874, "tokens_seen": 73728000, "tokens_per_second": 115626}
+{"step": 650, "max_steps": 24415, "train_loss": 2.896405, "learning_rate": 0.00014998473099707337, "grad_norm": 0.8379791378974915, "tokens_seen": 79872000, "tokens_per_second": 115637}
+{"step": 700, "max_steps": 24415, "train_loss": 2.799349, "learning_rate": 0.00014997385186588848, "grad_norm": 0.8146543502807617, "tokens_seen": 86016000, "tokens_per_second": 115635}
+{"step": 750, "max_steps": 24415, "train_loss": 2.928234, "learning_rate": 0.00014996006471598011, "grad_norm": 0.8336044549942017, "tokens_seen": 92160000, "tokens_per_second": 115613}
+{"step": 800, "max_steps": 24415, "train_loss": 2.825323, "learning_rate": 0.00014994337014155313, "grad_norm": 0.9470697045326233, "tokens_seen": 98304000, "tokens_per_second": 115612}
+{"step": 850, "max_steps": 24415, "train_loss": 2.879508, "learning_rate": 0.00014992376886211787, "grad_norm": 0.8570364713668823, "tokens_seen": 104448000, "tokens_per_second": 115616}
+{"step": 900, "max_steps": 24415, "train_loss": 2.905575, "learning_rate": 0.0001499012617224592, "grad_norm": 0.7632439136505127, "tokens_seen": 110592000, "tokens_per_second": 115640}
+{"step": 950, "max_steps": 24415, "train_loss": 2.864619, "learning_rate": 0.00014987584969259997, "grad_norm": 0.7789876461029053, "tokens_seen": 116736000, "tokens_per_second": 115639}
+{"step": 1000, "max_steps": 24415, "train_loss": 2.931551, "learning_rate": 0.0001498475338677595, "grad_norm": 0.8311377167701721, "tokens_seen": 122880000, "tokens_per_second": 115646}
+{"step": 1000, "validation_loss": 2.96824, "validation_perplexity": 19.4577}
+{"step": 1050, "max_steps": 24415, "train_loss": 2.925203, "learning_rate": 0.00014981631546830604, "grad_norm": 0.7916623950004578, "tokens_seen": 129024000, "tokens_per_second": 109465}
+{"step": 1100, "max_steps": 24415, "train_loss": 2.899991, "learning_rate": 0.00014978219583970429, "grad_norm": 0.7494450211524963, "tokens_seen": 135168000, "tokens_per_second": 115661}
+{"step": 1150, "max_steps": 24415, "train_loss": 2.859691, "learning_rate": 0.00014974517645245758, "grad_norm": 0.8097645044326782, "tokens_seen": 141312000, "tokens_per_second": 115689}
+{"step": 1200, "max_steps": 24415, "train_loss": 2.78326, "learning_rate": 0.00014970525890204428, "grad_norm": 0.8151496052742004, "tokens_seen": 147456000, "tokens_per_second": 115671}
+{"step": 1250, "max_steps": 24415, "train_loss": 2.912475, "learning_rate": 0.00014966244490884908, "grad_norm": 0.7340596914291382, "tokens_seen": 153600000, "tokens_per_second": 115662}
+{"step": 1300, "max_steps": 24415, "train_loss": 2.836194, "learning_rate": 0.0001496167363180889, "grad_norm": 0.869087278842926, "tokens_seen": 159744000, "tokens_per_second": 115640}
+{"step": 1350, "max_steps": 24415, "train_loss": 2.880843, "learning_rate": 0.00014956813509973336, "grad_norm": 0.9172841310501099, "tokens_seen": 165888000, "tokens_per_second": 115639}
+{"step": 1400, "max_steps": 24415, "train_loss": 2.907881, "learning_rate": 0.00014951664334841988, "grad_norm": 0.8426065444946289, "tokens_seen": 172032000, "tokens_per_second": 115641}
+{"step": 1450, "max_steps": 24415, "train_loss": 2.75049, "learning_rate": 0.00014946226328336332, "grad_norm": 0.7333223819732666, "tokens_seen": 178176000, "tokens_per_second": 115649}
+{"step": 1500, "max_steps": 24415, "train_loss": 2.902985, "learning_rate": 0.00014940499724826046, "grad_norm": 0.6550875306129456, "tokens_seen": 184320000, "tokens_per_second": 115621}
+{"step": 1550, "max_steps": 24415, "train_loss": 2.808746, "learning_rate": 0.00014934484771118885, "grad_norm": 0.9193676114082336, "tokens_seen": 190464000, "tokens_per_second": 115628}
+{"step": 1600, "max_steps": 24415, "train_loss": 2.813932, "learning_rate": 0.00014928181726450062, "grad_norm": 0.6951905488967896, "tokens_seen": 196608000, "tokens_per_second": 115653}
+{"step": 1650, "max_steps": 24415, "train_loss": 2.858552, "learning_rate": 0.0001492159086247106, "grad_norm": 0.8277786374092102, "tokens_seen": 202752000, "tokens_per_second": 115640}
+{"step": 1700, "max_steps": 24415, "train_loss": 2.82544, "learning_rate": 0.00014914712463237923, "grad_norm": 0.6503491997718811, "tokens_seen": 208896000, "tokens_per_second": 115643}
+{"step": 1750, "max_steps": 24415, "train_loss": 2.93095, "learning_rate": 0.00014907546825199033, "grad_norm": 0.6746272444725037, "tokens_seen": 215040000, "tokens_per_second": 115593}
+{"step": 1800, "max_steps": 24415, "train_loss": 2.918631, "learning_rate": 0.00014900094257182313, "grad_norm": 0.681274950504303, "tokens_seen": 221184000, "tokens_per_second": 115624}
+{"step": 1850, "max_steps": 24415, "train_loss": 2.732643, "learning_rate": 0.0001489235508038192, "grad_norm": 1.0000346899032593, "tokens_seen": 227328000, "tokens_per_second": 115644}
+{"step": 1900, "max_steps": 24415, "train_loss": 2.784161, "learning_rate": 0.00014884329628344416, "grad_norm": 0.7131108045578003, "tokens_seen": 233472000, "tokens_per_second": 115619}
+{"step": 1950, "max_steps": 24415, "train_loss": 2.867771, "learning_rate": 0.0001487601824695438, "grad_norm": 0.6672623157501221, "tokens_seen": 239616000, "tokens_per_second": 115612}
+{"step": 2000, "max_steps": 24415, "train_loss": 2.88868, "learning_rate": 0.000148674212944195, "grad_norm": 0.6188545227050781, "tokens_seen": 245760000, "tokens_per_second": 115613}
+{"step": 2000, "validation_loss": 2.957756, "validation_perplexity": 19.2547}
+{"step": 2050, "max_steps": 24415, "train_loss": 2.848936, "learning_rate": 0.00014858539141255145, "grad_norm": 0.6768792867660522, "tokens_seen": 251904000, "tokens_per_second": 113459}
+{"step": 2100, "max_steps": 24415, "train_loss": 2.911329, "learning_rate": 0.00014849372170268386, "grad_norm": 0.7390404343605042, "tokens_seen": 258048000, "tokens_per_second": 115657}
+{"step": 2150, "max_steps": 24415, "train_loss": 2.7573, "learning_rate": 0.00014839920776541505, "grad_norm": 0.7121871709823608, "tokens_seen": 264192000, "tokens_per_second": 115647}
+{"step": 2200, "max_steps": 24415, "train_loss": 2.712324, "learning_rate": 0.00014830185367414961, "grad_norm": 0.6592078804969788, "tokens_seen": 270336000, "tokens_per_second": 115660}
+{"step": 2250, "max_steps": 24415, "train_loss": 2.879639, "learning_rate": 0.00014820166362469842, "grad_norm": 0.7398443222045898, "tokens_seen": 276480000, "tokens_per_second": 115657}
+{"step": 2300, "max_steps": 24415, "train_loss": 2.785928, "learning_rate": 0.0001480986419350977, "grad_norm": 0.7555476427078247, "tokens_seen": 282624000, "tokens_per_second": 115677}
+{"step": 2350, "max_steps": 24415, "train_loss": 2.75432, "learning_rate": 0.00014799279304542314, "grad_norm": 0.7762490510940552, "tokens_seen": 288768000, "tokens_per_second": 115702}
+{"step": 2400, "max_steps": 24415, "train_loss": 2.971488, "learning_rate": 0.00014788412151759816, "grad_norm": 0.64515620470047, "tokens_seen": 294912000, "tokens_per_second": 115659}
+{"step": 2450, "max_steps": 24415, "train_loss": 2.837723, "learning_rate": 0.00014777263203519768, "grad_norm": 0.7510269284248352, "tokens_seen": 301056000, "tokens_per_second": 115677}
+{"step": 2500, "max_steps": 24415, "train_loss": 2.888861, "learning_rate": 0.00014765832940324614, "grad_norm": 0.6924780607223511, "tokens_seen": 307200000, "tokens_per_second": 115656}
+{"step": 2550, "max_steps": 24415, "train_loss": 2.793462, "learning_rate": 0.00014754121854801018, "grad_norm": 0.69148188829422, "tokens_seen": 313344000, "tokens_per_second": 115646}
+{"step": 2600, "max_steps": 24415, "train_loss": 2.906426, "learning_rate": 0.00014742130451678674, "grad_norm": 0.7049274444580078, "tokens_seen": 319488000, "tokens_per_second": 115640}
+{"step": 2650, "max_steps": 24415, "train_loss": 2.913443, "learning_rate": 0.00014729859247768516, "grad_norm": 0.682880163192749, "tokens_seen": 325632000, "tokens_per_second": 115638}
+{"step": 2700, "max_steps": 24415, "train_loss": 2.857629, "learning_rate": 0.00014717308771940472, "grad_norm": 0.6135403513908386, "tokens_seen": 331776000, "tokens_per_second": 115655}
+{"step": 2750, "max_steps": 24415, "train_loss": 2.883287, "learning_rate": 0.00014704479565100643, "grad_norm": 0.6782547831535339, "tokens_seen": 337920000, "tokens_per_second": 115658}
+{"step": 2800, "max_steps": 24415, "train_loss": 2.860058, "learning_rate": 0.0001469137218016802, "grad_norm": 0.7186660766601562, "tokens_seen": 344064000, "tokens_per_second": 115661}
+{"step": 2850, "max_steps": 24415, "train_loss": 2.853855, "learning_rate": 0.00014677987182050632, "grad_norm": 0.6767726540565491, "tokens_seen": 350208000, "tokens_per_second": 115653}
+{"step": 2900, "max_steps": 24415, "train_loss": 2.86035, "learning_rate": 0.00014664325147621213, "grad_norm": 0.6750748753547668, "tokens_seen": 356352000, "tokens_per_second": 115655}
+{"step": 2950, "max_steps": 24415, "train_loss": 2.855024, "learning_rate": 0.00014650386665692323, "grad_norm": 0.7292869091033936, "tokens_seen": 362496000, "tokens_per_second": 115648}
+{"step": 3000, "max_steps": 24415, "train_loss": 2.808876, "learning_rate": 0.00014636172336990991, "grad_norm": 0.6982874274253845, "tokens_seen": 368640000, "tokens_per_second": 115667}
+{"step": 3000, "validation_loss": 2.950226, "validation_perplexity": 19.1103}
+{"step": 3050, "max_steps": 24415, "train_loss": 2.787679, "learning_rate": 0.00014621682774132818, "grad_norm": 0.7349603772163391, "tokens_seen": 374784000, "tokens_per_second": 113471}
+{"step": 3100, "max_steps": 24415, "train_loss": 2.748469, "learning_rate": 0.00014606918601595562, "grad_norm": 0.8711739182472229, "tokens_seen": 380928000, "tokens_per_second": 115645}
+{"step": 3150, "max_steps": 24415, "train_loss": 2.822111, "learning_rate": 0.00014591880455692242, "grad_norm": 0.722649097442627, "tokens_seen": 387072000, "tokens_per_second": 115647}
+{"step": 3200, "max_steps": 24415, "train_loss": 2.784047, "learning_rate": 0.00014576568984543702, "grad_norm": 0.675203800201416, "tokens_seen": 393216000, "tokens_per_second": 115674}
+{"step": 3250, "max_steps": 24415, "train_loss": 2.812503, "learning_rate": 0.00014560984848050682, "grad_norm": 0.6620163321495056, "tokens_seen": 399360000, "tokens_per_second": 115674}
+{"step": 3300, "max_steps": 24415, "train_loss": 2.851004, "learning_rate": 0.00014545128717865377, "grad_norm": 0.6590436100959778, "tokens_seen": 405504000, "tokens_per_second": 115663}
+{"step": 3350, "max_steps": 24415, "train_loss": 2.666078, "learning_rate": 0.0001452900127736249, "grad_norm": 0.7361322045326233, "tokens_seen": 411648000, "tokens_per_second": 115664}
+{"step": 3400, "max_steps": 24415, "train_loss": 2.847474, "learning_rate": 0.00014512603221609774, "grad_norm": 0.6425556540489197, "tokens_seen": 417792000, "tokens_per_second": 115646}
+{"step": 3450, "max_steps": 24415, "train_loss": 2.894404, "learning_rate": 0.00014495935257338095, "grad_norm": 0.687091052532196, "tokens_seen": 423936000, "tokens_per_second": 115651}
+{"step": 3500, "max_steps": 24415, "train_loss": 2.785236, "learning_rate": 0.00014478998102910944, "grad_norm": 0.6465118527412415, "tokens_seen": 430080000, "tokens_per_second": 115671}
+{"step": 3550, "max_steps": 24415, "train_loss": 2.781479, "learning_rate": 0.00014461792488293496, "grad_norm": 0.7730088829994202, "tokens_seen": 436224000, "tokens_per_second": 115674}
+{"step": 3600, "max_steps": 24415, "train_loss": 2.919193, "learning_rate": 0.00014444319155021152, "grad_norm": 0.6525118947029114, "tokens_seen": 442368000, "tokens_per_second": 115663}
+{"step": 3650, "max_steps": 24415, "train_loss": 2.847713, "learning_rate": 0.00014426578856167568, "grad_norm": 0.737187922000885, "tokens_seen": 448512000, "tokens_per_second": 115661}
+{"step": 3700, "max_steps": 24415, "train_loss": 2.915229, "learning_rate": 0.00014408572356312203, "grad_norm": 0.6132097244262695, "tokens_seen": 454656000, "tokens_per_second": 115686}
+{"step": 3750, "max_steps": 24415, "train_loss": 2.85277, "learning_rate": 0.00014390300431507366, "grad_norm": 0.6486119031906128, "tokens_seen": 460800000, "tokens_per_second": 115701}
+{"step": 3800, "max_steps": 24415, "train_loss": 2.921737, "learning_rate": 0.00014371763869244775, "grad_norm": 0.8457760214805603, "tokens_seen": 466944000, "tokens_per_second": 115692}
+{"step": 3850, "max_steps": 24415, "train_loss": 2.825371, "learning_rate": 0.00014352963468421614, "grad_norm": 0.7568368315696716, "tokens_seen": 473088000, "tokens_per_second": 115654}
+{"step": 3900, "max_steps": 24415, "train_loss": 2.780189, "learning_rate": 0.00014333900039306097, "grad_norm": 0.7013327479362488, "tokens_seen": 479232000, "tokens_per_second": 115642}
+{"step": 3950, "max_steps": 24415, "train_loss": 2.902723, "learning_rate": 0.00014314574403502555, "grad_norm": 0.6669299602508545, "tokens_seen": 485376000, "tokens_per_second": 115658}
+{"step": 4000, "max_steps": 24415, "train_loss": 2.750378, "learning_rate": 0.0001429498739391602, "grad_norm": 0.6626065969467163, "tokens_seen": 491520000, "tokens_per_second": 115649}
+{"step": 4000, "validation_loss": 2.948161, "validation_perplexity": 19.0709}
+{"step": 4050, "max_steps": 24415, "train_loss": 2.874746, "learning_rate": 0.0001427513985471633, "grad_norm": 0.7452462315559387, "tokens_seen": 497664000, "tokens_per_second": 113529}
+{"step": 4100, "max_steps": 24415, "train_loss": 2.850423, "learning_rate": 0.0001425503264130175, "grad_norm": 0.6568276286125183, "tokens_seen": 503808000, "tokens_per_second": 115665}
+{"step": 4150, "max_steps": 24415, "train_loss": 2.802352, "learning_rate": 0.0001423466662026209, "grad_norm": 0.6452341675758362, "tokens_seen": 509952000, "tokens_per_second": 115661}
+{"step": 4200, "max_steps": 24415, "train_loss": 2.848085, "learning_rate": 0.00014214042669341388, "grad_norm": 0.6572521924972534, "tokens_seen": 516096000, "tokens_per_second": 115640}
+{"step": 4250, "max_steps": 24415, "train_loss": 2.969786, "learning_rate": 0.00014193161677400048, "grad_norm": 0.7090214490890503, "tokens_seen": 522240000, "tokens_per_second": 115650}
+{"step": 4300, "max_steps": 24415, "train_loss": 2.826574, "learning_rate": 0.00014172024544376543, "grad_norm": 0.6470843553543091, "tokens_seen": 528384000, "tokens_per_second": 115670}
+{"step": 4350, "max_steps": 24415, "train_loss": 2.935181, "learning_rate": 0.00014150632181248642, "grad_norm": 0.6939204335212708, "tokens_seen": 534528000, "tokens_per_second": 115678}
+{"step": 4400, "max_steps": 24415, "train_loss": 2.870769, "learning_rate": 0.00014128985509994122, "grad_norm": 0.6737850308418274, "tokens_seen": 540672000, "tokens_per_second": 115669}
+{"step": 4450, "max_steps": 24415, "train_loss": 3.00332, "learning_rate": 0.00014107085463551064, "grad_norm": 0.6614698171615601, "tokens_seen": 546816000, "tokens_per_second": 115649}
+{"step": 4500, "max_steps": 24415, "train_loss": 2.696218, "learning_rate": 0.00014084932985777618, "grad_norm": 0.6942455768585205, "tokens_seen": 552960000, "tokens_per_second": 115658}
+{"step": 4550, "max_steps": 24415, "train_loss": 2.828182, "learning_rate": 0.00014062529031411331, "grad_norm": 0.6730613708496094, "tokens_seen": 559104000, "tokens_per_second": 115665}
+{"step": 4600, "max_steps": 24415, "train_loss": 2.920113, "learning_rate": 0.00014039874566028015, "grad_norm": 0.6104084253311157, "tokens_seen": 565248000, "tokens_per_second": 115640}
+{"step": 4650, "max_steps": 24415, "train_loss": 2.754896, "learning_rate": 0.00014016970566000102, "grad_norm": 0.6483374834060669, "tokens_seen": 571392000, "tokens_per_second": 115647}
+{"step": 4700, "max_steps": 24415, "train_loss": 2.813306, "learning_rate": 0.00013993818018454598, "grad_norm": 0.6836441159248352, "tokens_seen": 577536000, "tokens_per_second": 115660}
+{"step": 4750, "max_steps": 24415, "train_loss": 2.903481, "learning_rate": 0.00013970417921230514, "grad_norm": 0.656783401966095, "tokens_seen": 583680000, "tokens_per_second": 115651}
+{"step": 4800, "max_steps": 24415, "train_loss": 3.033902, "learning_rate": 0.00013946771282835873, "grad_norm": 0.7004533410072327, "tokens_seen": 589824000, "tokens_per_second": 115658}
+{"step": 4850, "max_steps": 24415, "train_loss": 2.867407, "learning_rate": 0.0001392287912240424, "grad_norm": 0.6720044612884521, "tokens_seen": 595968000, "tokens_per_second": 115647}
+{"step": 4900, "max_steps": 24415, "train_loss": 2.976752, "learning_rate": 0.00013898742469650797, "grad_norm": 0.7038782835006714, "tokens_seen": 602112000, "tokens_per_second": 115666}
+{"step": 4950, "max_steps": 24415, "train_loss": 2.880877, "learning_rate": 0.00013874362364827976, "grad_norm": 0.6553775072097778, "tokens_seen": 608256000, "tokens_per_second": 115658}
+{"step": 5000, "max_steps": 24415, "train_loss": 2.872165, "learning_rate": 0.00013849739858680607, "grad_norm": 0.6521583795547485, "tokens_seen": 614400000, "tokens_per_second": 115656}
+{"step": 5000, "validation_loss": 2.944971, "validation_perplexity": 19.0101}
+Saved checkpoint: runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00005000
+{"step": 5050, "max_steps": 24415, "train_loss": 2.799103, "learning_rate": 0.00013824876012400648, "grad_norm": 0.6628615260124207, "tokens_seen": 620544000, "tokens_per_second": 111699}
+{"step": 5100, "max_steps": 24415, "train_loss": 2.91504, "learning_rate": 0.00013799771897581443, "grad_norm": 0.6126322746276855, "tokens_seen": 626688000, "tokens_per_second": 115663}
+{"step": 5150, "max_steps": 24415, "train_loss": 2.882699, "learning_rate": 0.00013774428596171538, "grad_norm": 0.6810411214828491, "tokens_seen": 632832000, "tokens_per_second": 115645}
+{"step": 5200, "max_steps": 24415, "train_loss": 2.850346, "learning_rate": 0.0001374884720042805, "grad_norm": 0.6813170909881592, "tokens_seen": 638976000, "tokens_per_second": 115652}
+{"step": 5250, "max_steps": 24415, "train_loss": 2.856393, "learning_rate": 0.00013723028812869602, "grad_norm": 0.619038462638855, "tokens_seen": 645120000, "tokens_per_second": 115651}
+{"step": 5300, "max_steps": 24415, "train_loss": 2.843284, "learning_rate": 0.00013696974546228781, "grad_norm": 0.6991771459579468, "tokens_seen": 651264000, "tokens_per_second": 115651}
+{"step": 5350, "max_steps": 24415, "train_loss": 2.908741, "learning_rate": 0.00013670685523404214, "grad_norm": 0.6153818368911743, "tokens_seen": 657408000, "tokens_per_second": 115647}
+{"step": 5400, "max_steps": 24415, "train_loss": 2.931608, "learning_rate": 0.00013644162877412153, "grad_norm": 0.6771771907806396, "tokens_seen": 663552000, "tokens_per_second": 115640}
+{"step": 5450, "max_steps": 24415, "train_loss": 2.815716, "learning_rate": 0.00013617407751337636, "grad_norm": 0.8512451648712158, "tokens_seen": 669696000, "tokens_per_second": 115659}
+{"step": 5500, "max_steps": 24415, "train_loss": 2.867514, "learning_rate": 0.00013590421298285252, "grad_norm": 0.6467471122741699, "tokens_seen": 675840000, "tokens_per_second": 115656}
+{"step": 5550, "max_steps": 24415, "train_loss": 2.826002, "learning_rate": 0.0001356320468132941, "grad_norm": 0.6404849290847778, "tokens_seen": 681984000, "tokens_per_second": 115648}
+{"step": 5600, "max_steps": 24415, "train_loss": 2.87931, "learning_rate": 0.0001353575907346424, "grad_norm": 0.6391315460205078, "tokens_seen": 688128000, "tokens_per_second": 115627}
+{"step": 5650, "max_steps": 24415, "train_loss": 2.75582, "learning_rate": 0.00013508085657553008, "grad_norm": 0.6846815943717957, "tokens_seen": 694272000, "tokens_per_second": 115641}
+{"step": 5700, "max_steps": 24415, "train_loss": 2.772559, "learning_rate": 0.00013480185626277175, "grad_norm": 0.7212074995040894, "tokens_seen": 700416000, "tokens_per_second": 115620}
+{"step": 5750, "max_steps": 24415, "train_loss": 2.822725, "learning_rate": 0.0001345206018208496, "grad_norm": 0.599242627620697, "tokens_seen": 706560000, "tokens_per_second": 115654}
+{"step": 5800, "max_steps": 24415, "train_loss": 2.858205, "learning_rate": 0.0001342371053713954, "grad_norm": 0.7058699727058411, "tokens_seen": 712704000, "tokens_per_second": 115668}
+{"step": 5850, "max_steps": 24415, "train_loss": 2.982627, "learning_rate": 0.00013395137913266788, "grad_norm": 0.6416256427764893, "tokens_seen": 718848000, "tokens_per_second": 115671}
+{"step": 5900, "max_steps": 24415, "train_loss": 2.781853, "learning_rate": 0.00013366343541902634, "grad_norm": 0.7527068853378296, "tokens_seen": 724992000, "tokens_per_second": 115660}
+{"step": 5950, "max_steps": 24415, "train_loss": 2.83377, "learning_rate": 0.0001333732866403997, "grad_norm": 0.6535189151763916, "tokens_seen": 731136000, "tokens_per_second": 115677}
+{"step": 6000, "max_steps": 24415, "train_loss": 2.767776, "learning_rate": 0.00013308094530175193, "grad_norm": 0.8586512207984924, "tokens_seen": 737280000, "tokens_per_second": 115664}
+{"step": 6000, "validation_loss": 2.940371, "validation_perplexity": 18.9229}
+{"step": 6050, "max_steps": 24415, "train_loss": 2.885991, "learning_rate": 0.00013278642400254285, "grad_norm": 0.6209027767181396, "tokens_seen": 743424000, "tokens_per_second": 113498}
+{"step": 6100, "max_steps": 24415, "train_loss": 2.79999, "learning_rate": 0.00013248973543618516, "grad_norm": 0.622372031211853, "tokens_seen": 749568000, "tokens_per_second": 115650}
+{"step": 6150, "max_steps": 24415, "train_loss": 2.847553, "learning_rate": 0.00013219089238949755, "grad_norm": 0.6702292561531067, "tokens_seen": 755712000, "tokens_per_second": 115648}
+{"step": 6200, "max_steps": 24415, "train_loss": 2.88014, "learning_rate": 0.00013188990774215341, "grad_norm": 0.7778111696243286, "tokens_seen": 761856000, "tokens_per_second": 115667}
+{"step": 6250, "max_steps": 24415, "train_loss": 2.876659, "learning_rate": 0.0001315867944661258, "grad_norm": 0.648591160774231, "tokens_seen": 768000000, "tokens_per_second": 115647}
+{"step": 6300, "max_steps": 24415, "train_loss": 2.835785, "learning_rate": 0.00013128156562512843, "grad_norm": 0.6847606897354126, "tokens_seen": 774144000, "tokens_per_second": 115637}
+{"step": 6350, "max_steps": 24415, "train_loss": 2.748451, "learning_rate": 0.00013097423437405254, "grad_norm": 0.7733544707298279, "tokens_seen": 780288000, "tokens_per_second": 115644}
+{"step": 6400, "max_steps": 24415, "train_loss": 2.864969, "learning_rate": 0.00013066481395840004, "grad_norm": 0.6182960867881775, "tokens_seen": 786432000, "tokens_per_second": 115636}
+{"step": 6450, "max_steps": 24415, "train_loss": 2.830928, "learning_rate": 0.0001303533177137126, "grad_norm": 0.6351659893989563, "tokens_seen": 792576000, "tokens_per_second": 115642}
+{"step": 6500, "max_steps": 24415, "train_loss": 2.778158, "learning_rate": 0.00013003975906499685, "grad_norm": 0.6366986632347107, "tokens_seen": 798720000, "tokens_per_second": 115654}
+{"step": 6550, "max_steps": 24415, "train_loss": 2.641845, "learning_rate": 0.00012972415152614594, "grad_norm": 0.9436250329017639, "tokens_seen": 804864000, "tokens_per_second": 115641}
+{"step": 6600, "max_steps": 24415, "train_loss": 2.877358, "learning_rate": 0.00012940650869935693, "grad_norm": 0.6089520454406738, "tokens_seen": 811008000, "tokens_per_second": 115625}
+{"step": 6650, "max_steps": 24415, "train_loss": 2.90905, "learning_rate": 0.00012908684427454472, "grad_norm": 0.6610862612724304, "tokens_seen": 817152000, "tokens_per_second": 115629}
+{"step": 6700, "max_steps": 24415, "train_loss": 2.787947, "learning_rate": 0.0001287651720287519, "grad_norm": 0.7656141519546509, "tokens_seen": 823296000, "tokens_per_second": 115623}
+{"step": 6750, "max_steps": 24415, "train_loss": 2.715172, "learning_rate": 0.00012844150582555508, "grad_norm": 0.6442705988883972, "tokens_seen": 829440000, "tokens_per_second": 115626}
+{"step": 6800, "max_steps": 24415, "train_loss": 2.770439, "learning_rate": 0.00012811585961446735, "grad_norm": 0.6757336258888245, "tokens_seen": 835584000, "tokens_per_second": 115638}
+{"step": 6850, "max_steps": 24415, "train_loss": 2.883263, "learning_rate": 0.00012778824743033703, "grad_norm": 0.624424159526825, "tokens_seen": 841728000, "tokens_per_second": 115659}
+{"step": 6900, "max_steps": 24415, "train_loss": 2.866001, "learning_rate": 0.0001274586833927429, "grad_norm": 0.6462403535842896, "tokens_seen": 847872000, "tokens_per_second": 115663}
+{"step": 6950, "max_steps": 24415, "train_loss": 2.759226, "learning_rate": 0.00012712718170538562, "grad_norm": 0.8008264899253845, "tokens_seen": 854016000, "tokens_per_second": 115657}
+{"step": 7000, "max_steps": 24415, "train_loss": 2.854571, "learning_rate": 0.00012679375665547546, "grad_norm": 0.6955330967903137, "tokens_seen": 860160000, "tokens_per_second": 115619}
+{"step": 7000, "validation_loss": 2.933616, "validation_perplexity": 18.7955}
+{"step": 7050, "max_steps": 24415, "train_loss": 2.797329, "learning_rate": 0.00012645842261311676, "grad_norm": 0.7074103951454163, "tokens_seen": 866304000, "tokens_per_second": 113444}
+{"step": 7100, "max_steps": 24415, "train_loss": 2.811077, "learning_rate": 0.0001261211940306884, "grad_norm": 0.6589587926864624, "tokens_seen": 872448000, "tokens_per_second": 115588}
+{"step": 7150, "max_steps": 24415, "train_loss": 2.85789, "learning_rate": 0.00012578208544222104, "grad_norm": 0.6195741891860962, "tokens_seen": 878592000, "tokens_per_second": 115604}
+{"step": 7200, "max_steps": 24415, "train_loss": 2.951097, "learning_rate": 0.00012544111146277072, "grad_norm": 0.7131823897361755, "tokens_seen": 884736000, "tokens_per_second": 115624}
+{"step": 7250, "max_steps": 24415, "train_loss": 2.760288, "learning_rate": 0.0001250982867877889, "grad_norm": 0.6765594482421875, "tokens_seen": 890880000, "tokens_per_second": 115599}
+{"step": 7300, "max_steps": 24415, "train_loss": 2.820308, "learning_rate": 0.0001247536261924892, "grad_norm": 0.6766009330749512, "tokens_seen": 897024000, "tokens_per_second": 115633}
+{"step": 7350, "max_steps": 24415, "train_loss": 2.978635, "learning_rate": 0.00012440714453121053, "grad_norm": 0.7272297143936157, "tokens_seen": 903168000, "tokens_per_second": 115719}
+{"step": 7400, "max_steps": 24415, "train_loss": 2.880204, "learning_rate": 0.00012405885673677698, "grad_norm": 0.6244488954544067, "tokens_seen": 909312000, "tokens_per_second": 115676}
+{"step": 7450, "max_steps": 24415, "train_loss": 2.904444, "learning_rate": 0.0001237087778198541, "grad_norm": 0.6648251414299011, "tokens_seen": 915456000, "tokens_per_second": 115711}
+{"step": 7500, "max_steps": 24415, "train_loss": 2.761484, "learning_rate": 0.0001233569228683021, "grad_norm": 0.6898263096809387, "tokens_seen": 921600000, "tokens_per_second": 115655}
+{"step": 7550, "max_steps": 24415, "train_loss": 2.747628, "learning_rate": 0.0001230033070465256, "grad_norm": 0.9069489240646362, "tokens_seen": 927744000, "tokens_per_second": 115602}
+{"step": 7600, "max_steps": 24415, "train_loss": 2.856875, "learning_rate": 0.00012264794559481993, "grad_norm": 0.6639710664749146, "tokens_seen": 933888000, "tokens_per_second": 115599}
+{"step": 7650, "max_steps": 24415, "train_loss": 2.803813, "learning_rate": 0.00012229085382871438, "grad_norm": 0.6735744476318359, "tokens_seen": 940032000, "tokens_per_second": 115599}
+{"step": 7700, "max_steps": 24415, "train_loss": 2.850425, "learning_rate": 0.00012193204713831213, "grad_norm": 0.6658360958099365, "tokens_seen": 946176000, "tokens_per_second": 115599}
+{"step": 7750, "max_steps": 24415, "train_loss": 2.651114, "learning_rate": 0.00012157154098762691, "grad_norm": 0.696196436882019, "tokens_seen": 952320000, "tokens_per_second": 115594}
+{"step": 7800, "max_steps": 24415, "train_loss": 2.810525, "learning_rate": 0.00012120935091391663, "grad_norm": 0.6725903749465942, "tokens_seen": 958464000, "tokens_per_second": 115602}
+{"step": 7850, "max_steps": 24415, "train_loss": 2.753515, "learning_rate": 0.00012084549252701364, "grad_norm": 0.6148095726966858, "tokens_seen": 964608000, "tokens_per_second": 115589}
+{"step": 7900, "max_steps": 24415, "train_loss": 2.743506, "learning_rate": 0.000120479981508652, "grad_norm": 0.6364421844482422, "tokens_seen": 970752000, "tokens_per_second": 115599}
+{"step": 7950, "max_steps": 24415, "train_loss": 2.852497, "learning_rate": 0.00012011283361179166, "grad_norm": 0.6017224788665771, "tokens_seen": 976896000, "tokens_per_second": 115577}
+{"step": 8000, "max_steps": 24415, "train_loss": 2.799852, "learning_rate": 0.00011974406465993947, "grad_norm": 0.6454333066940308, "tokens_seen": 983040000, "tokens_per_second": 115618}
+{"step": 8000, "validation_loss": 2.930552, "validation_perplexity": 18.738}
+{"step": 8050, "max_steps": 24415, "train_loss": 2.713696, "learning_rate": 0.00011937369054646724, "grad_norm": 0.7488113045692444, "tokens_seen": 989184000, "tokens_per_second": 113452}
+{"step": 8100, "max_steps": 24415, "train_loss": 2.814722, "learning_rate": 0.00011900172723392684, "grad_norm": 0.5979893803596497, "tokens_seen": 995328000, "tokens_per_second": 115611}
+{"step": 8150, "max_steps": 24415, "train_loss": 2.784884, "learning_rate": 0.00011862819075336208, "grad_norm": 0.6830214262008667, "tokens_seen": 1001472000, "tokens_per_second": 115602}
+{"step": 8200, "max_steps": 24415, "train_loss": 2.891899, "learning_rate": 0.00011825309720361792, "grad_norm": 0.6417458653450012, "tokens_seen": 1007616000, "tokens_per_second": 115604}
+{"step": 8250, "max_steps": 24415, "train_loss": 2.750473, "learning_rate": 0.00011787646275064659, "grad_norm": 0.6115127205848694, "tokens_seen": 1013760000, "tokens_per_second": 115613}
+{"step": 8300, "max_steps": 24415, "train_loss": 2.830243, "learning_rate": 0.00011749830362681082, "grad_norm": 0.6408085227012634, "tokens_seen": 1019904000, "tokens_per_second": 115590}
+{"step": 8350, "max_steps": 24415, "train_loss": 2.837465, "learning_rate": 0.00011711863613018439, "grad_norm": 0.6117357015609741, "tokens_seen": 1026048000, "tokens_per_second": 115559}
+{"step": 8400, "max_steps": 24415, "train_loss": 2.806834, "learning_rate": 0.00011673747662384954, "grad_norm": 0.6075411438941956, "tokens_seen": 1032192000, "tokens_per_second": 115583}
+{"step": 8450, "max_steps": 24415, "train_loss": 2.785034, "learning_rate": 0.00011635484153519188, "grad_norm": 0.6879437565803528, "tokens_seen": 1038336000, "tokens_per_second": 115682}
+{"step": 8500, "max_steps": 24415, "train_loss": 2.706253, "learning_rate": 0.00011597074735519223, "grad_norm": 0.6767988204956055, "tokens_seen": 1044480000, "tokens_per_second": 115683}
+{"step": 8550, "max_steps": 24415, "train_loss": 2.755598, "learning_rate": 0.00011558521063771618, "grad_norm": 0.6101839542388916, "tokens_seen": 1050624000, "tokens_per_second": 115676}
+{"step": 8600, "max_steps": 24415, "train_loss": 2.693565, "learning_rate": 0.00011519824799880022, "grad_norm": 0.7641435265541077, "tokens_seen": 1056768000, "tokens_per_second": 115653}
+{"step": 8650, "max_steps": 24415, "train_loss": 2.87077, "learning_rate": 0.0001148098761159361, "grad_norm": 0.6561196446418762, "tokens_seen": 1062912000, "tokens_per_second": 115597}
+{"step": 8700, "max_steps": 24415, "train_loss": 2.79678, "learning_rate": 0.00011442011172735157, "grad_norm": 0.6285972595214844, "tokens_seen": 1069056000, "tokens_per_second": 115544}
+{"step": 8750, "max_steps": 24415, "train_loss": 2.886481, "learning_rate": 0.00011402897163128938, "grad_norm": 0.6041844487190247, "tokens_seen": 1075200000, "tokens_per_second": 115560}
+{"step": 8800, "max_steps": 24415, "train_loss": 2.832706, "learning_rate": 0.00011363647268528311, "grad_norm": 0.6426976919174194, "tokens_seen": 1081344000, "tokens_per_second": 115582}
+{"step": 8850, "max_steps": 24415, "train_loss": 2.83513, "learning_rate": 0.00011324263180543064, "grad_norm": 0.7424055337905884, "tokens_seen": 1087488000, "tokens_per_second": 115581}
+{"step": 8900, "max_steps": 24415, "train_loss": 2.816452, "learning_rate": 0.00011284746596566514, "grad_norm": 0.7485107779502869, "tokens_seen": 1093632000, "tokens_per_second": 115567}
+{"step": 8950, "max_steps": 24415, "train_loss": 2.680914, "learning_rate": 0.00011245099219702354, "grad_norm": 0.6200953722000122, "tokens_seen": 1099776000, "tokens_per_second": 115559}
+{"step": 9000, "max_steps": 24415, "train_loss": 2.7827, "learning_rate": 0.00011205322758691243, "grad_norm": 0.6235812306404114, "tokens_seen": 1105920000, "tokens_per_second": 115537}
+{"step": 9000, "validation_loss": 2.923473, "validation_perplexity": 18.6058}
+{"step": 9050, "max_steps": 24415, "train_loss": 2.857782, "learning_rate": 0.0001116541892783717, "grad_norm": 0.6333112120628357, "tokens_seen": 1112064000, "tokens_per_second": 113341}
+{"step": 9100, "max_steps": 24415, "train_loss": 2.739355, "learning_rate": 0.00011125389446933568, "grad_norm": 0.6599845290184021, "tokens_seen": 1118208000, "tokens_per_second": 115497}
+{"step": 9150, "max_steps": 24415, "train_loss": 2.742508, "learning_rate": 0.0001108523604118919, "grad_norm": 0.628777265548706, "tokens_seen": 1124352000, "tokens_per_second": 115493}
+{"step": 9200, "max_steps": 24415, "train_loss": 2.775906, "learning_rate": 0.0001104496044115376, "grad_norm": 0.6229897737503052, "tokens_seen": 1130496000, "tokens_per_second": 115528}
+{"step": 9250, "max_steps": 24415, "train_loss": 2.848124, "learning_rate": 0.00011004564382643386, "grad_norm": 0.6016040444374084, "tokens_seen": 1136640000, "tokens_per_second": 115619}
+{"step": 9300, "max_steps": 24415, "train_loss": 2.68203, "learning_rate": 0.00010964049606665756, "grad_norm": 0.6977869868278503, "tokens_seen": 1142784000, "tokens_per_second": 115661}
+{"step": 9350, "max_steps": 24415, "train_loss": 2.952381, "learning_rate": 0.00010923417859345088, "grad_norm": 0.7186052203178406, "tokens_seen": 1148928000, "tokens_per_second": 115641}
+{"step": 9400, "max_steps": 24415, "train_loss": 2.80347, "learning_rate": 0.00010882670891846888, "grad_norm": 0.6344025731086731, "tokens_seen": 1155072000, "tokens_per_second": 115618}
+{"step": 9450, "max_steps": 24415, "train_loss": 2.885839, "learning_rate": 0.00010841810460302477, "grad_norm": 0.606657862663269, "tokens_seen": 1161216000, "tokens_per_second": 115545}
+{"step": 9500, "max_steps": 24415, "train_loss": 2.723036, "learning_rate": 0.00010800838325733296, "grad_norm": 0.6441790461540222, "tokens_seen": 1167360000, "tokens_per_second": 115506}
+{"step": 9550, "max_steps": 24415, "train_loss": 2.873209, "learning_rate": 0.00010759756253975014, "grad_norm": 0.6934483051300049, "tokens_seen": 1173504000, "tokens_per_second": 115502}
+{"step": 9600, "max_steps": 24415, "train_loss": 2.900885, "learning_rate": 0.0001071856601560143, "grad_norm": 0.6176964044570923, "tokens_seen": 1179648000, "tokens_per_second": 115514}
+{"step": 9650, "max_steps": 24415, "train_loss": 2.848973, "learning_rate": 0.0001067726938584815, "grad_norm": 0.6434008479118347, "tokens_seen": 1185792000, "tokens_per_second": 115454}
+{"step": 9700, "max_steps": 24415, "train_loss": 2.97445, "learning_rate": 0.00010635868144536079, "grad_norm": 0.612534761428833, "tokens_seen": 1191936000, "tokens_per_second": 115480}
+{"step": 9750, "max_steps": 24415, "train_loss": 2.820954, "learning_rate": 0.00010594364075994735, "grad_norm": 0.7931225299835205, "tokens_seen": 1198080000, "tokens_per_second": 115473}
+{"step": 9800, "max_steps": 24415, "train_loss": 2.845421, "learning_rate": 0.00010552758968985312, "grad_norm": 0.6815776228904724, "tokens_seen": 1204224000, "tokens_per_second": 115428}
+{"step": 9850, "max_steps": 24415, "train_loss": 2.838773, "learning_rate": 0.00010511054616623621, "grad_norm": 0.5951747894287109, "tokens_seen": 1210368000, "tokens_per_second": 115374}
+{"step": 9900, "max_steps": 24415, "train_loss": 2.772448, "learning_rate": 0.00010469252816302786, "grad_norm": 0.6392014622688293, "tokens_seen": 1216512000, "tokens_per_second": 115407}
+{"step": 9950, "max_steps": 24415, "train_loss": 2.7407, "learning_rate": 0.00010427355369615789, "grad_norm": 0.6149389147758484, "tokens_seen": 1222656000, "tokens_per_second": 115586}
+{"step": 10000, "max_steps": 24415, "train_loss": 2.783382, "learning_rate": 0.00010385364082277821, "grad_norm": 0.6641293168067932, "tokens_seen": 1228800000, "tokens_per_second": 115629}
+{"step": 10000, "validation_loss": 2.918266, "validation_perplexity": 18.5092}
+Saved checkpoint: runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00010000
+{"step": 10050, "max_steps": 24415, "train_loss": 2.775162, "learning_rate": 0.00010343280764048466, "grad_norm": 0.7611445188522339, "tokens_seen": 1234944000, "tokens_per_second": 111850}
+{"step": 10100, "max_steps": 24415, "train_loss": 2.774081, "learning_rate": 0.00010301107228653688, "grad_norm": 0.6389397382736206, "tokens_seen": 1241088000, "tokens_per_second": 115663}
+{"step": 10150, "max_steps": 24415, "train_loss": 2.850143, "learning_rate": 0.0001025884529370768, "grad_norm": 0.648176908493042, "tokens_seen": 1247232000, "tokens_per_second": 115662}
+{"step": 10200, "max_steps": 24415, "train_loss": 2.785788, "learning_rate": 0.00010216496780634514, "grad_norm": 0.6346315145492554, "tokens_seen": 1253376000, "tokens_per_second": 115662}
+{"step": 10250, "max_steps": 24415, "train_loss": 2.827677, "learning_rate": 0.00010174063514589646, "grad_norm": 0.6351058483123779, "tokens_seen": 1259520000, "tokens_per_second": 115682}
+{"step": 10300, "max_steps": 24415, "train_loss": 2.861314, "learning_rate": 0.00010131547324381256, "grad_norm": 0.7274054884910583, "tokens_seen": 1265664000, "tokens_per_second": 115658}
+{"step": 10350, "max_steps": 24415, "train_loss": 2.80999, "learning_rate": 0.00010088950042391428, "grad_norm": 0.6244896054267883, "tokens_seen": 1271808000, "tokens_per_second": 115603}
+{"step": 10400, "max_steps": 24415, "train_loss": 2.8915, "learning_rate": 0.00010046273504497171, "grad_norm": 0.6021413803100586, "tokens_seen": 1277952000, "tokens_per_second": 115526}
+{"step": 10450, "max_steps": 24415, "train_loss": 2.839523, "learning_rate": 0.00010003519549991305, "grad_norm": 0.6517390608787537, "tokens_seen": 1284096000, "tokens_per_second": 115511}
+{"step": 10500, "max_steps": 24415, "train_loss": 2.868553, "learning_rate": 9.960690021503191e-05, "grad_norm": 0.6538746356964111, "tokens_seen": 1290240000, "tokens_per_second": 115540}
+{"step": 10550, "max_steps": 24415, "train_loss": 2.958018, "learning_rate": 9.917786764919303e-05, "grad_norm": 0.681606113910675, "tokens_seen": 1296384000, "tokens_per_second": 115549}
+{"step": 10600, "max_steps": 24415, "train_loss": 2.696034, "learning_rate": 9.874811629303682e-05, "grad_norm": 0.6564909815788269, "tokens_seen": 1302528000, "tokens_per_second": 115552}
+{"step": 10650, "max_steps": 24415, "train_loss": 2.781479, "learning_rate": 9.831766466818254e-05, "grad_norm": 0.6478615999221802, "tokens_seen": 1308672000, "tokens_per_second": 115511}
+{"step": 10700, "max_steps": 24415, "train_loss": 2.929315, "learning_rate": 9.788653132642987e-05, "grad_norm": 0.6069942116737366, "tokens_seen": 1314816000, "tokens_per_second": 115469}
+{"step": 10750, "max_steps": 24415, "train_loss": 2.940819, "learning_rate": 9.745473484895944e-05, "grad_norm": 0.6308217644691467, "tokens_seen": 1320960000, "tokens_per_second": 115430}
+{"step": 10800, "max_steps": 24415, "train_loss": 2.799978, "learning_rate": 9.702229384553203e-05, "grad_norm": 0.6280612349510193, "tokens_seen": 1327104000, "tokens_per_second": 115436}
+{"step": 10850, "max_steps": 24415, "train_loss": 2.869563, "learning_rate": 9.658922695368647e-05, "grad_norm": 0.6281547546386719, "tokens_seen": 1333248000, "tokens_per_second": 115442}
+{"step": 10900, "max_steps": 24415, "train_loss": 2.887809, "learning_rate": 9.615555283793642e-05, "grad_norm": 0.6927506327629089, "tokens_seen": 1339392000, "tokens_per_second": 115582}
+{"step": 10950, "max_steps": 24415, "train_loss": 2.833543, "learning_rate": 9.572129018896597e-05, "grad_norm": 0.6338732242584229, "tokens_seen": 1345536000, "tokens_per_second": 115663}
+{"step": 11000, "max_steps": 24415, "train_loss": 2.729088, "learning_rate": 9.528645772282403e-05, "grad_norm": 0.6513716578483582, "tokens_seen": 1351680000, "tokens_per_second": 115694}
+{"step": 11000, "validation_loss": 2.911769, "validation_perplexity": 18.3893}
+{"step": 11050, "max_steps": 24415, "train_loss": 2.870943, "learning_rate": 9.485107418011784e-05, "grad_norm": 0.6725945472717285, "tokens_seen": 1357824000, "tokens_per_second": 113478}
+{"step": 11100, "max_steps": 24415, "train_loss": 2.791466, "learning_rate": 9.44151583252051e-05, "grad_norm": 0.6462335586547852, "tokens_seen": 1363968000, "tokens_per_second": 115642}
+{"step": 11150, "max_steps": 24415, "train_loss": 2.850855, "learning_rate": 9.397872894538538e-05, "grad_norm": 0.6676380634307861, "tokens_seen": 1370112000, "tokens_per_second": 115671}
+{"step": 11200, "max_steps": 24415, "train_loss": 2.849724, "learning_rate": 9.354180485009036e-05, "grad_norm": 0.5953037142753601, "tokens_seen": 1376256000, "tokens_per_second": 115721}
+{"step": 11250, "max_steps": 24415, "train_loss": 2.752258, "learning_rate": 9.310440487007324e-05, "grad_norm": 0.6712871193885803, "tokens_seen": 1382400000, "tokens_per_second": 115674}
+{"step": 11300, "max_steps": 24415, "train_loss": 2.850544, "learning_rate": 9.26665478565971e-05, "grad_norm": 0.6593591570854187, "tokens_seen": 1388544000, "tokens_per_second": 115636}
+{"step": 11350, "max_steps": 24415, "train_loss": 2.827023, "learning_rate": 9.222825268062237e-05, "grad_norm": 0.6266449689865112, "tokens_seen": 1394688000, "tokens_per_second": 115630}
+{"step": 11400, "max_steps": 24415, "train_loss": 2.742964, "learning_rate": 9.178953823199372e-05, "grad_norm": 0.6214085817337036, "tokens_seen": 1400832000, "tokens_per_second": 115692}
+{"step": 11450, "max_steps": 24415, "train_loss": 2.870918, "learning_rate": 9.135042341862582e-05, "grad_norm": 0.634956955909729, "tokens_seen": 1406976000, "tokens_per_second": 115698}
+{"step": 11500, "max_steps": 24415, "train_loss": 2.695957, "learning_rate": 9.091092716568831e-05, "grad_norm": 0.6031589508056641, "tokens_seen": 1413120000, "tokens_per_second": 115660}
+{"step": 11550, "max_steps": 24415, "train_loss": 2.973763, "learning_rate": 9.04710684147905e-05, "grad_norm": 0.6234080791473389, "tokens_seen": 1419264000, "tokens_per_second": 115694}
+{"step": 11600, "max_steps": 24415, "train_loss": 2.770549, "learning_rate": 9.003086612316455e-05, "grad_norm": 0.6769762635231018, "tokens_seen": 1425408000, "tokens_per_second": 115705}
+{"step": 11650, "max_steps": 24415, "train_loss": 2.84782, "learning_rate": 8.959033926284892e-05, "grad_norm": 0.7006694078445435, "tokens_seen": 1431552000, "tokens_per_second": 115663}
+{"step": 11700, "max_steps": 24415, "train_loss": 2.885127, "learning_rate": 8.914950681987033e-05, "grad_norm": 0.6738485097885132, "tokens_seen": 1437696000, "tokens_per_second": 115643}
+{"step": 11750, "max_steps": 24415, "train_loss": 2.778524, "learning_rate": 8.870838779342573e-05, "grad_norm": 0.6949870586395264, "tokens_seen": 1443840000, "tokens_per_second": 115675}
+{"step": 11800, "max_steps": 24415, "train_loss": 2.804691, "learning_rate": 8.82670011950633e-05, "grad_norm": 0.6358240842819214, "tokens_seen": 1449984000, "tokens_per_second": 115694}
+{"step": 11850, "max_steps": 24415, "train_loss": 2.793259, "learning_rate": 8.78253660478632e-05, "grad_norm": 0.6506847143173218, "tokens_seen": 1456128000, "tokens_per_second": 115639}
+{"step": 11900, "max_steps": 24415, "train_loss": 2.802632, "learning_rate": 8.738350138561769e-05, "grad_norm": 0.653716504573822, "tokens_seen": 1462272000, "tokens_per_second": 115615}
+{"step": 11950, "max_steps": 24415, "train_loss": 2.823897, "learning_rate": 8.69414262520107e-05, "grad_norm": 0.6153150200843811, "tokens_seen": 1468416000, "tokens_per_second": 115660}
+{"step": 12000, "max_steps": 24415, "train_loss": 2.723172, "learning_rate": 8.649915969979722e-05, "grad_norm": 0.6362366080284119, "tokens_seen": 1474560000, "tokens_per_second": 115652}
+{"step": 12000, "validation_loss": 2.905931, "validation_perplexity": 18.2823}
+{"step": 12050, "max_steps": 24415, "train_loss": 2.788503, "learning_rate": 8.605672078998203e-05, "grad_norm": 0.6385388970375061, "tokens_seen": 1480704000, "tokens_per_second": 113464}
+{"step": 12100, "max_steps": 24415, "train_loss": 2.863936, "learning_rate": 8.561412859099828e-05, "grad_norm": 0.6147498488426208, "tokens_seen": 1486848000, "tokens_per_second": 115615}
+{"step": 12150, "max_steps": 24415, "train_loss": 2.9177, "learning_rate": 8.517140217788565e-05, "grad_norm": 0.6115130186080933, "tokens_seen": 1492992000, "tokens_per_second": 115654}
+{"step": 12200, "max_steps": 24415, "train_loss": 2.721272, "learning_rate": 8.472856063146826e-05, "grad_norm": 0.6808973550796509, "tokens_seen": 1499136000, "tokens_per_second": 115618}
+{"step": 12250, "max_steps": 24415, "train_loss": 2.686518, "learning_rate": 8.428562303753227e-05, "grad_norm": 0.7563024759292603, "tokens_seen": 1505280000, "tokens_per_second": 115582}
+{"step": 12300, "max_steps": 24415, "train_loss": 2.819199, "learning_rate": 8.384260848600334e-05, "grad_norm": 0.6369250416755676, "tokens_seen": 1511424000, "tokens_per_second": 115612}
+{"step": 12350, "max_steps": 24415, "train_loss": 2.606734, "learning_rate": 8.339953607012387e-05, "grad_norm": 0.6867128610610962, "tokens_seen": 1517568000, "tokens_per_second": 115660}
+{"step": 12400, "max_steps": 24415, "train_loss": 2.724569, "learning_rate": 8.295642488563015e-05, "grad_norm": 0.6900272965431213, "tokens_seen": 1523712000, "tokens_per_second": 115654}
+{"step": 12450, "max_steps": 24415, "train_loss": 2.916764, "learning_rate": 8.251329402992934e-05, "grad_norm": 0.6223289966583252, "tokens_seen": 1529856000, "tokens_per_second": 115611}
+{"step": 12500, "max_steps": 24415, "train_loss": 2.714432, "learning_rate": 8.20701626012764e-05, "grad_norm": 0.6510653495788574, "tokens_seen": 1536000000, "tokens_per_second": 115652}
+{"step": 12550, "max_steps": 24415, "train_loss": 2.846118, "learning_rate": 8.162704969795096e-05, "grad_norm": 0.6865654587745667, "tokens_seen": 1542144000, "tokens_per_second": 115665}
+{"step": 12600, "max_steps": 24415, "train_loss": 2.918616, "learning_rate": 8.118397441743427e-05, "grad_norm": 0.661815881729126, "tokens_seen": 1548288000, "tokens_per_second": 115631}
+{"step": 12650, "max_steps": 24415, "train_loss": 2.86565, "learning_rate": 8.074095585558602e-05, "grad_norm": 0.6402216553688049, "tokens_seen": 1554432000, "tokens_per_second": 115621}
+{"step": 12700, "max_steps": 24415, "train_loss": 2.907798, "learning_rate": 8.029801310582152e-05, "grad_norm": 0.6475313901901245, "tokens_seen": 1560576000, "tokens_per_second": 115649}
+{"step": 12750, "max_steps": 24415, "train_loss": 2.718009, "learning_rate": 7.98551652582886e-05, "grad_norm": 0.6396787762641907, "tokens_seen": 1566720000, "tokens_per_second": 115666}
+{"step": 12800, "max_steps": 24415, "train_loss": 2.888366, "learning_rate": 7.941243139904506e-05, "grad_norm": 0.8234379291534424, "tokens_seen": 1572864000, "tokens_per_second": 115629}
+{"step": 12850, "max_steps": 24415, "train_loss": 2.671792, "learning_rate": 7.896983060923585e-05, "grad_norm": 0.6498484015464783, "tokens_seen": 1579008000, "tokens_per_second": 115603}
+{"step": 12900, "max_steps": 24415, "train_loss": 2.773788, "learning_rate": 7.852738196427095e-05, "grad_norm": 0.6323695778846741, "tokens_seen": 1585152000, "tokens_per_second": 115614}
+{"step": 12950, "max_steps": 24415, "train_loss": 2.8168, "learning_rate": 7.8085104533003e-05, "grad_norm": 0.6435253024101257, "tokens_seen": 1591296000, "tokens_per_second": 115633}
+{"step": 13000, "max_steps": 24415, "train_loss": 2.724554, "learning_rate": 7.764301737690578e-05, "grad_norm": 0.5999656915664673, "tokens_seen": 1597440000, "tokens_per_second": 115589}
+{"step": 13000, "validation_loss": 2.901231, "validation_perplexity": 18.1965}
+{"step": 13050, "max_steps": 24415, "train_loss": 2.780255, "learning_rate": 7.720113954925233e-05, "grad_norm": 0.6173715591430664, "tokens_seen": 1603584000, "tokens_per_second": 113429}
+{"step": 13100, "max_steps": 24415, "train_loss": 2.756385, "learning_rate": 7.675949009429407e-05, "grad_norm": 0.6280876398086548, "tokens_seen": 1609728000, "tokens_per_second": 115638}
+{"step": 13150, "max_steps": 24415, "train_loss": 2.79896, "learning_rate": 7.63180880464398e-05, "grad_norm": 0.7241061329841614, "tokens_seen": 1615872000, "tokens_per_second": 115638}
+{"step": 13200, "max_steps": 24415, "train_loss": 2.841177, "learning_rate": 7.587695242943563e-05, "grad_norm": 0.6539769768714905, "tokens_seen": 1622016000, "tokens_per_second": 115619}
+{"step": 13250, "max_steps": 24415, "train_loss": 2.778755, "learning_rate": 7.543610225554469e-05, "grad_norm": 0.6095080971717834, "tokens_seen": 1628160000, "tokens_per_second": 115628}
+{"step": 13300, "max_steps": 24415, "train_loss": 2.882869, "learning_rate": 7.499555652472813e-05, "grad_norm": 0.6407991647720337, "tokens_seen": 1634304000, "tokens_per_second": 115666}
+{"step": 13350, "max_steps": 24415, "train_loss": 2.947798, "learning_rate": 7.455533422382599e-05, "grad_norm": 0.6137878894805908, "tokens_seen": 1640448000, "tokens_per_second": 115646}
+{"step": 13400, "max_steps": 24415, "train_loss": 2.744945, "learning_rate": 7.411545432573904e-05, "grad_norm": 0.76528000831604, "tokens_seen": 1646592000, "tokens_per_second": 115618}
+{"step": 13450, "max_steps": 24415, "train_loss": 2.75651, "learning_rate": 7.367593578861094e-05, "grad_norm": 0.7015501856803894, "tokens_seen": 1652736000, "tokens_per_second": 115635}
+{"step": 13500, "max_steps": 24415, "train_loss": 2.878917, "learning_rate": 7.323679755501133e-05, "grad_norm": 0.5917170643806458, "tokens_seen": 1658880000, "tokens_per_second": 115676}
+{"step": 13550, "max_steps": 24415, "train_loss": 2.757949, "learning_rate": 7.279805855111927e-05, "grad_norm": 0.6195739507675171, "tokens_seen": 1665024000, "tokens_per_second": 115639}
+{"step": 13600, "max_steps": 24415, "train_loss": 2.804666, "learning_rate": 7.235973768590771e-05, "grad_norm": 0.7056005001068115, "tokens_seen": 1671168000, "tokens_per_second": 115632}
+{"step": 13650, "max_steps": 24415, "train_loss": 2.70874, "learning_rate": 7.192185385032843e-05, "grad_norm": 0.9107558727264404, "tokens_seen": 1677312000, "tokens_per_second": 115641}
+{"step": 13700, "max_steps": 24415, "train_loss": 2.779933, "learning_rate": 7.148442591649797e-05, "grad_norm": 0.6652510166168213, "tokens_seen": 1683456000, "tokens_per_second": 115682}
+{"step": 13750, "max_steps": 24415, "train_loss": 2.603291, "learning_rate": 7.104747273688412e-05, "grad_norm": 0.6849772334098816, "tokens_seen": 1689600000, "tokens_per_second": 115664}
+{"step": 13800, "max_steps": 24415, "train_loss": 2.811565, "learning_rate": 7.061101314349354e-05, "grad_norm": 0.6300348043441772, "tokens_seen": 1695744000, "tokens_per_second": 115635}
+{"step": 13850, "max_steps": 24415, "train_loss": 2.741807, "learning_rate": 7.01750659470601e-05, "grad_norm": 0.645389974117279, "tokens_seen": 1701888000, "tokens_per_second": 115581}
+{"step": 13900, "max_steps": 24415, "train_loss": 2.81428, "learning_rate": 6.97396499362341e-05, "grad_norm": 0.6963964104652405, "tokens_seen": 1708032000, "tokens_per_second": 115551}
+{"step": 13950, "max_steps": 24415, "train_loss": 2.861082, "learning_rate": 6.930478387677264e-05, "grad_norm": 0.6477249264717102, "tokens_seen": 1714176000, "tokens_per_second": 115599}
+{"step": 14000, "max_steps": 24415, "train_loss": 2.859481, "learning_rate": 6.887048651073072e-05, "grad_norm": 0.6993773579597473, "tokens_seen": 1720320000, "tokens_per_second": 115607}
+{"step": 14000, "validation_loss": 2.895466, "validation_perplexity": 18.0919}
+{"step": 14050, "max_steps": 24415, "train_loss": 2.814404, "learning_rate": 6.843677655565353e-05, "grad_norm": 0.6627041101455688, "tokens_seen": 1726464000, "tokens_per_second": 113444}
+{"step": 14100, "max_steps": 24415, "train_loss": 2.721513, "learning_rate": 6.800367270376977e-05, "grad_norm": 0.6665034294128418, "tokens_seen": 1732608000, "tokens_per_second": 115615}
+{"step": 14150, "max_steps": 24415, "train_loss": 2.683664, "learning_rate": 6.7571193621186e-05, "grad_norm": 0.6050234436988831, "tokens_seen": 1738752000, "tokens_per_second": 115613}
+{"step": 14200, "max_steps": 24415, "train_loss": 2.886776, "learning_rate": 6.713935794708225e-05, "grad_norm": 0.6370565891265869, "tokens_seen": 1744896000, "tokens_per_second": 115620}
+{"step": 14250, "max_steps": 24415, "train_loss": 2.712796, "learning_rate": 6.670818429290858e-05, "grad_norm": 0.6131051182746887, "tokens_seen": 1751040000, "tokens_per_second": 115631}
+{"step": 14300, "max_steps": 24415, "train_loss": 2.78503, "learning_rate": 6.6277691241583e-05, "grad_norm": 0.612759530544281, "tokens_seen": 1757184000, "tokens_per_second": 115644}
+{"step": 14350, "max_steps": 24415, "train_loss": 2.740587, "learning_rate": 6.584789734669072e-05, "grad_norm": 0.6165915131568909, "tokens_seen": 1763328000, "tokens_per_second": 115642}
+{"step": 14400, "max_steps": 24415, "train_loss": 2.870152, "learning_rate": 6.541882113168419e-05, "grad_norm": 0.6879968643188477, "tokens_seen": 1769472000, "tokens_per_second": 115640}
+{"step": 14450, "max_steps": 24415, "train_loss": 2.838705, "learning_rate": 6.499048108908511e-05, "grad_norm": 0.6072972416877747, "tokens_seen": 1775616000, "tokens_per_second": 115633}
+{"step": 14500, "max_steps": 24415, "train_loss": 2.752175, "learning_rate": 6.456289567968726e-05, "grad_norm": 0.6414802670478821, "tokens_seen": 1781760000, "tokens_per_second": 115631}
+{"step": 14550, "max_steps": 24415, "train_loss": 2.849361, "learning_rate": 6.41360833317609e-05, "grad_norm": 0.6170805096626282, "tokens_seen": 1787904000, "tokens_per_second": 115623}
+{"step": 14600, "max_steps": 24415, "train_loss": 2.782098, "learning_rate": 6.371006244025843e-05, "grad_norm": 0.6256428360939026, "tokens_seen": 1794048000, "tokens_per_second": 115589}
+{"step": 14650, "max_steps": 24415, "train_loss": 2.936581, "learning_rate": 6.32848513660219e-05, "grad_norm": 0.6580077409744263, "tokens_seen": 1800192000, "tokens_per_second": 115594}
+{"step": 14700, "max_steps": 24415, "train_loss": 2.845289, "learning_rate": 6.286046843499127e-05, "grad_norm": 0.6480897665023804, "tokens_seen": 1806336000, "tokens_per_second": 115546}
+{"step": 14750, "max_steps": 24415, "train_loss": 2.850777, "learning_rate": 6.243693193741497e-05, "grad_norm": 0.6406828761100769, "tokens_seen": 1812480000, "tokens_per_second": 115569}
+{"step": 14800, "max_steps": 24415, "train_loss": 2.725981, "learning_rate": 6.20142601270614e-05, "grad_norm": 0.7072864770889282, "tokens_seen": 1818624000, "tokens_per_second": 115645}
+{"step": 14850, "max_steps": 24415, "train_loss": 2.690922, "learning_rate": 6.15924712204323e-05, "grad_norm": 0.7200900912284851, "tokens_seen": 1824768000, "tokens_per_second": 115676}
+{"step": 14900, "max_steps": 24415, "train_loss": 2.866086, "learning_rate": 6.117158339597754e-05, "grad_norm": 0.6389758586883545, "tokens_seen": 1830912000, "tokens_per_second": 115629}
+{"step": 14950, "max_steps": 24415, "train_loss": 2.697815, "learning_rate": 6.075161479331188e-05, "grad_norm": 0.6718475818634033, "tokens_seen": 1837056000, "tokens_per_second": 115626}
+{"step": 15000, "max_steps": 24415, "train_loss": 2.823217, "learning_rate": 6.033258351243286e-05, "grad_norm": 0.6866132616996765, "tokens_seen": 1843200000, "tokens_per_second": 115586}
+{"step": 15000, "validation_loss": 2.890042, "validation_perplexity": 17.9941}
+Saved checkpoint: runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00015000
+{"step": 15050, "max_steps": 24415, "train_loss": 2.902357, "learning_rate": 5.991450761294112e-05, "grad_norm": 0.6383296251296997, "tokens_seen": 1849344000, "tokens_per_second": 111864}
+{"step": 15100, "max_steps": 24415, "train_loss": 2.827427, "learning_rate": 5.9497405113261604e-05, "grad_norm": 0.6769825220108032, "tokens_seen": 1855488000, "tokens_per_second": 115560}
+{"step": 15150, "max_steps": 24415, "train_loss": 2.633896, "learning_rate": 5.908129398986747e-05, "grad_norm": 0.6125101447105408, "tokens_seen": 1861632000, "tokens_per_second": 115565}
+{"step": 15200, "max_steps": 24415, "train_loss": 2.883741, "learning_rate": 5.866619217650488e-05, "grad_norm": 0.6056382060050964, "tokens_seen": 1867776000, "tokens_per_second": 115555}
+{"step": 15250, "max_steps": 24415, "train_loss": 2.786928, "learning_rate": 5.8252117563420435e-05, "grad_norm": 0.6179369688034058, "tokens_seen": 1873920000, "tokens_per_second": 115554}
+{"step": 15300, "max_steps": 24415, "train_loss": 2.869814, "learning_rate": 5.783908799658988e-05, "grad_norm": 0.589368462562561, "tokens_seen": 1880064000, "tokens_per_second": 115511}
+{"step": 15350, "max_steps": 24415, "train_loss": 2.79135, "learning_rate": 5.7427121276949194e-05, "grad_norm": 0.5995170474052429, "tokens_seen": 1886208000, "tokens_per_second": 115546}
+{"step": 15400, "max_steps": 24415, "train_loss": 2.735143, "learning_rate": 5.701623515962719e-05, "grad_norm": 0.6787047982215881, "tokens_seen": 1892352000, "tokens_per_second": 115503}
+{"step": 15450, "max_steps": 24415, "train_loss": 2.699596, "learning_rate": 5.660644735318049e-05, "grad_norm": 0.6562452912330627, "tokens_seen": 1898496000, "tokens_per_second": 115512}
+{"step": 15500, "max_steps": 24415, "train_loss": 2.916876, "learning_rate": 5.61977755188301e-05, "grad_norm": 0.6687349081039429, "tokens_seen": 1904640000, "tokens_per_second": 115433}
+{"step": 15550, "max_steps": 24415, "train_loss": 2.802557, "learning_rate": 5.579023726970045e-05, "grad_norm": 0.6334400177001953, "tokens_seen": 1910784000, "tokens_per_second": 115546}
+{"step": 15600, "max_steps": 24415, "train_loss": 2.887684, "learning_rate": 5.538385017006011e-05, "grad_norm": 0.6181633472442627, "tokens_seen": 1916928000, "tokens_per_second": 115636}
+{"step": 15650, "max_steps": 24415, "train_loss": 2.784732, "learning_rate": 5.4978631734564984e-05, "grad_norm": 0.6535164713859558, "tokens_seen": 1923072000, "tokens_per_second": 115668}
+{"step": 15700, "max_steps": 24415, "train_loss": 2.804852, "learning_rate": 5.457459942750329e-05, "grad_norm": 0.802883505821228, "tokens_seen": 1929216000, "tokens_per_second": 115642}
+{"step": 15750, "max_steps": 24415, "train_loss": 2.736158, "learning_rate": 5.4171770662043e-05, "grad_norm": 0.664082944393158, "tokens_seen": 1935360000, "tokens_per_second": 115632}
+{"step": 15800, "max_steps": 24415, "train_loss": 2.798161, "learning_rate": 5.37701627994812e-05, "grad_norm": 0.6006529927253723, "tokens_seen": 1941504000, "tokens_per_second": 115551}
+{"step": 15850, "max_steps": 24415, "train_loss": 2.810937, "learning_rate": 5.336979314849607e-05, "grad_norm": 0.6848961710929871, "tokens_seen": 1947648000, "tokens_per_second": 115517}
+{"step": 15900, "max_steps": 24415, "train_loss": 2.86459, "learning_rate": 5.297067896440069e-05, "grad_norm": 0.5799385905265808, "tokens_seen": 1953792000, "tokens_per_second": 115555}
+{"step": 15950, "max_steps": 24415, "train_loss": 2.862726, "learning_rate": 5.257283744839956e-05, "grad_norm": 0.6372018456459045, "tokens_seen": 1959936000, "tokens_per_second": 115553}
+{"step": 16000, "max_steps": 24415, "train_loss": 2.638452, "learning_rate": 5.2176285746847004e-05, "grad_norm": 0.622450590133667, "tokens_seen": 1966080000, "tokens_per_second": 115521}
+{"step": 16000, "validation_loss": 2.883631, "validation_perplexity": 17.8791}
+{"step": 16050, "max_steps": 24415, "train_loss": 2.759337, "learning_rate": 5.178104095050848e-05, "grad_norm": 0.6415831446647644, "tokens_seen": 1972224000, "tokens_per_second": 113344}
+{"step": 16100, "max_steps": 24415, "train_loss": 2.793138, "learning_rate": 5.13871200938238e-05, "grad_norm": 0.5900813341140747, "tokens_seen": 1978368000, "tokens_per_second": 115459}
+{"step": 16150, "max_steps": 24415, "train_loss": 2.735165, "learning_rate": 5.0994540154172984e-05, "grad_norm": 0.6464166641235352, "tokens_seen": 1984512000, "tokens_per_second": 115447}
+{"step": 16200, "max_steps": 24415, "train_loss": 2.77423, "learning_rate": 5.060331805114466e-05, "grad_norm": 0.6363893151283264, "tokens_seen": 1990656000, "tokens_per_second": 115414}
+{"step": 16250, "max_steps": 24415, "train_loss": 2.813646, "learning_rate": 5.0213470645806766e-05, "grad_norm": 0.6006516218185425, "tokens_seen": 1996800000, "tokens_per_second": 115415}
+{"step": 16300, "max_steps": 24415, "train_loss": 2.751798, "learning_rate": 4.982501473997987e-05, "grad_norm": 0.6130074858665466, "tokens_seen": 2002944000, "tokens_per_second": 115556}
+{"step": 16350, "max_steps": 24415, "train_loss": 2.581523, "learning_rate": 4.9437967075513156e-05, "grad_norm": 0.6909277439117432, "tokens_seen": 2009088000, "tokens_per_second": 115608}
+{"step": 16400, "max_steps": 24415, "train_loss": 2.735869, "learning_rate": 4.905234433356263e-05, "grad_norm": 0.6061579585075378, "tokens_seen": 2015232000, "tokens_per_second": 115618}
+{"step": 16450, "max_steps": 24415, "train_loss": 2.807998, "learning_rate": 4.8668163133872515e-05, "grad_norm": 0.6679533123970032, "tokens_seen": 2021376000, "tokens_per_second": 115633}
+{"step": 16500, "max_steps": 24415, "train_loss": 2.751439, "learning_rate": 4.8285440034058625e-05, "grad_norm": 0.6001737117767334, "tokens_seen": 2027520000, "tokens_per_second": 115605}
+{"step": 16550, "max_steps": 24415, "train_loss": 2.812106, "learning_rate": 4.790419152889506e-05, "grad_norm": 0.6463189721107483, "tokens_seen": 2033664000, "tokens_per_second": 115646}
+{"step": 16600, "max_steps": 24415, "train_loss": 2.806943, "learning_rate": 4.752443404960306e-05, "grad_norm": 0.589819073677063, "tokens_seen": 2039808000, "tokens_per_second": 115664}
+{"step": 16650, "max_steps": 24415, "train_loss": 2.696105, "learning_rate": 4.7146183963143024e-05, "grad_norm": 0.6867057085037231, "tokens_seen": 2045952000, "tokens_per_second": 115627}
+{"step": 16700, "max_steps": 24415, "train_loss": 2.667582, "learning_rate": 4.676945757150907e-05, "grad_norm": 0.6482738852500916, "tokens_seen": 2052096000, "tokens_per_second": 115647}
+{"step": 16750, "max_steps": 24415, "train_loss": 2.577223, "learning_rate": 4.639427111102632e-05, "grad_norm": 0.6611011028289795, "tokens_seen": 2058240000, "tokens_per_second": 115680}
+{"step": 16800, "max_steps": 24415, "train_loss": 2.715673, "learning_rate": 4.6020640751651346e-05, "grad_norm": 0.7082952260971069, "tokens_seen": 2064384000, "tokens_per_second": 115686}
+{"step": 16850, "max_steps": 24415, "train_loss": 2.767459, "learning_rate": 4.564858259627514e-05, "grad_norm": 0.612030565738678, "tokens_seen": 2070528000, "tokens_per_second": 115666}
+{"step": 16900, "max_steps": 24415, "train_loss": 2.778458, "learning_rate": 4.527811268002908e-05, "grad_norm": 0.6326088905334473, "tokens_seen": 2076672000, "tokens_per_second": 115642}
+{"step": 16950, "max_steps": 24415, "train_loss": 2.707249, "learning_rate": 4.4909246969594e-05, "grad_norm": 0.6098898649215698, "tokens_seen": 2082816000, "tokens_per_second": 115640}
+{"step": 17000, "max_steps": 24415, "train_loss": 2.895086, "learning_rate": 4.454200136251182e-05, "grad_norm": 0.5895346403121948, "tokens_seen": 2088960000, "tokens_per_second": 115704}
+{"step": 17000, "validation_loss": 2.878743, "validation_perplexity": 17.7919}
+{"step": 17050, "max_steps": 24415, "train_loss": 2.733071, "learning_rate": 4.417639168650056e-05, "grad_norm": 0.7047613859176636, "tokens_seen": 2095104000, "tokens_per_second": 113501}
+{"step": 17100, "max_steps": 24415, "train_loss": 2.790722, "learning_rate": 4.3812433698772194e-05, "grad_norm": 0.6512798070907593, "tokens_seen": 2101248000, "tokens_per_second": 115668}
+{"step": 17150, "max_steps": 24415, "train_loss": 2.787556, "learning_rate": 4.345014308535338e-05, "grad_norm": 0.6246313452720642, "tokens_seen": 2107392000, "tokens_per_second": 115608}
+{"step": 17200, "max_steps": 24415, "train_loss": 2.820263, "learning_rate": 4.308953546040962e-05, "grad_norm": 0.6640097498893738, "tokens_seen": 2113536000, "tokens_per_second": 115484}
+{"step": 17250, "max_steps": 24415, "train_loss": 2.645744, "learning_rate": 4.273062636557215e-05, "grad_norm": 0.6085199117660522, "tokens_seen": 2119680000, "tokens_per_second": 115510}
+{"step": 17300, "max_steps": 24415, "train_loss": 2.775353, "learning_rate": 4.2373431269268245e-05, "grad_norm": 0.7274950742721558, "tokens_seen": 2125824000, "tokens_per_second": 115548}
+{"step": 17350, "max_steps": 24415, "train_loss": 2.774427, "learning_rate": 4.201796556605439e-05, "grad_norm": 0.6599135994911194, "tokens_seen": 2131968000, "tokens_per_second": 115467}
+{"step": 17400, "max_steps": 24415, "train_loss": 2.784656, "learning_rate": 4.166424457595302e-05, "grad_norm": 0.6395982503890991, "tokens_seen": 2138112000, "tokens_per_second": 115483}
+{"step": 17450, "max_steps": 24415, "train_loss": 2.846176, "learning_rate": 4.131228354379201e-05, "grad_norm": 0.6397977471351624, "tokens_seen": 2144256000, "tokens_per_second": 115471}
+{"step": 17500, "max_steps": 24415, "train_loss": 2.925753, "learning_rate": 4.096209763854791e-05, "grad_norm": 0.6196093559265137, "tokens_seen": 2150400000, "tokens_per_second": 115394}
+{"step": 17550, "max_steps": 24415, "train_loss": 2.74457, "learning_rate": 4.061370195269189e-05, "grad_norm": 0.6290102601051331, "tokens_seen": 2156544000, "tokens_per_second": 115373}
+{"step": 17600, "max_steps": 24415, "train_loss": 2.70976, "learning_rate": 4.0267111501539575e-05, "grad_norm": 0.6314865350723267, "tokens_seen": 2162688000, "tokens_per_second": 115455}
+{"step": 17650, "max_steps": 24415, "train_loss": 2.808493, "learning_rate": 3.992234122260362e-05, "grad_norm": 0.6693544983863831, "tokens_seen": 2168832000, "tokens_per_second": 115637}
+{"step": 17700, "max_steps": 24415, "train_loss": 2.664855, "learning_rate": 3.957940597495023e-05, "grad_norm": 0.6201000809669495, "tokens_seen": 2174976000, "tokens_per_second": 115672}
+{"step": 17750, "max_steps": 24415, "train_loss": 2.847698, "learning_rate": 3.923832053855847e-05, "grad_norm": 0.6048368811607361, "tokens_seen": 2181120000, "tokens_per_second": 115660}
+{"step": 17800, "max_steps": 24415, "train_loss": 2.631377, "learning_rate": 3.889909961368344e-05, "grad_norm": 0.5928443670272827, "tokens_seen": 2187264000, "tokens_per_second": 115661}
+{"step": 17850, "max_steps": 24415, "train_loss": 2.685062, "learning_rate": 3.85617578202227e-05, "grad_norm": 0.6104403734207153, "tokens_seen": 2193408000, "tokens_per_second": 115674}
+{"step": 17900, "max_steps": 24415, "train_loss": 2.718334, "learning_rate": 3.8226309697086135e-05, "grad_norm": 0.6966298818588257, "tokens_seen": 2199552000, "tokens_per_second": 115707}
+{"step": 17950, "max_steps": 24415, "train_loss": 2.695795, "learning_rate": 3.789276970156935e-05, "grad_norm": 0.6385568380355835, "tokens_seen": 2205696000, "tokens_per_second": 115677}
+{"step": 18000, "max_steps": 24415, "train_loss": 2.832335, "learning_rate": 3.756115220873061e-05, "grad_norm": 0.6135808825492859, "tokens_seen": 2211840000, "tokens_per_second": 115656}
+{"step": 18000, "validation_loss": 2.874696, "validation_perplexity": 17.72}
+{"step": 18050, "max_steps": 24415, "train_loss": 2.773723, "learning_rate": 3.723147151077128e-05, "grad_norm": 0.6073247194290161, "tokens_seen": 2217984000, "tokens_per_second": 113427}
+{"step": 18100, "max_steps": 24415, "train_loss": 2.742398, "learning_rate": 3.69037418164199e-05, "grad_norm": 0.6289048790931702, "tokens_seen": 2224128000, "tokens_per_second": 115487}
+{"step": 18150, "max_steps": 24415, "train_loss": 2.613473, "learning_rate": 3.657797725031969e-05, "grad_norm": 0.6467992663383484, "tokens_seen": 2230272000, "tokens_per_second": 115556}
+{"step": 18200, "max_steps": 24415, "train_loss": 2.748806, "learning_rate": 3.6254191852419966e-05, "grad_norm": 0.6730474829673767, "tokens_seen": 2236416000, "tokens_per_second": 115559}
+{"step": 18250, "max_steps": 24415, "train_loss": 2.794285, "learning_rate": 3.593239957737087e-05, "grad_norm": 0.6612525582313538, "tokens_seen": 2242560000, "tokens_per_second": 115560}
+{"step": 18300, "max_steps": 24415, "train_loss": 2.714843, "learning_rate": 3.561261429392213e-05, "grad_norm": 0.6353873610496521, "tokens_seen": 2248704000, "tokens_per_second": 115549}
+{"step": 18350, "max_steps": 24415, "train_loss": 2.779381, "learning_rate": 3.5294849784325127e-05, "grad_norm": 0.5724009871482849, "tokens_seen": 2254848000, "tokens_per_second": 115511}
+{"step": 18400, "max_steps": 24415, "train_loss": 2.766123, "learning_rate": 3.49791197437391e-05, "grad_norm": 0.6544906497001648, "tokens_seen": 2260992000, "tokens_per_second": 115551}
+{"step": 18450, "max_steps": 24415, "train_loss": 2.741471, "learning_rate": 3.4665437779640766e-05, "grad_norm": 0.6024874448776245, "tokens_seen": 2267136000, "tokens_per_second": 115478}
+{"step": 18500, "max_steps": 24415, "train_loss": 2.701006, "learning_rate": 3.435381741123796e-05, "grad_norm": 0.6421911716461182, "tokens_seen": 2273280000, "tokens_per_second": 115466}
+{"step": 18550, "max_steps": 24415, "train_loss": 2.679634, "learning_rate": 3.404427206888688e-05, "grad_norm": 0.7828880548477173, "tokens_seen": 2279424000, "tokens_per_second": 115518}
+{"step": 18600, "max_steps": 24415, "train_loss": 2.690722, "learning_rate": 3.373681509351333e-05, "grad_norm": 0.7262030243873596, "tokens_seen": 2285568000, "tokens_per_second": 115651}
+{"step": 18650, "max_steps": 24415, "train_loss": 2.683981, "learning_rate": 3.343145973603772e-05, "grad_norm": 0.6637866497039795, "tokens_seen": 2291712000, "tokens_per_second": 115684}
+{"step": 18700, "max_steps": 24415, "train_loss": 2.810566, "learning_rate": 3.3128219156804e-05, "grad_norm": 0.6260550618171692, "tokens_seen": 2297856000, "tokens_per_second": 115682}
+{"step": 18750, "max_steps": 24415, "train_loss": 2.779154, "learning_rate": 3.282710642501238e-05, "grad_norm": 0.6040164828300476, "tokens_seen": 2304000000, "tokens_per_second": 115669}
+{"step": 18800, "max_steps": 24415, "train_loss": 2.774612, "learning_rate": 3.2528134518156235e-05, "grad_norm": 0.591951847076416, "tokens_seen": 2310144000, "tokens_per_second": 115609}
+{"step": 18850, "max_steps": 24415, "train_loss": 2.887604, "learning_rate": 3.223131632146259e-05, "grad_norm": 0.7033926844596863, "tokens_seen": 2316288000, "tokens_per_second": 115536}
+{"step": 18900, "max_steps": 24415, "train_loss": 2.66931, "learning_rate": 3.1936664627337e-05, "grad_norm": 0.6099238395690918, "tokens_seen": 2322432000, "tokens_per_second": 115559}
+{"step": 18950, "max_steps": 24415, "train_loss": 2.735053, "learning_rate": 3.164419213481199e-05, "grad_norm": 0.625353217124939, "tokens_seen": 2328576000, "tokens_per_second": 115573}
+{"step": 19000, "max_steps": 24415, "train_loss": 2.820366, "learning_rate": 3.135391144899995e-05, "grad_norm": 0.6075039505958557, "tokens_seen": 2334720000, "tokens_per_second": 115571}
+{"step": 19000, "validation_loss": 2.871389, "validation_perplexity": 17.6615}
+{"step": 19050, "max_steps": 24415, "train_loss": 2.712609, "learning_rate": 3.106583508054977e-05, "grad_norm": 0.5940249562263489, "tokens_seen": 2340864000, "tokens_per_second": 113400}
+{"step": 19100, "max_steps": 24415, "train_loss": 2.764279, "learning_rate": 3.077997544510766e-05, "grad_norm": 0.6305410861968994, "tokens_seen": 2347008000, "tokens_per_second": 115566}
+{"step": 19150, "max_steps": 24415, "train_loss": 2.63859, "learning_rate": 3.049634486278204e-05, "grad_norm": 0.6639687418937683, "tokens_seen": 2353152000, "tokens_per_second": 115546}
+{"step": 19200, "max_steps": 24415, "train_loss": 2.781917, "learning_rate": 3.0214955557612656e-05, "grad_norm": 0.6226011514663696, "tokens_seen": 2359296000, "tokens_per_second": 115559}
+{"step": 19250, "max_steps": 24415, "train_loss": 2.786218, "learning_rate": 2.9935819657043577e-05, "grad_norm": 0.5818777680397034, "tokens_seen": 2365440000, "tokens_per_second": 115539}
+{"step": 19300, "max_steps": 24415, "train_loss": 2.766167, "learning_rate": 2.9658949191400703e-05, "grad_norm": 0.5710976123809814, "tokens_seen": 2371584000, "tokens_per_second": 115537}
+{"step": 19350, "max_steps": 24415, "train_loss": 2.858842, "learning_rate": 2.9384356093373116e-05, "grad_norm": 0.6166850328445435, "tokens_seen": 2377728000, "tokens_per_second": 115525}
+{"step": 19400, "max_steps": 24415, "train_loss": 2.762764, "learning_rate": 2.9112052197498966e-05, "grad_norm": 0.6117745637893677, "tokens_seen": 2383872000, "tokens_per_second": 115610}
+{"step": 19450, "max_steps": 24415, "train_loss": 2.673555, "learning_rate": 2.8842049239655226e-05, "grad_norm": 0.6982988119125366, "tokens_seen": 2390016000, "tokens_per_second": 115678}
+{"step": 19500, "max_steps": 24415, "train_loss": 2.801038, "learning_rate": 2.8574358856552077e-05, "grad_norm": 0.5987298488616943, "tokens_seen": 2396160000, "tokens_per_second": 115661}
+{"step": 19550, "max_steps": 24415, "train_loss": 2.860203, "learning_rate": 2.830899258523124e-05, "grad_norm": 0.6768466234207153, "tokens_seen": 2402304000, "tokens_per_second": 115647}
+{"step": 19600, "max_steps": 24415, "train_loss": 2.757229, "learning_rate": 2.8045961862568865e-05, "grad_norm": 0.7006207704544067, "tokens_seen": 2408448000, "tokens_per_second": 115601}
+{"step": 19650, "max_steps": 24415, "train_loss": 2.685526, "learning_rate": 2.7785278024782547e-05, "grad_norm": 0.614594042301178, "tokens_seen": 2414592000, "tokens_per_second": 115549}
+{"step": 19700, "max_steps": 24415, "train_loss": 2.704333, "learning_rate": 2.752695230694275e-05, "grad_norm": 0.6088916659355164, "tokens_seen": 2420736000, "tokens_per_second": 115564}
+{"step": 19750, "max_steps": 24415, "train_loss": 2.555395, "learning_rate": 2.727099584248864e-05, "grad_norm": 0.6791955828666687, "tokens_seen": 2426880000, "tokens_per_second": 115597}
+{"step": 19800, "max_steps": 24415, "train_loss": 2.652574, "learning_rate": 2.701741966274819e-05, "grad_norm": 0.6295214295387268, "tokens_seen": 2433024000, "tokens_per_second": 115581}
+{"step": 19850, "max_steps": 24415, "train_loss": 2.805314, "learning_rate": 2.6766234696462827e-05, "grad_norm": 0.5992781519889832, "tokens_seen": 2439168000, "tokens_per_second": 115620}
+{"step": 19900, "max_steps": 24415, "train_loss": 2.779102, "learning_rate": 2.6517451769316337e-05, "grad_norm": 0.5922258496284485, "tokens_seen": 2445312000, "tokens_per_second": 115585}
+{"step": 19950, "max_steps": 24415, "train_loss": 2.606874, "learning_rate": 2.6271081603468357e-05, "grad_norm": 0.6390422582626343, "tokens_seen": 2451456000, "tokens_per_second": 115571}
+{"step": 20000, "max_steps": 24415, "train_loss": 2.831885, "learning_rate": 2.6027134817092206e-05, "grad_norm": 0.6103304028511047, "tokens_seen": 2457600000, "tokens_per_second": 115561}
+{"step": 20000, "validation_loss": 2.86737, "validation_perplexity": 17.5907}
+Saved checkpoint: runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00020000
+{"step": 20050, "max_steps": 24415, "train_loss": 2.725566, "learning_rate": 2.5785621923917355e-05, "grad_norm": 0.6002763509750366, "tokens_seen": 2463744000, "tokens_per_second": 111852}
+{"step": 20100, "max_steps": 24415, "train_loss": 2.882972, "learning_rate": 2.5546553332776153e-05, "grad_norm": 0.6204449534416199, "tokens_seen": 2469888000, "tokens_per_second": 115589}
+{"step": 20150, "max_steps": 24415, "train_loss": 2.607282, "learning_rate": 2.5309939347155386e-05, "grad_norm": 0.6274742484092712, "tokens_seen": 2476032000, "tokens_per_second": 115585}
+{"step": 20200, "max_steps": 24415, "train_loss": 2.657714, "learning_rate": 2.5075790164752117e-05, "grad_norm": 0.7395855188369751, "tokens_seen": 2482176000, "tokens_per_second": 115572}
+{"step": 20250, "max_steps": 24415, "train_loss": 2.80093, "learning_rate": 2.4844115877034186e-05, "grad_norm": 0.6137728095054626, "tokens_seen": 2488320000, "tokens_per_second": 115570}
+{"step": 20300, "max_steps": 24415, "train_loss": 2.673792, "learning_rate": 2.4614926468805284e-05, "grad_norm": 0.6156178712844849, "tokens_seen": 2494464000, "tokens_per_second": 115583}
+{"step": 20350, "max_steps": 24415, "train_loss": 2.843575, "learning_rate": 2.4388231817774697e-05, "grad_norm": 0.704043447971344, "tokens_seen": 2500608000, "tokens_per_second": 115584}
+{"step": 20400, "max_steps": 24415, "train_loss": 2.882671, "learning_rate": 2.4164041694131442e-05, "grad_norm": 0.6543155908584595, "tokens_seen": 2506752000, "tokens_per_second": 115685}
+{"step": 20450, "max_steps": 24415, "train_loss": 2.713107, "learning_rate": 2.3942365760123353e-05, "grad_norm": 0.6198663115501404, "tokens_seen": 2512896000, "tokens_per_second": 115752}
+{"step": 20500, "max_steps": 24415, "train_loss": 2.695461, "learning_rate": 2.372321356964054e-05, "grad_norm": 0.6344349384307861, "tokens_seen": 2519040000, "tokens_per_second": 115728}
+{"step": 20550, "max_steps": 24415, "train_loss": 2.793643, "learning_rate": 2.3506594567803688e-05, "grad_norm": 0.5910429358482361, "tokens_seen": 2525184000, "tokens_per_second": 115695}
+{"step": 20600, "max_steps": 24415, "train_loss": 2.825883, "learning_rate": 2.3292518090556933e-05, "grad_norm": 0.587986946105957, "tokens_seen": 2531328000, "tokens_per_second": 115675}
+{"step": 20650, "max_steps": 24415, "train_loss": 2.76228, "learning_rate": 2.3080993364265586e-05, "grad_norm": 0.672764778137207, "tokens_seen": 2537472000, "tokens_per_second": 115646}
+{"step": 20700, "max_steps": 24415, "train_loss": 2.885475, "learning_rate": 2.2872029505318372e-05, "grad_norm": 0.6077940464019775, "tokens_seen": 2543616000, "tokens_per_second": 115661}
+{"step": 20750, "max_steps": 24415, "train_loss": 2.764343, "learning_rate": 2.2665635519734637e-05, "grad_norm": 0.6056102514266968, "tokens_seen": 2549760000, "tokens_per_second": 115652}
+{"step": 20800, "max_steps": 24415, "train_loss": 2.62957, "learning_rate": 2.2461820302776146e-05, "grad_norm": 0.6368304491043091, "tokens_seen": 2555904000, "tokens_per_second": 115642}
+{"step": 20850, "max_steps": 24415, "train_loss": 2.761528, "learning_rate": 2.2260592638563736e-05, "grad_norm": 0.6025370359420776, "tokens_seen": 2562048000, "tokens_per_second": 115624}
+{"step": 20900, "max_steps": 24415, "train_loss": 2.83255, "learning_rate": 2.2061961199698666e-05, "grad_norm": 0.6237384676933289, "tokens_seen": 2568192000, "tokens_per_second": 115615}
+{"step": 20950, "max_steps": 24415, "train_loss": 2.722114, "learning_rate": 2.186593454688897e-05, "grad_norm": 0.6229617595672607, "tokens_seen": 2574336000, "tokens_per_second": 115642}
+{"step": 21000, "max_steps": 24415, "train_loss": 2.781463, "learning_rate": 2.167252112858037e-05, "grad_norm": 0.5941027402877808, "tokens_seen": 2580480000, "tokens_per_second": 115625}
+{"step": 21000, "validation_loss": 2.864438, "validation_perplexity": 17.5392}
+{"step": 21050, "max_steps": 24415, "train_loss": 2.72432, "learning_rate": 2.148172928059226e-05, "grad_norm": 0.6507408022880554, "tokens_seen": 2586624000, "tokens_per_second": 113491}
+{"step": 21100, "max_steps": 24415, "train_loss": 2.67957, "learning_rate": 2.1293567225758365e-05, "grad_norm": 0.6184972524642944, "tokens_seen": 2592768000, "tokens_per_second": 115608}
+{"step": 21150, "max_steps": 24415, "train_loss": 2.896593, "learning_rate": 2.1108043073572438e-05, "grad_norm": 0.5926744937896729, "tokens_seen": 2598912000, "tokens_per_second": 115619}
+{"step": 21200, "max_steps": 24415, "train_loss": 2.661033, "learning_rate": 2.0925164819838655e-05, "grad_norm": 0.65669846534729, "tokens_seen": 2605056000, "tokens_per_second": 115608}
+{"step": 21250, "max_steps": 24415, "train_loss": 2.70118, "learning_rate": 2.074494034632711e-05, "grad_norm": 0.6318796873092651, "tokens_seen": 2611200000, "tokens_per_second": 115653}
+{"step": 21300, "max_steps": 24415, "train_loss": 2.592898, "learning_rate": 2.0567377420434022e-05, "grad_norm": 0.630044162273407, "tokens_seen": 2617344000, "tokens_per_second": 115661}
+{"step": 21350, "max_steps": 24415, "train_loss": 2.703647, "learning_rate": 2.0392483694847048e-05, "grad_norm": 0.6456885933876038, "tokens_seen": 2623488000, "tokens_per_second": 115661}
+{"step": 21400, "max_steps": 24415, "train_loss": 2.721252, "learning_rate": 2.0220266707215445e-05, "grad_norm": 0.5997530221939087, "tokens_seen": 2629632000, "tokens_per_second": 115649}
+{"step": 21450, "max_steps": 24415, "train_loss": 2.855813, "learning_rate": 2.00507338798252e-05, "grad_norm": 0.6231884956359863, "tokens_seen": 2635776000, "tokens_per_second": 115664}
+{"step": 21500, "max_steps": 24415, "train_loss": 2.733331, "learning_rate": 1.9883892519279097e-05, "grad_norm": 0.5984932780265808, "tokens_seen": 2641920000, "tokens_per_second": 115628}
+{"step": 21550, "max_steps": 24415, "train_loss": 2.784818, "learning_rate": 1.9719749816181928e-05, "grad_norm": 0.5977855920791626, "tokens_seen": 2648064000, "tokens_per_second": 115644}
+{"step": 21600, "max_steps": 24415, "train_loss": 2.749432, "learning_rate": 1.9558312844830467e-05, "grad_norm": 0.5922501683235168, "tokens_seen": 2654208000, "tokens_per_second": 115647}
+{"step": 21650, "max_steps": 24415, "train_loss": 2.751568, "learning_rate": 1.939958856290866e-05, "grad_norm": 0.6253129839897156, "tokens_seen": 2660352000, "tokens_per_second": 115641}
+{"step": 21700, "max_steps": 24415, "train_loss": 2.851732, "learning_rate": 1.9243583811187723e-05, "grad_norm": 0.6306662559509277, "tokens_seen": 2666496000, "tokens_per_second": 115673}
+{"step": 21750, "max_steps": 24415, "train_loss": 2.777505, "learning_rate": 1.909030531323133e-05, "grad_norm": 0.6194624304771423, "tokens_seen": 2672640000, "tokens_per_second": 115657}
+{"step": 21800, "max_steps": 24415, "train_loss": 2.689925, "learning_rate": 1.8939759675105804e-05, "grad_norm": 0.6342402100563049, "tokens_seen": 2678784000, "tokens_per_second": 115669}
+{"step": 21850, "max_steps": 24415, "train_loss": 2.78969, "learning_rate": 1.879195338509549e-05, "grad_norm": 0.6131957173347473, "tokens_seen": 2684928000, "tokens_per_second": 115672}
+{"step": 21900, "max_steps": 24415, "train_loss": 2.616148, "learning_rate": 1.864689281342299e-05, "grad_norm": 0.6286548972129822, "tokens_seen": 2691072000, "tokens_per_second": 115696}
+{"step": 21950, "max_steps": 24415, "train_loss": 2.780351, "learning_rate": 1.8504584211974754e-05, "grad_norm": 0.6103248596191406, "tokens_seen": 2697216000, "tokens_per_second": 115681}
+{"step": 22000, "max_steps": 24415, "train_loss": 2.774347, "learning_rate": 1.8365033714031534e-05, "grad_norm": 0.6407751441001892, "tokens_seen": 2703360000, "tokens_per_second": 115697}
+{"step": 22000, "validation_loss": 2.861929, "validation_perplexity": 17.4952}
+{"step": 22050, "max_steps": 24415, "train_loss": 2.852945, "learning_rate": 1.8228247334004103e-05, "grad_norm": 0.6118343472480774, "tokens_seen": 2709504000, "tokens_per_second": 113499}
+{"step": 22100, "max_steps": 24415, "train_loss": 2.627281, "learning_rate": 1.8094230967173996e-05, "grad_norm": 0.6102780699729919, "tokens_seen": 2715648000, "tokens_per_second": 115659}
+{"step": 22150, "max_steps": 24415, "train_loss": 2.767095, "learning_rate": 1.79629903894395e-05, "grad_norm": 0.6172248721122742, "tokens_seen": 2721792000, "tokens_per_second": 115656}
+{"step": 22200, "max_steps": 24415, "train_loss": 2.762802, "learning_rate": 1.7834531257066644e-05, "grad_norm": 0.6430047154426575, "tokens_seen": 2727936000, "tokens_per_second": 115667}
+{"step": 22250, "max_steps": 24415, "train_loss": 2.763437, "learning_rate": 1.7708859106445492e-05, "grad_norm": 0.6189215779304504, "tokens_seen": 2734080000, "tokens_per_second": 115661}
+{"step": 22300, "max_steps": 24415, "train_loss": 2.864902, "learning_rate": 1.7585979353851473e-05, "grad_norm": 0.6051227450370789, "tokens_seen": 2740224000, "tokens_per_second": 115640}
+{"step": 22350, "max_steps": 24415, "train_loss": 2.78242, "learning_rate": 1.746589729521201e-05, "grad_norm": 0.6032001972198486, "tokens_seen": 2746368000, "tokens_per_second": 115630}
+{"step": 22400, "max_steps": 24415, "train_loss": 2.719381, "learning_rate": 1.7348618105878208e-05, "grad_norm": 0.6332842111587524, "tokens_seen": 2752512000, "tokens_per_second": 115634}
+{"step": 22450, "max_steps": 24415, "train_loss": 2.830464, "learning_rate": 1.7234146840401873e-05, "grad_norm": 0.6493021845817566, "tokens_seen": 2758656000, "tokens_per_second": 115615}
+{"step": 22500, "max_steps": 24415, "train_loss": 2.843654, "learning_rate": 1.7122488432317588e-05, "grad_norm": 0.6092942953109741, "tokens_seen": 2764800000, "tokens_per_second": 115618}
+{"step": 22550, "max_steps": 24415, "train_loss": 2.706203, "learning_rate": 1.701364769393017e-05, "grad_norm": 0.6111382842063904, "tokens_seen": 2770944000, "tokens_per_second": 115621}
+{"step": 22600, "max_steps": 24415, "train_loss": 2.776963, "learning_rate": 1.6907629316107217e-05, "grad_norm": 0.657183051109314, "tokens_seen": 2777088000, "tokens_per_second": 115621}
+{"step": 22650, "max_steps": 24415, "train_loss": 2.778902, "learning_rate": 1.6804437868076928e-05, "grad_norm": 0.608390212059021, "tokens_seen": 2783232000, "tokens_per_second": 115630}
+{"step": 22700, "max_steps": 24415, "train_loss": 2.763429, "learning_rate": 1.670407779723123e-05, "grad_norm": 0.6772242188453674, "tokens_seen": 2789376000, "tokens_per_second": 115635}
+{"step": 22750, "max_steps": 24415, "train_loss": 2.697392, "learning_rate": 1.6606553428934048e-05, "grad_norm": 0.8745754957199097, "tokens_seen": 2795520000, "tokens_per_second": 115629}
+{"step": 22800, "max_steps": 24415, "train_loss": 2.857977, "learning_rate": 1.6511868966334915e-05, "grad_norm": 0.6229487657546997, "tokens_seen": 2801664000, "tokens_per_second": 115645}
+{"step": 22850, "max_steps": 24415, "train_loss": 2.568233, "learning_rate": 1.6420028490187808e-05, "grad_norm": 0.6349725723266602, "tokens_seen": 2807808000, "tokens_per_second": 115634}
+{"step": 22900, "max_steps": 24415, "train_loss": 2.643429, "learning_rate": 1.633103595867531e-05, "grad_norm": 0.6417720317840576, "tokens_seen": 2813952000, "tokens_per_second": 115643}
+{"step": 22950, "max_steps": 24415, "train_loss": 2.868518, "learning_rate": 1.6244895207237968e-05, "grad_norm": 0.5957947969436646, "tokens_seen": 2820096000, "tokens_per_second": 115650}
+{"step": 23000, "max_steps": 24415, "train_loss": 2.711414, "learning_rate": 1.616160994840903e-05, "grad_norm": 0.6176562905311584, "tokens_seen": 2826240000, "tokens_per_second": 115621}
+{"step": 23000, "validation_loss": 2.860038, "validation_perplexity": 17.4622}
+{"step": 23050, "max_steps": 24415, "train_loss": 2.736907, "learning_rate": 1.608118377165442e-05, "grad_norm": 0.777596116065979, "tokens_seen": 2832384000, "tokens_per_second": 113486}
+{"step": 23100, "max_steps": 24415, "train_loss": 2.700006, "learning_rate": 1.6003620143218037e-05, "grad_norm": 0.6337012052536011, "tokens_seen": 2838528000, "tokens_per_second": 115625}
+{"step": 23150, "max_steps": 24415, "train_loss": 2.781038, "learning_rate": 1.5928922405972378e-05, "grad_norm": 0.6418102979660034, "tokens_seen": 2844672000, "tokens_per_second": 115618}
+{"step": 23200, "max_steps": 24415, "train_loss": 2.774231, "learning_rate": 1.5857093779274477e-05, "grad_norm": 0.6108967065811157, "tokens_seen": 2850816000, "tokens_per_second": 115636}
+{"step": 23250, "max_steps": 24415, "train_loss": 2.718765, "learning_rate": 1.5788137358827107e-05, "grad_norm": 0.6196231245994568, "tokens_seen": 2856960000, "tokens_per_second": 115648}
+{"step": 23300, "max_steps": 24415, "train_loss": 2.835135, "learning_rate": 1.572205611654541e-05, "grad_norm": 0.5968915820121765, "tokens_seen": 2863104000, "tokens_per_second": 115646}
+{"step": 23350, "max_steps": 24415, "train_loss": 2.845595, "learning_rate": 1.5658852900428792e-05, "grad_norm": 0.6030846834182739, "tokens_seen": 2869248000, "tokens_per_second": 115626}
+{"step": 23400, "max_steps": 24415, "train_loss": 2.771462, "learning_rate": 1.5598530434438176e-05, "grad_norm": 0.6051156520843506, "tokens_seen": 2875392000, "tokens_per_second": 115623}
+{"step": 23450, "max_steps": 24415, "train_loss": 2.774949, "learning_rate": 1.55410913183786e-05, "grad_norm": 0.60307776927948, "tokens_seen": 2881536000, "tokens_per_second": 115646}
+{"step": 23500, "max_steps": 24415, "train_loss": 2.73786, "learning_rate": 1.5486538027787192e-05, "grad_norm": 0.6082613468170166, "tokens_seen": 2887680000, "tokens_per_second": 115662}
+{"step": 23550, "max_steps": 24415, "train_loss": 2.694792, "learning_rate": 1.5434872913826446e-05, "grad_norm": 0.6187634468078613, "tokens_seen": 2893824000, "tokens_per_second": 115659}
+{"step": 23600, "max_steps": 24415, "train_loss": 2.712125, "learning_rate": 1.5386098203182932e-05, "grad_norm": 0.6332436800003052, "tokens_seen": 2899968000, "tokens_per_second": 115666}
+{"step": 23650, "max_steps": 24415, "train_loss": 2.709451, "learning_rate": 1.5340215997971285e-05, "grad_norm": 0.6231958866119385, "tokens_seen": 2906112000, "tokens_per_second": 115629}
+{"step": 23700, "max_steps": 24415, "train_loss": 2.908402, "learning_rate": 1.5297228275643623e-05, "grad_norm": 0.625374972820282, "tokens_seen": 2912256000, "tokens_per_second": 115644}
+{"step": 23750, "max_steps": 24415, "train_loss": 2.825391, "learning_rate": 1.5257136888904332e-05, "grad_norm": 0.6172897815704346, "tokens_seen": 2918400000, "tokens_per_second": 115627}
+{"step": 23800, "max_steps": 24415, "train_loss": 2.777977, "learning_rate": 1.5219943565630226e-05, "grad_norm": 0.6453419327735901, "tokens_seen": 2924544000, "tokens_per_second": 115656}
+{"step": 23850, "max_steps": 24415, "train_loss": 2.808457, "learning_rate": 1.5185649908796045e-05, "grad_norm": 0.6297765374183655, "tokens_seen": 2930688000, "tokens_per_second": 115677}
+{"step": 23900, "max_steps": 24415, "train_loss": 2.827693, "learning_rate": 1.5154257396405384e-05, "grad_norm": 0.6233020424842834, "tokens_seen": 2936832000, "tokens_per_second": 115662}
+{"step": 23950, "max_steps": 24415, "train_loss": 2.777882, "learning_rate": 1.5125767381427013e-05, "grad_norm": 0.5891589522361755, "tokens_seen": 2942976000, "tokens_per_second": 115657}
+{"step": 24000, "max_steps": 24415, "train_loss": 2.750225, "learning_rate": 1.5100181091736548e-05, "grad_norm": 0.5986984372138977, "tokens_seen": 2949120000, "tokens_per_second": 115623}
+{"step": 24000, "validation_loss": 2.858127, "validation_perplexity": 17.4289}
+{"step": 24050, "max_steps": 24415, "train_loss": 2.746184, "learning_rate": 1.507749963006351e-05, "grad_norm": 0.6033036708831787, "tokens_seen": 2955264000, "tokens_per_second": 113453}
+{"step": 24100, "max_steps": 24415, "train_loss": 2.776009, "learning_rate": 1.505772397394384e-05, "grad_norm": 0.6058425307273865, "tokens_seen": 2961408000, "tokens_per_second": 115635}
+{"step": 24150, "max_steps": 24415, "train_loss": 2.701993, "learning_rate": 1.504085497567777e-05, "grad_norm": 0.6101545095443726, "tokens_seen": 2967552000, "tokens_per_second": 115660}
+{"step": 24200, "max_steps": 24415, "train_loss": 2.651574, "learning_rate": 1.5026893362293033e-05, "grad_norm": 0.6251341700553894, "tokens_seen": 2973696000, "tokens_per_second": 115664}
+{"step": 24250, "max_steps": 24415, "train_loss": 2.731524, "learning_rate": 1.501583973551359e-05, "grad_norm": 0.6173787117004395, "tokens_seen": 2979840000, "tokens_per_second": 115673}
+{"step": 24300, "max_steps": 24415, "train_loss": 2.854924, "learning_rate": 1.5007694571733676e-05, "grad_norm": 0.607036292552948, "tokens_seen": 2985984000, "tokens_per_second": 115666}
+{"step": 24350, "max_steps": 24415, "train_loss": 2.92489, "learning_rate": 1.5002458221997248e-05, "grad_norm": 0.6901952624320984, "tokens_seen": 2992128000, "tokens_per_second": 115680}
+{"step": 24400, "max_steps": 24415, "train_loss": 2.692121, "learning_rate": 1.5000130911982901e-05, "grad_norm": 0.6857115030288696, "tokens_seen": 2998272000, "tokens_per_second": 115647}
+Final checkpoint: runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415
diff --git a/reports/fixed-recovery-6b/byte-evaluation.json b/reports/fixed-recovery-6b/byte-evaluation.json
new file mode 100644
index 0000000000000000000000000000000000000000..e8022dea1ba1b8856b15fd72d43af76a6994e975
--- /dev/null
+++ b/reports/fixed-recovery-6b/byte-evaluation.json
@@ -0,0 +1,17 @@
+{
+  "checkpoint": "/workspace/KAWK50M/runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147",
+  "tokenizer": "/workspace/KAWK50M/runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147/tokenizer",
+  "inputs": [
+    "/workspace/KAWK50M/data/clean-v2-full/validation-00000.jsonl"
+  ],
+  "documents": 500,
+  "characters": 792512,
+  "utf8_bytes": 1888545,
+  "predicted_tokens": 418575,
+  "context_length": 1024,
+  "token_nll": 2.8874621830420604,
+  "token_perplexity": 17.947703769418208,
+  "nats_per_character": 1.525048810954068,
+  "bits_per_utf8_byte": 0.9232871521890333,
+  "note": "Compare bits_per_utf8_byte only when checkpoints are evaluated on the exact same ordered raw-text documents."
+}
diff --git a/reports/fixed-recovery-6b/final_checkpoint.txt b/reports/fixed-recovery-6b/final_checkpoint.txt
new file mode 100644
index 0000000000000000000000000000000000000000..659a2f415b1502752d62baf3fe10d35b207eb6c1
--- /dev/null
+++ b/reports/fixed-recovery-6b/final_checkpoint.txt
@@ -0,0 +1 @@
+runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147
diff --git a/reports/fixed-recovery-6b/train.log b/reports/fixed-recovery-6b/train.log
new file mode 100644
index 0000000000000000000000000000000000000000..f711d40c3694444c50f13264a66a52e90cbeca87
--- /dev/null
+++ b/reports/fixed-recovery-6b/train.log
@@ -0,0 +1,423 @@
+{
+  "parameters": 51542528,
+  "device": "cuda:0",
+  "world_size": 1,
+  "sequence_length": 1024,
+  "training_sample_offset": 976640,
+  "tokens_per_optimizer_step": 131072,
+  "max_steps": 38147,
+  "planned_tokens": 5000003584,
+  "start_step": 0,
+  "initialized_from": "/workspace/KAWK50M/runs/kawk50m-fixed-recovery-1b-5090/checkpoint-00007630",
+  "precision": "bf16",
+  "compile": true
+}
+{"step": 1, "max_steps": 38147, "train_loss": 2.974643, "learning_rate": 2.6212319790301444e-07, "grad_norm": 0.4614468216896057, "tokens_seen": 131072, "tokens_per_second": 46891}
+{"step": 100, "max_steps": 38147, "train_loss": 2.908479, "learning_rate": 2.6212319790301444e-05, "grad_norm": 0.48229220509529114, "tokens_seen": 13107200, "tokens_per_second": 266634}
+{"step": 200, "max_steps": 38147, "train_loss": 2.938294, "learning_rate": 5.242463958060289e-05, "grad_norm": 0.48655542731285095, "tokens_seen": 26214400, "tokens_per_second": 266632}
+{"step": 300, "max_steps": 38147, "train_loss": 2.881706, "learning_rate": 7.863695937090433e-05, "grad_norm": 0.481501966714859, "tokens_seen": 39321600, "tokens_per_second": 266703}
+{"step": 400, "max_steps": 38147, "train_loss": 2.942861, "learning_rate": 0.00010484927916120577, "grad_norm": 0.5160865187644958, "tokens_seen": 52428800, "tokens_per_second": 266702}
+{"step": 500, "max_steps": 38147, "train_loss": 2.871376, "learning_rate": 0.00013106159895150723, "grad_norm": 0.5494230389595032, "tokens_seen": 65536000, "tokens_per_second": 266629}
+{"step": 600, "max_steps": 38147, "train_loss": 2.985494, "learning_rate": 0.00015727391874180866, "grad_norm": 0.560945451259613, "tokens_seen": 78643200, "tokens_per_second": 266656}
+{"step": 700, "max_steps": 38147, "train_loss": 2.941133, "learning_rate": 0.00018348623853211012, "grad_norm": 0.552539587020874, "tokens_seen": 91750400, "tokens_per_second": 266689}
+{"step": 800, "max_steps": 38147, "train_loss": 2.933866, "learning_rate": 0.0001999995649453435, "grad_norm": 0.5684460401535034, "tokens_seen": 104857600, "tokens_per_second": 266656}
+{"step": 900, "max_steps": 38147, "train_loss": 2.923692, "learning_rate": 0.00019999403545855837, "grad_norm": 0.5598779320716858, "tokens_seen": 117964800, "tokens_per_second": 266536}
+{"step": 1000, "max_steps": 38147, "train_loss": 2.863725, "learning_rate": 0.00019998215062313029, "grad_norm": 0.5328158736228943, "tokens_seen": 131072000, "tokens_per_second": 266536}
+{"step": 1100, "max_steps": 38147, "train_loss": 2.988881, "learning_rate": 0.00019996391127836236, "grad_norm": 0.5750011205673218, "tokens_seen": 144179200, "tokens_per_second": 266535}
+{"step": 1200, "max_steps": 38147, "train_loss": 2.960122, "learning_rate": 0.00019993931871231102, "grad_norm": 0.5375710725784302, "tokens_seen": 157286400, "tokens_per_second": 266542}
+{"step": 1300, "max_steps": 38147, "train_loss": 2.945494, "learning_rate": 0.00019990837466169503, "grad_norm": 0.5387780070304871, "tokens_seen": 170393600, "tokens_per_second": 266548}
+{"step": 1400, "max_steps": 38147, "train_loss": 2.960481, "learning_rate": 0.00019987108131177292, "grad_norm": 0.5903465151786804, "tokens_seen": 183500800, "tokens_per_second": 266531}
+{"step": 1500, "max_steps": 38147, "train_loss": 2.951986, "learning_rate": 0.0001998274412961885, "grad_norm": 0.5386484861373901, "tokens_seen": 196608000, "tokens_per_second": 266531}
+{"step": 1600, "max_steps": 38147, "train_loss": 2.979607, "learning_rate": 0.00019977745769678514, "grad_norm": 0.5697662830352783, "tokens_seen": 209715200, "tokens_per_second": 266557}
+{"step": 1700, "max_steps": 38147, "train_loss": 2.934249, "learning_rate": 0.0001997211340433878, "grad_norm": 0.5244824290275574, "tokens_seen": 222822400, "tokens_per_second": 266522}
+{"step": 1800, "max_steps": 38147, "train_loss": 2.874219, "learning_rate": 0.00019965847431355408, "grad_norm": 0.5934562683105469, "tokens_seen": 235929600, "tokens_per_second": 266475}
+{"step": 1900, "max_steps": 38147, "train_loss": 3.009789, "learning_rate": 0.0001995894829322931, "grad_norm": 0.5320238471031189, "tokens_seen": 249036800, "tokens_per_second": 266516}
+{"step": 2000, "max_steps": 38147, "train_loss": 3.027504, "learning_rate": 0.00019951416477175313, "grad_norm": 0.5308347940444946, "tokens_seen": 262144000, "tokens_per_second": 266528}
+{"step": 2000, "validation_loss": 3.035152, "validation_perplexity": 20.8041}
+{"step": 2100, "max_steps": 38147, "train_loss": 2.92116, "learning_rate": 0.00019943252515087738, "grad_norm": 0.5231989026069641, "tokens_seen": 275251200, "tokens_per_second": 248528}
+{"step": 2200, "max_steps": 38147, "train_loss": 2.995961, "learning_rate": 0.00019934456983502856, "grad_norm": 0.5607808828353882, "tokens_seen": 288358400, "tokens_per_second": 266498}
+{"step": 2300, "max_steps": 38147, "train_loss": 2.959142, "learning_rate": 0.0001992503050355816, "grad_norm": 0.552680253982544, "tokens_seen": 301465600, "tokens_per_second": 266486}
+{"step": 2400, "max_steps": 38147, "train_loss": 2.962559, "learning_rate": 0.00019914973740948512, "grad_norm": 0.555330753326416, "tokens_seen": 314572800, "tokens_per_second": 266467}
+{"step": 2500, "max_steps": 38147, "train_loss": 2.967474, "learning_rate": 0.00019904287405879116, "grad_norm": 0.5409094095230103, "tokens_seen": 327680000, "tokens_per_second": 266534}
+{"step": 2600, "max_steps": 38147, "train_loss": 2.935567, "learning_rate": 0.00019892972253015371, "grad_norm": 0.560372531414032, "tokens_seen": 340787200, "tokens_per_second": 266536}
+{"step": 2700, "max_steps": 38147, "train_loss": 3.014029, "learning_rate": 0.0001988102908142959, "grad_norm": 0.5003385543823242, "tokens_seen": 353894400, "tokens_per_second": 266545}
+{"step": 2800, "max_steps": 38147, "train_loss": 2.960769, "learning_rate": 0.00019868458734544547, "grad_norm": 0.553016722202301, "tokens_seen": 367001600, "tokens_per_second": 266548}
+{"step": 2900, "max_steps": 38147, "train_loss": 2.940143, "learning_rate": 0.00019855262100073925, "grad_norm": 0.49712949991226196, "tokens_seen": 380108800, "tokens_per_second": 266549}
+{"step": 3000, "max_steps": 38147, "train_loss": 2.85196, "learning_rate": 0.00019841440109959638, "grad_norm": 0.5317330360412598, "tokens_seen": 393216000, "tokens_per_second": 266495}
+{"step": 3100, "max_steps": 38147, "train_loss": 2.877238, "learning_rate": 0.00019826993740305993, "grad_norm": 0.537623405456543, "tokens_seen": 406323200, "tokens_per_second": 266546}
+{"step": 3200, "max_steps": 38147, "train_loss": 2.941891, "learning_rate": 0.00019811924011310777, "grad_norm": 0.5330936312675476, "tokens_seen": 419430400, "tokens_per_second": 266551}
+{"step": 3300, "max_steps": 38147, "train_loss": 3.023407, "learning_rate": 0.0001979623198719321, "grad_norm": 0.5457956194877625, "tokens_seen": 432537600, "tokens_per_second": 266546}
+{"step": 3400, "max_steps": 38147, "train_loss": 3.006085, "learning_rate": 0.00019779918776118772, "grad_norm": 0.5238074660301208, "tokens_seen": 445644800, "tokens_per_second": 266553}
+{"step": 3500, "max_steps": 38147, "train_loss": 2.975786, "learning_rate": 0.00019762985530120971, "grad_norm": 0.5653413534164429, "tokens_seen": 458752000, "tokens_per_second": 266553}
+{"step": 3600, "max_steps": 38147, "train_loss": 2.91367, "learning_rate": 0.00019745433445019964, "grad_norm": 0.5223200917243958, "tokens_seen": 471859200, "tokens_per_second": 266552}
+{"step": 3700, "max_steps": 38147, "train_loss": 2.930792, "learning_rate": 0.00019727263760338127, "grad_norm": 0.5368753671646118, "tokens_seen": 484966400, "tokens_per_second": 266565}
+{"step": 3800, "max_steps": 38147, "train_loss": 3.004488, "learning_rate": 0.000197084777592125, "grad_norm": 0.5460859537124634, "tokens_seen": 498073600, "tokens_per_second": 266578}
+{"step": 3900, "max_steps": 38147, "train_loss": 2.976407, "learning_rate": 0.00019689076768304197, "grad_norm": 0.5260820984840393, "tokens_seen": 511180800, "tokens_per_second": 266564}
+{"step": 4000, "max_steps": 38147, "train_loss": 2.959824, "learning_rate": 0.00019669062157704693, "grad_norm": 0.5276979804039001, "tokens_seen": 524288000, "tokens_per_second": 266553}
+{"step": 4000, "validation_loss": 3.024725, "validation_perplexity": 20.5883}
+{"step": 4100, "max_steps": 38147, "train_loss": 3.067965, "learning_rate": 0.00019648435340839087, "grad_norm": 0.5293189883232117, "tokens_seen": 537395200, "tokens_per_second": 262466}
+{"step": 4200, "max_steps": 38147, "train_loss": 2.972997, "learning_rate": 0.0001962719777436628, "grad_norm": 0.5041415095329285, "tokens_seen": 550502400, "tokens_per_second": 266505}
+{"step": 4300, "max_steps": 38147, "train_loss": 2.953, "learning_rate": 0.00019605350958076104, "grad_norm": 0.5775559544563293, "tokens_seen": 563609600, "tokens_per_second": 266564}
+{"step": 4400, "max_steps": 38147, "train_loss": 2.909318, "learning_rate": 0.00019582896434783403, "grad_norm": 0.6295892596244812, "tokens_seen": 576716800, "tokens_per_second": 266552}
+{"step": 4500, "max_steps": 38147, "train_loss": 2.940704, "learning_rate": 0.00019559835790219094, "grad_norm": 0.512575089931488, "tokens_seen": 589824000, "tokens_per_second": 266556}
+{"step": 4600, "max_steps": 38147, "train_loss": 2.884395, "learning_rate": 0.00019536170652918175, "grad_norm": 0.5334091186523438, "tokens_seen": 602931200, "tokens_per_second": 266554}
+{"step": 4700, "max_steps": 38147, "train_loss": 2.972331, "learning_rate": 0.0001951190269410471, "grad_norm": 0.52705317735672, "tokens_seen": 616038400, "tokens_per_second": 266553}
+{"step": 4800, "max_steps": 38147, "train_loss": 2.907125, "learning_rate": 0.00019487033627573833, "grad_norm": 0.5539998412132263, "tokens_seen": 629145600, "tokens_per_second": 266678}
+{"step": 4900, "max_steps": 38147, "train_loss": 2.931528, "learning_rate": 0.0001946156520957068, "grad_norm": 0.5631355047225952, "tokens_seen": 642252800, "tokens_per_second": 266645}
+{"step": 5000, "max_steps": 38147, "train_loss": 2.89311, "learning_rate": 0.00019435499238666415, "grad_norm": 0.5504894852638245, "tokens_seen": 655360000, "tokens_per_second": 266553}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00005000
+{"step": 5100, "max_steps": 38147, "train_loss": 3.031921, "learning_rate": 0.0001940883755563116, "grad_norm": 0.5478340983390808, "tokens_seen": 668467200, "tokens_per_second": 263557}
+{"step": 5200, "max_steps": 38147, "train_loss": 2.886816, "learning_rate": 0.00019381582043304047, "grad_norm": 0.5800094604492188, "tokens_seen": 681574400, "tokens_per_second": 266566}
+{"step": 5300, "max_steps": 38147, "train_loss": 2.953113, "learning_rate": 0.0001935373462646023, "grad_norm": 0.5333589911460876, "tokens_seen": 694681600, "tokens_per_second": 266559}
+{"step": 5400, "max_steps": 38147, "train_loss": 2.936551, "learning_rate": 0.00019325297271674955, "grad_norm": 0.5394105911254883, "tokens_seen": 707788800, "tokens_per_second": 266519}
+{"step": 5500, "max_steps": 38147, "train_loss": 3.012462, "learning_rate": 0.00019296271987184695, "grad_norm": 2.051757335662842, "tokens_seen": 720896000, "tokens_per_second": 266554}
+{"step": 5600, "max_steps": 38147, "train_loss": 2.913292, "learning_rate": 0.0001926666082274532, "grad_norm": 0.48872488737106323, "tokens_seen": 734003200, "tokens_per_second": 266553}
+{"step": 5700, "max_steps": 38147, "train_loss": 2.958948, "learning_rate": 0.00019236465869487346, "grad_norm": 0.5317707061767578, "tokens_seen": 747110400, "tokens_per_second": 266557}
+{"step": 5800, "max_steps": 38147, "train_loss": 2.885794, "learning_rate": 0.00019205689259768255, "grad_norm": 0.531381368637085, "tokens_seen": 760217600, "tokens_per_second": 266527}
+{"step": 5900, "max_steps": 38147, "train_loss": 2.895442, "learning_rate": 0.00019174333167021923, "grad_norm": 0.5155215263366699, "tokens_seen": 773324800, "tokens_per_second": 266491}
+{"step": 6000, "max_steps": 38147, "train_loss": 2.999445, "learning_rate": 0.00019142399805605113, "grad_norm": 0.526485800743103, "tokens_seen": 786432000, "tokens_per_second": 266492}
+{"step": 6000, "validation_loss": 3.016271, "validation_perplexity": 20.415}
+{"step": 6100, "max_steps": 38147, "train_loss": 2.872324, "learning_rate": 0.00019109891430641113, "grad_norm": 0.5473472476005554, "tokens_seen": 799539200, "tokens_per_second": 262481}
+{"step": 6200, "max_steps": 38147, "train_loss": 2.965532, "learning_rate": 0.00019076810337860484, "grad_norm": 0.5530160665512085, "tokens_seen": 812646400, "tokens_per_second": 266569}
+{"step": 6300, "max_steps": 38147, "train_loss": 2.929472, "learning_rate": 0.00019043158863438905, "grad_norm": 0.5624988079071045, "tokens_seen": 825753600, "tokens_per_second": 266565}
+{"step": 6400, "max_steps": 38147, "train_loss": 3.024289, "learning_rate": 0.00019008939383832242, "grad_norm": 0.5274127125740051, "tokens_seen": 838860800, "tokens_per_second": 266559}
+{"step": 6500, "max_steps": 38147, "train_loss": 2.921005, "learning_rate": 0.00018974154315608673, "grad_norm": 1.0540344715118408, "tokens_seen": 851968000, "tokens_per_second": 266569}
+{"step": 6600, "max_steps": 38147, "train_loss": 2.875171, "learning_rate": 0.00018938806115278073, "grad_norm": 0.5187219977378845, "tokens_seen": 865075200, "tokens_per_second": 266489}
+{"step": 6700, "max_steps": 38147, "train_loss": 2.952179, "learning_rate": 0.00018902897279118503, "grad_norm": 0.5519692897796631, "tokens_seen": 878182400, "tokens_per_second": 266547}
+{"step": 6800, "max_steps": 38147, "train_loss": 2.921197, "learning_rate": 0.00018866430342999953, "grad_norm": 0.5296387076377869, "tokens_seen": 891289600, "tokens_per_second": 266540}
+{"step": 6900, "max_steps": 38147, "train_loss": 2.921925, "learning_rate": 0.00018829407882205238, "grad_norm": 0.5336331129074097, "tokens_seen": 904396800, "tokens_per_second": 266548}
+{"step": 7000, "max_steps": 38147, "train_loss": 2.952497, "learning_rate": 0.00018791832511248134, "grad_norm": 0.5777912735939026, "tokens_seen": 917504000, "tokens_per_second": 266556}
+{"step": 7100, "max_steps": 38147, "train_loss": 2.930704, "learning_rate": 0.00018753706883688757, "grad_norm": 0.5356543660163879, "tokens_seen": 930611200, "tokens_per_second": 266559}
+{"step": 7200, "max_steps": 38147, "train_loss": 2.931836, "learning_rate": 0.0001871503369194616, "grad_norm": 0.5299394726753235, "tokens_seen": 943718400, "tokens_per_second": 266553}
+{"step": 7300, "max_steps": 38147, "train_loss": 3.022099, "learning_rate": 0.0001867581566710818, "grad_norm": 0.5290271639823914, "tokens_seen": 956825600, "tokens_per_second": 266542}
+{"step": 7400, "max_steps": 38147, "train_loss": 2.938763, "learning_rate": 0.00018636055578738606, "grad_norm": 0.5280903577804565, "tokens_seen": 969932800, "tokens_per_second": 266567}
+{"step": 7500, "max_steps": 38147, "train_loss": 2.952468, "learning_rate": 0.00018595756234681554, "grad_norm": 0.5503072738647461, "tokens_seen": 983040000, "tokens_per_second": 266533}
+{"step": 7600, "max_steps": 38147, "train_loss": 2.917225, "learning_rate": 0.00018554920480863213, "grad_norm": 0.512189507484436, "tokens_seen": 996147200, "tokens_per_second": 266547}
+{"step": 7700, "max_steps": 38147, "train_loss": 3.027621, "learning_rate": 0.00018513551201090837, "grad_norm": 0.4862686097621918, "tokens_seen": 1009254400, "tokens_per_second": 266559}
+{"step": 7800, "max_steps": 38147, "train_loss": 2.924481, "learning_rate": 0.00018471651316849104, "grad_norm": 0.684536874294281, "tokens_seen": 1022361600, "tokens_per_second": 266557}
+{"step": 7900, "max_steps": 38147, "train_loss": 2.910758, "learning_rate": 0.00018429223787093813, "grad_norm": 0.5597535371780396, "tokens_seen": 1035468800, "tokens_per_second": 266492}
+{"step": 8000, "max_steps": 38147, "train_loss": 2.882389, "learning_rate": 0.00018386271608042903, "grad_norm": 0.5164158344268799, "tokens_seen": 1048576000, "tokens_per_second": 266536}
+{"step": 8000, "validation_loss": 3.005551, "validation_perplexity": 20.1973}
+{"step": 8100, "max_steps": 38147, "train_loss": 2.893677, "learning_rate": 0.00018342797812964868, "grad_norm": 0.6013792157173157, "tokens_seen": 1061683200, "tokens_per_second": 262444}
+{"step": 8200, "max_steps": 38147, "train_loss": 2.956927, "learning_rate": 0.0001829880547196456, "grad_norm": 0.509283185005188, "tokens_seen": 1074790400, "tokens_per_second": 266533}
+{"step": 8300, "max_steps": 38147, "train_loss": 2.899491, "learning_rate": 0.00018254297691766365, "grad_norm": 0.5559905171394348, "tokens_seen": 1087897600, "tokens_per_second": 266524}
+{"step": 8400, "max_steps": 38147, "train_loss": 2.907307, "learning_rate": 0.0001820927761549482, "grad_norm": 0.55206698179245, "tokens_seen": 1101004800, "tokens_per_second": 266528}
+{"step": 8500, "max_steps": 38147, "train_loss": 2.953202, "learning_rate": 0.0001816374842245262, "grad_norm": 0.5241593718528748, "tokens_seen": 1114112000, "tokens_per_second": 266526}
+{"step": 8600, "max_steps": 38147, "train_loss": 2.900405, "learning_rate": 0.0001811771332789614, "grad_norm": 0.49315375089645386, "tokens_seen": 1127219200, "tokens_per_second": 266537}
+{"step": 8700, "max_steps": 38147, "train_loss": 2.92854, "learning_rate": 0.0001807117558280834, "grad_norm": 0.4962051212787628, "tokens_seen": 1140326400, "tokens_per_second": 266539}
+{"step": 8800, "max_steps": 38147, "train_loss": 2.929634, "learning_rate": 0.00018024138473669184, "grad_norm": 0.5195844173431396, "tokens_seen": 1153433600, "tokens_per_second": 266526}
+{"step": 8900, "max_steps": 38147, "train_loss": 2.947764, "learning_rate": 0.0001797660532222357, "grad_norm": 0.5545597672462463, "tokens_seen": 1166540800, "tokens_per_second": 266539}
+{"step": 9000, "max_steps": 38147, "train_loss": 2.882339, "learning_rate": 0.00017928579485246732, "grad_norm": 0.4967882037162781, "tokens_seen": 1179648000, "tokens_per_second": 266544}
+{"step": 9100, "max_steps": 38147, "train_loss": 2.909407, "learning_rate": 0.00017880064354307192, "grad_norm": 0.5079694390296936, "tokens_seen": 1192755200, "tokens_per_second": 266606}
+{"step": 9200, "max_steps": 38147, "train_loss": 2.920727, "learning_rate": 0.0001783106335552725, "grad_norm": 0.5576598048210144, "tokens_seen": 1205862400, "tokens_per_second": 266686}
+{"step": 9300, "max_steps": 38147, "train_loss": 2.946483, "learning_rate": 0.00017781579949341023, "grad_norm": 0.5156830549240112, "tokens_seen": 1218969600, "tokens_per_second": 266692}
+{"step": 9400, "max_steps": 38147, "train_loss": 2.839191, "learning_rate": 0.00017731617630250087, "grad_norm": 0.53850257396698, "tokens_seen": 1232076800, "tokens_per_second": 266691}
+{"step": 9500, "max_steps": 38147, "train_loss": 2.911981, "learning_rate": 0.00017681179926576682, "grad_norm": 0.5162245035171509, "tokens_seen": 1245184000, "tokens_per_second": 266693}
+{"step": 9600, "max_steps": 38147, "train_loss": 2.913818, "learning_rate": 0.00017630270400214551, "grad_norm": 0.5505062341690063, "tokens_seen": 1258291200, "tokens_per_second": 266613}
+{"step": 9700, "max_steps": 38147, "train_loss": 2.902928, "learning_rate": 0.0001757889264637739, "grad_norm": 0.562888503074646, "tokens_seen": 1271398400, "tokens_per_second": 266500}
+{"step": 9800, "max_steps": 38147, "train_loss": 2.910159, "learning_rate": 0.00017527050293344976, "grad_norm": 0.4832836985588074, "tokens_seen": 1284505600, "tokens_per_second": 266541}
+{"step": 9900, "max_steps": 38147, "train_loss": 2.925041, "learning_rate": 0.00017474747002206906, "grad_norm": 0.5571316480636597, "tokens_seen": 1297612800, "tokens_per_second": 266555}
+{"step": 10000, "max_steps": 38147, "train_loss": 2.910882, "learning_rate": 0.00017421986466604087, "grad_norm": 0.5821037888526917, "tokens_seen": 1310720000, "tokens_per_second": 266535}
+{"step": 10000, "validation_loss": 2.998426, "validation_perplexity": 20.0539}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00010000
+{"step": 10100, "max_steps": 38147, "train_loss": 2.918626, "learning_rate": 0.00017368772412467876, "grad_norm": 0.5134103894233704, "tokens_seen": 1323827200, "tokens_per_second": 258816}
+{"step": 10200, "max_steps": 38147, "train_loss": 2.949979, "learning_rate": 0.0001731510859775695, "grad_norm": 0.517809271812439, "tokens_seen": 1336934400, "tokens_per_second": 266552}
+{"step": 10300, "max_steps": 38147, "train_loss": 2.850333, "learning_rate": 0.00017260998812191928, "grad_norm": 0.5122731328010559, "tokens_seen": 1350041600, "tokens_per_second": 266656}
+{"step": 10400, "max_steps": 38147, "train_loss": 2.913494, "learning_rate": 0.00017206446876987747, "grad_norm": 0.5601559281349182, "tokens_seen": 1363148800, "tokens_per_second": 266653}
+{"step": 10500, "max_steps": 38147, "train_loss": 2.944695, "learning_rate": 0.000171514566445838, "grad_norm": 0.5485866069793701, "tokens_seen": 1376256000, "tokens_per_second": 266595}
+{"step": 10600, "max_steps": 38147, "train_loss": 2.960809, "learning_rate": 0.00017096031998371883, "grad_norm": 0.5545159578323364, "tokens_seen": 1389363200, "tokens_per_second": 266695}
+{"step": 10700, "max_steps": 38147, "train_loss": 2.922663, "learning_rate": 0.0001704017685242195, "grad_norm": 0.5326966643333435, "tokens_seen": 1402470400, "tokens_per_second": 266706}
+{"step": 10800, "max_steps": 38147, "train_loss": 2.803973, "learning_rate": 0.00016983895151205695, "grad_norm": 0.5638318657875061, "tokens_seen": 1415577600, "tokens_per_second": 266714}
+{"step": 10900, "max_steps": 38147, "train_loss": 2.913323, "learning_rate": 0.00016927190869318014, "grad_norm": 0.5387423634529114, "tokens_seen": 1428684800, "tokens_per_second": 266714}
+{"step": 11000, "max_steps": 38147, "train_loss": 2.977563, "learning_rate": 0.00016870068011196296, "grad_norm": 0.5534170269966125, "tokens_seen": 1441792000, "tokens_per_second": 266630}
+{"step": 11100, "max_steps": 38147, "train_loss": 2.912593, "learning_rate": 0.00016812530610837656, "grad_norm": 0.5476948618888855, "tokens_seen": 1454899200, "tokens_per_second": 266525}
+{"step": 11200, "max_steps": 38147, "train_loss": 2.911587, "learning_rate": 0.00016754582731514031, "grad_norm": 0.5375077724456787, "tokens_seen": 1468006400, "tokens_per_second": 266531}
+{"step": 11300, "max_steps": 38147, "train_loss": 2.890766, "learning_rate": 0.00016696228465485258, "grad_norm": 0.5167133808135986, "tokens_seen": 1481113600, "tokens_per_second": 266563}
+{"step": 11400, "max_steps": 38147, "train_loss": 2.913491, "learning_rate": 0.00016637471933710052, "grad_norm": 0.532808244228363, "tokens_seen": 1494220800, "tokens_per_second": 266545}
+{"step": 11500, "max_steps": 38147, "train_loss": 2.982643, "learning_rate": 0.0001657831728555501, "grad_norm": 0.5288663506507874, "tokens_seen": 1507328000, "tokens_per_second": 266504}
+{"step": 11600, "max_steps": 38147, "train_loss": 2.890127, "learning_rate": 0.00016518768698501574, "grad_norm": 0.5118499994277954, "tokens_seen": 1520435200, "tokens_per_second": 266550}
+{"step": 11700, "max_steps": 38147, "train_loss": 2.871277, "learning_rate": 0.0001645883037785102, "grad_norm": 0.5694160461425781, "tokens_seen": 1533542400, "tokens_per_second": 266542}
+{"step": 11800, "max_steps": 38147, "train_loss": 2.863222, "learning_rate": 0.00016398506556427472, "grad_norm": 0.547090470790863, "tokens_seen": 1546649600, "tokens_per_second": 266559}
+{"step": 11900, "max_steps": 38147, "train_loss": 2.871399, "learning_rate": 0.00016337801494279, "grad_norm": 0.5254355072975159, "tokens_seen": 1559756800, "tokens_per_second": 266540}
+{"step": 12000, "max_steps": 38147, "train_loss": 2.99516, "learning_rate": 0.00016276719478376756, "grad_norm": 0.5378596782684326, "tokens_seen": 1572864000, "tokens_per_second": 266543}
+{"step": 12000, "validation_loss": 2.985874, "validation_perplexity": 19.8038}
+{"step": 12100, "max_steps": 38147, "train_loss": 2.946746, "learning_rate": 0.00016215264822312252, "grad_norm": 0.5134831070899963, "tokens_seen": 1585971200, "tokens_per_second": 262442}
+{"step": 12200, "max_steps": 38147, "train_loss": 2.963517, "learning_rate": 0.00016153441865992708, "grad_norm": 0.5186991095542908, "tokens_seen": 1599078400, "tokens_per_second": 266535}
+{"step": 12300, "max_steps": 38147, "train_loss": 2.86126, "learning_rate": 0.00016091254975334607, "grad_norm": 0.5443694591522217, "tokens_seen": 1612185600, "tokens_per_second": 266543}
+{"step": 12400, "max_steps": 38147, "train_loss": 2.944561, "learning_rate": 0.00016028708541955322, "grad_norm": 0.5636797547340393, "tokens_seen": 1625292800, "tokens_per_second": 266550}
+{"step": 12500, "max_steps": 38147, "train_loss": 2.981808, "learning_rate": 0.00015965806982863042, "grad_norm": 0.5743669867515564, "tokens_seen": 1638400000, "tokens_per_second": 266530}
+{"step": 12600, "max_steps": 38147, "train_loss": 2.898306, "learning_rate": 0.00015902554740144798, "grad_norm": 0.5469308495521545, "tokens_seen": 1651507200, "tokens_per_second": 266564}
+{"step": 12700, "max_steps": 38147, "train_loss": 2.9353, "learning_rate": 0.00015838956280652788, "grad_norm": 0.5421141982078552, "tokens_seen": 1664614400, "tokens_per_second": 266482}
+{"step": 12800, "max_steps": 38147, "train_loss": 2.948559, "learning_rate": 0.00015775016095688921, "grad_norm": 0.527752161026001, "tokens_seen": 1677721600, "tokens_per_second": 266554}
+{"step": 12900, "max_steps": 38147, "train_loss": 2.946706, "learning_rate": 0.00015710738700687641, "grad_norm": 0.5152209401130676, "tokens_seen": 1690828800, "tokens_per_second": 266539}
+{"step": 13000, "max_steps": 38147, "train_loss": 2.895772, "learning_rate": 0.0001564612863489706, "grad_norm": 0.5434118509292603, "tokens_seen": 1703936000, "tokens_per_second": 266556}
+{"step": 13100, "max_steps": 38147, "train_loss": 2.92532, "learning_rate": 0.00015581190461058382, "grad_norm": 0.5467553734779358, "tokens_seen": 1717043200, "tokens_per_second": 266552}
+{"step": 13200, "max_steps": 38147, "train_loss": 2.877013, "learning_rate": 0.00015515928765083694, "grad_norm": 0.5095875263214111, "tokens_seen": 1730150400, "tokens_per_second": 266496}
+{"step": 13300, "max_steps": 38147, "train_loss": 2.873789, "learning_rate": 0.00015450348155732105, "grad_norm": 0.5356979966163635, "tokens_seen": 1743257600, "tokens_per_second": 266480}
+{"step": 13400, "max_steps": 38147, "train_loss": 2.847629, "learning_rate": 0.00015384453264284288, "grad_norm": 0.5649926662445068, "tokens_seen": 1756364800, "tokens_per_second": 266547}
+{"step": 13500, "max_steps": 38147, "train_loss": 2.885597, "learning_rate": 0.00015318248744215408, "grad_norm": 0.5296280384063721, "tokens_seen": 1769472000, "tokens_per_second": 266545}
+{"step": 13600, "max_steps": 38147, "train_loss": 2.89902, "learning_rate": 0.00015251739270866492, "grad_norm": 0.5799275636672974, "tokens_seen": 1782579200, "tokens_per_second": 266542}
+{"step": 13700, "max_steps": 38147, "train_loss": 2.897563, "learning_rate": 0.00015184929541114275, "grad_norm": 0.5654956102371216, "tokens_seen": 1795686400, "tokens_per_second": 266541}
+{"step": 13800, "max_steps": 38147, "train_loss": 2.892543, "learning_rate": 0.000151178242730395, "grad_norm": 0.5284501910209656, "tokens_seen": 1808793600, "tokens_per_second": 266547}
+{"step": 13900, "max_steps": 38147, "train_loss": 2.927978, "learning_rate": 0.0001505042820559372, "grad_norm": 0.5702105164527893, "tokens_seen": 1821900800, "tokens_per_second": 266544}
+{"step": 14000, "max_steps": 38147, "train_loss": 2.85512, "learning_rate": 0.00014982746098264648, "grad_norm": 0.5716403126716614, "tokens_seen": 1835008000, "tokens_per_second": 266603}
+{"step": 14000, "validation_loss": 2.978342, "validation_perplexity": 19.6552}
+{"step": 14100, "max_steps": 38147, "train_loss": 2.837504, "learning_rate": 0.00014914782730740032, "grad_norm": 0.5596545338630676, "tokens_seen": 1848115200, "tokens_per_second": 262606}
+{"step": 14200, "max_steps": 38147, "train_loss": 2.900359, "learning_rate": 0.00014846542902570122, "grad_norm": 0.5157343149185181, "tokens_seen": 1861222400, "tokens_per_second": 266660}
+{"step": 14300, "max_steps": 38147, "train_loss": 2.984998, "learning_rate": 0.00014778031432828738, "grad_norm": 0.546175479888916, "tokens_seen": 1874329600, "tokens_per_second": 266636}
+{"step": 14400, "max_steps": 38147, "train_loss": 2.799061, "learning_rate": 0.00014709253159772917, "grad_norm": 0.5169898271560669, "tokens_seen": 1887436800, "tokens_per_second": 266692}
+{"step": 14500, "max_steps": 38147, "train_loss": 2.93394, "learning_rate": 0.0001464021294050127, "grad_norm": 0.5111414790153503, "tokens_seen": 1900544000, "tokens_per_second": 266665}
+{"step": 14600, "max_steps": 38147, "train_loss": 2.874222, "learning_rate": 0.00014570915650610956, "grad_norm": 0.608252227306366, "tokens_seen": 1913651200, "tokens_per_second": 266542}
+{"step": 14700, "max_steps": 38147, "train_loss": 3.022098, "learning_rate": 0.0001450136618385338, "grad_norm": 0.520990788936615, "tokens_seen": 1926758400, "tokens_per_second": 266533}
+{"step": 14800, "max_steps": 38147, "train_loss": 2.967238, "learning_rate": 0.000144315694517886, "grad_norm": 0.5397151112556458, "tokens_seen": 1939865600, "tokens_per_second": 266544}
+{"step": 14900, "max_steps": 38147, "train_loss": 2.903136, "learning_rate": 0.00014361530383438445, "grad_norm": 0.5363152027130127, "tokens_seen": 1952972800, "tokens_per_second": 266545}
+{"step": 15000, "max_steps": 38147, "train_loss": 2.837465, "learning_rate": 0.00014291253924938468, "grad_norm": 0.5414167046546936, "tokens_seen": 1966080000, "tokens_per_second": 266519}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00015000
+{"step": 15100, "max_steps": 38147, "train_loss": 2.951748, "learning_rate": 0.00014220745039188626, "grad_norm": 0.756091833114624, "tokens_seen": 1979187200, "tokens_per_second": 262797}
+{"step": 15200, "max_steps": 38147, "train_loss": 2.910635, "learning_rate": 0.00014150008705502828, "grad_norm": 0.5328271985054016, "tokens_seen": 1992294400, "tokens_per_second": 266494}
+{"step": 15300, "max_steps": 38147, "train_loss": 2.890371, "learning_rate": 0.0001407904991925726, "grad_norm": 0.5145664215087891, "tokens_seen": 2005401600, "tokens_per_second": 266530}
+{"step": 15400, "max_steps": 38147, "train_loss": 2.915686, "learning_rate": 0.00014007873691537637, "grad_norm": 0.5268166065216064, "tokens_seen": 2018508800, "tokens_per_second": 266554}
+{"step": 15500, "max_steps": 38147, "train_loss": 2.906188, "learning_rate": 0.0001393648504878533, "grad_norm": 0.5345094203948975, "tokens_seen": 2031616000, "tokens_per_second": 266546}
+{"step": 15600, "max_steps": 38147, "train_loss": 2.892306, "learning_rate": 0.00013864889032442376, "grad_norm": 0.6043722629547119, "tokens_seen": 2044723200, "tokens_per_second": 266566}
+{"step": 15700, "max_steps": 38147, "train_loss": 2.841777, "learning_rate": 0.00013793090698595469, "grad_norm": 0.5641171336174011, "tokens_seen": 2057830400, "tokens_per_second": 266563}
+{"step": 15800, "max_steps": 38147, "train_loss": 2.899494, "learning_rate": 0.00013721095117618902, "grad_norm": 0.5548516511917114, "tokens_seen": 2070937600, "tokens_per_second": 266700}
+{"step": 15900, "max_steps": 38147, "train_loss": 2.935511, "learning_rate": 0.00013648907373816485, "grad_norm": 0.5173591375350952, "tokens_seen": 2084044800, "tokens_per_second": 266726}
+{"step": 16000, "max_steps": 38147, "train_loss": 2.883337, "learning_rate": 0.00013576532565062516, "grad_norm": 0.5861512422561646, "tokens_seen": 2097152000, "tokens_per_second": 266692}
+{"step": 16000, "validation_loss": 2.966163, "validation_perplexity": 19.4173}
+{"step": 16100, "max_steps": 38147, "train_loss": 2.869175, "learning_rate": 0.00013503975802441742, "grad_norm": 0.5603633522987366, "tokens_seen": 2110259200, "tokens_per_second": 262614}
+{"step": 16200, "max_steps": 38147, "train_loss": 2.987583, "learning_rate": 0.0001343124220988844, "grad_norm": 0.5374985337257385, "tokens_seen": 2123366400, "tokens_per_second": 266722}
+{"step": 16300, "max_steps": 38147, "train_loss": 2.914009, "learning_rate": 0.00013358336923824558, "grad_norm": 0.539892315864563, "tokens_seen": 2136473600, "tokens_per_second": 266726}
+{"step": 16400, "max_steps": 38147, "train_loss": 2.910758, "learning_rate": 0.0001328526509279698, "grad_norm": 0.5089977979660034, "tokens_seen": 2149580800, "tokens_per_second": 266615}
+{"step": 16500, "max_steps": 38147, "train_loss": 2.88835, "learning_rate": 0.00013212031877113932, "grad_norm": 0.5609439015388489, "tokens_seen": 2162688000, "tokens_per_second": 266680}
+{"step": 16600, "max_steps": 38147, "train_loss": 2.860655, "learning_rate": 0.00013138642448480594, "grad_norm": 0.5659797191619873, "tokens_seen": 2175795200, "tokens_per_second": 266558}
+{"step": 16700, "max_steps": 38147, "train_loss": 2.824591, "learning_rate": 0.00013065101989633818, "grad_norm": 0.5298318862915039, "tokens_seen": 2188902400, "tokens_per_second": 266556}
+{"step": 16800, "max_steps": 38147, "train_loss": 2.871027, "learning_rate": 0.00012991415693976193, "grad_norm": 0.5541119575500488, "tokens_seen": 2202009600, "tokens_per_second": 266524}
+{"step": 16900, "max_steps": 38147, "train_loss": 2.762313, "learning_rate": 0.0001291758876520923, "grad_norm": 0.5406379699707031, "tokens_seen": 2215116800, "tokens_per_second": 266500}
+{"step": 17000, "max_steps": 38147, "train_loss": 2.931732, "learning_rate": 0.0001284362641696591, "grad_norm": 0.5427020788192749, "tokens_seen": 2228224000, "tokens_per_second": 266486}
+{"step": 17100, "max_steps": 38147, "train_loss": 2.924223, "learning_rate": 0.00012769533872442502, "grad_norm": 0.5315942764282227, "tokens_seen": 2241331200, "tokens_per_second": 266557}
+{"step": 17200, "max_steps": 38147, "train_loss": 2.894472, "learning_rate": 0.00012695316364029683, "grad_norm": 0.5872063040733337, "tokens_seen": 2254438400, "tokens_per_second": 266562}
+{"step": 17300, "max_steps": 38147, "train_loss": 2.938319, "learning_rate": 0.00012620979132943033, "grad_norm": 0.5693638920783997, "tokens_seen": 2267545600, "tokens_per_second": 266570}
+{"step": 17400, "max_steps": 38147, "train_loss": 2.849607, "learning_rate": 0.00012546527428852923, "grad_norm": 0.5248034596443176, "tokens_seen": 2280652800, "tokens_per_second": 266551}
+{"step": 17500, "max_steps": 38147, "train_loss": 2.872927, "learning_rate": 0.00012471966509513754, "grad_norm": 0.5393016338348389, "tokens_seen": 2293760000, "tokens_per_second": 266545}
+{"step": 17600, "max_steps": 38147, "train_loss": 2.907589, "learning_rate": 0.00012397301640392684, "grad_norm": 0.5371799468994141, "tokens_seen": 2306867200, "tokens_per_second": 266487}
+{"step": 17700, "max_steps": 38147, "train_loss": 2.930816, "learning_rate": 0.00012322538094297755, "grad_norm": 0.5750351548194885, "tokens_seen": 2319974400, "tokens_per_second": 266558}
+{"step": 17800, "max_steps": 38147, "train_loss": 2.80574, "learning_rate": 0.00012247681151005558, "grad_norm": 0.5639591813087463, "tokens_seen": 2333081600, "tokens_per_second": 266565}
+{"step": 17900, "max_steps": 38147, "train_loss": 2.935044, "learning_rate": 0.00012172736096888354, "grad_norm": 0.5895889401435852, "tokens_seen": 2346188800, "tokens_per_second": 266558}
+{"step": 18000, "max_steps": 38147, "train_loss": 2.947257, "learning_rate": 0.00012097708224540767, "grad_norm": 0.4961288869380951, "tokens_seen": 2359296000, "tokens_per_second": 266572}
+{"step": 18000, "validation_loss": 2.956802, "validation_perplexity": 19.2364}
+{"step": 18100, "max_steps": 38147, "train_loss": 2.860126, "learning_rate": 0.0001202260283240601, "grad_norm": 0.6287165284156799, "tokens_seen": 2372403200, "tokens_per_second": 262469}
+{"step": 18200, "max_steps": 38147, "train_loss": 2.953648, "learning_rate": 0.00011947425224401725, "grad_norm": 0.5376870036125183, "tokens_seen": 2385510400, "tokens_per_second": 266548}
+{"step": 18300, "max_steps": 38147, "train_loss": 2.961425, "learning_rate": 0.00011872180709545405, "grad_norm": 0.5595741868019104, "tokens_seen": 2398617600, "tokens_per_second": 266556}
+{"step": 18400, "max_steps": 38147, "train_loss": 2.897191, "learning_rate": 0.00011796874601579491, "grad_norm": 0.5086379647254944, "tokens_seen": 2411724800, "tokens_per_second": 266540}
+{"step": 18500, "max_steps": 38147, "train_loss": 2.917819, "learning_rate": 0.00011721512218596106, "grad_norm": 0.5639253258705139, "tokens_seen": 2424832000, "tokens_per_second": 266538}
+{"step": 18600, "max_steps": 38147, "train_loss": 2.948039, "learning_rate": 0.00011646098882661496, "grad_norm": 0.6896440386772156, "tokens_seen": 2437939200, "tokens_per_second": 266549}
+{"step": 18700, "max_steps": 38147, "train_loss": 2.964076, "learning_rate": 0.00011570639919440187, "grad_norm": 0.5386029481887817, "tokens_seen": 2451046400, "tokens_per_second": 266527}
+{"step": 18800, "max_steps": 38147, "train_loss": 2.866205, "learning_rate": 0.00011495140657818889, "grad_norm": 0.5471669435501099, "tokens_seen": 2464153600, "tokens_per_second": 266506}
+{"step": 18900, "max_steps": 38147, "train_loss": 2.840063, "learning_rate": 0.00011419606429530166, "grad_norm": 0.5953474640846252, "tokens_seen": 2477260800, "tokens_per_second": 266550}
+{"step": 19000, "max_steps": 38147, "train_loss": 2.83049, "learning_rate": 0.0001134404256877593, "grad_norm": 0.5615992546081543, "tokens_seen": 2490368000, "tokens_per_second": 266566}
+{"step": 19100, "max_steps": 38147, "train_loss": 2.859421, "learning_rate": 0.00011268454411850713, "grad_norm": 0.5288406610488892, "tokens_seen": 2503475200, "tokens_per_second": 266566}
+{"step": 19200, "max_steps": 38147, "train_loss": 2.9146, "learning_rate": 0.00011192847296764846, "grad_norm": 0.5557245016098022, "tokens_seen": 2516582400, "tokens_per_second": 266567}
+{"step": 19300, "max_steps": 38147, "train_loss": 2.890018, "learning_rate": 0.00011117226562867467, "grad_norm": 0.5548304915428162, "tokens_seen": 2529689600, "tokens_per_second": 266566}
+{"step": 19400, "max_steps": 38147, "train_loss": 2.752083, "learning_rate": 0.0001104159755046948, "grad_norm": 0.5975026488304138, "tokens_seen": 2542796800, "tokens_per_second": 266567}
+{"step": 19500, "max_steps": 38147, "train_loss": 2.88171, "learning_rate": 0.00010965965600466413, "grad_norm": 0.5508555173873901, "tokens_seen": 2555904000, "tokens_per_second": 266556}
+{"step": 19600, "max_steps": 38147, "train_loss": 2.922331, "learning_rate": 0.00010890336053961243, "grad_norm": 0.5566782355308533, "tokens_seen": 2569011200, "tokens_per_second": 266548}
+{"step": 19700, "max_steps": 38147, "train_loss": 2.842486, "learning_rate": 0.0001081471425188721, "grad_norm": 0.5678550004959106, "tokens_seen": 2582118400, "tokens_per_second": 266549}
+{"step": 19800, "max_steps": 38147, "train_loss": 2.847586, "learning_rate": 0.00010739105534630656, "grad_norm": 0.5768691897392273, "tokens_seen": 2595225600, "tokens_per_second": 266561}
+{"step": 19900, "max_steps": 38147, "train_loss": 2.923671, "learning_rate": 0.00010663515241653866, "grad_norm": 0.5536670684814453, "tokens_seen": 2608332800, "tokens_per_second": 266573}
+{"step": 20000, "max_steps": 38147, "train_loss": 2.835271, "learning_rate": 0.0001058794871111801, "grad_norm": 0.5471276640892029, "tokens_seen": 2621440000, "tokens_per_second": 266575}
+{"step": 20000, "validation_loss": 2.945952, "validation_perplexity": 19.0288}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00020000
+{"step": 20100, "max_steps": 38147, "train_loss": 2.859491, "learning_rate": 0.00010512411279506171, "grad_norm": 0.5950771570205688, "tokens_seen": 2634547200, "tokens_per_second": 258912}
+{"step": 20200, "max_steps": 38147, "train_loss": 2.92326, "learning_rate": 0.00010436908281246469, "grad_norm": 0.5458201169967651, "tokens_seen": 2647654400, "tokens_per_second": 266576}
+{"step": 20300, "max_steps": 38147, "train_loss": 2.900287, "learning_rate": 0.0001036144504833535, "grad_norm": 0.5458999276161194, "tokens_seen": 2660761600, "tokens_per_second": 266571}
+{"step": 20400, "max_steps": 38147, "train_loss": 2.836447, "learning_rate": 0.00010286026909961053, "grad_norm": 0.5299811363220215, "tokens_seen": 2673868800, "tokens_per_second": 266546}
+{"step": 20500, "max_steps": 38147, "train_loss": 2.841372, "learning_rate": 0.00010210659192127246, "grad_norm": 0.5424965620040894, "tokens_seen": 2686976000, "tokens_per_second": 266510}
+{"step": 20600, "max_steps": 38147, "train_loss": 2.737658, "learning_rate": 0.00010135347217276924, "grad_norm": 0.6293522715568542, "tokens_seen": 2700083200, "tokens_per_second": 266518}
+{"step": 20700, "max_steps": 38147, "train_loss": 2.834829, "learning_rate": 0.00010060096303916524, "grad_norm": 0.5857658386230469, "tokens_seen": 2713190400, "tokens_per_second": 266516}
+{"step": 20800, "max_steps": 38147, "train_loss": 2.858683, "learning_rate": 9.984911766240343e-05, "grad_norm": 0.5542163848876953, "tokens_seen": 2726297600, "tokens_per_second": 266564}
+{"step": 20900, "max_steps": 38147, "train_loss": 2.894853, "learning_rate": 9.909798913755258e-05, "grad_norm": 0.5500002503395081, "tokens_seen": 2739404800, "tokens_per_second": 266539}
+{"step": 21000, "max_steps": 38147, "train_loss": 2.790889, "learning_rate": 9.834763050905747e-05, "grad_norm": 0.5608624815940857, "tokens_seen": 2752512000, "tokens_per_second": 266545}
+{"step": 21100, "max_steps": 38147, "train_loss": 2.886356, "learning_rate": 9.759809476699313e-05, "grad_norm": 0.534460186958313, "tokens_seen": 2765619200, "tokens_per_second": 266563}
+{"step": 21200, "max_steps": 38147, "train_loss": 2.811903, "learning_rate": 9.684943484332267e-05, "grad_norm": 0.5414276123046875, "tokens_seen": 2778726400, "tokens_per_second": 266558}
+{"step": 21300, "max_steps": 38147, "train_loss": 2.900397, "learning_rate": 9.610170360815912e-05, "grad_norm": 0.5601606965065002, "tokens_seen": 2791833600, "tokens_per_second": 266500}
+{"step": 21400, "max_steps": 38147, "train_loss": 2.82288, "learning_rate": 9.53549538660319e-05, "grad_norm": 0.5340302586555481, "tokens_seen": 2804940800, "tokens_per_second": 266550}
+{"step": 21500, "max_steps": 38147, "train_loss": 2.819525, "learning_rate": 9.460923835215771e-05, "grad_norm": 0.5730591416358948, "tokens_seen": 2818048000, "tokens_per_second": 266546}
+{"step": 21600, "max_steps": 38147, "train_loss": 2.880669, "learning_rate": 9.386460972871634e-05, "grad_norm": 0.5885633230209351, "tokens_seen": 2831155200, "tokens_per_second": 266550}
+{"step": 21700, "max_steps": 38147, "train_loss": 2.972164, "learning_rate": 9.312112058113178e-05, "grad_norm": 0.5533197522163391, "tokens_seen": 2844262400, "tokens_per_second": 266540}
+{"step": 21800, "max_steps": 38147, "train_loss": 2.847812, "learning_rate": 9.237882341435869e-05, "grad_norm": 0.5809752345085144, "tokens_seen": 2857369600, "tokens_per_second": 266549}
+{"step": 21900, "max_steps": 38147, "train_loss": 2.930798, "learning_rate": 9.163777064917427e-05, "grad_norm": 0.5463840961456299, "tokens_seen": 2870476800, "tokens_per_second": 266568}
+{"step": 22000, "max_steps": 38147, "train_loss": 2.91267, "learning_rate": 9.089801461847669e-05, "grad_norm": 0.5600722432136536, "tokens_seen": 2883584000, "tokens_per_second": 266562}
+{"step": 22000, "validation_loss": 2.9367, "validation_perplexity": 18.8535}
+{"step": 22100, "max_steps": 38147, "train_loss": 2.810362, "learning_rate": 9.015960756358901e-05, "grad_norm": 0.5334869027137756, "tokens_seen": 2896691200, "tokens_per_second": 262474}
+{"step": 22200, "max_steps": 38147, "train_loss": 2.799604, "learning_rate": 8.942260163057022e-05, "grad_norm": 0.5521989464759827, "tokens_seen": 2909798400, "tokens_per_second": 266574}
+{"step": 22300, "max_steps": 38147, "train_loss": 2.824443, "learning_rate": 8.868704886653239e-05, "grad_norm": 0.5473442077636719, "tokens_seen": 2922905600, "tokens_per_second": 266711}
+{"step": 22400, "max_steps": 38147, "train_loss": 2.797859, "learning_rate": 8.795300121596539e-05, "grad_norm": 0.6124777793884277, "tokens_seen": 2936012800, "tokens_per_second": 266708}
+{"step": 22500, "max_steps": 38147, "train_loss": 2.932135, "learning_rate": 8.722051051706846e-05, "grad_norm": 0.5962636470794678, "tokens_seen": 2949120000, "tokens_per_second": 266657}
+{"step": 22600, "max_steps": 38147, "train_loss": 2.877236, "learning_rate": 8.648962849808942e-05, "grad_norm": 0.5380517244338989, "tokens_seen": 2962227200, "tokens_per_second": 266692}
+{"step": 22700, "max_steps": 38147, "train_loss": 2.882246, "learning_rate": 8.576040677367164e-05, "grad_norm": 0.5944678783416748, "tokens_seen": 2975334400, "tokens_per_second": 266715}
+{"step": 22800, "max_steps": 38147, "train_loss": 2.793537, "learning_rate": 8.50328968412091e-05, "grad_norm": 0.543428361415863, "tokens_seen": 2988441600, "tokens_per_second": 266681}
+{"step": 22900, "max_steps": 38147, "train_loss": 2.864169, "learning_rate": 8.430715007720955e-05, "grad_norm": 0.5235292315483093, "tokens_seen": 3001548800, "tokens_per_second": 266681}
+{"step": 23000, "max_steps": 38147, "train_loss": 2.838596, "learning_rate": 8.35832177336664e-05, "grad_norm": 0.5795411467552185, "tokens_seen": 3014656000, "tokens_per_second": 266688}
+{"step": 23100, "max_steps": 38147, "train_loss": 2.949519, "learning_rate": 8.28611509344393e-05, "grad_norm": 0.5032678842544556, "tokens_seen": 3027763200, "tokens_per_second": 266683}
+{"step": 23200, "max_steps": 38147, "train_loss": 2.859625, "learning_rate": 8.214100067164374e-05, "grad_norm": 0.5826283097267151, "tokens_seen": 3040870400, "tokens_per_second": 266667}
+{"step": 23300, "max_steps": 38147, "train_loss": 2.908341, "learning_rate": 8.142281780205014e-05, "grad_norm": 0.5404061675071716, "tokens_seen": 3053977600, "tokens_per_second": 266728}
+{"step": 23400, "max_steps": 38147, "train_loss": 2.805495, "learning_rate": 8.070665304349216e-05, "grad_norm": 0.5462639331817627, "tokens_seen": 3067084800, "tokens_per_second": 266673}
+{"step": 23500, "max_steps": 38147, "train_loss": 2.939718, "learning_rate": 7.99925569712852e-05, "grad_norm": 0.5242215394973755, "tokens_seen": 3080192000, "tokens_per_second": 266575}
+{"step": 23600, "max_steps": 38147, "train_loss": 2.77057, "learning_rate": 7.928058001465473e-05, "grad_norm": 0.5677931904792786, "tokens_seen": 3093299200, "tokens_per_second": 266557}
+{"step": 23700, "max_steps": 38147, "train_loss": 2.792751, "learning_rate": 7.857077245317494e-05, "grad_norm": 0.577501654624939, "tokens_seen": 3106406400, "tokens_per_second": 266521}
+{"step": 23800, "max_steps": 38147, "train_loss": 2.794581, "learning_rate": 7.786318441321812e-05, "grad_norm": 0.5876113176345825, "tokens_seen": 3119513600, "tokens_per_second": 266544}
+{"step": 23900, "max_steps": 38147, "train_loss": 2.86267, "learning_rate": 7.715786586441469e-05, "grad_norm": 0.5562711358070374, "tokens_seen": 3132620800, "tokens_per_second": 266543}
+{"step": 24000, "max_steps": 38147, "train_loss": 2.833634, "learning_rate": 7.645486661612422e-05, "grad_norm": 0.541306734085083, "tokens_seen": 3145728000, "tokens_per_second": 266524}
+{"step": 24000, "validation_loss": 2.927752, "validation_perplexity": 18.6856}
+{"step": 24100, "max_steps": 38147, "train_loss": 2.857251, "learning_rate": 7.575423631391831e-05, "grad_norm": 0.5667536854743958, "tokens_seen": 3158835200, "tokens_per_second": 262408}
+{"step": 24200, "max_steps": 38147, "train_loss": 2.838729, "learning_rate": 7.505602443607418e-05, "grad_norm": 0.5656136274337769, "tokens_seen": 3171942400, "tokens_per_second": 266462}
+{"step": 24300, "max_steps": 38147, "train_loss": 2.884439, "learning_rate": 7.436028029008079e-05, "grad_norm": 0.592436671257019, "tokens_seen": 3185049600, "tokens_per_second": 266485}
+{"step": 24400, "max_steps": 38147, "train_loss": 2.880978, "learning_rate": 7.366705300915675e-05, "grad_norm": 0.5604985952377319, "tokens_seen": 3198156800, "tokens_per_second": 266537}
+{"step": 24500, "max_steps": 38147, "train_loss": 2.847855, "learning_rate": 7.297639154878039e-05, "grad_norm": 0.5508514642715454, "tokens_seen": 3211264000, "tokens_per_second": 266548}
+{"step": 24600, "max_steps": 38147, "train_loss": 2.791588, "learning_rate": 7.22883446832328e-05, "grad_norm": 0.5729002952575684, "tokens_seen": 3224371200, "tokens_per_second": 266561}
+{"step": 24700, "max_steps": 38147, "train_loss": 2.906638, "learning_rate": 7.160296100215316e-05, "grad_norm": 0.552596390247345, "tokens_seen": 3237478400, "tokens_per_second": 266598}
+{"step": 24800, "max_steps": 38147, "train_loss": 2.839932, "learning_rate": 7.092028890710744e-05, "grad_norm": 0.607927680015564, "tokens_seen": 3250585600, "tokens_per_second": 266540}
+{"step": 24900, "max_steps": 38147, "train_loss": 2.816602, "learning_rate": 7.024037660817038e-05, "grad_norm": 0.6242993474006653, "tokens_seen": 3263692800, "tokens_per_second": 266477}
+{"step": 25000, "max_steps": 38147, "train_loss": 2.816746, "learning_rate": 6.956327212052076e-05, "grad_norm": 0.5614867210388184, "tokens_seen": 3276800000, "tokens_per_second": 266557}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00025000
+{"step": 25100, "max_steps": 38147, "train_loss": 2.766988, "learning_rate": 6.888902326105082e-05, "grad_norm": 0.5991885662078857, "tokens_seen": 3289907200, "tokens_per_second": 262356}
+{"step": 25200, "max_steps": 38147, "train_loss": 2.854057, "learning_rate": 6.821767764498913e-05, "grad_norm": 0.558078944683075, "tokens_seen": 3303014400, "tokens_per_second": 266554}
+{"step": 25300, "max_steps": 38147, "train_loss": 2.845538, "learning_rate": 6.754928268253827e-05, "grad_norm": 0.5611226558685303, "tokens_seen": 3316121600, "tokens_per_second": 266547}
+{"step": 25400, "max_steps": 38147, "train_loss": 2.851045, "learning_rate": 6.688388557552657e-05, "grad_norm": 0.582211971282959, "tokens_seen": 3329228800, "tokens_per_second": 266543}
+{"step": 25500, "max_steps": 38147, "train_loss": 2.825767, "learning_rate": 6.622153331407494e-05, "grad_norm": 0.547619104385376, "tokens_seen": 3342336000, "tokens_per_second": 266537}
+{"step": 25600, "max_steps": 38147, "train_loss": 2.857817, "learning_rate": 6.556227267327817e-05, "grad_norm": 0.5610079765319824, "tokens_seen": 3355443200, "tokens_per_second": 266556}
+{"step": 25700, "max_steps": 38147, "train_loss": 2.892435, "learning_rate": 6.490615020990199e-05, "grad_norm": 0.5642598867416382, "tokens_seen": 3368550400, "tokens_per_second": 266541}
+{"step": 25800, "max_steps": 38147, "train_loss": 2.827709, "learning_rate": 6.4253212259095e-05, "grad_norm": 0.6536757349967957, "tokens_seen": 3381657600, "tokens_per_second": 266548}
+{"step": 25900, "max_steps": 38147, "train_loss": 2.801008, "learning_rate": 6.360350493111658e-05, "grad_norm": 0.5914214849472046, "tokens_seen": 3394764800, "tokens_per_second": 266563}
+{"step": 26000, "max_steps": 38147, "train_loss": 2.858851, "learning_rate": 6.295707410808061e-05, "grad_norm": 0.5447360277175903, "tokens_seen": 3407872000, "tokens_per_second": 266544}
+{"step": 26000, "validation_loss": 2.918962, "validation_perplexity": 18.5221}
+{"step": 26100, "max_steps": 38147, "train_loss": 2.800075, "learning_rate": 6.23139654407153e-05, "grad_norm": 0.5622711181640625, "tokens_seen": 3420979200, "tokens_per_second": 262408}
+{"step": 26200, "max_steps": 38147, "train_loss": 2.85427, "learning_rate": 6.167422434513944e-05, "grad_norm": 0.5513009428977966, "tokens_seen": 3434086400, "tokens_per_second": 266544}
+{"step": 26300, "max_steps": 38147, "train_loss": 2.849965, "learning_rate": 6.103789599965483e-05, "grad_norm": 0.6363672614097595, "tokens_seen": 3447193600, "tokens_per_second": 266545}
+{"step": 26400, "max_steps": 38147, "train_loss": 2.879174, "learning_rate": 6.0405025341556167e-05, "grad_norm": 0.5475148558616638, "tokens_seen": 3460300800, "tokens_per_second": 266547}
+{"step": 26500, "max_steps": 38147, "train_loss": 2.837725, "learning_rate": 5.977565706395736e-05, "grad_norm": 0.6237246990203857, "tokens_seen": 3473408000, "tokens_per_second": 266539}
+{"step": 26600, "max_steps": 38147, "train_loss": 2.820456, "learning_rate": 5.9149835612635305e-05, "grad_norm": 0.5387876629829407, "tokens_seen": 3486515200, "tokens_per_second": 266526}
+{"step": 26700, "max_steps": 38147, "train_loss": 2.899003, "learning_rate": 5.85276051828914e-05, "grad_norm": 0.5980178713798523, "tokens_seen": 3499622400, "tokens_per_second": 266528}
+{"step": 26800, "max_steps": 38147, "train_loss": 2.846585, "learning_rate": 5.790900971643014e-05, "grad_norm": 0.5368542671203613, "tokens_seen": 3512729600, "tokens_per_second": 266530}
+{"step": 26900, "max_steps": 38147, "train_loss": 2.852, "learning_rate": 5.72940928982562e-05, "grad_norm": 0.5674088001251221, "tokens_seen": 3525836800, "tokens_per_second": 266525}
+{"step": 27000, "max_steps": 38147, "train_loss": 2.919401, "learning_rate": 5.668289815358931e-05, "grad_norm": 0.6030111312866211, "tokens_seen": 3538944000, "tokens_per_second": 266538}
+{"step": 27100, "max_steps": 38147, "train_loss": 2.746781, "learning_rate": 5.6075468644797646e-05, "grad_norm": 0.5781011581420898, "tokens_seen": 3552051200, "tokens_per_second": 266521}
+{"step": 27200, "max_steps": 38147, "train_loss": 2.889836, "learning_rate": 5.547184726834964e-05, "grad_norm": 0.591314971446991, "tokens_seen": 3565158400, "tokens_per_second": 266536}
+{"step": 27300, "max_steps": 38147, "train_loss": 2.850757, "learning_rate": 5.48720766517848e-05, "grad_norm": 0.5595675706863403, "tokens_seen": 3578265600, "tokens_per_second": 266541}
+{"step": 27400, "max_steps": 38147, "train_loss": 2.888055, "learning_rate": 5.4276199150703144e-05, "grad_norm": 0.5893188118934631, "tokens_seen": 3591372800, "tokens_per_second": 266497}
+{"step": 27500, "max_steps": 38147, "train_loss": 2.850187, "learning_rate": 5.368425684577425e-05, "grad_norm": 0.5851203203201294, "tokens_seen": 3604480000, "tokens_per_second": 266544}
+{"step": 27600, "max_steps": 38147, "train_loss": 2.822457, "learning_rate": 5.309629153976541e-05, "grad_norm": 0.6213855147361755, "tokens_seen": 3617587200, "tokens_per_second": 266538}
+{"step": 27700, "max_steps": 38147, "train_loss": 2.705102, "learning_rate": 5.2512344754589603e-05, "grad_norm": 0.6402599811553955, "tokens_seen": 3630694400, "tokens_per_second": 266532}
+{"step": 27800, "max_steps": 38147, "train_loss": 2.895195, "learning_rate": 5.1932457728373274e-05, "grad_norm": 0.527906596660614, "tokens_seen": 3643801600, "tokens_per_second": 266524}
+{"step": 27900, "max_steps": 38147, "train_loss": 2.941834, "learning_rate": 5.1356671412543944e-05, "grad_norm": 0.5629961490631104, "tokens_seen": 3656908800, "tokens_per_second": 266492}
+{"step": 28000, "max_steps": 38147, "train_loss": 2.893293, "learning_rate": 5.078502646893841e-05, "grad_norm": 0.5659019351005554, "tokens_seen": 3670016000, "tokens_per_second": 266479}
+{"step": 28000, "validation_loss": 2.911568, "validation_perplexity": 18.3856}
+{"step": 28100, "max_steps": 38147, "train_loss": 2.847016, "learning_rate": 5.021756326693115e-05, "grad_norm": 0.5569750666618347, "tokens_seen": 3683123200, "tokens_per_second": 262443}
+{"step": 28200, "max_steps": 38147, "train_loss": 2.907253, "learning_rate": 4.9654321880583374e-05, "grad_norm": 0.5603170990943909, "tokens_seen": 3696230400, "tokens_per_second": 266532}
+{"step": 28300, "max_steps": 38147, "train_loss": 2.79605, "learning_rate": 4.9095342085813225e-05, "grad_norm": 0.5688501596450806, "tokens_seen": 3709337600, "tokens_per_second": 266530}
+{"step": 28400, "max_steps": 38147, "train_loss": 2.860015, "learning_rate": 4.854066335758653e-05, "grad_norm": 0.5661910176277161, "tokens_seen": 3722444800, "tokens_per_second": 266541}
+{"step": 28500, "max_steps": 38147, "train_loss": 2.832889, "learning_rate": 4.799032486712935e-05, "grad_norm": 0.5644569993019104, "tokens_seen": 3735552000, "tokens_per_second": 266554}
+{"step": 28600, "max_steps": 38147, "train_loss": 2.868754, "learning_rate": 4.7444365479161524e-05, "grad_norm": 0.582551121711731, "tokens_seen": 3748659200, "tokens_per_second": 266505}
+{"step": 28700, "max_steps": 38147, "train_loss": 2.815263, "learning_rate": 4.6902823749152175e-05, "grad_norm": 0.551891028881073, "tokens_seen": 3761766400, "tokens_per_second": 266554}
+{"step": 28800, "max_steps": 38147, "train_loss": 2.796259, "learning_rate": 4.636573792059689e-05, "grad_norm": 0.6193068027496338, "tokens_seen": 3774873600, "tokens_per_second": 266633}
+{"step": 28900, "max_steps": 38147, "train_loss": 2.900352, "learning_rate": 4.5833145922317056e-05, "grad_norm": 0.5879529714584351, "tokens_seen": 3787980800, "tokens_per_second": 266547}
+{"step": 29000, "max_steps": 38147, "train_loss": 2.837007, "learning_rate": 4.530508536578117e-05, "grad_norm": 0.5981994867324829, "tokens_seen": 3801088000, "tokens_per_second": 266560}
+{"step": 29100, "max_steps": 38147, "train_loss": 2.829343, "learning_rate": 4.4781593542448884e-05, "grad_norm": 0.6040003299713135, "tokens_seen": 3814195200, "tokens_per_second": 266558}
+{"step": 29200, "max_steps": 38147, "train_loss": 2.882287, "learning_rate": 4.426270742113743e-05, "grad_norm": 0.5958173274993896, "tokens_seen": 3827302400, "tokens_per_second": 266547}
+{"step": 29300, "max_steps": 38147, "train_loss": 2.780126, "learning_rate": 4.374846364541088e-05, "grad_norm": 0.5621843934059143, "tokens_seen": 3840409600, "tokens_per_second": 266548}
+{"step": 29400, "max_steps": 38147, "train_loss": 2.885348, "learning_rate": 4.32388985309925e-05, "grad_norm": 0.5459842681884766, "tokens_seen": 3853516800, "tokens_per_second": 266558}
+{"step": 29500, "max_steps": 38147, "train_loss": 2.919526, "learning_rate": 4.2734048063199994e-05, "grad_norm": 0.5731099843978882, "tokens_seen": 3866624000, "tokens_per_second": 266565}
+{"step": 29600, "max_steps": 38147, "train_loss": 2.77706, "learning_rate": 4.223394789440425e-05, "grad_norm": 0.624010443687439, "tokens_seen": 3879731200, "tokens_per_second": 266553}
+{"step": 29700, "max_steps": 38147, "train_loss": 2.850321, "learning_rate": 4.173863334151176e-05, "grad_norm": 0.6066707372665405, "tokens_seen": 3892838400, "tokens_per_second": 266535}
+{"step": 29800, "max_steps": 38147, "train_loss": 2.763236, "learning_rate": 4.1248139383470296e-05, "grad_norm": 0.5490103363990784, "tokens_seen": 3905945600, "tokens_per_second": 266557}
+{"step": 29900, "max_steps": 38147, "train_loss": 2.751048, "learning_rate": 4.076250065879897e-05, "grad_norm": 0.5612136721611023, "tokens_seen": 3919052800, "tokens_per_second": 266558}
+{"step": 30000, "max_steps": 38147, "train_loss": 2.759008, "learning_rate": 4.028175146314184e-05, "grad_norm": 0.5331870913505554, "tokens_seen": 3932160000, "tokens_per_second": 266549}
+{"step": 30000, "validation_loss": 2.904722, "validation_perplexity": 18.2602}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00030000
+{"step": 30100, "max_steps": 38147, "train_loss": 2.803232, "learning_rate": 3.980592574684605e-05, "grad_norm": 0.5768374800682068, "tokens_seen": 3945267200, "tokens_per_second": 258866}
+{"step": 30200, "max_steps": 38147, "train_loss": 2.840143, "learning_rate": 3.933505711256437e-05, "grad_norm": 0.5935572981834412, "tokens_seen": 3958374400, "tokens_per_second": 266555}
+{"step": 30300, "max_steps": 38147, "train_loss": 2.880723, "learning_rate": 3.886917881288202e-05, "grad_norm": 0.5887243151664734, "tokens_seen": 3971481600, "tokens_per_second": 266547}
+{"step": 30400, "max_steps": 38147, "train_loss": 2.895415, "learning_rate": 3.8408323747968466e-05, "grad_norm": 0.5813783407211304, "tokens_seen": 3984588800, "tokens_per_second": 266539}
+{"step": 30500, "max_steps": 38147, "train_loss": 2.812178, "learning_rate": 3.79525244632541e-05, "grad_norm": 0.5698392987251282, "tokens_seen": 3997696000, "tokens_per_second": 266540}
+{"step": 30600, "max_steps": 38147, "train_loss": 2.800062, "learning_rate": 3.7501813147131727e-05, "grad_norm": 0.5620970129966736, "tokens_seen": 4010803200, "tokens_per_second": 266523}
+{"step": 30700, "max_steps": 38147, "train_loss": 2.834445, "learning_rate": 3.705622162868352e-05, "grad_norm": 0.6195650100708008, "tokens_seen": 4023910400, "tokens_per_second": 266534}
+{"step": 30800, "max_steps": 38147, "train_loss": 2.806707, "learning_rate": 3.661578137543329e-05, "grad_norm": 0.5828126668930054, "tokens_seen": 4037017600, "tokens_per_second": 266542}
+{"step": 30900, "max_steps": 38147, "train_loss": 2.786363, "learning_rate": 3.618052349112416e-05, "grad_norm": 0.580255925655365, "tokens_seen": 4050124800, "tokens_per_second": 266541}
+{"step": 31000, "max_steps": 38147, "train_loss": 2.825516, "learning_rate": 3.575047871352223e-05, "grad_norm": 0.5789481401443481, "tokens_seen": 4063232000, "tokens_per_second": 266520}
+{"step": 31100, "max_steps": 38147, "train_loss": 2.801404, "learning_rate": 3.5325677412245626e-05, "grad_norm": 0.5894032120704651, "tokens_seen": 4076339200, "tokens_per_second": 266567}
+{"step": 31200, "max_steps": 38147, "train_loss": 2.862363, "learning_rate": 3.490614958661992e-05, "grad_norm": 0.5975892543792725, "tokens_seen": 4089446400, "tokens_per_second": 266553}
+{"step": 31300, "max_steps": 38147, "train_loss": 2.895666, "learning_rate": 3.44919248635597e-05, "grad_norm": 0.5712851881980896, "tokens_seen": 4102553600, "tokens_per_second": 266547}
+{"step": 31400, "max_steps": 38147, "train_loss": 2.820938, "learning_rate": 3.4083032495476144e-05, "grad_norm": 0.6001507639884949, "tokens_seen": 4115660800, "tokens_per_second": 266536}
+{"step": 31500, "max_steps": 38147, "train_loss": 2.859482, "learning_rate": 3.367950135821136e-05, "grad_norm": 0.5555902123451233, "tokens_seen": 4128768000, "tokens_per_second": 266481}
+{"step": 31600, "max_steps": 38147, "train_loss": 2.824783, "learning_rate": 3.3281359948999143e-05, "grad_norm": 0.5704244375228882, "tokens_seen": 4141875200, "tokens_per_second": 266490}
+{"step": 31700, "max_steps": 38147, "train_loss": 2.802811, "learning_rate": 3.288863638445238e-05, "grad_norm": 0.6088986396789551, "tokens_seen": 4154982400, "tokens_per_second": 266550}
+{"step": 31800, "max_steps": 38147, "train_loss": 2.787406, "learning_rate": 3.250135839857772e-05, "grad_norm": 0.5637134313583374, "tokens_seen": 4168089600, "tokens_per_second": 266539}
+{"step": 31900, "max_steps": 38147, "train_loss": 2.863412, "learning_rate": 3.2119553340816827e-05, "grad_norm": 0.6168907880783081, "tokens_seen": 4181196800, "tokens_per_second": 266545}
+{"step": 32000, "max_steps": 38147, "train_loss": 2.813874, "learning_rate": 3.174324817411495e-05, "grad_norm": 0.5987451076507568, "tokens_seen": 4194304000, "tokens_per_second": 266549}
+{"step": 32000, "validation_loss": 2.900096, "validation_perplexity": 18.1759}
+{"step": 32100, "max_steps": 38147, "train_loss": 2.755264, "learning_rate": 3.137246947301701e-05, "grad_norm": 0.5844534039497375, "tokens_seen": 4207411200, "tokens_per_second": 262483}
+{"step": 32200, "max_steps": 38147, "train_loss": 2.991299, "learning_rate": 3.1007243421790615e-05, "grad_norm": 0.6205332279205322, "tokens_seen": 4220518400, "tokens_per_second": 266503}
+{"step": 32300, "max_steps": 38147, "train_loss": 2.765144, "learning_rate": 3.064759581257723e-05, "grad_norm": 0.5922822952270508, "tokens_seen": 4233625600, "tokens_per_second": 266537}
+{"step": 32400, "max_steps": 38147, "train_loss": 2.833967, "learning_rate": 3.0293552043570544e-05, "grad_norm": 0.5997751355171204, "tokens_seen": 4246732800, "tokens_per_second": 266530}
+{"step": 32500, "max_steps": 38147, "train_loss": 2.781722, "learning_rate": 2.9945137117222933e-05, "grad_norm": 0.5541488528251648, "tokens_seen": 4259840000, "tokens_per_second": 266520}
+{"step": 32600, "max_steps": 38147, "train_loss": 2.785665, "learning_rate": 2.960237563847986e-05, "grad_norm": 0.5725107192993164, "tokens_seen": 4272947200, "tokens_per_second": 266539}
+{"step": 32700, "max_steps": 38147, "train_loss": 2.838851, "learning_rate": 2.926529181304208e-05, "grad_norm": 0.5699809789657593, "tokens_seen": 4286054400, "tokens_per_second": 266551}
+{"step": 32800, "max_steps": 38147, "train_loss": 2.860283, "learning_rate": 2.8933909445656494e-05, "grad_norm": 0.5856370329856873, "tokens_seen": 4299161600, "tokens_per_second": 266549}
+{"step": 32900, "max_steps": 38147, "train_loss": 2.827816, "learning_rate": 2.8608251938434895e-05, "grad_norm": 0.5361691117286682, "tokens_seen": 4312268800, "tokens_per_second": 266549}
+{"step": 33000, "max_steps": 38147, "train_loss": 2.884901, "learning_rate": 2.8288342289201348e-05, "grad_norm": 0.5725577473640442, "tokens_seen": 4325376000, "tokens_per_second": 266561}
+{"step": 33100, "max_steps": 38147, "train_loss": 2.89825, "learning_rate": 2.797420308986819e-05, "grad_norm": 0.5881522297859192, "tokens_seen": 4338483200, "tokens_per_second": 266553}
+{"step": 33200, "max_steps": 38147, "train_loss": 2.886364, "learning_rate": 2.76658565248404e-05, "grad_norm": 0.5617952942848206, "tokens_seen": 4351590400, "tokens_per_second": 266550}
+{"step": 33300, "max_steps": 38147, "train_loss": 2.882295, "learning_rate": 2.736332436944915e-05, "grad_norm": 0.5786371231079102, "tokens_seen": 4364697600, "tokens_per_second": 266558}
+{"step": 33400, "max_steps": 38147, "train_loss": 2.819813, "learning_rate": 2.706662798841395e-05, "grad_norm": 0.5660547018051147, "tokens_seen": 4377804800, "tokens_per_second": 266530}
+{"step": 33500, "max_steps": 38147, "train_loss": 2.843132, "learning_rate": 2.6775788334333824e-05, "grad_norm": 0.5831009745597839, "tokens_seen": 4390912000, "tokens_per_second": 266481}
+{"step": 33600, "max_steps": 38147, "train_loss": 2.822223, "learning_rate": 2.6490825946207792e-05, "grad_norm": 0.7210411429405212, "tokens_seen": 4404019200, "tokens_per_second": 266544}
+{"step": 33700, "max_steps": 38147, "train_loss": 2.735867, "learning_rate": 2.621176094798421e-05, "grad_norm": 0.5961363911628723, "tokens_seen": 4417126400, "tokens_per_second": 266545}
+{"step": 33800, "max_steps": 38147, "train_loss": 2.817519, "learning_rate": 2.5938613047139777e-05, "grad_norm": 0.6047573089599609, "tokens_seen": 4430233600, "tokens_per_second": 266523}
+{"step": 33900, "max_steps": 38147, "train_loss": 2.863799, "learning_rate": 2.5671401533287816e-05, "grad_norm": 0.5683556199073792, "tokens_seen": 4443340800, "tokens_per_second": 266624}
+{"step": 34000, "max_steps": 38147, "train_loss": 2.811208, "learning_rate": 2.5410145276815912e-05, "grad_norm": 0.603577733039856, "tokens_seen": 4456448000, "tokens_per_second": 266652}
+{"step": 34000, "validation_loss": 2.895255, "validation_perplexity": 18.0881}
+{"step": 34100, "max_steps": 38147, "train_loss": 2.855515, "learning_rate": 2.515486272755338e-05, "grad_norm": 0.6094146966934204, "tokens_seen": 4469555200, "tokens_per_second": 262551}
+{"step": 34200, "max_steps": 38147, "train_loss": 2.733138, "learning_rate": 2.4905571913468396e-05, "grad_norm": 0.6777827143669128, "tokens_seen": 4482662400, "tokens_per_second": 266673}
+{"step": 34300, "max_steps": 38147, "train_loss": 2.882184, "learning_rate": 2.4662290439394705e-05, "grad_norm": 0.5954318642616272, "tokens_seen": 4495769600, "tokens_per_second": 266662}
+{"step": 34400, "max_steps": 38147, "train_loss": 2.799615, "learning_rate": 2.442503548578856e-05, "grad_norm": 0.5584408044815063, "tokens_seen": 4508876800, "tokens_per_second": 266648}
+{"step": 34500, "max_steps": 38147, "train_loss": 2.807887, "learning_rate": 2.4193823807515308e-05, "grad_norm": 0.5776689648628235, "tokens_seen": 4521984000, "tokens_per_second": 266601}
+{"step": 34600, "max_steps": 38147, "train_loss": 2.83416, "learning_rate": 2.3968671732666227e-05, "grad_norm": 0.5929839015007019, "tokens_seen": 4535091200, "tokens_per_second": 266524}
+{"step": 34700, "max_steps": 38147, "train_loss": 2.907646, "learning_rate": 2.3749595161405472e-05, "grad_norm": 0.6023045182228088, "tokens_seen": 4548198400, "tokens_per_second": 266493}
+{"step": 34800, "max_steps": 38147, "train_loss": 2.870698, "learning_rate": 2.3536609564847074e-05, "grad_norm": 0.6041939854621887, "tokens_seen": 4561305600, "tokens_per_second": 266526}
+{"step": 34900, "max_steps": 38147, "train_loss": 2.772315, "learning_rate": 2.3329729983962546e-05, "grad_norm": 0.5803220868110657, "tokens_seen": 4574412800, "tokens_per_second": 266535}
+{"step": 35000, "max_steps": 38147, "train_loss": 2.879679, "learning_rate": 2.3128971028518633e-05, "grad_norm": 0.5865634083747864, "tokens_seen": 4587520000, "tokens_per_second": 266519}
+Saved checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00035000
+{"step": 35100, "max_steps": 38147, "train_loss": 2.790793, "learning_rate": 2.2934346876045487e-05, "grad_norm": 0.5853574275970459, "tokens_seen": 4600627200, "tokens_per_second": 262582}
+{"step": 35200, "max_steps": 38147, "train_loss": 2.833371, "learning_rate": 2.274587127083561e-05, "grad_norm": 0.58817058801651, "tokens_seen": 4613734400, "tokens_per_second": 266453}
+{"step": 35300, "max_steps": 38147, "train_loss": 2.877543, "learning_rate": 2.2563557522973084e-05, "grad_norm": 0.6056636571884155, "tokens_seen": 4626841600, "tokens_per_second": 266469}
+{"step": 35400, "max_steps": 38147, "train_loss": 2.813346, "learning_rate": 2.2387418507393733e-05, "grad_norm": 0.6120516061782837, "tokens_seen": 4639948800, "tokens_per_second": 266530}
+{"step": 35500, "max_steps": 38147, "train_loss": 2.86982, "learning_rate": 2.221746666297585e-05, "grad_norm": 0.5743942856788635, "tokens_seen": 4653056000, "tokens_per_second": 266525}
+{"step": 35600, "max_steps": 38147, "train_loss": 2.757251, "learning_rate": 2.2053713991661767e-05, "grad_norm": 0.6028977036476135, "tokens_seen": 4666163200, "tokens_per_second": 266537}
+{"step": 35700, "max_steps": 38147, "train_loss": 2.807111, "learning_rate": 2.189617205761028e-05, "grad_norm": 0.6074195504188538, "tokens_seen": 4679270400, "tokens_per_second": 266539}
+{"step": 35800, "max_steps": 38147, "train_loss": 2.824218, "learning_rate": 2.1744851986380013e-05, "grad_norm": 0.5873327255249023, "tokens_seen": 4692377600, "tokens_per_second": 266557}
+{"step": 35900, "max_steps": 38147, "train_loss": 2.88764, "learning_rate": 2.1599764464143705e-05, "grad_norm": 0.5763123035430908, "tokens_seen": 4705484800, "tokens_per_second": 266500}
+{"step": 36000, "max_steps": 38147, "train_loss": 2.789732, "learning_rate": 2.1460919736933597e-05, "grad_norm": 0.5788039565086365, "tokens_seen": 4718592000, "tokens_per_second": 266569}
+{"step": 36000, "validation_loss": 2.891825, "validation_perplexity": 18.0262}
+{"step": 36100, "max_steps": 38147, "train_loss": 2.732829, "learning_rate": 2.132832760991782e-05, "grad_norm": 0.5719741582870483, "tokens_seen": 4731699200, "tokens_per_second": 262502}
+{"step": 36200, "max_steps": 38147, "train_loss": 2.788649, "learning_rate": 2.1201997446707975e-05, "grad_norm": 0.5978461503982544, "tokens_seen": 4744806400, "tokens_per_second": 266706}
+{"step": 36300, "max_steps": 38147, "train_loss": 2.888856, "learning_rate": 2.1081938168697866e-05, "grad_norm": 0.6924115419387817, "tokens_seen": 4757913600, "tokens_per_second": 266715}
+{"step": 36400, "max_steps": 38147, "train_loss": 2.856264, "learning_rate": 2.0968158254433507e-05, "grad_norm": 0.5733427405357361, "tokens_seen": 4771020800, "tokens_per_second": 266712}
+{"step": 36500, "max_steps": 38147, "train_loss": 2.848382, "learning_rate": 2.0860665739014325e-05, "grad_norm": 0.5853831171989441, "tokens_seen": 4784128000, "tokens_per_second": 266707}
+{"step": 36600, "max_steps": 38147, "train_loss": 2.822363, "learning_rate": 2.0759468213525767e-05, "grad_norm": 0.5953521728515625, "tokens_seen": 4797235200, "tokens_per_second": 266585}
+{"step": 36700, "max_steps": 38147, "train_loss": 2.803841, "learning_rate": 2.0664572824503198e-05, "grad_norm": 0.6017800569534302, "tokens_seen": 4810342400, "tokens_per_second": 266526}
+{"step": 36800, "max_steps": 38147, "train_loss": 2.834847, "learning_rate": 2.0575986273427188e-05, "grad_norm": 0.5908879637718201, "tokens_seen": 4823449600, "tokens_per_second": 266539}
+{"step": 36900, "max_steps": 38147, "train_loss": 2.847193, "learning_rate": 2.0493714816250315e-05, "grad_norm": 0.6009106636047363, "tokens_seen": 4836556800, "tokens_per_second": 266543}
+{"step": 37000, "max_steps": 38147, "train_loss": 2.900528, "learning_rate": 2.041776426295533e-05, "grad_norm": 0.5982612371444702, "tokens_seen": 4849664000, "tokens_per_second": 266558}
+{"step": 37100, "max_steps": 38147, "train_loss": 2.825163, "learning_rate": 2.0348139977144858e-05, "grad_norm": 0.6053802967071533, "tokens_seen": 4862771200, "tokens_per_second": 266495}
+{"step": 37200, "max_steps": 38147, "train_loss": 2.835938, "learning_rate": 2.028484687566266e-05, "grad_norm": 0.5705294013023376, "tokens_seen": 4875878400, "tokens_per_second": 266549}
+{"step": 37300, "max_steps": 38147, "train_loss": 2.841648, "learning_rate": 2.0227889428246363e-05, "grad_norm": 0.6156661510467529, "tokens_seen": 4888985600, "tokens_per_second": 266548}
+{"step": 37400, "max_steps": 38147, "train_loss": 2.818843, "learning_rate": 2.0177271657211818e-05, "grad_norm": 0.6606355309486389, "tokens_seen": 4902092800, "tokens_per_second": 266541}
+{"step": 37500, "max_steps": 38147, "train_loss": 2.900203, "learning_rate": 2.013299713716906e-05, "grad_norm": 0.5641033053398132, "tokens_seen": 4915200000, "tokens_per_second": 266538}
+{"step": 37600, "max_steps": 38147, "train_loss": 2.782548, "learning_rate": 2.0095068994769872e-05, "grad_norm": 0.5759052634239197, "tokens_seen": 4928307200, "tokens_per_second": 266532}
+{"step": 37700, "max_steps": 38147, "train_loss": 2.782311, "learning_rate": 2.0063489908486975e-05, "grad_norm": 0.5701453685760498, "tokens_seen": 4941414400, "tokens_per_second": 266557}
+{"step": 37800, "max_steps": 38147, "train_loss": 2.820711, "learning_rate": 2.0038262108424856e-05, "grad_norm": 0.588422954082489, "tokens_seen": 4954521600, "tokens_per_second": 266547}
+{"step": 37900, "max_steps": 38147, "train_loss": 2.882058, "learning_rate": 2.0019387376162305e-05, "grad_norm": 0.5679551362991333, "tokens_seen": 4967628800, "tokens_per_second": 266540}
+{"step": 38000, "max_steps": 38147, "train_loss": 2.804259, "learning_rate": 2.0006867044626598e-05, "grad_norm": 0.5903794169425964, "tokens_seen": 4980736000, "tokens_per_second": 266543}
+{"step": 38000, "validation_loss": 2.889988, "validation_perplexity": 17.9931}
+{"step": 38100, "max_steps": 38147, "train_loss": 2.808716, "learning_rate": 2.000070199799935e-05, "grad_norm": 0.5782372951507568, "tokens_seen": 4993843200, "tokens_per_second": 262438}
+Final checkpoint: runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147
diff --git a/reports/kawk50m-ko-instruct-v1/baseline-evaluation.json b/reports/kawk50m-ko-instruct-v1/baseline-evaluation.json
new file mode 100644
index 0000000000000000000000000000000000000000..cbc6b8cd285728877b2316e3d51d9ab0db27d3f5
--- /dev/null
+++ b/reports/kawk50m-ko-instruct-v1/baseline-evaluation.json
@@ -0,0 +1,56 @@
+{
+  "checkpoint": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+  "tokenizer": "/workspace/KAWK50M/artifacts/tokenizer-20k-v3",
+  "validation_loss": 2.54827207645266,
+  "validation_perplexity": 12.784993194667898,
+  "evaluated_supervised_tokens": 341104,
+  "assistant_only_loss": true,
+  "samples": [
+    {
+      "prompt": "대한민국의 수도는 어디인가요? 한 문장으로 답해주세요.",
+      "response": "한국에서 가장 오래된 수도 중 하나인 서울은 1950년대에 지어진 최초의 수도로, 현재는 300년이 넘은 역사를 가지고 있습니다. 이 수도는 1872년에 처음 지어졌으며, 1964년에는 1960년대에 다시 지어졌습니다. 서울은 1970년대에 고덕동과 고덕동을 연결하는 도로가 개통되면서 번성했습니다. 또한, 1980년대에는 고덕동과 고덕동을 연결하는 도로가 개통되어 서울의 중심지 역할을 했습니다. 서울은 고덕동과 고덕동을 연결하는 도로를 건설하여 서울의 중심지 역할을 수행했습니다.",
+      "metrics": {
+        "characters": 270,
+        "hangul_visible_ratio": 0.8379629629629629,
+        "unique_word_ratio": 0.7818181818181819
+      }
+    },
+    {
+      "prompt": "비가 오는 날 외출할 때 준비할 물건 세 가지를 알려주세요.",
+      "response": "비오는 날 외출 시 준비해야 할 물품은 무엇인가요?\n### 1. 옷장:\n옷을 보관하는 장소는 어떤 것이 있나요?\n옷을 보관하기 위해 필요한 물품은 무엇인가요?\n### 2. 가방:\n가방을 보관할 수 있는 아이템은 무엇인가요?\n### 3. 지갑:\n가방을 보관할 수 있는 아이템은 무엇인가요?\n### 4. 지갑:\n가방을 보관할 수 있는 아이템은 무엇인가요?\n### 5. 지갑:\n가방을 보관할 수 있는 아이템은 무엇인가요?\n### 6. 지갑:\n가방을 보관할 수 있는 아이템은 무엇인가요?\n### 7. 지갑:\n가",
+      "metrics": {
+        "characters": 281,
+        "hangul_visible_ratio": 0.7619047619047619,
+        "unique_word_ratio": 0.4722222222222222
+      }
+    },
+    {
+      "prompt": "다음 문장을 자연스럽게 고쳐주세요: 나는 어제 학교에 갑니다.",
+      "response": "이 문장은 1980년대의 팝 음악과 2000년대의 록 음악 사이에 존재하는 전형적인 멜로디를 사용합니다.\n그것은 팝 음악의 멜로디와 록 음악의 멜로디가 서로 다른 방식으로 결합되어 있습니다.\n### 도우미:\n이 문장은 팝 음악의 멜로디와 록 음악의 멜로디가 서로 다른 방식으로 결합되어 있습니다.\n그것은 팝 음악의 멜로디와 록 음악의 멜로디가 서로 다른 방식으로 결합되어 있습니다.\n### 도우미:\n이 문장은 팝 음악의 멜로디와 록 음악의 멜로디",
+      "metrics": {
+        "characters": 249,
+        "hangul_visible_ratio": 0.8936170212765957,
+        "unique_word_ratio": 0.4032258064516129
+      }
+    },
+    {
+      "prompt": "한국어로 자기소개를 두 문장으로 해주세요.",
+      "response": "안녕하세요, 저는 한국에 있는 외국인으로서 한국어로 자기소개를 하고 싶습니다.\n이름:\n한국어로 자기소개를 하려면 어떻게 해야 할까요?\n도우미:\n저는 한국어로 자기소개를 하기 위해 다음과 같은 방법을 사용할 수 있습니다.\n1. 인터넷을 통해 자신의 언어를 검색합니다.\n2. 한국어로 자기소개를 하려면 어떻게 해야 할까요?\n3. 인터넷에서 자신의 언어를 검색하고, 자신의 언어를 다른 언어로 바꾸거나 변경할 수 있습니다.\n4. 인터넷에서 자신의 언어를 변경하거나 변경할 수 있습니다.\n5. 자신의 언어를 다른 언어로 바꾸거나 변경할 수 있습니다.\n6. 자신의 언어를 다른 언어로 바꿀 수도 있습니다.\n7. 자신의 언어를",
+      "metrics": {
+        "characters": 344,
+        "hangul_visible_ratio": 0.8973384030418251,
+        "unique_word_ratio": 0.5365853658536586
+      }
+    },
+    {
+      "prompt": "사용자가 위험한 요청을 하면 어떻게 대응해야 하나요?",
+      "response": "이메일이나 문자메시지로 사용자의 요청을 처리하는 것은 매우 어렵습니다. 하지만 사용자는 이러한 요청을 처리할 수 있는 도구를 제공합니다.\n### 2. 사용자의 요청 처리 방법\n사용자는 이메일, 문자 메시지, 또는 기타 방법으로 사용자의 요청을 처리할 수 있습니다.\n### 3. 사용자의 요청 처리 방법\n사용자는 사용자의 요청을 처리하기 위해 다음과 같은 방법을 사용할 수 있습니다.\n1. 사용자의 요청을 처리합니다.\n2. 사용자의 요청을 처리하기 위해 사용자의 요청을 처리합니다.\n3. 사용자의 요청을 처리하기 위해 사용자의 요청을 처리합니다.\n4. 사용자의 요청을 처리하기 위해 사용자의 요청을 처리합니다.\n5. 사용자의 요청을",
+      "metrics": {
+        "characters": 352,
+        "hangul_visible_ratio": 0.8888888888888888,
+        "unique_word_ratio": 0.46987951807228917
+      }
+    }
+  ],
+  "note": "Korean instruction evaluation; responses are sampled, not facts checked."
+}
diff --git a/reports/kawk50m-ko-instruct-v1/train.log b/reports/kawk50m-ko-instruct-v1/train.log
new file mode 100644
index 0000000000000000000000000000000000000000..3e8dba25ed2b4f303d6b9a913ac3b635b95d83c7
--- /dev/null
+++ b/reports/kawk50m-ko-instruct-v1/train.log
@@ -0,0 +1,112 @@
+{
+  "parameters": 51542528,
+  "device": "cuda",
+  "sequence_length": 5120,
+  "train_sequences": 15626,
+  "validation_sequences": 200,
+  "epochs": 2.0,
+  "sequences_per_optimizer_step": 24,
+  "tokens_per_optimizer_step": 122880,
+  "max_steps": 1303,
+  "planned_capacity_tokens": 160112640,
+  "start_step": 0,
+  "initialized_from": "/workspace/KAWK50M/runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+  "assistant_only_loss": true,
+  "precision": "bf16",
+  "compile": true
+}
+{"step": 1, "max_steps": 1303, "train_loss": 2.450684, "learning_rate": 1.282051282051282e-06, "grad_norm": 2.340644359588623, "supervised_tokens_in_step": 83853, "tokens_per_second": 6532}
+{"step": 20, "max_steps": 1303, "train_loss": 2.347481, "learning_rate": 2.564102564102564e-05, "grad_norm": 0.8594114780426025, "supervised_tokens_in_step": 86722, "tokens_per_second": 115987}
+Stop checkpoint: runs/kawk50m-ko-instruct-v1-5090/checkpoint-00000020
+{
+  "parameters": 51542528,
+  "device": "cuda",
+  "sequence_length": 5120,
+  "train_sequences": 15626,
+  "validation_sequences": 200,
+  "epochs": 2.0,
+  "sequences_per_optimizer_step": 24,
+  "tokens_per_optimizer_step": 122880,
+  "max_steps": 1303,
+  "planned_capacity_tokens": 160112640,
+  "start_step": 20,
+  "initialized_from": null,
+  "assistant_only_loss": true,
+  "precision": "bf16",
+  "compile": true
+}
+{"step": 40, "max_steps": 1303, "train_loss": 2.333369, "learning_rate": 4.999993050430598e-05, "grad_norm": 0.8435298204421997, "supervised_tokens_in_step": 84949, "tokens_per_second": 100529}
+{"step": 60, "max_steps": 1303, "train_loss": 2.324109, "learning_rate": 4.996935934013126e-05, "grad_norm": 0.8027786612510681, "supervised_tokens_in_step": 85477, "tokens_per_second": 115613}
+{"step": 80, "max_steps": 1303, "train_loss": 2.271922, "learning_rate": 4.988327873548549e-05, "grad_norm": 0.761134147644043, "supervised_tokens_in_step": 85546, "tokens_per_second": 115473}
+{"step": 100, "max_steps": 1303, "train_loss": 2.345757, "learning_rate": 4.974190134824319e-05, "grad_norm": 0.7603924870491028, "supervised_tokens_in_step": 87840, "tokens_per_second": 115765}
+{"step": 120, "max_steps": 1303, "train_loss": 2.286366, "learning_rate": 4.9545576444244234e-05, "grad_norm": 0.7394975423812866, "supervised_tokens_in_step": 85646, "tokens_per_second": 115659}
+{"step": 140, "max_steps": 1303, "train_loss": 2.319667, "learning_rate": 4.929478903444984e-05, "grad_norm": 0.797751784324646, "supervised_tokens_in_step": 89247, "tokens_per_second": 115754}
+{"step": 160, "max_steps": 1303, "train_loss": 2.319262, "learning_rate": 4.8990158676747e-05, "grad_norm": 0.7572959065437317, "supervised_tokens_in_step": 85585, "tokens_per_second": 115685}
+{"step": 180, "max_steps": 1303, "train_loss": 2.296479, "learning_rate": 4.863243794536136e-05, "grad_norm": 0.7168862223625183, "supervised_tokens_in_step": 88009, "tokens_per_second": 115681}
+{"step": 200, "max_steps": 1303, "train_loss": 2.279972, "learning_rate": 4.8222510571659895e-05, "grad_norm": 0.7220127582550049, "supervised_tokens_in_step": 88893, "tokens_per_second": 115636}
+/usr/local/lib/python3.12/dist-packages/torch/_inductor/compile_fx.py:282: UserWarning: TensorFloat32 tensor cores for float32 matrix multiplication available but not enabled. Consider setting `torch.set_float32_matmul_precision('high')` for better performance.
+  warnings.warn(
+{"step": 200, "validation_loss": 2.403591, "validation_perplexity": 11.0628, "validation_supervised_tokens": 341104}
+{"step": 220, "max_steps": 1303, "train_loss": 2.27585, "learning_rate": 4.776138926093622e-05, "grad_norm": 0.7102628350257874, "supervised_tokens_in_step": 85294, "tokens_per_second": 81196}
+{"step": 240, "max_steps": 1303, "train_loss": 2.252894, "learning_rate": 4.725021319057228e-05, "grad_norm": 0.7745625376701355, "supervised_tokens_in_step": 84501, "tokens_per_second": 115715}
+{"step": 260, "max_steps": 1303, "train_loss": 2.312163, "learning_rate": 4.669024519575705e-05, "grad_norm": 0.7289627194404602, "supervised_tokens_in_step": 85363, "tokens_per_second": 115689}
+{"step": 280, "max_steps": 1303, "train_loss": 2.227963, "learning_rate": 4.6082868649714635e-05, "grad_norm": 0.7343097925186157, "supervised_tokens_in_step": 85313, "tokens_per_second": 115678}
+{"step": 300, "max_steps": 1303, "train_loss": 2.253481, "learning_rate": 4.5429584046149166e-05, "grad_norm": 0.7375707626342773, "supervised_tokens_in_step": 88018, "tokens_per_second": 115699}
+{"step": 320, "max_steps": 1303, "train_loss": 2.317738, "learning_rate": 4.4732005292349395e-05, "grad_norm": 0.7279749512672424, "supervised_tokens_in_step": 85609, "tokens_per_second": 115741}
+{"step": 340, "max_steps": 1303, "train_loss": 2.268028, "learning_rate": 4.399185572211055e-05, "grad_norm": 0.7550586462020874, "supervised_tokens_in_step": 85623, "tokens_per_second": 115692}
+{"step": 360, "max_steps": 1303, "train_loss": 2.293647, "learning_rate": 4.321096383832345e-05, "grad_norm": 0.7362149953842163, "supervised_tokens_in_step": 85354, "tokens_per_second": 115731}
+{"step": 380, "max_steps": 1303, "train_loss": 2.217218, "learning_rate": 4.239125879574867e-05, "grad_norm": 0.7212095260620117, "supervised_tokens_in_step": 83026, "tokens_per_second": 115685}
+{"step": 400, "max_steps": 1303, "train_loss": 2.242836, "learning_rate": 4.153476563513506e-05, "grad_norm": 0.7235660552978516, "supervised_tokens_in_step": 89569, "tokens_per_second": 115714}
+{"step": 400, "validation_loss": 2.367918, "validation_perplexity": 10.6751, "validation_supervised_tokens": 341104}
+{"step": 420, "max_steps": 1303, "train_loss": 2.154666, "learning_rate": 4.064360028045682e-05, "grad_norm": 0.7504831552505493, "supervised_tokens_in_step": 77337, "tokens_per_second": 110396}
+{"step": 440, "max_steps": 1303, "train_loss": 2.249795, "learning_rate": 3.971996431162805e-05, "grad_norm": 0.793662965297699, "supervised_tokens_in_step": 85744, "tokens_per_second": 115753}
+{"step": 460, "max_steps": 1303, "train_loss": 2.220676, "learning_rate": 3.876613952560843e-05, "grad_norm": 0.7667786478996277, "supervised_tokens_in_step": 81542, "tokens_per_second": 115756}
+{"step": 480, "max_steps": 1303, "train_loss": 2.206832, "learning_rate": 3.778448229933679e-05, "grad_norm": 0.7093261480331421, "supervised_tokens_in_step": 84235, "tokens_per_second": 115761}
+{"step": 500, "max_steps": 1303, "train_loss": 2.09693, "learning_rate": 3.677741776841846e-05, "grad_norm": 0.7661908268928528, "supervised_tokens_in_step": 78815, "tokens_per_second": 115740}
+Saved checkpoint: runs/kawk50m-ko-instruct-v1-5090/checkpoint-00000500
+{"step": 520, "max_steps": 1303, "train_loss": 2.304523, "learning_rate": 3.574743383594776e-05, "grad_norm": 0.7090751528739929, "supervised_tokens_in_step": 86564, "tokens_per_second": 113600}
+{"step": 540, "max_steps": 1303, "train_loss": 2.214948, "learning_rate": 3.469707502626648e-05, "grad_norm": 0.7331322431564331, "supervised_tokens_in_step": 76710, "tokens_per_second": 115632}
+{"step": 560, "max_steps": 1303, "train_loss": 2.299292, "learning_rate": 3.362893619884243e-05, "grad_norm": 0.7434960007667542, "supervised_tokens_in_step": 85048, "tokens_per_second": 115524}
+{"step": 580, "max_steps": 1303, "train_loss": 2.099081, "learning_rate": 3.254565613779749e-05, "grad_norm": 0.7385064959526062, "supervised_tokens_in_step": 75457, "tokens_per_second": 115650}
+{"step": 600, "max_steps": 1303, "train_loss": 2.2911, "learning_rate": 3.1449911032922045e-05, "grad_norm": 0.7000813484191895, "supervised_tokens_in_step": 88458, "tokens_per_second": 115412}
+{"step": 600, "validation_loss": 2.345304, "validation_perplexity": 10.4364, "validation_supervised_tokens": 341104}
+{"step": 620, "max_steps": 1303, "train_loss": 2.082757, "learning_rate": 3.034440786828045e-05, "grad_norm": 0.7202531695365906, "supervised_tokens_in_step": 76615, "tokens_per_second": 110341}
+{"step": 640, "max_steps": 1303, "train_loss": 2.2964, "learning_rate": 2.9231877734740916e-05, "grad_norm": 0.6959240436553955, "supervised_tokens_in_step": 85483, "tokens_per_second": 115773}
+{"step": 660, "max_steps": 1303, "train_loss": 2.18364, "learning_rate": 2.8115069082950614e-05, "grad_norm": 0.7376174926757812, "supervised_tokens_in_step": 85536, "tokens_per_second": 115723}
+{"step": 680, "max_steps": 1303, "train_loss": 2.034453, "learning_rate": 2.6996740933424363e-05, "grad_norm": 0.6972545385360718, "supervised_tokens_in_step": 86494, "tokens_per_second": 115748}
+{"step": 700, "max_steps": 1303, "train_loss": 2.160494, "learning_rate": 2.5879656060520946e-05, "grad_norm": 0.7508715987205505, "supervised_tokens_in_step": 82246, "tokens_per_second": 115712}
+{"step": 720, "max_steps": 1303, "train_loss": 1.999812, "learning_rate": 2.4766574167145764e-05, "grad_norm": 0.7145387530326843, "supervised_tokens_in_step": 81685, "tokens_per_second": 115711}
+{"step": 740, "max_steps": 1303, "train_loss": 2.092892, "learning_rate": 2.3660245067041364e-05, "grad_norm": 0.7211691737174988, "supervised_tokens_in_step": 83164, "tokens_per_second": 115726}
+{"step": 760, "max_steps": 1303, "train_loss": 2.084289, "learning_rate": 2.256340189150864e-05, "grad_norm": 0.7231587767601013, "supervised_tokens_in_step": 82188, "tokens_per_second": 115740}
+{"step": 780, "max_steps": 1303, "train_loss": 2.019705, "learning_rate": 2.147875433734121e-05, "grad_norm": 0.7101276516914368, "supervised_tokens_in_step": 80317, "tokens_per_second": 115725}
+{"step": 800, "max_steps": 1303, "train_loss": 2.080972, "learning_rate": 2.040898197265353e-05, "grad_norm": 0.7223166823387146, "supervised_tokens_in_step": 83287, "tokens_per_second": 115599}
+{"step": 800, "validation_loss": 2.335017, "validation_perplexity": 10.3296, "validation_supervised_tokens": 341104}
+{"step": 820, "max_steps": 1303, "train_loss": 2.087878, "learning_rate": 1.9356727617140458e-05, "grad_norm": 0.7293902039527893, "supervised_tokens_in_step": 82008, "tokens_per_second": 110247}
+{"step": 840, "max_steps": 1303, "train_loss": 2.12016, "learning_rate": 1.832459081312199e-05, "grad_norm": 0.6915454864501953, "supervised_tokens_in_step": 84157, "tokens_per_second": 115367}
+{"step": 860, "max_steps": 1303, "train_loss": 2.165454, "learning_rate": 1.731512140350256e-05, "grad_norm": 0.7230251431465149, "supervised_tokens_in_step": 82607, "tokens_per_second": 115400}
+{"step": 880, "max_steps": 1303, "train_loss": 2.074008, "learning_rate": 1.6330813232510332e-05, "grad_norm": 0.6996212005615234, "supervised_tokens_in_step": 84391, "tokens_per_second": 115428}
+{"step": 900, "max_steps": 1303, "train_loss": 2.012958, "learning_rate": 1.537409798477839e-05, "grad_norm": 0.7183899879455566, "supervised_tokens_in_step": 84450, "tokens_per_second": 115550}
+{"step": 920, "max_steps": 1303, "train_loss": 2.167079, "learning_rate": 1.4447339177988183e-05, "grad_norm": 0.6651352047920227, "supervised_tokens_in_step": 86696, "tokens_per_second": 115753}
+{"step": 940, "max_steps": 1303, "train_loss": 2.202042, "learning_rate": 1.3552826323916119e-05, "grad_norm": 0.674192488193512, "supervised_tokens_in_step": 88343, "tokens_per_second": 115770}
+{"step": 960, "max_steps": 1303, "train_loss": 2.171797, "learning_rate": 1.2692769272307864e-05, "grad_norm": 0.6765074133872986, "supervised_tokens_in_step": 88750, "tokens_per_second": 115778}
+{"step": 980, "max_steps": 1303, "train_loss": 2.085758, "learning_rate": 1.1869292751553982e-05, "grad_norm": 0.7256887555122375, "supervised_tokens_in_step": 83377, "tokens_per_second": 115757}
+{"step": 1000, "max_steps": 1303, "train_loss": 2.127656, "learning_rate": 1.1084431119653585e-05, "grad_norm": 0.7082517147064209, "supervised_tokens_in_step": 85872, "tokens_per_second": 115464}
+{"step": 1000, "validation_loss": 2.326874, "validation_perplexity": 10.2459, "validation_supervised_tokens": 341104}
+Saved checkpoint: runs/kawk50m-ko-instruct-v1-5090/checkpoint-00001000
+{"step": 1020, "max_steps": 1303, "train_loss": 2.033393, "learning_rate": 1.0340123338433502e-05, "grad_norm": 0.7110400795936584, "supervised_tokens_in_step": 81863, "tokens_per_second": 108929}
+{"step": 1040, "max_steps": 1303, "train_loss": 2.064529, "learning_rate": 9.638208183439063e-06, "grad_norm": 0.7083670496940613, "supervised_tokens_in_step": 84796, "tokens_per_second": 115765}
+{"step": 1060, "max_steps": 1303, "train_loss": 2.118068, "learning_rate": 8.980419701330082e-06, "grad_norm": 0.7071433067321777, "supervised_tokens_in_step": 81092, "tokens_per_second": 115679}
+{"step": 1080, "max_steps": 1303, "train_loss": 2.064492, "learning_rate": 8.36838292600437e-06, "grad_norm": 0.6941749453544617, "supervised_tokens_in_step": 82037, "tokens_per_second": 115425}
+{"step": 1100, "max_steps": 1303, "train_loss": 2.037831, "learning_rate": 7.803609864031949e-06, "grad_norm": 0.6952521204948425, "supervised_tokens_in_step": 82017, "tokens_per_second": 115419}
+{"step": 1120, "max_steps": 1303, "train_loss": 2.091592, "learning_rate": 7.287495759317571e-06, "grad_norm": 0.719948947429657, "supervised_tokens_in_step": 82368, "tokens_per_second": 115710}
+{"step": 1140, "max_steps": 1303, "train_loss": 2.142646, "learning_rate": 6.821315646219733e-06, "grad_norm": 0.6843776106834412, "supervised_tokens_in_step": 82018, "tokens_per_second": 115759}
+{"step": 1160, "max_steps": 1303, "train_loss": 2.099951, "learning_rate": 6.406221199641351e-06, "grad_norm": 0.6954435706138611, "supervised_tokens_in_step": 80084, "tokens_per_second": 115739}
+{"step": 1180, "max_steps": 1303, "train_loss": 2.079199, "learning_rate": 6.043237889873913e-06, "grad_norm": 0.7361739873886108, "supervised_tokens_in_step": 80202, "tokens_per_second": 115484}
+{"step": 1200, "max_steps": 1303, "train_loss": 2.065013, "learning_rate": 5.733262449223885e-06, "grad_norm": 0.707120954990387, "supervised_tokens_in_step": 83275, "tokens_per_second": 115429}
+{"step": 1200, "validation_loss": 2.322639, "validation_perplexity": 10.2026, "validation_supervised_tokens": 341104}
+{"step": 1220, "max_steps": 1303, "train_loss": 2.151211, "learning_rate": 5.477060656679872e-06, "grad_norm": 0.6623756289482117, "supervised_tokens_in_step": 86610, "tokens_per_second": 110407}
+{"step": 1240, "max_steps": 1303, "train_loss": 2.194439, "learning_rate": 5.2752654460935424e-06, "grad_norm": 0.6283762454986572, "supervised_tokens_in_step": 90614, "tokens_per_second": 115738}
+{"step": 1260, "max_steps": 1303, "train_loss": 2.174987, "learning_rate": 5.128375342547875e-06, "grad_norm": 0.6523645520210266, "supervised_tokens_in_step": 88230, "tokens_per_second": 115401}
+{"step": 1280, "max_steps": 1303, "train_loss": 2.070068, "learning_rate": 5.036753230775589e-06, "grad_norm": 0.6893972754478455, "supervised_tokens_in_step": 86951, "tokens_per_second": 115404}
+{"step": 1300, "max_steps": 1303, "train_loss": 2.102395, "learning_rate": 5.0006254586703764e-06, "grad_norm": 0.7105104327201843, "supervised_tokens_in_step": 82481, "tokens_per_second": 115412}
+Final checkpoint: runs/kawk50m-ko-instruct-v1-5090/checkpoint-00001303
diff --git a/requirements-data.txt b/requirements-data.txt
new file mode 100644
index 0000000000000000000000000000000000000000..74015d0ab770c7998eb463a65a816a3531b55e79
--- /dev/null
+++ b/requirements-data.txt
@@ -0,0 +1,5 @@
+-r requirements.txt
+datasets>=4,<5
+huggingface-hub>=0.36,<2
+pyarrow>=20,<25
+
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 0000000000000000000000000000000000000000..425d2b154895d9877b2a6e071da6fdea8d9de6d9
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,3 @@
+-r requirements.txt
+pytest>=8,<10
+
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a96c4215ba23aa21e34a30d957fa76e94e9feb95
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,8 @@
+torch>=2.4,<3
+transformers>=4.48,<5
+sentencepiece>=0.2,<1
+protobuf>=4.25,<7
+PyYAML>=6,<7
+numpy>=1.26,<3
+safetensors>=0.4,<1
+tqdm>=4.66,<5
diff --git a/runpod/README.md b/runpod/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5baf84741d41bdce7a89b8b5ae871d45abb7f5ca
--- /dev/null
+++ b/runpod/README.md
@@ -0,0 +1,98 @@
+# RunPod RTX 5090 실행
+
+`KAWK-1.5-50M Korean Base`의 기준 환경은 RTX 5090 32GB 한 장입니다.
+엄격 한국어 20B 베이스 사전학습 후 같은 가중치를 5,120 컨텍스트로
+확장하여 3B 토큰을 계속학습합니다.
+
+## Pod 권장값
+
+- GPU: NVIDIA GeForce RTX 5090 1장
+- 이미지: CUDA 12.8 계열 RunPod PyTorch
+- Container disk: 20GB 이상
+- Persistent volume: **200GB 권장**
+- 프로젝트 경로: `/workspace/KAWK50M`
+
+20B `uint16` 토큰은 약 40GB입니다. 원문·정제본, 비교 체크포인트,
+중간 체크포인트까지 유지하므로 100GB volume은 빠듯합니다.
+
+## 환경 준비
+
+```bash
+cd /workspace/KAWK50M
+bash runpod/bootstrap.sh
+```
+
+`bootstrap.sh`는 시스템 Python을 변경하지 않고 `.venv`를 만들며 이미지의
+CUDA PyTorch를 재사용합니다.
+
+## 전체 빌드
+
+초기 341만 엄격 정제 문서를 토큰화합니다.
+
+```bash
+bash runpod/tokenize_v2_initial.sh
+```
+
+고정된 FineWeb2 revision에서 20B까지 직접 스트리밍·필터·토큰화합니다.
+원문을 별도로 저장하지 않으므로 volume 사용량을 줄일 수 있습니다.
+
+```bash
+bash runpod/stream_v2_20b.sh
+```
+
+중단 후 재개:
+
+```bash
+RESUME=1 bash runpod/stream_v2_20b.sh
+```
+
+20B manifest가 생긴 뒤 전체 후속 단계를 자동 실행:
+
+```bash
+bash runpod/continue_kawk_1_5_after_stream.sh
+```
+
+이 스크립트는 다음을 순서대로 수행합니다.
+
+1. 1,024 컨텍스트 20B 베이스 사전학습
+2. 고정 revision·허용 라이선스 한국어 RAG/대화 필터링
+3. 코드, LaTeX, 수학/코드 source, 영어 중심 행 제외
+4. 2.9B 장문 + 0.1B 구조 데이터 CPT 혼합
+5. 5,120 컨텍스트 3B 계속학습
+6. validation loss, UTF-8 byte loss, 생성 평가
+7. 모델 카드와 SHA-256 체크섬 생성
+
+## 속도 기준
+
+실측 RTX 5090 합성 벤치마크:
+
+- 1,024 컨텍스트: 약 266K tokens/s
+- 5,120 컨텍스트, batch 4 × accumulation 6: 약 116K tokens/s
+- 5,120 단계 peak VRAM: 약 8.5GiB
+
+계산만 보면 20B는 약 21시간, 3B CPT는 약 7.2시간입니다. 데이터 공급,
+평가와 체크포인트 저장 시간은 별도입니다.
+
+## 로그와 결과
+
+```text
+/workspace/kawk-v2-stream-20b-wrapper.log
+/workspace/kawk-v2-stream-20b-worker-00.log ... worker-03.log
+/workspace/kawk-1.5-build-continuation.log
+reports/v2-20b/
+reports/kawk-1.5-50m-v2/
+runs/kawk50m-v2-20b-5090/
+runs/kawk-1.5-50m-v2-cpt-3b-5090/
+```
+
+상태 확인:
+
+```bash
+cat data/tokenized-v2-20b/manifest.json
+tail -n 30 reports/v2-20b/train.log
+tail -n 30 reports/kawk-1.5-50m-v2/train.log
+nvidia-smi
+```
+
+Pod를 삭제하기 전에 최종 체크포인트, `MODEL_CARD.md`, 평가 JSON,
+`checksums.sha256`을 로컬이나 별도 영구 저장소에 복사하십시오.
diff --git a/runpod/bootstrap.sh b/runpod/bootstrap.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0877770dd1a347026dcc29bd3aa9e2b4236a01d3
--- /dev/null
+++ b/runpod/bootstrap.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+VENV_DIR="${VENV_DIR:-${PROJECT_DIR}/.venv}"
+
+if [[ ! -d "${PROJECT_DIR}" ]]; then
+  echo "Project directory not found: ${PROJECT_DIR}" >&2
+  exit 1
+fi
+
+cd "${PROJECT_DIR}"
+if [[ ! -x "${VENV_DIR}/bin/python" ]]; then
+  python -m venv --system-site-packages "${VENV_DIR}"
+fi
+
+# Keep the CUDA-enabled PyTorch bundled with the RunPod image available while
+# installing this project into an isolated environment (PEP 668 compatible).
+source "${VENV_DIR}/bin/activate"
+python -m pip install --upgrade pip
+python -m pip install -e .
+mkdir -p data/raw data/clean data/tokenized artifacts runs
+
+nvidia-smi
+python -m scripts.model_info --config configs/model_50m.yaml
+
+echo
+echo "Bootstrap complete."
+echo "Virtual environment: ${VENV_DIR}"
+echo "After tokenizer and token binaries are present, run:"
+echo "  bash runpod/train_5090.sh"
diff --git a/runpod/download_5b_parallel.sh b/runpod/download_5b_parallel.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9250fdbf12cf1806b518eb1e4627aa375179346e
--- /dev/null
+++ b/runpod/download_5b_parallel.sh
@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-data/raw/fineweb2-kor-5b}"
+REVISION="${REVISION:-af9c13333eb981300149d5ca60a8e9d659b276b9}"
+WORKERS="${WORKERS:-4}"
+TOTAL_DOCUMENTS="${TOTAL_DOCUMENTS:-6500000}"
+
+cd "${PROJECT_DIR}"
+source "${PROJECT_DIR}/.venv/bin/activate"
+
+if (( TOTAL_DOCUMENTS % WORKERS != 0 )); then
+  echo "TOTAL_DOCUMENTS must be divisible by WORKERS" >&2
+  exit 1
+fi
+
+documents_per_worker=$((TOTAL_DOCUMENTS / WORKERS))
+mkdir -p "${OUTPUT_ROOT}"
+pids=()
+
+for ((worker = 0; worker < WORKERS; worker++)); do
+  worker_dir="${OUTPUT_ROOT}/part-$(printf '%02d' "${worker}")"
+  worker_log="/workspace/kawk50m-download-5b-worker-$(printf '%02d' "${worker}").log"
+  if [[ -e "${worker_dir}" ]]; then
+    echo "Refusing to overwrite existing worker directory: ${worker_dir}" >&2
+    exit 1
+  fi
+  python -u -m scripts.download_fineweb2 \
+    --revision "${REVISION}" \
+    --output-dir "${worker_dir}" \
+    --max-documents "${documents_per_worker}" \
+    --documents-per-shard 50000 \
+    --shuffle-buffer 10000 \
+    --seed "$((42 + worker))" \
+    --compression-level 1 \
+    --dataset-num-shards "${WORKERS}" \
+    --dataset-shard-index "${worker}" \
+    > "${worker_log}" 2>&1 &
+  pids+=("$!")
+  echo "worker=${worker} pid=${pids[-1]} log=${worker_log}"
+done
+
+status=0
+for pid in "${pids[@]}"; do
+  if ! wait "${pid}"; then
+    status=1
+  fi
+done
+
+if (( status != 0 )); then
+  echo "At least one download worker failed." >&2
+  exit "${status}"
+fi
+
+python - <<'PY'
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+root = Path("data/raw/fineweb2-kor-5b")
+states = []
+for state_path in sorted(root.glob("part-*/download_state.json")):
+    states.append(json.loads(state_path.read_text(encoding="utf-8")))
+summary = {
+    "workers": len(states),
+    "documents": sum(int(state["documents_written"]) for state in states),
+    "utf8_text_gib": sum(int(state["utf8_bytes"]) for state in states) / 1024**3,
+    "shards": sum(int(state["completed_shards"]) for state in states),
+    "complete": bool(states) and all(bool(state["complete"]) for state in states),
+    "revision": sorted({state["revision"] for state in states}),
+}
+(root / "download_summary.json").write_text(
+    json.dumps(summary, ensure_ascii=False, indent=2) + "\n",
+    encoding="utf-8",
+)
+print(json.dumps(summary, ensure_ascii=False, indent=2))
+PY
diff --git a/runpod/prepare_5b_after_download.sh b/runpod/prepare_5b_after_download.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d6fc83bb7b12f54349041a749aef2ff752181a0f
--- /dev/null
+++ b/runpod/prepare_5b_after_download.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+DOWNLOAD_PID="${DOWNLOAD_PID:?Set DOWNLOAD_PID to the active coordinator PID}"
+RAW_ROOT="${RAW_ROOT:-data/raw/fineweb2-kor-5b}"
+CLEAN_DIR="${CLEAN_DIR:-data/clean-5b}"
+TOKENIZED_DIR="${TOKENIZED_DIR:-data/tokenized-5b}"
+TOKENIZER_DIR="${TOKENIZER_DIR:-artifacts/tokenizer-20k-pilot}"
+
+cd "${PROJECT_DIR}"
+source "${PROJECT_DIR}/.venv/bin/activate"
+
+for output_dir in "${CLEAN_DIR}" "${TOKENIZED_DIR}"; do
+  if [[ -e "${output_dir}" ]]; then
+    echo "Refusing to overwrite existing output: ${output_dir}" >&2
+    exit 1
+  fi
+done
+
+echo "Waiting for download coordinator PID ${DOWNLOAD_PID}..."
+while kill -0 "${DOWNLOAD_PID}" 2>/dev/null; do
+  sleep 30
+done
+
+python - <<'PY'
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+summary_path = Path("data/raw/fineweb2-kor-5b/download_summary.json")
+if not summary_path.is_file():
+    raise SystemExit(f"Download summary missing: {summary_path}")
+summary = json.loads(summary_path.read_text(encoding="utf-8"))
+if not summary.get("complete") or int(summary.get("documents", 0)) != 6_500_000:
+    raise SystemExit(f"Download incomplete: {summary}")
+print(json.dumps(summary, ensure_ascii=False, indent=2))
+PY
+
+echo "Starting clean/filter/dedup..."
+python -u -m scripts.prepare_corpus \
+  --input "${RAW_ROOT}/part-*/*.jsonl.gz" \
+  --output-dir "${CLEAN_DIR}" \
+  --documents-per-shard 50000 \
+  --validation-ratio 0.002 \
+  --test-ratio 0.001 \
+  --seed 42 \
+  --workers 16 \
+  --worker-batch-size 64
+
+echo "Starting tokenization..."
+bash runpod/tokenize_5b_parallel.sh
+
+echo "5B data preparation complete."
diff --git a/runpod/stream_v2_20b.sh b/runpod/stream_v2_20b.sh
new file mode 100644
index 0000000000000000000000000000000000000000..31fa605949258c6544a5478f16acee359cef89bd
--- /dev/null
+++ b/runpod/stream_v2_20b.sh
@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-data/tokenized-v2-20b/stream}"
+INITIAL_MANIFEST="${INITIAL_MANIFEST:-data/tokenized-v2-20b/initial/manifest.json}"
+TOKENIZER_DIR="${TOKENIZER_DIR:-artifacts/tokenizer-20k-v3}"
+REVISION="${REVISION:-af9c13333eb981300149d5ca60a8e9d659b276b9}"
+TARGET_TOKENS="${TARGET_TOKENS:-20000000000}"
+DATASET_SHARDS="${DATASET_SHARDS:-4}"
+SKIP_PER_SHARD="${SKIP_PER_SHARD:-1625000}"
+FILTER_WORKERS_PER_STREAM="${FILTER_WORKERS_PER_STREAM:-4}"
+RESUME="${RESUME:-0}"
+
+cd "${PROJECT_DIR}"
+source "${PROJECT_DIR}/.venv/bin/activate"
+ulimit -c 0
+
+if [[ ! -f "${INITIAL_MANIFEST}" ]]; then
+  echo "Initial token manifest is missing: ${INITIAL_MANIFEST}" >&2
+  exit 1
+fi
+if [[ -e "${OUTPUT_ROOT}" && "${RESUME}" != "1" ]]; then
+  echo "Refusing to overwrite existing stream output: ${OUTPUT_ROOT}" >&2
+  exit 1
+fi
+mkdir -p "${OUTPUT_ROOT}"
+
+read -r initial_tokens tokens_per_worker < <(
+  python - "${INITIAL_MANIFEST}" "${TARGET_TOKENS}" "${DATASET_SHARDS}" <<'PY'
+import json
+import math
+import sys
+
+initial = int(json.load(open(sys.argv[1], encoding="utf-8"))["tokens"])
+target = int(sys.argv[2])
+workers = int(sys.argv[3])
+remaining = target - initial
+if remaining <= 0:
+    raise SystemExit("Initial corpus already reaches the target")
+print(initial, math.ceil(remaining / workers))
+PY
+)
+echo "initial_tokens=${initial_tokens} tokens_per_stream=${tokens_per_worker}"
+
+pids=()
+for ((worker = 0; worker < DATASET_SHARDS; worker++)); do
+  worker_dir="${OUTPUT_ROOT}/part-$(printf '%02d' "${worker}")"
+  worker_log="/workspace/kawk-v2-stream-20b-worker-$(printf '%02d' "${worker}").log"
+  resume_args=()
+  if [[ -e "${worker_dir}" ]]; then
+    if [[ "${RESUME}" != "1" || ! -f "${worker_dir}/state.json" ]]; then
+      echo "Worker output exists without a resumable state: ${worker_dir}" >&2
+      exit 1
+    fi
+    resume_args+=(--resume)
+  fi
+  python -u -m scripts.stream_tokenize_fineweb2 \
+    --revision "${REVISION}" \
+    --tokenizer-dir "${TOKENIZER_DIR}" \
+    --output-dir "${worker_dir}" \
+    --dataset-num-shards "${DATASET_SHARDS}" \
+    --dataset-shard-index "${worker}" \
+    --skip-documents "${SKIP_PER_SHARD}" \
+    --max-output-tokens "${tokens_per_worker}" \
+    --tokens-per-chunk 250000000 \
+    --shuffle-buffer 10000 \
+    --seed "$((42 + worker))" \
+    --workers "${FILTER_WORKERS_PER_STREAM}" \
+    --worker-batch-size 64 \
+    --tokenize-batch-size 512 \
+    "${resume_args[@]}" \
+    > "${worker_log}" 2>&1 &
+  pids+=("$!")
+  echo "worker=${worker} pid=${pids[-1]} log=${worker_log}"
+done
+
+status=0
+for pid in "${pids[@]}"; do
+  if ! wait "${pid}"; then
+    status=1
+  fi
+done
+if (( status != 0 )); then
+  echo "At least one stream-tokenization worker failed." >&2
+  exit "${status}"
+fi
+
+python - "${INITIAL_MANIFEST}" "${OUTPUT_ROOT}" "${TARGET_TOKENS}" <<'PY'
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+initial_manifest = Path(sys.argv[1])
+output_root = Path(sys.argv[2])
+target = int(sys.argv[3])
+initial = json.loads(initial_manifest.read_text(encoding="utf-8"))
+states = [
+    json.loads(path.read_text(encoding="utf-8"))
+    for path in sorted(output_root.glob("part-*/state.json"))
+]
+summary = {
+    "initial_tokens": int(initial["tokens"]),
+    "stream_workers": len(states),
+    "stream_tokens": sum(int(state["tokens_written"]) for state in states),
+    "total_tokens": int(initial["tokens"])
+    + sum(int(state["tokens_written"]) for state in states),
+    "complete": bool(states) and all(bool(state["complete"]) for state in states),
+    "revision": sorted({state["revision"] for state in states}),
+}
+if not summary["complete"] or summary["total_tokens"] < target:
+    raise SystemExit(f"Incomplete 20B stream: {summary}")
+(output_root.parent / "manifest.json").write_text(
+    json.dumps(summary, ensure_ascii=False, indent=2) + "\n",
+    encoding="utf-8",
+)
+print(json.dumps(summary, ensure_ascii=False, indent=2))
+PY
+
+python -m scripts.preflight --config configs/pretrain_v2_20b_5090.yaml
+echo "KAWK50M v2 20B token corpus complete."
diff --git a/runpod/tokenize_5b_parallel.sh b/runpod/tokenize_5b_parallel.sh
new file mode 100644
index 0000000000000000000000000000000000000000..1479084175dc09880cd60335a1027748257ae393
--- /dev/null
+++ b/runpod/tokenize_5b_parallel.sh
@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+CLEAN_DIR="${CLEAN_DIR:-data/clean-5b}"
+TOKENIZED_DIR="${TOKENIZED_DIR:-data/tokenized-5b}"
+TOKENIZER_DIR="${TOKENIZER_DIR:-artifacts/tokenizer-20k-pilot}"
+WORKERS="${WORKERS:-16}"
+
+cd "${PROJECT_DIR}"
+source "${PROJECT_DIR}/.venv/bin/activate"
+
+if [[ -e "${TOKENIZED_DIR}" ]]; then
+  echo "Refusing to overwrite existing output: ${TOKENIZED_DIR}" >&2
+  exit 1
+fi
+mkdir -p "${TOKENIZED_DIR}/parts"
+
+tokenize_parts() {
+  local split="$1"
+  local split_dir="${TOKENIZED_DIR}/parts/${split}"
+  mkdir -p "${split_dir}"
+  find "${CLEAN_DIR}" -maxdepth 1 -type f -name "${split}-*.jsonl" -print0 \
+    | sort -z \
+    | xargs -0 -r -P "${WORKERS}" -I '{}' bash -c '
+        input="$1"
+        output_dir="$2"
+        tokenizer_dir="$3"
+        stem="$(basename "${input%.jsonl}")"
+        python -u -m scripts.tokenize_shard \
+          --input "${input}" \
+          --tokenizer-dir "${tokenizer_dir}" \
+          --output "${output_dir}/${stem}.bin" \
+          --batch-size 64
+      ' _ '{}' "${split_dir}" "${TOKENIZER_DIR}"
+}
+
+tokenize_parts train
+tokenize_parts validation
+tokenize_parts test
+
+python -m scripts.combine_token_parts \
+  --input-dir "${TOKENIZED_DIR}/parts/train" \
+  --output "${TOKENIZED_DIR}/train.bin" \
+  --max-tokens 5000000000
+python -m scripts.combine_token_parts \
+  --input-dir "${TOKENIZED_DIR}/parts/validation" \
+  --output "${TOKENIZED_DIR}/validation.bin" \
+  --max-tokens 2000000
+python -m scripts.combine_token_parts \
+  --input-dir "${TOKENIZED_DIR}/parts/test" \
+  --output "${TOKENIZED_DIR}/test.bin" \
+  --max-tokens 1000000
+
+python - <<'PY'
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+root = Path("data/tokenized-5b")
+splits = {}
+for split in ("train", "validation", "test"):
+    path = root / f"{split}.metadata.json"
+    splits[split] = json.loads(path.read_text(encoding="utf-8"))
+metadata = {
+    "tokenizer": str(Path("artifacts/tokenizer-20k-pilot").resolve()),
+    "vocab_size": 20000,
+    "eos_token_id": 2,
+    "splits": splits,
+}
+(root / "metadata.json").write_text(
+    json.dumps(metadata, ensure_ascii=False, indent=2) + "\n",
+    encoding="utf-8",
+)
+print(json.dumps(metadata, ensure_ascii=False, indent=2))
+PY
+
+echo "Parallel 5B tokenization complete."
diff --git a/runpod/train_5090.sh b/runpod/train_5090.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8e9e4f37a91f80d2a456adf684848774719142e2
--- /dev/null
+++ b/runpod/train_5090.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-/workspace/KAWK50M}"
+VENV_DIR="${VENV_DIR:-${PROJECT_DIR}/.venv}"
+CONFIG="${CONFIG:-configs/pretrain_5b_5090.yaml}"
+RESUME="${RESUME:-}"
+STOP_AFTER_STEPS="${STOP_AFTER_STEPS:-}"
+
+cd "${PROJECT_DIR}"
+if [[ ! -x "${VENV_DIR}/bin/python" ]]; then
+  echo "Virtual environment not found: ${VENV_DIR}" >&2
+  echo "Run: bash runpod/bootstrap.sh" >&2
+  exit 1
+fi
+source "${VENV_DIR}/bin/activate"
+
+python -m scripts.preflight --config "${CONFIG}"
+
+if [[ "${SKIP_BENCHMARK:-0}" != "1" ]]; then
+  python -m scripts.benchmark \
+    --batch-size 32 \
+    --gradient-accumulation 4 \
+    --compile \
+    --warmup-steps 1 \
+    --steps 3
+fi
+
+command=(python -m scripts.pretrain --config "${CONFIG}")
+if [[ -n "${RESUME}" ]]; then
+  command+=(--resume "${RESUME}")
+fi
+if [[ -n "${STOP_AFTER_STEPS}" ]]; then
+  command+=(--stop-after-steps "${STOP_AFTER_STEPS}")
+fi
+
+"${command[@]}"
diff --git a/scripts/__init__.py b/scripts/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc2fe56c7499e10f2170c7c4301402c2a2d2b706
--- /dev/null
+++ b/scripts/__init__.py
@@ -0,0 +1,2 @@
+"""Command-line entry modules. Run them with ``python -m scripts.<name>``."""
+
diff --git a/scripts/audit_corpus.py b/scripts/audit_corpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb4b50b2f4da89c295a781630330017d0c16f81b
--- /dev/null
+++ b/scripts/audit_corpus.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import argparse
+import json
+import random
+from collections import Counter
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from tqdm import tqdm
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import discover_paths, iter_documents
+from kawk50m.text import (
+    FilterConfig,
+    measure_text,
+    quality_score,
+    rejection_reason,
+)
+
+
+METRIC_FIELDS = (
+    "characters",
+    "hangul_visible_ratio",
+    "hangul_letter_ratio",
+    "digit_ratio",
+    "symbol_ratio",
+    "unique_line_ratio",
+    "unique_word_ratio",
+    "short_line_ratio",
+    "list_line_ratio",
+    "table_line_ratio",
+    "boilerplate_hits_per_1k",
+    "repeated_character_run",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Audit Korean corpus quality and write deterministic samples."
+    )
+    parser.add_argument("--input", nargs="+", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--limit", type=int, default=100_000)
+    parser.add_argument("--sample-size", type=int, default=200)
+    parser.add_argument("--lowest-quality-size", type=int, default=200)
+    parser.add_argument("--seed", type=int, default=42)
+    return parser.parse_args()
+
+
+def quantiles(values: list[float]) -> dict[str, float]:
+    if not values:
+        return {}
+    result = np.quantile(
+        np.asarray(values, dtype=np.float64),
+        [0.0, 0.01, 0.05, 0.25, 0.50, 0.75, 0.95, 0.99, 1.0],
+    )
+    names = ("min", "p01", "p05", "p25", "p50", "p75", "p95", "p99", "max")
+    return {name: float(value) for name, value in zip(names, result)}
+
+
+def compact_row(
+    document: dict[str, Any],
+    *,
+    score: float,
+    reason: str | None,
+    metrics: Any,
+) -> dict[str, Any]:
+    return {
+        "id": document.get("id"),
+        "source": document.get("source"),
+        "url": document.get("url"),
+        "quality_score": round(score, 6),
+        "rejection_reason": reason,
+        "metrics": {
+            field: getattr(metrics, field)
+            for field in METRIC_FIELDS
+        },
+        "text": document["text"],
+    }
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.limit <= 0:
+        raise ValueError("--limit must be positive")
+    if args.sample_size < 0 or args.lowest_quality_size < 0:
+        raise ValueError("sample sizes must be non-negative")
+
+    paths = discover_paths(args.input)
+    if not paths:
+        raise FileNotFoundError("No supported audit inputs were found")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    expected_outputs = (
+        output_dir / "audit_summary.json",
+        output_dir / "random_sample.jsonl",
+        output_dir / "lowest_quality.jsonl",
+    )
+    for path in expected_outputs:
+        if path.exists():
+            raise FileExistsError(
+                f"{path} already exists. Choose a new audit output directory."
+            )
+
+    rng = random.Random(args.seed)
+    filter_config = FilterConfig()
+    counters: Counter[str] = Counter()
+    sources: Counter[str] = Counter()
+    values: dict[str, list[float]] = {
+        field: [] for field in (*METRIC_FIELDS, "quality_score")
+    }
+    sample: list[dict[str, Any]] = []
+    lowest: list[dict[str, Any]] = []
+
+    documents = iter_documents(paths)
+    for index, document in enumerate(
+        tqdm(documents, total=args.limit, unit="docs"),
+        start=1,
+    ):
+        if index > args.limit:
+            break
+        metrics = measure_text(document["text"])
+        reason = rejection_reason(
+            document["text"], filter_config, metrics=metrics
+        )
+        score = quality_score(metrics, filter_config)
+        row = compact_row(
+            document,
+            score=score,
+            reason=reason,
+            metrics=metrics,
+        )
+
+        counters["documents"] += 1
+        counters["accepted" if reason is None else f"rejected_{reason}"] += 1
+        sources[str(document.get("source") or "unknown")] += 1
+        for field in METRIC_FIELDS:
+            values[field].append(float(getattr(metrics, field)))
+        values["quality_score"].append(score)
+
+        if len(sample) < args.sample_size:
+            sample.append(row)
+        elif args.sample_size:
+            replacement = rng.randrange(index)
+            if replacement < args.sample_size:
+                sample[replacement] = row
+
+        if args.lowest_quality_size:
+            lowest.append(row)
+            lowest.sort(key=lambda item: item["quality_score"])
+            if len(lowest) > args.lowest_quality_size:
+                lowest.pop()
+
+    summary = {
+        "inputs": [str(path) for path in paths],
+        "limit": args.limit,
+        "seed": args.seed,
+        "filter": asdict(filter_config),
+        "counts": dict(sorted(counters.items())),
+        "sources": dict(sources.most_common()),
+        "quantiles": {
+            field: quantiles(field_values)
+            for field, field_values in values.items()
+        },
+    }
+
+    with (output_dir / "audit_summary.json").open(
+        "w", encoding="utf-8"
+    ) as handle:
+        json.dump(summary, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    write_jsonl(output_dir / "random_sample.jsonl", sample)
+    write_jsonl(output_dir / "lowest_quality.jsonl", lowest)
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/benchmark.py b/scripts/benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..a39833123e72fea0397ff9e9bbcc41d51226836e
--- /dev/null
+++ b/scripts/benchmark.py
@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import time
+
+import torch
+from transformers import LlamaForCausalLM
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Benchmark synthetic BF16 pretraining throughput."
+    )
+    parser.add_argument("--config", default="configs/model_50m.yaml")
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--sequence-length", type=int, default=1024)
+    parser.add_argument("--gradient-accumulation", type=int, default=16)
+    parser.add_argument("--warmup-steps", type=int, default=1)
+    parser.add_argument("--steps", type=int, default=3)
+    parser.add_argument("--compile", action="store_true", dest="use_compile")
+    parser.add_argument("--compile-mode", default="default")
+    return parser.parse_args()
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if not torch.cuda.is_available() or not torch.cuda.is_bf16_supported():
+        raise RuntimeError("A CUDA GPU with BF16 support is required")
+    if args.use_compile and importlib.util.find_spec("triton") is None:
+        raise RuntimeError(
+            "--compile requires a working Triton installation; none was found"
+        )
+    for name in (
+        "batch_size",
+        "sequence_length",
+        "gradient_accumulation",
+        "warmup_steps",
+        "steps",
+    ):
+        if getattr(args, name) <= 0:
+            raise ValueError(f"--{name.replace('_', '-')} must be positive")
+
+    torch.set_float32_matmul_precision("high")
+    torch.backends.cuda.matmul.allow_tf32 = True
+    device = torch.device("cuda")
+    model_config, expected = build_llama_config(load_yaml(args.config))
+    if args.sequence_length > model_config.max_position_embeddings:
+        raise ValueError("sequence length exceeds the configured context length")
+
+    raw_model = LlamaForCausalLM(model_config).to(device)
+    parameter_count = count_unique_parameters(raw_model)
+    if expected is not None and parameter_count != expected:
+        raise RuntimeError(
+            f"Expected {expected} parameters but constructed {parameter_count}"
+        )
+    model = (
+        torch.compile(raw_model, mode=args.compile_mode)
+        if args.use_compile
+        else raw_model
+    )
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=6.0e-4,
+        betas=(0.9, 0.95),
+        weight_decay=0.1,
+        fused=True,
+    )
+    input_ids = torch.randint(
+        0,
+        model_config.vocab_size,
+        (args.batch_size, args.sequence_length),
+        device=device,
+        dtype=torch.long,
+    )
+
+    def optimizer_step() -> float:
+        optimizer.zero_grad(set_to_none=True)
+        total_loss = 0.0
+        for _ in range(args.gradient_accumulation):
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                loss = model(
+                    input_ids=input_ids,
+                    labels=input_ids,
+                    use_cache=False,
+                ).loss
+            (loss / args.gradient_accumulation).backward()
+            total_loss += loss.detach().item()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+        optimizer.step()
+        return total_loss / args.gradient_accumulation
+
+    for _ in range(args.warmup_steps):
+        optimizer_step()
+    torch.cuda.synchronize()
+    torch.cuda.reset_peak_memory_stats()
+    started = time.perf_counter()
+    final_loss = 0.0
+    for _ in range(args.steps):
+        final_loss = optimizer_step()
+    torch.cuda.synchronize()
+    elapsed = time.perf_counter() - started
+
+    tokens = (
+        args.steps
+        * args.gradient_accumulation
+        * args.batch_size
+        * args.sequence_length
+    )
+    tokens_per_second = tokens / elapsed
+    result = {
+        "gpu": torch.cuda.get_device_name(),
+        "parameters": parameter_count,
+        "precision": "bf16",
+        "compiled": args.use_compile,
+        "batch_size": args.batch_size,
+        "sequence_length": args.sequence_length,
+        "gradient_accumulation": args.gradient_accumulation,
+        "timed_optimizer_steps": args.steps,
+        "elapsed_seconds": elapsed,
+        "tokens": tokens,
+        "tokens_per_second": tokens_per_second,
+        "seconds_per_optimizer_step": elapsed / args.steps,
+        "peak_memory_gib": torch.cuda.max_memory_allocated() / 1024**3,
+        "final_synthetic_loss": final_loss,
+        "ideal_compute_only_hours": {
+            "1B": 1_000_000_000 / tokens_per_second / 3600,
+            "5B": 5_000_000_000 / tokens_per_second / 3600,
+            "10B": 10_000_000_000 / tokens_per_second / 3600,
+        },
+        "note": "Synthetic compute-only result; disk I/O, eval, and checkpoints are excluded.",
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/build_model_card.py b/scripts/build_model_card.py
new file mode 100644
index 0000000000000000000000000000000000000000..e230de7d16d8bcb7328693cc1af2a7c6906ffcfc
--- /dev/null
+++ b/scripts/build_model_card.py
@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from kawk50m.cli import configure_utf8_stdio
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Build the final KAWK-1.5-50M Korean model card."
+    )
+    parser.add_argument("--checkpoint", required=True)
+    parser.add_argument("--base-checkpoint", required=True)
+    parser.add_argument("--base-evaluation", required=True)
+    parser.add_argument("--base-byte-evaluation", required=True)
+    parser.add_argument("--evaluation", required=True)
+    parser.add_argument("--byte-evaluation", required=True)
+    parser.add_argument("--base-manifest", required=True)
+    parser.add_argument("--cpt-manifest", required=True)
+    parser.add_argument("--rag-state", required=True)
+    parser.add_argument("--chat-state", required=True)
+    parser.add_argument("--output", required=True)
+    return parser.parse_args()
+
+
+def read_json(path: str) -> dict[str, Any]:
+    value = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise TypeError(f"Expected a JSON object: {path}")
+    return value
+
+
+def metric(value: Any, digits: int = 6) -> str:
+    if isinstance(value, (int, float)):
+        return f"{float(value):.{digits}f}"
+    return "n/a"
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    checkpoint = Path(args.checkpoint).resolve()
+    base_checkpoint = Path(args.base_checkpoint).resolve()
+    base_eval = read_json(args.base_evaluation)
+    base_byte = read_json(args.base_byte_evaluation)
+    final_eval = read_json(args.evaluation)
+    final_byte = read_json(args.byte_evaluation)
+    base_manifest = read_json(args.base_manifest)
+    cpt_manifest = read_json(args.cpt_manifest)
+    rag_state = read_json(args.rag_state)
+    chat_state = read_json(args.chat_state)
+
+    text = f"""---
+language:
+- ko
+pipeline_tag: text-generation
+library_name: transformers
+tags:
+- llama
+- korean
+- base-model
+- long-context
+---
+
+# KAWK-1.5-50M Korean Base
+
+KAWK-1.5-50M은 한국어 중심 문서로 처음부터 학습한 51,542,528
+파라미터의 decoder-only Llama 계열 BASE 모델입니다. 1,024 토큰
+컨텍스트에서 20B 토큰 사전학습을 수행한 뒤, 같은 가중치를 5,120 토큰
+컨텍스트로 확장하여 3B 토큰을 추가 학습했습니다.
+
+이 모델은 지시 튜닝 모델이 아닙니다. 입력 뒤의 텍스트를 이어 쓰는 BASE
+모델이며, 질문에 정확히 답하거나 안전한 대화를 보장하지 않습니다.
+
+## Architecture
+
+| Item | Value |
+|---|---:|
+| Parameters | 51,542,528 |
+| Vocabulary | 20,000 |
+| Layers | 14 |
+| Hidden / MLP | 512 / 1,408 |
+| Attention / KV heads | 8 / 4 |
+| Head dimension | 64 |
+| Context | 5,120 |
+| Position encoding | RoPE, linear factor 5 |
+| Activation / norm | SwiGLU(SiLU) / RMSNorm |
+| Tied embeddings | yes |
+
+The tokenizer is a Korean-focused SentencePiece Unigram tokenizer with NFC
+input normalization and byte fallback. Dedicated English, source-code, and
+mathematics corpora were not used. Latin letters and numbers naturally
+embedded in Korean documents were retained.
+
+## Training
+
+- Base checkpoint: `{base_checkpoint}`
+- Final checkpoint: `{checkpoint}`
+- Base corpus tokens: {int(base_manifest.get("total_tokens", 0)):,}
+- Base pretraining budget: 20,000,000,000 tokens at context 1,024
+- Long-context CPT mix: {int(cpt_manifest.get("total_train_tokens", 0)):,} tokens
+- Long-context CPT budget: 3,000,000,000 tokens at context 5,120
+- Precision: BF16
+- Hardware: one NVIDIA GeForce RTX 5090
+
+The long-context mix contains 2.9B Korean web/document tokens and 100M
+strictly filtered structured Korean tokens:
+
+- Korean RAG: {int(rag_state.get("tokens_written", 0)):,} tokens,
+  accepted rows {int(rag_state.get("counts", {}).get("accepted", 0)):,}
+- Korean chat: {int(chat_state.get("tokens_written", 0)):,} tokens,
+  accepted rows {int(chat_state.get("counts", {}).get("accepted", 0)):,}
+
+ChatML markers were converted to plain Korean role labels. Rows containing
+code fences, LaTeX patterns, code/math-heavy text, disallowed licenses, or
+English-heavy content were rejected.
+
+## Data lineage and attribution
+
+- `HuggingFaceFW/fineweb-2`, subset `kor_Hang`, revision
+  `af9c13333eb981300149d5ca60a8e9d659b276b9`
+  (ODC-By 1.0; Common Crawl terms also apply)
+- `mkd-chanwoo/keural-rag-chatml-ko`, revision
+  `aa9023d231a3451d25135d5aa84b12b48ca06450`
+  (accepted rows: CC-BY-4.0)
+- `Mkd-Yonas/keural-SFT-chatml-ko-v1`, revision
+  `c56d7885efb37799deb1ecba471e4f6bf263852e`
+  (only rows with explicitly allowed permissive licenses were accepted)
+
+Users distributing the model should preserve these attributions and review
+the upstream dataset terms. The project source code license and the model
+weight release license should be stated separately at publication time.
+
+## Evaluation
+
+| Checkpoint | Context | Validation loss | Perplexity | Bits / UTF-8 byte |
+|---|---:|---:|---:|---:|
+| 20B base | 1,024 | {metric(base_eval.get("validation_loss"))} | {metric(base_eval.get("validation_perplexity"))} | {metric(base_byte.get("bits_per_utf8_byte"))} |
+| 3B long CPT | 5,120 | {metric(final_eval.get("validation_loss"))} | {metric(final_eval.get("validation_perplexity"))} | {metric(final_byte.get("bits_per_utf8_byte"))} |
+
+`bits / UTF-8 byte` is reported on the fixed ordered Korean validation
+documents. Generation samples are BASE-model continuations, not instruction
+following scores.
+
+## Limitations
+
+- At 50M parameters, factual coverage and multi-step reasoning are limited.
+- The model may generate incorrect, repetitive, biased, private, or unsafe text.
+- Web data can contain errors and cultural or temporal bias despite filtering.
+- A 5,120-token configuration does not guarantee reliable retrieval across the
+  entire context; task-specific long-context evaluation is still required.
+- Do not use the model as an authority for medical, legal, financial, or safety
+  decisions.
+"""
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(text, encoding="utf-8")
+    print(output.resolve())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/check_evaluation_gate.py b/scripts/check_evaluation_gate.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca383ed973865e84d770a7cb19d9b8df31b7e90
--- /dev/null
+++ b/scripts/check_evaluation_gate.py
@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+
+def load_result(path: str | Path) -> dict[str, Any]:
+    value = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError(f"Evaluation root must be an object: {path}")
+    return value
+
+
+def gate_result(
+    candidate: dict[str, Any],
+    *,
+    baseline: dict[str, Any] | None = None,
+    max_loss: float | None = None,
+    min_improvement: float = 0.0,
+) -> dict[str, Any]:
+    loss = float(candidate["validation_loss"])
+    if not math.isfinite(loss):
+        raise ValueError("Candidate validation loss is not finite")
+    if max_loss is not None and loss > max_loss:
+        raise ValueError(
+            f"Candidate loss {loss:.6f} exceeds maximum {max_loss:.6f}"
+        )
+    baseline_loss = None
+    improvement = None
+    if baseline is not None:
+        baseline_loss = float(baseline["validation_loss"])
+        if not math.isfinite(baseline_loss):
+            raise ValueError("Baseline validation loss is not finite")
+        improvement = baseline_loss - loss
+        if improvement < min_improvement:
+            raise ValueError(
+                f"Loss improvement {improvement:.6f} is below required "
+                f"{min_improvement:.6f}"
+            )
+    samples = candidate.get("samples")
+    if not isinstance(samples, list) or not samples:
+        raise ValueError("Candidate evaluation has no generation samples")
+    return {
+        "passed": True,
+        "candidate_loss": loss,
+        "baseline_loss": baseline_loss,
+        "loss_improvement": improvement,
+        "sample_count": len(samples),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Stop a staged training pipeline when evaluation regresses."
+    )
+    parser.add_argument("--candidate", required=True)
+    parser.add_argument("--baseline")
+    parser.add_argument("--max-loss", type=float)
+    parser.add_argument("--min-improvement", type=float, default=0.0)
+    args = parser.parse_args()
+    result = gate_result(
+        load_result(args.candidate),
+        baseline=load_result(args.baseline) if args.baseline else None,
+        max_loss=args.max_loss,
+        min_improvement=args.min_improvement,
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scripts/combine_token_parts.py b/scripts/combine_token_parts.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f201dfb3f60615aac8243c2e58f34dd2c724469
--- /dev/null
+++ b/scripts/combine_token_parts.py
@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from kawk50m.cli import configure_utf8_stdio
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Concatenate uint16 token parts with an optional exact limit."
+    )
+    parser.add_argument("--input-dir", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--max-tokens", type=int, default=None)
+    parser.add_argument("--copy-buffer-mib", type=int, default=8)
+    return parser.parse_args()
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.max_tokens is not None and args.max_tokens <= 0:
+        raise ValueError("--max-tokens must be positive")
+    if args.copy_buffer_mib <= 0:
+        raise ValueError("--copy-buffer-mib must be positive")
+
+    input_dir = Path(args.input_dir)
+    parts = sorted(input_dir.glob("*.bin"))
+    if not parts:
+        raise FileNotFoundError(f"No token parts found in {input_dir}")
+    output_path = Path(args.output)
+    metadata_path = output_path.with_suffix(".metadata.json")
+    if output_path.exists() or metadata_path.exists():
+        raise FileExistsError(f"Refusing to overwrite combined output: {output_path}")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    max_bytes = args.max_tokens * 2 if args.max_tokens is not None else None
+    buffer_size = args.copy_buffer_mib * 1024**2
+    bytes_written = 0
+    parts_used = 0
+    with output_path.open("wb") as target:
+        for part in parts:
+            part_size = part.stat().st_size
+            if part_size % 2:
+                raise ValueError(f"Odd byte size for uint16 part: {part}")
+            remaining = (
+                part_size
+                if max_bytes is None
+                else min(part_size, max_bytes - bytes_written)
+            )
+            if remaining <= 0:
+                break
+            with part.open("rb") as source:
+                while remaining:
+                    chunk = source.read(min(buffer_size, remaining))
+                    if not chunk:
+                        raise IOError(f"Unexpected EOF while reading {part}")
+                    target.write(chunk)
+                    bytes_written += len(chunk)
+                    remaining -= len(chunk)
+            parts_used += 1
+
+    summaries: list[dict[str, Any]] = []
+    for path in sorted(input_dir.glob("*.json")):
+        summaries.append(json.loads(path.read_text(encoding="utf-8")))
+    result = {
+        "output": str(output_path),
+        "tokens": bytes_written // 2,
+        "bytes": bytes_written,
+        "dtype": "uint16",
+        "available_part_tokens": sum(part.stat().st_size for part in parts) // 2,
+        "parts_available": len(parts),
+        "parts_used": parts_used,
+        "documents_seen": sum(int(row["documents_seen"]) for row in summaries),
+        "documents_written": sum(
+            int(row["documents_written"]) for row in summaries
+        ),
+    }
+    metadata_path.write_text(
+        json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/download_fineweb2.py b/scripts/download_fineweb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..97871c372eaa26c748e179de70d3800911b40bca
--- /dev/null
+++ b/scripts/download_fineweb2.py
@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any, TextIO
+
+from datasets import load_dataset
+from huggingface_hub import HfApi
+from tqdm import tqdm
+
+from kawk50m.cli import configure_utf8_stdio
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Stream a reproducible Korean FineWeb2 sample to sharded JSONL.gz."
+    )
+    parser.add_argument("--dataset", default="HuggingFaceFW/fineweb-2")
+    parser.add_argument("--subset", default="kor_Hang")
+    parser.add_argument("--split", default="train")
+    parser.add_argument(
+        "--revision",
+        default=None,
+        help="Hub commit SHA. The current dataset SHA is resolved when omitted.",
+    )
+    parser.add_argument(
+        "--output-dir", default="data/raw/fineweb2-kor-pilot"
+    )
+    parser.add_argument("--max-documents", type=int, default=300_000)
+    parser.add_argument("--documents-per-shard", type=int, default=50_000)
+    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument(
+        "--dataset-num-shards",
+        type=int,
+        default=1,
+        help="Split the streaming dataset into disjoint workers.",
+    )
+    parser.add_argument(
+        "--dataset-shard-index",
+        type=int,
+        default=0,
+        help="Zero-based worker index within --dataset-num-shards.",
+    )
+    parser.add_argument("--compression-level", type=int, default=6)
+    parser.add_argument(
+        "--cache-dir", default=".cache/huggingface/datasets"
+    )
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="Continue after completed shards recorded in download_state.json.",
+    )
+    return parser.parse_args()
+
+
+def atomic_json(path: Path, value: dict[str, Any]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    with temporary.open("w", encoding="utf-8") as handle:
+        json.dump(value, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    os.replace(temporary, path)
+
+
+def open_shard(
+    output_dir: Path, shard_index: int, compression_level: int
+) -> tuple[Path, Path, TextIO]:
+    final_path = output_dir / f"fineweb2-kor-{shard_index:05d}.jsonl.gz"
+    temporary_path = final_path.with_suffix(final_path.suffix + ".tmp")
+    if final_path.exists() or temporary_path.exists():
+        raise FileExistsError(f"Refusing to overwrite shard: {final_path}")
+    handle = gzip.open(
+        temporary_path,
+        "wt",
+        encoding="utf-8",
+        newline="\n",
+        compresslevel=compression_level,
+    )
+    return final_path, temporary_path, handle
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.max_documents <= 0:
+        raise ValueError("--max-documents must be positive")
+    if args.documents_per_shard <= 0:
+        raise ValueError("--documents-per-shard must be positive")
+    if args.shuffle_buffer < 1:
+        raise ValueError("--shuffle-buffer must be positive")
+    if args.dataset_num_shards <= 0:
+        raise ValueError("--dataset-num-shards must be positive")
+    if not 0 <= args.dataset_shard_index < args.dataset_num_shards:
+        raise ValueError(
+            "--dataset-shard-index must be in "
+            "[0, --dataset-num-shards)"
+        )
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    state_path = output_dir / "download_state.json"
+    existing_shards = sorted(output_dir.glob("fineweb2-kor-*.jsonl.gz"))
+
+    if args.resume:
+        if not state_path.is_file():
+            raise FileNotFoundError(f"Resume state is missing: {state_path}")
+        with state_path.open("r", encoding="utf-8") as handle:
+            state = json.load(handle)
+        if state["dataset"] != args.dataset or state["subset"] != args.subset:
+            raise ValueError("Resume dataset/subset does not match saved state")
+        if int(state.get("dataset_num_shards", 1)) != args.dataset_num_shards:
+            raise ValueError("Resume dataset shard count does not match saved state")
+        if int(state.get("dataset_shard_index", 0)) != args.dataset_shard_index:
+            raise ValueError("Resume dataset shard index does not match saved state")
+        revision = state["revision"]
+        documents_written = int(state["documents_written"])
+        utf8_bytes = int(state["utf8_bytes"])
+        shard_index = int(state["completed_shards"])
+        seed = int(state["seed"])
+        shuffle_buffer = int(state["shuffle_buffer"])
+        if len(existing_shards) != shard_index:
+            raise RuntimeError("Completed shard count does not match resume state")
+        if args.max_documents <= documents_written:
+            raise RuntimeError(
+                f"Download already contains {documents_written} documents; "
+                "--max-documents must be larger to extend it"
+            )
+    else:
+        if state_path.exists() or existing_shards:
+            raise FileExistsError(
+                f"{output_dir} already contains download artifacts; "
+                "use --resume or choose a new output directory"
+            )
+        revision = args.revision or HfApi().dataset_info(args.dataset).sha
+        documents_written = 0
+        utf8_bytes = 0
+        shard_index = 0
+        seed = args.seed
+        shuffle_buffer = args.shuffle_buffer
+
+    dataset = load_dataset(
+        args.dataset,
+        name=args.subset,
+        split=args.split,
+        revision=revision,
+        streaming=True,
+        cache_dir=args.cache_dir,
+    )
+    if args.dataset_num_shards > 1:
+        dataset = dataset.shard(
+            num_shards=args.dataset_num_shards,
+            index=args.dataset_shard_index,
+            contiguous=True,
+        )
+    dataset = dataset.shuffle(seed=seed, buffer_size=shuffle_buffer)
+    if documents_written:
+        dataset = dataset.skip(documents_written)
+
+    started = time.time()
+    progress = tqdm(
+        total=args.max_documents,
+        initial=documents_written,
+        unit="docs",
+        desc=args.subset,
+    )
+    final_path: Path | None = None
+    temporary_path: Path | None = None
+    handle: TextIO | None = None
+    documents_in_shard = 0
+
+    def save_state(*, complete: bool) -> None:
+        atomic_json(
+            state_path,
+            {
+                "dataset": args.dataset,
+                "subset": args.subset,
+                "split": args.split,
+                "revision": revision,
+                "license": "ODC-By-1.0; subject to CommonCrawl Terms of Use",
+                "seed": seed,
+                "shuffle_buffer": shuffle_buffer,
+                "dataset_num_shards": args.dataset_num_shards,
+                "dataset_shard_index": args.dataset_shard_index,
+                "max_documents": args.max_documents,
+                "documents_per_shard": args.documents_per_shard,
+                "documents_written": documents_written,
+                "utf8_bytes": utf8_bytes,
+                "completed_shards": shard_index,
+                "elapsed_seconds": time.time() - started,
+                "complete": complete,
+            },
+        )
+
+    try:
+        for row in dataset:
+            if documents_written >= args.max_documents:
+                break
+            if handle is None:
+                final_path, temporary_path, handle = open_shard(
+                    output_dir, shard_index, args.compression_level
+                )
+                documents_in_shard = 0
+
+            text = row.get("text")
+            if not isinstance(text, str) or not text.strip():
+                continue
+            output_row = {
+                "id": f"fineweb2:{row.get('id', documents_written)}",
+                "text": text,
+                "source": f"fineweb2:{args.subset}",
+                "url": row.get("url"),
+                "license": "ODC-By-1.0",
+                "date": row.get("date"),
+                "dump": row.get("dump"),
+                "language": row.get("language"),
+                "language_score": row.get("language_score"),
+                "minhash_cluster_size": row.get("minhash_cluster_size"),
+            }
+            encoded = json.dumps(
+                output_row, ensure_ascii=False, separators=(",", ":")
+            )
+            handle.write(encoded)
+            handle.write("\n")
+            documents_written += 1
+            documents_in_shard += 1
+            utf8_bytes += len(text.encode("utf-8"))
+            progress.update(1)
+
+            if documents_in_shard >= args.documents_per_shard:
+                handle.close()
+                handle = None
+                assert final_path is not None and temporary_path is not None
+                os.replace(temporary_path, final_path)
+                shard_index += 1
+                save_state(complete=False)
+
+        if handle is not None:
+            handle.close()
+            handle = None
+            assert final_path is not None and temporary_path is not None
+            os.replace(temporary_path, final_path)
+            shard_index += 1
+        save_state(complete=documents_written >= args.max_documents)
+    except BaseException:
+        if handle is not None:
+            handle.close()
+            handle = None
+            if documents_in_shard:
+                assert final_path is not None and temporary_path is not None
+                os.replace(temporary_path, final_path)
+                shard_index += 1
+        save_state(complete=False)
+        raise
+    finally:
+        if handle is not None:
+            handle.close()
+        progress.close()
+
+    print(
+        json.dumps(
+            {
+                "output_dir": str(output_dir.resolve()),
+                "revision": revision,
+                "documents": documents_written,
+                "utf8_text_gib": utf8_bytes / 1024**3,
+                "shards": shard_index,
+                "complete": documents_written >= args.max_documents,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/estimate_corpus_tokens.py b/scripts/estimate_corpus_tokens.py
new file mode 100644
index 0000000000000000000000000000000000000000..4844cd6ad8c17954bc36f83e79ea5820f399d3e1
--- /dev/null
+++ b/scripts/estimate_corpus_tokens.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import discover_paths, iter_documents
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Estimate total corpus tokens from a deterministic document sample."
+    )
+    parser.add_argument("--input", nargs="+", required=True)
+    parser.add_argument("--tokenizer-dir", required=True)
+    parser.add_argument("--prepare-stats", default=None)
+    parser.add_argument("--max-documents", type=int, default=50_000)
+    parser.add_argument("--batch-size", type=int, default=64)
+    return parser.parse_args()
+
+
+def accepted_counts(stats: dict[str, Any]) -> tuple[int, int]:
+    counts = stats.get("counts", {})
+    documents = sum(
+        int(counts.get(f"accepted_{split}", 0))
+        for split in ("train", "validation", "test")
+    )
+    characters = int(counts.get("accepted_characters", 0))
+    return documents, characters
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.max_documents <= 0 or args.batch_size <= 0:
+        raise ValueError("--max-documents and --batch-size must be positive")
+    paths = discover_paths(args.input)
+    if not paths:
+        raise FileNotFoundError("No corpus inputs were found")
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+
+    sampled_documents = 0
+    sampled_characters = 0
+    sampled_tokens = 0
+    batch: list[str] = []
+
+    def flush() -> None:
+        nonlocal sampled_documents, sampled_characters, sampled_tokens
+        if not batch:
+            return
+        encoded = tokenizer(
+            batch,
+            add_special_tokens=False,
+            return_attention_mask=False,
+            return_token_type_ids=False,
+        )["input_ids"]
+        for text, token_ids in zip(batch, encoded, strict=True):
+            sampled_documents += 1
+            sampled_characters += len(text)
+            sampled_tokens += len(token_ids) + 1
+        batch.clear()
+
+    for document in iter_documents(paths):
+        batch.append(document["text"])
+        if sampled_documents + len(batch) >= args.max_documents:
+            flush()
+            break
+        if len(batch) >= args.batch_size:
+            flush()
+    else:
+        flush()
+
+    if sampled_documents == 0 or sampled_characters == 0:
+        raise RuntimeError("Corpus sample contained no usable text")
+    content_tokens = sampled_tokens - sampled_documents
+    content_tokens_per_character = content_tokens / sampled_characters
+    result: dict[str, Any] = {
+        "tokenizer": str(Path(args.tokenizer_dir).resolve()),
+        "sampled_documents": sampled_documents,
+        "sampled_characters": sampled_characters,
+        "sampled_tokens_including_eos": sampled_tokens,
+        "content_tokens_per_character": content_tokens_per_character,
+        "characters_per_content_token": sampled_characters / content_tokens,
+    }
+    if args.prepare_stats is not None:
+        stats_path = Path(args.prepare_stats)
+        stats = json.loads(stats_path.read_text(encoding="utf-8"))
+        documents, characters = accepted_counts(stats)
+        result.update(
+            prepare_stats=str(stats_path.resolve()),
+            accepted_documents=documents,
+            accepted_characters=characters,
+            estimated_total_tokens=round(
+                characters * content_tokens_per_character + documents
+            ),
+        )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/evaluate.py b/scripts/evaluate.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed022a9042eaa5a61148900987f52e6fcf8d376b
--- /dev/null
+++ b/scripts/evaluate.py
@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import torch
+from transformers import AutoTokenizer, LlamaForCausalLM
+
+from kawk50m.binary_dataset import PackedTokenDataset
+from kawk50m.cli import configure_utf8_stdio
+
+
+DEFAULT_PROMPTS = [
+    "대한민국의 수도는",
+    "오늘 아침에 일어나서",
+    "인공지능 언어 모델은",
+    "비가 내리는 날에는",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Measure validation loss and generate Korean continuations."
+    )
+    parser.add_argument(
+        "--checkpoint",
+        required=True,
+        help="A checkpoint directory containing model/ and tokenizer/.",
+    )
+    parser.add_argument(
+        "--validation-bin", default="data/tokenized/validation.bin"
+    )
+    parser.add_argument(
+        "--tokenizer-dir",
+        default=None,
+        help="Override the tokenizer stored inside the checkpoint.",
+    )
+    parser.add_argument("--sequence-length", type=int, default=1024)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--eval-batches", type=int, default=50)
+    parser.add_argument("--max-new-tokens", type=int, default=80)
+    parser.add_argument("--temperature", type=float, default=0.8)
+    parser.add_argument("--top-k", type=int, default=0)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--repetition-penalty", type=float, default=1.05)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--prompt", action="append", default=None)
+    parser.add_argument("--cpu", action="store_true")
+    return parser.parse_args()
+
+
+@torch.no_grad()
+def validation_loss(
+    model: Any,
+    dataset: PackedTokenDataset,
+    *,
+    batches: int,
+    batch_size: int,
+    device: torch.device,
+    use_bf16: bool,
+) -> float:
+    total = 0.0
+    model.eval()
+    for batch_index in range(batches):
+        inputs, labels = dataset.evaluation_batch(
+            batch_index=batch_index,
+            batch_size=batch_size,
+            rank=0,
+            world_size=1,
+            device=device,
+        )
+        with torch.autocast(
+            device_type=device.type,
+            dtype=torch.bfloat16,
+            enabled=use_bf16,
+        ):
+            total += model(input_ids=inputs, labels=labels).loss.item()
+    return total / batches
+
+
+@torch.no_grad()
+def generate_samples(
+    model: Any,
+    tokenizer: Any,
+    prompts: list[str],
+    *,
+    device: torch.device,
+    max_new_tokens: int,
+    temperature: float,
+    top_k: int,
+    top_p: float,
+    repetition_penalty: float,
+) -> list[dict[str, str]]:
+    rows = []
+    do_sample = temperature > 0
+    for prompt in prompts:
+        encoded = tokenizer(prompt, return_tensors="pt", add_special_tokens=True)
+        input_ids = encoded["input_ids"].to(device)
+        available = model.config.max_position_embeddings - input_ids.shape[1]
+        new_token_limit = min(max_new_tokens, max(available, 1))
+        generation_kwargs: dict[str, Any] = {
+            "input_ids": input_ids,
+            "max_new_tokens": new_token_limit,
+            "do_sample": do_sample,
+            "repetition_penalty": repetition_penalty,
+            "pad_token_id": tokenizer.pad_token_id,
+            "eos_token_id": tokenizer.eos_token_id,
+        }
+        if do_sample:
+            generation_kwargs.update(
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+            )
+        generated = model.generate(**generation_kwargs)
+        continuation_ids = generated[0, input_ids.shape[1] :]
+        continuation = tokenizer.decode(
+            continuation_ids,
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=False,
+        )
+        rows.append(
+            {
+                "prompt": prompt,
+                "continuation": continuation,
+                "full_text": prompt + continuation,
+            }
+        )
+    return rows
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    checkpoint = Path(args.checkpoint)
+    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
+    tokenizer_dir = Path(args.tokenizer_dir) if args.tokenizer_dir else (
+        checkpoint / "tokenizer"
+        if (checkpoint / "tokenizer").is_dir()
+        else checkpoint
+    )
+    if args.cpu:
+        device = torch.device("cpu")
+    elif torch.cuda.is_available():
+        device = torch.device("cuda")
+    else:
+        device = torch.device("cpu")
+    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
+    torch.manual_seed(args.seed)
+    if device.type == "cuda":
+        torch.cuda.manual_seed_all(args.seed)
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer_dir, use_fast=False, legacy=True
+    )
+    model = LlamaForCausalLM.from_pretrained(model_dir)
+    model.to(device)
+    dataset = PackedTokenDataset(args.validation_bin, args.sequence_length)
+    loss = validation_loss(
+        model,
+        dataset,
+        batches=args.eval_batches,
+        batch_size=args.batch_size,
+        device=device,
+        use_bf16=use_bf16,
+    )
+    samples = generate_samples(
+        model,
+        tokenizer,
+        args.prompt or DEFAULT_PROMPTS,
+        device=device,
+        max_new_tokens=args.max_new_tokens,
+        temperature=args.temperature,
+        top_k=args.top_k,
+        top_p=args.top_p,
+        repetition_penalty=args.repetition_penalty,
+    )
+    result = {
+        "checkpoint": str(checkpoint.resolve()),
+        "tokenizer": str(tokenizer_dir.resolve()),
+        "validation_loss": loss,
+        "validation_perplexity": math.exp(min(loss, 20.0)),
+        "evaluated_tokens": (
+            args.eval_batches * args.batch_size * args.sequence_length
+        ),
+        "samples": samples,
+        "note": "This is a base-model continuation evaluation, not instruction QA.",
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/evaluate_position_buckets.py b/scripts/evaluate_position_buckets.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f571fd49bb82d2cf78e22a66fbbe0ec8217df2a
--- /dev/null
+++ b/scripts/evaluate_position_buckets.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from transformers import LlamaForCausalLM
+
+from kawk50m.binary_dataset import PackedTokenDataset
+from kawk50m.cli import configure_utf8_stdio
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Measure causal-LM loss by position on packed Korean text."
+    )
+    parser.add_argument("--checkpoint", required=True)
+    parser.add_argument("--validation-bin", required=True)
+    parser.add_argument("--sequence-length", type=int, default=5120)
+    parser.add_argument("--bucket-size", type=int, default=1024)
+    parser.add_argument("--batches", type=int, default=10)
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--cpu", action="store_true")
+    return parser.parse_args()
+
+
+@torch.no_grad()
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.sequence_length <= 1 or args.bucket_size <= 0:
+        raise ValueError("sequence and bucket lengths must be positive")
+    if args.batches <= 0 or args.batch_size <= 0:
+        raise ValueError("batches and batch size must be positive")
+
+    checkpoint = Path(args.checkpoint)
+    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
+    device = torch.device(
+        "cpu" if args.cpu or not torch.cuda.is_available() else "cuda"
+    )
+    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
+    model = LlamaForCausalLM.from_pretrained(model_dir).to(device).eval()
+    dataset = PackedTokenDataset(args.validation_bin, args.sequence_length)
+    bucket_count = math.ceil((args.sequence_length - 1) / args.bucket_size)
+    nll_sums = [0.0] * bucket_count
+    token_counts = [0] * bucket_count
+
+    for batch_index in range(args.batches):
+        inputs, _ = dataset.evaluation_batch(
+            batch_index=batch_index,
+            batch_size=args.batch_size,
+            rank=0,
+            world_size=1,
+            device=device,
+        )
+        with torch.autocast(
+            device_type=device.type,
+            dtype=torch.bfloat16,
+            enabled=use_bf16,
+        ):
+            logits = model(input_ids=inputs, use_cache=False).logits
+        per_token = F.cross_entropy(
+            logits[:, :-1, :].float().reshape(-1, logits.shape[-1]),
+            inputs[:, 1:].reshape(-1),
+            reduction="none",
+        ).view(inputs.shape[0], -1)
+        for bucket_index in range(bucket_count):
+            start = bucket_index * args.bucket_size
+            stop = min(start + args.bucket_size, per_token.shape[1])
+            if start >= stop:
+                continue
+            values = per_token[:, start:stop]
+            nll_sums[bucket_index] += values.sum().item()
+            token_counts[bucket_index] += values.numel()
+
+    buckets: list[dict[str, Any]] = []
+    for index, (nll, count) in enumerate(zip(nll_sums, token_counts, strict=True)):
+        loss = nll / count
+        buckets.append(
+            {
+                "start_position": index * args.bucket_size + 1,
+                "end_position": min(
+                    (index + 1) * args.bucket_size,
+                    args.sequence_length - 1,
+                ),
+                "tokens": count,
+                "loss": loss,
+                "perplexity": math.exp(min(loss, 20.0)),
+            }
+        )
+    total_nll = sum(nll_sums)
+    total_tokens = sum(token_counts)
+    result = {
+        "checkpoint": str(checkpoint.resolve()),
+        "validation_bin": str(Path(args.validation_bin).resolve()),
+        "sequence_length": args.sequence_length,
+        "bucket_size": args.bucket_size,
+        "evaluated_tokens": total_tokens,
+        "loss": total_nll / total_tokens,
+        "perplexity": math.exp(min(total_nll / total_tokens, 20.0)),
+        "buckets": buckets,
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scripts/evaluate_sft.py b/scripts/evaluate_sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff021c660575e75ac2c745644bc1c389b8e29726
--- /dev/null
+++ b/scripts/evaluate_sft.py
@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+import torch
+from transformers import AutoTokenizer, LlamaForCausalLM
+
+from kawk50m.chat import KOREAN_CHAT_TEMPLATE, format_generation_prompt
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.sft_dataset import SFTPackedDataset
+from scripts.sft import evaluate_loss
+
+
+DEFAULT_PROMPTS = [
+    "대한민국의 수도는 어디인가요? 한 문장으로 답해주세요.",
+    "비가 오는 날 외출할 때 준비할 물건 세 가지를 알려주세요.",
+    "다음 문장을 자연스럽게 고쳐주세요: 나는 어제 학교에 갑니다.",
+    "한국어로 자기소개를 두 문장으로 해주세요.",
+    "사용자가 위험한 요청을 하면 어떻게 대응해야 하나요?",
+]
+HANGUL_RE = re.compile(r"[가-힣]")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Evaluate assistant-only loss and Korean instruction responses."
+    )
+    parser.add_argument("--checkpoint", required=True)
+    parser.add_argument("--tokenizer-dir")
+    parser.add_argument("--validation-prefix", action="append", required=True)
+    parser.add_argument("--sequence-length", type=int, default=5120)
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--eval-batches", type=int, default=20)
+    parser.add_argument("--max-new-tokens", type=int, default=160)
+    parser.add_argument("--temperature", type=float, default=0.3)
+    parser.add_argument("--top-k", type=int, default=40)
+    parser.add_argument("--top-p", type=float, default=0.9)
+    parser.add_argument("--repetition-penalty", type=float, default=1.12)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--prompt", action="append")
+    parser.add_argument("--cpu", action="store_true")
+    return parser.parse_args()
+
+
+def response_metrics(text: str) -> dict[str, float | int]:
+    visible = [character for character in text if not character.isspace()]
+    words = text.split()
+    return {
+        "characters": len(text),
+        "hangul_visible_ratio": len(HANGUL_RE.findall(text)) / max(len(visible), 1),
+        "unique_word_ratio": len(set(words)) / max(len(words), 1),
+    }
+
+
+@torch.no_grad()
+def generate_samples(
+    model: Any,
+    tokenizer: Any,
+    prompts: list[str],
+    *,
+    device: torch.device,
+    max_new_tokens: int,
+    temperature: float,
+    top_k: int,
+    top_p: float,
+    repetition_penalty: float,
+) -> list[dict[str, Any]]:
+    model.eval()
+    rows: list[dict[str, Any]] = []
+    for prompt in prompts:
+        rendered = format_generation_prompt(prompt)
+        encoded = tokenizer(
+            rendered,
+            return_tensors="pt",
+            add_special_tokens=True,
+        )
+        input_ids = encoded["input_ids"].to(device)
+        available = model.config.max_position_embeddings - input_ids.shape[1]
+        generation_kwargs: dict[str, Any] = {
+            "input_ids": input_ids,
+            "max_new_tokens": min(max_new_tokens, max(available, 1)),
+            "do_sample": temperature > 0,
+            "repetition_penalty": repetition_penalty,
+            "pad_token_id": tokenizer.pad_token_id,
+            "eos_token_id": tokenizer.eos_token_id,
+        }
+        if temperature > 0:
+            generation_kwargs.update(
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+            )
+        generated = model.generate(**generation_kwargs)
+        response_ids = generated[0, input_ids.shape[1] :]
+        response = tokenizer.decode(
+            response_ids,
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=False,
+        ).strip()
+        rows.append(
+            {
+                "prompt": prompt,
+                "response": response,
+                "metrics": response_metrics(response),
+            }
+        )
+    return rows
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    checkpoint = Path(args.checkpoint)
+    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
+    tokenizer_dir = (
+        Path(args.tokenizer_dir)
+        if args.tokenizer_dir
+        else checkpoint / "tokenizer"
+        if (checkpoint / "tokenizer").is_dir()
+        else checkpoint
+    )
+    device = (
+        torch.device("cpu")
+        if args.cpu or not torch.cuda.is_available()
+        else torch.device("cuda")
+    )
+    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
+    torch.manual_seed(args.seed)
+    if device.type == "cuda":
+        torch.cuda.manual_seed_all(args.seed)
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.chat_template = KOREAN_CHAT_TEMPLATE
+    model = LlamaForCausalLM.from_pretrained(model_dir).to(device)
+    dataset = SFTPackedDataset(args.validation_prefix, args.sequence_length)
+    loss, supervised_tokens = evaluate_loss(
+        model,
+        dataset,
+        batches=args.eval_batches,
+        batch_size=args.batch_size,
+        device=device,
+        use_bf16=use_bf16,
+    )
+    samples = generate_samples(
+        model,
+        tokenizer,
+        args.prompt or DEFAULT_PROMPTS,
+        device=device,
+        max_new_tokens=args.max_new_tokens,
+        temperature=args.temperature,
+        top_k=args.top_k,
+        top_p=args.top_p,
+        repetition_penalty=args.repetition_penalty,
+    )
+    result = {
+        "checkpoint": str(checkpoint.resolve()),
+        "tokenizer": str(tokenizer_dir.resolve()),
+        "validation_loss": loss,
+        "validation_perplexity": math.exp(min(loss, 20.0)),
+        "evaluated_supervised_tokens": supervised_tokens,
+        "assistant_only_loss": True,
+        "samples": samples,
+        "note": "Korean instruction evaluation; responses are sampled, not facts checked.",
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/evaluate_text.py b/scripts/evaluate_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..8492d96eb06a8723efaee8ae6a7a0a22bc604efd
--- /dev/null
+++ b/scripts/evaluate_text.py
@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, LlamaForCausalLM
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import discover_paths, iter_documents
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Evaluate a checkpoint on raw text with tokenizer-independent "
+            "UTF-8 byte-normalized negative log-likelihood."
+        )
+    )
+    parser.add_argument(
+        "--checkpoint",
+        required=True,
+        help="Checkpoint directory containing model/ and tokenizer/.",
+    )
+    parser.add_argument(
+        "--input",
+        nargs="+",
+        required=True,
+        help="Validation JSONL/TXT files or glob patterns.",
+    )
+    parser.add_argument(
+        "--tokenizer-dir",
+        default=None,
+        help="Override the tokenizer stored inside the checkpoint.",
+    )
+    parser.add_argument("--max-documents", type=int, default=1_000)
+    parser.add_argument("--max-characters-per-document", type=int, default=20_000)
+    parser.add_argument("--context-length", type=int, default=None)
+    parser.add_argument("--cpu", action="store_true")
+    return parser.parse_args()
+
+
+@torch.no_grad()
+def document_nll(
+    model: Any,
+    tokenizer: Any,
+    text: str,
+    *,
+    context_length: int,
+    device: torch.device,
+    use_bf16: bool,
+) -> tuple[float, int]:
+    token_ids = tokenizer.encode(text, add_special_tokens=False)
+    if not token_ids:
+        return 0.0, 0
+    prefix_id = tokenizer.bos_token_id
+    if prefix_id is None:
+        prefix_id = tokenizer.eos_token_id
+    if prefix_id is None:
+        raise ValueError("Tokenizer must define bos_token_id or eos_token_id")
+
+    stream = [prefix_id, *token_ids]
+    total_nll = 0.0
+    predicted_tokens = 0
+    for start in range(0, len(stream) - 1, context_length):
+        stop = min(start + context_length, len(stream) - 1)
+        input_ids = torch.tensor(
+            stream[start:stop], dtype=torch.long, device=device
+        ).unsqueeze(0)
+        targets = torch.tensor(
+            stream[start + 1 : stop + 1], dtype=torch.long, device=device
+        )
+        with torch.autocast(
+            device_type=device.type,
+            dtype=torch.bfloat16,
+            enabled=use_bf16,
+        ):
+            logits = model(input_ids=input_ids, use_cache=False).logits[0]
+        total_nll += F.cross_entropy(
+            logits.float(), targets, reduction="sum"
+        ).item()
+        predicted_tokens += targets.numel()
+    return total_nll, predicted_tokens
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.max_documents <= 0:
+        raise ValueError("--max-documents must be positive")
+    if args.max_characters_per_document <= 0:
+        raise ValueError("--max-characters-per-document must be positive")
+
+    checkpoint = Path(args.checkpoint)
+    model_dir = checkpoint / "model" if (checkpoint / "model").is_dir() else checkpoint
+    tokenizer_dir = Path(args.tokenizer_dir) if args.tokenizer_dir else (
+        checkpoint / "tokenizer"
+        if (checkpoint / "tokenizer").is_dir()
+        else checkpoint
+    )
+    device = torch.device(
+        "cpu" if args.cpu or not torch.cuda.is_available() else "cuda"
+    )
+    use_bf16 = device.type == "cuda" and torch.cuda.is_bf16_supported()
+    tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+    model = LlamaForCausalLM.from_pretrained(model_dir).to(device).eval()
+    context_length = args.context_length or int(
+        model.config.max_position_embeddings
+    )
+    if context_length <= 0:
+        raise ValueError("--context-length must be positive")
+    context_length = min(context_length, int(model.config.max_position_embeddings))
+
+    paths = discover_paths(args.input)
+    if not paths:
+        raise FileNotFoundError("No evaluation inputs were found")
+
+    total_nll = 0.0
+    total_tokens = 0
+    total_characters = 0
+    total_utf8_bytes = 0
+    documents = 0
+    for document in iter_documents(paths):
+        text = document["text"][: args.max_characters_per_document]
+        if not text:
+            continue
+        nll, tokens = document_nll(
+            model,
+            tokenizer,
+            text,
+            context_length=context_length,
+            device=device,
+            use_bf16=use_bf16,
+        )
+        total_nll += nll
+        total_tokens += tokens
+        total_characters += len(text)
+        total_utf8_bytes += len(text.encode("utf-8"))
+        documents += 1
+        if documents >= args.max_documents:
+            break
+
+    if documents == 0 or total_tokens == 0 or total_utf8_bytes == 0:
+        raise RuntimeError("Evaluation set contained no usable text")
+    result = {
+        "checkpoint": str(checkpoint.resolve()),
+        "tokenizer": str(tokenizer_dir.resolve()),
+        "inputs": [str(path) for path in paths],
+        "documents": documents,
+        "characters": total_characters,
+        "utf8_bytes": total_utf8_bytes,
+        "predicted_tokens": total_tokens,
+        "context_length": context_length,
+        "token_nll": total_nll / total_tokens,
+        "token_perplexity": math.exp(min(total_nll / total_tokens, 20.0)),
+        "nats_per_character": total_nll / total_characters,
+        "bits_per_utf8_byte": total_nll / total_utf8_bytes / math.log(2.0),
+        "note": (
+            "Compare bits_per_utf8_byte only when checkpoints are evaluated "
+            "on the exact same ordered raw-text documents."
+        ),
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/model_info.py b/scripts/model_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c32f72a9b3efbfb815f3d9767231f8e2b8d3aeb
--- /dev/null
+++ b/scripts/model_info.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+from transformers import LlamaForCausalLM
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    parser = argparse.ArgumentParser(description="Inspect the configured model size.")
+    parser.add_argument("--config", default="configs/model_50m.yaml")
+    args = parser.parse_args()
+
+    config, expected = build_llama_config(load_yaml(args.config))
+    model = LlamaForCausalLM(config)
+    unique_parameters = count_unique_parameters(model)
+    embedding_parameters = config.vocab_size * config.hidden_size
+    result = {
+        "parameters": unique_parameters,
+        "parameters_millions": round(unique_parameters / 1_000_000, 6),
+        "embedding_parameters": embedding_parameters,
+        "transformer_and_norm_parameters": unique_parameters - embedding_parameters,
+        "layers": config.num_hidden_layers,
+        "hidden_size": config.hidden_size,
+        "vocab_size": config.vocab_size,
+        "attention_heads": config.num_attention_heads,
+        "kv_heads": config.num_key_value_heads,
+        "context_length": config.max_position_embeddings,
+        "expected_parameters": expected,
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    if expected is not None and unique_parameters != expected:
+        raise RuntimeError(
+            f"Parameter count mismatch: expected={expected}, actual={unique_parameters}"
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/preflight.py b/scripts/preflight.py
new file mode 100644
index 0000000000000000000000000000000000000000..163b57266d9cc7ce7e786757ca3c5e435766e0a0
--- /dev/null
+++ b/scripts/preflight.py
@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import argparse
+import glob
+import importlib.util
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.config import build_llama_config, load_yaml
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Validate model, tokenizer, token binaries, and GPU before training."
+    )
+    parser.add_argument("--config", default="configs/pretrain_5b_5090.yaml")
+    return parser.parse_args()
+
+
+def binary_info(
+    path_value: str | list[str],
+    sequence_length: int,
+) -> dict[str, Any]:
+    values = [path_value] if isinstance(path_value, str) else path_value
+    paths: set[Path] = set()
+    for value in values:
+        matches = [Path(item) for item in glob.glob(value)]
+        if matches:
+            paths.update(item.resolve() for item in matches if item.is_file())
+        else:
+            candidate = Path(value)
+            if candidate.is_file():
+                paths.add(candidate.resolve())
+    ordered_paths = sorted(paths)
+    if not ordered_paths:
+        return {"path": path_value, "exists": False}
+    byte_sizes = [path.stat().st_size for path in ordered_paths]
+    byte_size = sum(byte_sizes)
+    token_count = sum(
+        size // np.dtype(np.uint16).itemsize for size in byte_sizes
+    )
+    sequences = sum(
+        max(
+            0,
+            (size // np.dtype(np.uint16).itemsize - 1) // sequence_length,
+        )
+        for size in byte_sizes
+    )
+    return {
+        "path": path_value,
+        "files": [str(path) for path in ordered_paths],
+        "file_count": len(ordered_paths),
+        "exists": True,
+        "bytes": byte_size,
+        "tokens": token_count,
+        "sequences": sequences,
+        "even_byte_size": all(size % 2 == 0 for size in byte_sizes),
+    }
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    full_config = load_yaml(args.config)
+    data = full_config.get("data")
+    training = full_config.get("training")
+    if not isinstance(data, dict) or not isinstance(training, dict):
+        raise ValueError("Training YAML requires data and training mappings")
+
+    sequence_length = int(data["sequence_length"])
+    train_paths = data.get("train_bins", data.get("train_bin"))
+    if train_paths is None:
+        raise ValueError("data requires train_bin or train_bins")
+    train_info = binary_info(train_paths, sequence_length)
+    validation_info = binary_info(data["validation_bin"], sequence_length)
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    tokenizer_path = Path(full_config["tokenizer_dir"])
+    tokenizer_info: dict[str, Any] = {
+        "path": str(tokenizer_path),
+        "exists": tokenizer_path.is_dir(),
+    }
+    tokenizer = None
+    if tokenizer_path.is_dir():
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(
+                tokenizer_path, use_fast=False, legacy=True
+            )
+            tokenizer_info["vocab_size"] = len(tokenizer)
+            tokenizer_info["special_token_ids"] = {
+                "bos": tokenizer.bos_token_id,
+                "eos": tokenizer.eos_token_id,
+                "pad": tokenizer.pad_token_id,
+                "unk": tokenizer.unk_token_id,
+            }
+        except Exception as error:
+            errors.append(f"Tokenizer cannot be loaded: {error}")
+    else:
+        errors.append(f"Missing tokenizer directory: {tokenizer_path}")
+
+    model_config, expected_parameters = build_llama_config(
+        load_yaml(full_config["model_config"]),
+        tokenizer_vocab_size=len(tokenizer) if tokenizer is not None else None,
+    )
+    if sequence_length > model_config.max_position_embeddings:
+        errors.append("sequence_length exceeds model context length")
+
+    for split, info in (("train", train_info), ("validation", validation_info)):
+        if not info["exists"]:
+            errors.append(f"Missing {split} token binary: {info['path']}")
+        elif not info["even_byte_size"]:
+            errors.append(f"{split} binary size is not valid uint16")
+        elif info["sequences"] == 0:
+            errors.append(f"{split} binary does not contain one full sequence")
+
+    batch_size = int(training["per_device_batch_size"])
+    accumulation = int(training["gradient_accumulation_steps"])
+    world_size = int(training.get("world_size", 1))
+    tokens_per_step = sequence_length * batch_size * accumulation * world_size
+    max_steps_value = training.get("max_steps")
+    if max_steps_value is None:
+        max_tokens = int(training["max_tokens"])
+        max_steps = math.ceil(max_tokens / tokens_per_step)
+    else:
+        max_steps = int(max_steps_value)
+        max_tokens = max_steps * tokens_per_step
+    if train_info.get("exists") and train_info.get("tokens", 0) < max_tokens:
+        warnings.append(
+            "The train binary is smaller than the training token budget; "
+            "the deterministic sampler will start another pass over the data."
+        )
+
+    gpu_info: dict[str, Any] = {
+        "available": torch.cuda.is_available(),
+        "bf16_supported": (
+            torch.cuda.is_available() and torch.cuda.is_bf16_supported()
+        ),
+        "triton_available": importlib.util.find_spec("triton") is not None,
+    }
+    if torch.cuda.is_available():
+        properties = torch.cuda.get_device_properties(0)
+        gpu_info.update(
+            {
+                "name": properties.name,
+                "memory_gib": properties.total_memory / 1024**3,
+            }
+        )
+        if "5090" not in properties.name:
+            warnings.append(
+                f"Expected an RTX 5090 configuration, detected {properties.name}."
+            )
+    else:
+        warnings.append("No CUDA GPU is visible in this preflight environment.")
+    if torch.cuda.is_available() and not gpu_info["bf16_supported"]:
+        errors.append("The detected CUDA GPU does not support BF16")
+    if not gpu_info["triton_available"]:
+        warnings.append("Triton is unavailable; torch.compile will fall back to eager.")
+
+    result = {
+        "ok": not errors,
+        "config": str(Path(args.config).resolve()),
+        "model": {
+            "expected_parameters": expected_parameters,
+            "vocab_size": model_config.vocab_size,
+            "layers": model_config.num_hidden_layers,
+            "context_length": model_config.max_position_embeddings,
+        },
+        "tokenizer": tokenizer_info,
+        "data": {"train": train_info, "validation": validation_info},
+        "training": {
+            "per_device_batch_size": batch_size,
+            "gradient_accumulation_steps": accumulation,
+            "tokens_per_optimizer_step": tokens_per_step,
+            "max_steps": max_steps,
+            "planned_tokens": max_steps * tokens_per_step,
+        },
+        "gpu": gpu_info,
+        "warnings": warnings,
+        "errors": errors,
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/preflight_sft.py b/scripts/preflight_sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..9734a8b6eb7d8e2131cd41b451a3344b59ba994f
--- /dev/null
+++ b/scripts/preflight_sft.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+
+import torch
+from transformers import AutoTokenizer
+
+from kawk50m.config import build_llama_config, load_yaml
+from kawk50m.sft_dataset import SFTPackedDataset
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Validate an SFT run before GPU use.")
+    parser.add_argument("--config", required=True)
+    parser.add_argument("--init-from", required=True)
+    args = parser.parse_args()
+
+    config = load_yaml(args.config)
+    data = config["data"]
+    training = config["training"]
+    tokenizer = AutoTokenizer.from_pretrained(
+        config["tokenizer_dir"], use_fast=False, legacy=True
+    )
+    model_config, expected_parameters = build_llama_config(
+        load_yaml(config["model_config"]),
+        tokenizer_vocab_size=len(tokenizer),
+    )
+    sequence_length = int(data["sequence_length"])
+    train = SFTPackedDataset(data["train_prefixes"], sequence_length)
+    validation = SFTPackedDataset(data["validation_prefixes"], sequence_length)
+    batch_size = int(training["per_device_batch_size"])
+    accumulation = int(training["gradient_accumulation_steps"])
+    epochs = float(training["epochs"])
+    sequences_per_step = batch_size * accumulation
+    max_steps = math.ceil(len(train) * epochs / sequences_per_step)
+    init_path = Path(args.init_from)
+    errors: list[str] = []
+    if not (init_path / "model" / "model.safetensors").is_file():
+        errors.append("Initial checkpoint model.safetensors is missing")
+    if sequence_length > model_config.max_position_embeddings:
+        errors.append("SFT sequence length exceeds model context length")
+    result = {
+        "tokenizer_vocab_size": len(tokenizer),
+        "expected_parameters": expected_parameters,
+        "sequence_length": sequence_length,
+        "train_sequences": len(train),
+        "validation_sequences": len(validation),
+        "epochs": epochs,
+        "sequences_per_step": sequences_per_step,
+        "max_steps": max_steps,
+        "planned_capacity_tokens": max_steps * sequences_per_step * sequence_length,
+        "init_from": str(init_path.resolve()),
+        "gpu": {
+            "available": torch.cuda.is_available(),
+            "bf16_supported": (
+                torch.cuda.is_bf16_supported() if torch.cuda.is_available() else False
+            ),
+            "name": torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
+        },
+        "errors": errors,
+    }
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/prepare_corpus.py b/scripts/prepare_corpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..61f613d9baee25cc810457bb4b7114198dd1c86a
--- /dev/null
+++ b/scripts/prepare_corpus.py
@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+from collections import Counter
+from collections import deque
+from concurrent.futures import ProcessPoolExecutor
+from collections.abc import Iterable, Iterator
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from tqdm import tqdm
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import ShardedJsonlWriter, discover_paths, iter_documents
+from kawk50m.text import (
+    FilterConfig,
+    canonical_hash,
+    measure_text,
+    near_duplicate_signature,
+    normalize_text,
+    quality_score,
+    rejection_reason,
+    split_for_hash,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Clean, quality-filter, exactly/approximately deduplicate, "
+            "and split Korean documents."
+        )
+    )
+    parser.add_argument(
+        "--input",
+        nargs="+",
+        required=True,
+        help="Input files, directories, or glob patterns (.jsonl/.txt, optionally .gz).",
+    )
+    parser.add_argument("--output-dir", default="data/clean")
+    parser.add_argument("--text-field", default="text")
+    parser.add_argument("--txt-mode", choices=("line", "document"), default="line")
+    parser.add_argument("--documents-per-shard", type=int, default=50_000)
+    parser.add_argument("--validation-ratio", type=float, default=0.002)
+    parser.add_argument("--test-ratio", type=float, default=0.001)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=1,
+        help="Process normalization/filtering/hash batches in parallel.",
+    )
+    parser.add_argument(
+        "--worker-batch-size",
+        type=int,
+        default=64,
+        help="Documents submitted to each filtering worker at once.",
+    )
+
+    parser.add_argument("--min-chars", type=int, default=300)
+    parser.add_argument("--max-chars", type=int, default=100_000)
+    parser.add_argument("--min-hangul-chars", type=int, default=50)
+    parser.add_argument("--min-hangul-ratio", type=float, default=0.70)
+    parser.add_argument("--min-hangul-visible-ratio", type=float, default=0.55)
+    parser.add_argument("--max-digit-ratio", type=float, default=0.08)
+    parser.add_argument("--max-symbol-ratio", type=float, default=0.15)
+    parser.add_argument("--max-url-per-word", type=float, default=0.01)
+    parser.add_argument("--min-unique-line-ratio", type=float, default=0.70)
+    parser.add_argument("--min-unique-word-ratio", type=float, default=0.20)
+    parser.add_argument("--max-short-line-ratio", type=float, default=0.50)
+    parser.add_argument("--max-list-line-ratio", type=float, default=0.25)
+    parser.add_argument("--max-table-line-ratio", type=float, default=0.10)
+    parser.add_argument(
+        "--max-boilerplate-hits-per-1k", type=float, default=1.5
+    )
+    parser.add_argument("--max-repeated-character-run", type=int, default=20)
+    parser.add_argument("--max-code-line-ratio", type=float, default=0.25)
+    parser.add_argument("--max-code-math-char-ratio", type=float, default=0.15)
+    parser.add_argument("--min-quality-score", type=float, default=0.70)
+    parser.add_argument(
+        "--disable-near-dedupe",
+        action="store_true",
+        help="Disable bottom-k paragraph/chunk near-duplicate sketches.",
+    )
+    parser.add_argument(
+        "--keep-html", action="store_true", help="Do not remove residual HTML tags."
+    )
+    parser.add_argument(
+        "--keep-pii",
+        action="store_true",
+        help="Do not replace email, phone, and resident-registration patterns.",
+    )
+    return parser.parse_args()
+
+
+def process_document(
+    document: dict[str, Any],
+    filter_config: FilterConfig,
+) -> tuple[dict[str, Any], str, str | None, str | None, str | None, float]:
+    text = normalize_text(
+        document["text"],
+        strip_html=filter_config.strip_html,
+        mask_pii=filter_config.mask_pii,
+    )
+    metrics = measure_text(text)
+    reason = rejection_reason(text, filter_config, metrics=metrics)
+    document_hash = canonical_hash(text) if reason is None else None
+    near_signature = (
+        near_duplicate_signature(text) if reason is None else None
+    )
+    score = quality_score(metrics, filter_config)
+    return document, text, reason, document_hash, near_signature, score
+
+
+def process_batch(
+    documents: list[dict[str, Any]],
+    filter_config: FilterConfig,
+) -> list[
+    tuple[dict[str, Any], str, str | None, str | None, str | None, float]
+]:
+    return [process_document(document, filter_config) for document in documents]
+
+
+def document_batches(
+    documents: Iterable[dict[str, Any]],
+    *,
+    batch_size: int,
+    limit: int | None,
+) -> Iterator[list[dict[str, Any]]]:
+    batch: list[dict[str, Any]] = []
+    seen = 0
+    for document in documents:
+        if limit is not None and seen >= limit:
+            break
+        batch.append(document)
+        seen += 1
+        if len(batch) >= batch_size:
+            yield batch
+            batch = []
+    if batch:
+        yield batch
+
+
+def processed_documents(
+    documents: Iterable[dict[str, Any]],
+    *,
+    filter_config: FilterConfig,
+    workers: int,
+    batch_size: int,
+    limit: int | None,
+) -> Iterator[
+    tuple[dict[str, Any], str, str | None, str | None, str | None, float]
+]:
+    batches = document_batches(documents, batch_size=batch_size, limit=limit)
+    if workers == 1:
+        for batch in batches:
+            yield from process_batch(batch, filter_config)
+        return
+
+    max_pending = workers * 2
+    pending: deque[Any] = deque()
+    with ProcessPoolExecutor(max_workers=workers) as executor:
+        for batch in batches:
+            pending.append(executor.submit(process_batch, batch, filter_config))
+            if len(pending) >= max_pending:
+                yield from pending.popleft().result()
+        while pending:
+            yield from pending.popleft().result()
+
+
+def ensure_safe_output(output_dir: Path) -> None:
+    existing = [
+        *output_dir.glob("train-*.jsonl"),
+        *output_dir.glob("validation-*.jsonl"),
+        *output_dir.glob("test-*.jsonl"),
+    ]
+    if existing:
+        names = ", ".join(path.name for path in existing[:3])
+        raise FileExistsError(
+            f"{output_dir} already contains generated shards ({names}). "
+            "Choose a new output directory to avoid overwriting data."
+        )
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    paths = discover_paths(args.input)
+    if not paths:
+        raise FileNotFoundError("No supported input files were found")
+    if args.documents_per_shard <= 0:
+        raise ValueError("--documents-per-shard must be positive")
+    if args.workers <= 0:
+        raise ValueError("--workers must be positive")
+    if args.worker_batch_size <= 0:
+        raise ValueError("--worker-batch-size must be positive")
+
+    filter_config = FilterConfig(
+        min_chars=args.min_chars,
+        max_chars=args.max_chars,
+        min_hangul_chars=args.min_hangul_chars,
+        min_hangul_letter_ratio=args.min_hangul_ratio,
+        min_hangul_visible_ratio=args.min_hangul_visible_ratio,
+        max_digit_ratio=args.max_digit_ratio,
+        max_symbol_ratio=args.max_symbol_ratio,
+        max_url_per_word=args.max_url_per_word,
+        min_unique_line_ratio=args.min_unique_line_ratio,
+        min_unique_word_ratio=args.min_unique_word_ratio,
+        max_short_line_ratio=args.max_short_line_ratio,
+        max_list_line_ratio=args.max_list_line_ratio,
+        max_table_line_ratio=args.max_table_line_ratio,
+        max_boilerplate_hits_per_1k=args.max_boilerplate_hits_per_1k,
+        max_repeated_character_run=args.max_repeated_character_run,
+        max_code_line_ratio=args.max_code_line_ratio,
+        max_code_math_char_ratio=args.max_code_math_char_ratio,
+        min_quality_score=args.min_quality_score,
+        strip_html=not args.keep_html,
+        mask_pii=not args.keep_pii,
+    )
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ensure_safe_output(output_dir)
+
+    dedupe_path = output_dir / "exact_dedupe.sqlite3"
+    if dedupe_path.exists():
+        raise FileExistsError(
+            f"{dedupe_path} already exists. Choose a new output directory."
+        )
+
+    counters: Counter[str] = Counter()
+    writers = {
+        split: ShardedJsonlWriter(
+            output_dir, split, documents_per_shard=args.documents_per_shard
+        )
+        for split in ("train", "validation", "test")
+    }
+
+    connection = sqlite3.connect(dedupe_path)
+    connection.execute("PRAGMA journal_mode=WAL")
+    connection.execute("PRAGMA synchronous=NORMAL")
+    connection.execute("CREATE TABLE hashes (hash TEXT PRIMARY KEY)")
+    if not args.disable_near_dedupe:
+        connection.execute(
+            "CREATE TABLE near_signatures (signature TEXT PRIMARY KEY)"
+        )
+
+    try:
+        documents = iter_documents(
+            paths, text_field=args.text_field, txt_mode=args.txt_mode
+        )
+        processed = processed_documents(
+            documents,
+            filter_config=filter_config,
+            workers=args.workers,
+            batch_size=args.worker_batch_size,
+            limit=args.limit,
+        )
+        for index, (
+            document,
+            text,
+            reason,
+            document_hash,
+            near_signature,
+            score,
+        ) in enumerate(
+            tqdm(processed, total=args.limit, unit="docs"),
+            start=1,
+        ):
+            counters["seen"] += 1
+            if reason is not None:
+                counters[f"rejected_{reason}"] += 1
+            else:
+                assert document_hash is not None
+                cursor = connection.execute(
+                    "INSERT OR IGNORE INTO hashes(hash) VALUES (?)", (document_hash,)
+                )
+                if cursor.rowcount == 0:
+                    counters["rejected_exact_duplicate"] += 1
+                else:
+                    if not args.disable_near_dedupe:
+                        assert near_signature is not None
+                        near_cursor = connection.execute(
+                            "INSERT OR IGNORE INTO near_signatures(signature) "
+                            "VALUES (?)",
+                            (near_signature,),
+                        )
+                        if near_cursor.rowcount == 0:
+                            counters["rejected_near_duplicate"] += 1
+                            continue
+                    split = split_for_hash(
+                        document_hash,
+                        validation_ratio=args.validation_ratio,
+                        test_ratio=args.test_ratio,
+                        seed=args.seed,
+                    )
+                    output_row = {
+                        "id": document["id"],
+                        "text": text,
+                        "source": document["source"],
+                        "url": document["url"],
+                        "license": document["license"],
+                        "sha256": document_hash,
+                        "quality_score": round(score, 6),
+                    }
+                    writers[split].write(output_row)
+                    counters[f"accepted_{split}"] += 1
+                    counters["accepted_characters"] += len(text)
+                    counters["accepted_quality_score_micros"] += round(
+                        score * 1_000_000
+                    )
+
+            if index % 10_000 == 0:
+                connection.commit()
+        connection.commit()
+    finally:
+        connection.close()
+        for writer in writers.values():
+            writer.close()
+
+    stats = {
+        "inputs": [str(path) for path in paths],
+        "filter": asdict(filter_config),
+        "near_dedupe": {
+            "enabled": not args.disable_near_dedupe,
+            "method": "bottom-k paragraph/chunk sketch",
+        },
+        "split": {
+            "train": 1.0 - args.validation_ratio - args.test_ratio,
+            "validation": args.validation_ratio,
+            "test": args.test_ratio,
+            "seed": args.seed,
+        },
+        "counts": dict(sorted(counters.items())),
+    }
+    stats_path = output_dir / "prepare_stats.json"
+    with stats_path.open("w", encoding="utf-8") as handle:
+        json.dump(stats, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    print(json.dumps(stats["counts"], ensure_ascii=False, indent=2))
+    print(f"Stats: {stats_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/prepare_cpt_mix.py b/scripts/prepare_cpt_mix.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e70444abb4d3ff4bc5b48d91e3552fa06d70f33
--- /dev/null
+++ b/scripts/prepare_cpt_mix.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from kawk50m.cli import configure_utf8_stdio
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Build an exact-size long-context CPT mix with hard links for full "
+            "uint16 shards and a bounded copy only for the final partial shard."
+        )
+    )
+    parser.add_argument("--base-input", nargs="+", required=True)
+    parser.add_argument("--structured-input", nargs="+", required=True)
+    parser.add_argument("--validation-bin", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--base-target-tokens", type=int, default=2_800_000_000)
+    parser.add_argument(
+        "--structured-target-tokens", type=int, default=200_000_000
+    )
+    return parser.parse_args()
+
+
+def discover(values: list[str]) -> list[Path]:
+    paths: set[Path] = set()
+    for value in values:
+        matches = [Path(item) for item in glob.glob(value)]
+        if matches:
+            paths.update(path.resolve() for path in matches if path.is_file())
+        else:
+            candidate = Path(value)
+            if candidate.is_file():
+                paths.add(candidate.resolve())
+    return sorted(paths)
+
+
+def token_count(path: Path) -> int:
+    size = path.stat().st_size
+    if size % np.dtype(np.uint16).itemsize:
+        raise ValueError(f"Not a uint16 binary: {path}")
+    return size // np.dtype(np.uint16).itemsize
+
+
+def copy_prefix(source: Path, destination: Path, tokens: int) -> None:
+    remaining = tokens * np.dtype(np.uint16).itemsize
+    with source.open("rb") as input_handle, destination.open("xb") as output_handle:
+        while remaining:
+            block = input_handle.read(min(remaining, 16 * 1024 * 1024))
+            if not block:
+                raise EOFError(f"{source} ended before {tokens:,} tokens")
+            output_handle.write(block)
+            remaining -= len(block)
+
+
+def select_shards(
+    *,
+    sources: list[Path],
+    destination_dir: Path,
+    target_tokens: int,
+) -> dict[str, Any]:
+    if target_tokens <= 0:
+        raise ValueError("Target token count must be positive")
+    destination_dir.mkdir()
+    selected: list[dict[str, Any]] = []
+    written = 0
+    for index, source in enumerate(sources):
+        available = token_count(source)
+        remaining = target_tokens - written
+        if remaining <= 0:
+            break
+        take = min(available, remaining)
+        destination = destination_dir / f"{index:05d}-{source.name}"
+        if take == available:
+            os.link(source, destination)
+            mode = "hardlink"
+        else:
+            destination = destination.with_name(destination.stem + "-partial.bin")
+            copy_prefix(source, destination, take)
+            mode = "prefix-copy"
+        selected.append(
+            {
+                "source": str(source),
+                "output": str(destination),
+                "source_tokens": available,
+                "tokens": take,
+                "mode": mode,
+            }
+        )
+        written += take
+    if written != target_tokens:
+        raise RuntimeError(
+            f"Only {written:,} tokens were available for target {target_tokens:,}"
+        )
+    return {"tokens": written, "files": selected}
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    if output_dir.exists():
+        raise FileExistsError(f"Refusing to overwrite {output_dir}")
+    base_sources = discover(args.base_input)
+    structured_sources = discover(args.structured_input)
+    validation_source = Path(args.validation_bin).resolve()
+    if not base_sources:
+        raise FileNotFoundError("No base token shards were found")
+    if not structured_sources:
+        raise FileNotFoundError("No structured token shards were found")
+    if not validation_source.is_file():
+        raise FileNotFoundError(validation_source)
+
+    output_dir.mkdir(parents=True)
+    try:
+        base = select_shards(
+            sources=base_sources,
+            destination_dir=output_dir / "base",
+            target_tokens=args.base_target_tokens,
+        )
+        structured = select_shards(
+            sources=structured_sources,
+            destination_dir=output_dir / "structured",
+            target_tokens=args.structured_target_tokens,
+        )
+        validation_destination = output_dir / "validation.bin"
+        os.link(validation_source, validation_destination)
+        manifest = {
+            "dtype": "uint16",
+            "base": base,
+            "structured": structured,
+            "validation": {
+                "source": str(validation_source),
+                "output": str(validation_destination),
+                "tokens": token_count(validation_destination),
+                "mode": "hardlink",
+            },
+            "total_train_tokens": base["tokens"] + structured["tokens"],
+        }
+        (output_dir / "manifest.json").write_text(
+            json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        print(json.dumps(manifest, ensure_ascii=False, indent=2))
+    except BaseException:
+        shutil.rmtree(output_dir)
+        raise
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/prepare_sft.py b/scripts/prepare_sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..d237d77f40d3257e2f56c11b5c14f2009bbfe721
--- /dev/null
+++ b/scripts/prepare_sft.py
@@ -0,0 +1,432 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from datasets import load_dataset
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+from kawk50m.chat import ROLE_HEADERS, build_assistant_examples, parse_chatml
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.text import FilterConfig, measure_text, normalize_text, rejection_reason
+
+
+CODE_FENCE_RE = re.compile(r"```|~~~")
+LATEX_RE = re.compile(
+    r"\$\$|\\(?:begin|end|frac|dfrac|tfrac|sum|prod|sqrt|text|boxed)\b"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Stream a pinned Korean ChatML source and create packed SFT records "
+            "whose loss mask supervises assistant responses only."
+        )
+    )
+    parser.add_argument("--dataset", required=True)
+    parser.add_argument("--data-file", action="append", default=[])
+    parser.add_argument("--split", default="train")
+    parser.add_argument("--revision", required=True)
+    parser.add_argument("--tokenizer-dir", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--train-tokens", type=int, required=True)
+    parser.add_argument("--validation-tokens", type=int, required=True)
+    parser.add_argument("--sequence-length", type=int, default=5120)
+    parser.add_argument("--validation-permyriad", type=int, default=128)
+    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--allowed-license", action="append", default=[])
+    parser.add_argument("--exclude-source-regex")
+    parser.add_argument("--resume", action="store_true")
+    return parser.parse_args()
+
+
+def sft_filter_config() -> FilterConfig:
+    return FilterConfig(
+        min_chars=30,
+        max_chars=100_000,
+        min_hangul_chars=10,
+        min_hangul_letter_ratio=0.70,
+        min_hangul_visible_ratio=0.45,
+        max_digit_ratio=0.15,
+        max_symbol_ratio=0.20,
+        max_url_per_word=0.01,
+        min_unique_line_ratio=0.50,
+        min_unique_word_ratio=0.10,
+        max_short_line_ratio=1.0,
+        max_list_line_ratio=0.70,
+        max_table_line_ratio=0.20,
+        max_boilerplate_hits_per_1k=3.0,
+        max_repeated_character_run=30,
+        max_code_line_ratio=0.05,
+        max_code_math_char_ratio=0.08,
+        min_quality_score=0.55,
+        strip_html=True,
+        mask_pii=True,
+    )
+
+
+def contains_code_or_math(text: str) -> bool:
+    return bool(CODE_FENCE_RE.search(text) or LATEX_RE.search(text))
+
+
+def atomic_json(path: Path, value: dict[str, Any]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(value, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def validation_assignment(text: str, permyriad: int) -> bool:
+    digest = hashlib.blake2b(text.encode("utf-8"), digest_size=8).digest()
+    value = int.from_bytes(digest, "little") % 10_000
+    return value < permyriad
+
+
+class RecordPacker:
+    def __init__(
+        self,
+        *,
+        prefix: Path,
+        sequence_length: int,
+        target_tokens: int,
+        pad_token_id: int,
+        resume_records: int = 0,
+        resume_nonpad_tokens: int = 0,
+        resume_supervised_tokens: int = 0,
+    ) -> None:
+        self.sequence_length = sequence_length
+        self.target_records = (target_tokens + sequence_length - 1) // sequence_length
+        self.pad_token_id = pad_token_id
+        self.input_path = Path(str(prefix) + ".input_ids.bin")
+        self.mask_path = Path(str(prefix) + ".loss_mask.bin")
+        self.input_path.parent.mkdir(parents=True, exist_ok=True)
+        expected_tokens = resume_records * sequence_length
+        for path, item_size in ((self.input_path, 2), (self.mask_path, 1)):
+            if resume_records and not path.is_file():
+                raise FileNotFoundError(path)
+            if path.exists():
+                with path.open("r+b") as handle:
+                    handle.truncate(expected_tokens * item_size)
+        self.input_handle = self.input_path.open("ab")
+        self.mask_handle = self.mask_path.open("ab")
+        self.records = resume_records
+        self.nonpad_tokens = resume_nonpad_tokens
+        self.supervised_tokens = resume_supervised_tokens
+        self.buffer_ids: list[int] = []
+        self.buffer_mask: list[int] = []
+
+    @property
+    def complete(self) -> bool:
+        return self.records >= self.target_records
+
+    @property
+    def capacity_tokens(self) -> int:
+        return self.records * self.sequence_length
+
+    def add(self, input_ids: list[int], loss_mask: list[int]) -> None:
+        if self.complete:
+            return
+        if len(input_ids) != len(loss_mask) or not input_ids:
+            raise ValueError("Invalid SFT example")
+        if len(input_ids) > self.sequence_length:
+            raise ValueError("SFT example exceeds sequence length")
+        if self.buffer_ids and len(self.buffer_ids) + len(input_ids) > self.sequence_length:
+            self._write_buffer()
+        if self.complete:
+            return
+        self.buffer_ids.extend(input_ids)
+        self.buffer_mask.extend(loss_mask)
+        if len(self.buffer_ids) == self.sequence_length:
+            self._write_buffer()
+
+    def _write_buffer(self) -> None:
+        if not self.buffer_ids or self.complete:
+            return
+        used = len(self.buffer_ids)
+        supervised = sum(self.buffer_mask)
+        padding = self.sequence_length - used
+        input_array = np.asarray(
+            self.buffer_ids + [self.pad_token_id] * padding,
+            dtype=np.uint16,
+        )
+        mask_array = np.asarray(
+            self.buffer_mask + [0] * padding,
+            dtype=np.uint8,
+        )
+        input_array.tofile(self.input_handle)
+        mask_array.tofile(self.mask_handle)
+        self.records += 1
+        self.nonpad_tokens += used
+        self.supervised_tokens += supervised
+        self.buffer_ids.clear()
+        self.buffer_mask.clear()
+
+    def finalize_partial(self) -> None:
+        if not self.complete:
+            self._write_buffer()
+
+    def sync(self) -> None:
+        for handle in (self.input_handle, self.mask_handle):
+            handle.flush()
+            os.fsync(handle.fileno())
+
+    def close(self) -> None:
+        self.sync()
+        self.input_handle.close()
+        self.mask_handle.close()
+
+    def state(self) -> dict[str, int]:
+        return {
+            "target_records": self.target_records,
+            "records": self.records,
+            "capacity_tokens": self.capacity_tokens,
+            "nonpad_tokens": self.nonpad_tokens,
+            "supervised_tokens": self.supervised_tokens,
+        }
+
+
+def normalize_blocks(blocks: list[tuple[str, str]]) -> list[tuple[str, str]]:
+    normalized: list[tuple[str, str]] = []
+    for role, content in blocks:
+        cleaned = normalize_text(content, strip_html=True, mask_pii=True)
+        if cleaned:
+            normalized.append((role, cleaned))
+    return normalized
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    for name in (
+        "train_tokens",
+        "validation_tokens",
+        "sequence_length",
+        "shuffle_buffer",
+        "batch_size",
+    ):
+        if getattr(args, name) <= 0:
+            raise ValueError(f"--{name.replace('_', '-')} must be positive")
+    if not 0 < args.validation_permyriad < 10_000:
+        raise ValueError("--validation-permyriad must be between 1 and 9,999")
+
+    output_dir = Path(args.output_dir)
+    state_path = output_dir / "state.json"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = args.sequence_length
+    if len(tokenizer) > np.iinfo(np.uint16).max:
+        raise ValueError("uint16 requires vocabulary <= 65,535")
+    if tokenizer.pad_token_id is None:
+        raise ValueError("Tokenizer must define pad_token_id")
+
+    expected = {
+        "dataset": args.dataset,
+        "data_files": list(args.data_file),
+        "split": args.split,
+        "revision": args.revision,
+        "tokenizer_vocab_size": len(tokenizer),
+        "sequence_length": args.sequence_length,
+        "train_tokens_requested": args.train_tokens,
+        "validation_tokens_requested": args.validation_tokens,
+        "validation_permyriad": args.validation_permyriad,
+        "shuffle_buffer": args.shuffle_buffer,
+        "seed": args.seed,
+        "allowed_licenses": sorted(value.casefold() for value in args.allowed_license),
+        "exclude_source_regex": args.exclude_source_regex,
+    }
+    if args.resume:
+        if not state_path.is_file():
+            raise FileNotFoundError(state_path)
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+        for key, value in expected.items():
+            if state.get(key) != value:
+                raise ValueError(
+                    f"Resume state mismatch for {key}: "
+                    f"saved={state.get(key)!r}, requested={value!r}"
+                )
+        if state.get("complete"):
+            print(json.dumps(state, ensure_ascii=False, indent=2))
+            return
+        documents_seen = int(state["documents_seen"])
+        counters = Counter({key: int(value) for key, value in state["counts"].items()})
+        train_state = state["train"]
+        validation_state = state["validation"]
+    else:
+        existing = [
+            output_dir / "train.input_ids.bin",
+            output_dir / "train.loss_mask.bin",
+            output_dir / "validation.input_ids.bin",
+            output_dir / "validation.loss_mask.bin",
+        ]
+        if state_path.exists() or any(path.exists() for path in existing):
+            raise FileExistsError(f"{output_dir} contains previous SFT data")
+        documents_seen = 0
+        counters: Counter[str] = Counter()
+        train_state = {}
+        validation_state = {}
+
+    train = RecordPacker(
+        prefix=output_dir / "train",
+        sequence_length=args.sequence_length,
+        target_tokens=args.train_tokens,
+        pad_token_id=int(tokenizer.pad_token_id),
+        resume_records=int(train_state.get("records", 0)),
+        resume_nonpad_tokens=int(train_state.get("nonpad_tokens", 0)),
+        resume_supervised_tokens=int(train_state.get("supervised_tokens", 0)),
+    )
+    validation = RecordPacker(
+        prefix=output_dir / "validation",
+        sequence_length=args.sequence_length,
+        target_tokens=args.validation_tokens,
+        pad_token_id=int(tokenizer.pad_token_id),
+        resume_records=int(validation_state.get("records", 0)),
+        resume_nonpad_tokens=int(validation_state.get("nonpad_tokens", 0)),
+        resume_supervised_tokens=int(validation_state.get("supervised_tokens", 0)),
+    )
+    allowed_licenses = {value.casefold() for value in args.allowed_license}
+    source_pattern = (
+        re.compile(args.exclude_source_regex) if args.exclude_source_regex else None
+    )
+    filter_config = sft_filter_config()
+
+    def state_value(*, complete: bool) -> dict[str, Any]:
+        return {
+            **expected,
+            "tokenizer": str(Path(args.tokenizer_dir).resolve()),
+            "documents_seen": documents_seen,
+            "counts": dict(sorted(counters.items())),
+            "train": train.state(),
+            "validation": validation.state(),
+            "complete": complete,
+        }
+
+    dataset = load_dataset(
+        args.dataset,
+        data_files=args.data_file or None,
+        split=args.split,
+        revision=args.revision,
+        streaming=True,
+    ).shuffle(seed=args.seed, buffer_size=args.shuffle_buffer)
+    if documents_seen:
+        dataset = dataset.skip(documents_seen)
+
+    progress = tqdm(initial=documents_seen, unit="rows")
+    batch: list[dict[str, Any]] = []
+
+    def commit_batch() -> bool:
+        nonlocal documents_seen
+        for row in batch:
+            counters["seen"] += 1
+            license_name = str(row.get("license", "")).casefold()
+            counters[f"license_{license_name or 'missing'}"] += 1
+            if allowed_licenses and license_name not in allowed_licenses:
+                counters["rejected_license"] += 1
+                continue
+            source_name = str(row.get("source_name", ""))
+            if source_pattern and source_pattern.search(source_name):
+                counters["rejected_source"] += 1
+                continue
+            raw_text = row.get("text")
+            if not isinstance(raw_text, str):
+                counters["rejected_missing_text"] += 1
+                continue
+            blocks = normalize_blocks(parse_chatml(raw_text))
+            roles = {role for role, _ in blocks}
+            if "user" not in roles or "assistant" not in roles:
+                counters["rejected_chatml"] += 1
+                continue
+            rendered = "\n\n".join(
+                ROLE_HEADERS[role] + content
+                for role, content in blocks
+                if role in ROLE_HEADERS
+            )
+            if contains_code_or_math(rendered):
+                counters["rejected_explicit_code_or_math"] += 1
+                continue
+            reason = rejection_reason(
+                rendered,
+                filter_config,
+                metrics=measure_text(rendered),
+            )
+            if reason is not None:
+                counters[f"rejected_{reason}"] += 1
+                continue
+            packer = (
+                validation
+                if validation_assignment(raw_text, args.validation_permyriad)
+                else train
+            )
+            if packer.complete:
+                counters["skipped_split_complete"] += 1
+                continue
+            examples = list(
+                build_assistant_examples(
+                    blocks,
+                    tokenizer,
+                    max_length=args.sequence_length,
+                )
+            )
+            if not examples:
+                counters["rejected_no_assistant_example"] += 1
+                continue
+            for input_ids, loss_mask in examples:
+                packer.add(input_ids, loss_mask)
+                counters["examples"] += 1
+                if packer.complete:
+                    break
+            counters["accepted_conversations"] += 1
+
+        documents_seen += len(batch)
+        progress.update(len(batch))
+        batch.clear()
+        train.sync()
+        validation.sync()
+        complete = train.complete and validation.complete
+        atomic_json(state_path, state_value(complete=complete))
+        return complete
+
+    complete = False
+    try:
+        for row in dataset:
+            batch.append(row)
+            if len(batch) >= args.batch_size and commit_batch():
+                complete = True
+                break
+        else:
+            if batch:
+                complete = commit_batch()
+            train.finalize_partial()
+            validation.finalize_partial()
+            complete = train.complete and validation.complete
+    finally:
+        train.close()
+        validation.close()
+        progress.close()
+
+    final_state = state_value(complete=complete)
+    atomic_json(state_path, final_state)
+    print(json.dumps(final_state, ensure_ascii=False, indent=2))
+    if not complete:
+        raise RuntimeError("Dataset ended before both SFT token targets were reached")
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/pretrain.py b/scripts/pretrain.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1d79fc1b5b5960e0700d693f067e5f254783b9e
--- /dev/null
+++ b/scripts/pretrain.py
@@ -0,0 +1,537 @@
+from __future__ import annotations
+
+import argparse
+import contextlib
+import importlib.util
+import json
+import math
+import os
+import random
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel
+from transformers import AutoTokenizer, LlamaForCausalLM
+
+from kawk50m.binary_dataset import PackedTokenDataset
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.checkpoint import (
+    load_training_state,
+    resolve_checkpoint,
+    restore_rng_state,
+    save_checkpoint,
+)
+from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Pretrain KAWK50M with BF16 and resumable checkpoints."
+    )
+    parser.add_argument("--config", default="configs/pretrain_5b.yaml")
+    parser.add_argument(
+        "--resume",
+        default=None,
+        help="Checkpoint directory or 'latest'.",
+    )
+    parser.add_argument(
+        "--init-from",
+        default=None,
+        help=(
+            "Initialize model weights from a checkpoint/model directory while "
+            "resetting optimizer, scheduler, RNG, and step. Use this for CPT "
+            "or context-extension stages."
+        ),
+    )
+    parser.add_argument(
+        "--allow-cpu",
+        action="store_true",
+        help="Allow a slow FP32 CPU run for debugging.",
+    )
+    parser.add_argument(
+        "--no-compile", action="store_true", help="Disable torch.compile."
+    )
+    parser.add_argument(
+        "--stop-after-steps",
+        type=int,
+        default=None,
+        help="Stop after this many optimizer steps in the current invocation and save.",
+    )
+    return parser.parse_args()
+
+
+def setup_distributed(allow_cpu: bool) -> tuple[torch.device, int, int, int]:
+    world_size = int(os.environ.get("WORLD_SIZE", "1"))
+    rank = int(os.environ.get("RANK", "0"))
+    local_rank = int(os.environ.get("LOCAL_RANK", "0"))
+
+    if torch.cuda.is_available():
+        device = torch.device("cuda", local_rank)
+        torch.cuda.set_device(device)
+    elif allow_cpu and world_size == 1:
+        device = torch.device("cpu")
+    else:
+        raise RuntimeError(
+            "CUDA is required for BF16 pretraining. Use --allow-cpu only for debugging."
+        )
+
+    if world_size > 1:
+        if device.type != "cuda":
+            raise RuntimeError("Distributed CPU training is not supported by this script")
+        backend = "nccl" if dist.is_nccl_available() else "gloo"
+        dist.init_process_group(backend=backend)
+    return device, rank, local_rank, world_size
+
+
+def set_seed(seed: int, rank: int) -> None:
+    local_seed = seed + rank
+    random.seed(local_seed)
+    np.random.seed(local_seed)
+    torch.manual_seed(local_seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(local_seed)
+
+
+def cosine_scheduler(
+    optimizer: torch.optim.Optimizer,
+    *,
+    max_steps: int,
+    warmup_ratio: float,
+    min_lr_ratio: float,
+) -> torch.optim.lr_scheduler.LambdaLR:
+    warmup_steps = round(max_steps * warmup_ratio)
+
+    def multiplier(step: int) -> float:
+        if warmup_steps > 0 and step < warmup_steps:
+            return max(step, 1) / warmup_steps
+        progress = (step - warmup_steps) / max(max_steps - warmup_steps, 1)
+        progress = min(max(progress, 0.0), 1.0)
+        cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
+        return min_lr_ratio + (1.0 - min_lr_ratio) * cosine
+
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, multiplier)
+
+
+def create_optimizer(
+    parameters: Any,
+    training: dict[str, Any],
+    *,
+    use_fused: bool,
+) -> torch.optim.AdamW:
+    kwargs = {
+        "lr": float(training["learning_rate"]),
+        "betas": (
+            float(training.get("adam_beta1", 0.9)),
+            float(training.get("adam_beta2", 0.95)),
+        ),
+        "eps": float(training.get("adam_eps", 1.0e-8)),
+        "weight_decay": float(training.get("weight_decay", 0.1)),
+    }
+    if use_fused:
+        try:
+            return torch.optim.AdamW(parameters, fused=True, **kwargs)
+        except (TypeError, RuntimeError):
+            pass
+    return torch.optim.AdamW(parameters, **kwargs)
+
+
+@torch.no_grad()
+def evaluate_loss(
+    model: Any,
+    dataset: PackedTokenDataset,
+    *,
+    batches: int,
+    batch_size: int,
+    rank: int,
+    world_size: int,
+    device: torch.device,
+    use_bf16: bool,
+) -> float:
+    model.eval()
+    total_loss = torch.zeros((), device=device, dtype=torch.float64)
+    total_batches = torch.zeros((), device=device, dtype=torch.float64)
+    for batch_index in range(batches):
+        inputs, labels = dataset.evaluation_batch(
+            batch_index=batch_index,
+            batch_size=batch_size,
+            rank=rank,
+            world_size=world_size,
+            device=device,
+        )
+        with torch.autocast(
+            device_type=device.type,
+            dtype=torch.bfloat16,
+            enabled=use_bf16,
+        ):
+            loss = model(input_ids=inputs, labels=labels, use_cache=False).loss
+        total_loss += loss.detach().double()
+        total_batches += 1
+    if world_size > 1:
+        dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
+        dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
+    model.train()
+    return (total_loss / total_batches).item()
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.resume is not None and args.init_from is not None:
+        raise ValueError("--resume and --init-from are mutually exclusive")
+    full_config = load_yaml(args.config)
+    data_config = full_config.get("data")
+    training = full_config.get("training")
+    if not isinstance(data_config, dict) or not isinstance(training, dict):
+        raise ValueError("Training YAML requires 'data' and 'training' mappings")
+
+    device, rank, local_rank, world_size = setup_distributed(args.allow_cpu)
+    is_main = rank == 0
+    seed = int(training.get("seed", 42))
+    set_seed(seed, rank)
+
+    if device.type == "cuda":
+        torch.set_float32_matmul_precision("high")
+        torch.backends.cuda.matmul.allow_tf32 = True
+    requested_precision = str(training.get("precision", "bf16")).lower()
+    if requested_precision not in {"bf16", "fp32"}:
+        raise ValueError("precision must be bf16 or fp32")
+    use_bf16 = requested_precision == "bf16" and device.type == "cuda"
+    if requested_precision == "bf16" and device.type == "cuda":
+        if not torch.cuda.is_bf16_supported():
+            raise RuntimeError("This GPU does not support BF16")
+    if device.type == "cpu" and requested_precision == "bf16" and is_main:
+        print("CPU debug mode: falling back from BF16 to FP32")
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        full_config["tokenizer_dir"], use_fast=False, legacy=True
+    )
+    model_yaml = load_yaml(full_config["model_config"])
+    model_config, expected_parameters = build_llama_config(
+        model_yaml, tokenizer_vocab_size=len(tokenizer)
+    )
+
+    output_dir = Path(training["output_dir"])
+    resume_path = (
+        resolve_checkpoint(args.resume, output_dir) if args.resume is not None else None
+    )
+    if resume_path is None:
+        prior_checkpoints = list(output_dir.glob("checkpoint-*"))
+        prior_markers = (
+            (output_dir / "latest_checkpoint.txt").exists()
+            or (output_dir / "run_config.json").exists()
+            or bool(prior_checkpoints)
+        )
+        if prior_markers:
+            raise FileExistsError(
+                f"{output_dir} already contains training artifacts. "
+                "Use --resume latest or choose a new training.output_dir."
+            )
+    init_path = Path(args.init_from).resolve() if args.init_from else None
+    if init_path is not None and not init_path.exists():
+        raise FileNotFoundError(init_path)
+
+    if resume_path is None and init_path is None:
+        raw_model = LlamaForCausalLM(model_config)
+    elif resume_path is not None:
+        raw_model = LlamaForCausalLM.from_pretrained(resume_path / "model")
+        for attribute in (
+            "vocab_size",
+            "hidden_size",
+            "intermediate_size",
+            "num_hidden_layers",
+            "num_attention_heads",
+            "num_key_value_heads",
+        ):
+            expected_value = getattr(model_config, attribute)
+            actual_value = getattr(raw_model.config, attribute)
+            if expected_value != actual_value:
+                raise ValueError(
+                    f"Checkpoint model mismatch for {attribute}: "
+                    f"config={expected_value}, checkpoint={actual_value}"
+                )
+    else:
+        assert init_path is not None
+        source_dir = init_path / "model" if (init_path / "model").is_dir() else init_path
+        source_model = LlamaForCausalLM.from_pretrained(source_dir)
+        raw_model = LlamaForCausalLM(model_config)
+        raw_model.load_state_dict(source_model.state_dict(), strict=True)
+        del source_model
+
+    parameter_count = count_unique_parameters(raw_model)
+    if expected_parameters is not None and parameter_count != expected_parameters:
+        raise RuntimeError(
+            f"Expected {expected_parameters} parameters, got {parameter_count}"
+        )
+    raw_model.config.use_cache = False
+    if bool(training.get("gradient_checkpointing", False)):
+        raw_model.gradient_checkpointing_enable()
+    raw_model.to(device)
+
+    sequence_length = int(data_config["sequence_length"])
+    if sequence_length > model_config.max_position_embeddings:
+        raise ValueError("sequence_length exceeds max_position_embeddings")
+    train_paths = data_config.get("train_bins", data_config.get("train_bin"))
+    if train_paths is None:
+        raise ValueError("data requires train_bin or train_bins")
+    train_dataset = PackedTokenDataset(train_paths, sequence_length)
+    training_sample_offset = int(data_config.get("sample_offset", 0))
+    if training_sample_offset < 0:
+        raise ValueError("data.sample_offset must be non-negative")
+    validation_dataset = None
+    if int(training.get("eval_every", 0)) > 0:
+        validation_dataset = PackedTokenDataset(
+            data_config["validation_bin"], sequence_length
+        )
+
+    batch_size = int(training["per_device_batch_size"])
+    gradient_accumulation = int(training["gradient_accumulation_steps"])
+    if batch_size <= 0 or gradient_accumulation <= 0:
+        raise ValueError("batch size and gradient accumulation must be positive")
+    tokens_per_step = (
+        sequence_length * batch_size * gradient_accumulation * world_size
+    )
+    configured_steps = training.get("max_steps")
+    if configured_steps is None:
+        max_tokens = int(training["max_tokens"])
+        max_steps = math.ceil(max_tokens / tokens_per_step)
+    else:
+        max_steps = int(configured_steps)
+    if max_steps <= 0:
+        raise ValueError("max_steps must be positive")
+    if args.stop_after_steps is not None and args.stop_after_steps <= 0:
+        raise ValueError("--stop-after-steps must be positive")
+
+    compile_enabled = bool(training.get("torch_compile", True)) and not args.no_compile
+    if (
+        compile_enabled
+        and device.type == "cuda"
+        and importlib.util.find_spec("triton") is None
+    ):
+        if is_main:
+            print(
+                "torch.compile disabled: no working Triton installation was found. "
+                "Continuing with eager BF16."
+            )
+        compile_enabled = False
+    train_model: Any = raw_model
+    if compile_enabled:
+        train_model = torch.compile(
+            train_model, mode=str(training.get("compile_mode", "default"))
+        )
+    if world_size > 1:
+        train_model = DistributedDataParallel(
+            train_model,
+            device_ids=[local_rank],
+            broadcast_buffers=False,
+            gradient_as_bucket_view=True,
+        )
+
+    optimizer = create_optimizer(
+        train_model.parameters(), training, use_fused=device.type == "cuda"
+    )
+    learning_rate = float(training["learning_rate"])
+    minimum_learning_rate = float(training.get("min_learning_rate", 0.0))
+    scheduler = cosine_scheduler(
+        optimizer,
+        max_steps=max_steps,
+        warmup_ratio=float(training.get("warmup_ratio", 0.02)),
+        min_lr_ratio=minimum_learning_rate / learning_rate,
+    )
+
+    start_step = 0
+    if resume_path is not None:
+        state = load_training_state(resume_path / "trainer_state.pt")
+        if int(state["world_size"]) != world_size:
+            raise ValueError(
+                "Resume requires the same world size: "
+                f"checkpoint={state['world_size']}, current={world_size}"
+            )
+        optimizer.load_state_dict(state["optimizer"])
+        scheduler.load_state_dict(state["scheduler"])
+        restore_rng_state(state["rng"])
+        start_step = int(state["step"])
+        if start_step >= max_steps:
+            raise ValueError(
+                f"Checkpoint step {start_step} already reached max_steps {max_steps}"
+            )
+
+    if is_main:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        run_summary = {
+            "parameters": parameter_count,
+            "device": str(device),
+            "world_size": world_size,
+            "sequence_length": sequence_length,
+            "training_sample_offset": training_sample_offset,
+            "tokens_per_optimizer_step": tokens_per_step,
+            "max_steps": max_steps,
+            "planned_tokens": max_steps * tokens_per_step,
+            "start_step": start_step,
+            "initialized_from": str(init_path) if init_path is not None else None,
+            "precision": "bf16" if use_bf16 else "fp32",
+            "compile": compile_enabled,
+        }
+        print(json.dumps(run_summary, ensure_ascii=False, indent=2))
+        run_config_path = output_dir / "run_config.json"
+        if not run_config_path.exists():
+            with run_config_path.open("w", encoding="utf-8") as handle:
+                json.dump(
+                    {"summary": run_summary, "config": full_config},
+                    handle,
+                    ensure_ascii=False,
+                    indent=2,
+                )
+                handle.write("\n")
+
+    train_model.train()
+    optimizer.zero_grad(set_to_none=True)
+    step = start_step
+    log_every = int(training.get("log_every", 10))
+    eval_every = int(training.get("eval_every", 0))
+    save_every = int(training.get("save_every", 0))
+    max_grad_norm = float(training.get("max_grad_norm", 1.0))
+    interval_start = time.perf_counter()
+    interval_step = step
+    run_stop_step = (
+        min(max_steps, step + args.stop_after_steps)
+        if args.stop_after_steps is not None
+        else max_steps
+    )
+
+    while step < run_stop_step:
+        accumulated_loss = torch.zeros((), device=device)
+        for micro_index in range(gradient_accumulation):
+            micro_step = step * gradient_accumulation + micro_index
+            inputs, labels = train_dataset.training_batch(
+                micro_step=micro_step,
+                batch_size=batch_size,
+                rank=rank,
+                world_size=world_size,
+                seed=seed,
+                sample_offset=training_sample_offset,
+                device=device,
+            )
+            should_sync = micro_index == gradient_accumulation - 1
+            sync_context = (
+                contextlib.nullcontext()
+                if should_sync or world_size == 1
+                else train_model.no_sync()
+            )
+            with sync_context:
+                with torch.autocast(
+                    device_type=device.type,
+                    dtype=torch.bfloat16,
+                    enabled=use_bf16,
+                ):
+                    loss = train_model(
+                        input_ids=inputs, labels=labels, use_cache=False
+                    ).loss
+                (loss / gradient_accumulation).backward()
+            accumulated_loss += loss.detach()
+
+        grad_norm = torch.nn.utils.clip_grad_norm_(
+            train_model.parameters(), max_grad_norm
+        )
+        optimizer.step()
+        scheduler.step()
+        optimizer.zero_grad(set_to_none=True)
+        step += 1
+
+        accumulated_loss /= gradient_accumulation
+        if world_size > 1:
+            dist.all_reduce(accumulated_loss, op=dist.ReduceOp.SUM)
+            accumulated_loss /= world_size
+
+        if log_every > 0 and (step % log_every == 0 or step == 1):
+            if device.type == "cuda":
+                torch.cuda.synchronize(device)
+            elapsed = time.perf_counter() - interval_start
+            processed_tokens = (step - interval_step) * tokens_per_step
+            if is_main:
+                log_row = {
+                    "step": step,
+                    "max_steps": max_steps,
+                    "train_loss": round(accumulated_loss.item(), 6),
+                    "learning_rate": scheduler.get_last_lr()[0],
+                    "grad_norm": float(grad_norm),
+                    "tokens_seen": step * tokens_per_step,
+                    "tokens_per_second": round(processed_tokens / max(elapsed, 1e-9)),
+                }
+                print(json.dumps(log_row, ensure_ascii=False))
+            interval_start = time.perf_counter()
+            interval_step = step
+
+        if eval_every > 0 and step % eval_every == 0:
+            assert validation_dataset is not None
+            validation_loss = evaluate_loss(
+                train_model,
+                validation_dataset,
+                batches=int(training.get("eval_batches", 50)),
+                batch_size=batch_size,
+                rank=rank,
+                world_size=world_size,
+                device=device,
+                use_bf16=use_bf16,
+            )
+            if is_main:
+                print(
+                    json.dumps(
+                        {
+                            "step": step,
+                            "validation_loss": round(validation_loss, 6),
+                            "validation_perplexity": round(
+                                math.exp(min(validation_loss, 20.0)), 4
+                            ),
+                        },
+                        ensure_ascii=False,
+                    )
+                )
+
+        if save_every > 0 and step % save_every == 0:
+            if world_size > 1:
+                dist.barrier()
+            if is_main:
+                checkpoint_path = save_checkpoint(
+                    output_dir=output_dir,
+                    step=step,
+                    model=raw_model,
+                    tokenizer=tokenizer,
+                    optimizer=optimizer,
+                    scheduler=scheduler,
+                    training_config=full_config,
+                    world_size=world_size,
+                )
+                print(f"Saved checkpoint: {checkpoint_path}")
+            if world_size > 1:
+                dist.barrier()
+
+    stopped_early = step < max_steps
+    if bool(training.get("save_final", True)) or stopped_early:
+        if world_size > 1:
+            dist.barrier()
+        if is_main:
+            checkpoint_path = save_checkpoint(
+                output_dir=output_dir,
+                step=step,
+                model=raw_model,
+                tokenizer=tokenizer,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                training_config=full_config,
+                world_size=world_size,
+            )
+            label = "Stop checkpoint" if stopped_early else "Final checkpoint"
+            print(f"{label}: {checkpoint_path}")
+        if world_size > 1:
+            dist.barrier()
+
+    if world_size > 1:
+        dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/sft.py b/scripts/sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..da34316b1202e7107f153c67c10cbe42135e7282
--- /dev/null
+++ b/scripts/sft.py
@@ -0,0 +1,393 @@
+from __future__ import annotations
+
+import argparse
+import contextlib
+import importlib.util
+import json
+import math
+import random
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import AutoTokenizer, LlamaForCausalLM
+
+from kawk50m.chat import KOREAN_CHAT_TEMPLATE
+from kawk50m.checkpoint import (
+    load_training_state,
+    resolve_checkpoint,
+    restore_rng_state,
+    save_checkpoint,
+)
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml
+from kawk50m.sft_dataset import SFTPackedDataset
+from scripts.pretrain import cosine_scheduler, create_optimizer
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Assistant-only supervised fine-tuning for KAWK50M."
+    )
+    parser.add_argument("--config", default="configs/sft_ko_80m_5k_5090.yaml")
+    parser.add_argument("--resume", help="Checkpoint path or 'latest'.")
+    parser.add_argument("--init-from", help="Base checkpoint used for fresh SFT.")
+    parser.add_argument("--no-compile", action="store_true")
+    parser.add_argument("--allow-cpu", action="store_true")
+    parser.add_argument("--stop-after-steps", type=int)
+    return parser.parse_args()
+
+
+def set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+@torch.no_grad()
+def evaluate_loss(
+    model: Any,
+    dataset: SFTPackedDataset,
+    *,
+    batches: int,
+    batch_size: int,
+    device: torch.device,
+    use_bf16: bool,
+) -> tuple[float, int]:
+    model.eval()
+    weighted_loss = 0.0
+    supervised_tokens = 0
+    for batch_index in range(batches):
+        inputs, labels = dataset.evaluation_batch(
+            batch_index=batch_index,
+            batch_size=batch_size,
+            rank=0,
+            world_size=1,
+            device=device,
+        )
+        token_count = int((labels[:, 1:] != -100).sum().item())
+        with torch.autocast(
+            device_type=device.type,
+            dtype=torch.bfloat16,
+            enabled=use_bf16,
+        ):
+            loss = model(input_ids=inputs, labels=labels, use_cache=False).loss
+        weighted_loss += float(loss.item()) * token_count
+        supervised_tokens += token_count
+    model.train()
+    if supervised_tokens == 0:
+        raise RuntimeError("SFT validation has no supervised assistant tokens")
+    return weighted_loss / supervised_tokens, supervised_tokens
+
+
+def checkpoint_model_dir(path: Path) -> Path:
+    return path / "model" if (path / "model").is_dir() else path
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    full_config = load_yaml(args.config)
+    data_config = full_config["data"]
+    training = full_config["training"]
+
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+    elif args.allow_cpu:
+        device = torch.device("cpu")
+    else:
+        raise RuntimeError("CUDA is required; use --allow-cpu only for debugging")
+    requested_precision = str(training.get("precision", "bf16")).casefold()
+    if requested_precision not in {"bf16", "fp32"}:
+        raise ValueError("precision must be bf16 or fp32")
+    use_bf16 = requested_precision == "bf16" and device.type == "cuda"
+    if use_bf16 and not torch.cuda.is_bf16_supported():
+        raise RuntimeError("This GPU does not support BF16")
+
+    seed = int(training.get("seed", 42))
+    set_seed(seed)
+    tokenizer = AutoTokenizer.from_pretrained(
+        full_config["tokenizer_dir"], use_fast=False, legacy=True
+    )
+    tokenizer.chat_template = KOREAN_CHAT_TEMPLATE
+    model_yaml = load_yaml(full_config["model_config"])
+    model_config, expected_parameters = build_llama_config(
+        model_yaml, tokenizer_vocab_size=len(tokenizer)
+    )
+
+    output_dir = Path(training["output_dir"])
+    resume_path = (
+        resolve_checkpoint(args.resume, output_dir) if args.resume else None
+    )
+    if resume_path is None:
+        if (
+            (output_dir / "latest_checkpoint.txt").exists()
+            or (output_dir / "run_config.json").exists()
+            or list(output_dir.glob("checkpoint-*"))
+        ):
+            raise FileExistsError(
+                f"{output_dir} contains SFT artifacts; use --resume latest"
+            )
+    init_path = Path(args.init_from).resolve() if args.init_from else None
+    if resume_path is None and init_path is None:
+        raise ValueError("Fresh SFT requires --init-from")
+
+    if resume_path is not None:
+        raw_model = LlamaForCausalLM.from_pretrained(resume_path / "model")
+    else:
+        assert init_path is not None
+        if not init_path.exists():
+            raise FileNotFoundError(init_path)
+        source_model = LlamaForCausalLM.from_pretrained(
+            checkpoint_model_dir(init_path)
+        )
+        raw_model = LlamaForCausalLM(model_config)
+        raw_model.load_state_dict(source_model.state_dict(), strict=True)
+        del source_model
+
+    for attribute in (
+        "vocab_size",
+        "hidden_size",
+        "intermediate_size",
+        "num_hidden_layers",
+        "num_attention_heads",
+        "num_key_value_heads",
+        "max_position_embeddings",
+    ):
+        if getattr(raw_model.config, attribute) != getattr(model_config, attribute):
+            raise ValueError(f"Checkpoint mismatch for {attribute}")
+    parameter_count = count_unique_parameters(raw_model)
+    if expected_parameters is not None and parameter_count != expected_parameters:
+        raise RuntimeError(
+            f"Expected {expected_parameters} parameters, got {parameter_count}"
+        )
+    raw_model.config.use_cache = False
+    raw_model.to(device)
+
+    sequence_length = int(data_config["sequence_length"])
+    if sequence_length > model_config.max_position_embeddings:
+        raise ValueError("SFT sequence length exceeds model context length")
+    train_dataset = SFTPackedDataset(
+        data_config["train_prefixes"], sequence_length
+    )
+    validation_dataset = SFTPackedDataset(
+        data_config["validation_prefixes"], sequence_length
+    )
+    batch_size = int(training["per_device_batch_size"])
+    gradient_accumulation = int(training["gradient_accumulation_steps"])
+    if batch_size <= 0 or gradient_accumulation <= 0:
+        raise ValueError("Batch size and gradient accumulation must be positive")
+    sequences_per_step = batch_size * gradient_accumulation
+    epochs = float(training.get("epochs", 1.0))
+    if epochs <= 0:
+        raise ValueError("training.epochs must be positive")
+    configured_steps = training.get("max_steps")
+    max_steps = (
+        int(configured_steps)
+        if configured_steps is not None
+        else math.ceil(len(train_dataset) * epochs / sequences_per_step)
+    )
+    if max_steps <= 0:
+        raise ValueError("SFT max_steps must be positive")
+    if args.stop_after_steps is not None and args.stop_after_steps <= 0:
+        raise ValueError("--stop-after-steps must be positive")
+
+    compile_enabled = bool(training.get("torch_compile", True)) and not args.no_compile
+    if (
+        compile_enabled
+        and device.type == "cuda"
+        and importlib.util.find_spec("triton") is None
+    ):
+        print("torch.compile disabled because Triton is unavailable")
+        compile_enabled = False
+    train_model: Any = raw_model
+    if compile_enabled:
+        train_model = torch.compile(
+            train_model, mode=str(training.get("compile_mode", "default"))
+        )
+
+    optimizer = create_optimizer(
+        train_model.parameters(), training, use_fused=device.type == "cuda"
+    )
+    learning_rate = float(training["learning_rate"])
+    minimum_learning_rate = float(training.get("min_learning_rate", 0.0))
+    scheduler = cosine_scheduler(
+        optimizer,
+        max_steps=max_steps,
+        warmup_ratio=float(training.get("warmup_ratio", 0.03)),
+        min_lr_ratio=minimum_learning_rate / learning_rate,
+    )
+    start_step = 0
+    if resume_path is not None:
+        state = load_training_state(resume_path / "trainer_state.pt")
+        optimizer.load_state_dict(state["optimizer"])
+        scheduler.load_state_dict(state["scheduler"])
+        restore_rng_state(state["rng"])
+        start_step = int(state["step"])
+        if start_step >= max_steps:
+            raise ValueError("SFT checkpoint already reached max_steps")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    tokens_per_step = sequence_length * sequences_per_step
+    summary = {
+        "parameters": parameter_count,
+        "device": str(device),
+        "sequence_length": sequence_length,
+        "train_sequences": len(train_dataset),
+        "validation_sequences": len(validation_dataset),
+        "epochs": epochs,
+        "sequences_per_optimizer_step": sequences_per_step,
+        "tokens_per_optimizer_step": tokens_per_step,
+        "max_steps": max_steps,
+        "planned_capacity_tokens": max_steps * tokens_per_step,
+        "start_step": start_step,
+        "initialized_from": str(init_path) if init_path else None,
+        "assistant_only_loss": True,
+        "precision": "bf16" if use_bf16 else "fp32",
+        "compile": compile_enabled,
+    }
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+    run_config_path = output_dir / "run_config.json"
+    if not run_config_path.exists():
+        run_config_path.write_text(
+            json.dumps(
+                {"summary": summary, "config": full_config},
+                ensure_ascii=False,
+                indent=2,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+    train_model.train()
+    optimizer.zero_grad(set_to_none=True)
+    step = start_step
+    log_every = int(training.get("log_every", 10))
+    eval_every = int(training.get("eval_every", 0))
+    save_every = int(training.get("save_every", 0))
+    max_grad_norm = float(training.get("max_grad_norm", 1.0))
+    interval_start = time.perf_counter()
+    interval_step = step
+    run_stop_step = (
+        min(max_steps, step + args.stop_after_steps)
+        if args.stop_after_steps is not None
+        else max_steps
+    )
+
+    while step < run_stop_step:
+        accumulated_loss = torch.zeros((), device=device)
+        supervised_this_step = 0
+        for micro_index in range(gradient_accumulation):
+            micro_step = step * gradient_accumulation + micro_index
+            inputs, labels = train_dataset.training_batch(
+                micro_step=micro_step,
+                batch_size=batch_size,
+                rank=0,
+                world_size=1,
+                seed=seed,
+                device=device,
+            )
+            supervised_this_step += int((labels[:, 1:] != -100).sum().item())
+            with contextlib.nullcontext():
+                with torch.autocast(
+                    device_type=device.type,
+                    dtype=torch.bfloat16,
+                    enabled=use_bf16,
+                ):
+                    loss = train_model(
+                        input_ids=inputs,
+                        labels=labels,
+                        use_cache=False,
+                    ).loss
+                (loss / gradient_accumulation).backward()
+            accumulated_loss += loss.detach()
+
+        grad_norm = torch.nn.utils.clip_grad_norm_(
+            train_model.parameters(), max_grad_norm
+        )
+        optimizer.step()
+        scheduler.step()
+        optimizer.zero_grad(set_to_none=True)
+        step += 1
+        accumulated_loss /= gradient_accumulation
+
+        if log_every > 0 and (step % log_every == 0 or step == 1):
+            if device.type == "cuda":
+                torch.cuda.synchronize(device)
+            elapsed = time.perf_counter() - interval_start
+            processed_tokens = (step - interval_step) * tokens_per_step
+            print(
+                json.dumps(
+                    {
+                        "step": step,
+                        "max_steps": max_steps,
+                        "train_loss": round(float(accumulated_loss.item()), 6),
+                        "learning_rate": scheduler.get_last_lr()[0],
+                        "grad_norm": float(grad_norm),
+                        "supervised_tokens_in_step": supervised_this_step,
+                        "tokens_per_second": round(processed_tokens / max(elapsed, 1e-9)),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            interval_start = time.perf_counter()
+            interval_step = step
+
+        if eval_every > 0 and step % eval_every == 0:
+            validation_loss, supervised_tokens = evaluate_loss(
+                train_model,
+                validation_dataset,
+                batches=int(training.get("eval_batches", 20)),
+                batch_size=batch_size,
+                device=device,
+                use_bf16=use_bf16,
+            )
+            print(
+                json.dumps(
+                    {
+                        "step": step,
+                        "validation_loss": round(validation_loss, 6),
+                        "validation_perplexity": round(
+                            math.exp(min(validation_loss, 20.0)), 4
+                        ),
+                        "validation_supervised_tokens": supervised_tokens,
+                    },
+                    ensure_ascii=False,
+                )
+            )
+
+        if save_every > 0 and step % save_every == 0:
+            checkpoint_path = save_checkpoint(
+                output_dir=output_dir,
+                step=step,
+                model=raw_model,
+                tokenizer=tokenizer,
+                optimizer=optimizer,
+                scheduler=scheduler,
+                training_config=full_config,
+                world_size=1,
+            )
+            print(f"Saved checkpoint: {checkpoint_path}")
+
+    stopped_early = step < max_steps
+    if bool(training.get("save_final", True)) or stopped_early:
+        checkpoint_path = save_checkpoint(
+            output_dir=output_dir,
+            step=step,
+            model=raw_model,
+            tokenizer=tokenizer,
+            optimizer=optimizer,
+            scheduler=scheduler,
+            training_config=full_config,
+            world_size=1,
+        )
+        label = "Stop checkpoint" if stopped_early else "Final checkpoint"
+        print(f"{label}: {checkpoint_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/stream_tokenize_chatml.py b/scripts/stream_tokenize_chatml.py
new file mode 100644
index 0000000000000000000000000000000000000000..82708a53fa408006c42ce5d9f9aad00e46e6caf3
--- /dev/null
+++ b/scripts/stream_tokenize_chatml.py
@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from datasets import load_dataset
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.text import (
+    FilterConfig,
+    measure_text,
+    normalize_text,
+    rejection_reason,
+)
+
+
+CHATML_BLOCK_RE = re.compile(
+    r"<\|im_start\|>\s*(system|user|assistant)\s*\n?(.*?)<\|im_end\|>",
+    re.IGNORECASE | re.DOTALL,
+)
+CODE_FENCE_RE = re.compile(r"```|~~~")
+LATEX_RE = re.compile(
+    r"\$\$|\\(?:begin|end|frac|dfrac|tfrac|sum|prod|sqrt|text|boxed)\b"
+)
+ROLE_LABELS = {
+    "system": "지침",
+    "user": "사용자",
+    "assistant": "도우미",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Stream a pinned Korean ChatML dataset, remove code/math and "
+            "non-Korean-heavy rows, and write resumable uint16 token chunks."
+        )
+    )
+    parser.add_argument("--dataset", required=True)
+    parser.add_argument(
+        "--data-file",
+        action="append",
+        default=[],
+        help=(
+            "Explicit repository data file; repeat for multiple shards. "
+            "Use this to exclude manifest/metadata JSON files."
+        ),
+    )
+    parser.add_argument("--split", default="train")
+    parser.add_argument("--revision", required=True)
+    parser.add_argument("--tokenizer-dir", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--max-output-tokens", type=int, required=True)
+    parser.add_argument("--tokens-per-chunk", type=int, default=50_000_000)
+    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--batch-size", type=int, default=256)
+    parser.add_argument(
+        "--allowed-license",
+        action="append",
+        default=[],
+        help="Accepted per-row license value; repeat for multiple licenses.",
+    )
+    parser.add_argument(
+        "--exclude-source-regex",
+        default=None,
+        help="Reject rows whose source_name matches this regular expression.",
+    )
+    parser.add_argument("--resume", action="store_true")
+    return parser.parse_args()
+
+
+def render_chatml(text: str) -> str | None:
+    blocks = [
+        (role.casefold(), content.strip())
+        for role, content in CHATML_BLOCK_RE.findall(text)
+        if content.strip()
+    ]
+    roles = {role for role, _ in blocks}
+    if "user" not in roles or "assistant" not in roles:
+        return None
+    return "\n\n".join(
+        f"{ROLE_LABELS[role]}:\n{content}"
+        for role, content in blocks
+        if role in ROLE_LABELS
+    )
+
+
+def contains_code_or_math(text: str) -> bool:
+    return bool(CODE_FENCE_RE.search(text) or LATEX_RE.search(text))
+
+
+def structured_filter_config() -> FilterConfig:
+    return FilterConfig(
+        min_chars=100,
+        max_chars=100_000,
+        min_hangul_chars=30,
+        min_hangul_letter_ratio=0.70,
+        min_hangul_visible_ratio=0.50,
+        max_digit_ratio=0.10,
+        max_symbol_ratio=0.15,
+        max_url_per_word=0.01,
+        min_unique_line_ratio=0.60,
+        min_unique_word_ratio=0.15,
+        max_short_line_ratio=0.75,
+        max_list_line_ratio=0.50,
+        max_table_line_ratio=0.20,
+        max_boilerplate_hits_per_1k=3.0,
+        max_repeated_character_run=30,
+        max_code_line_ratio=0.05,
+        max_code_math_char_ratio=0.08,
+        min_quality_score=0.65,
+        strip_html=True,
+        mask_pii=True,
+    )
+
+
+def atomic_json(path: Path, value: dict[str, Any]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(value, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    for name in (
+        "max_output_tokens",
+        "tokens_per_chunk",
+        "shuffle_buffer",
+        "batch_size",
+    ):
+        if getattr(args, name) <= 0:
+            raise ValueError(f"--{name.replace('_', '-')} must be positive")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    state_path = output_dir / "state.json"
+    allowed_licenses = {value.casefold() for value in args.allowed_license}
+    source_pattern = (
+        re.compile(args.exclude_source_regex)
+        if args.exclude_source_regex
+        else None
+    )
+    filter_config = structured_filter_config()
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+    if len(tokenizer) > np.iinfo(np.uint16).max:
+        raise ValueError("uint16 requires a vocabulary no larger than 65,535")
+    if tokenizer.eos_token_id is None:
+        raise ValueError("Tokenizer must define eos_token_id")
+
+    expected_state = {
+        "dataset": args.dataset,
+        "data_files": list(args.data_file),
+        "split": args.split,
+        "revision": args.revision,
+        "max_output_tokens": args.max_output_tokens,
+        "tokens_per_chunk": args.tokens_per_chunk,
+        "shuffle_buffer": args.shuffle_buffer,
+        "seed": args.seed,
+        "allowed_licenses": sorted(allowed_licenses),
+        "exclude_source_regex": args.exclude_source_regex,
+        "tokenizer_vocab_size": len(tokenizer),
+    }
+    if args.resume:
+        if not state_path.is_file():
+            raise FileNotFoundError(f"Resume state is missing: {state_path}")
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+        for key, value in expected_state.items():
+            if state.get(key) != value:
+                raise ValueError(
+                    f"Resume state mismatch for {key}: "
+                    f"saved={state.get(key)!r}, requested={value!r}"
+                )
+        if state.get("complete"):
+            print(json.dumps(state, ensure_ascii=False, indent=2))
+            return
+        documents_seen = int(state["documents_seen"])
+        tokens_written = int(state["tokens_written"])
+        completed_chunks = int(state["completed_chunks"])
+        current_chunk_tokens = int(state["current_chunk_tokens"])
+        counters = Counter(
+            {key: int(value) for key, value in state["counts"].items()}
+        )
+    else:
+        if state_path.exists() or list(output_dir.glob("tokens-*.bin*")):
+            raise FileExistsError(
+                f"{output_dir} contains prior structured-token artifacts"
+            )
+        documents_seen = 0
+        tokens_written = 0
+        completed_chunks = 0
+        current_chunk_tokens = 0
+        counters: Counter[str] = Counter()
+
+    def final_path(index: int) -> Path:
+        return output_dir / f"tokens-{index:05d}.bin"
+
+    def temporary_path(index: int) -> Path:
+        return output_dir / f"tokens-{index:05d}.bin.tmp"
+
+    def state_value(*, complete: bool) -> dict[str, Any]:
+        return {
+            **expected_state,
+            "tokenizer": str(Path(args.tokenizer_dir).resolve()),
+            "documents_seen": documents_seen,
+            "tokens_written": tokens_written,
+            "completed_chunks": completed_chunks,
+            "current_chunk_tokens": current_chunk_tokens,
+            "counts": dict(sorted(counters.items())),
+            "complete": complete,
+        }
+
+    current_final = final_path(completed_chunks)
+    current_temporary = temporary_path(completed_chunks)
+    if current_chunk_tokens:
+        if not current_temporary.is_file():
+            raise RuntimeError("Resume state points to a missing token chunk")
+        expected_bytes = current_chunk_tokens * np.dtype(np.uint16).itemsize
+        with current_temporary.open("r+b") as handle:
+            handle.truncate(expected_bytes)
+    elif current_final.exists() or current_temporary.exists():
+        raise RuntimeError("Unexpected token chunk exists beyond committed state")
+
+    dataset = load_dataset(
+        args.dataset,
+        data_files=args.data_file or None,
+        split=args.split,
+        revision=args.revision,
+        streaming=True,
+    ).shuffle(seed=args.seed, buffer_size=args.shuffle_buffer)
+    if documents_seen:
+        dataset = dataset.skip(documents_seen)
+
+    handle = current_temporary.open("ab")
+    progress = tqdm(initial=documents_seen, unit="rows")
+    row_batch: list[dict[str, Any]] = []
+
+    def finalize_chunk(*, reopen: bool) -> None:
+        nonlocal handle, completed_chunks, current_chunk_tokens
+        handle.flush()
+        os.fsync(handle.fileno())
+        handle.close()
+        atomic_json(state_path, state_value(complete=False))
+        os.replace(temporary_path(completed_chunks), final_path(completed_chunks))
+        completed_chunks += 1
+        current_chunk_tokens = 0
+        atomic_json(
+            state_path,
+            state_value(complete=tokens_written >= args.max_output_tokens),
+        )
+        if reopen:
+            handle = temporary_path(completed_chunks).open("ab")
+
+    def commit_batch() -> bool:
+        nonlocal documents_seen, tokens_written, current_chunk_tokens
+        accepted: list[str] = []
+        for row in row_batch:
+            source_name = str(row.get("source_name", ""))
+            license_name = str(row.get("license", "")).casefold()
+            counters[f"license_{license_name or 'missing'}"] += 1
+            if allowed_licenses and license_name not in allowed_licenses:
+                counters["rejected_license"] += 1
+                continue
+            if source_pattern and source_pattern.search(source_name):
+                counters["rejected_source"] += 1
+                continue
+            raw_text = row.get("text")
+            if not isinstance(raw_text, str):
+                counters["rejected_missing_text"] += 1
+                continue
+            rendered = render_chatml(raw_text)
+            if rendered is None:
+                counters["rejected_chatml"] += 1
+                continue
+            if contains_code_or_math(rendered):
+                counters["rejected_explicit_code_or_math"] += 1
+                continue
+            text = normalize_text(rendered)
+            reason = rejection_reason(
+                text,
+                filter_config,
+                metrics=measure_text(text),
+            )
+            if reason is not None:
+                counters[f"rejected_{reason}"] += 1
+                continue
+            accepted.append(text)
+            counters["accepted"] += 1
+
+        documents_seen += len(row_batch)
+        counters["seen"] += len(row_batch)
+        progress.update(len(row_batch))
+        row_batch.clear()
+        if accepted:
+            encoded = tokenizer(
+                accepted,
+                add_special_tokens=False,
+                return_attention_mask=False,
+                return_token_type_ids=False,
+            )["input_ids"]
+            flat: list[int] = []
+            for token_ids in encoded:
+                flat.extend(token_ids)
+                flat.append(tokenizer.eos_token_id)
+            remaining = args.max_output_tokens - tokens_written
+            if len(flat) > remaining:
+                flat = flat[:remaining]
+            if flat:
+                array = np.asarray(flat, dtype=np.uint16)
+                array.tofile(handle)
+                tokens_written += len(array)
+                current_chunk_tokens += len(array)
+        atomic_json(
+            state_path,
+            state_value(complete=tokens_written >= args.max_output_tokens),
+        )
+        if (
+            current_chunk_tokens >= args.tokens_per_chunk
+            or tokens_written >= args.max_output_tokens
+        ):
+            finalize_chunk(reopen=tokens_written < args.max_output_tokens)
+        return tokens_written >= args.max_output_tokens
+
+    complete = False
+    try:
+        for row in dataset:
+            row_batch.append(row)
+            if len(row_batch) >= args.batch_size and commit_batch():
+                complete = True
+                break
+        else:
+            complete = commit_batch()
+    finally:
+        if not handle.closed:
+            handle.flush()
+            os.fsync(handle.fileno())
+            handle.close()
+        progress.close()
+
+    atomic_json(state_path, state_value(complete=complete))
+    print(json.dumps(state_value(complete=complete), ensure_ascii=False, indent=2))
+    if not complete:
+        raise RuntimeError(
+            f"{args.dataset} ended after {tokens_written:,} accepted tokens; "
+            f"target was {args.max_output_tokens:,}"
+        )
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/stream_tokenize_fineweb2.py b/scripts/stream_tokenize_fineweb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..0db18337819ba1d29fef151d97eebed6b7c5b874
--- /dev/null
+++ b/scripts/stream_tokenize_fineweb2.py
@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections import Counter
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from datasets import load_dataset
+from huggingface_hub import HfApi
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.text import FilterConfig
+from scripts.prepare_corpus import processed_documents
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Stream a pinned FineWeb2 shard, strictly filter Korean documents, "
+            "and write resumable uint16 token chunks without keeping raw text."
+        )
+    )
+    parser.add_argument("--dataset", default="HuggingFaceFW/fineweb-2")
+    parser.add_argument("--subset", default="kor_Hang")
+    parser.add_argument("--split", default="train")
+    parser.add_argument("--revision", default=None)
+    parser.add_argument("--tokenizer-dir", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--dataset-num-shards", type=int, default=4)
+    parser.add_argument("--dataset-shard-index", type=int, required=True)
+    parser.add_argument("--skip-documents", type=int, default=0)
+    parser.add_argument("--max-output-tokens", type=int, required=True)
+    parser.add_argument("--tokens-per-chunk", type=int, default=250_000_000)
+    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--worker-batch-size", type=int, default=64)
+    parser.add_argument("--tokenize-batch-size", type=int, default=512)
+    parser.add_argument("--cache-dir", default=".cache/huggingface/datasets")
+    parser.add_argument("--resume", action="store_true")
+    return parser.parse_args()
+
+
+def atomic_json(path: Path, value: dict[str, Any]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    with temporary.open("w", encoding="utf-8") as handle:
+        json.dump(value, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    os.replace(temporary, path)
+
+
+def output_row(row: dict[str, Any], index: int) -> dict[str, Any] | None:
+    text = row.get("text")
+    if not isinstance(text, str) or not text.strip():
+        return None
+    return {
+        "id": f"fineweb2:{row.get('id', index)}",
+        "text": text,
+        "source": "fineweb2:kor_Hang",
+        "url": row.get("url"),
+        "license": "ODC-By-1.0",
+    }
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    for name in (
+        "dataset_num_shards",
+        "max_output_tokens",
+        "tokens_per_chunk",
+        "shuffle_buffer",
+        "workers",
+        "worker_batch_size",
+        "tokenize_batch_size",
+    ):
+        if getattr(args, name) <= 0:
+            raise ValueError(f"--{name.replace('_', '-')} must be positive")
+    if not 0 <= args.dataset_shard_index < args.dataset_num_shards:
+        raise ValueError("--dataset-shard-index is outside the shard range")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    state_path = output_dir / "state.json"
+    filter_config = FilterConfig()
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+    if len(tokenizer) > np.iinfo(np.uint16).max:
+        raise ValueError("uint16 requires a vocabulary no larger than 65,535")
+    if tokenizer.eos_token_id is None:
+        raise ValueError("Tokenizer must define eos_token_id")
+
+    if args.resume:
+        if not state_path.is_file():
+            raise FileNotFoundError(f"Resume state is missing: {state_path}")
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+        expected = {
+            "dataset": args.dataset,
+            "subset": args.subset,
+            "split": args.split,
+            "dataset_num_shards": args.dataset_num_shards,
+            "dataset_shard_index": args.dataset_shard_index,
+            "skip_documents": args.skip_documents,
+            "max_output_tokens": args.max_output_tokens,
+            "tokens_per_chunk": args.tokens_per_chunk,
+            "tokenizer_vocab_size": len(tokenizer),
+            "filter": asdict(filter_config),
+        }
+        for key, value in expected.items():
+            if state.get(key) != value:
+                raise ValueError(
+                    f"Resume state mismatch for {key}: "
+                    f"saved={state.get(key)!r}, requested={value!r}"
+                )
+        revision = state["revision"]
+        seed = int(state["seed"])
+        shuffle_buffer = int(state["shuffle_buffer"])
+        documents_seen = int(state["documents_seen"])
+        tokens_written = int(state["tokens_written"])
+        completed_chunks = int(state["completed_chunks"])
+        current_chunk_tokens = int(state["current_chunk_tokens"])
+        counters = Counter(
+            {key: int(value) for key, value in state["counts"].items()}
+        )
+        if state.get("complete"):
+            print(json.dumps(state, ensure_ascii=False, indent=2))
+            return
+    else:
+        if state_path.exists() or list(output_dir.glob("tokens-*.bin*")):
+            raise FileExistsError(
+                f"{output_dir} contains prior stream-tokenization artifacts"
+            )
+        revision = args.revision or HfApi().dataset_info(args.dataset).sha
+        seed = args.seed
+        shuffle_buffer = args.shuffle_buffer
+        documents_seen = 0
+        tokens_written = 0
+        completed_chunks = 0
+        current_chunk_tokens = 0
+        counters: Counter[str] = Counter()
+
+    def final_path(index: int) -> Path:
+        return output_dir / f"tokens-{index:05d}.bin"
+
+    def temporary_path(index: int) -> Path:
+        return output_dir / f"tokens-{index:05d}.bin.tmp"
+
+    def state_value(*, complete: bool) -> dict[str, Any]:
+        return {
+            "dataset": args.dataset,
+            "subset": args.subset,
+            "split": args.split,
+            "revision": revision,
+            "license": "ODC-By-1.0; subject to CommonCrawl Terms of Use",
+            "dataset_num_shards": args.dataset_num_shards,
+            "dataset_shard_index": args.dataset_shard_index,
+            "skip_documents": args.skip_documents,
+            "seed": seed,
+            "shuffle_buffer": shuffle_buffer,
+            "max_output_tokens": args.max_output_tokens,
+            "tokens_per_chunk": args.tokens_per_chunk,
+            "tokenizer": str(Path(args.tokenizer_dir).resolve()),
+            "tokenizer_vocab_size": len(tokenizer),
+            "filter": asdict(filter_config),
+            "upstream_deduplication": "FineWeb2 global MinHash deduplication",
+            "documents_seen": documents_seen,
+            "tokens_written": tokens_written,
+            "completed_chunks": completed_chunks,
+            "current_chunk_tokens": current_chunk_tokens,
+            "counts": dict(sorted(counters.items())),
+            "complete": complete,
+        }
+
+    current_final = final_path(completed_chunks)
+    current_temporary = temporary_path(completed_chunks)
+    if current_chunk_tokens:
+        if current_final.is_file() and not current_temporary.exists():
+            completed_chunks += 1
+            current_chunk_tokens = 0
+            atomic_json(
+                state_path,
+                state_value(complete=tokens_written >= args.max_output_tokens),
+            )
+            current_final = final_path(completed_chunks)
+            current_temporary = temporary_path(completed_chunks)
+        elif current_temporary.is_file():
+            expected_bytes = current_chunk_tokens * np.dtype(np.uint16).itemsize
+            with current_temporary.open("r+b") as handle:
+                handle.truncate(expected_bytes)
+        else:
+            raise RuntimeError("Resume state points to a missing current token chunk")
+    elif current_final.exists() or current_temporary.exists():
+        raise RuntimeError("Unexpected token chunk exists beyond committed state")
+
+    dataset = load_dataset(
+        args.dataset,
+        name=args.subset,
+        split=args.split,
+        revision=revision,
+        streaming=True,
+        cache_dir=args.cache_dir,
+    )
+    dataset = dataset.shard(
+        num_shards=args.dataset_num_shards,
+        index=args.dataset_shard_index,
+        contiguous=True,
+    )
+    dataset = dataset.shuffle(seed=seed, buffer_size=shuffle_buffer)
+    total_skip = args.skip_documents + documents_seen
+    if total_skip:
+        dataset = dataset.skip(total_skip)
+
+    def documents() -> Any:
+        for index, row in enumerate(dataset, start=total_skip):
+            document = output_row(row, index)
+            if document is not None:
+                yield document
+
+    processed = processed_documents(
+        documents(),
+        filter_config=filter_config,
+        workers=args.workers,
+        batch_size=args.worker_batch_size,
+        limit=None,
+    )
+    result_batch: list[Any] = []
+    handle = current_temporary.open("ab")
+    progress = tqdm(initial=documents_seen, unit="docs")
+
+    def finalize_chunk(*, reopen: bool) -> None:
+        nonlocal handle, completed_chunks, current_chunk_tokens
+        handle.flush()
+        os.fsync(handle.fileno())
+        handle.close()
+        atomic_json(state_path, state_value(complete=False))
+        os.replace(temporary_path(completed_chunks), final_path(completed_chunks))
+        completed_chunks += 1
+        current_chunk_tokens = 0
+        atomic_json(
+            state_path,
+            state_value(complete=tokens_written >= args.max_output_tokens),
+        )
+        if reopen:
+            handle = temporary_path(completed_chunks).open("ab")
+
+    def commit_batch() -> bool:
+        nonlocal documents_seen, tokens_written, current_chunk_tokens
+        if not result_batch:
+            return False
+        accepted_texts: list[str] = []
+        for _, text, reason, _, _, _ in result_batch:
+            if reason is None:
+                accepted_texts.append(text)
+                counters["accepted"] += 1
+            else:
+                counters[f"rejected_{reason}"] += 1
+        documents_seen += len(result_batch)
+        counters["seen"] += len(result_batch)
+        progress.update(len(result_batch))
+        result_batch.clear()
+
+        if accepted_texts:
+            encoded = tokenizer(
+                accepted_texts,
+                add_special_tokens=False,
+                return_attention_mask=False,
+                return_token_type_ids=False,
+            )["input_ids"]
+            flat: list[int] = []
+            for token_ids in encoded:
+                flat.extend(token_ids)
+                flat.append(tokenizer.eos_token_id)
+            remaining = args.max_output_tokens - tokens_written
+            if len(flat) > remaining:
+                flat = flat[:remaining]
+            if flat:
+                array = np.asarray(flat, dtype=np.uint16)
+                array.tofile(handle)
+                tokens_written += len(array)
+                current_chunk_tokens += len(array)
+        atomic_json(
+            state_path,
+            state_value(complete=tokens_written >= args.max_output_tokens),
+        )
+        if (
+            current_chunk_tokens >= args.tokens_per_chunk
+            or tokens_written >= args.max_output_tokens
+        ):
+            finalize_chunk(reopen=tokens_written < args.max_output_tokens)
+        return tokens_written >= args.max_output_tokens
+
+    try:
+        for result in processed:
+            result_batch.append(result)
+            if len(result_batch) >= args.tokenize_batch_size and commit_batch():
+                break
+        else:
+            commit_batch()
+        if current_chunk_tokens and not handle.closed:
+            handle.flush()
+            atomic_json(state_path, state_value(complete=False))
+    finally:
+        close_processed = getattr(processed, "close", None)
+        if close_processed is not None:
+            close_processed()
+        if not handle.closed:
+            handle.close()
+        progress.close()
+
+    complete = tokens_written >= args.max_output_tokens
+    atomic_json(state_path, state_value(complete=complete))
+    print(json.dumps(state_value(complete=complete), ensure_ascii=False, indent=2))
+    if not complete:
+        raise RuntimeError(
+            "FineWeb2 shard ended before the requested token target was reached"
+        )
+    # Some pyarrow/fsspec streaming combinations abort in interpreter finalizers
+    # after a remote iterator is intentionally stopped early. All output handles,
+    # worker generators, and the atomic state file are already closed above.
+    # A direct successful exit avoids turning a fully committed shard into a
+    # false pipeline failure (and avoids producing a large core dump).
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/tokenize_corpus.py b/scripts/tokenize_corpus.py
new file mode 100644
index 0000000000000000000000000000000000000000..1172083c0c48c4354e5b176e00abb98c0c059165
--- /dev/null
+++ b/scripts/tokenize_corpus.py
@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import discover_paths, iter_documents
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Tokenize clean JSONL shards into flat uint16 streams."
+    )
+    parser.add_argument("--input-dir", default="data/clean")
+    parser.add_argument("--tokenizer-dir", default="artifacts/tokenizer-20k")
+    parser.add_argument("--output-dir", default="data/tokenized")
+    parser.add_argument("--batch-size", type=int, default=64)
+    parser.add_argument("--max-train-tokens", type=int, default=None)
+    parser.add_argument("--max-validation-tokens", type=int, default=None)
+    parser.add_argument("--max-test-tokens", type=int, default=None)
+    return parser.parse_args()
+
+
+def tokenize_split(
+    *,
+    split: str,
+    paths: list[Path],
+    tokenizer: Any,
+    output_path: Path,
+    batch_size: int,
+    max_tokens: int | None,
+) -> dict[str, Any]:
+    documents_seen = 0
+    documents_written = 0
+    token_count = 0
+    text_batch: list[str] = []
+
+    def flush(handle: Any) -> bool:
+        nonlocal documents_written, token_count
+        if not text_batch:
+            return False
+        encoded_batch = tokenizer(
+            text_batch,
+            add_special_tokens=False,
+            return_attention_mask=False,
+            return_token_type_ids=False,
+        )["input_ids"]
+        reached_limit = False
+        for token_ids in encoded_batch:
+            tokens = list(token_ids)
+            if not tokens or tokens[-1] != tokenizer.eos_token_id:
+                tokens.append(tokenizer.eos_token_id)
+            if max_tokens is not None:
+                remaining = max_tokens - token_count
+                if remaining <= 0:
+                    reached_limit = True
+                    break
+                if len(tokens) > remaining:
+                    tokens = tokens[:remaining]
+                    reached_limit = True
+            if tokens:
+                np.asarray(tokens, dtype=np.uint16).tofile(handle)
+                token_count += len(tokens)
+                documents_written += 1
+            if reached_limit:
+                break
+        text_batch.clear()
+        return reached_limit
+
+    with output_path.open("wb") as handle:
+        progress = tqdm(iter_documents(paths), desc=split, unit="docs")
+        for document in progress:
+            documents_seen += 1
+            text_batch.append(document["text"])
+            if len(text_batch) >= batch_size and flush(handle):
+                break
+        else:
+            flush(handle)
+
+    return {
+        "split": split,
+        "output": str(output_path),
+        "input_files": len(paths),
+        "documents_seen": documents_seen,
+        "documents_written": documents_written,
+        "tokens": token_count,
+        "bytes": output_path.stat().st_size,
+        "dtype": "uint16",
+    }
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.batch_size <= 0:
+        raise ValueError("--batch-size must be positive")
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    existing = [
+        *(output_dir / f"{split}.bin" for split in ("train", "validation", "test")),
+        output_dir / "metadata.json",
+    ]
+    existing = [path for path in existing if path.exists()]
+    if existing:
+        raise FileExistsError(
+            f"{existing[0]} already exists. Choose a new output directory."
+        )
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+    if len(tokenizer) > np.iinfo(np.uint16).max:
+        raise ValueError("uint16 output requires a vocabulary no larger than 65,535")
+    if tokenizer.eos_token_id is None:
+        raise ValueError("Tokenizer must define eos_token_id")
+
+    input_dir = Path(args.input_dir)
+    limits = {
+        "train": args.max_train_tokens,
+        "validation": args.max_validation_tokens,
+        "test": args.max_test_tokens,
+    }
+    summaries: dict[str, Any] = {
+        "tokenizer": str(Path(args.tokenizer_dir).resolve()),
+        "vocab_size": len(tokenizer),
+        "eos_token_id": tokenizer.eos_token_id,
+        "splits": {},
+    }
+    for split in ("train", "validation", "test"):
+        paths = discover_paths([str(input_dir / f"{split}-*.jsonl")])
+        if not paths:
+            print(f"Skipping {split}: no input shards")
+            continue
+        summary = tokenize_split(
+            split=split,
+            paths=paths,
+            tokenizer=tokenizer,
+            output_path=output_dir / f"{split}.bin",
+            batch_size=args.batch_size,
+            max_tokens=limits[split],
+        )
+        summaries["splits"][split] = summary
+
+    if "train" not in summaries["splits"]:
+        raise FileNotFoundError("No train shards were found")
+    metadata_path = output_dir / "metadata.json"
+    with metadata_path.open("w", encoding="utf-8") as handle:
+        json.dump(summaries, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    print(json.dumps(summaries, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/tokenize_shard.py b/scripts/tokenize_shard.py
new file mode 100644
index 0000000000000000000000000000000000000000..87d44bc83dc7c5d0ec0e0ea38e4d0acacb56d101
--- /dev/null
+++ b/scripts/tokenize_shard.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+from transformers import AutoTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from scripts.tokenize_corpus import tokenize_split
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Tokenize one clean JSONL shard into a uint16 token part."
+    )
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--tokenizer-dir", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--batch-size", type=int, default=64)
+    return parser.parse_args()
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+    metadata_path = output_path.with_suffix(".json")
+    if not input_path.is_file():
+        raise FileNotFoundError(input_path)
+    if output_path.exists() or metadata_path.exists():
+        raise FileExistsError(f"Refusing to overwrite token part: {output_path}")
+    if args.batch_size <= 0:
+        raise ValueError("--batch-size must be positive")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer_dir, use_fast=False, legacy=True
+    )
+    tokenizer.model_max_length = int(1e30)
+    if len(tokenizer) > np.iinfo(np.uint16).max:
+        raise ValueError("uint16 output requires a vocabulary no larger than 65,535")
+    if tokenizer.eos_token_id is None:
+        raise ValueError("Tokenizer must define eos_token_id")
+
+    summary = tokenize_split(
+        split=input_path.stem,
+        paths=[input_path],
+        tokenizer=tokenizer,
+        output_path=output_path,
+        batch_size=args.batch_size,
+        max_tokens=None,
+    )
+    summary["input"] = str(input_path)
+    with metadata_path.open("w", encoding="utf-8") as handle:
+        json.dump(summary, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    print(json.dumps(summary, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/train_tokenizer.py b/scripts/train_tokenizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..49258b30b8ed39bcd876ff23ca73677d307d6d4f
--- /dev/null
+++ b/scripts/train_tokenizer.py
@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+from collections.abc import Iterator
+from pathlib import Path
+
+import sentencepiece as spm
+from tqdm import tqdm
+from transformers import LlamaTokenizer
+
+from kawk50m.cli import configure_utf8_stdio
+from kawk50m.io import discover_paths, iter_documents
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Train a Korean SentencePiece Unigram tokenizer."
+    )
+    parser.add_argument(
+        "--input",
+        nargs="+",
+        default=["data/clean/train-*.jsonl"],
+        help="Clean training shards or glob patterns.",
+    )
+    parser.add_argument("--output-dir", default="artifacts/tokenizer-20k")
+    parser.add_argument("--vocab-size", type=int, default=20_000)
+    parser.add_argument("--max-sentences", type=int, default=2_000_000)
+    parser.add_argument(
+        "--min-sentences",
+        type=int,
+        default=1_000,
+        help="Safety floor; lower only for a synthetic smoke test.",
+    )
+    parser.add_argument("--max-line-chars", type=int, default=4096)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--model-max-length", type=int, default=1024)
+    parser.add_argument("--text-field", default="text")
+    parser.add_argument("--num-threads", type=int, default=os.cpu_count() or 1)
+    parser.add_argument(
+        "--reuse-model",
+        action="store_true",
+        help=(
+            "Reuse an existing tokenizer.model/tokenizer.vocab in --output-dir "
+            "and rebuild only the Hugging Face wrapper files."
+        ),
+    )
+    parser.add_argument(
+        "--training-lines",
+        type=int,
+        default=None,
+        help="Original SentencePiece line count recorded with --reuse-model.",
+    )
+    return parser.parse_args()
+
+
+def chunks(text: str, max_chars: int) -> Iterator[str]:
+    for paragraph in text.splitlines():
+        paragraph = paragraph.strip()
+        if not paragraph:
+            continue
+        for start in range(0, len(paragraph), max_chars):
+            piece = paragraph[start : start + max_chars].strip()
+            if piece:
+                yield piece
+
+
+def main() -> None:
+    configure_utf8_stdio()
+    args = parse_args()
+    if args.vocab_size <= 300:
+        raise ValueError("--vocab-size must exceed 300 when byte fallback is enabled")
+    if args.max_sentences <= 0:
+        raise ValueError("--max-sentences must be positive")
+
+    paths = discover_paths(args.input)
+    if not paths:
+        raise FileNotFoundError("No tokenizer training inputs were found")
+    random.Random(args.seed).shuffle(paths)
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    model_path = output_dir / "tokenizer.model"
+    generated_paths = [
+        output_dir / "tokenizer.model",
+        output_dir / "tokenizer.vocab",
+        output_dir / "tokenizer_config.json",
+        output_dir / "training_metadata.json",
+    ]
+    existing_generated = [path for path in generated_paths if path.exists()]
+    if existing_generated and not args.reuse_model:
+        raise FileExistsError(
+            f"{existing_generated[0]} already exists. "
+            "Choose a new output directory to avoid overwriting tokenizer artifacts."
+        )
+    if args.reuse_model:
+        if not model_path.is_file() or not (output_dir / "tokenizer.vocab").is_file():
+            raise FileNotFoundError(
+                "--reuse-model requires tokenizer.model and tokenizer.vocab"
+            )
+        for stale_wrapper in (
+            output_dir / "tokenizer.json",
+            output_dir / "tokenizer_config.json",
+            output_dir / "special_tokens_map.json",
+            output_dir / "training_metadata.json",
+        ):
+            stale_wrapper.unlink(missing_ok=True)
+    temporary_corpus = output_dir / ".sentencepiece_input.tmp"
+
+    sentence_count = args.training_lines if args.reuse_model else 0
+    if not args.reuse_model:
+        try:
+            with temporary_corpus.open("w", encoding="utf-8", newline="\n") as handle:
+                documents = iter_documents(paths, text_field=args.text_field)
+                progress = tqdm(total=args.max_sentences, unit="lines")
+                for document in documents:
+                    for line in chunks(document["text"], args.max_line_chars):
+                        handle.write(line.replace("\n", " "))
+                        handle.write("\n")
+                        sentence_count += 1
+                        progress.update(1)
+                        if sentence_count >= args.max_sentences:
+                            break
+                    if sentence_count >= args.max_sentences:
+                        break
+                progress.close()
+
+            if sentence_count < args.min_sentences:
+                raise ValueError(
+                    f"Only {sentence_count} lines were found; "
+                    f"at least {args.min_sentences} are required"
+                )
+
+            spm.SentencePieceTrainer.train(
+                input=str(temporary_corpus),
+                model_prefix=str(output_dir / "tokenizer"),
+                model_type="unigram",
+                vocab_size=args.vocab_size,
+                character_coverage=1.0,
+                normalization_rule_name="identity",
+                byte_fallback=True,
+                split_digits=True,
+                unk_id=0,
+                bos_id=1,
+                eos_id=2,
+                pad_id=3,
+                unk_piece="<unk>",
+                bos_piece="<s>",
+                eos_piece="</s>",
+                pad_piece="<pad>",
+                user_defined_symbols=["<EMAIL>", "<PHONE>", "<RRN>"],
+                input_sentence_size=0,
+                shuffle_input_sentence=False,
+                max_sentence_length=max(args.max_line_chars * 2, 8192),
+                num_threads=args.num_threads,
+                train_extremely_large_corpus=True,
+                hard_vocab_limit=True,
+            )
+        finally:
+            temporary_corpus.unlink(missing_ok=True)
+
+    tokenizer = LlamaTokenizer(
+        vocab_file=str(model_path),
+        unk_token="<unk>",
+        bos_token="<s>",
+        eos_token="</s>",
+        pad_token="<pad>",
+        add_bos_token=True,
+        add_eos_token=False,
+        model_max_length=args.model_max_length,
+        clean_up_tokenization_spaces=False,
+        legacy=True,
+    )
+    tokenizer.padding_side = "right"
+    tokenizer.save_pretrained(output_dir)
+    if len(tokenizer) != args.vocab_size:
+        raise RuntimeError(
+            f"Expected {args.vocab_size} tokens, tokenizer has {len(tokenizer)}"
+        )
+
+    probes = [
+        "안녕하세요. 오늘 날씨가 좋습니다.",
+        "이거 진짜 되는 거 맞아? ㅋㅋㅋㅋ",
+        "갤럭시 S26을 2026년에 구매했습니다.",
+        "KTX를 타고 부산에 내려갔다. 🚄",
+    ]
+    round_trip = []
+    for text in probes:
+        token_ids = tokenizer.encode(text, add_special_tokens=False)
+        decoded = tokenizer.decode(
+            token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
+        )
+        round_trip.append(
+            {
+                "text": text,
+                "tokens": len(token_ids),
+                "unknown_tokens": token_ids.count(tokenizer.unk_token_id),
+                "decoded": decoded,
+                "exact_round_trip": decoded == text,
+            }
+        )
+
+    metadata = {
+        "type": "SentencePiece Unigram",
+        "vocab_size": len(tokenizer),
+        "normalization": "external NFC + SentencePiece identity",
+        "byte_fallback": True,
+        "split_digits": True,
+        "training_lines": sentence_count,
+        "reused_sentencepiece_model": args.reuse_model,
+        "model_max_length": args.model_max_length,
+        "special_token_ids": {
+            "unk": tokenizer.unk_token_id,
+            "bos": tokenizer.bos_token_id,
+            "eos": tokenizer.eos_token_id,
+            "pad": tokenizer.pad_token_id,
+        },
+        "probes": round_trip,
+    }
+    with (output_dir / "training_metadata.json").open(
+        "w", encoding="utf-8"
+    ) as handle:
+        json.dump(metadata, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/upload_hf_release.py b/scripts/upload_hf_release.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab203bed639a78146dd066b7455a1a86bc5a70da
--- /dev/null
+++ b/scripts/upload_hf_release.py
@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from huggingface_hub import CommitOperationAdd, HfApi
+
+
+@dataclass(frozen=True)
+class ModelRelease:
+    repo_name: str
+    checkpoint: str
+    config: str
+    report_dir: str
+    title: str
+    description: str
+    context_length: int
+    evaluation: str
+
+
+MODEL_RELEASES = (
+    ModelRelease(
+        repo_name="KAWK-1.5-50M-Korean-Base",
+        checkpoint="runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147",
+        config="configs/pretrain_fixed_recovery_plus5b_5090.yaml",
+        report_dir="reports/fixed-recovery-6b",
+        title="KAWK-1.5-50M Korean Base",
+        description="한국어 중심 데이터 6B 토큰으로 학습한 51.5M 파라미터 베이스 모델",
+        context_length=1024,
+        evaluation="validation loss 2.8903 (이전 1B 체크포인트 2.9745)",
+    ),
+    ModelRelease(
+        repo_name="KAWK-1.5-50M-Korean-Base-5K",
+        checkpoint="runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
+        config="configs/cpt_fixed_ko_3b_5k_5090.yaml",
+        report_dir="reports/fixed-ko-cpt-3b-5k",
+        title="KAWK-1.5-50M Korean Base 5K",
+        description="KAWK 한국어 베이스 모델을 5,120 토큰 문맥으로 계속 사전학습한 모델",
+        context_length=5120,
+        evaluation="validation loss 2.8583",
+    ),
+    ModelRelease(
+        repo_name="KAWK-1.5-50M-Korean-Instruct",
+        checkpoint="runs/kawk50m-ko-instruct-v1-5090/checkpoint-00001303",
+        config="configs/sft_ko_80m_5k_5090.yaml",
+        report_dir="reports/kawk50m-ko-instruct-v1",
+        title="KAWK-1.5-50M Korean Instruct",
+        description="5K 문맥 한국어 베이스 모델에 약 80M 토큰의 한국어 SFT를 적용한 모델",
+        context_length=5120,
+        evaluation="SFT validation loss 2.3216 (베이스라인 2.5483)",
+    ),
+)
+
+
+def model_card(spec: ModelRelease, repo_id: str) -> bytes:
+    card = f"""---
+language:
+- ko
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- llama
+- korean
+- causal-lm
+- kawk50m
+---
+
+# {spec.title}
+
+{spec.description}입니다. 이 저장소는 우선 비공개 백업 및 검증 목적으로 생성됐습니다.
+
+## 구조
+
+- 아키텍처: Llama 계열 decoder-only Transformer
+- 파라미터: 51,542,528
+- 어휘: 한국어 SentencePiece Unigram 20,000
+- 레이어/hidden/MLP: 14 / 512 / 1,408
+- Attention/KV heads: 8 / 4
+- 최대 문맥: {spec.context_length:,} 토큰
+- 입력·출력 임베딩 공유
+
+## 평가
+
+{spec.evaluation}. 자세한 결과와 로그는 `training/reports/`에 포함했습니다.
+
+평가는 소규모 내부 검증 세트에 기반하므로 범용 한국어 성능을 보장하지 않습니다. 50M급 모델인 만큼 지식량, 추론, 사실성 및 장문 지시 수행에 뚜렷한 한계가 있습니다.
+
+## 사용 예시
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+repo_id = "{repo_id}"
+tokenizer = AutoTokenizer.from_pretrained(repo_id)
+model = AutoModelForCausalLM.from_pretrained(repo_id)
+```
+
+## 데이터 및 공개 전 확인사항
+
+한국어 웹 데이터와 공개 한국어 대화형 데이터가 사용됐습니다. 저장소를 공개로 전환하기 전에 데이터 출처별 재배포 조건, 모델 라이선스, 개인정보 및 평가 한계를 다시 검토해야 합니다.
+"""
+    return card.encode("utf-8")
+
+
+def archive_card(title: str, body: str) -> bytes:
+    return f"""---
+language:
+- ko
+tags:
+- korean
+- language-modeling
+- kawk50m
+---
+
+# {title}
+
+{body}
+
+이 저장소는 비공개 프로젝트 백업용입니다. 공개 전환 전에 원천 데이터 라이선스, 개인정보, 중복 파일 및 실패 실험 산출물을 검토해야 합니다.
+""".encode("utf-8")
+
+
+def create_private_repo(api: HfApi, repo_id: str, repo_type: str) -> None:
+    api.create_repo(repo_id=repo_id, repo_type=repo_type, private=True, exist_ok=True)
+
+
+def upload_readme(api: HfApi, repo_id: str, repo_type: str, content: bytes) -> None:
+    api.create_commit(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        operations=[CommitOperationAdd(path_in_repo="README.md", path_or_fileobj=content)],
+        commit_message="Add repository card",
+    )
+
+
+def upload_models(api: HfApi, root: Path, namespace: str) -> None:
+    for spec in MODEL_RELEASES:
+        repo_id = f"{namespace}/{spec.repo_name}"
+        checkpoint = root / spec.checkpoint
+        model_dir = checkpoint / "model"
+        tokenizer_dir = checkpoint / "tokenizer"
+        if not model_dir.is_dir() or not tokenizer_dir.is_dir():
+            raise FileNotFoundError(f"Incomplete checkpoint: {checkpoint}")
+
+        create_private_repo(api, repo_id, "model")
+        upload_readme(api, repo_id, "model", model_card(spec, repo_id))
+        api.upload_folder(
+            repo_id=repo_id,
+            repo_type="model",
+            folder_path=model_dir,
+            commit_message="Upload model weights and configuration",
+        )
+        api.upload_folder(
+            repo_id=repo_id,
+            repo_type="model",
+            folder_path=tokenizer_dir,
+            commit_message="Upload Korean tokenizer",
+        )
+        api.upload_file(
+            repo_id=repo_id,
+            repo_type="model",
+            path_or_fileobj=checkpoint / "trainer_state.pt",
+            path_in_repo="training/trainer_state.pt",
+            commit_message="Upload resumable trainer state",
+        )
+        api.upload_file(
+            repo_id=repo_id,
+            repo_type="model",
+            path_or_fileobj=checkpoint / "state_summary.json",
+            path_in_repo="training/state_summary.json",
+            commit_message="Upload checkpoint summary",
+        )
+        api.upload_file(
+            repo_id=repo_id,
+            repo_type="model",
+            path_or_fileobj=root / spec.config,
+            path_in_repo=f"training/{Path(spec.config).name}",
+            commit_message="Upload training configuration",
+        )
+        api.upload_folder(
+            repo_id=repo_id,
+            repo_type="model",
+            folder_path=root / spec.report_dir,
+            path_in_repo="training/reports",
+            commit_message="Upload evaluation reports and logs",
+        )
+        files = set(api.list_repo_files(repo_id=repo_id, repo_type="model"))
+        required = {"config.json", "model.safetensors", "tokenizer.model", "README.md"}
+        missing = required - files
+        if missing:
+            raise RuntimeError(f"Upload verification failed for {repo_id}: {sorted(missing)}")
+        print(json.dumps({"repo": repo_id, "status": "verified", "files": len(files)}))
+
+
+def upload_archive(
+    api: HfApi,
+    *,
+    root: Path,
+    namespace: str,
+    phase: str,
+    workers: int,
+) -> None:
+    definitions = {
+        "project": (
+            "KAWK50M-Project",
+            root,
+            archive_card(
+                "KAWK50M Project",
+                "한국어 50M 언어모델의 코드, 설정, 토크나이저 산출물 및 평가 보고서입니다.",
+            ),
+            [
+                "data/**",
+                "runs/**",
+                ".venv/**",
+                ".git/**",
+                ".cache/**",
+                ".pytest_cache/**",
+                "README.md",
+                "**/__pycache__/**",
+                "**/*.pyc",
+            ],
+        ),
+        "data": (
+            "KAWK50M-Training-Data",
+            root / "data",
+            archive_card(
+                "KAWK50M Training Data Archive",
+                "수집 원문, 정제 말뭉치, 토큰화 바이너리와 SFT 데이터의 전체 작업 사본입니다.",
+            ),
+            [".cache/**", "**/__pycache__/**"],
+        ),
+        "runs": (
+            "KAWK50M-Training-Runs",
+            root / "runs",
+            archive_card(
+                "KAWK50M Training Runs Archive",
+                "최종·중간·실험 체크포인트를 포함한 전체 학습 이력입니다.",
+            ),
+            [".cache/**", "**/__pycache__/**"],
+        ),
+    }
+    repo_name, folder, card, ignore = definitions[phase]
+    repo_id = f"{namespace}/{repo_name}"
+    create_private_repo(api, repo_id, "dataset")
+    api.upload_large_folder(
+        repo_id=repo_id,
+        repo_type="dataset",
+        folder_path=folder,
+        ignore_patterns=ignore,
+        num_workers=workers,
+        print_report=True,
+        print_report_every=60,
+    )
+    if phase == "project":
+        api.upload_file(
+            repo_id=repo_id,
+            repo_type="dataset",
+            path_or_fileobj=root / "README.md",
+            path_in_repo="PROJECT_README.md",
+            commit_message="Upload project README",
+        )
+    upload_readme(api, repo_id, "dataset", card)
+    files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
+    if "README.md" not in files:
+        raise RuntimeError(f"Upload verification failed for {repo_id}")
+    print(json.dumps({"repo": repo_id, "status": "verified", "files": len(files)}))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Upload KAWK50M releases to Hugging Face")
+    parser.add_argument("--namespace", required=True)
+    parser.add_argument("--project-root", type=Path, default=Path.cwd())
+    parser.add_argument(
+        "--phase",
+        choices=("models", "project", "data", "runs", "all"),
+        default="models",
+    )
+    parser.add_argument("--workers", type=int, default=8)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    root = args.project_root.resolve()
+    api = HfApi(token=True)
+    identity = api.whoami()
+    if identity.get("name") != args.namespace:
+        raise RuntimeError(
+            f"Authenticated as {identity.get('name')!r}, expected {args.namespace!r}"
+        )
+
+    phases = ("models", "project", "data", "runs") if args.phase == "all" else (args.phase,)
+    for phase in phases:
+        if phase == "models":
+            upload_models(api, root, args.namespace)
+        else:
+            upload_archive(
+                api,
+                root=root,
+                namespace=args.namespace,
+                phase=phase,
+                workers=args.workers,
+            )
+
+
+if __name__ == "__main__":
+    main()