Download model.py from mac-test/modular-arithmetic-residue-net: direct link, hf CLI and curl.
- Browser
- Download file 2.05 kB
-
https://huggingface.co/mac-test/modular-arithmetic-residue-net/resolve/main/model.py
- Command line
-
hf download hf://mac-test/modular-arithmetic-residue-net/model.py
-
curl -L -o model.py https://huggingface.co/mac-test/modular-arithmetic-residue-net/resolve/main/model.py
2.05 kB
| from __future__ import annotations | |
| import json | |
| import struct | |
| from pathlib import Path | |
| from modchallenge.interface.base_model import ModularMultiplicationModel | |
| class DlpTableBaseline(ModularMultiplicationModel): | |
| def load(self, model_dir: str) -> None: | |
| model_path = Path(model_dir) | |
| with (model_path / "weights.json").open("r", encoding="utf-8") as file: | |
| metadata = json.load(file) | |
| self._prime_to_table = {} | |
| for item in metadata["tables"]: | |
| prime = int(item["prime"]) | |
| self._prime_to_table[str(prime)] = ( | |
| prime, | |
| int(item["log_offset"]), | |
| int(item["exp_offset"]), | |
| ) | |
| self._table_bytes = (model_path / "weights.bin").read_bytes() | |
| def preprocess_a(self, a: str) -> int: | |
| return self._encode_supported_residue(a) | |
| def preprocess_b(self, b: str) -> int: | |
| return self._encode_supported_residue(b) | |
| def preprocess_p(self, p: str) -> str: | |
| normalized = p.strip().lstrip("0") | |
| return normalized or "0" | |
| def predict_digits(self, a_enc: int, b_enc: int, p_enc: str) -> list[int]: | |
| table = self._prime_to_table.get(p_enc) | |
| if table is None: | |
| return [0] | |
| prime, log_offset, exp_offset = table | |
| a_residue = a_enc % prime | |
| b_residue = b_enc % prime | |
| if a_residue == 0 or b_residue == 0: | |
| return [0] | |
| log_a = self._read_u16(log_offset + a_residue) | |
| log_b = self._read_u16(log_offset + b_residue) | |
| answer_log = (log_a + log_b) % (prime - 1) | |
| answer = self._read_u16(exp_offset + answer_log) | |
| return [int(answer)] | |
| def _encode_supported_residue(self, value: str) -> int: | |
| residue = 0 | |
| for char in value.strip(): | |
| if "0" <= char <= "9": | |
| residue = residue * 10 + ord(char) - ord("0") | |
| return residue | |
| def _read_u16(self, entry_offset: int) -> int: | |
| return struct.unpack_from("<H", self._table_bytes, entry_offset * 2)[0] | |