Add Word Error Rate (WER) metric to pythainlp.benchmarks

Co-authored-by: wannaphong <8536487+wannaphong@users.noreply.github.com>

Author: Copilot

CHANGELOG.md

@@ -23,7 +23,7 @@ Added official support and CI testing for Python 3.14.
 Some features and fixes in this version are AI-assisted.
 See PR for prompt and details.
 
-- Add BLEU and ROUGE metrics to pythainlp.benchmarks #<issue_number>
+- Add BLEU, ROUGE, and WER metrics to pythainlp.benchmarks #<issue_number>
 - Fix `royin` romanization #1172
 - Fix final consonant classification in `check_marttra()` #1173
 - Lazy load dictionaries to reduce memory usage #1186

docs/api/benchmarks.rst

@@ -91,6 +91,24 @@ ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is a set of metrics fo
     for rouge_type, (precision, recall, fmeasure) in scores.items():
         print(f"{rouge_type}: P={precision:.4f}, R={recall:.4f}, F={fmeasure:.4f}")
 
+Word Error Rate (WER)
+^^^^^^^^^^^^^^^^^^^^^
+
+Word Error Rate is a common metric for evaluating speech recognition and machine translation systems. It measures the minimum number of word-level edits (insertions, deletions, substitutions) needed to transform the hypothesis into the reference.
+
+.. autofunction:: pythainlp.benchmarks.word_error_rate
+
+**Example:**
+
+.. code-block:: python
+
+    from pythainlp.benchmarks import word_error_rate
+
+    reference = "สวัสดีครับ วันนี้อากาศดีมาก"
+    hypothesis = "สวัสดีค่ะ วันนี้อากาศดี"
+    wer = word_error_rate(reference, hypothesis)
+    print(f"WER: {wer:.4f}")
+
 Usage
 -----
 

pythainlp/benchmarks/__init__.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Performance benchmarking."""
 
-__all__: list[str] = ["benchmark", "bleu_score", "rouge_score"]
+__all__: list[str] = ["benchmark", "bleu_score", "rouge_score", "word_error_rate"]
 
-from pythainlp.benchmarks.metrics import bleu_score, rouge_score
+from pythainlp.benchmarks.metrics import bleu_score, rouge_score, word_error_rate
 from pythainlp.benchmarks.word_tokenization import benchmark

pythainlp/benchmarks/metrics.py

@@ -319,3 +319,80 @@ def rouge_score(
             )
 
     return result
+
+
+def word_error_rate(
+    reference: str,
+    hypothesis: str,
+    tokenize: str = "newmm",
+) -> float:
+    """
+    Calculate Word Error Rate (WER) for Thai text with automatic tokenization.
+
+    Word Error Rate is a common metric for evaluating speech recognition
+    and machine translation systems. It measures the minimum number of
+    word-level edits (insertions, deletions, substitutions) needed to
+    transform the hypothesis into the reference, normalized by the
+    reference length.
+
+    WER = (S + D + I) / N
+
+    where:
+    - S = number of substitutions
+    - D = number of deletions
+    - I = number of insertions
+    - N = number of words in reference
+
+    :param str reference: reference text
+    :param str hypothesis: hypothesis text to evaluate
+    :param str tokenize: tokenization engine to use (default: "newmm").
+        See :func:`pythainlp.tokenize.word_tokenize` for available engines.
+
+    :return: word error rate as a float (0.0 = perfect, >1.0 = very poor)
+    :rtype: float
+
+    :Example:
+    ::
+
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = "สวัสดีครับ วันนี้อากาศดีมาก"
+        hypothesis = "สวัสดีค่ะ วันนี้อากาศดี"
+        wer = word_error_rate(reference, hypothesis)
+        print(f"WER: {wer:.4f}")
+    """
+    from pythainlp.tokenize import word_tokenize
+
+    # Tokenize texts
+    ref_tokens = word_tokenize(reference, engine=tokenize, keep_whitespace=False)
+    hyp_tokens = word_tokenize(hypothesis, engine=tokenize, keep_whitespace=False)
+
+    # Calculate edit distance using dynamic programming
+    r = len(ref_tokens)
+    h = len(hyp_tokens)
+
+    # Create distance matrix
+    d = [[0] * (h + 1) for _ in range(r + 1)]
+
+    # Initialize first row and column
+    for i in range(r + 1):
+        d[i][0] = i
+    for j in range(h + 1):
+        d[0][j] = j
+
+    # Fill in the rest of the matrix
+    for i in range(1, r + 1):
+        for j in range(1, h + 1):
+            if ref_tokens[i - 1] == hyp_tokens[j - 1]:
+                d[i][j] = d[i - 1][j - 1]
+            else:
+                substitution = d[i - 1][j - 1] + 1
+                insertion = d[i][j - 1] + 1
+                deletion = d[i - 1][j] + 1
+                d[i][j] = min(substitution, insertion, deletion)
+
+    # Calculate WER
+    if r == 0:
+        return 0.0 if h == 0 else float('inf')
+
+    return d[r][h] / r

tests/extra/testx_benchmarks.py

@@ -241,3 +241,81 @@ def test_rouge_score_no_overlap(self):
             self.assertGreaterEqual(precision, 0.0)
             self.assertGreaterEqual(recall, 0.0)
             self.assertGreaterEqual(fmeasure, 0.0)
+
+    def test_word_error_rate_basic(self):
+        """Test WER with basic Thai text."""
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = "สวัสดีครับ วันนี้อากาศดีมาก"
+        hypothesis = "สวัสดีค่ะ วันนี้อากาศดี"
+
+        wer = word_error_rate(reference, hypothesis)
+
+        self.assertIsNotNone(wer)
+        self.assertGreaterEqual(wer, 0.0)
+        # WER can be > 1.0 if hypothesis has many insertions
+        self.assertIsInstance(wer, float)
+
+    def test_word_error_rate_perfect_match(self):
+        """Test WER when reference and hypothesis are identical."""
+        from pythainlp.benchmarks import word_error_rate
+
+        text = "สวัสดีครับ วันนี้อากาศดีมาก"
+
+        wer = word_error_rate(text, text)
+
+        # Perfect match should have WER = 0
+        self.assertEqual(wer, 0.0)
+
+    def test_word_error_rate_completely_different(self):
+        """Test WER with completely different text."""
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = "สวัสดีครับ"
+        hypothesis = "ลาก่อนค่ะ"
+
+        wer = word_error_rate(reference, hypothesis)
+
+        # Should be > 0 since texts are different
+        self.assertGreater(wer, 0.0)
+
+    def test_word_error_rate_different_engines(self):
+        """Test WER with different tokenization engines."""
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = "สวัสดีครับ"
+        hypothesis = "สวัสดีค่ะ"
+
+        # Test with newmm (default)
+        wer_newmm = word_error_rate(reference, hypothesis, tokenize="newmm")
+        self.assertIsNotNone(wer_newmm)
+        self.assertGreaterEqual(wer_newmm, 0.0)
+
+        # Test with longest
+        wer_longest = word_error_rate(reference, hypothesis, tokenize="longest")
+        self.assertIsNotNone(wer_longest)
+        self.assertGreaterEqual(wer_longest, 0.0)
+
+    def test_word_error_rate_empty_reference(self):
+        """Test WER with empty reference."""
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = ""
+        hypothesis = "สวัสดีครับ"
+
+        wer = word_error_rate(reference, hypothesis)
+
+        # Empty reference with non-empty hypothesis should return inf or 0
+        self.assertTrue(wer == 0.0 or wer == float('inf'))
+
+    def test_word_error_rate_insertions(self):
+        """Test WER with insertions (hypothesis longer than reference)."""
+        from pythainlp.benchmarks import word_error_rate
+
+        reference = "สวัสดี"
+        hypothesis = "สวัสดี ครับ วันนี้"
+
+        wer = word_error_rate(reference, hypothesis)
+
+        # WER can be > 1.0 due to insertions
+        self.assertGreater(wer, 0.0)