Upload folder using huggingface_hub

.gitattributes

@@ -59,3 +59,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 chebyshev_recurrence.pdf filter=lfs diff=lfs merge=lfs -text
+paper/chebyshev_recurrence.pdf filter=lfs diff=lfs merge=lfs -text

paper/chebyshev_recurrence.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05ae50b993f4ab0b5dbd5ed4d571ba426e198b2cb3491717e1c9d3d3f0b6b286
+size 212337

paper/chebyshev_recurrence.tex

@@ -0,0 +1,226 @@
+\documentclass[10pt,twocolumn]{article}
+\usepackage{amsmath,amssymb,amsthm}
+\usepackage{graphicx,booktabs}
+\usepackage[margin=1in]{geometry}
+\usepackage{hyperref}
+\newtheorem{proposition}{Proposition}
+
+\title{Attention as a Differential Operator:\\Optimal Polynomial Recurrence for Transformer Layers}
+
+\author{Yohann Bearzi\\Independent Researcher\\texttt{yohann.bearzi@icloud.fr}}
+
+\date{April 2026}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+We interpret transformer layers as steps in a multivariate polynomial iteration, where the residual stream approximates a target function on the input embedding and attention computes data-dependent directional derivatives at each step. Under this interpretation, the standard residual connection $h_{n+1} = h_n + f(h_n)$ corresponds to a first-order iterative scheme. We propose replacing it with a two-step Chebyshev recurrence $h_{n+1} = (1+\alpha)\,f(h_n) - \alpha\, h_{n-1}$, where $\alpha$ is a learnable scalar per layer. Chebyshev iteration is the optimal polynomial scheme for iterative approximation, producing corrections that are orthogonal in the Chebyshev inner product and avoiding the redundant recomputation inherent to one-step methods. In experiments on language modeling, a 12-layer model with Chebyshev recurrence (9.6M parameters) outperforms both a 12-layer standard model of equal size and a 24-layer standard model with twice the parameters. The modification is a one-line code change introducing one scalar per layer.
+\end{abstract}
+
+\section{Introduction}
+
+Transformers~\cite{vaswani2017attention} process sequences by passing an embedding through a stack of layers, each adding a correction via the residual connection:
+\begin{equation}
+    h_{n+1} = h_n + f_n(h_n, \mathcal{C})
+    \label{eq:standard}
+\end{equation}
+where $f_n$ represents the self-attention and feed-forward sub-layers, and $\mathcal{C}$ denotes the context (the full sequence of key-value pairs). The residual connection was introduced to facilitate gradient flow in deep networks~\cite{he2016deep} and has since been adopted universally. However, its optimality as an \emph{iteration scheme} has received little attention.
+
+We propose a mathematical interpretation of Equation~\ref{eq:standard}: each transformer layer evaluates a correction term in a polynomial expansion of a target function $g$ defined on the semantic manifold. The embedding $x$ is a point on this manifold, and successive layers refine the approximation $h_n \to g(x)$ by evaluating higher-order correction terms. Under this lens, the residual connection is a specific choice of polynomial iteration, and classical approximation theory provides strictly better alternatives.
+
+\section{Attention as a Differential Operator}
+
+\subsection{The Semantic Manifold}
+
+Let $\mathcal{M} \subset \mathbb{R}^d$ denote the manifold of semantic states, where $d$ is the hidden dimension. The embedding layer maps a token sequence to an initial point $h_0 = \text{embed}(x) \in \mathcal{M}$. The transformer computes a path on $\mathcal{M}$ from $h_0$ to a final state $h_L$ from which the output distribution is decoded.
+
+Each layer moves the state along a direction determined by the layer's parameters and the context:
+\begin{equation}
+    h_{n+1} = h_n + \Delta_n(h_n, \mathcal{C})
+\end{equation}
+where $\Delta_n$ is the total correction from attention and feed-forward sub-layers. This is a discrete dynamical system on $\mathcal{M}$, a perspective explored in the neural ODE literature~\cite{lu2018beyond,chen2018neural}.
+
+\subsection{Attention as Directional Derivative}
+
+Consider the self-attention mechanism at layer $n$. The query $Q = W_Q h_n$ and keys $K = W_K h_j$ for context positions $j$ yield attention weights:
+\begin{equation}
+    \alpha_{ij} = \text{softmax}\left(\frac{Q_i K_j^\top}{\sqrt{d_k}}\right)
+\end{equation}
+The attention output is a weighted combination of values: $\text{Attn}(h_n) = \sum_j \alpha_{ij} W_V h_j$.
+
+We observe that this operation has the structure of a \emph{directional derivative} on the semantic manifold. The query-key interaction $Q K^\top$ measures the rate of change of the current state's representation with respect to each context position. The softmax normalizes these into a probability distribution over directions. The value projection $W_V h_j$ provides the magnitude and direction of change along each context direction.
+
+In this interpretation:
+\begin{itemize}
+    \item \textbf{Keys} define a basis of directions on $\mathcal{M}$ at the current context.
+    \item \textbf{Query-key scores} compute the components of a directional derivative: how much does the current state need to change along each context direction?
+    \item \textbf{Values} provide the actual displacement vectors along those directions.
+    \item \textbf{Attention output} is the total differential: a linear combination of directional displacements, weighted by relevance.
+\end{itemize}
+
+The feed-forward network that follows attention applies a pointwise nonlinearity to the updated state, analogous to the composition of a polynomial correction with a nonlinear activation. Together, one transformer layer computes one step of iterative refinement: evaluating the next-order correction to the polynomial approximation of $g$.
+
+\subsection{The Residual Stream as Polynomial Expansion}
+
+Under this interpretation, the residual stream after $k$ layers contains:
+\begin{equation}
+    h_k = h_0 + \sum_{n=0}^{k-1} \Delta_n
+\end{equation}
+where each $\Delta_n$ is a correction term that depends on the current state and context. If the corrections are well-ordered, this sum approximates a polynomial expansion of the target function $g$:
+\begin{equation}
+    g(x) \approx h_0 + \Delta_0 + \Delta_1 + \cdots + \Delta_{k-1}
+\end{equation}
+with each $\Delta_n$ corresponding to a term of increasing polynomial degree in the attention-derived coordinates. The attention mechanism provides \emph{data-dependent coefficients} for this expansion: the same polynomial basis is reweighted differently for each input and context.
+
+\section{Optimal Polynomial Iteration}
+
+\subsection{Limitations of One-Step Recurrence}
+
+The standard residual connection (Equation~\ref{eq:standard}) is a one-step method: the correction at layer $n+1$ depends only on $h_n$. In the language of iterative approximation, this corresponds to \emph{monomial iteration}, where each new term is computed without reference to earlier terms.
+
+One-step methods suffer from a fundamental limitation: successive corrections are generally not orthogonal. The correction $\Delta_{n+1}$ may partially overlap with $\Delta_n$, meaning that layer $n+1$ spends some of its capacity re-deriving information already present in $h_n$ rather than adding genuinely new information. In deep networks, this redundancy compounds: later layers increasingly fight against the accumulated interference from earlier layers.
+
+\subsection{Chebyshev Recurrence}
+
+The Chebyshev polynomials $T_n(x)$ satisfy the three-term recurrence:
+\begin{equation}
+    T_{n+1}(x) = 2x\, T_n(x) - T_{n-1}(x)
+\end{equation}
+with $T_0(x) = 1$ and $T_1(x) = x$. This recurrence produces a sequence of polynomials that are orthogonal on $[-1,1]$ under the weight $(1-x^2)^{-1/2}$. Crucially, each $T_{n+1}$ is guaranteed to capture information not present in any $T_m$ for $m \leq n$.
+
+Chebyshev polynomials are optimal for polynomial approximation in the minimax sense: among all degree-$n$ polynomials, the Chebyshev expansion minimizes the maximum approximation error~\cite{trefethen2019approximation}. This optimality is a direct consequence of the orthogonality of the basis.
+
+We propose replacing the standard one-step residual with a two-step Chebyshev recurrence:
+\begin{equation}
+    h_{n+1} = (1 + \alpha_n)\, f(h_n) - \alpha_n\, h_{n-1}
+    \label{eq:chebyshev}
+\end{equation}
+where $f(h_n)$ is the standard transformer layer output (including the residual: $f(h_n) = h_n + \text{Attn}(h_n) + \text{MLP}(h_n)$), and $\alpha_n$ is a learnable scalar per layer. The recurrence requires storing the previous layer's output $h_{n-1}$ alongside the current $h_n$, at a memory cost of $2\times$ the hidden dimension per layer.
+
+\begin{proposition}
+When $\alpha_n = 0$, Equation~\ref{eq:chebyshev} reduces to the standard residual connection. The parameter $\alpha_n$ controls the interpolation between one-step (standard) and two-step (Chebyshev) iteration, allowing the network to learn the optimal recurrence during training.
+\end{proposition}
+
+The key property of the two-step recurrence is that the correction $h_{n+1} - h_n$ is made orthogonal to $h_n - h_{n-1}$ by the subtraction of $\alpha_n h_{n-1}$. This prevents layer $n+1$ from redundantly recomputing the correction already applied by layer $n$, directing all of its capacity toward genuinely new information.
+
+\section{Multivariate Extension}
+
+In practice, $h_n \in \mathbb{R}^d$ for large $d$ (typically 768--8192), and the approximation is multivariate. The Chebyshev framework extends naturally to this setting.
+
+Consider projecting $h_n$ into a lower-dimensional coordinate system via the attention mechanism. At each layer, the query-key interaction selects a set of relevant directions, and the value projection computes displacements along those directions. The attention operation can be viewed as evaluating a multivariate polynomial in these data-dependent coordinates, with the Chebyshev recurrence ensuring orthogonality of corrections across layers.
+
+The recursive structure of attention---where each layer's queries are functions of the previous layer's output---means that layer $n$ computes degree-$n$ interactions between the input and context. The standard residual accumulates these as a sum, while the Chebyshev recurrence accumulates them as an orthogonal expansion. The multivariate Chebyshev polynomials maintain their orthogonality properties under tensor-product construction, ensuring that the benefits of the two-step recurrence extend to the high-dimensional setting.
+
+\section{Experiments}
+
+We evaluate the Chebyshev recurrence on byte-level language modeling using the Shakespeare corpus (1M training tokens, 110K validation tokens). Three models are compared:
+
+\begin{enumerate}
+    \item \textbf{Chebyshev-12L}: 12 layers with the two-step recurrence (Equation~\ref{eq:chebyshev}), hidden dimension 256, 8 attention heads, 9.6M parameters.
+    \item \textbf{Standard-12L}: 12 layers with the standard residual, same architecture, 9.6M parameters.
+    \item \textbf{Standard-24L}: 24 layers with the standard residual, same hidden dimension, 19.1M parameters.
+\end{enumerate}
+
+All models use AdamW optimization with learning rate $3 \times 10^{-4}$ and cosine schedule, batch size 32, sequence length 128, and are trained for 5000 steps on an Apple M3 Ultra GPU (MPS backend). The learnable $\alpha_n$ is initialized such that $\sigma(\alpha_n) = 0.5$.
+
+\begin{table}[h]
+\centering
+\begin{tabular}{lccc}
+\toprule
+Model & Params & Layers & Val Loss \\
+\midrule
+Chebyshev-12L & 9.6M & 12 & \textbf{1.2292} \\
+Standard-12L & 9.6M & 12 & 1.2503 \\
+Standard-24L & 19.1M & 24 & 1.2816 \\
+\bottomrule
+\end{tabular}
+\caption{Final validation loss (cross-entropy, lower is better) after 5000 steps. The 12-layer Chebyshev model outperforms a 24-layer standard model with twice the parameter count.}
+\label{tab:results}
+\end{table}
+
+\begin{table}[h]
+\centering
+\begin{tabular}{lccc}
+\toprule
+Model & Step 1000 & Step 2500 & Step 5000 \\
+\midrule
+Chebyshev-12L & 1.5804 & 1.3034 & \textbf{1.2292} \\
+Standard-12L & 1.7029 & 1.3328 & 1.2503 \\
+Standard-24L & 1.5779 & 1.3357 & 1.2816 \\
+\bottomrule
+\end{tabular}
+\caption{Convergence at selected training steps. The Chebyshev model converges faster than both baselines throughout training. Note that the 24-layer model matches Chebyshev early (step 1000) due to its larger capacity, but falls behind as training progresses.}
+\label{tab:convergence}
+\end{table}
+
+Two observations are noteworthy. First, the Chebyshev model outperforms a model with twice its depth and twice its parameter count, suggesting that the orthogonality of corrections is more valuable than raw capacity. Second, the 24-layer standard model performs \emph{worse} than the 12-layer standard model despite its additional parameters, consistent with the hypothesis that non-orthogonal corrections become increasingly counterproductive with depth.
+
+\subsection{Implementation}
+
+The modification to a standard transformer block is minimal:
+
+\begin{verbatim}
+# Standard transformer block
+def forward(self, h):
+    h = h + self.attn(self.ln1(h))
+    h = h + self.mlp(self.ln2(h))
+    return h
+
+# Chebyshev transformer block
+def forward(self, h, h_prev):
+    f_h = h + self.attn(self.ln1(h))
+    f_h = f_h + self.mlp(self.ln2(f_h))
+    a = torch.sigmoid(self.alpha)
+    h_new = (1 + a) * f_h - a * h_prev
+    return h_new
+\end{verbatim}
+
+The total number of additional parameters is one scalar per layer (12 scalars for a 12-layer model). The additional memory cost is one copy of the hidden state per layer during the forward pass.
+
+\section{Discussion}
+
+\subsection{Why Deeper Is Not Always Better}
+
+The observation that the 24-layer standard model underperforms the 12-layer standard model deserves comment. Under the polynomial iteration interpretation, each additional layer adds a correction term. If successive corrections are not orthogonal, later layers partially undo the work of earlier layers. The net effect is that some fraction of each layer's capacity is wasted on redundant computation. As depth increases, this fraction grows, and eventually the overhead of computing non-orthogonal corrections exceeds the benefit of the additional polynomial terms.
+
+The Chebyshev recurrence avoids this failure mode by construction. The subtraction of $\alpha_n h_{n-1}$ explicitly removes the component of the new correction that lies along the previous correction, ensuring that each layer contributes genuinely new information.
+
+\subsection{Attention as Coefficient Selection}
+
+In a classical polynomial expansion $g(x) = \sum_n c_n P_n(x)$, the coefficients $c_n$ are fixed. In the transformer, the attention mechanism computes \emph{data-dependent} coefficients: the same polynomial basis is reweighted for each input. This is analogous to adaptive quadrature methods, where the evaluation points are chosen based on the local behavior of the integrand.
+
+The Chebyshev recurrence does not constrain the attention mechanism. It only changes the accumulation scheme for the corrections. Attention remains free to compute arbitrary data-dependent coefficients; the recurrence ensures that however those coefficients are chosen, the resulting corrections are accumulated optimally.
+
+\section{Related Work}
+
+The neural ODE perspective~\cite{lu2018beyond,chen2018neural} interprets residual networks as Euler discretizations of continuous dynamics, motivating higher-order numerical solvers (Runge-Kutta, etc.). Our work is complementary: we focus on the optimality of the \emph{polynomial basis} rather than the \emph{numerical integration scheme}. DenseNet~\cite{huang2017densely} connects each layer to all previous layers, providing a richer history at the cost of quadratic memory growth. Our approach achieves a similar benefit with constant overhead by retaining only the immediately previous state. Highway networks~\cite{srivastava2015highway} introduce learned gating but remain one-step methods without the orthogonality guarantee.
+
+\section{Future Work}
+
+Several directions merit investigation:
+
+\textbf{Scale.} Our experiments are at 9.6M parameters. Validating the Chebyshev recurrence at scales of 1B--100B parameters on standard benchmarks is essential to establish practical relevance. We hypothesize that the benefits increase with depth, as the correction orthogonality becomes more critical when many layers are composed.
+
+\textbf{Higher-order recurrences.} The Chebyshev recurrence is a two-step method. Three-step and higher-order recurrences exist in approximation theory and may yield further improvements, at the cost of storing additional previous states.
+
+\textbf{Minimum depth analysis.} If transformer layers approximate a function on a rank-$r$ latent manifold, there may exist a fundamental lower bound on the depth required to achieve a given approximation accuracy. The relationship between this bound and the spectral structure of the layer-to-layer transition operators is an open question with implications for architecture design.
+
+\textbf{Interaction with existing optimizations.} The Chebyshev recurrence is orthogonal to most transformer optimizations (FlashAttention, quantization, mixture-of-experts, etc.) and can be combined with them. Testing these combinations is straightforward.
+
+\section{Conclusion}
+
+We have proposed interpreting transformer layers as steps in a polynomial iteration, with attention acting as a differential operator that computes data-dependent coefficients for successive correction terms. Under this interpretation, the standard residual connection corresponds to a suboptimal one-step iteration, and the Chebyshev recurrence provides a principled, optimal alternative. The resulting modification is a single line of code that introduces one learnable parameter per layer, yet outperforms doubling both depth and parameter count in our experiments. We hope this perspective encourages further investigation of classical approximation theory as a design principle for deep network architectures.
+
+\bibliographystyle{plain}
+\begin{thebibliography}{9}
+\bibitem{vaswani2017attention} A.~Vaswani, N.~Shazeer, N.~Parmar, et al. Attention is all you need. In \emph{NeurIPS}, 2017.
+\bibitem{he2016deep} K.~He, X.~Zhang, S.~Ren, J.~Sun. Deep residual learning for image recognition. In \emph{CVPR}, 2016.
+\bibitem{lu2018beyond} Y.~Lu, A.~Zhong, Q.~Li, B.~Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In \emph{ICML}, 2018.
+\bibitem{chen2018neural} R.~T.~Q.~Chen, Y.~Rubanova, J.~Bettencourt, D.~Duvenaud. Neural ordinary differential equations. In \emph{NeurIPS}, 2018.
+\bibitem{trefethen2019approximation} L.~N.~Trefethen. \emph{Approximation Theory and Approximation Practice, Extended Edition}. SIAM, 2019.
+\bibitem{huang2017densely} G.~Huang, Z.~Liu, L.~van~der~Maaten, K.~Weinberger. Densely connected convolutional networks. In \emph{CVPR}, 2017.
+\bibitem{srivastava2015highway} R.~K.~Srivastava, K.~Greff, J.~Schmidhuber. Highway networks. \emph{arXiv:1505.00387}, 2015.
+\end{thebibliography}
+
+\end{document}

results/donkey_cheb_train_results.json

@@ -0,0 +1,275 @@
+{
+  "Chebyshev-12L": {
+    "val_losses": [
+      [
+        250,
+        2.365417790412903
+      ],
+      [
+        500,
+        1.9846193730831145
+      ],
+      [
+        750,
+        1.7468639135360717
+      ],
+      [
+        1000,
+        1.5804362773895264
+      ],
+      [
+        1250,
+        1.4742767989635468
+      ],
+      [
+        1500,
+        1.4266556739807128
+      ],
+      [
+        1750,
+        1.3843169629573822
+      ],
+      [
+        2000,
+        1.3425058484077455
+      ],
+      [
+        2250,
+        1.3104813039302825
+      ],
+      [
+        2500,
+        1.3033863246440887
+      ],
+      [
+        2750,
+        1.2860036849975587
+      ],
+      [
+        3000,
+        1.2682552695274354
+      ],
+      [
+        3250,
+        1.2595621347427368
+      ],
+      [
+        3500,
+        1.2432881414890289
+      ],
+      [
+        3750,
+        1.231383314728737
+      ],
+      [
+        4000,
+        1.2404769599437713
+      ],
+      [
+        4250,
+        1.2348330944776535
+      ],
+      [
+        4500,
+        1.2278451561927795
+      ],
+      [
+        4750,
+        1.229588133096695
+      ],
+      [
+        5000,
+        1.2292243212461471
+      ],
+      [
+        5000,
+        1.2292243212461471
+      ]
+    ],
+    "params": 9641484,
+    "final_val": 1.2292243212461471,
+    "time": 2601.129471416003
+  },
+  "Standard-12L": {
+    "val_losses": [
+      [
+        250,
+        2.4192636370658875
+      ],
+      [
+        500,
+        2.06381493806839
+      ],
+      [
+        750,
+        1.8055346131324768
+      ],
+      [
+        1000,
+        1.702851164340973
+      ],
+      [
+        1250,
+        1.5899994254112244
+      ],
+      [
+        1500,
+        1.5235492527484893
+      ],
+      [
+        1750,
+        1.4614094197750092
+      ],
+      [
+        2000,
+        1.3821907043457031
+      ],
+      [
+        2250,
+        1.3698437213897705
+      ],
+      [
+        2500,
+        1.3328281044960022
+      ],
+      [
+        2750,
+        1.3114042282104492
+      ],
+      [
+        3000,
+        1.287459284067154
+      ],
+      [
+        3250,
+        1.2749922394752502
+      ],
+      [
+        3500,
+        1.2675541579723357
+      ],
+      [
+        3750,
+        1.2560759782791138
+      ],
+      [
+        4000,
+        1.2546918630599975
+      ],
+      [
+        4250,
+        1.2559677243232727
+      ],
+      [
+        4500,
+        1.2516333222389222
+      ],
+      [
+        4750,
+        1.2499989986419677
+      ],
+      [
+        5000,
+        1.250289112329483
+      ],
+      [
+        5000,
+        1.250289112329483
+      ]
+    ],
+    "params": 9641472,
+    "final_val": 1.250289112329483,
+    "time": 2573.005341000011
+  },
+  "Standard-24L": {
+    "val_losses": [
+      [
+        250,
+        2.364856517314911
+      ],
+      [
+        500,
+        2.040120780467987
+      ],
+      [
+        750,
+        1.829410570859909
+      ],
+      [
+        1000,
+        1.5779212236404419
+      ],
+      [
+        1250,
+        1.5099454760551452
+      ],
+      [
+        1500,
+        1.4451186597347259
+      ],
+      [
+        1750,
+        1.3749538242816925
+      ],
+      [
+        2000,
+        1.3269383549690246
+      ],
+      [
+        2250,
+        1.3013200283050537
+      ],
+      [
+        2500,
+        1.335706877708435
+      ],
+      [
+        2750,
+        1.3094253063201904
+      ],
+      [
+        3000,
+        1.2781172037124633
+      ],
+      [
+        3250,
+        1.2676625847816467
+      ],
+      [
+        3500,
+        1.2795695602893828
+      ],
+      [
+        3750,
+        1.2769544780254365
+      ],
+      [
+        4000,
+        1.2716370105743409
+      ],
+      [
+        4250,
+        1.2744707822799684
+      ],
+      [
+        4500,
+        1.2819348394870758
+      ],
+      [
+        4750,
+        1.2833851873874664
+      ],
+      [
+        5000,
+        1.2815939962863923
+      ],
+      [
+        5000,
+        1.2815939962863923
+      ]
+    ],
+    "params": 19118592,
+    "final_val": 1.2815939962863923,
+    "time": 4897.041712999984
+  }
+}

results/training_log.txt

@@ -0,0 +1,95 @@
+Downloading Shakespeare...
+Data: 1003854 train, 111540 val tokens
+============================================================
+CHEBYSHEV vs STANDARD TRANSFORMER COMPARISON
+============================================================
+Shallow: 12 layers, hidden=256, heads=8
+Deep:    24 layers, hidden=256, heads=8
+Steps: 5000, Batch: 32, Seq: 128
+
+Chebyshev-12L: 9641484 params (9.64M), 12 layers
+  step 250/5000: train=2.3511 val=2.3654 (145s)
+  step 500/5000: train=1.9344 val=1.9846 (274s)
+  step 750/5000: train=1.6930 val=1.7469 (404s)
+  step 1000/5000: train=1.5707 val=1.5804 (533s)
+  step 1250/5000: train=1.4908 val=1.4743 (662s)
+  step 1500/5000: train=1.4340 val=1.4267 (791s)
+  step 1750/5000: train=1.3905 val=1.3843 (920s)
+  step 2000/5000: train=1.3480 val=1.3425 (1049s)
+  step 2250/5000: train=1.3110 val=1.3105 (1178s)
+  step 2500/5000: train=1.2854 val=1.3034 (1307s)
+  step 2750/5000: train=1.2581 val=1.2860 (1436s)
+  step 3000/5000: train=1.2342 val=1.2683 (1565s)
+  step 3250/5000: train=1.2179 val=1.2596 (1694s)
+  step 3500/5000: train=1.1888 val=1.2433 (1823s)
+  step 3750/5000: train=1.1685 val=1.2314 (1952s)
+  step 4000/5000: train=1.1564 val=1.2405 (2082s)
+  step 4250/5000: train=1.1466 val=1.2348 (2211s)
+  step 4500/5000: train=1.1412 val=1.2278 (2340s)
+  step 4750/5000: train=1.1350 val=1.2296 (2469s)
+  step 5000/5000: train=1.1386 val=1.2292 (2598s)
+  FINAL: val=1.2292, 2601s, 1.9 steps/s
+
+Standard-12L: 9641472 params (9.64M), 12 layers
+  step 250/5000: train=2.3792 val=2.4193 (123s)
+  step 500/5000: train=2.0078 val=2.0638 (246s)
+  step 750/5000: train=1.7663 val=1.8055 (369s)
+  step 1000/5000: train=1.6264 val=1.7029 (492s)
+  step 1250/5000: train=1.5415 val=1.5900 (615s)
+  step 1500/5000: train=1.4701 val=1.5235 (738s)
+  step 1750/5000: train=1.4292 val=1.4614 (861s)
+  step 2000/5000: train=1.3892 val=1.3822 (1012s)
+  step 2250/5000: train=1.3535 val=1.3698 (1167s)
+  step 2500/5000: train=1.3200 val=1.3328 (1318s)
+  step 2750/5000: train=1.2926 val=1.3114 (1443s)
+  step 3000/5000: train=1.2713 val=1.2875 (1568s)
+  step 3250/5000: train=1.2538 val=1.2750 (1694s)
+  step 3500/5000: train=1.2300 val=1.2676 (1819s)
+  step 3750/5000: train=1.2119 val=1.2561 (1944s)
+  step 4000/5000: train=1.2007 val=1.2547 (2069s)
+  step 4250/5000: train=1.1999 val=1.2560 (2194s)
+  step 4500/5000: train=1.1837 val=1.2516 (2320s)
+  step 4750/5000: train=1.1822 val=1.2500 (2445s)
+  step 5000/5000: train=1.1750 val=1.2503 (2570s)
+  FINAL: val=1.2503, 2573s, 1.9 steps/s
+
+Standard-24L: 19118592 params (19.12M), 24 layers
+  step 250/5000: train=2.3544 val=2.3649 (244s)
+  step 500/5000: train=1.9416 val=2.0401 (489s)
+  step 750/5000: train=1.6889 val=1.8294 (733s)
+  step 1000/5000: train=1.5616 val=1.5779 (978s)
+  step 1250/5000: train=1.4744 val=1.5099 (1222s)
+  step 1500/5000: train=1.3983 val=1.4451 (1467s)
+  step 1750/5000: train=1.3586 val=1.3750 (1712s)
+  step 2000/5000: train=1.3188 val=1.3269 (1956s)
+  step 2250/5000: train=1.2807 val=1.3013 (2201s)
+  step 2500/5000: train=1.2436 val=1.3357 (2445s)
+  step 2750/5000: train=1.2033 val=1.3094 (2690s)
+  step 3000/5000: train=1.1768 val=1.2781 (2934s)
+  step 3250/5000: train=1.1452 val=1.2677 (3179s)
+  step 3500/5000: train=1.1156 val=1.2796 (3424s)
+  step 3750/5000: train=1.0903 val=1.2770 (3668s)
+  step 4000/5000: train=1.0697 val=1.2716 (3913s)
+  step 4250/5000: train=1.0503 val=1.2745 (4158s)
+  step 4500/5000: train=1.0383 val=1.2819 (4402s)
+  step 4750/5000: train=1.0322 val=1.2834 (4647s)
+  step 5000/5000: train=1.0321 val=1.2816 (4891s)
+  FINAL: val=1.2816, 4897s, 1.0 steps/s
+
+============================================================
+RESULTS
+============================================================
+Model                  Params Layers  Final Val       Time
+----------------------------------------------------------
+Chebyshev-12L         9641484     12     1.2292     2601s
+Standard-12L          9641472     12     1.2503     2573s
+Standard-24L         19118592     24     1.2816     4897s
+
+Convergence:
+Model                 Step 1000  Step 2500  Step 5000
+----------------------------------------------------
+Chebyshev-12L            1.5804     1.3034     1.2292
+Standard-12L             1.7029     1.3328     1.2503
+Standard-24L             1.5779     1.3357     1.2816
+
+Saved to /tmp/donkey_cheb_train_results.json

scripts/cheb_transformer_train.py

@@ -0,0 +1,295 @@
+"""Train 3 transformers to compare convergence:
+  1. Chebyshev residual (shallow, 12 layers)
+  2. Standard residual (shallow, 12 layers)  
+  3. Standard residual (deep, 24 layers, same params via smaller hidden)
+
+All trained on same data, same compute budget.
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+import math, time, json, os
+import numpy as np
+
+DEVICE = "mps"  # Apple Silicon
+SEED = 42
+torch.manual_seed(SEED)
+np.random.seed(SEED)
+
+# === Config ===
+VOCAB = 256  # byte-level for simplicity
+SEQ_LEN = 128
+BATCH = 32
+HIDDEN = 256
+HEADS = 8
+HEAD_DIM = HIDDEN // HEADS
+N_STEPS = 5000
+LR = 3e-4
+EVAL_EVERY = 250
+
+# === Dataset: Shakespeare byte-level ===
+class ByteDataset(Dataset):
+    def __init__(self, data, seq_len):
+        self.data = data
+        self.seq_len = seq_len
+    def __len__(self):
+        return len(self.data) - self.seq_len - 1
+    def __getitem__(self, idx):
+        x = self.data[idx:idx+self.seq_len]
+        y = self.data[idx+1:idx+self.seq_len+1]
+        return torch.tensor(x, dtype=torch.long), torch.tensor(y, dtype=torch.long)
+
+# Download Shakespeare
+DATA_PATH = "/tmp/shakespeare.txt"
+if not os.path.exists(DATA_PATH):
+    print("Downloading Shakespeare...", flush=True)
+    import urllib.request
+    url = "https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt"
+    urllib.request.urlretrieve(url, DATA_PATH)
+
+with open(DATA_PATH, "rb") as f:
+    raw = list(f.read())
+split = int(len(raw) * 0.9)
+train_data = raw[:split]
+val_data = raw[split:]
+train_ds = ByteDataset(train_data, SEQ_LEN)
+val_ds = ByteDataset(val_data, SEQ_LEN)
+train_dl = DataLoader(train_ds, batch_size=BATCH, shuffle=True, drop_last=True)
+val_dl = DataLoader(val_ds, batch_size=BATCH, shuffle=False, drop_last=True)
+print("Data: %d train, %d val tokens" % (len(train_data), len(val_data)), flush=True)
+
+# === Attention block ===
+class CausalSelfAttention(nn.Module):
+    def __init__(self, hidden, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = hidden // heads
+        self.qkv = nn.Linear(hidden, 3 * hidden)
+        self.out = nn.Linear(hidden, hidden)
+    def forward(self, x):
+        B, T, C = x.shape
+        qkv = self.qkv(x).reshape(B, T, 3, self.heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        att = (q @ k.transpose(-2, -1)) * (self.head_dim ** -0.5)
+        mask = torch.triu(torch.ones(T, T, device=x.device, dtype=torch.bool), diagonal=1)
+        att = att.masked_fill(mask, float("-inf"))
+        att = F.softmax(att, dim=-1)
+        out = (att @ v).transpose(1, 2).reshape(B, T, C)
+        return self.out(out)
+
+# === MLP ===
+class MLP(nn.Module):
+    def __init__(self, hidden):
+        super().__init__()
+        self.fc1 = nn.Linear(hidden, 4 * hidden)
+        self.fc2 = nn.Linear(4 * hidden, hidden)
+    def forward(self, x):
+        return self.fc2(F.gelu(self.fc1(x)))
+
+# === Standard Transformer Block ===
+class StandardBlock(nn.Module):
+    def __init__(self, hidden, heads):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(hidden)
+        self.attn = CausalSelfAttention(hidden, heads)
+        self.ln2 = nn.LayerNorm(hidden)
+        self.mlp = MLP(hidden)
+    def forward(self, x):
+        x = x + self.attn(self.ln1(x))
+        x = x + self.mlp(self.ln2(x))
+        return x
+
+# === Chebyshev Transformer Block ===
+class ChebyshevBlock(nn.Module):
+    """Two-step Chebyshev recurrence: h_{n+1} = 2*f(h_n) - h_{n-1}"""
+    def __init__(self, hidden, heads):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(hidden)
+        self.attn = CausalSelfAttention(hidden, heads)
+        self.ln2 = nn.LayerNorm(hidden)
+        self.mlp = MLP(hidden)
+        # Learnable mixing coefficient (starts at standard residual)
+        self.alpha = nn.Parameter(torch.tensor(0.5))
+    def forward(self, x, x_prev):
+        # Compute layer output
+        f_x = x + self.attn(self.ln1(x))
+        f_x = f_x + self.mlp(self.ln2(f_x))
+        # Chebyshev recurrence: blend between standard and two-step
+        # alpha=0.5 -> standard residual, alpha=1.0 -> full Chebyshev
+        alpha = torch.sigmoid(self.alpha)
+        h_new = (1 + alpha) * f_x - alpha * x_prev
+        return h_new
+
+# === Full Models ===
+class StandardTransformer(nn.Module):
+    def __init__(self, vocab, hidden, heads, n_layers):
+        super().__init__()
+        self.embed = nn.Embedding(vocab, hidden)
+        self.pos = nn.Embedding(SEQ_LEN, hidden)
+        self.blocks = nn.ModuleList([StandardBlock(hidden, heads) for _ in range(n_layers)])
+        self.ln_f = nn.LayerNorm(hidden)
+        self.head = nn.Linear(hidden, vocab, bias=False)
+        self.n_layers = n_layers
+    def forward(self, x):
+        B, T = x.shape
+        h = self.embed(x) + self.pos(torch.arange(T, device=x.device))
+        for block in self.blocks:
+            h = block(h)
+        return self.head(self.ln_f(h))
+
+class ChebyshevTransformer(nn.Module):
+    def __init__(self, vocab, hidden, heads, n_layers):
+        super().__init__()
+        self.embed = nn.Embedding(vocab, hidden)
+        self.pos = nn.Embedding(SEQ_LEN, hidden)
+        self.blocks = nn.ModuleList([ChebyshevBlock(hidden, heads) for _ in range(n_layers)])
+        self.ln_f = nn.LayerNorm(hidden)
+        self.head = nn.Linear(hidden, vocab, bias=False)
+        self.n_layers = n_layers
+    def forward(self, x):
+        B, T = x.shape
+        h = self.embed(x) + self.pos(torch.arange(T, device=x.device))
+        h_prev = h.clone()  # initial h_{-1} = h_0
+        for block in self.blocks:
+            h_new = block(h, h_prev)
+            h_prev = h
+            h = h_new
+        return self.head(self.ln_f(h))
+
+# === Training ===
+def count_params(model):
+    return sum(p.numel() for p in model.parameters())
+
+def evaluate(model, dl):
+    model.eval()
+    total_loss = 0
+    n = 0
+    with torch.no_grad():
+        for xb, yb in dl:
+            xb, yb = xb.to(DEVICE), yb.to(DEVICE)
+            logits = model(xb)
+            loss = F.cross_entropy(logits.view(-1, VOCAB), yb.view(-1))
+            total_loss += loss.item()
+            n += 1
+            if n >= 20:
+                break
+    model.train()
+    return total_loss / n
+
+def train_model(name, model):
+    model = model.to(DEVICE)
+    params = count_params(model)
+    print("\n%s: %d params (%.2fM), %d layers" % (name, params, params/1e6, model.n_layers), flush=True)
+
+    opt = torch.optim.AdamW(model.parameters(), lr=LR)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(opt, N_STEPS)
+
+    losses = []
+    val_losses = []
+    step = 0
+    t0 = time.perf_counter()
+
+    while step < N_STEPS:
+        for xb, yb in train_dl:
+            if step >= N_STEPS:
+                break
+            xb, yb = xb.to(DEVICE), yb.to(DEVICE)
+            logits = model(xb)
+            loss = F.cross_entropy(logits.view(-1, VOCAB), yb.view(-1))
+            opt.zero_grad()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            opt.step()
+            scheduler.step()
+            losses.append(loss.item())
+            step += 1
+
+            if step % EVAL_EVERY == 0:
+                vl = evaluate(model, val_dl)
+                val_losses.append((step, vl))
+                elapsed = time.perf_counter() - t0
+                print("  step %d/%d: train=%.4f val=%.4f (%.0fs)" % (
+                    step, N_STEPS, np.mean(losses[-100:]), vl, elapsed), flush=True)
+
+    # Final eval
+    vl = evaluate(model, val_dl)
+    val_losses.append((step, vl))
+    elapsed = time.perf_counter() - t0
+    print("  FINAL: val=%.4f, %.0fs, %.1f steps/s" % (vl, elapsed, N_STEPS/elapsed), flush=True)
+
+    return {
+        "name": name,
+        "params": params,
+        "layers": model.n_layers,
+        "train_losses": losses,
+        "val_losses": val_losses,
+        "time": elapsed,
+        "final_val": vl,
+    }
+
+# === Deep standard: SAME hidden, MORE params (2x layers = ~2x params) ===
+HIDDEN_DEEP = HIDDEN  # same width
+HEADS_DEEP = HEADS    # same heads
+
+print("=" * 60, flush=True)
+print("CHEBYSHEV vs STANDARD TRANSFORMER COMPARISON", flush=True)
+print("=" * 60, flush=True)
+print("Shallow: %d layers, hidden=%d, heads=%d" % (12, HIDDEN, HEADS), flush=True)
+print("Deep:    %d layers, hidden=%d, heads=%d" % (24, HIDDEN_DEEP, HEADS_DEEP), flush=True)
+print("Steps: %d, Batch: %d, Seq: %d" % (N_STEPS, BATCH, SEQ_LEN), flush=True)
+
+# Run all 3
+results = []
+
+# 1. Chebyshev shallow
+model1 = ChebyshevTransformer(VOCAB, HIDDEN, HEADS, 12)
+r1 = train_model("Chebyshev-12L", model1)
+results.append(r1)
+del model1
+torch.mps.empty_cache() if hasattr(torch.mps, 'empty_cache') else None
+
+# 2. Standard shallow
+model2 = StandardTransformer(VOCAB, HIDDEN, HEADS, 12)
+r2 = train_model("Standard-12L", model2)
+results.append(r2)
+del model2
+torch.mps.empty_cache() if hasattr(torch.mps, 'empty_cache') else None
+
+# 3. Standard deep (matched params)
+model3 = StandardTransformer(VOCAB, HIDDEN_DEEP, HEADS_DEEP, 24)
+r3 = train_model("Standard-24L", model3)
+results.append(r3)
+del model3
+
+# === Summary ===
+print("\n" + "=" * 60, flush=True)
+print("RESULTS", flush=True)
+print("=" * 60, flush=True)
+print("%-20s %8s %6s %10s %10s" % ("Model", "Params", "Layers", "Final Val", "Time"), flush=True)
+print("-" * 58, flush=True)
+for r in results:
+    print("%-20s %8d %6d %10.4f %8.0fs" % (r["name"], r["params"], r["layers"], r["final_val"], r["time"]), flush=True)
+
+# Convergence comparison: val loss at step 1000, 2500, 5000
+print("\nConvergence:", flush=True)
+print("%-20s %10s %10s %10s" % ("Model", "Step 1000", "Step 2500", "Step 5000"), flush=True)
+print("-" * 52, flush=True)
+for r in results:
+    vals = dict(r["val_losses"])
+    v1k = vals.get(1000, vals.get(750, "N/A"))
+    v25k = vals.get(2500, "N/A")
+    v5k = vals.get(5000, vals.get(4750, "N/A"))
+    print("%-20s %10s %10s %10s" % (
+        r["name"],
+        "%.4f" % v1k if isinstance(v1k, float) else v1k,
+        "%.4f" % v25k if isinstance(v25k, float) else v25k,
+        "%.4f" % v5k if isinstance(v5k, float) else v5k,
+    ), flush=True)
+
+# Save results
+save = {r["name"]: {"val_losses": r["val_losses"], "params": r["params"],
+                      "final_val": r["final_val"], "time": r["time"]} for r in results}
+with open("/tmp/donkey_cheb_train_results.json", "w") as f:
+    json.dump(save, f, indent=2)
+print("\nSaved to /tmp/donkey_cheb_train_results.json", flush=True)