Show HN: I把DOM变成变形器

Doomformer将整数神经网络编译为ZDoom地图并运行于ViZDoom. 巫术玩偶(复制品)

DOOM 为额外玩家-1起动而产卵的玩家)进行算术，扇区光度和平面高度保持

金额。 Python从正在运行的游戏中读取出每个被曝光值，并将其与一个NumPy整数引用，可容忍性0相比较。

一个值一个值，运行失败。 速度慢：在小型MLP上比NumPy慢了约23 000倍(引擎时间；65 000)

手写数字需要163秒的实时 DOOM 在地图上

默认时间表和 -- opt 3 8 秒

· 安装证据 · 如何工作 · 电影 · 医生

pip 安装 git+https://github.com/motttopanikeiku/doomformer# Python 3.11+, Linux或macOS

#2 s：一个小型的 MLP，每个值检查

末日取出 -- -- 数字 7 # 15 s：海军陆战队行走一行一行一行一行一行一行一行一行

末日医生检查 ViZDoom, Freedoom 和显示器，如果缺失则建立 ACC，并编译 ACS 探测器

在报告成功之前。 第一个构建需要git,cmake，一个C编译器和github.com的网络访问。

Linux使用动态运行时间：不需要glibc-static. 在Fedora上：sudo dnf安装了gt cmake gcc-ccc-c++制造。

Colab 笔记本

不需要设置，但你画的浏览器 canvas 和末日前的 mnist - 图像将其输入 DOOM，没有海洋。

持有FIRE，海军陆战队的墨水 3×3刷子的地板细胞在他下面。 READ 让关卡将784像素写入

和1355个巫毒娃娃在同一地图上计算用 -- 数字，Python 代表你：它按住

海军陆战队的钥匙和USE一次，然后只推进时钟和阅读。

▄▄▄▄▄▄▄▄▄▄▄▄▄▄

▄████████████████

████▀▀ ▀████▀

▀▀▀ ▄███▀

████

███

███

███

████

███▀

████

▀███

DOOM 读作：7 (右) -- -- 胜者玩偶将它放入了"七分块"的显示器上

EXACT: DOOM计算出的所有248个值[.]等于NumPy整数参考(容忍0)

READ出道口：273个出道道口=8 s 在35个出道口/s,3 s出道口[.]

缩写为。; docs/ commands. md 拥有全部输出。 绘图构建其

使用 --opt 3 的映射图，所以 READ 需要 273 个游戏；在 --opt 0 时，最初的时间表需要 5 705 个( 实时 163 s)

(原始内容存档于2018-09-21). DOM. 没有 -- -- 数字化的命令打开窗口，你就走动并画出自己；DOOM 然后实时运行。

玩偶计算出784像素64个隐藏单位45对比分比较10取胜计分。 只有赢得其所有9个比较的数位才能得到一个玩偶通过，而玩偶所交叉的行会开启显示上点出数位的关卡脚本。 Python读取了784像素，隐藏地层，每次比较以及答案和检查全部248个值(119个值，每个值读取时带有被否定的双子，加上10个输出).

EXACT表示DOM等于整数网络。 称没有关于数字是否正确的问题。 在第一次100 MNIST测试中

DOOM 数字读取正确 99, 1 000个样本中的966个从所有10 000个样本中抽取出来；每个结果都是准确的。 整数网络

在所有10,000人中得分97.16%(浮标模式得分97.58%)。 30个行走数字(0到9,3个脚本中风)

在 --opt 3 上，网络也接受了中风分布培训：

第一个版本的这个演示，一个784-32-10网络训练仅关于MNIST，只读41.08%的这种中风。 通过真正的X

关键事件 a raw 7 读取精确到默认的 -- opt 3; a 7 和 a 1 尝试在 --opt 0 上使用更早的网络。

细节电影

末日博物馆建筑写作"Museum.wad"，一张没有Python就可以玩的地图。 你踩到七层地上取光

数字并按读取码。 136个巫术玩偶计算出一个手写的小字

网络：每个数字的分数计算同意的分数，而胜利者玩偶点亮了显示。 马特

在运行级别内重新连接网络中的一个连接：段从 1 到 - 1，通过更改

其两条重量线的特产。 同样的7，然后读作1, RESTORE把它放回去。 HUD和记分牌

显示每个 READ 之后的 10 个分数，以及一个相机站显示数字 7 的第六个分数玩偶：它通过它的门之前

MUTATE，然后停在它的前面之后。

末日博物馆核实

7页 abc w 7a+1 DOOM读取了7分 [4, 6, 3, 5, 4, 3, 2, 7, 3, 4] EXACT (148个值；744个tex; [.])

7 在MUTATE supers abc w 7a-1 DOOM 后读取 1分 [4, 6, 3, 5, 4, 3, 2, 5, 3, 4] EXACT (148分；744分；[.])

7 在RESTORE paps abc w 7a +1 DOOM 后读取了 7 分 [4, 6, 3, 5, 4, 3, 3, 2, 7, 3, 4] EXACT (148 值；744 tics; [.])

Python在这里演奏：它按下海军陆战队的钥匙和USE，在每一次读取时，它只读取，并有警戒读取。 它将所有148个值与网络的NumPy参考值进行比较，因为它当时是wired. 不运行DOOM，静态提取器也是显示，即重联地图的网名列表正是一个重量变化的网络。 我只在VizDoom管理整个地图它的自试地图读取了数字0到9，然后在MUTATE后和RESTORE后读取7，没有玩家。 在GitHub跑道上，它记录了GZDoom 4.1.4.2、LZDoom 3.88b、UZDoom 5.0.3和ZDoom 2.8.1中的确切值，仅在每个扇区标记低于32 768时，才记录Zandronum 3.2.1中的确切值。 细节

Python 从运行的游戏中读取扇区光度和地平和天花板高度，并用一个比对

独立的 NumPy 整数执行同一网络。 检查是整数平等相对于运行

称没有关于未运行的输入。 测试会攻击它：在小编译中提高一股重量线

从 5到 6 的映射必须完全以 + 1 失败。

Python所写值必须失败(pytest tests/test tamper.py,3个tests，约15 s).

Readback被默认守护：在每页前，Python毒药并检查它的USER槽，然后要求

页面替换它们。 丢弃一页无法默回重复输入的答案或上页的值。

guard=false是一个明确的一相图历史选择退出。 守卫建筑有新的散列(ACS和元数据，而不是

几何或算术；散列记录解释变化。

末日模糊 -- -- 40网比较了DOOM(306次通过，0次不匹配，约10次)运行的40个随机蚊帐的每个值。

--works 2；已找到已安装的编译器错误). 模糊 -- -- 网点将权重、偏差和投入置于幅度限度：15 000个网

超过10个新鲜种子，在 -- opt 0、 -- opt 3和作为平面图，通过了113 605个种子，并将1 987 632个值与

没有错配(范围检查拒绝了47 686项输入，约占30%)，由于发电机被加宽，又增加了3 000项

从下面的界限(22 682个通行证)开始，从15 000个到16 000个(14 782个)，再增加2 000个。

通过，所有没有不匹配。 早些时候的竞选活动有2 000个随机的MLP

(15 374个通过，276 594个值),300个刺网和100个随机变压器，覆盖所有8个注意力、规范和MLP变体

(99跑；一个全零矩阵不支持)，在时间安排修正后；200个尖顶网，12 794个通过。

没有不匹配。 模糊- 尖端不绘制变压器。 CI 有60个网点

每推一次都要有新鲜的印刷种子每周一还要有更长的竞选时间模糊和独立的跑道找到了四个

这个repo自己的地图上的断层：两个排程错误和两个平面限制。 一个超过14,018的平面动作

零的单位让移动器忙于3个字节然后把下一个请求和启动的飞机放下

16 000以上在第一个通行证上是准确的，在后面的通行证上是错误的，因此，DOOM不同意在网上提及

net.check已经接受。 检查和编译现在拒绝：飞机从内部开始[15 000,16 000]并在内部移动

±14,018(户口核实 -- -- 飞机扫射、文件/核查。

末日者核查一个小型MLP的每个输入类(这些类别与20个蚊帐中的20个输入类一致)

假设在同一页中说明)。 df. 覆盖值计算比较值：在MNIST上，所有248个暴露值，即

129 值参考定义和119个双胞胎，当一个读出名被丢弃时计数会下降。 地图没有

披露903个楼梯和1 351个门对同一网点的比较；通过它们提供的数量加以核对。

末日验证 -- extract net.wad -- net net.npz 在不启动 DOOM 和

比较每个重量、偏差和阈值与源网：运出的MNIST网(784-64-45-10-10)返回等值

仅从地图上的 -- opt 0到3, 490个随机渔网中的484个在 -- opt 0 (其他6个相等但打破)

(b) 飞机合同)和199架，每架199架 -- 选择1至3。 EQUAL包括算术网名单、飞机合同

触发并重复标记、 移动器速度、 重置脚本和读出页；计时和几何打印为 NOT

检查。 改变的重量线显示正是这个重量。 在23 622个单一编辑器中，有23 622个编辑器在 -- opt 0 the

提取器检测出17,906分，在DOOM中运行于12个输入的98个未被检测到的编辑都是准确的。 它的显示什么是

地图称；DOOM运行的地图如所读是精确度检查测试。

变形带改变地图的一行：在运行的1 004个站点(5 578个站点中)中，297个站点被杀死，所有重量，标志

和他们中的目标阶级。 在707名幸存者中，590人符合规则(一个冗余的卷轴机，一个冻结行即前行传)

(b) 117个是输入缺口(只有一些输入暴露的行走地板);

证明是等同的。 末日前 lint -- fuzz 比较静态

5,397张地图上的DOOM时间表检查器：0假底片。 方法是翻译验证(Pnueli、Siegel和

Singerman, 1998)：每个编译器的测试，而不是编译器是正确的证明。

谁做什么：

- 玩偶们做每一个乘法加法，激活和比较。 ACS 级别脚本地址单元格，移动输入门，倒带

玩偶们感受世界复制结果出来网络的算术都没有在ACS运行。 这个工具箱

df.Agent是一个例外：它在ACS(docs/agents.md)中取出它的正弦。

- mnist:Python写出784像素端口，决定玩偶停止的时间；玩偶选择数字。

- 演示并询问：Python 写出代号，并决定玩偶何时停止

对数 DOM 计算，当一个模型被切入到多个地图中时，复制整数从一个游戏到下一个游戏。 演示 -- 1- 映射是一个图，层间没有 Python; Python 在每封信后写出符号和样本

通过。

- Draw and his brain is the level: Python只推进时钟并运行读取脚本(从READ上).

关卡提供输入(784像素，感应符)，玩偶会选择数字或动作。

- demo -- 1-map --loop: Python 只推进时钟并运行读取脚本。 玩偶们每封信都挑一写

它进入下一个位置。

- 苍蝇回路：Python只推进时钟并跑出读取脚本，在校正它确实所写的单独游戏的步段后。 关卡绘制出输入尖顶，输出尖顶会点燃推力线。

- --opt 3( 绘图的默认；其他 --opt 0，带有被守护的回放的原始时间表): ACS 脚本副本

每层的灯光水平进入下层的门高。 它新增和比无，娃娃仍然做

和数，阈值，比较和选择，但“层间无ACS”只保留到-opt 0到2。

- 末日机器：娃娃运行程序计数器和登记器。 默认循环、倒带和停止

检查是ACS脚本，存储的程序由主机在第一个tic之前加载。 有 -- 点时玩偶的循环

玩偶和行特辑重新启动，倒带并停止关卡，ACS只读取玩偶拥有的值并检查

已停止(文件/机器.md)。

- 学习数字：Python 写每个考试的像素和标签

本文由 AI宝库自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。

Doomformer compiles integer neural networks into ZDoom maps and runs them in ViZDoom. Voodoo dolls (the copies of the

player that DOOM spawns for extra player-1 starts) do the arithmetic, and sector light levels and plane heights hold the

sums. Python reads every exposed value back from the running game and compares it with a NumPy integer reference, tolerance 0.

One value off by one and the run fails. It is slow: about 23,000 times slower than NumPy on a small MLP (engine time; 65,000

times with a timer around the whole call), and a handwritten digit takes 163 seconds of real-time DOOM in one map at the

default schedule and 8 seconds at --opt 3.

Install · Proof · How it works · Films · Docs

pip install git+https://github.com/mottopanikeiku/doomformer # Python 3.11+, Linux or macOS

doomformer hello # 2 s: a small MLP, every value checked

doomformer draw --digit 7 # 15 s: the marine walks a 7 and the level reads it

doomformer doctor checks ViZDoom, Freedoom and the display, builds ACC if it is absent, and compiles an ACS probe

before reporting success. The first build needs git, cmake, a C compiler and network access to github.com.

Linux uses dynamic runtimes: glibc-static is not required. On Fedora: sudo dnf install git cmake gcc gcc-c++ make.

The Colab notebook

needs no setup, but you draw on a browser canvas and doomformer mnist --image feeds it to DOOM, with no marine.

Holding FIRE, the marine inks a 3×3 brush of floor cells under him. READ makes the level write the 784 pixels into the

network, and 1,355 voodoo dolls in the same map compute it. With --digit, Python stands in for you: it presses the

marine's keys and USE once, then only advances the clock and reads.

▄▄▄▄▄▄▄▄▄▄▄▄▄▄

▄████████████████

████▀▀ ▀████▀

▀▀▀ ▄███▀

████

███

███

███

████

███▀

████

▀███

DOOM reads: 7 (right) -- the winner's doll lit it on the 7-segment display

EXACT: all 248 values DOOM computed [...] equal the NumPy integer reference (tolerance 0)

READ pass: 273 game tics = 8 s of real-time DOOM at 35 tics/s, 3 s wall [...]

Abridged at [...]; docs/commands.md has the whole output. draw builds its

map with --opt 3, so a READ takes 273 game tics; at --opt 0, the original schedule, it takes 5,705 (163 s of real-time

DOOM). Without --digit the command opens a window and you walk and draw yourself; DOOM then runs in real time.

The dolls compute 784 pixels → 64 hidden units → 45 pairwise score comparisons → 10 win counts. Only the digit that wins all nine of its comparisons gets a doll through, and the line that doll crosses starts the level script that lights the digit on the display. Python reads back the 784 pixels, the hidden layer, every comparison and the answer and checks all 248 values (119 values, each read with its negated twin, plus 10 outputs).

EXACT means DOOM equals the integer network. It says nothing about whether the digit is right. On the first 100 MNIST test

digits DOOM reads 99 correctly, and 966 of 1,000 sampled from all 10,000; every result is exact. The integer network

scores 97.16 % on all 10,000 (the float model scores 97.58 %). The 30 walked digits (0 to 9, three scripted stroke

variants each) all read correctly and exact at --opt 3, and the network is also trained on that stroke distribution: the

first version of this demo, a 784-32-10 network trained on MNIST alone, reads only 41.08 % of such strokes. Through real X

key events a drawn 7 read exact at the default --opt 3; a 7 and a 1 were tried at --opt 0 with an earlier network.

Details · film

doomformer museum build writes museum.wad, a map you can play without Python. You step on seven floor pads to light

a digit and press READ. 136 voodoo dolls compute a small hand-written

network: each digit's score counts the segments that agree with it, and the winner's doll lights the display. MUTATE

rewires one connection of that network inside the running level: segment a to digit 7 goes from +1 to -1, by changing

the specials of its two weight lines. The same 7 then reads as 1, and RESTORE puts it back. The HUD and a scoreboard

show the ten scores after each READ, and a camera station shows digit 7's sixth score doll: it passes its gate before

MUTATE and stops in front of it after.

$ doomformer museum verify

7 pads abc w_7a +1 DOOM reads 7 scores [4, 6, 3, 5, 4, 3, 2, 7, 3, 4] EXACT (148 values; 744 tics; [...])

7 after MUTATE pads abc w_7a -1 DOOM reads 1 scores [4, 6, 3, 5, 4, 3, 2, 5, 3, 4] EXACT (148 values; 744 tics; [...])

7 after RESTORE pads abc w_7a +1 DOOM reads 7 scores [4, 6, 3, 5, 4, 3, 2, 7, 3, 4] EXACT (148 values; 744 tics; [...])

Here Python plays: it presses the marine's keys and USE, and during each READ it only reads, with guarded readouts. It compares all 148 values with the NumPy reference of the network as it is wired at that moment. Without running DOOM, the static extractor also shows that the rewired map's netlist is the network with exactly that one weight changed. I have run the whole map only in ViZDoom. Its self-test map reads the digits 0 to 9, then the 7 after MUTATE and after RESTORE, without a player. On a GitHub runner it logs the exact values in GZDoom 4.14.2, LZDoom 3.88b, UZDoom 5.0.3 and ZDoom 2.8.1, and in Zandronum 3.2.1 only when every sector tag is below 32,768. Details

Python reads sector light levels and floor and ceiling heights from the running game and compares each with an

independent NumPy integer implementation of the same network. The check is integer equality over the runs that were

made, and says nothing about inputs that were not run. The tests attack it: raising one weight line in a small compiled

map from 5 to 6 must fail by exactly +1 on exactly the inputs whose dolls cross that line, and a readout that echoes a

value Python wrote must fail (pytest tests/test_tamper.py, three tests, about 15 s).

Readback is guarded by default: before each page, Python poisons and checks its USER slots, then requires the

page to replace them. Dropping a page cannot silently reuse a repeated input's answer or the previous page's values.

guard=False is an explicit one-map historical opt-out. Guarded builds have new hashes (ACS and metadata, not

geometry or arithmetic); the hash record explains the change.

doomformer fuzz --nets 40 compares every value of 40 random nets run in DOOM (306 passes, 0 mismatches, about 10 s with

--workers 2; a planted compiler bug is found). fuzz --edge puts weights, biases and inputs at the range limits: 15,000 nets

over ten fresh seeds, at --opt 0, at --opt 3 and as tile maps, made 113,605 passes and compared 1,987,632 values with

no mismatch (the range check refused 47,686 of the inputs it drew, about 30 %), 3,000 more with the generator widened

to plane starts near the bounds below (22,682 passes) and 2,000 more that also draw starts from 15,000 to 16,000 (14,782

passes), all with no mismatch. Earlier campaigns ran 2,000 random MLPs

(15,374 passes, 276,594 values), 300 spiking nets and 100 random transformers over all 8 attention, norm and MLP variants

(99 ran; one all-zero matrix is unsupported), after the scheduling fixes; 200 spiking --edge nets made 12,794 passes with

no mismatch. fuzz --edge does not draw transformers. CI fuzzes 60 nets

with a fresh, printed seed on every push and a longer campaign every Monday. The fuzzer and independent runs found four

faults in this repo's own maps: two scheduling bugs and two plane limits. A plane move that starts more than 14,018

units from zero keeps its mover busy for three tics and drops the next request on that plane, and a plane that starts

above 16,000 is exact on the first pass and wrong on later ones, so DOOM disagreed with the reference on nets that

net.check had accepted. check and compile now refuse them: planes start inside [-15,000, 16,000] and move within

±14,018 (doomformer verify --plane-sweep, docs/verification.md).

doomformer verify runs every input class of a small MLP (the classes agree with every input on 20 of 20 nets, under an

assumption stated in the same page). df.coverage counts what is compared: on MNIST all 248 exposed values, which are

129 values the reference defines and 119 twins, and the count falls when a readout name is dropped. The map does not

expose the 903 staircase counts and 1,351 gate comparisons of the same net; they are checked through the sums they feed.

doomformer verify --extract net.wad --net net.npz reads the net back out of a compiled map without starting DOOM and

compares every weight, bias and threshold with the source net: the shipped MNIST net (784-64-45-10-10) comes back equal

from its map alone at --opt 0 to 3, and so do 484 of 490 random nets at --opt 0 (the other 6 are equal but break the

plane contract) and 199 of 199 at each of --opt 1 to 3. EQUAL covers the arithmetic netlist, the plane contract, the

trigger and repeat flags, the mover speeds, the reset script and the readout pages; timing and geometry are printed as NOT

CHECKED. A changed weight line shows as exactly that weight. Of 23,622 single edits to a small map at --opt 0 the

extractor detects 17,906, and the 98 undetected edits that were run in DOOM on 12 inputs were all exact. It shows what the

map says; that DOOM runs the map as read is what the exactness checks test.

A mutation harness changes one line of a compiled map: of the 1,004 sites run (of 5,578) 297 are killed, all weight, sign

and target classes among them. Of the 707 survivors 590 match a rule (a redundant scroller, a freeze line a forward pass

never needs) that aggregate controls support, and 117 are input gaps (walking floors that only some inputs expose); none

is proven equivalent. doomformer lint --fuzz compared the static

schedule checker with DOOM on 5,397 maps: 0 false negatives. The method is translation validation (Pnueli, Siegel and

Singerman, 1998): a test of each compile, not a proof that the compiler is right.

Who does what:

- The dolls do every multiply-add, activation and comparison. ACS level scripts address cells, move input gates, rewind

the dolls, sense the world and copy results out. None of the network's arithmetic runs in ACS. The toolkit's

df.Agent is the one exception: it takes its argmax in ACS (docs/agents.md).

- mnist: Python writes the 784 pixel ports and decides when the dolls have stopped; the dolls pick the digit.

- demo and ask: Python writes the token ids and decides when the dolls have stopped, samples each letter from the

logits DOOM computed and, when a model is cut into several maps, copies integers from one game to the next. demo --one-map is one map with no Python between layers; Python writes the tokens and samples the letter after each

pass.

- draw and his brain is the level: Python only advances the clock and runs readout scripts (in draw, from READ on).

The level supplies the inputs (the 784 pixels, the sensed tokens) and the dolls pick the digit or the action.

- demo --one-map --loop: Python only advances the clock and runs readout scripts. The dolls pick each letter and write

it into the next position.

- The fly loop: Python only advances the clock and runs readout scripts, after calibrating the step period on a separate game that it does write. The level draws the input spikes and the output spikes fire the thrust lines.

- --opt 3 (the default of draw; elsewhere --opt 0, the original schedule with guarded readback): an ACS script copies

each layer's light levels into the next layer's gate heights. It adds and compares nothing, and the dolls still do the

sums, thresholds, comparisons and the choice, but "no ACS between layers" holds at --opt 0 to 2 only.

- doomformer machine: the dolls run the program counter and the registers. By default the loop, the rewind and the halt

check are an ACS script, and a stored program is loaded by the host before the first tic. With --clock dolls a loop

doll and line specials restart, rewind and stop the level, and ACS only reads values and checks that the dolls have

stopped (docs/machine.md).

- learn digits: Python writes the pixels and the label of each exampl

Auto-fetched and translated by AI Gem Box. All rights belong to the original author.