Upload folder using huggingface_hub

README.md

@@ -1,72 +1,72 @@
----
-license: mit
-tags:
-- pytorch
-- safetensors
-- threshold-logic
-- neuromorphic
----
-
-# threshold-parity8
-
-8-bit parity function. Outputs 1 if odd number of inputs are high.
-
-## Function
-
-parity8(b0..b7) = b0 XOR b1 XOR b2 XOR b3 XOR b4 XOR b5 XOR b6 XOR b7
-
-## Architecture
-
-Balanced tree of 7 XOR2 gates:
-
-```
-b0 b1  b2 b3  b4 b5  b6 b7
-  \/     \/     \/     \/
- xor01  xor23  xor45  xor67   (Level 1: 4 gates)
-    \    /       \    /
-   xor0123      xor4567       (Level 2: 2 gates)
-        \        /
-        xor_final             (Level 3: 1 gate)
-```
-
-Each XOR2 uses OR-NAND-AND structure (3 neurons, 9 params, magnitude 10).
-
-## Parameters
-
-| | |
-|---|---|
-| Inputs | 8 |
-| Outputs | 1 |
-| Neurons | 21 |
-| Layers | 6 |
-| Parameters | 63 |
-| Magnitude | 70 |
-
-## Usage
-
-```python
-from safetensors.torch import load_file
-
-w = load_file('model.safetensors')
-
-def xor2(a, b, prefix):
-    or_out = int(a * w[f'{prefix}.or.weight'][0] + b * w[f'{prefix}.or.weight'][1] + w[f'{prefix}.or.bias'] >= 0)
-    nand_out = int(a * w[f'{prefix}.nand.weight'][0] + b * w[f'{prefix}.nand.weight'][1] + w[f'{prefix}.nand.bias'] >= 0)
-    return int(or_out * w[f'{prefix}.and.weight'][0] + nand_out * w[f'{prefix}.and.weight'][1] + w[f'{prefix}.and.bias'] >= 0)
-
-def parity8(bits):
-    x01 = xor2(bits[0], bits[1], 'xor_01')
-    x23 = xor2(bits[2], bits[3], 'xor_23')
-    x45 = xor2(bits[4], bits[5], 'xor_45')
-    x67 = xor2(bits[6], bits[7], 'xor_67')
-    x0123 = xor2(x01, x23, 'xor_0123')
-    x4567 = xor2(x45, x67, 'xor_4567')
-    return xor2(x0123, x4567, 'xor_final')
-
-print(parity8([1, 0, 1, 0, 1, 0, 1, 0]))  # 0 (even)
-print(parity8([1, 1, 1, 0, 0, 0, 0, 0]))  # 1 (odd)
-```
-
-## License
-
-MIT
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-parity8
+
+8-bit parity function. Outputs 1 if odd number of inputs are high.
+
+## Function
+
+parity8(b0..b7) = b0 XOR b1 XOR b2 XOR b3 XOR b4 XOR b5 XOR b6 XOR b7
+
+## Architecture
+
+Balanced tree of 7 XOR2 gates:
+
+```
+b0 b1  b2 b3  b4 b5  b6 b7
+  \/     \/     \/     \/
+ xor01  xor23  xor45  xor67   (Level 1: 4 gates)
+    \    /       \    /
+   xor0123      xor4567       (Level 2: 2 gates)
+        \        /
+        xor_final             (Level 3: 1 gate)
+```
+
+Each XOR2 uses OR-NAND-AND structure (3 neurons, 9 params, magnitude 10).
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 8 |
+| Outputs | 1 |
+| Neurons | 21 |
+| Layers | 6 |
+| Parameters | 63 |
+| Magnitude | 70 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+def xor2(a, b, prefix):
+    or_out = int(a * w[f'{prefix}.or.weight'][0] + b * w[f'{prefix}.or.weight'][1] + w[f'{prefix}.or.bias'] >= 0)
+    nand_out = int(a * w[f'{prefix}.nand.weight'][0] + b * w[f'{prefix}.nand.weight'][1] + w[f'{prefix}.nand.bias'] >= 0)
+    return int(or_out * w[f'{prefix}.and.weight'][0] + nand_out * w[f'{prefix}.and.weight'][1] + w[f'{prefix}.and.bias'] >= 0)
+
+def parity8(bits):
+    x01 = xor2(bits[0], bits[1], 'xor_01')
+    x23 = xor2(bits[2], bits[3], 'xor_23')
+    x45 = xor2(bits[4], bits[5], 'xor_45')
+    x67 = xor2(bits[6], bits[7], 'xor_67')
+    x0123 = xor2(x01, x23, 'xor_0123')
+    x4567 = xor2(x45, x67, 'xor_4567')
+    return xor2(x0123, x4567, 'xor_final')
+
+print(parity8([1, 0, 1, 0, 1, 0, 1, 0]))  # 0 (even)
+print(parity8([1, 1, 1, 0, 0, 0, 0, 0]))  # 1 (odd)
+```
+
+## License
+
+MIT

config.json

@@ -1,9 +1,9 @@
-{
-  "name": "threshold-parity8",
-  "description": "8-bit parity (XOR of 8 inputs)",
-  "inputs": 8,
-  "outputs": 1,
-  "neurons": 21,
-  "layers": 6,
-  "parameters": 63
-}
+{
+  "name": "threshold-parity8",
+  "description": "8-bit parity (XOR of 8 inputs)",
+  "inputs": 8,
+  "outputs": 1,
+  "neurons": 21,
+  "layers": 6,
+  "parameters": 63
+}

create_safetensors.py

@@ -1,61 +1,61 @@
-import torch
-from safetensors.torch import save_file
-
-# Balanced tree structure for 8-bit parity
-# Level 1: XOR(a,b), XOR(c,d), XOR(e,f), XOR(g,h)
-# Level 2: XOR(ab, cd), XOR(ef, gh)
-# Level 3: XOR(abcd, efgh)
-
-def xor_block(prefix):
-    return {
-        f'{prefix}.or.weight': torch.tensor([1.0, 1.0], dtype=torch.float32),
-        f'{prefix}.or.bias': torch.tensor([-1.0], dtype=torch.float32),
-        f'{prefix}.nand.weight': torch.tensor([-1.0, -1.0], dtype=torch.float32),
-        f'{prefix}.nand.bias': torch.tensor([1.0], dtype=torch.float32),
-        f'{prefix}.and.weight': torch.tensor([1.0, 1.0], dtype=torch.float32),
-        f'{prefix}.and.bias': torch.tensor([-2.0], dtype=torch.float32),
-    }
-
-weights = {}
-# Level 1
-weights.update(xor_block('xor_01'))
-weights.update(xor_block('xor_23'))
-weights.update(xor_block('xor_45'))
-weights.update(xor_block('xor_67'))
-# Level 2
-weights.update(xor_block('xor_0123'))
-weights.update(xor_block('xor_4567'))
-# Level 3
-weights.update(xor_block('xor_final'))
-
-save_file(weights, 'model.safetensors')
-
-def xor2(a, b, prefix):
-    or_out = int(a * weights[f'{prefix}.or.weight'][0] + b * weights[f'{prefix}.or.weight'][1] + weights[f'{prefix}.or.bias'] >= 0)
-    nand_out = int(a * weights[f'{prefix}.nand.weight'][0] + b * weights[f'{prefix}.nand.weight'][1] + weights[f'{prefix}.nand.bias'] >= 0)
-    return int(or_out * weights[f'{prefix}.and.weight'][0] + nand_out * weights[f'{prefix}.and.weight'][1] + weights[f'{prefix}.and.bias'] >= 0)
-
-def parity8(bits):
-    # Level 1
-    x01 = xor2(bits[0], bits[1], 'xor_01')
-    x23 = xor2(bits[2], bits[3], 'xor_23')
-    x45 = xor2(bits[4], bits[5], 'xor_45')
-    x67 = xor2(bits[6], bits[7], 'xor_67')
-    # Level 2
-    x0123 = xor2(x01, x23, 'xor_0123')
-    x4567 = xor2(x45, x67, 'xor_4567')
-    # Level 3
-    return xor2(x0123, x4567, 'xor_final')
-
-print("Verifying parity8...")
-errors = 0
-for i in range(256):
-    bits = [(i >> j) & 1 for j in range(8)]
-    result = parity8(bits)
-    expected = sum(bits) % 2
-    if result != expected:
-        errors += 1
-        print(f"ERROR: parity({bits}) = {result}, expected {expected}")
-if errors == 0:
-    print("All 256 test cases passed!")
-print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")
+import torch
+from safetensors.torch import save_file
+
+# Balanced tree structure for 8-bit parity
+# Level 1: XOR(a,b), XOR(c,d), XOR(e,f), XOR(g,h)
+# Level 2: XOR(ab, cd), XOR(ef, gh)
+# Level 3: XOR(abcd, efgh)
+
+def xor_block(prefix):
+    return {
+        f'{prefix}.or.weight': torch.tensor([1.0, 1.0], dtype=torch.float32),
+        f'{prefix}.or.bias': torch.tensor([-1.0], dtype=torch.float32),
+        f'{prefix}.nand.weight': torch.tensor([-1.0, -1.0], dtype=torch.float32),
+        f'{prefix}.nand.bias': torch.tensor([1.0], dtype=torch.float32),
+        f'{prefix}.and.weight': torch.tensor([1.0, 1.0], dtype=torch.float32),
+        f'{prefix}.and.bias': torch.tensor([-2.0], dtype=torch.float32),
+    }
+
+weights = {}
+# Level 1
+weights.update(xor_block('xor_01'))
+weights.update(xor_block('xor_23'))
+weights.update(xor_block('xor_45'))
+weights.update(xor_block('xor_67'))
+# Level 2
+weights.update(xor_block('xor_0123'))
+weights.update(xor_block('xor_4567'))
+# Level 3
+weights.update(xor_block('xor_final'))
+
+save_file(weights, 'model.safetensors')
+
+def xor2(a, b, prefix):
+    or_out = int(a * weights[f'{prefix}.or.weight'][0] + b * weights[f'{prefix}.or.weight'][1] + weights[f'{prefix}.or.bias'] >= 0)
+    nand_out = int(a * weights[f'{prefix}.nand.weight'][0] + b * weights[f'{prefix}.nand.weight'][1] + weights[f'{prefix}.nand.bias'] >= 0)
+    return int(or_out * weights[f'{prefix}.and.weight'][0] + nand_out * weights[f'{prefix}.and.weight'][1] + weights[f'{prefix}.and.bias'] >= 0)
+
+def parity8(bits):
+    # Level 1
+    x01 = xor2(bits[0], bits[1], 'xor_01')
+    x23 = xor2(bits[2], bits[3], 'xor_23')
+    x45 = xor2(bits[4], bits[5], 'xor_45')
+    x67 = xor2(bits[6], bits[7], 'xor_67')
+    # Level 2
+    x0123 = xor2(x01, x23, 'xor_0123')
+    x4567 = xor2(x45, x67, 'xor_4567')
+    # Level 3
+    return xor2(x0123, x4567, 'xor_final')
+
+print("Verifying parity8...")
+errors = 0
+for i in range(256):
+    bits = [(i >> j) & 1 for j in range(8)]
+    result = parity8(bits)
+    expected = sum(bits) % 2
+    if result != expected:
+        errors += 1
+        print(f"ERROR: parity({bits}) = {result}, expected {expected}")
+if errors == 0:
+    print("All 256 test cases passed!")
+print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")

model.py

@@ -1,26 +1,26 @@
-import torch
-from safetensors.torch import load_file
-
-def load_model(path='model.safetensors'):
-    return load_file(path)
-
-def xor2(a, b, prefix, w):
-    or_out = int(a * w[f'{prefix}.or.weight'][0] + b * w[f'{prefix}.or.weight'][1] + w[f'{prefix}.or.bias'] >= 0)
-    nand_out = int(a * w[f'{prefix}.nand.weight'][0] + b * w[f'{prefix}.nand.weight'][1] + w[f'{prefix}.nand.bias'] >= 0)
-    return int(or_out * w[f'{prefix}.and.weight'][0] + nand_out * w[f'{prefix}.and.weight'][1] + w[f'{prefix}.and.bias'] >= 0)
-
-def parity8(bits, weights):
-    x01 = xor2(bits[0], bits[1], 'xor_01', weights)
-    x23 = xor2(bits[2], bits[3], 'xor_23', weights)
-    x45 = xor2(bits[4], bits[5], 'xor_45', weights)
-    x67 = xor2(bits[6], bits[7], 'xor_67', weights)
-    x0123 = xor2(x01, x23, 'xor_0123', weights)
-    x4567 = xor2(x45, x67, 'xor_4567', weights)
-    return xor2(x0123, x4567, 'xor_final', weights)
-
-if __name__ == '__main__':
-    w = load_model()
-    print('parity8 selected outputs:')
-    for n_ones in range(9):
-        bits = [1 if j < n_ones else 0 for j in range(8)]
-        print(f'  {n_ones} ones: {parity8(bits, w)}')
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def xor2(a, b, prefix, w):
+    or_out = int(a * w[f'{prefix}.or.weight'][0] + b * w[f'{prefix}.or.weight'][1] + w[f'{prefix}.or.bias'] >= 0)
+    nand_out = int(a * w[f'{prefix}.nand.weight'][0] + b * w[f'{prefix}.nand.weight'][1] + w[f'{prefix}.nand.bias'] >= 0)
+    return int(or_out * w[f'{prefix}.and.weight'][0] + nand_out * w[f'{prefix}.and.weight'][1] + w[f'{prefix}.and.bias'] >= 0)
+
+def parity8(bits, weights):
+    x01 = xor2(bits[0], bits[1], 'xor_01', weights)
+    x23 = xor2(bits[2], bits[3], 'xor_23', weights)
+    x45 = xor2(bits[4], bits[5], 'xor_45', weights)
+    x67 = xor2(bits[6], bits[7], 'xor_67', weights)
+    x0123 = xor2(x01, x23, 'xor_0123', weights)
+    x4567 = xor2(x45, x67, 'xor_4567', weights)
+    return xor2(x0123, x4567, 'xor_final', weights)
+
+if __name__ == '__main__':
+    w = load_model()
+    print('parity8 selected outputs:')
+    for n_ones in range(9):
+        bits = [1 if j < n_ones else 0 for j in range(8)]
+        print(f'  {n_ones} ones: {parity8(bits, w)}')