Apple

Close of development

The checkpoint that closed the run was written at 16:17:49 local time on 10 October 2026. Recorded training time in that file is 4,413.2 seconds, which is 1 hour 13 minutes 33 seconds, including earlier time carried from a resume the same day. The process was then stopped. Generation 10,212 had started and was not saved.

tjdax ended the project there. More generations were not run. Public open-source weights for this kind of puzzle already exist, and this network was not trained to replace them. The useful record is the measurement below, not another night of the same loop.

What the hour produced

The run stood up a complete training loop and kept a checkpoint after every generation.

• Rules engine. A Rust engine for the guideline falling-block rules: seven pieces, hold, rotation kicks, line clears, attack, and incoming garbage. The same engine supplied the legal placements to the learner.
• Network. A value network trained from scratch with NumPy and Adam. It has 306 observation inputs, one hidden layer of 64 ReLU units, and one output that predicts remaining attack. PyTorch was not used. The optimizer state was stored with the weights, so a reboot continued the same update rather than resetting Adam.
• Self-play. Eight worker processes, one game each per generation, then one value update on the main process. The core cap was 8 of 16 logical CPUs, and the process priority was below normal so the machine stayed usable.
• Move choice. Search looks one ply ahead, over every legal placement. The score adds attack sent and 0.35 times lines cleared, adds 0.4 times a z-scored value estimate, and subtracts a penalty for holes, stack height, and topping out.
• Ladder. One duel per generation against a fixed greedy heuristic. Both sides receive the same piece sequence. The piece limit is 40. A win counts as 1 only when the heuristic tops out and Apple does not. A loss counts as 0 when Apple tops out. If both survive the limit, the game is a draw and counts as 0.5.
• Elo. The heuristic is anchored at 1000. Each evaluation updates Apple with K = 24.

Final checkpoint

• Generation. 10,211 completed. 10,212 was in progress and was discarded.
• Recorded time. 4,413.2 seconds, or 1 hour 13 minutes 33 seconds.
• Self-play games. 81,696, including games restored when training resumed.
• Afterstate samples. 2,776,545 positions used to train the value output.
• Value updates. 8,682.
• Workers. 8.
• Network shape. 306 × 64 × 1.
• Best attack per piece. 0.250, the highest generation in the run. Attack per piece is attack sent divided by pieces placed.
• Attack per piece at generation 10,211. 0.163. Later generations did not lock in a level above the early peak.
• Elo. 970.4. The heuristic stays at 1000, so Apple finished slightly behind that opponent.
• Evaluations. 8,682.
• Wins / losses / draws. 8 / 525 / 8,149.
• Mean score. 0.4702. A win is 1, a draw is 0.5, and a loss is 0, averaged from the first evaluation.

How to read that score

Almost every ladder game was a draw. 8,149 of 8,682 evaluations ended with both sides still alive after 40 pieces, so neither player proved it could kill the other inside the limit. Draws sit on 0.5 and barely move an Elo that is already near 1000. The decided games are the informative ones: Apple won 8 and lost 525. When someone topped out, it was usually Apple.

The mean score of 0.4702 is that lifetime average. It stays near one half because of the draws, and it sits under one half because of the losses. It is a poor gauge of a single generation. Elo is the running rating, and attack per piece is the self-play attack of the latest generation. Neither one was climbing through the close of the run.

Survival inside self-play was usually 1, which means the eight games of a generation reached the piece limit without topping out. That is endurance under a short cap, not a win on the ladder. The T-spin rate in late generations was usually 0.

Marks during the run

• Generation 0. Training started.
• Generation 8. The first T-spin clear appeared in self-play.
• Generation 596. One generation reached 0.20 attack per piece.
• Generation 672. The first win against the heuristic.

The marks that were defined and not reached are 0.50 attack per piece and 1.00 attack per piece. The best generation stopped at 0.250.

Evidence

The two files below are the checkpoint as it was when training stopped. The manifest repeats the totals and the arithmetic, so the page can be checked without trusting the prose.

• Record. live.json, 63,927 bytes. SHA-256 ccde4576c2700809a2a6591c7c5b000bbb17a4597a080b06be126f82414dcaec. The history array keeps the last 400 generations, 9,812 through 10,211. Totals and milestones are for the run.
• Weights. az-weights.npz, 239,012 bytes. SHA-256 f218094346d6f4aa215890f7f0bfc7caa671c38c529f7da143689430ff301ddb. Arrays inside: w, step, and the Adam moments and variances mom_w1, mom_b1, mom_w2, mom_b2, var_w1, var_b1, var_w2, var_b2.
• Manifest. manifest.json.
• Check the record. 8 + 525 + 8,149 = 8,682 evaluations. 8 + 8,149 × 0.5 = 4,082.5. 4,082.5 / 8,682 = 0.47022345, stored as 0.4702. (10,211 + 1) × 8 = 81,696 games.
• What the file does not show. Generation 10,211 means 10,212 generation indexes if counting from 0. Scored duels are 8,682. The other 1,530 indexes have no stored duel. Elo and the win, loss, and draw counts are the 8,682 scored duels only.

What the result is

Apple is evidence that tjdax could train a small value network on the lab engine, resume it after a restart, and write down the ladder score. It is not evidence that the network plays better than the heuristic it was measured against, and it is not a claim about the open-source weights that already exist for this puzzle. Those weights are the reason this training stopped. The numbers on this page are the whole result.

Back to the AI lab