Upload folder using huggingface_hub

README.md

@@ -0,0 +1,160 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- encoding
+- decoder
+---
+
+# threshold-binary-to-onehot
+
+2-to-4 binary-to-one-hot encoder. Converts a 2-bit binary value to a 4-bit one-hot representation. The inverse of the one-hot decoder.
+
+## Circuit
+
+```
+     a1        a0
+      │         │
+      ├─────────┤
+      │         │
+  ┌───┴───┐ ┌───┴───┐
+  │       │ │       │
+  ▼       ▼ ▼       ▼
+┌───┐   ┌───┐   ┌───┐   ┌───┐
+│y0 │   │y1 │   │y2 │   │y3 │
+│NOR│   │AND│   │AND│   │AND│
+│   │   │¬a1│   │a1 │   │a1 │
+│   │   │ a0│   │¬a0│   │a0 │
+└───┘   └───┘   └───┘   └───┘
+  │       │       │       │
+  ▼       ▼       ▼       ▼
+ y0      y1      y2      y3
+(00)    (01)    (10)    (11)
+```
+
+## Function
+
+```
+binary_to_onehot(a1, a0) -> (y0, y1, y2, y3)
+```
+
+Exactly one output is high, corresponding to the binary input value.
+
+## Truth Table
+
+| a1 | a0 | Value | y0 | y1 | y2 | y3 |
+|:--:|:--:|:-----:|:--:|:--:|:--:|:--:|
+| 0 | 0 | 0 | 1 | 0 | 0 | 0 |
+| 0 | 1 | 1 | 0 | 1 | 0 | 0 |
+| 1 | 0 | 2 | 0 | 0 | 1 | 0 |
+| 1 | 1 | 3 | 0 | 0 | 0 | 1 |
+
+Output encoding: `y[i] = 1` iff input value equals `i`.
+
+## Mechanism
+
+Each output neuron detects a specific binary pattern:
+
+| Output | Pattern | Weights [a1, a0] | Bias | Logic |
+|--------|---------|------------------|------|-------|
+| y0 | 00 | [-1, -1] | 0 | NOR(a1, a0) |
+| y1 | 01 | [-1, +1] | -1 | ¬a1 AND a0 |
+| y2 | 10 | [+1, -1] | -1 | a1 AND ¬a0 |
+| y3 | 11 | [+1, +1] | -2 | a1 AND a0 |
+
+**Analysis:**
+
+- **y0 (value 0):** Fires when both inputs are 0. Negative weights ensure any 1 prevents firing.
+- **y1 (value 1):** Fires when a1=0 and a0=1. The -1 on a1 inhibits, +1 on a0 excites.
+- **y2 (value 2):** Fires when a1=1 and a0=0. The +1 on a1 excites, -1 on a0 inhibits.
+- **y3 (value 3):** Fires when both are 1. Both positive weights must overcome bias -2.
+
+## Architecture
+
+Single-layer implementation with 4 parallel neurons:
+
+| Neuron | Weights | Bias | Detects |
+|--------|---------|------|---------|
+| y0 | [-1, -1] | 0 | Binary 00 |
+| y1 | [-1, +1] | -1 | Binary 01 |
+| y2 | [+1, -1] | -1 | Binary 10 |
+| y3 | [+1, +1] | -2 | Binary 11 |
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 2 (a1, a0) |
+| Outputs | 4 (y0, y1, y2, y3) |
+| Neurons | 4 |
+| Layers | 1 |
+| Parameters | 12 |
+| Magnitude | 12 |
+
+## Relationship to One-Hot Decoder
+
+This circuit is the **inverse** of `threshold-onehot-decoder`:
+
+```
+Binary [a1, a0] ──► binary-to-onehot ──► One-hot [y0, y1, y2, y3]
+One-hot [y0, y1, y2, y3] ──► onehot-decoder ──► Binary [a1, a0]
+```
+
+Together they form a codec pair for binary ↔ one-hot conversion.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def binary_to_onehot(a1, a0):
+    inp = torch.tensor([float(a1), float(a0)])
+    y0 = int((inp @ w['y0.weight'].T + w['y0.bias'] >= 0).item())
+    y1 = int((inp @ w['y1.weight'].T + w['y1.bias'] >= 0).item())
+    y2 = int((inp @ w['y2.weight'].T + w['y2.bias'] >= 0).item())
+    y3 = int((inp @ w['y3.weight'].T + w['y3.bias'] >= 0).item())
+    return y0, y1, y2, y3
+
+# Examples
+print(binary_to_onehot(0, 0))  # (1, 0, 0, 0) - value 0
+print(binary_to_onehot(0, 1))  # (0, 1, 0, 0) - value 1
+print(binary_to_onehot(1, 0))  # (0, 0, 1, 0) - value 2
+print(binary_to_onehot(1, 1))  # (0, 0, 0, 1) - value 3
+```
+
+## Applications
+
+- Address decoding in memory systems
+- Demultiplexer control signals
+- State machine encoding
+- Neural network softmax approximation
+- Priority encoder inputs
+
+## Scaling
+
+For n-bit binary to 2^n one-hot:
+- 3-bit → 8 outputs (8 neurons)
+- 4-bit → 16 outputs (16 neurons)
+
+Each additional input bit doubles the outputs.
+
+## Files
+
+```
+threshold-binary-to-onehot/
+├── model.safetensors
+├── model.py
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-binary-to-onehot",
+  "description": "2-to-4 binary to one-hot encoder",
+  "inputs": 2,
+  "outputs": 4,
+  "neurons": 4,
+  "layers": 1,
+  "parameters": 12
+}

create_safetensors.py

@@ -0,0 +1,71 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# Binary to One-Hot Encoder (2-to-4)
+# Inputs: a1, a0 (binary value 0-3)
+# Outputs: y0, y1, y2, y3 (one-hot encoding)
+#
+# y0 = 1 when a1=0, a0=0 (NOR)
+# y1 = 1 when a1=0, a0=1 (AND with inverted a1)
+# y2 = 1 when a1=1, a0=0 (AND with inverted a0)
+# y3 = 1 when a1=1, a0=1 (AND)
+
+# y0: NOR(a1, a0) - fires when both are 0
+weights['y0.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['y0.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# y1: NOT(a1) AND a0 - fires when a1=0, a0=1
+weights['y1.weight'] = torch.tensor([[-1.0, 1.0]], dtype=torch.float32)
+weights['y1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y2: a1 AND NOT(a0) - fires when a1=1, a0=0
+weights['y2.weight'] = torch.tensor([[1.0, -1.0]], dtype=torch.float32)
+weights['y2.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y3: a1 AND a0 - fires when both are 1
+weights['y3.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y3.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def binary_to_onehot(a1, a0):
+    inp = torch.tensor([float(a1), float(a0)])
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y2 = int((inp @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    y3 = int((inp @ weights['y3.weight'].T + weights['y3.bias'] >= 0).item())
+    return y0, y1, y2, y3
+
+print("Verifying binary-to-onehot...")
+errors = 0
+for val in range(4):
+    a1, a0 = (val >> 1) & 1, val & 1
+    y0, y1, y2, y3 = binary_to_onehot(a1, a0)
+
+    # Check exactly one output is high
+    outputs = [y0, y1, y2, y3]
+    if sum(outputs) != 1:
+        errors += 1
+        print(f"ERROR: {a1}{a0} -> {outputs} (not one-hot)")
+    # Check correct output is high
+    elif outputs[val] != 1:
+        errors += 1
+        print(f"ERROR: {a1}{a0} -> {outputs} (wrong position)")
+
+if errors == 0:
+    print("All 4 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")
+
+print("\nTruth Table:")
+print("a1 a0 | y0 y1 y2 y3 | value")
+print("------+-------------+------")
+for val in range(4):
+    a1, a0 = (val >> 1) & 1, val & 1
+    y0, y1, y2, y3 = binary_to_onehot(a1, a0)
+    print(f" {a1}  {a0} |  {y0}  {y1}  {y2}  {y3} |   {val}")

model.py

@@ -0,0 +1,24 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def binary_to_onehot(a1, a0, weights):
+    """Convert 2-bit binary to 4-bit one-hot encoding."""
+    inp = torch.tensor([float(a1), float(a0)])
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y2 = int((inp @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    y3 = int((inp @ weights['y3.weight'].T + weights['y3.bias'] >= 0).item())
+    return y0, y1, y2, y3
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Binary to One-Hot Encoder (2-to-4):')
+    print('a1 a0 | y0 y1 y2 y3 | value')
+    print('------+-------------+------')
+    for val in range(4):
+        a1, a0 = (val >> 1) & 1, val & 1
+        y0, y1, y2, y3 = binary_to_onehot(a1, a0, w)
+        print(f' {a1}  {a0} |  {y0}  {y1}  {y2}  {y3} |   {val}')

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b68212cf121754735cc150c45cdb9587afe702f91a23356c4f210e00ecf60fd5
+size 560