# 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))