File size: 4,636 Bytes
6637b21
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# 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))