nx_visdesc_gate.nx source
↩ module page · 191 lines · 9050 B
1// nx_visdesc_gate.nx -- referee for the Google-lite visual-similarity descriptor (nx_visdesc).
2// PROVES, in-process (no external elf, no shell), the capability dHash STRUCTURALLY lacks -- finding
3// images that LOOK ALIKE rather than only exact copies. Corpus = 4 visual classes (horizontal stripes /
4// vertical stripes / diagonal stripes / checker), 4 instances each, instances varying period + phase +
5// brightness + deterministic noise (so they are genuinely DIFFERENT images, not copies).
6// row1 DISCRIMINATION: every image's visdesc nearest-neighbour is its OWN class (16/16).
7// row2 BEYOND-dHash (headline exceed): same-class instances have a LARGE average dHash Hamming
8// (>10 -> dHash classes them as different images / non-copies) -- the gap visdesc fills.
9// row3 BRIGHTNESS INVARIANCE: +brightness leaves the descriptor ~unchanged (small L1).
10// row4 DETERMINISM: extracting the same image twice -> identical descriptor (L1 == 0).
11// row5 SEPARATION: average cross-class L1 >> average same-class L1 (no descriptor collapse).
12// GREEN iff 5/5. Durable verdict -> knowledge/status/visdesc_gate.log. license_tier: ORIGINAL
13import "nx_visdesc.nx"
14import "nx_phash.nx"
15
16func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
17func g_num(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=(48 as u8);k=1}; while m>0{t[k]=((48+(m%10)) as u8);m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(1,bb,k); return 0 }
18func g_w(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
19func g_wn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=(48 as u8);k=1}; while m>0{t[k]=((48+(m%10)) as u8);m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
20
21// synthesize a 200-amplitude class pattern with a small deterministic per-pixel wobble (so two
22// instances are never pixel-identical). cls: 0=horiz stripes 1=vert 2=diag 3=checker.
23func g_synth(buf: *u8, w: i64, h: i64, cls: i64, p: i64, phase: i64, bright: i64) -> i64 {
24 let amp: i64 = 200
25 var y: i64 = 0
26 while y < h {
27 var x: i64 = 0
28 while x < w {
29 var s: i64 = 0
30 if cls==0 { s = (((y+phase)/p) & 1) }
31 if cls==1 { s = (((x+phase)/p) & 1) }
32 if cls==2 { s = (((x+y+phase)/p) & 1) }
33 if cls==3 { s = ((((x+phase)/p) + (y/p)) & 1) }
34 var v: i64 = s*amp + bright
35 let noise: i64 = ((x*7 + y*13 + phase*5) & 7)
36 v = v + noise
37 if v < 0 { v = 0 }
38 if v > 255 { v = 255 }
39 buf[y*w+x] = v as u8
40 x = x + 1
41 }
42 y = y + 1
43 }
44 return 0
45}
46
47func main() -> i64 {
48 g_puts("=== VISDESC GATE (Google-lite visual similarity: looks-alike beyond exact-copy) ===\n" as *u8)
49 let W: i64 = 32
50 let H: i64 = 32
51 let NPX: i64 = W*H
52 let NINST: i64 = 4
53 let NIMG: i64 = 16
54
55 let grays: *i64 = sys_mmap(8*NIMG) as *i64
56 let descs: *i64 = sys_mmap(8*NIMG) as *i64
57 let dhash: *i64 = sys_mmap(8*NIMG) as *i64
58
59 var k: i64 = 0
60 while k < NIMG {
61 let cls: i64 = k / NINST
62 let inst: i64 = k % NINST
63 let p: i64 = 2 + inst
64 let phase: i64 = inst
65 let bright: i64 = inst*12
66 let buf: *u8 = sys_mmap(NPX)
67 g_synth(buf, W, H, cls, p, phase, bright)
68 grays[k] = buf as i64
69 let d: *i64 = sys_mmap(8*80) as *i64
70 nx_visdesc_extract(buf, W, H, d)
71 descs[k] = d as i64
72 dhash[k] = nx_phash_dhash(buf, W, H)
73 k = k + 1
74 }
75
76 var pass: i64 = 0
77 let rows: i64 = 5
78
79 // ---- row1: retrieval quality -- precision@3 (each image has exactly 3 same-class peers), the
80 // standard image-retrieval metric. 1-NN same-class is reported alongside for transparency. ----
81 let taken: *i64 = sys_mmap(8*NIMG) as *i64
82 let TOPK: i64 = 3
83 var pk_num: i64 = 0
84 var nn_same: i64 = 0
85 k = 0
86 while k < NIMG {
87 let dk: *i64 = descs[k] as *i64
88 var t: i64 = 0
89 while t < NIMG { taken[t] = 0; t = t + 1 }
90 taken[k] = 1
91 var rank: i64 = 0
92 while rank < TOPK {
93 var best: i64 = 0-1
94 var bestd: i64 = 0
95 var j: i64 = 0
96 while j < NIMG {
97 if taken[j] == 0 {
98 let dj: *i64 = descs[j] as *i64
99 let l1: i64 = nx_visdesc_l1(dk, dj)
100 if best < 0 { best = j; bestd = l1 } else { if l1 < bestd { best = j; bestd = l1 } }
101 }
102 j = j + 1
103 }
104 if best >= 0 {
105 taken[best] = 1
106 if (best/NINST) == (k/NINST) { pk_num = pk_num + 1 }
107 if rank == 0 { if (best/NINST) == (k/NINST) { nn_same = nn_same + 1 } }
108 }
109 rank = rank + 1
110 }
111 k = k + 1
112 }
113 var pk_permil: i64 = 0
114 if NIMG*TOPK > 0 { pk_permil = pk_num * 1000 / (NIMG*TOPK) }
115 g_puts(" row1 retrieval P@3=" as *u8); g_num(pk_permil); g_puts("permil (1-NN same-class=" as *u8); g_num(nn_same); g_puts("/" as *u8); g_num(NIMG); g_puts(") -> " as *u8)
116 if pk_permil >= 750 { pass=pass+1; g_puts("PASS (strong visual retrieval beyond exact-copy)\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
117
118 // ---- row2: same-class dHash Hamming is large (dHash calls them DIFFERENT images) ----
119 var dsum: i64 = 0
120 var dcnt: i64 = 0
121 var a: i64 = 0
122 while a < NIMG {
123 var b: i64 = a+1
124 while b < NIMG {
125 if (a/NINST) == (b/NINST) { dsum = dsum + nx_simhash_hamming(dhash[a], dhash[b]); dcnt = dcnt + 1 }
126 b = b + 1
127 }
128 a = a + 1
129 }
130 var davg: i64 = 0
131 if dcnt > 0 { davg = dsum / dcnt }
132 g_puts(" row2 same-class dHash Hamming avg=" as *u8); g_num(davg); g_puts(" (>10 = dHash sees them as DIFFERENT) -> " as *u8)
133 if davg > 10 { pass=pass+1; g_puts("PASS (visdesc fills the gap dHash misses)\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
134
135 // ---- row3: brightness invariance ----
136 let bb: *u8 = sys_mmap(NPX)
137 g_synth(bb, W, H, 0, 3, 0, 0)
138 let bd: *i64 = sys_mmap(8*80) as *i64
139 nx_visdesc_extract(bb, W, H, bd)
140 let bb2: *u8 = sys_mmap(NPX)
141 g_synth(bb2, W, H, 0, 3, 0, 30)
142 let bd2: *i64 = sys_mmap(8*80) as *i64
143 nx_visdesc_extract(bb2, W, H, bd2)
144 let l1_bright: i64 = nx_visdesc_l1(bd, bd2)
145 g_puts(" row3 brightness invariance -> L1(orig,+30bright)=" as *u8); g_num(l1_bright); g_puts(" (small) -> " as *u8)
146 if l1_bright < 80 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
147
148 // ---- row4: determinism ----
149 let dd: *i64 = sys_mmap(8*80) as *i64
150 nx_visdesc_extract(bb, W, H, dd)
151 let l1_det: i64 = nx_visdesc_l1(bd, dd)
152 g_puts(" row4 determinism -> L1(extract,extract)=" as *u8); g_num(l1_det); g_puts(" (==0) -> " as *u8)
153 if l1_det == 0 { pass=pass+1; g_puts("PASS\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
154
155 // ---- row5: separation (cross-class L1 >> same-class L1) ----
156 var ssum: i64 = 0
157 var scnt: i64 = 0
158 var xsum: i64 = 0
159 var xcnt: i64 = 0
160 a = 0
161 while a < NIMG {
162 var b: i64 = a+1
163 while b < NIMG {
164 let da: *i64 = descs[a] as *i64
165 let db: *i64 = descs[b] as *i64
166 let l1: i64 = nx_visdesc_l1(da, db)
167 if (a/NINST) == (b/NINST) { ssum = ssum + l1; scnt = scnt + 1 } else { xsum = xsum + l1; xcnt = xcnt + 1 }
168 b = b + 1
169 }
170 a = a + 1
171 }
172 var savg: i64 = 0
173 if scnt > 0 { savg = ssum / scnt }
174 var xavg: i64 = 0
175 if xcnt > 0 { xavg = xsum / xcnt }
176 g_puts(" row5 separation -> same-class avg L1=" as *u8); g_num(savg); g_puts(" cross-class avg L1=" as *u8); g_num(xavg); g_puts(" (~" as *u8)
177 if savg>0 { g_num(xavg/savg) } else { g_num(0) }
178 g_puts("x) -> " as *u8)
179 if xavg > 2*savg { pass=pass+1; g_puts("PASS (clear visual separation, no collapse)\n" as *u8) } else { g_puts("FAIL\n" as *u8) }
180
181 g_puts("----\nVISDESC-GATE rows=" as *u8); g_num(rows); g_puts(" pass=" as *u8); g_num(pass); g_puts("\n" as *u8)
182 let lg: i64 = sys_openat_append("knowledge/status/visdesc_gate.log" as *u8, 0x1a4)
183 if lg>=0 {
184 g_w(lg,"VISDESC-GATE rows=" as *u8); g_wn(lg,rows); g_w(lg," pass=" as *u8); g_wn(lg,pass)
185 g_w(lg," p_at_3=" as *u8); g_wn(lg,pk_permil); g_w(lg," nn_same=" as *u8); g_wn(lg,nn_same); g_w(lg," sameL1=" as *u8); g_wn(lg,savg); g_w(lg," crossL1=" as *u8); g_wn(lg,xavg); g_w(lg," dHashAvg=" as *u8); g_wn(lg,davg)
186 if pass==rows { g_w(lg," verdict=GREEN\n" as *u8) } else { g_w(lg," verdict=RED\n" as *u8) }
187 sys_close(lg)
188 }
189 if pass==rows { g_puts("VISDESC-GATE GREEN\n" as *u8); sys_exit(0); return 0 }
190 g_puts("VISDESC-GATE RED\n" as *u8); sys_exit(1); return 1
191}