papers/ngpt/sau.json

{
  "paper_id": "ngpt",
  "paper_title": "nGPT: Normalized Transformer with Representation Learning on the Hypersphere",
  "D1": [
    {
      "id": "ngpt-D1-001",
      "claim": "Model architecture dimensions for 0.5B/1B models (Table 2): n_layers=24/36, d_model=1024/1280, n_heads=16/20, d_k=64 (d_model/n_heads), d_MLP=4096/5120 (4*d_model).",
      "source": "Section A.6, Table 2; Section 2.3.1"
    },
    {
      "id": "ngpt-D1-002",
      "claim": "Model parameter counts including embeddings: GPT baseline 468.2M/1025.7M; nGPT 468.4M/1026.1M for 0.5B/1B models. nGPT has ~0.2M-0.4M extra parameters from 6 learnable scaling factors.",
      "source": "Section A.6, Table 2; Section A.10"
    },
    {
      "id": "ngpt-D1-003",
      "claim": "Optimizer configuration: GPT uses AdamW with weight_decay=0.1 and warmup_steps=2000; nGPT uses Adam (AdamW with weight_decay=0.0) with warmup_steps=0. Both share Cosine Annealing schedule, lr_final=0, and problem-specific initial learning rate.",
      "source": "Section A.6, Table 3; Section 2.6 step 7; Section A.7"
    },
    {
      "id": "ngpt-D1-004",
      "claim": "Training infrastructure: global batch_size=512, 64 A100 GPUs across 8 compute nodes (8 GPUs/node). Same hardware configuration used for both 0.5B and 1B model training.",
      "source": "Section A.6"
    },
    {
      "id": "ngpt-D1-005",
      "claim": "Data configuration: OpenWebText dataset with LLaMA-2 tokenizer (vocab_size=32000). All matrix parameters stored in bfloat16 precision.",
      "source": "Section A.6"
    },
    {
      "id": "ngpt-D1-006",
      "claim": "Weight initialization: GPT uses N(0, 0.02^2); nGPT uses N(0, 1/d_model). Output matrix standard deviation scaled by sqrt(2*n_layers) per Radford et al. (2018). nGPT matrices normalized along embedding dimension after initialization.",
      "source": "Section A.6"
    },
    {
      "id": "ngpt-D1-007",
      "claim": "RoPE positional encoding base frequency: rope_base=10000, applied to query and key vectors in each attention head before computing attention scores.",
      "source": "Section A.6"
    },
    {
      "id": "ngpt-D1-008",
      "claim": "Eigen learning rates (default): alpha_A_init=0.05, alpha_M_init=0.05, both with scale=1/sqrt(d_model). Via the init/scale trick (Section 2.5), effective learning rate ratio relative to global LR is approximately 1/sqrt(d_model).",
      "source": "Section 2.6 step 3; Section 2.5"
    },
    {
      "id": "ngpt-D1-009",
      "claim": "Alternative eigen learning rates for 1B model at 8k context length: alpha_A_init_alt=0.1, alpha_M_init_alt=0.1. Increasing from default 0.05 reduces Adam effective LR on these variables by factor ~3, restoring smooth hyperparameter sensitivity curves.",
      "source": "Section A.7"
    },
    {
      "id": "ngpt-D1-010",
      "claim": "QK scaling factor s_qk: s_qk_init=1, s_qk_scale=1/sqrt(d_model). Applied as per-head element-wise scaling after normalizing query and key vectors (Eq. 15-16), controlling the magnitude of QK dot products.",
      "source": "Section 2.6 step 4"
    },
    {
      "id": "ngpt-D1-011",
      "claim": "MLP intermediate scaling factors: s_u_init=1, s_u_scale=1; s_v_init=1, s_v_scale=1. s_u scales the u vector; s_v scales the v vector (with additional sqrt(d_model) rescaling per Eq. 20-21).",
      "source": "Section 2.6 step 5; Section 2.4.2 Eq. 20-21"
    },
    {
      "id": "ngpt-D1-012",
      "claim": "Logit scaling factor s_z: s_z_init=1, s_z_scale=1/sqrt(d_model). Element-wise scaling of logits (Eq. 3) to control softmax temperature; higher mean(s_z) produces sharper probability distributions.",
      "source": "Section 2.6 step 6; Section A.10"
    },
    {
      "id": "ngpt-D1-013",
      "claim": "Softmax attention scaling factor: baseline GPT uses 1/sqrt(d_k); nGPT uses sqrt(d_k). The change restores unit variance for normalized q/k dot products (expected variance 1/d_k instead of 1).",
      "source": "Section 2.3.1 Eq. 13; Section 2.3.2; Section 2.6 step 4"
    },
    {
      "id": "ngpt-D1-014",
      "claim": "MLP intermediate v rescaling: v vector multiplied by sqrt(d_model) before SiLU non-linearity (Eq. 21). Compensates for expected dot product magnitude E[|cos(theta)|] ~ 1/sqrt(d_model) so SiLU benefits from its non-linear region.",
      "source": "Section 2.4.2 Eq. 21; Appendix A.1"
    },
    {
      "id": "ngpt-D1-015",
      "claim": "SiLU activation function numerical properties: minimum at x=-1.278 with SiLU_min_val=-0.278. For |x| close to 0, SiLU(x) approximates x/2 (linear); for large positive x, approximates ReLU.",
      "source": "Appendix A.1"
    },
    {
      "id": "ngpt-D1-016",
      "claim": "Training context lengths: experiments conducted at three levels using separate training phases: 1k tokens (first), 4k tokens (second), and 8k tokens (third). Reported speedups are 4x/10x/20x at 1k/4k/8k respectively.",
      "source": "Section 3.1, Figure 2; Section A.7"
    },
    {
      "id": "ngpt-D1-017",
      "claim": "Ablation study configuration (Section A.9): model_size=0.5B, context_length=1k, learning_rate=1e-3, training_iterations=100000 consuming approximately 52B tokens.",
      "source": "Section A.9"
    },
    {
      "id": "ngpt-D1-018",
      "claim": "PG19 length extrapolation evaluation: perplexity measured at context lengths from 1K to 32K tokens, testing generalization well beyond the training context lengths (1k/4k/8k).",
      "source": "Section A.8, Figure 14"
    },
    {
      "id": "ngpt-D1-019",
      "claim": "nGPT introduces 6 additional trainable scaling parameter types beyond the baseline GPT: eigen learning rates (alpha_A, alpha_M) and scaling factors (s_qk, s_u, s_v, s_z). These are per-element or per-head vectors applied across all layers.",
      "source": "Section A.10"
    },
    {
      "id": "ngpt-D1-020",
      "claim": "Default analysis configuration for Section A.10 (scaling parameter distributions, Figure 15): context_length=1K, model_size=0.5B, learning_rate=2.0e-3, training_tokens=52B. Specific condition sweeps vary one parameter at a time.",
      "source": "Section A.10, Figure 15"
    },
    {
      "id": "ngpt-D1-021",
      "claim": "Per-step time cost: nGPT is approximately 80% slower than GPT at 4k context and 60% slower at 8k, due to 6 normalization steps per layer vs 2 in GPT. Removing QK normalization (Eq. 15-16) recovers ~12% speed with minor accuracy impact.",
      "source": "Section A.5; Section A.9, Table 6"
    }
  ],
  "D2": [
    {
      "id": "ngpt-D2-001",
      "claim": "Unit Vector Normalization (Norm): Norm(x) = x / ||x||_2",
      "source": "Section 2.2.2, Eq. 10-11 context"
    },
    {
      "id": "ngpt-D2-002",
      "claim": "Matrix Row-wise Normalization Along Embedding Dimension: For matrix M in R^{d_in x d_out}:\n  M[i,:] = M[i,:] / ||M[i,:]||_2  for each row i in [0, d_in)",
      "source": "Section 2.6, Step 2"
    },
    {
      "id": "ngpt-D2-003",
      "claim": "Forward Pass: Token Embedding Lookup (nGPT): x_embed_i = E_input[t_i,:]\nwhere each row of E_input is normalized: ||E_input[j,:]||_2 = 1",
      "source": "Section 2.1"
    },
    {
      "id": "ngpt-D2-004",
      "claim": "Logits Computation with Element-wise Scaling: z_i = E_output @ h_i\nz_i = z_i ⊙ s_z",
      "source": "Section 2.1, Eq. 1, Eq. 3"
    },
    {
      "id": "ngpt-D2-005",
      "claim": "Softmax Probability with Scaled Logits: P(y_i | x_1, ..., x_{i-1}) = exp(z_{i,y_i}) / sum_{v=1}^{V} exp(z_{i,v})",
      "source": "Section 2.1, Eq. 2"
    },
    {
      "id": "ngpt-D2-006",
      "claim": "Cross-Entropy Loss for Next-Token Prediction: L = -(1/T) * sum_{i=1}^{T} log(P(y_i | x_1, ..., x_{i-1}))\n  = -(1/T) * sum_{i=1}^{T} log(exp(z_{i,y_i}) / sum_v exp(z_{i,v}))",
      "source": "Section 2.1, Eq. 2 context"
    },
    {
      "id": "ngpt-D2-007",
      "claim": "nGPT Attention Block: Query/Key/Value Projection with Normalized Matrices: For each head i in [1, n_heads]:\n  q_i = h @ W_q^i\n  k_i = h @ W_k^i\n  v_i = h @ W_v^i\nwhere each row of W_q^i, W_k^i, W_v^i has unit L2 norm",
      "source": "Section 2.3.1, Eq. 12; Section 2.3.2"
    },
    {
      "id": "ngpt-D2-008",
      "claim": "Rotary Position Embedding (RoPE) Application: q_i = RoPE(q_i, pos)\nk_i = RoPE(k_i, pos)",
      "source": "Section 2.3.1"
    },
    {
      "id": "ngpt-D2-009",
      "claim": "nGPT Query/Key Normalization with Per-Head Scaling: For each head i:\n  q_i = Norm(q_i) ⊙ s_qk^i\n  k_i = Norm(k_i) ⊙ s_qk^i",
      "source": "Section 2.3.2, Eq. 15, Eq. 16"
    },
    {
      "id": "ngpt-D2-010",
      "claim": "nGPT Scaled Dot-Product Attention with Modified Scaling Factor: For each head i:\n  scores = (q_i @ k_i^T) * sqrt(d_k)\n  scores = scores + causal_mask\n  attn_i = softmax(scores) @ v_i",
      "source": "Section 2.3.1, Eq. 13; Section 2.3.2, Section 2.6 Step 4"
    },
    {
      "id": "ngpt-D2-011",
      "claim": "Multi-Head Attention Output Concatenation: h_A = Concat(head_1, head_2, ..., head_{n_heads}) @ W_o",
      "source": "Section 2.3.1, Eq. 14"
    },
    {
      "id": "ngpt-D2-012",
      "claim": "nGPT Attention Block Output Normalization: h_A_norm = Norm(h_A)",
      "source": "Section 2.2.2, Eq. 10 context; Table 1"
    },
    {
      "id": "ngpt-D2-013",
      "claim": "nGPT Hidden State Update: Attention Block (LERP with Eigen Learning Rates): h_A_norm = Norm(ATTN(h))\nh = h + alpha_A ⊙ (h_A_norm - h)\nh = Norm(h)",
      "source": "Section 2.2.2, Eq. 7, Eq. 9, Eq. 10; Table 1"
    },
    {
      "id": "ngpt-D2-014",
      "claim": "nGPT MLP Block: Up-Projections with Normalized Matrices: u = h @ W_u\nnu = h @ W_nu",
      "source": "Section 2.4.1, Eq. 17; Section 2.4.2"
    },
    {
      "id": "ngpt-D2-015",
      "claim": "nGPT MLP Intermediate State Rescaling: u = u ⊙ s_u\nnu = nu ⊙ s_nu * sqrt(d_model)",
      "source": "Section 2.4.2, Eq. 20, Eq. 21"
    },
    {
      "id": "ngpt-D2-016",
      "claim": "SwiGLU Activation: SiLU(nu) = nu ⊙ sigma(nu)\nSwiGLU(u, nu) = u ⊙ SiLU(nu)",
      "source": "Section 2.4.1, Eq. 18, Eq. 19"
    },
    {
      "id": "ngpt-D2-017",
      "claim": "nGPT MLP Output Projection: h_M = SwiGLU(u, nu) @ W_oMLP",
      "source": "Section 2.4.1, Eq. 19; Section 2.4.2"
    },
    {
      "id": "ngpt-D2-018",
      "claim": "nGPT MLP Block Output Normalization: h_M_norm = Norm(h_M)",
      "source": "Section 2.2.2, Eq. 11 context"
    },
    {
      "id": "ngpt-D2-019",
      "claim": "nGPT Hidden State Update: MLP Block (LERP with Eigen Learning Rates): h_M_norm = Norm(MLP(h))\nh = h + alpha_M ⊙ (h_M_norm - h)\nh = Norm(h)",
      "source": "Section 2.2.2, Eq. 11; Table 1"
    },
    {
      "id": "ngpt-D2-020",
      "claim": "nGPT Complete Layer Forward Pass: # Attention block\nh_A_norm = Norm(ATTN(h))\nh = Norm(h + alpha_A ⊙ (h_A_norm - h))\n\n# MLP block\nh_M_norm = Norm(MLP(h))\nh = Norm(h + alpha_M ⊙ (h_M_norm - h))",
      "source": "Section 2.2.2, Eq. 10-11; Section 2.6 Step 3"
    },
    {
      "id": "ngpt-D2-021",
      "claim": "Adam Optimizer Update (No Weight Decay, No Warmup): m = beta_1 * m + (1 - beta_1) * g\nv = beta_2 * v + (1 - beta_2) * g^2\ntheta = theta - alpha * m / (sqrt(v) + epsilon)",
      "source": "Section 2.5, Eq. 22-24; Table 3"
    },
    {
      "id": "ngpt-D2-022",
      "claim": "Effective Learning Rate Control via Init/Scale Parameter Trick: # During parameter initialization:\nparam_stored = s_{a,scale}\n\n# During forward pass:\nparam_actual = (s_{a,init} / s_{a,scale}) * param_stored\n\n# Effective learning rate relative to global LR:\neffective_LR_ratio = s_{a,scale} / s_{a,init}",
      "source": "Section 2.5"
    },
    {
      "id": "ngpt-D2-023",
      "claim": "nGPT Summary Recipe: Converting Baseline Transformer to nGPT: Step 1: Remove all RMSNorm / LayerNorm layers\nStep 2: After each training step, normalize all matrices along embedding dimension\n  (E_input, E_output, W_q, W_k, W_v, W_o, W_u, W_nu, W_oMLP)\nStep 3: Replace residual updates with LERP+NORM:\n  h = Norm(h + alpha_A ⊙ (Norm(ATTN(h)) - h))\n  h = Norm(h + alpha_M ⊙ (Norm(MLP(h)) - h))\nStep 4: Change softmax scaling from 1/sqrt(d_k) to sqrt(d_k); normalize q,k with per-head scaling s_qk\nStep 5: Rescale MLP intermediate states: u by s_u, nu by s_nu * sqrt(d_model)\nStep 6: Rescale logits element-wise by s_z\nStep 7: Remove weight decay and learning rate warmup",
      "source": "Section 2.6, Steps 1-7"
    },
    {
      "id": "ngpt-D2-024",
      "claim": "nGPT Parameter Initialization: For non-output matrices:  W ~ N(0, (1/sqrt(d_model))^2)\nFor output matrices:       W ~ N(0, (1/sqrt(d_model) * sqrt(2 * n_layers))^2)",
      "source": "Section A.6"
    },
    {
      "id": "ngpt-D2-025",
      "claim": "nGPT Full Training Loop: For each training step:\n  1. Forward pass (optional: normalize matrices before forward)\n     tokens = input_batch\n     h = Norm(E_input[tokens])  # embed + normalize\n     For layer in 1..n_layers:\n       h_A = Norm(ATTN(h))\n       h = Norm(h + alpha_A ⊙ (h_A - h))\n       h_M = Norm(MLP(h))\n       h = Norm(h + alpha_M ⊙ (h_M - h))\n  2. Compute cross-entropy loss on logits and backpropagate\n  3. Adam optimizer update (no weight decay, no warmup)\n  4. After step: normalize all matrices along embedding dimension",
      "source": "Section 2.6, Section A.6"
    }
  ],
  "D3": [
    {
      "id": "ngpt-D3-001",
      "claim": "Train GPT and nGPT (0.5B/1B) from scratch on OpenWebText at 1k/4k/8k context lengths with 64 A100 GPUs (batch_size=512). Compare against GPT baseline with best initial LR via validation loss curves (Figure 1-2), downstream task accuracy (Figure 3, 8-10), and convergence speed in tokens: nGPT achieves 4x/10x/20x speedup at 1k/4k/8k respectively.",
      "source": "Section 3.1, Figure 1, Figure 2, Figure 3; Section A.6, A.7"
    },
    {
      "id": "ngpt-D3-002",
      "claim": "Load GPT and nGPT checkpoints (0.5B/1B, 100k iters on OpenWebText). Extract and compare: (1) embedding vector norms, pairwise dot products, and eigenvalue distributions (Figure 4); (2) median condition numbers of attention and MLP matrices across all layers (Figure 5, Figure 11-13); (3) per-layer alpha_A/alpha_M, s_qk/s_u/s_nu/s_z distributions (Figure 6). For GPT, renormalize matrices post-training and recompute condition numbers to assess rank deficiency.",
      "source": "Section 3.2, Figure 4, Figure 5, Figure 6; Figure 11, Figure 12, Figure 13 (Appendix)"
    },
    {
      "id": "ngpt-D3-003",
      "claim": "Train 0.5B nGPT on OpenWebText (1k context, LR=1e-3, 100k iters, ~52B tokens). Enumerate s_init/s_scale combinations for s_qk, s_u/s_v, and s_z across multiple settings (Table 4). After training, record Mean(s) per distribution and evaluate final validation loss plus average accuracy on 5 downstream tasks. Compare each variant to the default initialization (s_init=1, corresponding scale) to quantify hyperparameter sensitivity.",
      "source": "Section A.9, Table 4"
    },
    {
      "id": "ngpt-D3-004",
      "claim": "Replace each per-element learnable vector (s_qk, s_u/s_v, s_z, alpha_A, alpha_M) with a single learnable scalar or fixed constant. Train 0.5B variants on OpenWebText (1k context, LR=1e-3, 100k iters). Evaluate validation loss and 5-task downstream accuracy vs the per-element baseline; most simplifications cause <=0.3% loss increase, indicating per-element vectors are not essential for performance.",
      "source": "Section A.9, Table 5"
    },
    {
      "id": "ngpt-D3-005",
      "claim": "Implement two nGPT architectural variants: (a) remove QK normalization from Eq. 15-16; (b) replace LERP (Eq. 7) with full SLERP (Eq. 6). Train 0.5B models on OpenWebText (1k context, LR=1e-3, 100k iters). Measure training time per step, validation loss, and 5-task downstream accuracy vs baseline nGPT. QK norm removal saves ~12% compute; SLERP adds ~10% overhead; both maintain comparable accuracy.",
      "source": "Section A.9, Table 6"
    },
    {
      "id": "ngpt-D3-006",
      "claim": "Train GPT, nGPT (with QK norm), and nGPT (without QK norm) on OpenWebText. Evaluate perplexity on PG19 dataset at context lengths from 1K to 32K tokens, far exceeding training context lengths. Compare perplexity curves across all variants: GPT perplexity rises sharply beyond training length; nGPT with QK norm maintains stable perplexity at extrapolated lengths, demonstrating superior length generalization.",
      "source": "Section A.8, Figure 14"
    },
    {
      "id": "ngpt-D3-007",
      "claim": "Collect nGPT checkpoints across varying conditions: context lengths (1K/4K/8K), model sizes (0.5B/1B), learning rates, and training token budgets (default: 1K ctx, 0.5B, LR=2e-3, 52B tokens). Extract per-layer alpha_A, alpha_M, s_qk, s_u, s_nu, s_z values; aggregate into condition-specific histograms (Figure 15). Analyze distribution shifts: eigen rates move right with longer contexts/larger models; s_qk is stable (high density near zero); s_z mean increases with context/size/tokens.",
      "source": "Section A.10, Figure 15"
    }
  ],
  "D4": [
    {
      "id": "ngpt-D4-001",
      "claim": "Experiment phases: 1. Initialize GPT and nGPT models with the same transformer backbone dimensions (identical n_layers, d_model, n_heads, d_MLP for both models). 2. Replicate weight initialization: N(0, 0.02^2) for GPT, N(0, 1/d_model) for nGPT. 3. For nGPT: normalize all matrices along the embedding dimension after initialization, set scaling factors s_init=1.0, s_scale=1/sqrt(d_model). 4. Train both models on OpenWebText at context lengths 1k (0.5B), 4k (1B), and 8k (1B) for 100k iterations. 5. For GPT: AdamW optimizer with weight_decay=0.1, warmup=2000 steps, cosine decay to 0. For nGPT: Adam optimizer with weight_decay=0.0, no warmup, cosine decay. 6. Measure: (a) training curves (loss vs iterations/tokens), (b) final validation loss at different token budgets, (c) convergence speedup factor (e.g., nGPT reaches GPT's 100k-iteration loss at 25k iterations = 4x speedup).",
      "source": "Section 3.1, Figure 1, Figure 2, Figure 3; Section A.6, A.7"
    },
    {
      "id": "ngpt-D4-002",
      "claim": "Experiment phases: 1. Load trained GPT and nGPT checkpoints (100k iterations). 2. Extract and compute norm of each embedding vector in E_input and E_output matrices. 3. Compute covariance matrix of embeddings, then perform SVD to obtain eigenvalues; compute condition number = lambda_max / lambda_min. 4. For each weight matrix W, compute eigen learning rates from the optimizer state and weight gradient statistics. 5. Compare GPT vs nGPT: (a) embedding norm distributions (nGPT embeddings are unit-norm by construction), (b) condition numbers of embedding covariance matrices, (c) eigen learning rate spectra across layers. 6. Plot distributions: norms (Figure 4), condition numbers (Figure 5), eigen learning rates (Figure 6). Key finding: nGPT eliminates the eigenvalue imbalance that causes uneven learning rates in GPT.",
      "source": "Section 3.2, Figure 4, Figure 5, Figure 6; Figure 11, Figure 12, Figure 13 (Appendix)"
    },
    {
      "id": "ngpt-D4-003",
      "claim": "Experiment phases: 1. For each scaling factor (s_qk, s_u/s_nu, s_z), enumerate combinations of s_init in {0.05, 0.1, 0.5, 1.0} and s_scale in {1, 1/sqrt(d_model)}. 2. Train each variant for 100k iterations. 3. After training, record Mean(s) for each scaling factor to check convergence behavior. 4. Evaluate final validation loss and downstream task accuracy across all initialization variants. 5. Compare against baseline (s_init=0.05, s_scale=1/sqrt(d_model)) to identify sensitivity of each initialization setting. Key finding: nGPT is robust to wide ranges of s_init and s_scale choices.",
      "source": "Section A.9, Table 4"
    },
    {
      "id": "ngpt-D4-004",
      "claim": "Experiment phases: 1. For each variant, replace the target per-element vector with a learnable scalar parameter (simplifying from vector to scalar per scaling factor). 2. Train each variant for 100k iterations using 0.5B model on OpenWebText at 1k context length with LR=1e-3 (ablation configuration per Section A.9). 3. After training, record final validation loss and compute degradation relative to per-element baseline. 4. Also test fixing scaling factors to constant values (s_qk=1, s_u=1, s_z=1) to test whether learning them is necessary. 5. Results: replacing per-element vectors with scalars or fixed values causes only negligible degradation (<=0.3% loss increase). Key finding: scalar scaling factors are sufficient, reducing parameter count.",
      "source": "Section A.9, Table 5"
    },
    {
      "id": "ngpt-D4-005",
      "claim": "Experiment phases: 1. Implement both variants: (a) remove QK normalization (use standard attention without normalizing Q,K), (b) replace LERP with SLERP for embedding interpolation. 2. Train each variant for 100k iterations. 3. Measure training time per step for each variant to quantify compute savings. 4. Evaluate final validation loss compared to full nGPT baseline. 5. Key finding: QK normalization can be removed for approximately 12% compute savings with minimal accuracy impact (within 0.2% of full nGPT validation loss).",
      "source": "Section A.9, Table 6"
    },
    {
      "id": "ngpt-D4-006",
      "claim": "Experiment phases: 1. Train GPT, nGPT (with QK norm), and nGPT (without QK norm) on OpenWebText at context length 1k. 2. For each trained model, evaluate perplexity on PG19 at context lengths 1k, 2k, 4k, 8k, 16k, 32k tokens (extrapolation beyond training length). 3. Plot perplexity vs context length curves for all three models. 4. Compare extrapolation behavior: (a) GPT perplexity dramatically increases beyond training length, (b) nGPT maintains stable perplexity at extrapolated lengths up to 32x training context. Key finding: nGPT's normalized representations provide inherent length generalization.",
      "source": "Section A.8, Figure 14"
    },
    {
      "id": "ngpt-D4-007",
      "claim": "Experiment phases: 1. Collect trained nGPT checkpoints spanning all condition variations (model sizes: 0.5B, 1B; context lengths: 1k, 4k, 8k). 2. For each checkpoint, extract all alpha_A, alpha_M, s_qk, s_u, s_nu, s_z values from the model parameters. 3. Aggregate into histograms showing distribution of learned scaling factors across layers and training conditions. 4. Analyze correlation between Mean(s) values and training conditions (model size, context length, token budget). 5. Key finding: scaling factors converge to stable distributions with lower means for longer contexts, larger models, and more tokens (corresponding to lower temperature / sharper distributions in the normalized hypersphere).",
      "source": "Section A.10, Figure 15"
    }
  ]
}