8-to-3 priority encoder, magnitude 68

README.md

@@ -0,0 +1,68 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- encoder
+---
+
+# threshold-priorityencoder8
+
+8-to-3 priority encoder. Outputs 3-bit binary encoding of highest-priority active input.
+
+## Function
+
+priority_encode(i7..i0) -> (y2, y1, y0, valid)
+
+- i7 = highest priority, i0 = lowest priority
+- y2,y1,y0 = 3-bit binary encoding of highest active input index
+- valid = 1 if any input is active
+
+## Architecture
+
+**Layer 1: 8 neurons (h7..h0)**
+
+Each hk detects "ik is the highest active input":
+- hk fires when ik=1 AND all higher-priority inputs are 0
+- h7: weights [1,0,0,0,0,0,0,0], bias -1
+- h6: weights [-1,1,0,0,0,0,0,0], bias -1
+- ...
+- h0: weights [-1,-1,-1,-1,-1,-1,-1,1], bias -1
+
+**Layer 2: 4 neurons**
+
+- y2 = h7 OR h6 OR h5 OR h4
+- y1 = h7 OR h6 OR h3 OR h2
+- y0 = h7 OR h5 OR h3 OR h1
+- v = any h active
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 8 |
+| Outputs | 4 |
+| Neurons | 12 |
+| Layers | 2 |
+| Parameters | 108 |
+| Magnitude | 68 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+# (see model.py for full implementation)
+
+# Example: i5 is highest active (index 5 = 101)
+# priority_encode(0,0,1,0,0,0,0,0, w) -> (1, 0, 1, 1)
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-priorityencoder8",
+  "description": "8-to-3 priority encoder as threshold circuit",
+  "inputs": 8,
+  "outputs": 4,
+  "neurons": 12,
+  "layers": 2,
+  "parameters": 108
+}

create_safetensors.py

@@ -0,0 +1,92 @@
+import torch
+from safetensors.torch import save_file
+
+# Input order: i7, i6, i5, i4, i3, i2, i1, i0 (i7 = highest priority)
+# Layer 1: hk = "ik is the highest active input"
+# Layer 2: y2, y1, y0 (3-bit encoding), v (valid)
+
+weights = {}
+
+# Layer 1: 8 neurons detecting "this input is highest active"
+# layer1.hk detects input k being highest
+for k in range(8):
+    w = [0.0] * 8
+    # Input ik is at position (7-k) in the input array
+    w[7-k] = 1.0
+    # All higher-priority inputs (indices k+1 to 7) need to be 0
+    # These are at positions 0 to (6-k) in the input array
+    for j in range(7-k):
+        w[j] = -1.0
+    bias = -1.0
+    weights[f'layer1.h{k}.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'layer1.h{k}.bias'] = torch.tensor([bias], dtype=torch.float32)
+
+# Layer 2: combine h outputs
+# h array will be [h0, h1, h2, h3, h4, h5, h6, h7]
+# y2 = h4 OR h5 OR h6 OR h7 (indices 4,5,6,7 have bit 2 set)
+weights['layer2.y2.weight'] = torch.tensor([[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]], dtype=torch.float32)
+weights['layer2.y2.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y1 = h2 OR h3 OR h6 OR h7 (indices 2,3,6,7 have bit 1 set)
+weights['layer2.y1.weight'] = torch.tensor([[0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0]], dtype=torch.float32)
+weights['layer2.y1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y0 = h1 OR h3 OR h5 OR h7 (indices 1,3,5,7 have bit 0 set)
+weights['layer2.y0.weight'] = torch.tensor([[0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]], dtype=torch.float32)
+weights['layer2.y0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# v = any h active
+weights['layer2.v.weight'] = torch.tensor([[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]], dtype=torch.float32)
+weights['layer2.v.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def priority_encode(inputs):
+    inp = torch.tensor([float(x) for x in inputs])
+    # Layer 1: h[k] = hk output
+    h = []
+    for k in range(8):
+        hk = int((inp @ weights[f'layer1.h{k}.weight'].T + weights[f'layer1.h{k}.bias'] >= 0).item())
+        h.append(hk)
+    h_tensor = torch.tensor([float(x) for x in h])
+    # Layer 2
+    y2 = int((h_tensor @ weights['layer2.y2.weight'].T + weights['layer2.y2.bias'] >= 0).item())
+    y1 = int((h_tensor @ weights['layer2.y1.weight'].T + weights['layer2.y1.bias'] >= 0).item())
+    y0 = int((h_tensor @ weights['layer2.y0.weight'].T + weights['layer2.y0.bias'] >= 0).item())
+    v = int((h_tensor @ weights['layer2.v.weight'].T + weights['layer2.v.bias'] >= 0).item())
+    return y2, y1, y0, v
+
+print("Verifying priorityencoder8...")
+errors = 0
+for val in range(256):
+    inputs = [(val >> (7-j)) & 1 for j in range(8)]
+    y2, y1, y0, v = priority_encode(inputs)
+
+    # Find highest active input (i7 has highest priority)
+    highest = -1
+    for k in range(7, -1, -1):
+        if inputs[7-k]:  # inputs[7-k] is ik
+            highest = k
+            break
+
+    if highest == -1:
+        exp_v = 0
+        exp_y2, exp_y1, exp_y0 = 0, 0, 0
+    else:
+        exp_v = 1
+        exp_y2 = (highest >> 2) & 1
+        exp_y1 = (highest >> 1) & 1
+        exp_y0 = highest & 1
+
+    if v != exp_v or (v == 1 and (y2 != exp_y2 or y1 != exp_y1 or y0 != exp_y0)):
+        errors += 1
+        if errors <= 3:
+            print(f"ERROR: val={val}, inputs={inputs}, got ({y2},{y1},{y0},{v}), expected ({exp_y2},{exp_y1},{exp_y0},{exp_v})")
+
+if errors == 0:
+    print("All 256 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"Magnitude: {mag:.0f}")

model.py

@@ -0,0 +1,31 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def priority_encode(i7, i6, i5, i4, i3, i2, i1, i0, weights):
+    """8-to-3 priority encoder. Returns (y2, y1, y0, valid)."""
+    inputs = [i7, i6, i5, i4, i3, i2, i1, i0]
+    inp = torch.tensor([float(x) for x in inputs])
+    # Layer 1
+    h = []
+    for k in range(8):
+        hk = int((inp @ weights[f'layer1.h{k}.weight'].T + weights[f'layer1.h{k}.bias'] >= 0).item())
+        h.append(hk)
+    h_tensor = torch.tensor([float(x) for x in h])
+    # Layer 2
+    y2 = int((h_tensor @ weights['layer2.y2.weight'].T + weights['layer2.y2.bias'] >= 0).item())
+    y1 = int((h_tensor @ weights['layer2.y1.weight'].T + weights['layer2.y1.bias'] >= 0).item())
+    y0 = int((h_tensor @ weights['layer2.y0.weight'].T + weights['layer2.y0.bias'] >= 0).item())
+    v = int((h_tensor @ weights['layer2.v.weight'].T + weights['layer2.v.bias'] >= 0).item())
+    return y2, y1, y0, v
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Priority Encoder 8 (selected tests)')
+    for val in [0, 1, 2, 4, 8, 16, 32, 64, 128, 255]:
+        inputs = [(val >> (7-j)) & 1 for j in range(8)]
+        y2, y1, y0, v = priority_encode(*inputs, w)
+        idx = 4*y2 + 2*y1 + y0
+        print(f'  {val:3d} ({val:08b}) -> y={idx} ({y2}{y1}{y0}) v={v}')