compute-wer 0.1.3__tar.gz

compute_wer-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 彭震东
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

compute_wer-0.1.3/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: compute-wer
+Version: 0.1.3
+Summary: Compute WER
+Author-email: Zhendong Peng <pzd17@tsinghua.org.cn>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pengzhendong/compute-wer
+Project-URL: Documentation, https://github.com/pengzhendong/compute-wer#readme
+Project-URL: BugTracker, https://github.com/pengzhendong/compute-wer/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.7
+Requires-Dist: contractions>=0.1.73
+Requires-Dist: edit-distance>=1.0.6
+Requires-Dist: wetext>=0.0.7
+Dynamic: license-file
+
+# compute-wer
+
+## Installation
+
+```bash
+$ pip install compute-wer
+```
+
+## Usage
+
+```bash
+$ cat ref.txt
+
+/path/to/audio1 莫愁前路无知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ cat hyp.txt
+
+/path/to/audio1 海内存知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ compute-wer ref.txt hyp.txt wer.txt
+```
+
+```bash
+$ compute-wer "莫愁前路无知己" "海内存知己"
+```
+
+## Help
+
+```bash
+$ compute-wer --help
+```

compute_wer-0.1.3/README.md

@@ -0,0 +1,37 @@
+# compute-wer
+
+## Installation
+
+```bash
+$ pip install compute-wer
+```
+
+## Usage
+
+```bash
+$ cat ref.txt
+
+/path/to/audio1 莫愁前路无知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ cat hyp.txt
+
+/path/to/audio1 海内存知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ compute-wer ref.txt hyp.txt wer.txt
+```
+
+```bash
+$ compute-wer "莫愁前路无知己" "海内存知己"
+```
+
+## Help
+
+```bash
+$ compute-wer --help
+```

compute_wer-0.1.3/VERSION

@@ -0,0 +1 @@
+0.1.3

compute_wer-0.1.3/compute_wer/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2023 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from compute_wer.calculator import Calculator
+
+__all__ = ["Calculator"]

compute_wer-0.1.3/compute_wer/calculator.py

@@ -0,0 +1,172 @@
+# Copyright (c) 2025, Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from collections import defaultdict
+
+import contractions
+from edit_distance import DELETE, EQUAL, INSERT, REPLACE, SequenceMatcher
+from wetext import Normalizer
+
+from compute_wer.utils import characterize, default_cluster, strip_tags, width
+
+
+class WER:
+    def __init__(self):
+        self.equal = 0
+        self.replace = 0
+        self.delete = 0
+        self.insert = 0
+
+    def __getitem__(self, key):
+        return self.__dict__[key]
+
+    def __setitem__(self, key, value):
+        self.__dict__[key] = value
+
+    @property
+    def all(self):
+        return self.equal + self.replace + self.delete
+
+    @property
+    def wer(self):
+        if self.all == 0:
+            return 0
+        return (self.replace + self.delete + self.insert) / self.all
+
+    def __str__(self):
+        return f"{self.wer * 100:4.2f} % N={self.all} C={self.equal} S={self.replace} D={self.delete} I={self.insert}"
+
+    @staticmethod
+    def overall(wers):
+        overall = WER()
+        for wer in wers:
+            if wer is None:
+                continue
+            for key in (EQUAL, REPLACE, DELETE, INSERT):
+                overall[key] += wer[key]
+        return overall
+
+
+class SER:
+    def __init__(self):
+        self.cor = 0
+        self.err = 0
+
+    @property
+    def all(self):
+        return self.cor + self.err
+
+    @property
+    def ser(self):
+        return self.err / self.all if self.all != 0 else 0
+
+    def __str__(self):
+        return f"{self.ser * 100:4.2f} % N={self.all} C={self.cor} E={self.err}"
+
+
+class Calculator:
+
+    def __init__(
+        self,
+        tochar: bool = False,
+        case_sensitive: bool = False,
+        remove_tag: bool = False,
+        ignore_words: set = set(),
+        operator: str = None,
+        max_wer: float = sys.maxsize,
+    ):
+        self.tochar = tochar
+        self.case_sensitive = case_sensitive
+        self.remove_tag = remove_tag
+        self.ignore_words = ignore_words
+        self.normalizer = None if operator is None else Normalizer(operator=operator)
+
+        self.clusters = defaultdict(set)
+        self.data = {}
+        self.max_wer = max_wer
+        self.ser = SER()
+
+    def normalize(self, text):
+        """
+        Normalize the input text.
+        Args:
+            text: input text
+        Returns:
+            list of normalized tokens
+        """
+        text = contractions.fix(text)
+        if self.normalizer is not None:
+            text = self.normalizer.normalize(text)
+        tokens = characterize(text, self.tochar)
+        tokens = (strip_tags(token) if self.remove_tag else token for token in tokens)
+        tokens = (token.upper() if not self.case_sensitive else token for token in tokens)
+        return [token for token in tokens if token and token not in self.ignore_words]
+
+    def calculate(self, ref, hyp):
+        """
+        Calculate the WER and align the reference and hypothesis.
+        Args:
+            ref: reference text
+            hyp: hypothesis text
+        Returns:
+            result: result of the WER calculation
+        """
+        ref = self.normalize(ref)
+        hyp = self.normalize(hyp)
+        for token in set(ref + hyp):
+            if token not in self.data:
+                self.data[token] = WER()
+                self.clusters[default_cluster(token)].add(token)
+        opcodes = SequenceMatcher(ref, hyp).get_opcodes()
+
+        result = {"ref": [], "hyp": [], "wer": WER()}
+        for op, i, _, j, _ in opcodes:
+            result["wer"][op] += 1
+            ref_token = ref[i] if op != INSERT else ""
+            hyp_token = hyp[j] if op != DELETE else ""
+            diff = width(hyp_token) - width(ref_token)
+            result["ref"].append(ref_token + " " * diff)
+            result["hyp"].append(hyp_token + " " * -diff)
+
+        self.ser.cor += result["wer"].wer == 0
+        if result["wer"].wer < self.max_wer:
+            for op, i, _, j, _ in opcodes:
+                self.data[ref[i] if op != INSERT else hyp[j]][op] += 1
+            self.ser.err += result["wer"].wer > 0
+        return result
+
+    def cluster(self, data):
+        """
+        Calculate the WER for a cluster.
+        Args:
+            data: list of tokens
+        Returns:
+            WER for the cluster
+        """
+        return WER.overall((self.data.get(token) for token in data))
+
+    def overall(self):
+        """
+        Calculate the overall WER and the WER for each cluster.
+        Returns:
+            overall WER
+            WER for each cluster
+        """
+        cluster_wers = {}
+        for name, cluster in self.clusters.items():
+            wer = self.cluster(cluster)
+            if wer.all > 0:
+                cluster_wers[name] = wer
+        return WER.overall(self.data.values()), cluster_wers

compute_wer-0.1.3/compute_wer/cli.py

@@ -0,0 +1,121 @@
+# Copyright (c) 2025, Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import codecs
+import logging
+import os
+import sys
+
+import click
+
+from compute_wer.calculator import Calculator
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+
+@click.command(help="Compute Word Error Rate (WER) and align recognition results with references.")
+@click.argument("ref")
+@click.argument("hyp")
+@click.argument("output-file", type=click.Path(dir_okay=False), required=False)
+@click.option("--align-to-ref", is_flag=True, help="If set, align to reference (default: align to hypothesis)")
+@click.option("--char", "-c", is_flag=True, help="Use character-level WER instead of word-level WER.")
+@click.option("--sort", "-s", is_flag=True, help="Sort the hypotheses by WER in ascending order.")
+@click.option("--case-sensitive", "-cs", is_flag=True, help="Use case-sensitive matching.")
+@click.option("--remove-tag", "-rt", is_flag=True, default=True, help="Remove tags from the reference and hypothesis.")
+@click.option("--ignore-file", "-ig", type=click.Path(exists=True, dir_okay=False), help="Path to the ignore file.")
+@click.option("--operator", "-o", type=click.Choice(["tn", "itn"], case_sensitive=False), help="Normalizer operator.")
+@click.option("--verbose", "-v", is_flag=True, default=True, help="Print verbose output.")
+@click.option("--max-wer", "-mw", type=float, default=sys.maxsize, help="Filter hypotheses with WER <= this value.")
+def main(
+    ref, hyp, output_file, align_to_ref, char, sort, case_sensitive, remove_tag, ignore_file, operator, verbose, max_wer
+):
+    input_is_file = False
+    if os.path.exists(ref):
+        assert os.path.exists(hyp)
+        input_is_file = True
+
+    ignore_words = set()
+    if ignore_file is not None:
+        for line in codecs.open(ignore_file, encoding="utf-8"):
+            word = line.strip()
+            if len(word) > 0:
+                ignore_words.add(word if case_sensitive else word.upper())
+    calculator = Calculator(char, case_sensitive, remove_tag, ignore_words, operator, max_wer)
+
+    if input_is_file:
+        hyp_set = {}
+        for line in codecs.open(hyp, encoding="utf-8"):
+            array = line.strip().split(maxsplit=1)
+            if len(array) == 0:
+                continue
+            utt, hyp = array[0], array[1] if len(array) > 1 else ""
+            if utt in hyp_set:
+                if hyp != hyp_set[utt]:
+                    raise ValueError(f"Conflicting hypotheses found:\n{utt}\t{hyp}\n{utt}\t{hyp_set[utt]}")
+                logging.warning("Skip duplicate hypothesis: %s\t%s", utt, hyp)
+            hyp_set[utt] = hyp
+
+    results = []
+    if input_is_file:
+        ref_set = {}
+        for line in codecs.open(ref, encoding="utf-8"):
+            array = line.strip().split(maxsplit=1)
+            if len(array) == 0:
+                continue
+            utt, ref = array[0], array[1] if len(array) > 1 else ""
+            if utt in ref_set:
+                if ref != ref_set[utt]:
+                    raise ValueError(f"Conflicting references found:\n{utt}\t{ref}\n{utt}\t{ref_set[utt]}")
+                logging.warning("Skip duplicate reference: %s\t%s", utt, ref)
+            ref_set[utt] = ref
+            if not (utt in hyp_set or align_to_ref):
+                hyp_set[utt] = ""
+                logging.warning("No hypothesis found for %s, use empty string as hypothesis.", utt)
+            else:
+                continue
+            result = calculator.calculate(ref, hyp_set[utt])
+            if result["wer"].wer < max_wer:
+                results.append((utt, result))
+    else:
+        results.append((None, calculator.calculate(ref, hyp)))
+
+    fout = sys.stdout
+    if output_file is None:
+        fout.write("\n")
+    else:
+        fout = codecs.open(output_file, "w", encoding="utf-8")
+
+    if verbose:
+        if sort:
+            results = sorted(results, key=lambda x: x[1]["wer"].wer)
+        for utt, result in results:
+            if utt is not None:
+                fout.write(f"utt: {utt}\n")
+            fout.write(f"WER: {result['wer']}\n")
+            for key in ("ref", "hyp"):
+                fout.write(f"{key}: {' '.join(result[key])}\n")
+            fout.write("\n")
+    fout.write("===========================================================================\n")
+    wer, cluster_wers = calculator.overall()
+    fout.write(f"Overall -> {wer}\n")
+    for cluster, wer in cluster_wers.items():
+        fout.write(f"{cluster} -> {wer}\n")
+    if input_is_file:
+        fout.write(f"SER -> {calculator.ser}\n")
+    fout.write("===========================================================================\n")
+    fout.close()
+
+
+if __name__ == "__main__":
+    main()

compute_wer-0.1.3/compute_wer/utils.py

@@ -0,0 +1,141 @@
+# Copyright (c) 2025, Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unicodedata
+from unicodedata import category, east_asian_width
+
+spacelist = [" ", "\t", "\r", "\n"]
+puncts = ["!", ",", ".", "?", "-", "、", "。", "！", "，", "；", "？", "：", "「", "」", "︰", "『", "』", "《", "》"]
+
+
+def characterize(text, tochar):
+    """
+    Characterize the text.
+    Args:
+        text: text to characterize
+        tochar: whether to characterize to character
+    Returns:
+        list of characterized tokens
+    """
+    res = []
+    i = 0
+    length = len(text)
+    while i < length:
+        char = text[i]
+        if char in puncts or char in spacelist:
+            i += 1
+            continue
+        cat = category(char)
+        # https://unicodebook.readthedocs.io/unicode.html#unicode-categories
+        if cat in {"Zs", "Cn"}:  # space or not assigned
+            i += 1
+        elif cat == "Lo":  # Letter-other (Chinese letter)
+            res.append(char)
+            i += 1
+        elif tochar and cat.startswith(("L", "N")):
+            res.append(char)
+            i += 1
+        else:
+            # some input looks like: <unk><noise>, we want to separate it to two words.
+            sep = ">" if char == "<" else " "
+            j = i + 1
+            while j < length:
+                c = text[j]
+                if ord(c) >= 128 or c in spacelist or c == sep:
+                    break
+                j += 1
+            if j < length and text[j] == ">":
+                j += 1
+            res.append(text[i:j])
+            i = j
+    return res
+
+
+def default_cluster(word):
+    """
+    Get the default cluster of a word.
+    Args:
+        word: word to get the default cluster
+    Returns:
+        default cluster
+    """
+    replacements = {
+        "DIGIT": "Number",
+        "CJK UNIFIED IDEOGRAPH": "Chinese",
+        "CJK COMPATIBILITY IDEOGRAPH": "Chinese",
+        "LATIN CAPITAL LETTER": "English",
+        "LATIN SMALL LETTER": "English",
+        "HIRAGANA LETTER": "Japanese",
+    }
+    ignored_prefixes = (
+        "AMPERSAND",
+        "APOSTROPHE",
+        "COMMERCIAL AT",
+        "DEGREE CELSIUS",
+        "EQUALS SIGN",
+        "FULL STOP",
+        "HYPHEN-MINUS",
+        "LOW LINE",
+        "NUMBER SIGN",
+        "PLUS SIGN",
+        "SEMICOLON",
+    )
+    clusters = set()
+    for name in [unicodedata.name(char) for char in word]:
+        if any(name.startswith(prefix) for prefix in ignored_prefixes):
+            continue
+        cluster = "Other"
+        for key, value in replacements.items():
+            if name.startswith(key):
+                cluster = value
+                break
+        clusters.add(cluster or "Other")
+    return clusters.pop() if len(clusters) == 1 else "Other"
+
+
+def strip_tags(token):
+    """
+    Strip the tags from the token.
+    Args:
+        token: token to strip the tags
+    Returns:
+        token without tags
+    """
+    if not token:
+        return ""
+    chars = []
+    i = 0
+    while i < len(token):
+        if token[i] == "<":
+            end = token.find(">", i) + 1
+            if end == 0:
+                chars.append(token[i])
+                i += 1
+            else:
+                i = end
+        else:
+            chars.append(token[i])
+            i += 1
+    return "".join(chars)
+
+
+def width(str):
+    """
+    Get the width of a string.
+    Args:
+        str: string to get the width
+    Returns:
+        width of the string
+    """
+    return sum(1 + (east_asian_width(char) in "AFW") for char in str)

compute_wer-0.1.3/compute_wer.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: compute-wer
+Version: 0.1.3
+Summary: Compute WER
+Author-email: Zhendong Peng <pzd17@tsinghua.org.cn>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pengzhendong/compute-wer
+Project-URL: Documentation, https://github.com/pengzhendong/compute-wer#readme
+Project-URL: BugTracker, https://github.com/pengzhendong/compute-wer/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.7
+Requires-Dist: contractions>=0.1.73
+Requires-Dist: edit-distance>=1.0.6
+Requires-Dist: wetext>=0.0.7
+Dynamic: license-file
+
+# compute-wer
+
+## Installation
+
+```bash
+$ pip install compute-wer
+```
+
+## Usage
+
+```bash
+$ cat ref.txt
+
+/path/to/audio1 莫愁前路无知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ cat hyp.txt
+
+/path/to/audio1 海内存知己
+/path/to/audio2 天下谁人不识君
+```
+
+```bash
+$ compute-wer ref.txt hyp.txt wer.txt
+```
+
+```bash
+$ compute-wer "莫愁前路无知己" "海内存知己"
+```
+
+## Help
+
+```bash
+$ compute-wer --help
+```

compute_wer-0.1.3/compute_wer.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+VERSION
+pyproject.toml
+compute_wer/__init__.py
+compute_wer/calculator.py
+compute_wer/cli.py
+compute_wer/utils.py
+compute_wer.egg-info/PKG-INFO
+compute_wer.egg-info/SOURCES.txt
+compute_wer.egg-info/dependency_links.txt
+compute_wer.egg-info/entry_points.txt
+compute_wer.egg-info/requires.txt
+compute_wer.egg-info/top_level.txt

compute_wer-0.1.3/compute_wer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

compute_wer-0.1.3/compute_wer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+compute-wer = compute_wer.cli:main

compute_wer-0.1.3/compute_wer.egg-info/requires.txt

@@ -0,0 +1,4 @@
+click>=8.1.7
+contractions>=0.1.73
+edit-distance>=1.0.6
+wetext>=0.0.7

compute_wer-0.1.3/compute_wer.egg-info/top_level.txt

@@ -0,0 +1 @@
+compute_wer

compute_wer-0.1.3/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "compute-wer"
+authors = [{ name = "Zhendong Peng", email = "pzd17@tsinghua.org.cn" }]
+description = "Compute WER"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dynamic = ["version"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "click>=8.1.7",
+    "contractions>=0.1.73",
+    "edit-distance>=1.0.6",
+    "wetext>=0.0.7",
+]
+
+[project.scripts]
+compute-wer = "compute_wer.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/pengzhendong/compute-wer"
+Documentation = "https://github.com/pengzhendong/compute-wer#readme"
+BugTracker = "https://github.com/pengzhendong/compute-wer/issues"
+
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }

compute_wer-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+