Actual Verification Records

2026-10-11: Added a GPU rental recommendation (Zhichuan Cloud invitation link)

Check	Actual result
Content	The home page gained "Rent a GPU: Zhichuan Cloud, which the author uses"; section 3.1 gained "Where to rent" (prices, new-user vouchers, instance choice, experience with data disks and mirror sources); the account and budget rows of the preparation table in section 0.4 were changed to RMB examples. All include the invitation link and invitation code zt4f01m0, and state that it is the author's invitation link and explain the voucher redemption rules
Price source	User-provided page screenshot from 2026-10-11: RTX 4090D 24 GB pay-as-you-go ¥1.25/hour, daily ¥29, weekly ¥200, monthly ¥800; the invitation rules come from a user-provided screenshot of the invitation page. gpuhome.cc is a client-rendered page that opened blank in the built-in browser, so it could not be checked directly
Regression tests / e-book	106 passed; mkdocs build --strict passed, 52 pages and 27,728 link and resource checks passed
Price screenshot	The user-provided rental page screenshot was converted to images/gpuhome-rtx4090d-price-2026-10-11.png and embedded on the home page and below the price table in section 3.1

2026-10-11: Added an author introduction to the home page; target reader changed to non-ML developers

Check	Actual result
Content	The home page gained "About the author" (bio, X, WeChat Official Account, Xiaohongshu (RED), and two QR codes); the target reader on the home page, the tutorial opening, README, the site description and CLAUDE.md was changed to "developers who don't do ML and want to learn LoRA fine-tuning from scratch"; the chapter 1 title and the "backend analogy" were changed to general development analogies
Images	images/author-wechat-qrcode.jpg; the Xiaohongshu QR code was cropped from a business-card screenshot as images/author-xiaohongshu-qrcode.jpg; book/build.py now publishes both PNG and JPG files under images/
Regression tests / e-book	106 passed; mkdocs build --strict passed, 52 pages and 27,716 link and resource checks passed; a local preview was visually checked and the layout looks fine at desktop and phone widths

2026-10-11: Notebook section 13 switched to curl calls

Check	Actual result
Content	Notebook section 13 dropped the Python examples in favor of 5 curl groups: health check, minimal request, request in the training format (system = role + grade band + fact cards), multi-turn, streaming; tutorial section 5.5 gained the same "Call it directly with curl first", and the original Python and SDK examples were kept
Request bodies	The two JSON files are generated by build_messages; with the Qwen tokenizer the single-turn request's prompt_tokens comes to 395; the heredocs were actually executed with bash on this machine, and the generated files are all valid JSON
Tests	test_tutorial.py gained curl tests: the model name matches --served-model-name, temperature=0, a streaming example is present, and the messages in the files are identical to the build_messages output; the Python call example is now read from plan.md and executed. 106 passed
E-book / bundle	mkdocs build --strict passed, 52 pages and 27,708 link and resource checks passed; the GPU upload bundle was rebuilt
Not yet checked	curl responses from a real vLLM server

2026-10-11: First full 1-Epoch training run on an RTX 4090 (measured by the user on the GPU host)

Check	Actual result
Environment	RTX 4090 24 GB (driver 580.119.02, max CUDA 13.0); image 2.7.1-CUDA12.6-Py3.11-Ubuntu22; the official PyTorch index was unreachable, so torch was installed from a domestic mirror
Loading	After loading the NF4 base model, nvidia-smi showed 4353 MiB
Training	runs/science-002, 72/72 steps, took 26:19; average training loss 2.233; per-step training loss first/last 5.813 → 1.55
Validation loss	At steps 12/24/36/48/60/72: 2.506 / 2.186 / 2.034 / 1.976 / 1.961 / 1.960; Mean Token Accuracy 0.462 → 0.573
Lesson from a failure	Twice before, the training cell was re-run without restarting the kernel, so training continued on an already-trained model: training loss dropped to about 0.5 and validation loss climbed back to 2.3 (overfitting); runs/science-001 was deleted
Docs	The curve screenshot was saved as images/loss-curve-rtx4090-2026-10-11.png and added to section 4.5 with a segment-by-segment explanation; book/build.py now publishes all PNGs under images/
Not yet checked	The step 8 completion record (peak VRAM, adapter files), base-model validation loss with LoRA disabled, the step 10 answer comparison, merge and vLLM

2026-10-10: Alibaba Cloud mirror fallback when the official PyTorch index is unreachable

Check	Actual result
Trigger	Running pip install torch==2.8.0 --index-url https://download.pytorch.org/whl/cu126 on the GPU host failed with Network is unreachable (the user's actual output)
Mirror check	Queried mirrors.aliyun.com/pytorch-wheels from the development machine: the cu126 directory has torch-2.8.0+cu126-cp311-manylinux_2_28_x86_64; the cu129 directory has cp311 Linux packages for torch 2.11.0, torchaudio 2.11.0 and torchvision 0.26.0, which vLLM 0.21.0 requires (dependency versions taken from the vLLM 0.21.0 metadata on PyPI). Not yet actually installed from the mirror on the GPU host
Docs	Section 3.3, section 5.4, the Notebook deployment cell and GPU_UPLOAD_README.md gained the -f https://mirrors.aliyun.com/pytorch-wheels/... fallback command; the GPU upload bundle was rebuilt (31 files, 3.89 MiB)
Regression tests / e-book	105 passed; mkdocs build --strict passed, 52 pages and 27,600 link and resource checks passed

2026-10-10: Section 3.3 explains the upload bundle contents

Check	Actual result
Content	Section 3.3 gained the packaging command and "What's in the upload bundle": a directory tree and purposes written from the 31 files actually listed by unzip -l, plus a separate list of what is not in the bundle and where it comes from; the old section number in a requirements-train.txt comment was changed to 3.1
Bundle	Rebuilt with tools/build_gpu_zip.py: 31 files, 3.89 MiB
Regression tests / e-book	105 passed; mkdocs build --strict passed, 52 pages and 27,594 link and resource checks passed

2026-10-10: Trimmed the second half of chapter 2

Check	Actual result
Content	Section 2.4 gained "Is a multi-turn conversation trained multiple times?" and how multi-turn history accumulates; the old 2.6–2.11 became 2.6 seven-step recap, 2.7 changing and swapping data, 2.8 optional local checks; the duplicated observation-question explanation was removed (section 4.5 already has it); review requirements moved to section 6.1, the CLI snapshot explanation moved to section 4.6, and the few-shot selection explanation moved to section 6.4; related section-number references were updated
Regression tests	105 passed (the tutorial lost two duplicate example commands, lab.prepare/lab.audit; every CLI still has at least one example)
E-book	mkdocs build --strict passed; 52 pages and 27,561 local link and resource checks passed

2026-10-10: Added "Why fact cards are needed"

Check	Actual result
Content	Section 2.2 gained "Why fact cards are needed: three common questions" (why cards are needed when the base model already knows common sense; cards are input, not a learning target, and after training you can't rely on the model remembering them; why they must also be included during training), with data/README.md updated to match; sections 0.1 and 2.5 gained pointers to it; below the table in section 2.1, "Why a val set is still needed" was added
Regression tests	107 passed
E-book	mkdocs build --strict passed; 52 pages and 27,594 local link and resource checks passed; a local preview was visually checked and the chapter 2 blockquotes and comparison table render fine

2026-10-10: dataset.json changed to side-by-side train/val/test (schema 4)

Check	Actual result
Data conversion	The top level became four side-by-side arrays, facts, train, val, test; the split field was removed from conversations, with content unchanged; lab.data --allow-draft --formal prints {'train': 500, 'val': 50, 'test': 50}
Reading logic	lab.data.tag_splits adds split in memory based on the containing array; the old episodes layout and conversations that carry their own split both raise errors; validate, prepare and infer are unchanged
CLI snapshot	Ran lab.prepare --allow-draft --formal with the pinned Qwen tokenizer: 9 files, 1150 train and 115 val SFT samples; all 50 conversations in val.episodes.jsonl are split: val
Docs	Section 2.2 gained "What fact cards are for and where they are used" (validation, prompt assembly, Notebook, snapshot, A/B/C inference, blind review, deployment calls); data/README.md, README and the GPU upload instructions were updated to match
Regression tests	107 passed (three new tests: side-by-side layout, rejection of the old layout, Notebook D1 reading)
E-book	mkdocs build --strict passed; 52 pages and 27,571 local link and resource checks passed; the GPU upload bundle was rebuilt (31 files, 3.88 MiB)

2026-10-10: Chapters reordered; the "Advanced and Reference" collapsible removed

Check	Actual result
Structure	The old chapters 0–13 were consolidated into chapters 0–8 + appendices: 0 goals and preparation (newly written full workflow, how the two machines work together, preparation checklist), 1 concepts, 2 training data (old chapters 3–5), 3 GPU, 4 training, 5 deployment, 6 quality evaluation (old chapters 8–9), 7 cost, troubleshooting and acceptance, 8 developer reference (old chapters 11 and 13); the sidebar is a single flat table of contents, and collapsible blocks in the body became ordinary subsections
New explanations	Chapters 2–6 each open with a "Chapter at a glance" box (what you do / what you need / what you get / time); section 2.5 adds day-night-01:0 as actually rendered with the pinned Qwen tokenizer (408 tokens, 22 supervised tokens); section 4.1 explains what happens inside one step; chapter 5 opens with a diagram of an API request's path
Reference updates	Chapter numbers in plan.md, the Notebook, README, GPU_UPLOAD_README, todo.md and book/README.md were updated to the new numbering; the GPU upload bundle was rebuilt (31 files, 3.88 MiB)
Regression tests	103 passed
E-book	mkdocs build --strict passed; 52 pages and 28,089 local link and resource checks passed; a local preview was visually checked and the diagrams and at-a-glance boxes in chapters 0, 2, 4 and 5 render fine

2026-10-04: Revision focused on learning deployment

Check	Actual result
Training amount	The Notebook computes the step count from the sample count: 1150 train samples ÷ accumulation 16 → 72 steps (1 Epoch); added eval loss on 115 val samples (every 12 steps) and loss-curve.png
Data cleanup	Removed stray half-width spaces left by concatenation from 662 answers; rewrote 60 answers each for increase_depth_when_requested, ask_for_evidence_without_blame and explain_then_invite_exploration; lab.data --allow-draft --formal passed
Real tokenization	Regenerated with the pinned Qwen tokenizer: 1150 train, 115 val; longest 550 tokens, average 459 tokens, average 36 supervised tokens
CLI draft gate	lab.train --allow-draft can run epoch comparisons, and the manifest records draft; freezing a candidate and test-set inference still require reviewed data
Deployment chapter	Chapter 10 gained a KV cache estimate (144 KiB per token), parameter explanations, a mounted adapter, OpenAI SDK streaming calls, vllm bench serve load testing, and a go-live checklist
Call examples	The local API example now uses build_messages, so the prompt matches training; it is still executed by test_tutorial.py against a temporary HTTP server
GPU upload bundle	New tools/build_gpu_zip.py builds it: 31 files, about 3.88 MiB, no weights; it refuses to package a Notebook with outputs
Regression tests	103 passed (including the eval and loss-curve cells of the Notebook executed with a tiny CPU model)
E-book	mkdocs build --strict passed; 57 pages and 28,387 local link and resource checks passed; main navigation changed to Learning path → Concepts → GPU → Training → Deployment

| Readability for beginners (2026-10-08) | Chapter 2 was rewritten as an 8-section progressive concept lesson (model directory, a concrete token example, intuition for loss values, LoRA as a diff analogy, how the seven libraries divide the work); chapter 6 gained a section on nvidia-smi/driver/CUDA and a Jupyter operations table; the governance content in chapter 4 was collapsed as advanced material; every Notebook code cell gained "What you'll see after running it" and a per-parameter table (BitsAndBytesConfig, generate, LoraConfig, SFTConfig); the expected output values in the Notebook are estimates, to be checked against real GPU runs |

This round still did not run on an RTX 4090: the actual time and VRAM for 72 steps, the vLLM 0.21 startup log, and the parameters and results of vllm bench serve are all subject to real measurements on the GPU host.

2026-09-29: Primary-school science exploration, 500 training conversations

Check	Actual result
Single editable data source	data/dataset.json: 60 fact cards; 500 train, 50 val, 50 test; 2–3 turns per conversation
Coverage	100/10/10 conversations for each of the five categories; train has 167, 167 and 166 conversations for grades 1–2, 3–4 and 5–6 respectively
Generation method	10 teaching paths for each of 50 training topics; knowledge, misconceptions, limits of analogies, observations and follow-up questions were written topic by topic and then combined into complete conversations; some answers are reused within a topic, so these are not 500 independent knowledge questions
Data status	All synthetic/draft; 35 cards record reading of the reference source, 25 are still marked pending; every individual fact, child readability and real exploration effectiveness are still awaiting review
Supervision counts	1150 train answer targets, 115 each for val/test; training filters train only
Reference card independence	Facts were rewritten as independent summaries; no complete assistant target was found verbatim in the corresponding fact text; this does not rule out all semantic similarity
Real tokenization and masking	The pinned Qwen tokenizer and the real TRL collator checked 1150/1150 samples as passing, longest 553 tokens; the first sample is 408 tokens, with 22 supervised positions
Data snapshot	Final corresponds to data/processed/science-v3, 9 auto-generated files; v1/v2 are old snapshots from this round's cleanup process, and formal use should re-run prepare from the source data
Input and isolation	grade_band enters the prompt; behavior/review/source_url do not; the same topic and the same fact cannot cross splits; future Q&A cannot leak
Evaluation protocol	B/C keep the same input; few-shot examples prefer covering all three grade bands and are taken only from train; blind review keeps the grade band, bootstrap is clustered by topic, and each evaluation set has only 5 independent topics
Notebook and tutorial	46 cells / 16 code cells, outputs empty, each cell with an explanation; science observation questions, data description, formal comparison, vLLM and Chinese API examples are in sync
Experiment directory	The new scenario defaults to runs/science-001, to avoid confusion with the old scenario's lesson/gpu directories
Regression tests	101 passed, 10 warnings; including tiny CPU LoRA update/save/reload/merge and the tutorial's API requests and history passing
Release boundary	This round did not run real 4B CUDA training or vLLM, nor any study with children; local checks cannot prove that LoRA beats a full-prompt baseline

The final builds and consistency checks of the e-book and the GPU ZIP were completed with this round's delivery. Everything below is historical version records; old scenarios and old counts do not represent the current data.

2026-09-29: Single-file data and D1–D7 usage notes

Check	Actual result
Data merge	data/dataset.json holds the original 10 fact cards, 30 conversations, 60 reference answers and all metadata; objects are identical before and after migration, and the two duplicate source JSONL files were deleted
Main entry point	The Notebook reads the single file directly and builds samples in memory, without depending on the processed directory; D1–D7 mark reading, filtering, context, targets, trainer, labels and save location
Training content	Executed the Notebook's sample-generation cell with the real pinned Qwen tokenizer; all 60 prompt/completion/input_ids/completion_mask entries match the old seed-v2. The first sample is still 302 tokens, with 53 supervised positions
Leak prevention	Tests confirm val/test do not enter training, the current target and future turns do not enter the prompt, and history is kept correctly; source URLs and review fields are not used as model input
Regression tests	95 passed, 0 skipped, 10 warnings; real tiny CPU LoRA training, saving, reloading, merging and the tutorial API examples passed
Notebook format	nbformat validation passed, 46 cells / 16 code cells; every code cell has an explanation below it, and delivered outputs are empty
Experiment review	Before training, the in-memory data is saved to runs//dataset.json, and the copy's SHA-256 is recorded in the manifest; day to day, only data/dataset.json is edited
CLI	data/prepare changed to --input data/dataset.json; advanced experiments generate snapshots as needed; the historical seed-v1/v2 and runs were kept
Upload bundle	31 files, about 3.82 MiB; contains only one copy of the source data and no intermediate files from processed; after extraction, verified 30 conversations and 60 training targets, with files byte-for-byte identical to the source
Lightweight CLI	In the Torch-free .venv-data, prepared the single-file data with --input; the 60 generated samples match the old snapshot; then the real TRL collator's mask/EOS/padding check passed
E-book	Strict build passed; 54 pages and 5,987 local link and resource checks passed; the data page shows one complete conversation and the facts it references, and the old two-file source pages were removed

The 10 warnings still come from the tiny model's PEFT config path and checkpoint timestamp ordering. This round did not run real 4B CUDA training on an RTX 4090 or a vLLM service; data and local code verification do not indicate improved model quality.

The following are records of earlier versions; for the old data entry point and file counts, this section is authoritative.

2026-09-29: Final correspondence check of e-book, Notebook and code

Check	Actual result
Full regression	91 passed, 0 skipped, 10 warnings; includes the actual Notebook tiny training run and local HTTP checks of the tutorial API examples
Tutorial commands	The lab.* commands in README, the data description and the main text all pass the corresponding real CLI parsers; every remaining CLI has a runnable example
Entry points and explanations	Chapter 13 maps item by item to the existing modules; filled in switching to the advanced training environment and the A/B/C data and prompt differences; the Notebook and chapter 10 deployment/call code match block by block
Source sync	The training appendix matches the two actual training modules; the build removes old auto-generated source pages and download copies
Cleanup	Deleted lab/client.py and its old tests; the standard-library API example in the material is now tested directly instead. Kept the CLIs still used for formal comparison, blind review, resume and export
Download version	Fixed an issue where the first download from Hugging Face could fetch a newer revision; all three download sources now use the tutorial's pinned version, and old version directories are not silently rewritten
Actual data	Re-checked seed-v2 with the pinned Qwen tokenizer and the TRL collator; supervision range, EOS and padding passed for 60/60 samples
GPU upload bundle	Updated to 38 files, about 3.85 MiB; after extraction, the frozen data yields 60 training samples; the old client was removed
E-book and delivery bundles	Strict build passed; 55 pages and 4,880 local links and resources passed. The 37 source files in the GPU ZIP and the 53 files in the general source ZIP correspond byte-for-byte to the current files; the general source ZIP builds independently after extraction and passes the link check
Doc snippets	32 Bash blocks, 3 Python blocks and 10 JSON blocks pass syntax checks; the SSH tunnel address/port placeholders were replaced as the text instructs before checking, without connecting to a remote host

The above is the correspondence that can be verified locally. The 10 warnings come from the tiny model's PEFT config path and checkpoint timestamp ordering. No RTX 4090 was connected, so this cannot be used to claim that a real 4B download, CUDA/NF4 training, quality review or vLLM service has passed; the GitHub Pages workflow was also not published in this round.

The following records correspond to earlier versions; for file counts, entry points and test counts, this section is authoritative.

2026-09-29: Teaching Notebook rewrite and domestic downloads

Check	Actual result
Full regression	51 passed, 0 skipped, 10 warnings; local port tests run in an environment that allows listening
Notebook format	Official nbformat validation passed; 44 cells, 15 of them Python code cells; each cell has its purpose and rationale below it, and delivered outputs are empty
Notebook real code	Extracted the actual code cells and used a tiny Qwen3 CPU model to run LoRA config, TRL supervision checks, two training steps, save, reload, generate, merge and reload of the full model; reloaded logits match, merged logits match within tolerance
Device boundary	CPU tests only replace CUDA device/precision settings; training is not simulated with command return values. The PEFT load device is pinned explicitly so the CPU merge is not automatically moved to the GPU; the CLI merge was fixed the same way
Download sources	ModelScope 1.34.0 actually downloaded 9 config/tokenizer files, each matching the pinned HF revision by SHA-256; the real Qwen tokenizer fingerprint matches seed-v2
Weight accessibility	Read 64 bytes from each of the three safetensors shards, all returning HTTP 206; the total size in Content-Range matches the frozen manifest. The full 8 GB of weights was not downloaded
Download failure protection	Tests partial local cache, same-size corrupted files, remote version changes, tokenizer changes, version-lock protection, mirror endpoints and offline integrity checks
E-book	Chapter 6 covers the environment and domestic downloads; chapter 7 corresponds to direct training; chapter 10 explains export, vLLM and local single-turn/multi-turn calls; strict build and local link checks passed
Upload bundle	39 files, about 3.85 MiB; after extraction the 60 frozen samples are complete, and the Notebook/code/download lock and dependencies are in sync; no environments, caches, full weights or training results
Cleanup	Deleted the old Notebook subprocess helper module, optional workflow switches and automatic packaging of a results ZIP; kept the CLIs still used by the tutorial for formal evaluation, training resume, etc.

References: ModelScope model repository, vLLM 0.21 GPU installation, IPython kernel registration. The user-provided Zhihu article triggered a security verification and its body could not be read; the mirror endpoint was checked against the SDK and official docs, with no claim of having read the full article.

The 10 warnings come from the tiny model's PEFT config path and checkpoint timestamp ordering. Testing found that PEFT's default automatic device placement would move the CPU merge off the CPU; the device is now specified explicitly and the full regression passes. The user's RTX 4090 was not connected; real 4B download, CUDA/NF4 training, quality review and the vLLM service have not yet been run on that host. vLLM uses a separate environment; first check that the host driver supports CUDA 12.9.

The following are historical records of earlier versions; the old Notebook workflow has been replaced by this rewrite.

2026-09-29: GPU Notebook and tutorial entry point

Check	Actual result
Full regression tests	46 passed, 0 skipped, 6 warnings; new checks for Notebook subprocess interrupt cleanup, error returns, output protection, file syntax, download consistency, and refusing to package when only audit results exist
Notebook format	notebooks/01_gpu_train.ipynb passed official nbformat validation, 33 cells (18 code cells); execution counts and outputs in the delivered file are empty
Cell flow	In a real local Jupyter kernel, ran the default workflow and all optional workflows with simulated command results; call arguments were validated by the real CLI parsers, and result reading, HTML escaping of answers and ZIP backup passed. Installation, downloads and GPU computation all used test doubles
E-book	Chapter 6 uses the Notebook as the main entry point, with chapters 7 and 10 providing the corresponding steps; strict build and local link checks passed, and the Notebook download file matches the source file
GPU upload bundle	llm-lora-tutorial-gpu.zip updated to 37 files, about 3.84 MiB; ZIP integrity, import after extraction and the 60 frozen training samples were checked as passing; it contains the Notebook and its execution helper module, without full weights or local environments

Reproduced the issue from the user's screenshot where "a results ZIP could still be generated with only token-audit.json"; fixed step 13: it now checks the A/B/C replies, the 10-step training record and the adapter files before allowing packaging. The default and optional workflows passed the local kernel simulation check again, and the GPU upload bundle was updated; the existing Notebook on the user's machine needs to be synced separately.

This round did not connect to the user's RTX 4090, did not download the full 4B weights, and did not run real GPU training. The Notebook workflow simulation and the CPU tiny-training regression can only verify what is checkable locally; real CUDA, NF4, VRAM, time and training quality are still subject to records from running on the GPU. The 6 warnings come from the existing tiny-model save and checkpoint timestamp ordering; the HTTP tests were completed in an environment that allows temporary local ports.

2026-09-26: Data and tutorial streamlining

Check	Actual result
Full regression tests	38 passed, 0 skipped, 6 warnings; includes new and old data bundles, missing sets, the data browsing page and the existing tiny training checks
Lightweight data environment	Created .venv-data and installed Transformers 4.57.3 and Jinja2 3.1.6 with their dependencies per requirements-data.txt; confirmed torch, trl, peft, datasets and accelerate are not installed
Data preparation in the lightweight environment	Generated 30 conversations and 60 training samples; the 5 files in the manifest are byte-for-byte identical to the seed-v2 generated in the full CPU environment
Data bundle structure	The new schema=2 has 6 files in total; the 13 files of the old seed-v1 are kept and pass the integrity check
Data and supervision	Source data content unchanged; the real Qwen tokenizer and the TRL collator checked 60/60 samples as passing; report at runs/token-audit-v2.json
Example in the book	The Palace Museum example comes from the real first record; palace-01:0 totals 302 tokens, with 249 context positions and 53 supervised positions
Doc code	The 30 Bash blocks, 2 Python blocks, 1 embedded Python snippet and 10 JSON blocks in the README, tutorial and data description pass syntax checks; the training code appendix matches the source
E-book build	mkdocs build --strict passed; 51 HTML pages and 4192 local link and resource checks passed
Browser check	Checked the data chapter at desktop and 390px phone width; long JSON wraps automatically, no horizontal overflow, EOS fields are fully displayed; the source data page shows the purpose and the first record first, with the full raw text collapsed by default

The first lightweight run found that the chat template was missing Jinja2; after adding the dependency, preparation succeeded. Transformers' warning that no model compute library is available is expected in this environment; tokenization and template rendering both work. The HTTP tests were completed in an environment that allows temporary local ports; the sandbox's listening restriction was not handled by skipping tests.

The 6 warnings come from the tiny model's save config and checkpoint timestamp ordering, the same kind as in earlier verification. This time only data processing, the CPU training mechanism and the book's web pages were verified; no 4B GPU training was run, and no candidate conversations were approved in review.

2026-09-23: First verification record

The first execution record is kept below.

Environment

• Local Darwin 25.3.0 arm64, Python 3.11.15.
• Tests used a temporary isolated environment /tmp/beijing-lora-env, without changing the system Python.
• Torch 2.8.0, Transformers 4.57.3, TRL 0.24.0, PEFT 0.18.0, Accelerate 1.11.0, Datasets 4.3.0, pytest 8.4.2.
• uv pip check passed for 52 installed packages. This is a Mac CPU environment without bitsandbytes; it cannot be used to claim the Linux CUDA combination has been brought up.

Executed

Check	Result
Full python -m pytest -q tests	27 passed, 0 skipped, 6 warnings, about 3.92 seconds this time
CLI entry points	--help succeeded for all 9: download/data/prepare/audit/train/infer/evaluate/merge/client
Python syntax	All lab and tests files parse
Tutorial static checks	Syntax of 31 Bash code blocks, 2 complete Python code blocks, 1 JSON example and all local Markdown links passed
Raw data	10 cards, 30 conversations, 60 target replies, 6 conversations per each of the five categories; all draft
Real Qwen tokenizer	Pinned revision; downloaded config and tokenizer, not the 4B weights
Data preparation	seed-v1, train=30 conversations, 60 expanded samples; val/test empty
Real TRL collator audit	60/60 supervision ranges correct, exactly one EOS; two samples of different lengths checked together for padding
Token lengths	Total length 285–382; target supervision length 18–54, including EOS; this is the current seed, not an estimate for the formal data
Tiny model training	A randomly initialized, very small Qwen3 ran two steps with real Torch/PEFT/TRL; only LoRA parameters changed
Tiny model resume and merge	4 steps planned in total, saved at step 2; resumed to 4; reloaded logits match, merged logits match within tolerance
HTTP client	A temporary local server verified history, normal responses, 503, error structure and invalid JSON; timeout boundary tested
Evaluation and integrity	Blind-review pairing, missing scores, ties, clustering by conversation; changing the adapter config changes the fingerprint; modified preparation outputs are rejected

Model revision: cdbee75f17c01a7cc42f958dc650907174af0554.

Tokenizer fingerprint: 5cc703e3e68312a345b0aa88aed16fd37eb4ca2d871900402275514280124405.

The current detailed local records are in runs/token-audit.json and data/processed/seed-v1/manifest.json; they are rebuildable generated files. Intermediate CPU data bundles from during code changes were moved to a temporary directory, and the final seed-v1 was rebuilt with the current prompt code.

Issues Encountered During Testing

• The HTTP tests initially failed due to the sandbox's listening restriction; they passed when rerun in an environment that allows local ports, without deleting or skipping tests.
• Fixed an issue where a single conversation was shown as a zero-width uncertainty interval: with fewer than two conversations, an empty interval is returned.
• The adapter fingerprint includes both the parameter files and the config, so changing only alpha can't still pass the freeze check.
• Model file hashing uses streaming reads, to avoid copying multi-GB shards into RAM.
• The 6 warnings come from the tiny random model having no pretrained config path, and from unreliable file timestamps on quickly saved checkpoints. Resume succeeded after sorting checkpoints by numeric step; these warnings were not suppressed.

Not Yet Executed; Cannot Be Claimed as Passing

• Conversation-by-conversation human/independent review of the 30 conversations; there are currently no approved conversations.
• Expansion and review of 30 cards and 150 formal conversations.
• 4B model weight download, Linux CUDA/bitsandbytes bring-up, real QLoRA.
• GPU 10-step smoke test, 20-sample overfit, 1 Epoch and r8/r16 comparison.
• Real generation quality, fact-support rate, blind-review win rate, GPU VRAM/time/cost.
• Real 4B BF16 merge, vLLM image pull/startup, real model API and load.

The CPU tiny-model tests are not a substitute for 4B experiments. Each time an item is completed, attach the corresponding logs/results and update the todo; metrics that have not actually been run stay blank.