shield-small / classify.py
LucasValbuena's picture
Release Shield Small S15e int8 ONNX weights and inference example
6637b21 verified
Raw History Blame Contribute Delete
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))