@@ -33,6 +33,10 @@
                    the learning rate schedule as a table
 =================  ============================================
 
+As in nanoGPT, the model and the loss are separate. The model is the
+view ``logits``; the loss is SQL that reads it, as nanoGPT's
+``F.cross_entropy`` reads the model's logits.
+
 Each training step updates every parameter table with its own
 statement; the statements share one backward pass. By default the
 optimizer is SGD at a fixed learning rate, the simplest step to read.
@@ -226,42 +230,60 @@ def block(layer: int, x: str, out: str) -> str:
 
 
 def model() -> str:
-    """The CTEs of the whole model, ending in ``loss``: the mean
-    cross-entropy of predicting each next character of the batch."""
+    """The model, as the view ``logits``: for each position of each
+    sequence in ``batch``, a score for every character that could come
+    next. A DataFusion view reads the tables that existed when it was
+    created (DuckDB's looks them up by name), so it is recreated whenever
+    the batch or the parameters are."""
     blocks = "".join(
         block(layer, f"x{layer}", f"x{layer + 1}") for layer in range(LAYERS)
     )
     return f"""
-x0 AS (
+CREATE OR REPLACE VIEW logits AS
+WITH x0 AS (
   SELECT b.seq, b.pos, te.e, te.w + pe.w AS val
   FROM batch b
   JOIN wte te ON b.tok = te.tok
   JOIN wpe pe ON b.pos = pe.pos AND te.e = pe.e),
 {blocks}
-{layer_norm(f"x{LAYERS}", "final", "ln_f")}
-logits AS (
-  SELECT x.seq, x.pos, te.tok, SUM(x.val * te.w) AS val
-  FROM final x JOIN wte te ON x.e = te.e
-  GROUP BY x.seq, x.pos, te.tok),
+{layer_norm(f"x{LAYERS}", "final", "ln_f").rstrip(",")}
+SELECT x.seq, x.pos, te.tok, SUM(x.val * te.w) AS val
+FROM final x JOIN wte te ON x.e = te.e
+GROUP BY x.seq, x.pos, te.tok
+"""
+
+
+# The loss, separate from the model, as in nanoGPT: the mean cross-entropy
+# of the model's logits against each next character of the batch.
+# TODO(xqlsystems/ddx#142): remove ddx_stop_gradient from the window MAX
+# once ddx can differentiate a window aggregate. The max only keeps exp()
+# from overflowing, and cancels out of the log-sum-exp, so its gradient is
+# zero.
+#
+# The loss reads the model's view once, into the CTE ``predicted``, and
+# uses that twice: a host expands a view at every read, but DuckDB
+# computes a CTE that is read twice only once.
+LOSS = """
+predicted AS (
+  SELECT seq, pos, tok, val FROM logits),
 shifted AS (
-  -- TODO(xqlsystems/ddx#142): as in the attention weights above.
   SELECT seq, pos, tok, val,
          ddx_stop_gradient(MAX(val) OVER (PARTITION BY seq, pos)) AS m
-  FROM logits),
+  FROM predicted),
 log_sum_exp AS (
   SELECT seq, pos, MAX(m) + ln(SUM(exp(val - m))) AS lse
   FROM shifted GROUP BY seq, pos),
 loss AS (
   SELECT AVG(s.lse - l.val) AS l
   FROM log_sum_exp s
   JOIN batch b ON s.seq = b.seq AND s.pos = b.pos
-  JOIN logits l ON l.seq = b.seq AND l.pos = b.pos AND l.tok = b.next)"""
+  JOIN predicted l ON l.seq = b.seq AND l.pos = b.pos AND l.tok = b.next)"""
 
 
 def step_statements(lr: float) -> list[str]:
     """One SGD step: each parameter table's next version, as a statement."""
     return [
-        f"WITH {model()} SELECT {', '.join(dims)}, "
+        f"WITH {LOSS} SELECT {', '.join(dims)}, "
         f"w - {lr} * grad(loss, w) AS w FROM {table} "
         f"ORDER BY {', '.join(dims)}"
         for table, dims in PARAMS.items()
@@ -273,7 +295,7 @@ def gradient_statements() -> list[str]:
     the table ``{name}_grad``'s rows. The statements share one backward
     pass."""
     return [
-        f"WITH {model()} SELECT {', '.join(dims)}, grad(loss, w) AS g "
+        f"WITH {LOSS} SELECT {', '.join(dims)}, grad(loss, w) AS g "
         f"FROM {table} ORDER BY {', '.join(dims)}"
         for table, dims in PARAMS.items()
     ]
@@ -316,7 +338,7 @@ def adamw_statement(table: str, step: int) -> str:
 
 
 def loss_statement() -> str:
-    return f"WITH {model()} SELECT l FROM loss"
+    return f"WITH {LOSS} SELECT l FROM loss"
 
 
 # --------------------------------------------------------------------------
@@ -492,7 +514,7 @@ def main():
     report = Report("nanogpt", "batch", args.reps)
     text = shakespeare()
     vocab = len(set(text))
-    lines = len(loss_statement().splitlines())
+    lines = len(model().splitlines()) + len(loss_statement().splitlines())
     count = sum(
         v.size for v in init_params(vocab, np.random.default_rng(0)).values()
     )
@@ -521,6 +543,7 @@ def main():
 
             for step, batch in data:
                 host.load("batch", batch)
+                host.execute(model())
                 tok, nxt = batch["tok"].values, batch["next"].values
 
                 rows = report.time(
 
@@ -18,7 +18,7 @@ array programs.
 | # | Script | Model | What it measures |
 |---|---|---|---|
 | 01 | [`01_attention.py`](01_attention.py) | causal softmax attention, the core of a transformer, as a view (the model) in einfold's window and `GROUP BY` spellings, and a loss that reads it | the naive plan, which stores every score, for [FlashAttention](https://arxiv.org/abs/2205.14135)'s tiled plan to beat; gradients with respect to Q, K and V; masked pairs as absent rows; a control that isn't attention, the Nadaraya–Watson kernel average |
-| 02 | [`02_nanogpt.py`](02_nanogpt.py) | [nanoGPT](https://github.com/karpathy/nanoGPT)'s GPT-2 model, at 1 layer and 4,416 parameters, on Tiny Shakespeare | the loss on each host; training steps with SGD or, as nanoGPT trains, AdamW, every parameter table checked after every step |
+| 02 | [`02_nanogpt.py`](02_nanogpt.py) | [nanoGPT](https://github.com/karpathy/nanoGPT)'s GPT-2 model, at 1 layer and 4,416 parameters, as a view, and a cross-entropy loss that reads it, on Tiny Shakespeare | the loss on each host; training steps with SGD or, as nanoGPT trains, AdamW, every parameter table checked after every step |
 | 03 | [`03_graphcast.py`](03_graphcast.py) | a miniature [GraphCast](https://arxiv.org/abs/2212.12794), DeepMind's graph neural network for weather forecasting, over [ERA5](https://www.ecmwf.int/en/forecasts/dataset/ecmwf-reanalysis-v5) reanalysis in Zarr | a global against a regional forecast; the gradient of the forecast error; the receptive field of a region |
 
 The SQL favors legibility over speed. Each model reads like its definition,