Create README.md

README.md

@@ -0,0 +1,123 @@
+---
+license: cc-by-sa-4.0
+tags:
+- tiny
+- edge-ai
+- micro-model
+- boolean
+- comparison
+- RaspizdAI
+---
+
+# pizdecB3
+
+**pizdecB3** (format: `n.f.c` → name.function.count) is a tiny boolean comparison model.
+
+- **n** = pizdec  
+- **f** = B (Boolean)  
+- **c** = 3 (third model in the series)
+
+It takes two numbers and predicts one of three relations:
+
+- `>` (greater)
+- `=` (equal)
+- `<` (less)
+
+Also supports string input in the format `x?y`.
+
+## Model Details
+
+| Property              | Value                  |
+|-----------------------|------------------------|
+| Parameters            | ~1731                  |
+| Input                 | two floats `(a, b)` or string `"a?b"` |
+| Output                | `<`, `=`, or `>`       |
+| Architecture          | small MLP (input features: `a, b, a-b`) |
+| Framework             | PyTorch + Safetensors  |
+| License               | CC-BY-SA-4.0           |
+
+## Intended Use
+
+- Extremely lightweight number comparison
+- Edge / constrained environments
+- Educational / experimental micro-models
+- Fun baseline for boolean tasks
+
+**Not intended for** high-precision scientific computing or production systems that require perfect floating-point equality handling.
+
+## Example inference script
+
+```python
+import torch
+import torch.nn as nn
+from safetensors.torch import load_file
+from pathlib import Path
+
+class PizdecB3(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(3, 32),
+            nn.ReLU(),
+            nn.Linear(32, 32),
+            nn.ReLU(),
+            nn.Linear(32, 16),
+            nn.ReLU(),
+            nn.Linear(16, 3)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+    def _prepare(self, a, b):
+        a = torch.tensor([[float(a)]], dtype=torch.float32)
+        b = torch.tensor([[float(b)]], dtype=torch.float32)
+        return torch.cat([a, b, a - b], dim=1)
+
+    def predict(self, a, b) -> str:
+        with torch.no_grad():
+            x = self._prepare(a, b)
+            logits = self.forward(x)
+            pred = torch.argmax(logits, dim=-1).item()
+        return ["<", "=", ">"][pred]
+
+    def predict_str(self, s: str) -> str:
+        try:
+            left, right = s.strip().split("?")
+            return self.predict(left, right)
+        except:
+            return "format error"
+
+    @classmethod
+    def from_pretrained(cls, path="pizdecB3"):
+        model = cls()
+        state = load_file(Path(path) / "model.safetensors")
+        model.load_state_dict(state)
+        model.eval()
+        return model
+
+# Load
+model = PizdecB3.from_pretrained("pizdecB3")
+
+# Usage
+print(model.predict(10, 5))       # >
+print(model.predict(3, 3))        # =
+print(model.predict_str("8?2"))   # >
+```
+
+## Known Limitations
+
+- Struggles with very close floating-point numbers (e.g. `100` vs `99.9`, `7.0` vs `7.01`)
+- Exact equality on large floats can be unstable
+- No support for non-numeric input
+- Not suitable for high-precision comparison tasks
+- Performance degrades when numbers differ by less than ~0.01–0.05 depending on magnitude
+
+## Files
+
+- `model.safetensors` — model weights
+- `config.json` — basic config
+
+---
+
+Part of the experimental **RaspizdAI** micro-model collection.