Upload folder using huggingface_hub

.gitattributes

@@ -1 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,95 +1,95 @@
----
-license: mit
-tags:
-- pytorch
-- safetensors
-- threshold-logic
-- neuromorphic
-- encoding
----
-
-# threshold-onehot-decoder
-
-4-to-2 one-hot decoder. Converts a 4-bit one-hot representation to a 2-bit binary value.
-
-## Function
-
-onehot_decode(y3, y2, y1, y0) -> (a1, a0)
-
-Input must have exactly one bit set.
-
-## Truth Table
-
-| y3 | y2 | y1 | y0 | a1 | a0 | Value |
-|----|----|----|----|----|-----|-------|
-| 0 | 0 | 0 | 1 | 0 | 0 | 0 |
-| 0 | 0 | 1 | 0 | 0 | 1 | 1 |
-| 0 | 1 | 0 | 0 | 1 | 0 | 2 |
-| 1 | 0 | 0 | 0 | 1 | 1 | 3 |
-
-## Architecture
-
-Single-layer implementation:
-
-```
-  y3   y2   y1   y0
-   │    │    │    │
-   └────┴────┴────┘
-         │
-    ┌────┴────┐
-    │         │
-    ▼         ▼
-  ┌───┐     ┌───┐
-  │a1 │     │a0 │  Layer 1
-  │OR │     │OR │
-  └───┘     └───┘
-    │         │
-    ▼         ▼
-```
-
-Each output is a single OR gate:
-- a0 = OR(y1, y3): w=[1,0,1,0], b=-1
-- a1 = OR(y2, y3): w=[1,1,0,0], b=-1
-
-The decoder recognizes that:
-- Bit 0 of position = 1 for positions 1 and 3
-- Bit 1 of position = 1 for positions 2 and 3
-
-## Parameters
-
-| | |
-|---|---|
-| Inputs | 4 |
-| Outputs | 2 |
-| Neurons | 2 |
-| Layers | 1 |
-| Parameters | 10 |
-| Magnitude | 6 |
-
-## Usage
-
-```python
-from safetensors.torch import load_file
-import torch
-
-w = load_file('model.safetensors')
-
-def decode(y3, y2, y1, y0):
-    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
-    a0 = int((inp @ w['a0.weight'].T + w['a0.bias'] >= 0).item())
-    a1 = int((inp @ w['a1.weight'].T + w['a1.bias'] >= 0).item())
-    return a1, a0
-
-# decode(0, 1, 0, 0) = (1, 0)  # value 2
-```
-
-## Applications
-
-- Priority encoder output processing
-- State machine decoding
-- Memory address reconstruction
-- Neural network output interpretation
-
-## License
-
-MIT
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- encoding
+---
+
+# threshold-onehot-decoder
+
+4-to-2 one-hot decoder. Converts a 4-bit one-hot representation to a 2-bit binary value.
+
+## Function
+
+onehot_decode(y3, y2, y1, y0) -> (a1, a0)
+
+Input must have exactly one bit set.
+
+## Truth Table
+
+| y3 | y2 | y1 | y0 | a1 | a0 | Value |
+|----|----|----|----|----|-----|-------|
+| 0 | 0 | 0 | 1 | 0 | 0 | 0 |
+| 0 | 0 | 1 | 0 | 0 | 1 | 1 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 2 |
+| 1 | 0 | 0 | 0 | 1 | 1 | 3 |
+
+## Architecture
+
+Single-layer implementation:
+
+```
+  y3   y2   y1   y0
+   │    │    │    │
+   └────┴────┴────┘
+         │
+    ┌────┴────┐
+    │         │
+    ▼         ▼
+  ┌───┐     ┌───┐
+  │a1 │     │a0 │  Layer 1
+  │OR │     │OR │
+  └───┘     └───┘
+    │         │
+    ▼         ▼
+```
+
+Each output is a single OR gate:
+- a0 = OR(y1, y3): w=[1,0,1,0], b=-1
+- a1 = OR(y2, y3): w=[1,1,0,0], b=-1
+
+The decoder recognizes that:
+- Bit 0 of position = 1 for positions 1 and 3
+- Bit 1 of position = 1 for positions 2 and 3
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 2 |
+| Neurons | 2 |
+| Layers | 1 |
+| Parameters | 10 |
+| Magnitude | 6 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def decode(y3, y2, y1, y0):
+    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
+    a0 = int((inp @ w['a0.weight'].T + w['a0.bias'] >= 0).item())
+    a1 = int((inp @ w['a1.weight'].T + w['a1.bias'] >= 0).item())
+    return a1, a0
+
+# decode(0, 1, 0, 0) = (1, 0)  # value 2
+```
+
+## Applications
+
+- Priority encoder output processing
+- State machine decoding
+- Memory address reconstruction
+- Neural network output interpretation
+
+## License
+
+MIT

config.json

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

create_safetensors.py

@@ -1,76 +1,76 @@
-import torch
-from safetensors.torch import save_file
-
-weights = {}
-
-# One-Hot Decoder (4-to-2)
-# Inputs: y3, y2, y1, y0 (one-hot encoding, exactly one bit set)
-# Outputs: a1, a0 (binary value 0-3)
-#
-# y3 y2 y1 y0 | a1 a0 | value
-# -----------+-------+------
-#  0  0  0  1 |  0  0 |   0
-#  0  0  1  0 |  0  1 |   1
-#  0  1  0  0 |  1  0 |   2
-#  1  0  0  0 |  1  1 |   3
-#
-# Single layer implementation:
-# a0 = OR(y1, y3) = 1 when position 1 or 3
-# a1 = OR(y2, y3) = 1 when position 2 or 3
-
-# a0 = OR(y1, y3)
-weights['a0.weight'] = torch.tensor([[1.0, 0.0, 1.0, 0.0]], dtype=torch.float32)
-weights['a0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
-
-# a1 = OR(y2, y3)
-weights['a1.weight'] = torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32)
-weights['a1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
-
-save_file(weights, 'model.safetensors')
-
-def onehot_decode(y3, y2, y1, y0):
-    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
-
-    a0 = int((inp @ weights['a0.weight'].T + weights['a0.bias'] >= 0).item())
-    a1 = int((inp @ weights['a1.weight'].T + weights['a1.bias'] >= 0).item())
-
-    return a1, a0
-
-def reference_decode(y3, y2, y1, y0):
-    if y0 == 1:
-        return 0, 0
-    if y1 == 1:
-        return 0, 1
-    if y2 == 1:
-        return 1, 0
-    if y3 == 1:
-        return 1, 1
-    return 0, 0
-
-print("Verifying One-Hot Decoder (4-to-2)...")
-errors = 0
-test_cases = [(0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0)]
-for y3, y2, y1, y0 in test_cases:
-    result = onehot_decode(y3, y2, y1, y0)
-    expected = reference_decode(y3, y2, y1, y0)
-    if result != expected:
-        errors += 1
-        print(f"ERROR: ({y3},{y2},{y1},{y0}) -> {result}, expected {expected}")
-
-if errors == 0:
-    print("All 4 test cases passed!")
-else:
-    print(f"FAILED: {errors} errors")
-
-print("\nTruth Table:")
-print("y3 y2 y1 y0 | a1 a0 | value")
-print("-" * 30)
-for y3, y2, y1, y0 in test_cases:
-    a1, a0 = onehot_decode(y3, y2, y1, y0)
-    val = a1 * 2 + a0
-    print(f" {y3}  {y2}  {y1}  {y0}  |  {a1}  {a0}  |   {val}")
-
-mag = sum(t.abs().sum().item() for t in weights.values())
-print(f"\nMagnitude: {mag:.0f}")
-print(f"Parameters: {sum(t.numel() for t in weights.values())}")
-print(f"Neurons: {len([k for k in weights.keys() if 'weight' in k])}")
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# One-Hot Decoder (4-to-2)
+# Inputs: y3, y2, y1, y0 (one-hot encoding, exactly one bit set)
+# Outputs: a1, a0 (binary value 0-3)
+#
+# y3 y2 y1 y0 | a1 a0 | value
+# -----------+-------+------
+#  0  0  0  1 |  0  0 |   0
+#  0  0  1  0 |  0  1 |   1
+#  0  1  0  0 |  1  0 |   2
+#  1  0  0  0 |  1  1 |   3
+#
+# Single layer implementation:
+# a0 = OR(y1, y3) = 1 when position 1 or 3
+# a1 = OR(y2, y3) = 1 when position 2 or 3
+
+# a0 = OR(y1, y3)
+weights['a0.weight'] = torch.tensor([[1.0, 0.0, 1.0, 0.0]], dtype=torch.float32)
+weights['a0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# a1 = OR(y2, y3)
+weights['a1.weight'] = torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32)
+weights['a1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def onehot_decode(y3, y2, y1, y0):
+    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
+
+    a0 = int((inp @ weights['a0.weight'].T + weights['a0.bias'] >= 0).item())
+    a1 = int((inp @ weights['a1.weight'].T + weights['a1.bias'] >= 0).item())
+
+    return a1, a0
+
+def reference_decode(y3, y2, y1, y0):
+    if y0 == 1:
+        return 0, 0
+    if y1 == 1:
+        return 0, 1
+    if y2 == 1:
+        return 1, 0
+    if y3 == 1:
+        return 1, 1
+    return 0, 0
+
+print("Verifying One-Hot Decoder (4-to-2)...")
+errors = 0
+test_cases = [(0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0)]
+for y3, y2, y1, y0 in test_cases:
+    result = onehot_decode(y3, y2, y1, y0)
+    expected = reference_decode(y3, y2, y1, y0)
+    if result != expected:
+        errors += 1
+        print(f"ERROR: ({y3},{y2},{y1},{y0}) -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 4 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("y3 y2 y1 y0 | a1 a0 | value")
+print("-" * 30)
+for y3, y2, y1, y0 in test_cases:
+    a1, a0 = onehot_decode(y3, y2, y1, y0)
+    val = a1 * 2 + a0
+    print(f" {y3}  {y2}  {y1}  {y0}  |  {a1}  {a0}  |   {val}")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"\nMagnitude: {mag:.0f}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")
+print(f"Neurons: {len([k for k in weights.keys() if 'weight' in k])}")

model.py

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