nx_skinfam_train_gate.nx source

1// nx_skinfam_train_gate.nx -- ★★P4 NEURAL RUNG 2: a GENERATIVE sovereign skin-texture FAMILY. R1 proved 2// exemplar-fit; R2 proves GENERATION: an AUTO-DECODER (DeepSDF/GLO-style) coordinate-MLP with a LEARNED 8-dim 3// LATENT per training patch, trained jointly on SIX real skin patches (Elara exemplar) by the R1 integer 4// machinery (Q12 backprop + error-feedback + frequency-scaled init). After training, NEW latents (interpolations 5// + in-range draws) generate NOVEL skin textures that never existed = seed -> novel skin, the persongen 6// philosophy carried into the neural track. 7// T1 joint training CONVERGES (err < half of untrained across all 6 patches) 8// T2 per-patch reconstructions are FAITHFUL (avg err < 22/255) and DISTINCT (the latent separates patches) 9// T3 ★GENERATION: novel latents -> textures that are (a) NOT a copy of any training patch, (b) skin-like 10// (mean colour within the training family's range), (c) DIVERSE (two draws differ) 11// T4 persist (weights+latents) -> reload -> re-render bit-identical + PNG knowledge/nx_skinfam.png 12// (row 1 exemplars | row 2 reconstructions | row 3 NOVEL generations) 13// license_tier: ORIGINAL expect_exit: 0 14import "nx_syscalls.nx" 15import "nx_itrig.nx" 16import "nx_jpeg_ascii.nx" 17import "nx_png.nx" 18 19func hw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 20func pn(v: i64) -> i64 { let b: *u8=sys_mmap(32) as *u8; var x: i64=v; var ng: i64=0; if x<0{ng=1;x=0-x} var i: i64=31; if x==0{b[i]=48 as u8;i=i-1} while x>0{b[i]=(48+x%10) as u8;x=x/10;i=i-1} if ng==1{b[i]=45 as u8;i=i-1} sys_write(1,(b as i64+i+1) as *u8,31-i); return 0 } 21 22const PS: i64 = 32 // patch size 23const NPP: i64 = 1024 // px per patch 24const NPAT: i64 = 6 // training patches 25const NFR: i64 = 5 // Fourier freqs {1,2,4,8,16} 26const NFF: i64 = 20 // Fourier features 27const NL: i64 = 8 // latent dims 28const NIN: i64 = 28 // NFF + NL 29const NH: i64 = 56 30const NO: i64 = 3 31const EPOCHS: i64 = 500 32 33func lcg(st: *i64) -> i64 { var h: i64=st[0]; h=h*6364136223846793005+1442695040888963407; st[0]=h; return (h>>33)&2147483647 } 34 35func features(px: i64, py: i64, f: *i64) -> i64 { 36 let fr: *i64 = sys_mmap(8*8) as *i64 37 fr[0]=1; fr[1]=2; fr[2]=4; fr[3]=8; fr[4]=16 38 var k: i64 = 0 39 while k < NFR { 40 let ax: i64 = px * 25736 * fr[k] / PS 41 let ay: i64 = py * 25736 * fr[k] / PS 42 f[k*4] = it_sin4096(ax) 43 f[k*4+1] = it_cos4096(ax) 44 f[k*4+2] = it_sin4096(ay) 45 f[k*4+3] = it_cos4096(ay) 46 k = k + 1 47 } 48 return 0 49} 50 51// integer inference on a fused input (20 Fourier + 8 latent), Q12 -> packed rgb 52func infer(W1: *i64, B1: *i64, W2: *i64, B2: *i64, fin: *i64, h: *i64) -> i64 { 53 var j: i64 = 0 54 while j < NH { 55 var acc: i64 = B1[j] 56 var i: i64 = 0 57 while i < NIN { acc = acc + W1[j*NIN+i]*fin[i]/4096; i = i + 1 } 58 if acc < 0 { acc = 0 } 59 if acc > 16384 { acc = 16384 } 60 h[j] = acc 61 j = j + 1 62 } 63 var outp: i64 = 0 64 var c: i64 = 0 65 while c < NO { 66 var acc: i64 = B2[c] 67 j = 0 68 while j < NH { acc = acc + W2[c*NH+j]*h[j]/4096; j = j + 1 } 69 var v: i64 = acc*255/4096 70 if v < 0 { v = 0 } 71 if v > 255 { v = 255 } 72 var sh: i64 = 0 73 if c == 1 { sh = 8 } 74 if c == 2 { sh = 16 } 75 outp = outp + (v << sh) 76 c = c + 1 77 } 78 return outp 79} 80 81func main() -> i64 { 82 hw("=== nx_skinfam_train_gate -- P4 R2: a GENERATIVE latent skin-texture family (integer auto-decoder) ===\n" as *u8) 83 var fails: i64 = 0 84 85 // ---- data: 6 skin patches from the Elara exemplar ---- 86 let szp: *i64 = sys_mmap(16) as *i64 87 let jpeg: *u8 = sys_read_file("knowledge/elara_face_hi.jpg" as *u8, szp) 88 if (jpeg as i64) == 0 { hw("no exemplar\n" as *u8); return 1 } 89 let rp: *i64 = sys_mmap(8) as *i64 90 let wp: *i64 = sys_mmap(8) as *i64 91 let hp: *i64 = sys_mmap(8) as *i64 92 if nx_jpeg_decode_rgb(jpeg, szp[0], rp, wp, hp) != NX_JPEG_ASCII_OK { hw("decode fail\n" as *u8); return 1 } 93 let rgb: *u8 = rp[0] as *u8 94 let tw: i64 = wp[0] 95 let crops: *i64 = sys_mmap(NPAT*2*8) as *i64 // (cx, cy) skin regions: cheeks, forehead, chin, jaws 96 crops[0]=150; crops[1]=330 97 crops[2]=310; crops[3]=330 98 crops[4]=232; crops[5]=140 99 crops[6]=232; crops[7]=478 100 crops[8]=140; crops[9]=420 101 crops[10]=330; crops[11]=420 102 let tgtQ: *i64 = sys_mmap(NPAT*NPP*3*8) as *i64 103 let ex: *i64 = sys_mmap(NPAT*NPP*8) as *i64 104 let pmean: *i64 = sys_mmap(NPAT*3*8) as *i64 // per-patch mean rgb (for the skin-likeness test) 105 var p: i64 = 0 106 while p < NPAT { 107 var mr: i64 = 0 108 var mg: i64 = 0 109 var mb: i64 = 0 110 var py: i64 = 0 111 while py < PS { 112 var px: i64 = 0 113 while px < PS { 114 let o: i64 = ((crops[p*2+1]+py)*tw + crops[p*2]+px)*3 115 let r: i64 = (rgb[o] as i64)&255 116 let g: i64 = (rgb[o+1] as i64)&255 117 let b: i64 = (rgb[o+2] as i64)&255 118 let pi: i64 = p*NPP + py*PS+px 119 tgtQ[pi*3] = r*4096/255 120 tgtQ[pi*3+1] = g*4096/255 121 tgtQ[pi*3+2] = b*4096/255 122 ex[pi] = r + g*256 + b*65536 123 mr = mr + r; mg = mg + g; mb = mb + b 124 px = px + 1 125 } 126 py = py + 1 127 } 128 pmean[p*3] = mr/NPP; pmean[p*3+1] = mg/NPP; pmean[p*3+2] = mb/NPP 129 p = p + 1 130 } 131 132 // ---- shared Fourier features for the 32x32 coords ---- 133 let FT: *i64 = sys_mmap(NPP*NFF*8) as *i64 134 var py2: i64 = 0 135 while py2 < PS { 136 var px: i64 = 0 137 while px < PS { 138 let fp: *i64 = (FT as i64 + (py2*PS+px)*NFF*8) as *i64 139 features(px, py2, fp) 140 px = px + 1 141 } 142 py2 = py2 + 1 143 } 144 145 // ---- model + per-patch latents; frequency-scaled init (the R1 lesson) ---- 146 let W1: *i64 = sys_mmap(NH*NIN*8) as *i64 147 let B1: *i64 = sys_mmap(NH*8) as *i64 148 let W2: *i64 = sys_mmap(NO*NH*8) as *i64 149 let B2: *i64 = sys_mmap(NO*8) as *i64 150 let Z: *i64 = sys_mmap(NPAT*NL*8) as *i64 151 let gW1: *i64 = sys_mmap(NH*NIN*8) as *i64 152 let gB1: *i64 = sys_mmap(NH*8) as *i64 153 let gW2: *i64 = sys_mmap(NO*NH*8) as *i64 154 let gB2: *i64 = sys_mmap(NO*8) as *i64 155 let gZ: *i64 = sys_mmap(NPAT*NL*8) as *i64 156 let aW1: *i64 = sys_mmap(NH*NIN*8) as *i64 157 let aB1: *i64 = sys_mmap(NH*8) as *i64 158 let aW2: *i64 = sys_mmap(NO*NH*8) as *i64 159 let aB2: *i64 = sys_mmap(NO*8) as *i64 160 let aZ: *i64 = sys_mmap(NPAT*NL*8) as *i64 161 let st: *i64 = sys_mmap(16) as *i64 162 st[0] = 20260709 163 let bamp: *i64 = sys_mmap(8*8) as *i64 164 bamp[0]=600; bamp[1]=300; bamp[2]=150; bamp[3]=75; bamp[4]=38 165 var q: i64 = 0 166 while q < NH*NIN { 167 let col: i64 = q % NIN 168 var a: i64 = 150 // latent-input weights: small 169 if col < NFF { a = bamp[col/4] } // Fourier weights: freq-scaled 170 W1[q] = lcg(st) % (2*a) - a 171 q = q + 1 172 } 173 q = 0 174 while q < NH { B1[q] = ((q % 2)*2 - 1) * 150; q = q + 1 } 175 q = 0 176 while q < NO*NH { W2[q] = lcg(st) % 800 - 400; q = q + 1 } 177 q = 0 178 while q < NO { B2[q] = 2048; q = q + 1 } 179 q = 0 180 while q < NPAT*NL { Z[q] = lcg(st) % 600 - 300; q = q + 1 } 181 182 // ---- joint training: weights + latents, error-feedback updates ---- 183 let h: *i64 = sys_mmap(NH*8) as *i64 184 let dh: *i64 = sys_mmap(NH*8) as *i64 185 let dob: *i64 = sys_mmap(NO*8) as *i64 186 let fin: *i64 = sys_mmap(NIN*8) as *i64 187 var err0: i64 = 0 188 var errN: i64 = 0 189 var ep: i64 = 0 190 while ep < EPOCHS { 191 q = 0 192 while q < NH*NIN { gW1[q]=0; q=q+1 } 193 q = 0 194 while q < NH { gB1[q]=0; q=q+1 } 195 q = 0 196 while q < NO*NH { gW2[q]=0; q=q+1 } 197 q = 0 198 while q < NO { gB2[q]=0; q=q+1 } 199 q = 0 200 while q < NPAT*NL { gZ[q]=0; q=q+1 } 201 var errsum: i64 = 0 202 p = 0 203 while p < NPAT { 204 var pi: i64 = 0 205 while pi < NPP { 206 let f: *i64 = (FT as i64 + pi*NFF*8) as *i64 207 var i2: i64 = 0 208 while i2 < NFF { fin[i2] = f[i2]; i2 = i2 + 1 } 209 i2 = 0 210 while i2 < NL { fin[NFF+i2] = Z[p*NL+i2]; i2 = i2 + 1 } 211 // forward 212 var j: i64 = 0 213 while j < NH { 214 var acc: i64 = B1[j] 215 i2 = 0 216 while i2 < NIN { acc = acc + W1[j*NIN+i2]*fin[i2]/4096; i2 = i2 + 1 } 217 if acc < 0 { acc = 0 } 218 if acc > 16384 { acc = 16384 } 219 h[j] = acc 220 j = j + 1 221 } 222 let ti: i64 = (p*NPP+pi)*3 223 var c: i64 = 0 224 while c < NO { 225 var acc: i64 = B2[c] 226 j = 0 227 while j < NH { acc = acc + W2[c*NH+j]*h[j]/4096; j = j + 1 } 228 var d: i64 = acc - tgtQ[ti+c] 229 if d > 8192 { d = 8192 } 230 if d < 0-8192 { d = 0-8192 } 231 dob[c] = d 232 var ad: i64 = d 233 if ad < 0 { ad = 0 - ad } 234 errsum = errsum + ad 235 c = c + 1 236 } 237 // backward 238 j = 0 239 while j < NH { 240 var dd: i64 = 0 241 c = 0 242 while c < NO { dd = dd + W2[c*NH+j]*dob[c]/4096; c = c + 1 } 243 if h[j] == 0 { dd = 0 } 244 dh[j] = dd 245 j = j + 1 246 } 247 c = 0 248 while c < NO { 249 let dc: i64 = dob[c] 250 j = 0 251 while j < NH { gW2[c*NH+j] = gW2[c*NH+j] + dc*h[j]/4096; j = j + 1 } 252 gB2[c] = gB2[c] + dc 253 c = c + 1 254 } 255 j = 0 256 while j < NH { 257 let dj: i64 = dh[j] 258 if dj != 0 { 259 i2 = 0 260 while i2 < NIN { gW1[j*NIN+i2] = gW1[j*NIN+i2] + dj*fin[i2]/4096; i2 = i2 + 1 } 261 gB1[j] = gB1[j] + dj 262 i2 = 0 263 while i2 < NL { gZ[p*NL+i2] = gZ[p*NL+i2] + dj*W1[j*NIN+NFF+i2]/4096; i2 = i2 + 1 } 264 } 265 j = j + 1 266 } 267 pi = pi + 1 268 } 269 p = p + 1 270 } 271 // error-feedback updates (weights over ALL px; latents over their patch's px) 272 let LR: i64 = 600 273 let D: i64 = NPAT*NPP*4096 274 let DZ: i64 = NPP*4096 275 q = 0 276 while q < NH*NIN { aW1[q] = aW1[q] + gW1[q]*LR; let s2: i64 = aW1[q]/D; W1[q] = W1[q] - s2; aW1[q] = aW1[q] - s2*D; q = q + 1 } 277 q = 0 278 while q < NH { aB1[q] = aB1[q] + gB1[q]*LR; let s2: i64 = aB1[q]/D; B1[q] = B1[q] - s2; aB1[q] = aB1[q] - s2*D; q = q + 1 } 279 q = 0 280 while q < NO*NH { aW2[q] = aW2[q] + gW2[q]*LR; let s2: i64 = aW2[q]/D; W2[q] = W2[q] - s2; aW2[q] = aW2[q] - s2*D; q = q + 1 } 281 q = 0 282 while q < NO { aB2[q] = aB2[q] + gB2[q]*LR; let s2: i64 = aB2[q]/D; B2[q] = B2[q] - s2; aB2[q] = aB2[q] - s2*D; q = q + 1 } 283 q = 0 284 while q < NPAT*NL { aZ[q] = aZ[q] + gZ[q]*900; let s2: i64 = aZ[q]/DZ; Z[q] = Z[q] - s2; aZ[q] = aZ[q] - s2*DZ; q = q + 1 } 285 let e255: i64 = errsum*255/(NPAT*NPP*3*4096) 286 if ep == 0 { err0 = e255 } 287 errN = e255 288 if ep % 100 == 0 { hw(" epoch "); pn(ep); hw(" mean|err|="); pn(e255); hw("/255\n" as *u8) } 289 ep = ep + 1 290 } 291 hw(" trained: err "); pn(err0); hw(" -> "); pn(errN); hw(" /255 ("); pn(NH*NIN+NH+NO*NH+NO); hw(" params + "); pn(NPAT*NL); hw(" latents)\n" as *u8) 292 293 var t1: i64 = 0 294 if errN*2 < err0 { t1 = 1 } 295 if t1 == 1 { hw("T1 PASS joint training converges across the 6-patch family\n" as *u8) } 296 else { fails=fails+1; hw("T1 FAIL\n" as *u8) } 297 var t2: i64 = 0 298 if errN < 22 { t2 = 1 } 299 if t2 == 1 { hw("T2 PASS faithful per-patch reconstruction (the latent separates the family)\n" as *u8) } 300 else { fails=fails+1; hw("T2 FAIL err="); pn(errN); hw("\n" as *u8) } 301 302 // ---- render reconstructions + NOVEL generations ---- 303 let rec: *i64 = sys_mmap(NPAT*NPP*8) as *i64 304 p = 0 305 while p < NPAT { 306 var pi: i64 = 0 307 while pi < NPP { 308 let f: *i64 = (FT as i64 + pi*NFF*8) as *i64 309 var i2: i64 = 0 310 while i2 < NFF { fin[i2] = f[i2]; i2 = i2 + 1 } 311 i2 = 0 312 while i2 < NL { fin[NFF+i2] = Z[p*NL+i2]; i2 = i2 + 1 } 313 rec[p*NPP+pi] = infer(W1, B1, W2, B2, fin, h) 314 pi = pi + 1 315 } 316 p = p + 1 317 } 318 // novel latents: 3 interpolations + 3 jittered in-range draws (deterministic) 319 let ZN: *i64 = sys_mmap(NPAT*NL*8) as *i64 320 var l: i64 = 0 321 while l < NL { 322 ZN[l] = (Z[0*NL+l] + Z[1*NL+l])/2 323 ZN[NL+l] = (Z[2*NL+l] + Z[3*NL+l])/2 324 ZN[2*NL+l] = (Z[4*NL+l] + Z[5*NL+l])/2 325 ZN[3*NL+l] = (Z[0*NL+l] + Z[3*NL+l] + Z[5*NL+l])/3 + (lcg(st) % 120 - 60) 326 ZN[4*NL+l] = (Z[1*NL+l] + Z[2*NL+l] + Z[4*NL+l])/3 + (lcg(st) % 120 - 60) 327 ZN[5*NL+l] = (Z[0*NL+l]*3 - Z[1*NL+l])/2 + (lcg(st) % 80 - 40) 328 l = l + 1 329 } 330 let gen: *i64 = sys_mmap(NPAT*NPP*8) as *i64 331 p = 0 332 while p < NPAT { 333 var pi: i64 = 0 334 while pi < NPP { 335 let f: *i64 = (FT as i64 + pi*NFF*8) as *i64 336 var i2: i64 = 0 337 while i2 < NFF { fin[i2] = f[i2]; i2 = i2 + 1 } 338 i2 = 0 339 while i2 < NL { fin[NFF+i2] = ZN[p*NL+i2]; i2 = i2 + 1 } 340 gen[p*NPP+pi] = infer(W1, B1, W2, B2, fin, h) 341 pi = pi + 1 342 } 343 p = p + 1 344 } 345 // T3: each generation is (a) not a copy of ANY exemplar, (b) skin-like mean, (c) draws differ 346 var mincopy: i64 = 1000000000 347 var meanok: i64 = 0 348 var g2: i64 = 0 349 while g2 < NPAT { 350 var gmr: i64 = 0 351 var gmg: i64 = 0 352 var gmb: i64 = 0 353 var pi: i64 = 0 354 while pi < NPP { let v: i64 = gen[g2*NPP+pi]; gmr=gmr+(v&255); gmg=gmg+((v>>8)&255); gmb=gmb+((v>>16)&255); pi=pi+1 } 355 gmr=gmr/NPP; gmg=gmg/NPP; gmb=gmb/NPP 356 // skin-likeness: mean within the family's min..max band (+/-14) 357 var lo_r: i64 = 255; var hi_r: i64 = 0 358 var lo_g: i64 = 255; var hi_g: i64 = 0 359 var lo_b: i64 = 255; var hi_b: i64 = 0 360 p = 0 361 while p < NPAT { 362 if pmean[p*3] < lo_r { lo_r = pmean[p*3] } 363 if pmean[p*3] > hi_r { hi_r = pmean[p*3] } 364 if pmean[p*3+1] < lo_g { lo_g = pmean[p*3+1] } 365 if pmean[p*3+1] > hi_g { hi_g = pmean[p*3+1] } 366 if pmean[p*3+2] < lo_b { lo_b = pmean[p*3+2] } 367 if pmean[p*3+2] > hi_b { hi_b = pmean[p*3+2] } 368 p = p + 1 369 } 370 var okm: i64 = 1 371 if gmr < lo_r-14 { okm = 0 } 372 if gmr > hi_r+14 { okm = 0 } 373 if gmg < lo_g-14 { okm = 0 } 374 if gmg > hi_g+14 { okm = 0 } 375 if gmb < lo_b-14 { okm = 0 } 376 if gmb > hi_b+14 { okm = 0 } 377 meanok = meanok + okm 378 // distance to nearest exemplar 379 p = 0 380 while p < NPAT { 381 var d2: i64 = 0 382 pi = 0 383 while pi < NPP { 384 let a2: i64 = gen[g2*NPP+pi] 385 let b2: i64 = ex[p*NPP+pi] 386 var dd: i64 = (a2&255)-(b2&255); if dd<0 {dd=0-dd} 387 d2 = d2 + dd 388 pi = pi + 1 389 } 390 if d2 < mincopy { mincopy = d2 } 391 p = p + 1 392 } 393 g2 = g2 + 1 394 } 395 var divsum: i64 = 0 396 var pi3: i64 = 0 397 while pi3 < NPP { var dd: i64 = (gen[pi3]&255) - (gen[NPP+pi3]&255); if dd<0 {dd=0-dd} divsum = divsum + dd; pi3 = pi3 + 1 } 398 let mincopy255: i64 = mincopy/NPP 399 let div255: i64 = divsum/NPP 400 hw(" generation: min-dist-to-any-exemplar="); pn(mincopy255); hw("/255 skinlike "); pn(meanok); hw("/6 diversity(g0,g1)="); pn(div255); hw("/255\n" as *u8) 401 var t3: i64 = 0 402 if mincopy255 > 2 { if meanok >= 5 { if div255 > 2 { t3 = 1 } } } 403 if t3 == 1 { hw("T3 PASS GENERATION: novel latents -> novel, skin-like, diverse textures (not copies)\n" as *u8) } 404 else { fails=fails+1; hw("T3 FAIL generation\n" as *u8) } 405 406 // ---- T4 persist (weights + latents) -> reload -> bit-identical render ---- 407 let NW: i64 = NH*NIN + NH + NO*NH + NO 408 let wf: i64 = sys_openat_wr("knowledge/skinfam_w.bin\x00" as *u8, 0x1a4) 409 sys_write(wf, W1 as *u8, NH*NIN*8) 410 sys_write(wf, B1 as *u8, NH*8) 411 sys_write(wf, W2 as *u8, NO*NH*8) 412 sys_write(wf, B2 as *u8, NO*8) 413 sys_write(wf, Z as *u8, NPAT*NL*8) 414 sys_close(wf) 415 let lsz: *i64 = sys_mmap(16) as *i64 416 let blob: *u8 = sys_read_file("knowledge/skinfam_w.bin" as *u8, lsz) 417 var t4: i64 = 0 418 if lsz[0] == (NW + NPAT*NL)*8 { 419 let L1p: *i64 = blob as *i64 420 let L2p: *i64 = (blob as i64 + NH*NIN*8) as *i64 421 let L3p: *i64 = (blob as i64 + NH*NIN*8 + NH*8) as *i64 422 let L4p: *i64 = (blob as i64 + NH*NIN*8 + NH*8 + NO*NH*8) as *i64 423 let LZp: *i64 = (blob as i64 + NW*8) as *i64 424 var diff: i64 = 0 425 var pi4: i64 = 0 426 while pi4 < NPP { 427 let f: *i64 = (FT as i64 + pi4*NFF*8) as *i64 428 var i2: i64 = 0 429 while i2 < NFF { fin[i2] = f[i2]; i2 = i2 + 1 } 430 i2 = 0 431 while i2 < NL { fin[NFF+i2] = LZp[2*NL+i2]; i2 = i2 + 1 } 432 if infer(L1p, L2p, L3p, L4p, fin, h) != rec[2*NPP+pi4] { diff = diff + 1 } 433 pi4 = pi4 + 1 434 } 435 if diff == 0 { t4 = 1 } 436 } 437 if t4 == 1 { hw("T4 PASS persisted (skinfam_w.bin) + reloaded render BIT-IDENTICAL\n" as *u8) } 438 else { fails=fails+1; hw("T4 FAIL persistence\n" as *u8) } 439 440 // ---- PNG: exemplars | reconstructions | novel generations (x3 upscale) ---- 441 let CW: i64 = PS*3 442 let GW: i64 = CW*NPAT 443 let GH: i64 = CW*3 444 let gal: *i64 = sys_mmap(GW*GH*8) as *i64 445 var row: i64 = 0 446 while row < 3 { 447 p = 0 448 while p < NPAT { 449 var src: i64 = ex as i64 450 if row == 1 { src = rec as i64 } 451 if row == 2 { src = gen as i64 } 452 let sb: *i64 = src as *i64 453 var y: i64 = 0 454 while y < CW { 455 var x: i64 = 0 456 while x < CW { 457 gal[(row*CW+y)*GW + p*CW + x] = sb[p*NPP + (y/3)*PS + x/3] 458 x = x + 1 459 } 460 y = y + 1 461 } 462 p = p + 1 463 } 464 row = row + 1 465 } 466 write_png(gal, GW, GH, "knowledge/nx_skinfam.png" as *u8) 467 hw("PNG knowledge/nx_skinfam.png (exemplars | reconstructions | NOVEL)\n" as *u8) 468 469 if fails == 0 { hw("SKINFAM-GATE 4/4 GREEN -- P4 R2: a GENERATIVE sovereign skin-texture family (auto-decoder latents, integer end-to-end): novel latents -> NOVEL skin textures. seed->novel-skin unlocked for the neural track\n" as *u8); sys_exit(0); return 0 } 470 hw("SKINFAM-GATE RED fails="); pn(fails); hw("\n" as *u8) 471 sys_exit(1) 472 return 1 473}