| --- |
| 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 | |
|
|
| ## Training Dynamics |
|
|
| Here is the visualization of the model's training metrics (Loss and Accuracy): |
|
|
|  |
|
|
| ## 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 |
| * `training_metrics.png` — training visualization |
|
|
| --- |
|
|
| Part of the experimental **RaspizdAI** micro-model collection. |
|
|
