The whole project history

Finished training the three-pass version of our Qwen model and scored it on its own against the one-pass model. By itself it came out lower, 0.609 against 0.621.

Swapped the three-pass model in for the one-pass model at 10 percent of the ensemble and checked it on two sets of creative writing. It beat the one-pass model on 16 of 18 creative comparisons, so we chose it for the next Kaggle test run.

Checked the new public 0.684 recipe. Two public copies run identical code and the page shows 0.684. Our best is still 0.682.

Trained bigger style networks on 245,081 passages. On the official passages they beat the old style model, 0.324 against 0.278. On the two creative sets the whole-passage network did worse than the old model.

Added the style networks to the ensemble, then added word-order style features on top. The style networks added about four tenths of a point on the main test. The word-order features made it worse, so we dropped them.

Added a correction that separates Qwen from the GPT models it gets confused with. Scores moved by less than a point either way: up a little on the independent test sets, flat to slightly down on the official folds. We did not use it.

Finished training the Liquid model with three separate runs and mixed it into an earlier public blend. It added about half a point at a 5 percent share and about three quarters of a point at 10 percent on our local test. It has not been on the board.

Submitted the public 0.682 recipe by itself, then three versions with our models mixed in: our tokenizer model, our earlier Qwen, and tokenizer plus raw-byte models. The plain recipe scored 0.682, our new best. The three additions scored 0.675, 0.678 and 0.669, so all three lost.

Submitted the public 0.683 recipe by itself, then the same recipe with our new full-pool Qwen mixed in at 10 percent. The plain copy scored 0.679 and the Qwen version 0.675, so Qwen lost. Our best stays 0.682.

Trained our Qwen model on the whole 253,598-passage public pool for one pass on a rented GPU. Our local five-fold score rose from 0.587 to 0.621. Two earlier rented hosts failed before training, about 90 cents lost, and the third host finished the run.

Ran the 540-row comparison of our model against the full public 0.681 stack on Kaggle. It took three tries after setup and file-path crashes. The result could not judge our model: the public stack had already seen those passages and scored 0.978 alone, and blending ours in only lowered it.

Tested the shared Mistral and OLMo predictions against our stack. Mistral helped most, +0.018 at a 20 percent share on our local test. OLMo added +0.009. Running the public Mistral model on Kaggle got as far as three test rows.

Built token and raw-byte specialist models for the five GPT authors. The byte model added about four tenths of a point inside the GPT group on our local test, 0.579 to 0.583. We have not put it on the board.

Retested the 6,000 passages we bought from six models, using three separate training runs. The score moved by -0.001, -0.006 and +0.007 across the three runs, with no consistent gain.

Tested GLM and Qwen likelihood fingerprints as extra features. Most versions made the score slightly worse.

Got the large GLM model running on a rented GPU. It loaded and read three full passages on the fourth attempt, for about 54 cents. The rental was shut down.

Ran the public 0.681 notebook in full on Kaggle's free GPUs and submitted it that night. It scored 0.681, up from 0.651.

Blended our own model into an earlier public ensemble on all 2,699 training passages. Balanced accuracy rose from 0.543 to 0.613 in the three-response setting, and recall rose for all 18 models. On the real board, mixing our Qwen into the 0.682 recipe the next day lost.

Tested tokenizer fingerprints, meaning how different tokenizers split a passage, as a 1 percent blend. It was weak on its own and moved the earlier ensemble from 0.5431 to 0.5438. The tokenizer idea later lost on the board.

Had a team of reviewers go through the whole repository and propose a better order of work. We held 0.651 against a leader at 0.730 and had made no submission since October 31. The plan puts a safe Kaggle submission first, then the group-context idea, then new model ideas, and recommends closing the extra-data work.

Ran the clean-pool fold on Kaggle's CPU machine and compared it with the result from our own machine. The two matched except for one prediction, and that one was wrong on both. The result carries over to Kaggle.

Finished the second training run on Jethro that compares the 6,000 bought passages against the combined-data control. The bought passages scored 0.580 against 0.586 for the control.

Tested a group-aware scoring head that judges passages from the same prompt together. It gained about six points when whole groups were present and lost about three points when groups were split into pairs. We did not switch it on everywhere. A rule based on group size is next.

Finished the four-way data comparison across three training runs. The combined data beat the plain data in every run, by 0.001 to 0.009.

Averaged the three runs of the combined-data model and compared it with the average of the plain-data runs. The combined data scored 0.6005 against 0.6016 for plain. The gain disappeared once averaged.

Repaired the adapter memory step that crashed on Kaggle. The repaired step gives exactly the same results as the original on real model weights.

Ran the whole upgraded public ensemble on Son's RTX 4090 machine, on the three visible test passages. Every stage finished, including all six main models and all 18 adapters. This was not a board score and not a test of Kaggle's two-card machine.

Swapped a cleaner public data pool into the word-pattern model and scored it on all five folds. By itself it rose from 0.490 to 0.512.

Blended the word-pattern model on the cleaner pool with the three-run neural models. The gain shrank to 0.613 to 0.616 once blended.

Ran the cleaner data pool on Kaggle's CPU machine. Kaggle attached a newer version of the pool than the one we asked for, and the run stopped on a file check. We saved the exact pool as a private dataset of our own.

Pulled the source of the new public 0.667 notebook. Kaggle refused the download. We could only read the rendered page.

Ran the upgraded public ensemble on Kaggle's two-card GPU machine, without submitting it for a score. It crashed with out-of-memory on the second card after its side models had finished. No score came out of it.

Built the upgraded public ensemble into our own runner and checked it on the real competition data. All eight checks passed, including empty and one-row inputs.

Compared our model trained with the 6,000 bought passages against the plain version, same training run, same held-out prompts. The bought passages scored 0.594 against 0.595. No gain.

Submitted our own Qwen3-8B model alone to check the whole pipeline. It scored 0.585 on the hidden test, close to its 0.588 local score. The public ensemble at 0.651 stayed our best.

Hunted for why training on Jethro was slow. The old math libraries used a slow route. The newer installed ones ran the key steps six to eight times faster in tests.

Bought 6,000 new passages, 1,000 from each of six models, after a sixty-passage trial. All 6,000 arrived for about $7.10, well under the $18 limit.

Cleared disk space on Jethro and started training on the expanded data. About 186 gigabytes were freed and training started on the new data.

Trained our own Qwen3-8B model in two stages, starting with a large public pool of writing. It scored 0.588 on held-back topics, against 0.480 for the public recipe on the same folds.

Added 1,752 Qwen passages we bought through OpenRouter to the word-pattern model. No help: it scored 0.481 with them and 0.484 without. About $7.72 was spent on 2,499 requests, and 1,752 of the replies were usable.

Repaired the training script and ran it on the real Qwen model on Son's RTX 4090. The test passed, and the twelve-run Qwen data comparison started that evening on the same card.

Had an independent review check our numbers. It found the 0.588 against 0.480 comparison was not a clean test, because the training run also differed in settings. It could not reproduce an earlier blend figure of 0.611 and got 0.603. It asked for a matched control.

Mined the Mac Mini's saved Claude Code replies for text from Claude models. Found 2,124 passages labelled with the right model names.

Trained our classifier with those Claude replies and saved Astra replies added. Held-out accuracy rose only from 0.331 to 0.338 and several authors got worse, so the scored entry stayed as it was.

Measured whether each author's use of dashes helps tell authors apart. Dashes alone scored 0.137. Added to the classifier they lifted local accuracy from 0.331 to 0.344. We kept it aside and did not put it in the scored entry.

Tested whether the Mac can collect writing from GPT models through the ChatGPT subscription. GPT-5.6 Luna, Sol and Terra answered. GPT-5.5 was refused as unsupported.

Submitted a classifier we built ourselves, to prove an entry of ours can run on Kaggle's hidden test. It ran clean and scored 0.348, far below the public leaders.

Ran the strong public neural ensemble in full and submitted it. Kaggle accepted it and the score came back at 0.651.

Added writing-style features to our own classifier. Local accuracy went from 0.275 to 0.331, which is why it was the version we submitted.

Looked into why our first two Kaggle submissions came back with no score. Both crashed on the hidden test. Both carried extra wrapper code the original notebook did not have, including a guard that rejects small test inputs.

Rebuilt the entry as an exact copy of the best public notebook, which scores 0.651. The copy matches the original byte for byte.

Split Name That LLM out of the old shared repo into its own standalone home. The setup checks pass on the real training data.