All/Python/OCSVM/m2c/m2c.py

import re


class Model:
    def __init__(self, features: "int"):
        assert features > 0, f"features = {self._kv['gama']} should bigger than zero."

        self._kv: "dict" = {
            "size": 0, "bias": 0, "gama": 0, "feat": features,
            "scales": [], "elements": [], "weights": []
        }
        self._m = {}

    def __dict__(self):
        return self._kv

    def __getitem__(self, key: "str"):
        return getattr(self._kv, key, None)

    def _v2s(self) -> "None":
        assert self._kv["size"] > 0, f"total_sv = {self._kv['size']} should bigger than zero."
        assert self._kv["bias"] > 0, f"rho = {self._kv['bias']} should bigger than zero."
        assert self._kv["gama"] > 0, f"gamma = {self._kv['gama']} should bigger than zero."
        assert len(self._kv["scales"]) == self._kv["size"], \
            f"scales_count={len(self._kv['scales'])} should equal to total_sv={self._kv['size']}."
        assert len(self._kv["elements"]) > 0, f"weights count = {self._kv['elements']} should bigger than zero."
        assert sum(self._kv["elements"]) == len(self._kv["weights"]), \
            f"ele_sum={sum(self._kv['elements'])} should equal to weights_count={len(self._kv['weights'])}"

        self._m["@{size}"] = f"{self._kv['size']}"
        self._m["@{feat}"] = f"{self._kv['feat']}"
        self._m["@{bias}"] = f"{self._kv['bias']}f"
        self._m["@{gama}"] = f"{self._kv['gama']}f"

        self._m["@{scales}"] = f"{self._kv['scales'][0]}f"
        for num in self._kv["scales"]:
            self._m["@{scales}"] += f",{num}f"

        self._m["@{elements}"] = f"{self._kv['elements'][0]}"
        for num in self._kv["elements"]:
            self._m["@{elements}"] += f",{num}"

        self._m["@{weights}"] = f"{self._kv['weights'][0]}f"
        for num in self._kv["weights"]:
            self._m["@{weights}"] += f",{num}f"

    def load(self, path: "str" = "test.model") -> "Model":
        with open(path) as fp:
            lines = fp.read().strip().split("\n")
            assert lines[0] == "svm_type one_class", "svm_type first line and one class svm only"
            assert lines[1] == "kernel_type rbf", "kernel_type second line and rbf only"
            self._kv["gama"] = float(lines[2][6:])
            self._kv["size"] = int(lines[4][9:])
            self._kv["bias"] = float(lines[5][4:])

            for ws in lines[7:]:
                nums = ws.strip().split(" ")
                self._kv["scales"].append(float(nums[0]))
                self._kv["elements"].append(len(nums) - 1)
                self._kv["weights"] += [float(one.split(":")[1]) for one in nums[1:]]

        self._v2s()
        return self

    def toc(self, file: "str" = "svm.c") -> "None":
        newLines = []
        with open("./svm.c.t") as fp:
            lines = fp.readlines()
            pattern = re.compile(r"@{\w+}")
            for line in lines:
                keys = pattern.findall(line)
                for key in keys:
                    if key in self._m:
                        line = line.replace(key, self._m[key])
                    else:
                        print(f"\"{key}\" not in model map")
                newLines.append(line)
        with open(file, "wt") as tp:
            tp.writelines(newLines)

        print(f"file written to {file}")


if __name__ == "__main__":
    model = Model(23)
    model.load("real.model").toc()