BCD to 7-segment decoder, magnitude 111

README.md

@@ -0,0 +1,89 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-7segment
+
+BCD to 7-segment display decoder.
+
+## Function
+
+segment_decode(B3, B2, B1, B0) -> {a, b, c, d, e, f, g}
+
+Converts 4-bit BCD input (0-9) to 7 segment control signals.
+
+## Segment Layout
+
+```
+  aaa
+ f   b
+  ggg
+ e   c
+  ddd
+```
+
+## Digit Patterns
+
+| Digit | a | b | c | d | e | f | g | Display |
+|-------|---|---|---|---|---|---|---|---------|
+| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | `0` |
+| 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | `1` |
+| 2 | 1 | 1 | 0 | 1 | 1 | 0 | 1 | `2` |
+| 3 | 1 | 1 | 1 | 1 | 0 | 0 | 1 | `3` |
+| 4 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | `4` |
+| 5 | 1 | 0 | 1 | 1 | 0 | 1 | 1 | `5` |
+| 6 | 1 | 0 | 1 | 1 | 1 | 1 | 1 | `6` |
+| 7 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | `7` |
+| 8 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | `8` |
+| 9 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | `9` |
+
+## Architecture
+
+Two-layer design:
+
+```
+B3,B2,B1,B0 ─► [d0] ─┐
+             [d1] ─┤
+             [d2] ─┤      [OR] ─► a
+             [d3] ─┼─────► [OR] ─► b
+             [d4] ─┤      [OR] ─► c
+             [d5] ─┤      [OR] ─► d
+             [d6] ─┤      [OR] ─► e
+             [d7] ─┤      [OR] ─► f
+             [d8] ─┤      [OR] ─► g
+             [d9] ─┘
+```
+
+Layer 1: 10 digit detectors (pattern matchers)
+Layer 2: 7 OR gates combining relevant digits for each segment
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 7 |
+| Neurons | 17 |
+| Layers | 2 |
+| Parameters | 127 |
+| Magnitude | 111 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+# Full implementation in model.py
+
+# Example: Display digit 5
+# result = segment_decode(0, 1, 0, 1, weights)
+# -> {'a':1, 'b':0, 'c':1, 'd':1, 'e':0, 'f':1, 'g':1}
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-7segment",
+  "description": "BCD to 7-segment display decoder",
+  "inputs": 4,
+  "outputs": 7,
+  "neurons": 17,
+  "layers": 2,
+  "parameters": 127
+}

create_safetensors.py

@@ -0,0 +1,105 @@
+import torch
+from safetensors.torch import save_file
+
+# BCD to 7-segment decoder
+# Inputs: B3, B2, B1, B0 (4-bit BCD, 0-9)
+# Outputs: a, b, c, d, e, f, g (7 segments)
+#
+# Segment layout:
+#   aaa
+#  f   b
+#   ggg
+#  e   c
+#   ddd
+#
+# Layer 1: 10 digit detectors (d0-d9)
+# Layer 2: 7 segment OR gates
+
+weights = {}
+
+# Segment patterns: which digits activate each segment
+# 0=OFF, 1=ON
+segments = {
+    'a': [1, 0, 1, 1, 0, 1, 1, 1, 1, 1],  # 0,2,3,5,6,7,8,9
+    'b': [1, 1, 1, 1, 1, 0, 0, 1, 1, 1],  # 0,1,2,3,4,7,8,9
+    'c': [1, 1, 0, 1, 1, 1, 1, 1, 1, 1],  # 0,1,3,4,5,6,7,8,9
+    'd': [1, 0, 1, 1, 0, 1, 1, 0, 1, 1],  # 0,2,3,5,6,8,9
+    'e': [1, 0, 1, 0, 0, 0, 1, 0, 1, 0],  # 0,2,6,8
+    'f': [1, 0, 0, 0, 1, 1, 1, 0, 1, 1],  # 0,4,5,6,8,9
+    'g': [0, 0, 1, 1, 1, 1, 1, 0, 1, 1],  # 2,3,4,5,6,8,9
+}
+
+# Layer 1: Digit detectors
+# For digit d, fire when input matches d
+for d in range(10):
+    b3, b2, b1, b0 = (d >> 3) & 1, (d >> 2) & 1, (d >> 1) & 1, d & 1
+    w = [
+        1.0 if b3 else -1.0,
+        1.0 if b2 else -1.0,
+        1.0 if b1 else -1.0,
+        1.0 if b0 else -1.0,
+    ]
+    bias = -bin(d).count('1')  # Need all 1-bits to match
+    weights[f'd{d}.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'd{d}.bias'] = torch.tensor([float(bias)], dtype=torch.float32)
+
+# Layer 2: Segment OR gates
+for seg_name, pattern in segments.items():
+    # OR gate: weight 1 for each digit that activates this segment
+    w = [float(pattern[d]) for d in range(10)]
+    # OR fires if any input is 1: bias = -1
+    weights[f'{seg_name}.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'{seg_name}.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def segment_decode(b3, b2, b1, b0):
+    inp = torch.tensor([float(b3), float(b2), float(b1), float(b0)])
+
+    # Layer 1: detect which digit
+    digits = []
+    for d in range(10):
+        val = int((inp @ weights[f'd{d}.weight'].T + weights[f'd{d}.bias'] >= 0).item())
+        digits.append(val)
+    digit_vec = torch.tensor([float(d) for d in digits])
+
+    # Layer 2: compute segments
+    result = {}
+    for seg in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
+        val = int((digit_vec @ weights[f'{seg}.weight'].T + weights[f'{seg}.bias'] >= 0).item())
+        result[seg] = val
+
+    return result
+
+print("Verifying 7segment decoder...")
+errors = 0
+
+expected_patterns = [
+    "1111110",  # 0
+    "0110000",  # 1
+    "1101101",  # 2
+    "1111001",  # 3
+    "0110011",  # 4
+    "1011011",  # 5
+    "1011111",  # 6
+    "1110000",  # 7
+    "1111111",  # 8
+    "1111011",  # 9
+]
+
+for digit in range(10):
+    b3, b2, b1, b0 = (digit >> 3) & 1, (digit >> 2) & 1, (digit >> 1) & 1, digit & 1
+    result = segment_decode(b3, b2, b1, b0)
+    pattern = ''.join([str(result[s]) for s in 'abcdefg'])
+
+    if pattern != expected_patterns[digit]:
+        errors += 1
+        print(f"ERROR: digit {digit} -> {pattern}, expected {expected_patterns[digit]}")
+
+if errors == 0:
+    print("All 10 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,43 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def segment_decode(b3, b2, b1, b0, weights):
+    """BCD to 7-segment decoder. Returns dict with segments a-g."""
+    inp = torch.tensor([float(b3), float(b2), float(b1), float(b0)])
+
+    # Layer 1: detect which digit
+    digits = []
+    for d in range(10):
+        val = int((inp @ weights[f'd{d}.weight'].T + weights[f'd{d}.bias'] >= 0).item())
+        digits.append(val)
+    digit_vec = torch.tensor([float(d) for d in digits])
+
+    # Layer 2: compute segments
+    result = {}
+    for seg in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
+        val = int((digit_vec @ weights[f'{seg}.weight'].T + weights[f'{seg}.bias'] >= 0).item())
+        result[seg] = val
+
+    return result
+
+def display_digit(segs):
+    """ASCII art display of 7-segment pattern."""
+    a = ' ' + ('_' * 3 if segs['a'] else ' ' * 3) + ' '
+    b = ('|' if segs['f'] else ' ') + ' ' * 3 + ('|' if segs['b'] else ' ')
+    g = ' ' + ('_' * 3 if segs['g'] else ' ' * 3) + ' '
+    c = ('|' if segs['e'] else ' ') + ' ' * 3 + ('|' if segs['c'] else ' ')
+    d = ' ' + ('_' * 3 if segs['d'] else ' ' * 3) + ' '
+    return '\n'.join([a, b, g, c, d])
+
+if __name__ == '__main__':
+    w = load_model()
+    print('7-Segment Display Decoder:')
+    for digit in range(10):
+        b3, b2, b1, b0 = (digit >> 3) & 1, (digit >> 2) & 1, (digit >> 1) & 1, digit & 1
+        result = segment_decode(b3, b2, b1, b0, w)
+        pattern = ''.join([str(result[s]) for s in 'abcdefg'])
+        print(f'\nDigit {digit} ({b3}{b2}{b1}{b0}) -> {pattern}')
+        print(display_digit(result))