add wer fn

app.py

@@ -1,78 +1,55 @@
+import jiwer
 import spaces
-import gradio as gr
 import numpy as np
+import gradio as gr
 
 @spaces.GPU()
-def get_mismatched_sentences(reference, hypothesis):
+def calculate_wer(reference, hypothesis):
     """
-    Get mismatched sentences between reference and hypothesis.
+    Calculate the Word Error Rate (WER) using jiwer.
     """
-    reference = reference.split()
-    hypothesis = hypothesis.split()
-    
-    mismatched = []
-    for ref, hyp in zip(reference, hypothesis):
-        if ref != hyp:
-            mismatched.append((ref, hyp))
-
-    return mismatched
-
-@spaces.GPU()
-def calculate_wer(reference, hypothesis):
-    reference_words = reference.split()
-    hypothesis_words = hypothesis.split()
-
-    m = len(reference_words)
-    n = len(hypothesis_words)
-
-    # Initialize DP table
-    dp = np.zeros((m+1, n+1), dtype=np.int32)
-
-    # Base cases
-    for i in range(m+1):
-        dp[i][0] = i
-    for j in range(n+1):
-        dp[0][j] = j
-
-    # Fill DP table
-    for i in range(1, m+1):
-        for j in range(1, n+1):
-            cost = 0 if reference_words[i-1] == hypothesis_words[j-1] else 1
-            dp[i][j] = min(dp[i-1][j] + 1,      # Deletion
-                           dp[i][j-1] + 1,      # Insertion
-                           dp[i-1][j-1] + cost) # Substitution or no cost
-
-    wer = dp[m][n] / m
+    wer = jiwer.wer(reference, hypothesis)
     return wer
 
 @spaces.GPU()
 def calculate_cer(reference, hypothesis):
-    reference = reference.replace(" ", "")
-    hypothesis = hypothesis.replace(" ", "")
-
-    m = len(reference)
-    n = len(hypothesis)
-
-    # Initialize DP table
-    dp = np.zeros((m+1, n+1), dtype=np.int32)
-
-    # Base cases
-    for i in range(m+1):
-        dp[i][0] = i
-    for j in range(n+1):
-        dp[0][j] = j
-
-    # Fill DP table
-    for i in range(1, m+1):
-        for j in range(1, n+1):
-            cost = 0 if reference[i-1] == hypothesis[j-1] else 1
-            dp[i][j] = min(dp[i-1][j] + 1,      # Deletion
-                           dp[i][j-1] + 1,      # Insertion
-                           dp[i-1][j-1] + cost) # Substitution or no cost
-
-    cer = dp[m][n] / m
+    """
+    Calculate the Character Error Rate (CER) using jiwer.
+    """
+    cer = jiwer.cer(reference, hypothesis)
     return cer
 
+@spaces.GPU()
+def calculate_sentence_wer(reference, hypothesis):
+    """
+    Calculate WER for each sentence and overall statistics.
+    """
+    reference_sentences = jiwer.split_into_sentences(reference)
+    hypothesis_sentences = jiwer.split_into_sentences(hypothesis)
+
+    if len(reference_sentences) != len(hypothesis_sentences):
+        raise ValueError("Reference and hypothesis must contain the same number of sentences")
+
+    sentence_wers = []
+    for ref, hyp in zip(reference_sentences, hypothesis_sentences):
+        sentence_wer = jiwer.wer(ref, hyp)
+        sentence_wers.append(sentence_wer)
+
+    if not sentence_wers:
+        return {
+            "sentence_wers": [],
+            "average_wer": 0.0,
+            "std_dev": 0.0
+        }
+
+    average_wer = np.mean(sentence_wers)
+    std_dev = np.std(sentence_wers)
+
+    return {
+        "sentence_wers": sentence_wers,
+        "average_wer": average_wer,
+        "std_dev": std_dev
+    }
 
 @spaces.GPU()
 def process_files(reference_file, hypothesis_file):
@@ -85,16 +62,30 @@ def process_files(reference_file, hypothesis_file):
 
         wer_value = calculate_wer(reference_text, hypothesis_text)
         cer_value = calculate_cer(reference_text, hypothesis_text)
-        mismatched_sentences = get_mismatched_sentences(reference_text, hypothesis_text)
+        sentence_wer_stats = calculate_sentence_wer(reference_text, hypothesis_text)
 
         return {
             "WER": wer_value,
             "CER": cer_value,
-            "Mismatched Sentences": mismatched_sentences
+            "Sentence WERs": sentence_wer_stats["sentence_wers"],
+            "Average WER": sentence_wer_stats["average_wer"],
+            "Standard Deviation": sentence_wer_stats["std_dev"]
         }
     except Exception as e:
         return {"error": str(e)}
 
+def format_sentence_wer_stats(sentence_wers, average_wer, std_dev):
+    if not sentence_wers:
+        return "All sentences match perfectly!"
+
+    md = "### Sentence-level WER Analysis\n\n"
+    md += f"* Average WER: {average_wer:.2f}\n"
+    md += f"* Standard Deviation: {std_dev:.2f}\n\n"
+    md += "### WER for Each Sentence\n\n"
+    for i, wer in enumerate(sentence_wers):
+        md += f"* Sentence {i+1}: {wer:.2f}\n"
+    return md
+
 def main():
     with gr.Blocks() as demo:
         gr.Markdown("# ASR Metrics Calculator")
@@ -110,6 +101,7 @@ def main():
         with gr.Row():
             compute_button = gr.Button("Compute Metrics")
             results_output = gr.JSON(label="Results")
+            wer_stats_output = gr.Markdown(label="WER Statistics")
 
         # Update previews when files are uploaded
         def update_previews(ref_file, hyp_file):
@@ -136,10 +128,28 @@ def main():
             outputs=[reference_preview, hypothesis_preview]
         )
 
+        def process_and_display(ref_file, hyp_file):
+            result = process_files(ref_file, hyp_file)
+            if "error" in result:
+                return {}, {}, "Error: " + result["error"]
+
+            metrics = {
+                "WER": result["WER"],
+                "CER": result["CER"]
+            }
+
+            wer_stats_md = format_sentence_wer_stats(
+                result["Sentence WERs"],
+                result["Average WER"],
+                result["Standard Deviation"]
+            )
+
+            return metrics, wer_stats_md
+
         compute_button.click(
-            fn=process_files,
+            fn=process_and_display,
             inputs=[reference_file, hypothesis_file],
-            outputs=results_output
+            outputs=[results_output, wer_stats_output]
         )
 
     demo.launch()