Add Lecture 4 discrete diffusion and Lecture 5 discrete flow matching

Add complete CPU training and generation examples for seven diffusion and guidance methods and eight flow methods. Include synthetic DNA, mathematical checks, slide links, and recorded example outputs. Update the course index and setup instructions.

README.md

@@ -32,13 +32,16 @@ and implementation notes; additional directories will accompany later lectures.
 | --- | --- | --- |
 | 2 | Unconditional MNIST image generation with flow matching and a simple U-Net | [Guide](lecture_2/README.md) · [Script](lecture_2/flow_matching_unet_lecture.py) · [Saved checkpoint](https://huggingface.co/ChatterjeeLab/CIS6270/resolve/main/lecture_2/flow_unet_mnist.pt?download=true) |
 | 3 | Flow matching, diffusion, and guidance for ESM-2 residue embeddings | [Guide](lecture_3/README.md) · [Flow matching](lecture_3/esm2_flow_guidance.py) · [Diffusion](lecture_3/esm2_diffusion_guidance.py) |
+| 4 | Discrete diffusion, masked and uniform corruption, block generation, and guidance | [Guide](lecture_4/README.md) · [Training and generation](lecture_4/run.py) · [Slide code map](lecture_4/SLIDE_CODE_MAP.md) |
+| 5 | Discrete flow matching, Dirichlet and Fisher paths, Gumbel-Softmax, rectification, and multi-objective generation | [Guide](lecture_5/README.md) · [Training and generation](lecture_5/run.py) · [Slide code map](lecture_5/SLIDE_CODE_MAP.md) |
 
 ## Installation
 
 Use Python 3.11, or another compatible Python version at least 3.10, in a new
 virtual environment. The shared `requirements.txt` pins PyTorch 2.9.1,
 TorchVision 0.24.1, and Transformers 4.57.6. Lecture 2 uses PyTorch and
-TorchVision; Lecture 3 also uses Transformers.
+TorchVision; Lecture 3 also uses Transformers. Lectures 4 and 5 use PyTorch,
+NumPy, and SciPy. Their lecture folders also provide minimal requirements.
 
 ```bash
 git clone https://huggingface.co/ChatterjeeLab/CIS6270
@@ -102,6 +105,45 @@ The [lecture guide](lecture_3/README.md) describes the data format, training
 and sampling settings, property calculations, normalization, and residue-count
 constraint, with commands for using a custom dataset.
 
+## Lecture 4 - Discrete diffusion
+
+Train small DNA denoisers and generate sequences with MDLM, UDLM, block diffusion,
+classifier-free guidance, exact and gradient-based classifier guidance, and a
+PepTune-style search. The [guide](lecture_4/README.md) includes each method's
+command and mathematical assumptions. The [code map](lecture_4/SLIDE_CODE_MAP.md)
+links the slide walkthroughs to their functions.
+
+From the repository root, run the complete MDLM example.
+
+```bash
+python lecture_4/run.py --method mdlm --data lecture_4/data/dna_train.tsv --out lecture_4/outputs/mdlm
+python lecture_4/run.py --method mdlm --mode sample --out lecture_4/outputs/mdlm
+```
+
+The script trains, saves a checkpoint, and writes generated DNA and loss logs.
+The bundled data are synthetic, and the guidance objectives are explicit toy
+properties. No pretrained model or external dataset is required.
+
+## Lecture 5 - Discrete flow matching
+
+Start with Gat et al.'s discrete flow matching, then run Dirichlet, Fisher,
+Gumbel-Softmax, rectified flow, ReDi, MOG-DFM, and AReUReDi examples. Each method
+has a complete training and generation command in the [guide](lecture_5/README.md).
+
+```bash
+python lecture_5/run.py --method gat --data lecture_5/data/dna_train.tsv --out lecture_5/outputs/gat
+python lecture_5/run.py --method gat --mode sample --out lecture_5/outputs/gat
+```
+
+The current [Discrete Generation slide deck](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit)
+contains both lectures. Diffusion code through PepTune belongs to Lecture 4.
+Classic DFM and the subsequent flow methods belong to Lecture 5. The code maps
+use stable slide links, so added transition slides do not break the mapping.
+
+Both folders include numerical examples, mathematical tests, and saved results
+from seeded CPU runs. The guides explain finite endpoint approximations and
+classroom simplifications for each method.
+
 ## Repository organization
 
 | Location | Contents |
@@ -109,6 +151,8 @@ constraint, with commands for using a custom dataset.
 | Repository root | Course index, installation requirements, and license |
 | [`lecture_2/`](https://huggingface.co/ChatterjeeLab/CIS6270/tree/main/lecture_2) | One MNIST flow-matching script, guide, trained checkpoint, and selected example images |
 | [`lecture_3/`](https://huggingface.co/ChatterjeeLab/CIS6270/tree/main/lecture_3) | ESM-2 flow and diffusion guidance scripts, sequence data, guide, and mathematical notes |
+| [`lecture_4/`](https://huggingface.co/ChatterjeeLab/CIS6270/tree/main/lecture_4) | Seven discrete diffusion and guidance examples, synthetic DNA, slide code map, and verified outputs |
+| [`lecture_5/`](https://huggingface.co/ChatterjeeLab/CIS6270/tree/main/lecture_5) | Eight discrete and simplex flow examples, synthetic DNA, slide code map, and verified outputs |
 | [`tests/`](https://huggingface.co/ChatterjeeLab/CIS6270/tree/main/tests) | Offline checks for the Lecture 3 examples |
 
 Installation instructions and the lecture index are maintained at the
@@ -119,11 +163,18 @@ references accompany the corresponding code.
 
 ```bash
 python -m unittest discover -s tests -v
+python -m unittest discover -s lecture_4/tests -v
+python -m unittest discover -s lecture_5/tests -v
 ```
 
 The Lecture 3 unit tests cover property annotations, scalarization weights, reward
 gradients, DDPM schedule indexing, and constrained decoding.
 
+Lecture 4 tests check reverse KL losses and guidance calculations. Lecture 5
+tests check the master equation, Fisher geometry, Gumbel path derivatives, and
+MH detailed balance. Run a short end-to-end check of every method from its
+lecture folder with `python run_all.py --quick`.
+
 ## License
 
 The repository code is distributed under the

lecture_4/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+.venv/
+outputs/
+*.pt
+.pytest_cache/

lecture_4/README.md

@@ -0,0 +1,85 @@
+# CIS 6270 - Lecture 4 - Discrete Diffusion
+
+Course hub: [ChatterjeeLab/CIS6270 on Hugging Face](https://huggingface.co/ChatterjeeLab/CIS6270).
+
+Complete CPU training and generation examples for the code walkthroughs in the [Discrete Generation lecture](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit). This folder ends with PepTune. Classic discrete flow matching and the later methods are in [Lecture 5](../lecture_5/README.md).
+
+These are small, inspectable implementations of the mathematical mechanisms. The DNA data and two objective functions are synthetic. They are not benchmark reproductions or biological property predictors.
+
+## Start with the complete MDLM example
+
+Python 3.11 or later, CPU. No downloaded data or pretrained checkpoint is required.
+
+From the course repository root, enter this lecture folder.
+
+```bash
+cd lecture_4
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+python run.py --method mdlm --data data/dna_train.tsv --out outputs/mdlm
+```
+
+This command loads the DNA examples, reserves the final 20% for validation, trains a transformer denoiser, writes a checkpoint, and generates new sequences. Each output folder contains `config.json`, `losses.json`, `report.json`, `samples.txt`, and `checkpoint.pt`.
+
+Inspect `data/dna_train.tsv` before training. `label=1` means GC fraction at least 0.6. It is a deterministic toy label, not measured activity. Omitting `--data` generates synthetic examples at `--length`.
+
+```bash
+# Continue with the saved weights for generation only.
+python run.py --method mdlm --mode sample --out outputs/mdlm
+# An entire small experiment using the four-base vocabulary.
+python examples/mdlm.py --length 4 --train-steps 160 --samples 8
+# Run every method, or a short CPU integration check.
+python run_all.py
+python run_all.py --quick
+python -m unittest discover -s tests -v
+python numerical_examples.py
+```
+
+For `--mode sample`, use the same `--method`, `--width`, and `--length` as the checkpoint. Checkpoints contain model weights and metadata; they do not contain optimizer state for resuming optimization.
+
+## One shared backbone; small method changes
+
+`lecture_core.py` contains the functions shown in the slides. `common.py` contains data, optimization, and output utilities. `diffusion.py` adds the complete samplers and guidance/search loops that make those modules runnable. `run.py` connects training to generation. Each file under `examples/` is a complete command-line entry point for one method and accepts the same options.
+
+| Example | Training target | Generation procedure |
+| --- | --- | --- |
+| `mdlm` | Weighted cross-entropy at masked positions | Schedule-based reveals; preserve visible bases |
+| `udlm` | Reverse-rate KL including the staying term | Adaptive reverse Euler; visible bases may be revised |
+| `block` | Conditional masked loss on a sampled block, scaled by block count | Finish each block before extending the sequence |
+| `cfg` / `classifier-free` | Label-conditioned MDLM with 15% label dropout | Geometric conditional/unconditional prediction blend |
+| `classifier-exact` | MDLM plus a classifier trained on noisy sequences | Evaluate every replacement's log-value change and multiply rates |
+| `classifier-gradient` | Same denoiser and noisy classifier | Approximate replacement log-value changes with one-hot gradients |
+| `peptune` | MDLM backbone | MCTS selection, expansion, completion, Pareto rewards, and reward backup |
+
+```bash
+python examples/udlm.py --out outputs/udlm
+python examples/block.py --block-size 2
+python examples/cfg.py --label 1 --strength 2
+python examples/classifier_exact.py --classifier-steps 300
+python examples/classifier_gradient.py --classifier-steps 300
+python examples/peptune.py --search-steps 100
+```
+
+MDLM and block losses sum over positions, then average over sequences. The uniform method uses the slide's linear schedule and integrates its training loss over `t in [0.02, 0.98]`; uniform initialization at 0.98 and stopping at 0.02 approximate the ideal endpoints. The output retains residual corruption. We do not reinterpret the UDLM parameter vector as a clean-token posterior for a final resampling step. The classifier-guided sampler uses adaptive steps to keep outgoing probabilities valid, then closes any residual masks at `t=0.005`. These finite endpoint conventions are reported in the outputs.
+
+CFG here is a categorical prediction blend. It is not asserted to equal geometric mixing of every possible rate parameterization. Classifier guidance is approximate because the classifier is learned; the gradient version also approximates finite edit differences. `strength=0` recovers the unguided rate multiplier in the classifier routines.
+
+The block implementation omits future blocks from the input entirely. This is a transparent teaching alternative to a full block-causal attention mask and KV-cache implementation. Training prefixes are clean; generation prefixes are sampled.
+
+The PepTune example uses the search mechanism on DNA. Every A/C/G/T sequence is valid, so there is no invalid-SMILES penalty. Peptide tokenization, bond-dependent schedules, chemical validity, RoFormer pretraining, and the paper's biological predictors are outside this toy example. Its archive is the non-dominated subset of evaluated DNA candidates; it is not a global Pareto certificate.
+
+## Read the math next to the implementation
+
+The tests verify the masked reverse KL cancellation, the small-step UDLM KL limit, the numerical CFG example, and the classifier directional derivative. `numerical_examples.py` prints corruption, training-loss, and generation-step calculations from the slides. `SLIDE_CODE_MAP.md` maps every Lecture 4 code unit to its function.
+
+The seeded example runs in `verified_examples/` record actual CPU results. Losses from different objectives are not directly comparable; one Monte Carlo validation draw is not a perplexity estimate. Sampling quality should be assessed with more seeds and longer training if extending these examples.
+
+## Sources
+
+- [MDLM - Simple and Effective Masked Diffusion Language Models](https://arxiv.org/abs/2406.07524)
+- [UDLM - Simple Guidance Mechanisms for Discrete Diffusion Models](https://arxiv.org/abs/2412.10193)
+- [Block Diffusion](https://arxiv.org/abs/2503.09573)
+- [PepTune](https://arxiv.org/abs/2412.17780)
+
+The source papers define the full research methods and experiments. Comments identify the classroom simplifications.

lecture_4/SLIDE_CODE_MAP.md

@@ -0,0 +1,21 @@
+# Code walkthrough map
+
+Function names are stable even if the combined deck is later split or reordered. Each method has a full training and sampling command in the README.
+
+| Slide unit | Code | Location |
+| --- | --- | --- |
+| [Code for the four-letter vocabulary](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u141_s5) | `complete experiment` | `lecture_core.py` |
+| [Code for a small shared DNA network](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u142_s6) | `DNA` | `lecture_core.py` |
+| [Code for the network forward pass](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u143_s5) | `forward` | `lecture_core.py` |
+| [Code for one cross-entropy per DNA position](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u144_s3) | `token_ce` | `lecture_core.py` |
+| [Code for MDLM training loss](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u145_s10) | `mdlm_loss` | `lecture_core.py` |
+| [Code for one reusable optimization step](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u146_s8) | `train_step` | `lecture_core.py` |
+| [Code for sample each categorical DNA vector](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u147_s5) | `draw` | `lecture_core.py` |
+| [Code for MDLM generation](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u148_s13) | `mdlm_sample` | `lecture_core.py` |
+| [Code for UDLM reverse rates](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u149_s7) | `udlm_rates` | `lecture_core.py` |
+| [Code for the continuous UDLM loss](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u150_s10) | `udlm_loss` | `lecture_core.py` |
+| [Code for train one conditional DNA block](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u151_s9) | `block_loss` | `lecture_core.py` |
+| [Code for classifier-free categorical guidance](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u152_s5) | `geometric_cfg` | `lecture_core.py` |
+| [Code for predictor guidance as a rate multiplier](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u153_s4) | `guide_rates` | `lecture_core.py` |
+| [Code for preserve non-dominated DNA candidates](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u154_s6) | `pareto_filter` | `lecture_core.py` |
+| [Code for run a complete MDLM experiment](https://docs.google.com/presentation/d/1qcPdF4SYTq4VdTN_5w9GjviLRPr2HFtbuYMpbfLrc_M/edit#slide=id.cis4r2_u180_s6) | `complete experiment` | `lecture_core.py` and `run.py` |

lecture_4/common.py

@@ -0,0 +1,134 @@
+"""CPU teaching utilities shared by the two lecture folders."""
+import csv
+import json
+import random
+from pathlib import Path
+import numpy as np
+import torch
+from torch import nn
+from lecture_core import DNA, K, MASK, encode
+
+
+def seed_all(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.set_num_threads(1)
+
+
+def decode(tokens):
+    alphabet = 'ACGTm'
+    return [''.join(alphabet[int(i)] for i in row) for row in tokens]
+
+
+def make_data(count=512, length=8, seed=7):
+    """Four synthetic motif families, with independent 8% base mutations."""
+    rng = np.random.default_rng(seed)
+    motifs = ['ACGT', 'CGTA', 'TATA', 'GCGC']
+    strings, labels = [], []
+    for _ in range(count):
+        motif = motifs[int(rng.integers(4))]
+        seq = list((motif * ((length + 3) // 4))[:length])
+        for j in range(length):
+            if rng.random() < .08:
+                seq[j] = 'ACGT'[int(rng.integers(4))]
+        strings.append(''.join(seq))
+        labels.append(int(sum(x in 'GC' for x in seq) / length >= .6))
+    return encode(strings), torch.tensor(labels)
+
+
+def load_data(path, length):
+    if path is None:
+        return make_data(length=length)
+    with open(path) as f:
+        rows = list(csv.DictReader(f, delimiter='\t'))
+    strings = [r['sequence'].strip().upper() for r in rows]
+    if not strings or any(len(s) != length or set(s) - set('ACGT') for s in strings):
+        raise ValueError('All DNA sequences must contain only A/C/G/T and have --length bases.')
+    labels = [int(r.get('label', sum(c in 'GC' for c in s) / length >= .6))
+              for r, s in zip(rows, strings)]
+    if set(labels) - {0, 1}:
+        raise ValueError('Labels must be 0 or 1.')
+    return encode(strings), torch.tensor(labels)
+
+
+class ConditionalDNA(DNA):
+    """The slide network plus a label embedding; label 2 means unconditional."""
+    def __init__(self, width=32, max_len=64):
+        super().__init__(width, max_len)
+        self.condition = nn.Embedding(3, width)
+
+    def forward(self, z, t=None, label=None):
+        h = self.token(z) if z.ndim == 2 else self.soft(z)
+        pos = torch.arange(z.shape[1], device=z.device)
+        h = h + self.position(pos)[None]
+        if t is not None:
+            h = h + self.time(t[:, None])[:, None]
+        if label is None:
+            label = torch.full((len(z),), 2, dtype=torch.long, device=z.device)
+        h = h + self.condition(label)[:, None]
+        return self.output(self.context(h))
+
+
+def objectives(tokens):
+    """Both toy objectives are maximized: GC fraction and ATAT agreement."""
+    onehot = torch.nn.functional.one_hot(tokens.long(), 4).float()
+    return soft_objectives(onehot)
+
+
+def soft_objectives(z):
+    gc = (z[..., 1] + z[..., 2]).mean(-1)
+    motif = torch.tensor([0, 3], device=z.device).repeat((z.shape[1] + 1) // 2)[:z.shape[1]]
+    match = z.gather(-1, motif[None, :, None].expand(z.shape[0], -1, 1)).squeeze(-1).mean(-1)
+    return torch.stack((gc, match), -1)
+
+
+def metrics(tokens):
+    strings = decode(tokens)
+    score = objectives(tokens).mean(0)
+    return dict(valid_dna=all(set(s) <= set('ACGT') for s in strings),
+                unique_fraction=len(set(strings)) / len(strings),
+                mean_gc=float(score[0]), mean_atat_match=float(score[1]))
+
+
+def save_run(out, config, losses, samples, extra=None):
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    (out / ('sample_config.json' if config.get('mode') == 'sample' else 'config.json')).write_text(json.dumps(config, indent=2))
+    if losses or not (out / 'losses.json').exists():
+        (out / 'losses.json').write_text(json.dumps(losses, indent=2))
+    (out / 'samples.txt').write_text('\n'.join(decode(samples)) + '\n')
+    report = {'metrics': metrics(samples), **(extra or {})}
+    (out / 'report.json').write_text(json.dumps(report, indent=2))
+    print(json.dumps({'output': str(out), **report}, indent=2))
+    return report
+
+
+def optimize(model, loss_fn, data, steps, batch_size=32, lr=.002):
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    losses = []
+    model.train()
+    for step in range(steps):
+        idx = torch.randint(len(data), (batch_size,))
+        optimizer.zero_grad(set_to_none=True)
+        loss = loss_fn(model, data[idx], idx)
+        if not torch.isfinite(loss):
+            raise FloatingPointError(f'Nonfinite loss at step {step}')
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.)
+        optimizer.step()
+        losses.append(float(loss.detach()))
+    model.eval()
+    return losses
+
+
+def project_simplex(z, eps=1e-6):
+    """Euclidean simplex projection, followed by a small interior floor."""
+    sorted_z = z.sort(-1, descending=True).values
+    cssv = sorted_z.cumsum(-1) - 1.
+    k = torch.arange(1, z.shape[-1] + 1, dtype=z.dtype, device=z.device)
+    active = sorted_z - cssv / k > 0
+    rho = active.sum(-1, keepdim=True).clamp_min(1)
+    theta = cssv.gather(-1, rho - 1) / rho
+    result = (z - theta).clamp_min(eps)
+    return result / result.sum(-1, keepdim=True)

lecture_4/data/README.md

@@ -0,0 +1 @@
+Synthetic teaching DNA only. Each eight-base sequence begins as two copies of ACGT, CGTA, TATA, or GCGC, then each base is replaced independently with probability 0.08. Seed 7. Label 1 means GC fraction >= 0.6. These labels are not measured biological activity. The CLI also generates length-adjusted data when --data is omitted.

lecture_4/data/dna_train.tsv

@@ -0,0 +1,257 @@
+sequence	label
+TAAACTTA	0
+ACGCTCCC	1
+CGTACGTA	0
+ACGTACGT	0
+CGTACGTA	0
+ACGTAAGT	0
+TATAAATA	0
+ACGTACGT	0
+GCGCGCGC	1
+GCGCGCGC	1
+TATATACA	0
+ACGTACGT	0
+ACGTACGT	0
+ACGCGCGC	1
+TCTATATA	0
+GCGCGCGC	1
+CGTACGTA	0
+ACGTACGT	0
+CGTACGTA	0
+GAGCGCGC	1
+TATATATA	0
+ACGTACGT	0
+GCGCGCGC	1
+ACGTACGT	0
+GCGCACGC	1
+CGTACGTA	0
+GGTACGTA	0
+CTTACGTA	0
+ACGTACGT	0
+AATATATA	0
+CGTACGTA	0
+TATATATA	0
+GCGCGCGC	1
+GCGCGCGC	1
+GCGCTCGC	1
+TCTATCTA	0
+GCGCGCGC	1
+CAAATATA	0
+TCGCGCGC	1
+ACGTACGT	0
+AAGTACGT	0
+GCGCGCGC	1
+CGCGCTTA	1
+TACATATA	0
+TATATATA	0
+CGTACGTA	0
+ACGTACGT	0
+GCGTGCGC	1
+ACGTACCT	0
+ACATACAT	0
+ATGGACGT	0
+GCGCGCGC	1
+TATAAATA	0
+CGTACGTA	0
+ATTTACGA	0
+CGTACGTA	0
+GCACGCGC	1
+GCGCGCGC	1
+TTTATATA	0
+ACGTACGT	0
+GCGCGCGT	1
+GCGCGCGC	1
+TATATATA	0
+CTTACGTA	0
+CGTACGTA	0
+GCGCGCGC	1
+CGTACGTA	0
+TGTTCGTA	0
+ACGTACCT	0
+ACGTACGC	1
+GCGCGCGC	1
+CTTATGTA	0
+CGTGCGTG	1
+ACGTACGT	0
+GCGCCCAC	1
+CGTACGTC	1
+TATATATA	0
+GGGCGCGC	1
+TATATATA	0
+TCGCGCGC	1
+ACGTACGT	0
+TATATCTA	0
+GCGCGCGC	1
+TATATATC	0
+GCACGCGC	1
+ACGTACGT	0
+CGTACGTA	0
+TATATATA	0
+CGTACGTA	0
+GGGCGCGC	1
+TAGATATA	0
+CGTACATA	0
+ACGTACGT	0
+TAGAGATA	0
+ACGTACGT	0
+ACGTACGT	0
+TATATATA	0
+ACTTACGT	0
+CGTACCTA	0
+CGTACGTA	0
+GCGCGCGC	1
+GCTCGCGC	1
+GGGCGCCC	1
+TATATATA	0
+ACGTACGT	0
+ACGTACGT	0
+GCGCCCGC	1
+TATATATA	0
+ACGTACGT	0
+TATAGATA	0
+TATATATT	0
+CAGACGTA	0
+CGTACGTA	0
+CGTAGGTA	0
+GCACGACC	1
+CGTACGAA	0
+GTGCGCGC	1
+CGTACGTA	0
+TATATATA	0
+CGTACGTA	0
+GCACGCGC	1
+ACATACGA	0
+CGTAGGTA	0
+ACGTACAT	0
+TATATATA	0
+GATATATA	0
+ACGTACGT	0
+TCTAGATA	0
+CGTACGTA	0
+CGTACGTA	0
+TATATATA	0
+GCGCGCGC	1
+ACGTACGT	0
+TATATATA	0
+CGTACGTA	0
+ACGTACGT	0
+ACGTTCGT	0
+TATATATA	0
+GCGCGCGC	1
+ACGTACGT	0
+TATATATA	0
+ACGCACGT	1
+ACGTGCGT	1
+CGTACGTA	0
+GTGCGCGC	1
+GCGCGCGC	1
+CGTACGTA	0
+GCGCGCGC	1
+TATATATA	0
+GCGCGCGC	1
+CGTACGTA	0
+CGTACGTA	0
+ACGTACGT	0
+GCGCGCGC	1
+CGTACGTA	0
+GCGCGGGA	1
+TATATATA	0
+ACGTACGT	0
+ACGTACGT	0
+GCGCGCGT	1
+ACTTACGT	0
+CGTACGTA	0
+ACGTACGT	0
+TAAATAAA	0
+GCGTGCGC	1
+GCGCGCAC	1
+ACGTACGT	0
+TATATATA	0
+TAAATATA	0
+CGTACGTA	0
+ACGTACGT	0
+TGTACATA	0
+CGTACGGA	1
+CGTCCGTA	1
+GCGCGCGC	1
+ACGTACGT	0
+TATATATA	0
+CGTACGTA	0
+TGTACGTA	0
+ACGTACGT	0
+ACGTACGT	0
+GCGTATGT	0
+ACGTACGT	0
+CGGAAGTC	1
+TATATATA	0
+TATATATA	0
+CGTGCGTA	1
+GCGCGCGC	1
+CGTACGTA	0
+ACGTACGT	0
+ACGTACGT	0
+GCGCGCGC	1
+ACGTACGT	0
+ACGTACGT	0
+ACGTACGT	0
+CGTACGTA	0
+GCGCGCGC	1
+ACGTAGGT	0
+TATATATA	0
+ACATACGT	0
+CCGTACGT	1
+AAGTACGT	0
+CGTACGTA	0
+GCACGCGC	1
+TACATATA	0
+TATATATA	0
+GCGCGCGC	1
+ACGTACGT	0
+GCGTACGT	1
+TATATATA	0
+TATATATA	0
+GCGCGCGC	1
+CGTGCTTA	0
+ACGTACGT	0
+TATATATA	0
+CGTACGTA	0
+TATATATA	0
+GTGCGCGC	1
+CGTACGTA	0
+GCGTACGT	1
+GCGCGCGC	1
+TATATATA	0
+TATATGTA	0
+TATATATA	0
+CATACTAA	0
+ACGAACGT	0
+CGTACGTA	0
+GCGAGCGC	1
+TATATATA	0
+ACGAACCT	0
+GCGCGCGC	1
+CGTCCGTG	1
+GCGCGAGC	1
+CGTACCTA	0
+CGTACGTA	0
+GCGCGCGC	1
+TATATATA	0
+ACGTACGT	0
+ACGTAGGT	0
+GGTACGTA	0
+CGTACGTA	0
+GCGCGCGA	1
+CGTACGTA	0
+CGTACGGA	1
+ACGTACGT	0
+GCGCGCGC	1
+GCGCGCGC	1
+TATATATA	0
+ACGTACGT	0
+GCGCGCGC	1
+ACGTACGT	0
+ATGGACGT	0
+CGTAAGTA	0
+TATATATA	0
+TATATATA	0
+TATATATA	0

lecture_4/diffusion.py

@@ -0,0 +1,223 @@
+"""Complete samplers and guidance extensions around the lecture code modules."""
+import math
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from lecture_core import (K, MASK, draw, token_ce, udlm_rates,
+                          rate_step, geometric_cfg, pareto_filter)
+from common import objectives
+
+
+@torch.no_grad()
+def uniform_sample(model, batch, length, steps=100, epsilon=.02):
+    """Adaptive reverse Euler on the same truncated interval as udlm_loss.
+
+    Uniform initialization at t=1-epsilon and stopping at t=epsilon
+    are endpoint approximations. The returned sequence retains residual
+    corruption; UDLM output probabilities are not treated as a clean posterior.
+    """
+    z = torch.randint(K, (batch, length))
+    time = 1. - epsilon
+    count = 0
+    while time > epsilon + 1e-8:
+        t = torch.full((batch,), time)
+        rate = udlm_rates(model(z, t).softmax(-1), z, t)
+        max_exit = float(rate.sum(-1).max())
+        h = min(1. / steps, time - epsilon, .5 / max(max_exit, 1e-8))
+        z = rate_step(z, rate, h)
+        time -= h
+        count += 1
+        if count > 100000:
+            raise RuntimeError('Adaptive sampler failed to advance.')
+    return z
+
+
+@torch.no_grad()
+def block_sample(model, batch, length, size=2, steps=20):
+    """Generate one block completely before appending the next one."""
+    prefix = torch.empty((batch, 0), dtype=torch.long)
+    for start in range(0, length, size):
+        width = min(size, length - start)
+        block = torch.full((batch, width), MASK)
+        grid = torch.linspace(1., 0., steps + 1)
+        for t, s in zip(grid[:-1], grid[1:]):
+            context = torch.cat((prefix, block), 1)
+            p = model(context)[:, start:].softmax(-1)
+            candidate = draw(p)
+            reveal = (block == MASK) & (torch.rand(block.shape) < (t-s)/t)
+            block = torch.where(reveal, candidate, block)
+        prefix = torch.cat((prefix, block), 1)
+    return prefix
+
+
+def conditional_loss(model, clean, labels, drop=.15):
+    t = torch.rand(len(clean)).clamp_min(1e-4)
+    mask = torch.rand(clean.shape) < t[:, None]
+    context = clean.masked_fill(mask, MASK)
+    condition = labels.clone()
+    condition[torch.rand(len(clean)) < drop] = 2
+    ce = token_ce(model(context, label=condition), clean)
+    return (ce * mask / t[:, None]).sum(1).mean()
+
+
+@torch.no_grad()
+def cfg_sample(model, batch, length, strength=2., label=1, steps=20):
+    z = torch.full((batch, length), MASK)
+    grid = torch.linspace(1., 0., steps + 1)
+    labels = torch.full((batch,), label, dtype=torch.long)
+    for t, s in zip(grid[:-1], grid[1:]):
+        uncond = model(z).softmax(-1)
+        cond = model(z, label=labels).softmax(-1)
+        probability = geometric_cfg(uncond, cond, strength)
+        candidate = draw(probability)
+        reveal = (z == MASK) & (torch.rand(z.shape) < (t-s)/t)
+        z = torch.where(reveal, candidate, z)
+    return z
+
+
+class NoisyClassifier(nn.Module):
+    """Predict high-GC class from a masked sequence and its noise level."""
+    def __init__(self, length):
+        super().__init__()
+        self.net = nn.Sequential(nn.Linear(length * 5 + 1, 64),
+                                 nn.SiLU(), nn.Linear(64, 1))
+
+    def forward(self, z, t):
+        features = F.one_hot(z, 5).float() if z.ndim == 2 else z
+        return self.net(torch.cat((features.flatten(1), t[:, None]), 1)).squeeze(-1)
+
+
+def fit_classifier(model, data, labels, steps=200, batch=32):
+    opt = torch.optim.Adam(model.parameters(), lr=.003)
+    losses = []
+    for _ in range(steps):
+        idx = torch.randint(len(data), (batch,))
+        t = torch.rand(batch)
+        noisy = data[idx].masked_fill(torch.rand(batch, data.shape[1]) < t[:, None], MASK)
+        loss = F.binary_cross_entropy_with_logits(model(noisy, t), labels[idx].float())
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+        losses.append(float(loss.detach()))
+    model.eval()
+    return losses
+
+
+def log_success(classifier, z, t, label):
+    logit = classifier(z, t)
+    return F.logsigmoid(logit if label == 1 else -logit)
+
+
+def guidance_changes(classifier, z, time, label=1, gradient=False):
+    """Log h(candidate)-log h(current), exact or first-order one-hot."""
+    batch, length = z.shape
+    t = torch.full((batch,), float(time))
+    if gradient:
+        with torch.enable_grad():
+            soft = F.one_hot(z, 5).float().requires_grad_(True)
+            value = log_success(classifier, soft, t, label)
+            grad = torch.autograd.grad(value.sum(), soft)[0]
+        current = grad.gather(-1, z[..., None])
+        return grad[..., :K] - current
+    with torch.no_grad():
+        current = log_success(classifier, z, t, label)
+        delta = torch.empty((batch, length, K))
+        for i in range(length):
+            for a in range(K):
+                edited = z.clone()
+                edited[:, i] = a
+                delta[:, i, a] = log_success(classifier, edited, t, label) - current
+        return delta
+
+
+@torch.no_grad()
+def classifier_sample(model, classifier, batch, length, strength=1.,
+                      label=1, steps=40, gradient=False, epsilon=.005):
+    """Rate guidance with adaptive Euler and an explicit endpoint closure."""
+    z = torch.full((batch, length), MASK)
+    time = 1.
+    iterations = 0
+    while time > epsilon + 1e-8:
+        p = model(z).softmax(-1)
+        delta = guidance_changes(classifier, z, time, label, gradient)
+        rates = p / time * (strength * delta).clamp(-20, 20).exp()
+        rates *= (z == MASK)[..., None]
+        exit_rate = rates.sum(-1)
+        h = min(1. / steps, time-epsilon, .5 / max(float(exit_rate.max()), 1e-8))
+        change = torch.rand(z.shape) < h * exit_rate
+        candidate = draw(rates / exit_rate.clamp_min(1e-12)[..., None] + 1e-12)
+        z = torch.where(change & (z == MASK), candidate, z)
+        time -= h
+        iterations += 1
+        if iterations > 100000:
+            raise RuntimeError('Guided rate integration failed to advance.')
+    z = torch.where(z == MASK, draw(model(z).softmax(-1)), z)
+    return z
+
+
+class SearchNode:
+    def __init__(self, tokens, parent=None, prior=1.):
+        self.tokens, self.parent, self.prior = tokens, parent, prior
+        self.children = []
+        self.visits = 0
+        self.reward = np.zeros(2)
+
+
+@torch.no_grad()
+def peptune_search(model, length=8, iterations=100, branching=4):
+    """DNA MCTS: selection, expansion, completion, Pareto rewards, backup.
+
+    All DNA strings are valid. Peptide chemistry, bond-dependent masks,
+    RoFormer training, and the PepTune invalid-SMILES penalty are not used.
+    """
+    root = SearchNode(torch.full((length,), MASK))
+    archive = torch.empty((0, length), dtype=torch.long)
+    archive_scores = torch.empty((0, 2))
+    trace = []
+    for iteration in range(iterations):
+        node = root
+        while node.children:
+            def selection(child):
+                mean = child.reward.mean() / max(child.visits, 1)
+                bonus = 1.5 * child.prior * math.sqrt(node.visits + 1) / (child.visits + 1)
+                return mean + bonus
+            node = max(node.children, key=selection)
+        if (node.tokens == MASK).any():
+            p = model(node.tokens[None]).softmax(-1)[0]
+            positions = torch.where(node.tokens == MASK)[0]
+            seen = set()
+            for _ in range(branching):
+                pos = int(positions[torch.randint(len(positions), ())])
+                token = int(torch.multinomial(p[pos], 1))
+                candidate = node.tokens.clone()
+                candidate[pos] = token
+                key = tuple(candidate.tolist())
+                if key not in seen:
+                    node.children.append(SearchNode(candidate, node, float(p[pos, token])))
+                    seen.add(key)
+            node = node.children[0]
+        rollout = node.tokens.clone()
+        while (rollout == MASK).any():
+            prob = model(rollout[None]).softmax(-1)
+            position = int(torch.where(rollout == MASK)[0][0])
+            rollout[position] = draw(prob)[0, position]
+        score = objectives(rollout[None])[0]
+        reward = ((score >= archive_scores).float().mean(0).numpy()
+                  if len(archive) else np.ones(2))
+        archive = torch.cat((archive, rollout[None]))
+        archive_scores = torch.cat((archive_scores, score[None]))
+        archive, archive_scores = pareto_filter(archive, archive_scores)
+        # Equal-score alternatives remain; remove exact repeated sequences only.
+        unique = []; seen = set()
+        for i, row in enumerate(archive.tolist()):
+            key = tuple(row)
+            if key not in seen:
+                unique.append(i); seen.add(key)
+        archive, archive_scores = archive[unique], archive_scores[unique]
+        while node is not None:
+            node.visits += 1
+            node.reward += reward
+            node = node.parent
+        trace.append(dict(iteration=iteration, archive_size=len(archive), score=score.tolist()))
+    return archive, archive_scores, trace

lecture_4/examples/block.py

@@ -0,0 +1,7 @@
+"""Complete block training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'block', '--out', 'outputs/block'] + sys.argv[1:])

lecture_4/examples/cfg.py

@@ -0,0 +1,7 @@
+"""Complete cfg training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'cfg', '--out', 'outputs/cfg'] + sys.argv[1:])

lecture_4/examples/classifier_exact.py

@@ -0,0 +1,7 @@
+"""Complete classifier-exact training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'classifier-exact', '--out', 'outputs/classifier-exact'] + sys.argv[1:])

lecture_4/examples/classifier_gradient.py

@@ -0,0 +1,7 @@
+"""Complete classifier-gradient training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'classifier-gradient', '--out', 'outputs/classifier-gradient'] + sys.argv[1:])

lecture_4/examples/mdlm.py

@@ -0,0 +1,7 @@
+"""Complete mdlm training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'mdlm', '--out', 'outputs/mdlm'] + sys.argv[1:])

lecture_4/examples/peptune.py

@@ -0,0 +1,7 @@
+"""Complete peptune training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'peptune', '--out', 'outputs/peptune'] + sys.argv[1:])

lecture_4/examples/udlm.py

@@ -0,0 +1,7 @@
+"""Complete udlm training and generation example."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from run import main
+if __name__ == '__main__':
+    main(['--method', 'udlm', '--out', 'outputs/udlm'] + sys.argv[1:])

lecture_4/lecture_core.py

@@ -0,0 +1,136 @@
+"""Small teaching implementations; illustrative data, not paper reproductions."""
+
+import math
+
+import numpy as np
+
+import torch
+
+from torch import nn
+
+import torch.nn.functional as F
+
+from scipy.special import betainc, beta
+
+from scipy.stats import rankdata
+
+K, MASK = 4, 4
+
+ALPHABET = 'ACGT'
+
+def encode(strings):
+    return torch.tensor([[ALPHABET.index(c) for c in s]
+                         for s in strings])
+
+def draw(prob):
+    shape = prob.shape[:-1]
+    sample = torch.multinomial(prob.reshape(-1, K), 1)
+    return sample.reshape(shape)
+
+class DNA(nn.Module):
+    def __init__(self, width=32, max_len=64):
+        super().__init__()
+        self.token = nn.Embedding(K + 1, width)
+        self.soft = nn.Linear(K, width)
+        self.position = nn.Embedding(max_len, width)
+        self.time = nn.Linear(1, width)
+        layer = nn.TransformerEncoderLayer(
+            width, 4, 2 * width, dropout=0., batch_first=True)
+        self.context = nn.TransformerEncoder(layer, 1)
+        self.output = nn.Linear(width, K)
+
+    def forward(self, z, t=None):
+        h = self.token(z) if z.ndim == 2 else self.soft(z)
+        pos = torch.arange(z.shape[1], device=z.device)
+        h = h + self.position(pos)[None]
+        if t is not None:
+            h = h + self.time(t[:, None])[:, None]
+        return self.output(self.context(h))
+
+def token_ce(logits, target):
+    return F.cross_entropy(logits.transpose(1, 2),
+                           target, reduction='none')
+
+def mdlm_loss(model, clean):
+    batch, length = clean.shape
+    t = torch.rand(batch).clamp_min(1e-4)
+    masked = torch.rand(batch, length) < t[:, None]
+    noisy = clean.masked_fill(masked, MASK)
+    logits = model(noisy)  # optimal predictor needs no t
+    ce = token_ce(logits, clean)
+    weighted = ce * masked / t[:, None]
+    return weighted.sum(1).mean()
+
+def train_step(model, optimizer, clean, loss_fn):
+    model.train()
+    optimizer.zero_grad()
+    loss = loss_fn(model, clean)
+    loss.backward()
+    optimizer.step()
+    return loss.item()
+
+@torch.no_grad()
+def mdlm_sample(model, batch, length, steps=20):
+    model.eval()
+    z = torch.full((batch, length), MASK)
+    grid = torch.linspace(1., 0., steps + 1)
+    for t, s in zip(grid[:-1], grid[1:]):
+        prob = model(z).softmax(-1)
+        candidate = draw(prob)
+        reveal = torch.rand(z.shape) < (t - s) / t
+        update = (z == MASK) & reveal
+        z = torch.where(update, candidate, z)
+    return z
+
+def rate_step(z, rates, h):
+    exit_rate = rates.sum(-1)
+    assert torch.all(h * exit_rate <= 1. + 1e-6)
+    prob = h * rates
+    prob.scatter_(-1, z[..., None],
+                  (1. - h * exit_rate)[..., None])
+    return draw(prob.clamp_min(0.))
+
+def udlm_rates(clean_prob, z, t):
+    alpha = 1. - t[:, None, None]
+    noisy_prob = alpha * clean_prob + (1. - alpha) / K
+    current = noisy_prob.gather(-1, z[..., None])
+    rates = noisy_prob / (K * alpha * current)
+    return rates.scatter(-1, z[..., None], 0.)
+
+def udlm_loss(model, clean):
+    t = .02 + .96 * torch.rand(clean.shape[0])
+    random = torch.randint(K, clean.shape)
+    z = torch.where(torch.rand(clean.shape) < t[:, None],
+                    random, clean)
+    exact = F.one_hot(clean, K).float()
+    pred = model(z, t).softmax(-1)
+    a, b = udlm_rates(exact, z, t), udlm_rates(pred, z, t)
+    term = a * (a.clamp_min(1e-12).log()
+                - b.clamp_min(1e-12).log()) + b - a
+    return .96 * term.sum((1, 2)).mean()
+
+def block_loss(model, clean, start, size):
+    prefix, block = clean[:, :start], clean[:, start:start+size]
+    t = torch.rand(clean.shape[0]).clamp_min(1e-4)
+    mask = torch.rand(block.shape) < t[:, None]
+    ctx = torch.cat([prefix, block.masked_fill(mask, MASK)], 1)
+    logits = model(ctx)[:, start:]
+    loss = token_ce(logits, block) * mask / t[:, None]
+    return loss.sum(1).mean()
+
+def geometric_cfg(uncond, cond, strength):
+    logits = (1. - strength) * uncond.clamp_min(1e-12).log()
+    logits += strength * cond.clamp_min(1e-12).log()
+    return logits.softmax(-1)
+
+def guide_rates(base_rates, log_values, current_log_value,
+                strength=1.):
+    log_ratio = log_values - current_log_value[..., None]
+    return base_rates * (strength * log_ratio).exp()
+
+def pareto_filter(sequences, scores):
+    # Maximize both objectives; keep equal-score alternatives.
+    ge = (scores[:, None] >= scores[None, :]).all(-1)
+    gt = (scores[:, None] > scores[None, :]).any(-1)
+    dominated = (ge & gt).any(0)
+    return sequences[~dominated], scores[~dominated]

lecture_4/numerical_examples.py

@@ -0,0 +1,24 @@
+"""Print the four-letter training and sampling calculations from the lecture."""
+import math
+import torch
+from lecture_core import udlm_rates, geometric_cfg
+
+dtype = torch.float64
+print('Alphabet order: A C G T; log losses are nats.')
+q = .6*torch.eye(4,dtype=dtype)+.1*torch.ones(4,4,dtype=dtype)
+print('Uniform one-step corruption matrix:\n',q)
+print('Two-step marginal from clean A:',(q@q)[0].tolist())
+reverse=q[0]*q[:,1];reverse/=reverse.sum()
+print('Previous base given clean A and final C:',reverse.tolist())
+loss=2*(-math.log(.6)-math.log(.7))
+print('MDLM ACGT -> AmGm, t=.5, loss:',loss)
+print('MDLM reverse .5 -> .25 at missing C:',[.05,.30,.10,.05,.50])
+z=torch.tensor([[1]]);t=torch.tensor([.5],dtype=dtype)
+a=udlm_rates(torch.tensor([[[1,0,0,0]]],dtype=dtype),z,t)
+b=udlm_rates(torch.tensor([[[.6,.2,.1,.1]]],dtype=dtype),z,t)
+rate_kl=(a*(a.clamp_min(1e-12).log()-b.clamp_min(1e-12).log())+b-a).sum()
+print('UDLM target rates C -> A,C,G,T:',a.flatten().tolist())
+print('UDLM learned rates:',b.flatten().tolist(),'rate loss:',float(rate_kl))
+p=.1*b;p[...,1]=1-.1*b.sum(-1)
+print('UDLM Euler step:',p.flatten().tolist())
+print('CFG strength 2:',geometric_cfg(torch.full((4,),.25),torch.tensor([.1,.2,.6,.1]),2).tolist())

lecture_4/requirements.txt

@@ -0,0 +1,3 @@
+torch>=2.2
+numpy>=1.24
+scipy>=1.10

lecture_4/run.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Train and sample each Lecture 4 method on small, explicit DNA examples."""
+import argparse
+from pathlib import Path
+import torch
+from lecture_core import DNA, mdlm_loss, mdlm_sample, udlm_loss, block_loss
+from common import (seed_all, load_data, optimize, save_run, ConditionalDNA,
+                    decode, metrics)
+from diffusion import (uniform_sample, block_sample, conditional_loss,
+                       cfg_sample, NoisyClassifier, fit_classifier,
+                       classifier_sample, peptune_search)
+
+METHODS = ['mdlm', 'udlm', 'block', 'cfg', 'classifier-free',
+           'classifier-gradient', 'classifier-exact', 'peptune']
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--method', choices=METHODS, default='mdlm')
+    parser.add_argument('--mode', choices=['train-sample', 'train', 'sample'], default='train-sample')
+    parser.add_argument('--train-steps', type=int, default=300)
+    parser.add_argument('--sample-steps', type=int, default=40)
+    parser.add_argument('--classifier-steps', type=int, default=300)
+    parser.add_argument('--search-steps', type=int, default=100)
+    parser.add_argument('--batch-size', type=int, default=32)
+    parser.add_argument('--samples', type=int, default=32)
+    parser.add_argument('--length', type=int, default=8)
+    parser.add_argument('--width', type=int, default=32)
+    parser.add_argument('--block-size', type=int, default=2)
+    parser.add_argument('--strength', type=float, default=1.5)
+    parser.add_argument('--label', type=int, choices=[0, 1], default=1)
+    parser.add_argument('--seed', type=int, default=7)
+    parser.add_argument('--data', help='TSV with sequence and optional binary label columns')
+    parser.add_argument('--out', default='outputs/mdlm')
+    args = parser.parse_args(argv)
+    if min(args.length, args.sample_steps, args.batch_size, args.samples, args.block_size) < 1:
+        parser.error('Lengths, step counts, and batch counts must be positive.')
+    if args.width % 4 or args.length > 64:
+        parser.error('Width must be divisible by four; length must not exceed 64.')
+    if args.mode != 'sample' and args.train_steps < 1:
+        parser.error('Training requires at least one step.')
+    seed_all(args.seed)
+    out = Path(args.out); out.mkdir(parents=True, exist_ok=True)
+    method = 'cfg' if args.method == 'classifier-free' else args.method
+    model = ConditionalDNA(args.width) if method == 'cfg' else DNA(args.width)
+    classifier = None
+    losses = []
+    report = {'method': method, 'data': 'synthetic DNA; not biological validation'}
+    if args.mode == 'sample':
+        checkpoint = torch.load(out / 'checkpoint.pt', weights_only=True)
+        if checkpoint['method'] != method or checkpoint['length'] != args.length:
+            raise ValueError('Checkpoint method/length must match command arguments.')
+        model.load_state_dict(checkpoint['model'])
+        if 'classifier' in checkpoint:
+            classifier = NoisyClassifier(args.length)
+            classifier.load_state_dict(checkpoint['classifier'])
+    else:
+        data, labels = load_data(args.data, args.length)
+        split = max(1, int(.8 * len(data)))
+        train, train_labels = data[:split], labels[:split]
+        if method == 'udlm':
+            loss_fn = lambda m, x, idx: udlm_loss(m, x)
+        elif method == 'block':
+            starts = list(range(0, args.length, args.block_size))
+            def loss_fn(m, x, idx):
+                start = starts[int(torch.randint(len(starts), ()))]
+                return len(starts) * block_loss(m, x, start, args.block_size)
+        elif method == 'cfg':
+            loss_fn = lambda m, x, idx: conditional_loss(m, x, train_labels[idx])
+        else:
+            loss_fn = lambda m, x, idx: mdlm_loss(m, x)
+        losses = optimize(model, loss_fn, train, args.train_steps, args.batch_size)
+        checkpoint = {'model': model.state_dict(), 'method': method,
+                      'length': args.length, 'width': args.width}
+        if method.startswith('classifier-'):
+            classifier = NoisyClassifier(args.length)
+            classifier_losses = fit_classifier(classifier, train, train_labels,
+                                               args.classifier_steps, args.batch_size)
+            checkpoint['classifier'] = classifier.state_dict()
+            report['classifier_final_loss'] = classifier_losses[-1]
+        torch.save(checkpoint, out / 'checkpoint.pt')
+        report['train_loss_first_20_mean'] = sum(losses[:20]) / len(losses[:20])
+        report['train_loss_last_20_mean'] = sum(losses[-20:]) / len(losses[-20:])
+        # An independent noisy validation estimate, not a perplexity claim.
+        val = data[split:]
+        if len(val):
+            with torch.no_grad():
+                if method == 'udlm':
+                    validation = udlm_loss(model, val)
+                elif method == 'cfg':
+                    validation = conditional_loss(model, val, labels[split:], drop=0.)
+                elif method == 'block':
+                    validation = sum(block_loss(model, val, start, args.block_size)
+                                     for start in starts)
+                else:
+                    validation = mdlm_loss(model, val)
+            report['validation_loss_one_mc_draw'] = float(validation)
+        if args.mode == 'train':
+            save_run(out, vars(args), losses, train[:args.samples],
+                     {**report, 'sample_file_contains': 'training examples; generation not requested'})
+            return report
+    model.eval()
+    if method == 'udlm':
+        samples = uniform_sample(model, args.samples, args.length, args.sample_steps)
+        report['endpoint_approximation'] = 't in [0.02, 0.98]; stop at residual noise 0.02, without a posterior interpretation of the UDLM parameter vector'
+    elif method == 'block':
+        samples = block_sample(model, args.samples, args.length, args.block_size, args.sample_steps)
+    elif method == 'cfg':
+        samples = cfg_sample(model, args.samples, args.length, args.strength, args.label, args.sample_steps)
+    elif method.startswith('classifier-'):
+        classifier.eval()
+        samples = classifier_sample(model, classifier, args.samples, args.length,
+                                    args.strength, args.label, args.sample_steps,
+                                    gradient=method == 'classifier-gradient')
+        report['guidance'] = 'learned noisy classifier; final residual masks use denoiser closure'
+    elif method == 'peptune':
+        samples, scores, trace = peptune_search(model, args.length, args.search_steps)
+        report['archive_scores'] = scores.tolist()
+        report['search_trace'] = trace
+        report['scope'] = 'DNA MCTS mechanism; not peptide-model training or paper reproduction'
+    else:
+        samples = mdlm_sample(model, args.samples, args.length, args.sample_steps)
+    return save_run(out, vars(args), losses, samples, report)
+
+
+if __name__ == '__main__':
+    main()

lecture_4/run_all.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Run every complete training example; pass --quick for a small CPU check."""
+import argparse
+from run import main
+parser = argparse.ArgumentParser()
+parser.add_argument('--quick', action='store_true')
+args = parser.parse_args()
+methods = ['mdlm', 'udlm', 'block', 'cfg', 'classifier-exact', 'classifier-gradient', 'peptune']
+for method in methods:
+    command = ['--method', method, '--out', 'outputs/' + method]
+    if args.quick:
+        command += ['--train-steps', '20', '--samples', '4', '--length', '4',
+                    '--batch-size', '8', '--sample-steps', '20']
+        command += ['--classifier-steps', '20', '--search-steps', '12']
+    main(command)

lecture_4/tests/test_mathematics.py

@@ -0,0 +1,50 @@
+import unittest
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import torch
+from lecture_core import udlm_rates, geometric_cfg
+from diffusion import guidance_changes, NoisyClassifier
+
+
+class Mathematics(unittest.TestCase):
+    def test_masked_kl_reduces_to_cross_entropy(self):
+        r = .5
+        d = torch.tensor([.1,.6,.2,.1], dtype=torch.float64)
+        q = torch.tensor([0,r,0,0,1-r], dtype=torch.float64)
+        p = torch.cat((r*d, torch.tensor([1-r])))
+        actual = (q[q>0] * (q[q>0]/p[q>0]).log()).sum()
+        self.assertAlmostEqual(float(actual), float(-r*d[1].log()), places=12)
+
+    def test_udlm_small_step_kl_converges_to_rate_loss(self):
+        a = torch.tensor([2.5,.5,.5], dtype=torch.float64)
+        b = torch.tensor([17/18,7/18,7/18], dtype=torch.float64)
+        target = (a*(a/b).log()+b-a).sum()
+        errors = []
+        for h in [1e-3,1e-4,1e-5]:
+            q = torch.cat((h*a,(1-h*a.sum()).reshape(1)))
+            p = torch.cat((h*b,(1-h*b.sum()).reshape(1)))
+            local = (q*(q/p).log()).sum()/h
+            errors.append(abs(float(local-target)))
+        self.assertLess(errors[-1], errors[0]/50)
+        self.assertAlmostEqual(float(target), .9071595148, places=8)
+
+    def test_cfg_dna_example(self):
+        p = geometric_cfg(torch.full((4,),.25),torch.tensor([.1,.2,.6,.1]),2.)
+        torch.testing.assert_close(p, torch.tensor([1,4,36,1])/42.)
+
+    def test_classifier_gradient_matches_directional_derivative(self):
+        torch.manual_seed(2)
+        model = NoisyClassifier(4).double()
+        z = torch.tensor([[0,1,2,3]])
+        soft = torch.nn.functional.one_hot(z,5).double().requires_grad_(True)
+        t = torch.tensor([.5], dtype=torch.float64)
+        f = lambda x: torch.nn.functional.logsigmoid(model(x,t)).sum()
+        grad = torch.autograd.grad(f(soft),soft)[0]
+        direction = torch.zeros_like(soft);direction[0,0,0]=-1;direction[0,0,1]=1
+        h=1e-5
+        numeric=(f(soft+h*direction)-f(soft-h*direction))/(2*h)
+        self.assertAlmostEqual(float(numeric.detach()),float((grad*direction).sum()),places=8)
+
+
+if __name__ == '__main__': unittest.main()

lecture_4/verified_examples/README.md

@@ -0,0 +1,15 @@
+# Verified CPU examples
+
+Actual seed-7 runs: 160 optimizer steps, length 4, batch size 16, 40 sampling steps, and 8 requested samples. ReDi/AReUReDi additionally use 160 teacher updates and 128 recoupled pairs. PepTune returns its archive, whose size can differ from the requested sample count.
+
+| Method | Mean first 20 losses | Mean last 20 losses | Valid DNA |
+| --- | ---: | ---: | --- |
+| mdlm | 4.8388 | 2.6139 | True |
+| udlm | 5.1313 | 2.2786 | True |
+| block | 5.3755 | 3.2929 | True |
+| cfg | 4.3721 | 2.3383 | True |
+| classifier-exact | 4.8388 | 2.6139 | True |
+| classifier-gradient | 4.8388 | 2.6139 | True |
+| peptune | 4.8388 | 2.6139 | True |
+
+These are execution and learning checks on toy data, not paper benchmark results. Different method losses have different meanings and scales. The sample counts are too small for statistical quality claims.

lecture_4/verified_examples/block/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "block",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/block"
+}

lecture_4/verified_examples/block/losses.json

@@ -0,0 +1,162 @@
+[
+  4.331284523010254,
+  5.4537835121154785,
+  4.560967445373535,
+  6.563370704650879,
+  8.061755180358887,
+  3.8685860633850098,
+  6.454323768615723,
+  7.774837970733643,
+  2.178312301635742,
+  4.992790222167969,
+  12.195539474487305,
+  5.040197372436523,
+  3.1479640007019043,
+  4.1676025390625,
+  4.741274356842041,
+  6.513577461242676,
+  5.152376651763916,
+  6.8658881187438965,
+  3.170300006866455,
+  2.2749924659729004,
+  2.5343780517578125,
+  4.639561176300049,
+  3.381667375564575,
+  2.6100592613220215,
+  4.106627941131592,
+  5.132066249847412,
+  4.543891906738281,
+  4.116055011749268,
+  4.740029811859131,
+  11.817144393920898,
+  1.597190499305725,
+  2.864633321762085,
+  3.4319229125976562,
+  2.477750778198242,
+  2.259556293487549,
+  5.4611029624938965,
+  1.7751753330230713,
+  3.8391871452331543,
+  10.745177268981934,
+  2.813826084136963,
+  3.071927547454834,
+  4.419896602630615,
+  5.47519588470459,
+  15.978719711303711,
+  1.765317440032959,
+  3.7841482162475586,
+  3.9389586448669434,
+  4.711722373962402,
+  3.904447078704834,
+  4.800976753234863,
+  2.614999771118164,
+  3.3339426517486572,
+  7.427157402038574,
+  3.459439754486084,
+  5.940922260284424,
+  6.2956037521362305,
+  1.3079692125320435,
+  3.5128886699676514,
+  4.249375820159912,
+  2.7473535537719727,
+  2.1603171825408936,
+  0.7737497687339783,
+  2.2809128761291504,
+  4.380037307739258,
+  0.9533628225326538,
+  2.962036609649658,
+  2.988816261291504,
+  2.04714298248291,
+  7.599990367889404,
+  3.762449026107788,
+  3.4661433696746826,
+  2.0959715843200684,
+  1.7144439220428467,
+  3.5818352699279785,
+  3.0614638328552246,
+  0.7883206605911255,
+  1.4352097511291504,
+  1.7439507246017456,
+  0.8709290623664856,
+  0.458389014005661,
+  3.4738333225250244,
+  4.326974391937256,
+  6.331646919250488,
+  2.4808788299560547,
+  3.24576997756958,
+  4.848365306854248,
+  1.6670418977737427,
+  2.3548476696014404,
+  1.993442177772522,
+  2.5002496242523193,
+  0.3059796988964081,
+  2.1486732959747314,
+  6.24207878112793,
+  1.8249398469924927,
+  3.396871566772461,
+  3.9418718814849854,
+  0.29895153641700745,
+  16.587575912475586,
+  0.5883609652519226,
+  3.9876809120178223,
+  1.529473066329956,
+  6.409687519073486,
+  3.979583978652954,
+  3.5919885635375977,
+  0.8253586292266846,
+  2.201484203338623,
+  0.2219580113887787,
+  0.9641126990318298,
+  8.145115852355957,
+  4.052484035491943,
+  2.1619670391082764,
+  3.3841612339019775,
+  2.688559055328369,
+  0.4211858808994293,
+  0.799785852432251,
+  3.8083810806274414,
+  1.6525324583053589,
+  4.437976837158203,
+  1.2433699369430542,
+  3.8457489013671875,
+  4.093887805938721,
+  1.0025733709335327,
+  1.6318846940994263,
+  3.593684196472168,
+  2.961604356765747,
+  2.3301167488098145,
+  0.24246026575565338,
+  3.887437582015991,
+  2.659883737564087,
+  0.6962559223175049,
+  1.298153042793274,
+  1.4727579355239868,
+  2.848424196243286,
+  1.1403732299804688,
+  4.791389465332031,
+  4.210074424743652,
+  1.5758970975875854,
+  2.269327402114868,
+  0.18495622277259827,
+  1.9766299724578857,
+  1.7147716283798218,
+  3.4504735469818115,
+  4.908379554748535,
+  5.258154392242432,
+  0.6683526039123535,
+  1.2319836616516113,
+  6.596828460693359,
+  3.3549842834472656,
+  9.503194808959961,
+  5.601862907409668,
+  3.6974446773529053,
+  4.31416654586792,
+  1.9783447980880737,
+  0.26172930002212524,
+  0.2431989312171936,
+  2.2771925926208496,
+  1.737384557723999,
+  3.598238706588745,
+  3.4887681007385254,
+  1.9730119705200195
+]

lecture_4/verified_examples/block/report.json

@@ -0,0 +1,13 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.75,
+    "mean_gc": 0.59375,
+    "mean_atat_match": 0.25
+  },
+  "method": "block",
+  "data": "synthetic DNA; not biological validation",
+  "train_loss_first_20_mean": 5.375486207008362,
+  "train_loss_last_20_mean": 3.2929233014583588,
+  "validation_loss_one_mc_draw": 2.7980802059173584
+}

lecture_4/verified_examples/block/samples.txt

@@ -0,0 +1,8 @@
+ACGC
+ACGT
+ACGT
+CCTA
+ACGT
+CGTA
+ACGA
+GCGC

lecture_4/verified_examples/cfg/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "cfg",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/cfg"
+}

lecture_4/verified_examples/cfg/losses.json

@@ -0,0 +1,162 @@
+[
+  4.093783855438232,
+  6.376791000366211,
+  4.311301231384277,
+  5.4559221267700195,
+  5.326346397399902,
+  4.026087760925293,
+  2.633061647415161,
+  4.690178394317627,
+  5.398682117462158,
+  7.209366798400879,
+  4.6532487869262695,
+  5.112819671630859,
+  4.506524085998535,
+  4.212957382202148,
+  4.013753890991211,
+  3.131486177444458,
+  2.223745346069336,
+  2.7967262268066406,
+  3.788841724395752,
+  3.4797284603118896,
+  2.963750123977661,
+  4.317558288574219,
+  3.753492832183838,
+  5.249013900756836,
+  4.309139728546143,
+  3.7436439990997314,
+  10.669134140014648,
+  4.060160160064697,
+  2.0760574340820312,
+  3.706965684890747,
+  3.228757381439209,
+  2.2654337882995605,
+  4.35042667388916,
+  3.539440631866455,
+  3.0063133239746094,
+  2.5612518787384033,
+  5.035284519195557,
+  3.1380114555358887,
+  3.5969271659851074,
+  4.42738151550293,
+  2.6170473098754883,
+  4.362626075744629,
+  4.103579998016357,
+  2.5357091426849365,
+  3.5490846633911133,
+  2.5230069160461426,
+  2.873248338699341,
+  3.158176898956299,
+  4.957892894744873,
+  2.1993887424468994,
+  2.1841094493865967,
+  4.587640285491943,
+  1.8580347299575806,
+  2.267033100128174,
+  1.8229238986968994,
+  1.7472164630889893,
+  3.5524239540100098,
+  2.736100435256958,
+  3.342960834503174,
+  2.218371629714966,
+  2.875619411468506,
+  2.75288462638855,
+  1.6586329936981201,
+  3.1111838817596436,
+  4.498309135437012,
+  2.5214474201202393,
+  3.716679811477661,
+  2.803637981414795,
+  2.1772122383117676,
+  2.169358253479004,
+  1.9947891235351562,
+  2.1023731231689453,
+  2.3627333641052246,
+  1.7967830896377563,
+  1.8754620552062988,
+  2.9364476203918457,
+  2.1339101791381836,
+  4.144628524780273,
+  1.9647955894470215,
+  2.0155508518218994,
+  2.1333699226379395,
+  1.434370517730713,
+  2.0664165019989014,
+  2.257500410079956,
+  1.5195107460021973,
+  4.65607213973999,
+  2.1975350379943848,
+  0.781586229801178,
+  1.8217566013336182,
+  2.1626477241516113,
+  1.8518555164337158,
+  3.667850971221924,
+  2.1525752544403076,
+  4.357625961303711,
+  1.1739027500152588,
+  0.9763473272323608,
+  1.2919902801513672,
+  2.5940964221954346,
+  2.762819290161133,
+  1.969483733177185,
+  1.4582405090332031,
+  1.5817911624908447,
+  1.1240861415863037,
+  2.102308988571167,
+  3.745494842529297,
+  2.124908208847046,
+  2.0141687393188477,
+  1.9382771253585815,
+  1.5961400270462036,
+  1.9971623420715332,
+  2.9211485385894775,
+  2.4554712772369385,
+  2.6297366619110107,
+  1.5343077182769775,
+  3.172154664993286,
+  2.1179494857788086,
+  2.9100096225738525,
+  1.7049200534820557,
+  4.258328437805176,
+  2.4142634868621826,
+  2.198406934738159,
+  1.5292108058929443,
+  5.4681267738342285,
+  2.697603225708008,
+  3.230813503265381,
+  2.773991107940674,
+  2.4651236534118652,
+  0.9841868877410889,
+  0.870418906211853,
+  3.471985101699829,
+  2.449937582015991,
+  3.4545187950134277,
+  1.8310009241104126,
+  2.834800958633423,
+  0.7408347129821777,
+  2.966944456100464,
+  2.631303548812866,
+  2.5108256340026855,
+  2.7800302505493164,
+  2.462411880493164,
+  1.2342865467071533,
+  2.3784074783325195,
+  1.8845710754394531,
+  2.4422521591186523,
+  2.492060422897339,
+  1.5423519611358643,
+  2.8376150131225586,
+  3.2689411640167236,
+  4.493769645690918,
+  1.8553943634033203,
+  2.3281853199005127,
+  1.4675829410552979,
+  2.056398391723633,
+  3.948185443878174,
+  2.2498135566711426,
+  1.085364818572998,
+  2.6406710147857666,
+  2.0750088691711426,
+  1.4774831533432007,
+  3.007999897003174
+]

lecture_4/verified_examples/cfg/report.json

@@ -0,0 +1,13 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.625,
+    "mean_gc": 0.9375,
+    "mean_atat_match": 0.03125
+  },
+  "method": "cfg",
+  "data": "synthetic DNA; not biological validation",
+  "train_loss_first_20_mean": 4.372067654132843,
+  "train_loss_last_20_mean": 2.3383171617984773,
+  "validation_loss_one_mc_draw": 2.0500779151916504
+}

lecture_4/verified_examples/cfg/samples.txt

@@ -0,0 +1,8 @@
+GCCC
+GCGC
+CGGC
+GCGC
+GCGC
+GCAC
+GCGA
+GCGC

lecture_4/verified_examples/classifier-exact/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "classifier-exact",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/classifier-exact"
+}

lecture_4/verified_examples/classifier-exact/losses.json

@@ -0,0 +1,162 @@
+[
+  4.01927375793457,
+  3.8247132301330566,
+  6.5967559814453125,
+  3.0379931926727295,
+  5.381988048553467,
+  4.364372730255127,
+  6.268919944763184,
+  4.896388530731201,
+  2.5558066368103027,
+  5.216179847717285,
+  4.734250545501709,
+  5.792362213134766,
+  3.2293550968170166,
+  4.882113456726074,
+  4.7334160804748535,
+  4.435980796813965,
+  5.003822326660156,
+  5.925942420959473,
+  7.791959762573242,
+  4.085095405578613,
+  3.899994373321533,
+  3.2904622554779053,
+  3.4589755535125732,
+  2.720918655395508,
+  3.027308225631714,
+  3.0458157062530518,
+  3.7035269737243652,
+  3.8884239196777344,
+  4.001327037811279,
+  4.476953983306885,
+  2.1432690620422363,
+  4.810318946838379,
+  2.952962875366211,
+  4.420904159545898,
+  3.500626564025879,
+  4.333303928375244,
+  3.9793171882629395,
+  1.8058104515075684,
+  4.20003080368042,
+  3.7151639461517334,
+  2.2277348041534424,
+  2.7376279830932617,
+  3.615410327911377,
+  4.500275611877441,
+  5.066170692443848,
+  3.6637136936187744,
+  2.8754518032073975,
+  2.339322328567505,
+  2.037803888320923,
+  2.1924853324890137,
+  3.4916043281555176,
+  2.519395351409912,
+  2.597137451171875,
+  2.4708733558654785,
+  2.5220284461975098,
+  2.5972704887390137,
+  3.05387806892395,
+  5.856385231018066,
+  2.131591320037842,
+  3.3278908729553223,
+  2.400947093963623,
+  5.875596046447754,
+  3.1304073333740234,
+  3.21421217918396,
+  2.4150002002716064,
+  2.215695381164551,
+  2.139690637588501,
+  3.2768962383270264,
+  2.847025156021118,
+  3.595715045928955,
+  1.7762316465377808,
+  3.3017048835754395,
+  3.1203761100769043,
+  2.4890081882476807,
+  4.99165153503418,
+  3.243589401245117,
+  2.338869333267212,
+  1.9984252452850342,
+  3.838407516479492,
+  2.6884045600891113,
+  6.401689052581787,
+  1.2461563348770142,
+  2.748701810836792,
+  8.534076690673828,
+  3.991495132446289,
+  2.489625930786133,
+  2.2347571849823,
+  2.9534873962402344,
+  2.5714945793151855,
+  1.147279977798462,
+  2.4217231273651123,
+  1.3990497589111328,
+  2.5761783123016357,
+  2.3062100410461426,
+  3.08569073677063,
+  1.516831874847412,
+  3.085536003112793,
+  2.8733534812927246,
+  1.2969731092453003,
+  3.7263309955596924,
+  2.435549736022949,
+  3.5106093883514404,
+  2.7424113750457764,
+  3.264981269836426,
+  1.683659315109253,
+  1.149167776107788,
+  2.775585889816284,
+  3.208291530609131,
+  2.314664602279663,
+  3.91782283782959,
+  1.7896864414215088,
+  2.5307981967926025,
+  2.4437763690948486,
+  2.521484136581421,
+  2.2941794395446777,
+  1.6110831499099731,
+  3.128873825073242,
+  3.0251963138580322,
+  2.2769689559936523,
+  1.4722540378570557,
+  1.7136496305465698,
+  5.040107727050781,
+  2.9950344562530518,
+  4.272597789764404,
+  2.686481237411499,
+  2.7622010707855225,
+  3.0286059379577637,
+  2.0905165672302246,
+  2.4465155601501465,
+  2.035715341567993,
+  2.315361499786377,
+  1.4022663831710815,
+  3.5252881050109863,
+  2.6312732696533203,
+  3.7926905155181885,
+  1.7568085193634033,
+  1.798338532447815,
+  3.3464834690093994,
+  2.249241828918457,
+  2.2580409049987793,
+  4.0587310791015625,
+  2.206573247909546,
+  0.6222774982452393,
+  1.8168766498565674,
+  3.9070353507995605,
+  2.2064626216888428,
+  1.1733113527297974,
+  1.383936882019043,
+  2.251495599746704,
+  2.962852954864502,
+  2.8415677547454834,
+  1.3905932903289795,
+  3.165285587310791,
+  3.477961540222168,
+  1.7277320623397827,
+  2.4671823978424072,
+  5.010605812072754,
+  3.3257808685302734,
+  2.7084109783172607,
+  3.5739824771881104
+]

lecture_4/verified_examples/classifier-exact/report.json

@@ -0,0 +1,15 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.625,
+    "mean_gc": 0.84375,
+    "mean_atat_match": 0.0625
+  },
+  "method": "classifier-exact",
+  "data": "synthetic DNA; not biological validation",
+  "classifier_final_loss": 0.3678973913192749,
+  "train_loss_first_20_mean": 4.838834500312805,
+  "train_loss_last_20_mean": 2.613932800292969,
+  "validation_loss_one_mc_draw": 3.0652260780334473,
+  "guidance": "learned noisy classifier; final residual masks use denoiser closure"
+}

lecture_4/verified_examples/classifier-exact/samples.txt

@@ -0,0 +1,8 @@
+GCGC
+GCGC
+ACGC
+GCGC
+GGTC
+GCAA
+CGTC
+GCGC

lecture_4/verified_examples/classifier-gradient/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "classifier-gradient",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/classifier-gradient"
+}

lecture_4/verified_examples/classifier-gradient/losses.json

@@ -0,0 +1,162 @@
+[
+  4.01927375793457,
+  3.8247132301330566,
+  6.5967559814453125,
+  3.0379931926727295,
+  5.381988048553467,
+  4.364372730255127,
+  6.268919944763184,
+  4.896388530731201,
+  2.5558066368103027,
+  5.216179847717285,
+  4.734250545501709,
+  5.792362213134766,
+  3.2293550968170166,
+  4.882113456726074,
+  4.7334160804748535,
+  4.435980796813965,
+  5.003822326660156,
+  5.925942420959473,
+  7.791959762573242,
+  4.085095405578613,
+  3.899994373321533,
+  3.2904622554779053,
+  3.4589755535125732,
+  2.720918655395508,
+  3.027308225631714,
+  3.0458157062530518,
+  3.7035269737243652,
+  3.8884239196777344,
+  4.001327037811279,
+  4.476953983306885,
+  2.1432690620422363,
+  4.810318946838379,
+  2.952962875366211,
+  4.420904159545898,
+  3.500626564025879,
+  4.333303928375244,
+  3.9793171882629395,
+  1.8058104515075684,
+  4.20003080368042,
+  3.7151639461517334,
+  2.2277348041534424,
+  2.7376279830932617,
+  3.615410327911377,
+  4.500275611877441,
+  5.066170692443848,
+  3.6637136936187744,
+  2.8754518032073975,
+  2.339322328567505,
+  2.037803888320923,
+  2.1924853324890137,
+  3.4916043281555176,
+  2.519395351409912,
+  2.597137451171875,
+  2.4708733558654785,
+  2.5220284461975098,
+  2.5972704887390137,
+  3.05387806892395,
+  5.856385231018066,
+  2.131591320037842,
+  3.3278908729553223,
+  2.400947093963623,
+  5.875596046447754,
+  3.1304073333740234,
+  3.21421217918396,
+  2.4150002002716064,
+  2.215695381164551,
+  2.139690637588501,
+  3.2768962383270264,
+  2.847025156021118,
+  3.595715045928955,
+  1.7762316465377808,
+  3.3017048835754395,
+  3.1203761100769043,
+  2.4890081882476807,
+  4.99165153503418,
+  3.243589401245117,
+  2.338869333267212,
+  1.9984252452850342,
+  3.838407516479492,
+  2.6884045600891113,
+  6.401689052581787,
+  1.2461563348770142,
+  2.748701810836792,
+  8.534076690673828,
+  3.991495132446289,
+  2.489625930786133,
+  2.2347571849823,
+  2.9534873962402344,
+  2.5714945793151855,
+  1.147279977798462,
+  2.4217231273651123,
+  1.3990497589111328,
+  2.5761783123016357,
+  2.3062100410461426,
+  3.08569073677063,
+  1.516831874847412,
+  3.085536003112793,
+  2.8733534812927246,
+  1.2969731092453003,
+  3.7263309955596924,
+  2.435549736022949,
+  3.5106093883514404,
+  2.7424113750457764,
+  3.264981269836426,
+  1.683659315109253,
+  1.149167776107788,
+  2.775585889816284,
+  3.208291530609131,
+  2.314664602279663,
+  3.91782283782959,
+  1.7896864414215088,
+  2.5307981967926025,
+  2.4437763690948486,
+  2.521484136581421,
+  2.2941794395446777,
+  1.6110831499099731,
+  3.128873825073242,
+  3.0251963138580322,
+  2.2769689559936523,
+  1.4722540378570557,
+  1.7136496305465698,
+  5.040107727050781,
+  2.9950344562530518,
+  4.272597789764404,
+  2.686481237411499,
+  2.7622010707855225,
+  3.0286059379577637,
+  2.0905165672302246,
+  2.4465155601501465,
+  2.035715341567993,
+  2.315361499786377,
+  1.4022663831710815,
+  3.5252881050109863,
+  2.6312732696533203,
+  3.7926905155181885,
+  1.7568085193634033,
+  1.798338532447815,
+  3.3464834690093994,
+  2.249241828918457,
+  2.2580409049987793,
+  4.0587310791015625,
+  2.206573247909546,
+  0.6222774982452393,
+  1.8168766498565674,
+  3.9070353507995605,
+  2.2064626216888428,
+  1.1733113527297974,
+  1.383936882019043,
+  2.251495599746704,
+  2.962852954864502,
+  2.8415677547454834,
+  1.3905932903289795,
+  3.165285587310791,
+  3.477961540222168,
+  1.7277320623397827,
+  2.4671823978424072,
+  5.010605812072754,
+  3.3257808685302734,
+  2.7084109783172607,
+  3.5739824771881104
+]

lecture_4/verified_examples/classifier-gradient/report.json

@@ -0,0 +1,15 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.5,
+    "mean_gc": 0.90625,
+    "mean_atat_match": 0.03125
+  },
+  "method": "classifier-gradient",
+  "data": "synthetic DNA; not biological validation",
+  "classifier_final_loss": 0.3678973913192749,
+  "train_loss_first_20_mean": 4.838834500312805,
+  "train_loss_last_20_mean": 2.613932800292969,
+  "validation_loss_one_mc_draw": 3.0652260780334473,
+  "guidance": "learned noisy classifier; final residual masks use denoiser closure"
+}

lecture_4/verified_examples/classifier-gradient/samples.txt

@@ -0,0 +1,8 @@
+GCGC
+CCGC
+GCTC
+GCGC
+GCGC
+GCAA
+GCGC
+GCGC

lecture_4/verified_examples/environment.json

@@ -0,0 +1,7 @@
+{
+  "python": "3.12.14",
+  "torch": "2.14.0+cpu",
+  "numpy": "2.3.5",
+  "scipy": "1.17.0",
+  "device": "cpu"
+}

lecture_4/verified_examples/mdlm/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "mdlm",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/mdlm"
+}

lecture_4/verified_examples/mdlm/losses.json

@@ -0,0 +1,162 @@
+[
+  4.01927375793457,
+  3.8247132301330566,
+  6.5967559814453125,
+  3.0379931926727295,
+  5.381988048553467,
+  4.364372730255127,
+  6.268919944763184,
+  4.896388530731201,
+  2.5558066368103027,
+  5.216179847717285,
+  4.734250545501709,
+  5.792362213134766,
+  3.2293550968170166,
+  4.882113456726074,
+  4.7334160804748535,
+  4.435980796813965,
+  5.003822326660156,
+  5.925942420959473,
+  7.791959762573242,
+  4.085095405578613,
+  3.899994373321533,
+  3.2904622554779053,
+  3.4589755535125732,
+  2.720918655395508,
+  3.027308225631714,
+  3.0458157062530518,
+  3.7035269737243652,
+  3.8884239196777344,
+  4.001327037811279,
+  4.476953983306885,
+  2.1432690620422363,
+  4.810318946838379,
+  2.952962875366211,
+  4.420904159545898,
+  3.500626564025879,
+  4.333303928375244,
+  3.9793171882629395,
+  1.8058104515075684,
+  4.20003080368042,
+  3.7151639461517334,
+  2.2277348041534424,
+  2.7376279830932617,
+  3.615410327911377,
+  4.500275611877441,
+  5.066170692443848,
+  3.6637136936187744,
+  2.8754518032073975,
+  2.339322328567505,
+  2.037803888320923,
+  2.1924853324890137,
+  3.4916043281555176,
+  2.519395351409912,
+  2.597137451171875,
+  2.4708733558654785,
+  2.5220284461975098,
+  2.5972704887390137,
+  3.05387806892395,
+  5.856385231018066,
+  2.131591320037842,
+  3.3278908729553223,
+  2.400947093963623,
+  5.875596046447754,
+  3.1304073333740234,
+  3.21421217918396,
+  2.4150002002716064,
+  2.215695381164551,
+  2.139690637588501,
+  3.2768962383270264,
+  2.847025156021118,
+  3.595715045928955,
+  1.7762316465377808,
+  3.3017048835754395,
+  3.1203761100769043,
+  2.4890081882476807,
+  4.99165153503418,
+  3.243589401245117,
+  2.338869333267212,
+  1.9984252452850342,
+  3.838407516479492,
+  2.6884045600891113,
+  6.401689052581787,
+  1.2461563348770142,
+  2.748701810836792,
+  8.534076690673828,
+  3.991495132446289,
+  2.489625930786133,
+  2.2347571849823,
+  2.9534873962402344,
+  2.5714945793151855,
+  1.147279977798462,
+  2.4217231273651123,
+  1.3990497589111328,
+  2.5761783123016357,
+  2.3062100410461426,
+  3.08569073677063,
+  1.516831874847412,
+  3.085536003112793,
+  2.8733534812927246,
+  1.2969731092453003,
+  3.7263309955596924,
+  2.435549736022949,
+  3.5106093883514404,
+  2.7424113750457764,
+  3.264981269836426,
+  1.683659315109253,
+  1.149167776107788,
+  2.775585889816284,
+  3.208291530609131,
+  2.314664602279663,
+  3.91782283782959,
+  1.7896864414215088,
+  2.5307981967926025,
+  2.4437763690948486,
+  2.521484136581421,
+  2.2941794395446777,
+  1.6110831499099731,
+  3.128873825073242,
+  3.0251963138580322,
+  2.2769689559936523,
+  1.4722540378570557,
+  1.7136496305465698,
+  5.040107727050781,
+  2.9950344562530518,
+  4.272597789764404,
+  2.686481237411499,
+  2.7622010707855225,
+  3.0286059379577637,
+  2.0905165672302246,
+  2.4465155601501465,
+  2.035715341567993,
+  2.315361499786377,
+  1.4022663831710815,
+  3.5252881050109863,
+  2.6312732696533203,
+  3.7926905155181885,
+  1.7568085193634033,
+  1.798338532447815,
+  3.3464834690093994,
+  2.249241828918457,
+  2.2580409049987793,
+  4.0587310791015625,
+  2.206573247909546,
+  0.6222774982452393,
+  1.8168766498565674,
+  3.9070353507995605,
+  2.2064626216888428,
+  1.1733113527297974,
+  1.383936882019043,
+  2.251495599746704,
+  2.962852954864502,
+  2.8415677547454834,
+  1.3905932903289795,
+  3.165285587310791,
+  3.477961540222168,
+  1.7277320623397827,
+  2.4671823978424072,
+  5.010605812072754,
+  3.3257808685302734,
+  2.7084109783172607,
+  3.5739824771881104
+]

lecture_4/verified_examples/mdlm/report.json

@@ -0,0 +1,13 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.75,
+    "mean_gc": 0.625,
+    "mean_atat_match": 0.09375
+  },
+  "method": "mdlm",
+  "data": "synthetic DNA; not biological validation",
+  "train_loss_first_20_mean": 4.838834500312805,
+  "train_loss_last_20_mean": 2.613932800292969,
+  "validation_loss_one_mc_draw": 2.5891432762145996
+}

lecture_4/verified_examples/mdlm/samples.txt

@@ -0,0 +1,8 @@
+CGTA
+ATGT
+GCGC
+TCGC
+GCGC
+GCGC
+TATA
+TCGA

lecture_4/verified_examples/peptune/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "peptune",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 160,
+  "search_steps": 40,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/peptune"
+}

lecture_4/verified_examples/peptune/losses.json

@@ -0,0 +1,162 @@
+[
+  4.01927375793457,
+  3.8247132301330566,
+  6.5967559814453125,
+  3.0379931926727295,
+  5.381988048553467,
+  4.364372730255127,
+  6.268919944763184,
+  4.896388530731201,
+  2.5558066368103027,
+  5.216179847717285,
+  4.734250545501709,
+  5.792362213134766,
+  3.2293550968170166,
+  4.882113456726074,
+  4.7334160804748535,
+  4.435980796813965,
+  5.003822326660156,
+  5.925942420959473,
+  7.791959762573242,
+  4.085095405578613,
+  3.899994373321533,
+  3.2904622554779053,
+  3.4589755535125732,
+  2.720918655395508,
+  3.027308225631714,
+  3.0458157062530518,
+  3.7035269737243652,
+  3.8884239196777344,
+  4.001327037811279,
+  4.476953983306885,
+  2.1432690620422363,
+  4.810318946838379,
+  2.952962875366211,
+  4.420904159545898,
+  3.500626564025879,
+  4.333303928375244,
+  3.9793171882629395,
+  1.8058104515075684,
+  4.20003080368042,
+  3.7151639461517334,
+  2.2277348041534424,
+  2.7376279830932617,
+  3.615410327911377,
+  4.500275611877441,
+  5.066170692443848,
+  3.6637136936187744,
+  2.8754518032073975,
+  2.339322328567505,
+  2.037803888320923,
+  2.1924853324890137,
+  3.4916043281555176,
+  2.519395351409912,
+  2.597137451171875,
+  2.4708733558654785,
+  2.5220284461975098,
+  2.5972704887390137,
+  3.05387806892395,
+  5.856385231018066,
+  2.131591320037842,
+  3.3278908729553223,
+  2.400947093963623,
+  5.875596046447754,
+  3.1304073333740234,
+  3.21421217918396,
+  2.4150002002716064,
+  2.215695381164551,
+  2.139690637588501,
+  3.2768962383270264,
+  2.847025156021118,
+  3.595715045928955,
+  1.7762316465377808,
+  3.3017048835754395,
+  3.1203761100769043,
+  2.4890081882476807,
+  4.99165153503418,
+  3.243589401245117,
+  2.338869333267212,
+  1.9984252452850342,
+  3.838407516479492,
+  2.6884045600891113,
+  6.401689052581787,
+  1.2461563348770142,
+  2.748701810836792,
+  8.534076690673828,
+  3.991495132446289,
+  2.489625930786133,
+  2.2347571849823,
+  2.9534873962402344,
+  2.5714945793151855,
+  1.147279977798462,
+  2.4217231273651123,
+  1.3990497589111328,
+  2.5761783123016357,
+  2.3062100410461426,
+  3.08569073677063,
+  1.516831874847412,
+  3.085536003112793,
+  2.8733534812927246,
+  1.2969731092453003,
+  3.7263309955596924,
+  2.435549736022949,
+  3.5106093883514404,
+  2.7424113750457764,
+  3.264981269836426,
+  1.683659315109253,
+  1.149167776107788,
+  2.775585889816284,
+  3.208291530609131,
+  2.314664602279663,
+  3.91782283782959,
+  1.7896864414215088,
+  2.5307981967926025,
+  2.4437763690948486,
+  2.521484136581421,
+  2.2941794395446777,
+  1.6110831499099731,
+  3.128873825073242,
+  3.0251963138580322,
+  2.2769689559936523,
+  1.4722540378570557,
+  1.7136496305465698,
+  5.040107727050781,
+  2.9950344562530518,
+  4.272597789764404,
+  2.686481237411499,
+  2.7622010707855225,
+  3.0286059379577637,
+  2.0905165672302246,
+  2.4465155601501465,
+  2.035715341567993,
+  2.315361499786377,
+  1.4022663831710815,
+  3.5252881050109863,
+  2.6312732696533203,
+  3.7926905155181885,
+  1.7568085193634033,
+  1.798338532447815,
+  3.3464834690093994,
+  2.249241828918457,
+  2.2580409049987793,
+  4.0587310791015625,
+  2.206573247909546,
+  0.6222774982452393,
+  1.8168766498565674,
+  3.9070353507995605,
+  2.2064626216888428,
+  1.1733113527297974,
+  1.383936882019043,
+  2.251495599746704,
+  2.962852954864502,
+  2.8415677547454834,
+  1.3905932903289795,
+  3.165285587310791,
+  3.477961540222168,
+  1.7277320623397827,
+  2.4671823978424072,
+  5.010605812072754,
+  3.3257808685302734,
+  2.7084109783172607,
+  3.5739824771881104
+]

lecture_4/verified_examples/peptune/report.json

@@ -0,0 +1,350 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 1.0,
+    "mean_gc": 0.75,
+    "mean_atat_match": 0.25
+  },
+  "method": "peptune",
+  "data": "synthetic DNA; not biological validation",
+  "train_loss_first_20_mean": 4.838834500312805,
+  "train_loss_last_20_mean": 2.613932800292969,
+  "validation_loss_one_mc_draw": 2.5891432762145996,
+  "archive_scores": [
+    [
+      1.0,
+      0.0
+    ],
+    [
+      0.5,
+      0.5
+    ],
+    [
+      0.75,
+      0.25
+    ]
+  ],
+  "search_trace": [
+    {
+      "iteration": 0,
+      "archive_size": 1,
+      "score": [
+        0.25,
+        0.25
+      ]
+    },
+    {
+      "iteration": 1,
+      "archive_size": 2,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 2,
+      "archive_size": 2,
+      "score": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 3,
+      "archive_size": 2,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 4,
+      "archive_size": 2,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 5,
+      "archive_size": 2,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 6,
+      "archive_size": 2,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 7,
+      "archive_size": 2,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 8,
+      "archive_size": 2,
+      "score": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 9,
+      "archive_size": 2,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 10,
+      "archive_size": 2,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 11,
+      "archive_size": 3,
+      "score": [
+        0.75,
+        0.25
+      ]
+    },
+    {
+      "iteration": 12,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 13,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 14,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 15,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 16,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 17,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 18,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 19,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 20,
+      "archive_size": 3,
+      "score": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 21,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 22,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 23,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 24,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 25,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 26,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 27,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 28,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 29,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 30,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 31,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 32,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 33,
+      "archive_size": 3,
+      "score": [
+        0.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 34,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 35,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 36,
+      "archive_size": 3,
+      "score": [
+        1.0,
+        0.0
+      ]
+    },
+    {
+      "iteration": 37,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    },
+    {
+      "iteration": 38,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.0
+      ]
+    },
+    {
+      "iteration": 39,
+      "archive_size": 3,
+      "score": [
+        0.5,
+        0.5
+      ]
+    }
+  ],
+  "scope": "DNA MCTS mechanism; not peptide-model training or paper reproduction"
+}

lecture_4/verified_examples/peptune/samples.txt

@@ -0,0 +1,3 @@
+GCGC
+ACGT
+GCGT

lecture_4/verified_examples/udlm/config.json

@@ -0,0 +1,18 @@
+{
+  "method": "udlm",
+  "mode": "train-sample",
+  "train_steps": 160,
+  "sample_steps": 40,
+  "classifier_steps": 300,
+  "search_steps": 100,
+  "batch_size": 16,
+  "samples": 8,
+  "length": 4,
+  "width": 32,
+  "block_size": 2,
+  "strength": 1.5,
+  "label": 1,
+  "seed": 7,
+  "data": null,
+  "out": "outputs/udlm"
+}

lecture_4/verified_examples/udlm/losses.json

@@ -0,0 +1,162 @@
+[
+  11.047435760498047,
+  3.638819932937622,
+  4.339240550994873,
+  6.615440368652344,
+  7.487863540649414,
+  3.715148448944092,
+  4.2508416175842285,
+  5.987113952636719,
+  4.574474334716797,
+  2.5587449073791504,
+  7.678818225860596,
+  10.757691383361816,
+  3.761280059814453,
+  6.221782684326172,
+  2.411395788192749,
+  3.9185919761657715,
+  2.432310104370117,
+  5.186282157897949,
+  2.995053768157959,
+  3.0481975078582764,
+  6.479434490203857,
+  4.919713497161865,
+  2.8192875385284424,
+  2.8869221210479736,
+  8.790794372558594,
+  2.300025463104248,
+  3.3890492916107178,
+  3.32928466796875,
+  3.703833818435669,
+  2.642963409423828,
+  3.1563267707824707,
+  2.6353256702423096,
+  3.5707004070281982,
+  2.8710131645202637,
+  2.8604514598846436,
+  3.6414551734924316,
+  4.774967193603516,
+  2.004885673522949,
+  8.153873443603516,
+  1.7916756868362427,
+  2.389755964279175,
+  4.308714389801025,
+  3.9405770301818848,
+  6.173405170440674,
+  2.9836504459381104,
+  2.4070658683776855,
+  4.4768242835998535,
+  4.716032981872559,
+  2.6472368240356445,
+  2.835066795349121,
+  2.540917158126831,
+  3.043062925338745,
+  5.332056045532227,
+  3.2398338317871094,
+  4.370035171508789,
+  2.7836556434631348,
+  4.69325590133667,
+  1.9069887399673462,
+  3.3850021362304688,
+  2.8949105739593506,
+  6.395257472991943,
+  6.112308979034424,
+  2.172653913497925,
+  3.731419324874878,
+  3.2633914947509766,
+  2.7229864597320557,
+  3.2528135776519775,
+  6.598641395568848,
+  2.3790218830108643,
+  1.4963032007217407,
+  2.819007158279419,
+  2.80535888671875,
+  2.719237804412842,
+  2.0492019653320312,
+  3.2515711784362793,
+  1.8298454284667969,
+  2.3929498195648193,
+  2.056596517562866,
+  15.28537654876709,
+  3.128511667251587,
+  2.0100417137145996,
+  1.5984283685684204,
+  1.9779601097106934,
+  3.192647695541382,
+  2.118055582046509,
+  2.90411114692688,
+  3.8938608169555664,
+  2.1555304527282715,
+  2.7105512619018555,
+  3.3428311347961426,
+  1.0114843845367432,
+  3.9458742141723633,
+  5.690505027770996,
+  3.6527702808380127,
+  1.1432782411575317,
+  5.013024806976318,
+  2.777940273284912,
+  3.2634408473968506,
+  4.932656288146973,
+  4.210480690002441,
+  2.6948583126068115,
+  2.285061836242676,
+  3.583308696746826,
+  2.962766647338867,
+  2.7541191577911377,
+  2.287432909011841,
+  3.1161656379699707,
+  2.5217714309692383,
+  3.1153383255004883,
+  1.9834219217300415,
+  2.0762336254119873,
+  2.764826536178589,
+  2.7770273685455322,
+  1.6031702756881714,
+  4.0543365478515625,
+  2.547313690185547,
+  2.8786070346832275,
+  2.6822168827056885,
+  6.25325345993042,
+  2.590442419052124,
+  2.122274398803711,
+  1.6236686706542969,
+  1.8864619731903076,
+  2.4540152549743652,
+  3.4854989051818848,
+  3.156172513961792,
+  4.207565784454346,
+  3.6062185764312744,
+  2.4027581214904785,
+  1.1646852493286133,
+  4.980432510375977,
+  6.687517166137695,
+  1.4371603727340698,
+  1.6977627277374268,
+  3.9442780017852783,
+  2.9689416885375977,
+  2.100611686706543,
+  2.377840995788574,
+  3.0913102626800537,
+  6.303923606872559,
+  2.232814073562622,
+  1.8777183294296265,
+  1.323475956916809,
+  3.0791330337524414,
+  1.765347957611084,
+  1.629030466079712,
+  2.6598291397094727,
+  2.1885077953338623,
+  2.656402587890625,
+  2.2888011932373047,
+  2.212771415710449,
+  1.9104533195495605,
+  4.000855445861816,
+  2.3612029552459717,
+  1.7967439889907837,
+  1.9667776823043823,
+  2.8789355754852295,
+  1.4103233814239502,
+  1.952869176864624,
+  3.3791284561157227
+]

lecture_4/verified_examples/udlm/report.json

@@ -0,0 +1,14 @@
+{
+  "metrics": {
+    "valid_dna": true,
+    "unique_fraction": 0.875,
+    "mean_gc": 0.625,
+    "mean_atat_match": 0.25
+  },
+  "method": "udlm",
+  "data": "synthetic DNA; not biological validation",
+  "train_loss_first_20_mean": 5.131326353549957,
+  "train_loss_last_20_mean": 2.2785560965538023,
+  "validation_loss_one_mc_draw": 2.245309829711914,
+  "endpoint_approximation": "t in [0.02, 0.98]; stop at residual noise 0.02, without a posterior interpretation of the UDLM parameter vector"
+}