Download classify.py from ZeroLeaks/shield-small: direct link, hf CLI and curl.
- Browser
- Download file 4.64 kB
-
https://huggingface.co/ZeroLeaks/shield-small/resolve/main/classify.py
- Command line
-
hf download hf://ZeroLeaks/shield-small/classify.py
-
curl -L -o classify.py https://huggingface.co/ZeroLeaks/shield-small/resolve/main/classify.py
4.64 kB
| # SPDX-License-Identifier: MIT | |
| """Run Shield Small locally with ONNX Runtime. Model weights: CC BY-NC 4.0.""" | |
| import argparse | |
| import json | |
| import math | |
| from pathlib import Path | |
| import numpy as np | |
| import onnxruntime as ort | |
| from tokenizers import Tokenizer | |
| class ShieldSmall: | |
| def __init__(self, model_dir: str | Path = Path(__file__).parent) -> None: | |
| model_dir = Path(model_dir) | |
| self.tokenizer = Tokenizer.from_file(str(model_dir / "tokenizer.json")) | |
| self.tokenizer.no_padding() | |
| self.tokenizer.no_truncation() | |
| plain = self.tokenizer.encode("a", add_special_tokens=False).ids | |
| wrapped = self.tokenizer.encode("a").ids | |
| index = next( | |
| i for i in range(len(wrapped)) if wrapped[i : i + len(plain)] == plain | |
| ) | |
| self.head = wrapped[:index] | |
| self.tail = wrapped[index + len(plain) :] | |
| self.body_size = 256 - len(self.head) - len(self.tail) | |
| tokenizer_config = json.loads((model_dir / "tokenizer_config.json").read_text()) | |
| pad_token = tokenizer_config["pad_token"] | |
| if isinstance(pad_token, dict): | |
| pad_token = pad_token["content"] | |
| self.pad_id = self.tokenizer.token_to_id(pad_token) | |
| if self.pad_id is None: | |
| raise ValueError("Tokenizer has no padding token.") | |
| config = json.loads((model_dir / "config.json").read_text()) | |
| if config["id2label"] != {"0": "BENIGN", "1": "INJECTION"}: | |
| raise ValueError("Expected the Shield Small binary classifier.") | |
| options = ort.SessionOptions() | |
| options.intra_op_num_threads = 2 | |
| options.inter_op_num_threads = 1 | |
| self.session = ort.InferenceSession( | |
| str(model_dir / "onnx" / "model_quantized.onnx"), | |
| options, | |
| providers=["CPUExecutionProvider"], | |
| ) | |
| def classify(self, text: str, threshold: float = 0.5) -> dict[str, object]: | |
| if not isinstance(text, str) or not text.strip(): | |
| raise ValueError("Pass nonempty text to classify.") | |
| if not math.isfinite(threshold) or not 0 <= threshold <= 1: | |
| raise ValueError("Threshold must be between 0 and 1.") | |
| ids = self.tokenizer.encode(text, add_special_tokens=False).ids | |
| room = 192 * 31 + self.body_size | |
| truncated = len(ids) > room | |
| if len(ids) <= self.body_size: | |
| bodies = [ids] | |
| elif not truncated: | |
| bodies = [ | |
| ids[start : start + self.body_size] | |
| for start in range(0, min(len(ids), 192 * 32), 192) | |
| ] | |
| else: | |
| bodies = [ | |
| ids[start : start + self.body_size] for start in range(0, 192 * 28, 192) | |
| ] | |
| for offset in (3, 2, 1, 0): | |
| end = len(ids) - offset * 192 | |
| bodies.append(ids[end - self.body_size : end]) | |
| best = 0.0 | |
| for start in range(0, len(bodies), 8): | |
| rows = [self.head + body + self.tail for body in bodies[start : start + 8]] | |
| width = max(map(len, rows)) | |
| values = np.array( | |
| [row + [self.pad_id] * (width - len(row)) for row in rows], | |
| dtype=np.int64, | |
| ) | |
| mask = np.array( | |
| [[1] * len(row) + [0] * (width - len(row)) for row in rows], | |
| dtype=np.int64, | |
| ) | |
| logits = self.session.run( | |
| ["logits"], {"input_ids": values, "attention_mask": mask} | |
| )[0].astype(np.float64) | |
| if logits.shape != (len(rows), 2) or not np.isfinite(logits).all(): | |
| raise ValueError("Model returned invalid logits.") | |
| probabilities = np.exp(logits - logits.max(axis=1, keepdims=True)) | |
| probabilities /= probabilities.sum(axis=1, keepdims=True) | |
| best = max(best, float(probabilities[:, 1].max())) | |
| return { | |
| "label": "INJECTION" if best >= threshold else "BENIGN", | |
| "score": best, | |
| "flagged": best >= threshold, | |
| "input_tokens": len(ids), | |
| "coverage": { | |
| "windows": len(bodies), | |
| "max_windows": 32, | |
| "truncated": truncated, | |
| }, | |
| } | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("text") | |
| parser.add_argument("--model-dir", type=Path, default=Path(__file__).parent) | |
| parser.add_argument("--threshold", type=float, default=0.5) | |
| args = parser.parse_args() | |
| model = ShieldSmall(args.model_dir) | |
| print(json.dumps(model.classify(args.text, args.threshold), indent=2)) | |