Upload skeptic_test.py with huggingface_hub

skeptic_test.py

@@ -0,0 +1,215 @@
+import warnings
+warnings.filterwarnings('ignore')
+from safetensors.torch import load_file
+import torch
+
+model = load_file('neural_computer.safetensors')
+
+def heaviside(x):
+    return (x >= 0).float()
+
+def int_to_bits(val):
+    return torch.tensor([(val >> (7-i)) & 1 for i in range(8)], dtype=torch.float32)
+
+def eval_xor_bool(a, b):
+    inp = torch.tensor([float(a), float(b)], dtype=torch.float32)
+    w1_or = model['boolean.xor.layer1.neuron1.weight']
+    b1_or = model['boolean.xor.layer1.neuron1.bias']
+    w1_nand = model['boolean.xor.layer1.neuron2.weight']
+    b1_nand = model['boolean.xor.layer1.neuron2.bias']
+    w2 = model['boolean.xor.layer2.weight']
+    b2 = model['boolean.xor.layer2.bias']
+    h_or = heaviside(inp @ w1_or + b1_or)
+    h_nand = heaviside(inp @ w1_nand + b1_nand)
+    hidden = torch.tensor([h_or.item(), h_nand.item()])
+    return int(heaviside(hidden @ w2 + b2).item())
+
+def eval_xor_arith(inp, prefix):
+    w1_or = model[f'{prefix}.layer1.or.weight']
+    b1_or = model[f'{prefix}.layer1.or.bias']
+    w1_nand = model[f'{prefix}.layer1.nand.weight']
+    b1_nand = model[f'{prefix}.layer1.nand.bias']
+    w2 = model[f'{prefix}.layer2.weight']
+    b2 = model[f'{prefix}.layer2.bias']
+    h_or = heaviside(inp @ w1_or + b1_or)
+    h_nand = heaviside(inp @ w1_nand + b1_nand)
+    hidden = torch.tensor([h_or.item(), h_nand.item()])
+    return heaviside(hidden @ w2 + b2).item()
+
+def eval_full_adder(a, b, cin, prefix):
+    inp_ab = torch.tensor([a, b], dtype=torch.float32)
+    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
+    w_c1 = model[f'{prefix}.ha1.carry.weight']
+    b_c1 = model[f'{prefix}.ha1.carry.bias']
+    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
+    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
+    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
+    w_c2 = model[f'{prefix}.ha2.carry.weight']
+    b_c2 = model[f'{prefix}.ha2.carry.bias']
+    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
+    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
+    w_or = model[f'{prefix}.carry_or.weight']
+    b_or = model[f'{prefix}.carry_or.bias']
+    cout = heaviside(inp_cout @ w_or + b_or).item()
+    return int(ha2_sum), int(cout)
+
+def add_8bit(a, b):
+    carry = 0.0
+    result = 0
+    for i in range(8):
+        s, carry = eval_full_adder(float((a >> i) & 1), float((b >> i) & 1), carry, f'arithmetic.ripplecarry8bit.fa{i}')
+        result |= (s << i)
+    return result, int(carry)
+
+def xor_8bit(a, b):
+    result = 0
+    for i in range(8):
+        bit = eval_xor_bool((a >> i) & 1, (b >> i) & 1)
+        result |= (bit << i)
+    return result
+
+def and_8bit(a, b):
+    result = 0
+    w = model['boolean.and.weight']
+    bias = model['boolean.and.bias']
+    for i in range(8):
+        inp = torch.tensor([float((a >> i) & 1), float((b >> i) & 1)], dtype=torch.float32)
+        out = int(heaviside(inp @ w + bias).item())
+        result |= (out << i)
+    return result
+
+def or_8bit(a, b):
+    result = 0
+    w = model['boolean.or.weight']
+    bias = model['boolean.or.bias']
+    for i in range(8):
+        inp = torch.tensor([float((a >> i) & 1), float((b >> i) & 1)], dtype=torch.float32)
+        out = int(heaviside(inp @ w + bias).item())
+        result |= (out << i)
+    return result
+
+def not_8bit(a):
+    result = 0
+    w = model['boolean.not.weight']
+    bias = model['boolean.not.bias']
+    for i in range(8):
+        inp = torch.tensor([float((a >> i) & 1)], dtype=torch.float32)
+        out = int(heaviside(inp @ w + bias).item())
+        result |= (out << i)
+    return result
+
+def gt(a, b):
+    a_bits, b_bits = int_to_bits(a), int_to_bits(b)
+    w = model['arithmetic.greaterthan8bit.comparator']
+    return 1 if ((a_bits - b_bits) @ w).item() > 0 else 0
+
+def lt(a, b):
+    a_bits, b_bits = int_to_bits(a), int_to_bits(b)
+    w = model['arithmetic.lessthan8bit.comparator']
+    return 1 if ((b_bits - a_bits) @ w).item() > 0 else 0
+
+def eq(a, b):
+    return 1 if (gt(a,b) == 0 and lt(a,b) == 0) else 0
+
+print('=' * 70)
+print('SKEPTICAL NERD TESTS')
+print('=' * 70)
+
+failures = []
+
+print('\n[1] IDENTITY LAWS')
+for a in [0, 1, 127, 128, 255, 170, 85]:
+    r, _ = add_8bit(a, 0)
+    if r != a: failures.append(f'A+0: {a}')
+    if xor_8bit(a, 0) != a: failures.append(f'A^0: {a}')
+    if and_8bit(a, 255) != a: failures.append(f'A&255: {a}')
+    if or_8bit(a, 0) != a: failures.append(f'A|0: {a}')
+print('  28 tests')
+
+print('\n[2] ANNIHILATION LAWS')
+for a in [0, 1, 127, 128, 255]:
+    if and_8bit(a, 0) != 0: failures.append(f'A&0: {a}')
+    if or_8bit(a, 255) != 255: failures.append(f'A|255: {a}')
+    if xor_8bit(a, a) != 0: failures.append(f'A^A: {a}')
+print('  15 tests')
+
+print('\n[3] INVOLUTION (~~A = A)')
+for a in [0, 1, 127, 128, 255, 170]:
+    if not_8bit(not_8bit(a)) != a: failures.append(f'~~A: {a}')
+print('  6 tests')
+
+print('\n[4] TWOS COMPLEMENT: A + ~A + 1 = 0')
+for a in [0, 1, 42, 127, 128, 255]:
+    not_a = not_8bit(a)
+    r1, _ = add_8bit(a, not_a)
+    r2, _ = add_8bit(r1, 1)
+    if r2 != 0: failures.append(f'twos comp: {a}')
+print('  6 tests')
+
+print('\n[5] CARRY PROPAGATION (worst case)')
+cases = [(255, 1, 0), (127, 129, 0), (1, 255, 0), (128, 128, 0), (255, 255, 254)]
+for a, b, exp in cases:
+    r, _ = add_8bit(a, b)
+    if r != exp: failures.append(f'carry: {a}+{b}={r}, expected {exp}')
+print('  5 tests')
+
+print('\n[6] COMMUTATIVITY')
+pairs = [(17, 42), (0, 255), (128, 127), (1, 254), (170, 85)]
+for a, b in pairs:
+    r1, _ = add_8bit(a, b)
+    r2, _ = add_8bit(b, a)
+    if r1 != r2: failures.append(f'add commute: {a},{b}')
+    if xor_8bit(a, b) != xor_8bit(b, a): failures.append(f'xor commute: {a},{b}')
+    if and_8bit(a, b) != and_8bit(b, a): failures.append(f'and commute: {a},{b}')
+    if or_8bit(a, b) != or_8bit(b, a): failures.append(f'or commute: {a},{b}')
+print('  20 tests')
+
+print('\n[7] DE MORGAN')
+for a, b in [(0, 0), (0, 255), (255, 0), (255, 255), (170, 85)]:
+    lhs = not_8bit(and_8bit(a, b))
+    rhs = or_8bit(not_8bit(a), not_8bit(b))
+    if lhs != rhs: failures.append(f'DM1: {a},{b}')
+    lhs = not_8bit(or_8bit(a, b))
+    rhs = and_8bit(not_8bit(a), not_8bit(b))
+    if lhs != rhs: failures.append(f'DM2: {a},{b}')
+print('  10 tests')
+
+print('\n[8] COMPARATOR EDGE CASES')
+cmp_tests = [
+    (0, 0, 0, 0, 1), (0, 1, 0, 1, 0), (1, 0, 1, 0, 0),
+    (127, 128, 0, 1, 0), (128, 127, 1, 0, 0),
+    (255, 255, 0, 0, 1), (255, 0, 1, 0, 0), (0, 255, 0, 1, 0),
+]
+for a, b, exp_gt, exp_lt, exp_eq in cmp_tests:
+    if gt(a, b) != exp_gt: failures.append(f'gt({a},{b})')
+    if lt(a, b) != exp_lt: failures.append(f'lt({a},{b})')
+    if eq(a, b) != exp_eq: failures.append(f'eq({a},{b})')
+print('  24 tests')
+
+print('\n[9] POPCOUNT SINGLE BITS + EXTREMES')
+w_pop = model['pattern_recognition.popcount.weight']
+b_pop = model['pattern_recognition.popcount.bias']
+for i in range(8):
+    val = 1 << i
+    bits = int_to_bits(val)
+    pc = int((bits @ w_pop + b_pop).item())
+    if pc != 1: failures.append(f'popcount(1<<{i})')
+if int((int_to_bits(0) @ w_pop + b_pop).item()) != 0: failures.append('popcount(0)')
+if int((int_to_bits(255) @ w_pop + b_pop).item()) != 8: failures.append('popcount(255)')
+print('  10 tests')
+
+print('\n[10] DISTRIBUTIVITY: A & (B | C) = (A & B) | (A & C)')
+for a, b, c in [(255, 15, 240), (170, 85, 51), (0, 255, 0)]:
+    lhs = and_8bit(a, or_8bit(b, c))
+    rhs = or_8bit(and_8bit(a, b), and_8bit(a, c))
+    if lhs != rhs: failures.append(f'distrib: {a},{b},{c}')
+print('  3 tests')
+
+print('\n' + '=' * 70)
+if failures:
+    print(f'FAILURES: {len(failures)}')
+    for f in failures[:20]:
+        print(f'  {f}')
+else:
+    print('ALL 127 SKEPTICAL TESTS PASSED')
+print('=' * 70)