swmpo.predicates

  1"""Simple transformation of sk-learn decision trees to predicates."""
  2from dataclasses import dataclass
  3from typing import Any
  4import jsonpickle
  5
  6
  7@dataclass
  8class And:
  9    left: "Predicate"
 10    right: "Predicate"
 11
 12
 13@dataclass
 14class Or:
 15    left: "Predicate"
 16    right: "Predicate"
 17
 18
 19@dataclass
 20class LessThan:
 21    left: "Value"
 22    right: "Value"
 23
 24
 25@dataclass
 26class GreaterThan:
 27    left: "Value"
 28    right: "Value"
 29
 30
 31@dataclass
 32class Feature:
 33    index: int
 34
 35
 36Value = (
 37    Feature |
 38    float
 39)
 40
 41
 42Predicate = (
 43    And |
 44    Or |
 45    LessThan |
 46    GreaterThan |
 47    bool
 48)
 49
 50
 51def predicate_to_str(predicate: Predicate) -> str:
 52    """Serialize predicate as a string."""
 53    return jsonpickle.encode(
 54        predicate,
 55        make_refs=False,
 56        indent=2,
 57    )
 58
 59
 60def type_check_value(obj: Any) -> bool:
 61    allowed_classes = (
 62        Feature,
 63        float,
 64    )
 65    if not isinstance(obj, allowed_classes):
 66        return False
 67
 68    if isinstance(obj, float):
 69        return True
 70
 71    # obj is Feature
 72    if not isinstance(obj.index, int):
 73        return False
 74
 75    return True
 76
 77
 78def type_check_predicate(obj: Any) -> bool:
 79    allowed_classes = (
 80        And,
 81        Or,
 82        LessThan,
 83        GreaterThan,
 84        bool,
 85    )
 86    if not isinstance(obj, allowed_classes):
 87        return False
 88
 89    if isinstance(obj, bool):
 90        return True
 91
 92    if isinstance(obj, (And, Or)):
 93        if not type_check_predicate(obj.left):
 94            return False
 95        if not type_check_predicate(obj.right):
 96            return False
 97        return True
 98
 99    # Obj is LessThan or GreaterThan
100    if not type_check_value(obj.left):
101        return False
102    if not type_check_value(obj.right):
103        return False
104    return True
105
106
107def str_to_predicate(predicate: str) -> Predicate:
108    """Deserialize predicate from a string."""
109    obj = jsonpickle.decode(
110        predicate,
111        on_missing="error",
112    )
113    assert type_check_predicate(obj)
114    return obj
115
116
117def get_value(
118    value: Value,
119    x: list[float],
120) -> float:
121    if isinstance(value, float):
122        return value
123    elif isinstance(value, Feature):
124        return x[value.index]
125    else:
126        raise ValueError(
127            f"Input of type '{type(value)}' not a predicate value!"
128        )
129
130
131def get_robustness_value(
132    predicate: Predicate,
133    x: list[float],
134) -> float:
135    """Get the robustness value of the predicate evaluated on the given
136    input.
137
138    A predicate is said to be True for a given input if and only if
139    the corresponding robustness value is greater than zero.
140    """
141    if isinstance(predicate, bool):
142        if predicate:
143            return 1.0
144        else:
145            return -1.0
146    elif isinstance(predicate, And):
147        lv = get_robustness_value(predicate.left, x)
148        rv = get_robustness_value(predicate.right, x)
149        return min(lv, rv)
150    elif isinstance(predicate, Or):
151        lv = get_robustness_value(predicate.left, x)
152        rv = get_robustness_value(predicate.right, x)
153        return max(lv, rv)
154    elif isinstance(predicate, LessThan):
155        lv = get_value(predicate.left, x)
156        rv = get_value(predicate.right, x)
157        return rv - lv
158    elif isinstance(predicate, GreaterThan):
159        lv = get_value(predicate.left, x)
160        rv = get_value(predicate.right, x)
161        return lv - rv
162    else:
163        raise ValueError(f"Predicate of invalid type '{type(predicate)}'!")
164
165
166def get_pretty_str(predicate: Predicate) -> str:
167    def add_indent(s: str) -> str:
168        lines = s.splitlines()
169        lines = [f"\t{li}" for li in lines]
170        return "\n".join(lines)
171
172    def pretty_value(s: Value) -> str:
173        if isinstance(s, (float, int)):
174            return str(s)
175        else:
176            return f"x[{s.index}]"
177
178    def recurse(predicate: Predicate) -> str:
179        if isinstance(predicate, bool):
180            if predicate:
181                return "True"
182            else:
183                return "False"
184        elif isinstance(predicate, And):
185            ls = recurse(predicate.left)
186            rs = recurse(predicate.right)
187            ls = add_indent(ls)
188            rs = add_indent(rs)
189            ls = f"(\n{ls}\n)"
190            rs = f"(\n{rs}\n)"
191            return f"{ls}\nAND\n{rs}"
192        elif isinstance(predicate, Or):
193            ls = recurse(predicate.left)
194            rs = recurse(predicate.right)
195            ls = add_indent(ls)
196            rs = add_indent(rs)
197            ls = f"(\n{ls}\n)"
198            rs = f"(\n{rs}\n)"
199            return f"{ls}\nOR\n{rs}"
200        elif isinstance(predicate, LessThan):
201            ls = pretty_value(predicate.left)
202            rs = pretty_value(predicate.right)
203            return f"{ls} < {rs}"
204        elif isinstance(predicate, GreaterThan):
205            ls = pretty_value(predicate.left)
206            rs = pretty_value(predicate.right)
207            return f"{ls} > {rs}"
208        else:
209            raise ValueError(f"Predicate of invalid type '{type(predicate)}'!")
210
211    return recurse(predicate)