add nltk

app.py

@@ -1,7 +1,11 @@
 import jiwer
-import spaces
 import numpy as np
 import gradio as gr
+import nltk
+from nltk.tokenize import sent_tokenize
+
+# Ensure NLTK data is downloaded
+nltk.download('punkt')
 
 @spaces.GPU()
 def calculate_wer(reference, hypothesis):
@@ -24,33 +28,55 @@ def calculate_sentence_wer(reference, hypothesis):
     """
     Calculate WER for each sentence and overall statistics.
     """
-    reference_sentences = reference.split()
-    hypothesis_sentences = hypothesis.split()
+    try:
+        reference_sentences = sent_tokenize(reference)
+        hypothesis_sentences = sent_tokenize(hypothesis)
+
+        # Get minimum number of sentences
+        min_sentences = min(len(reference_sentences), len(hypothesis_sentences))
+
+        # Trim to the same number of sentences
+        reference_sentences = reference_sentences[:min_sentences]
+        hypothesis_sentences = hypothesis_sentences[:min_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,
+                "warning": "No sentences to compare"
+            }
 
-    if len(reference_sentences) != len(hypothesis_sentences):
-        raise ValueError("Reference and hypothesis must contain the same number of sentences")
+        average_wer = np.mean(sentence_wers)
+        std_dev = np.std(sentence_wers)
 
-    sentence_wers = []
-    for ref, hyp in zip(reference_sentences, hypothesis_sentences):
-        sentence_wer = jiwer.wer(ref, hyp)
-        sentence_wers.append(sentence_wer)
+        # Check if there were extra sentences
+        if len(reference_sentences) != len(hypothesis_sentences):
+            warning = f"Reference has {len(reference_sentences)} sentences, " \
+                      f"hypothesis has {len(hypothesis_sentences)} sentences. " \
+                      f"Only compared the first {min_sentences} sentences."
+        else:
+            warning = None
 
-    if not sentence_wers:
+        return {
+            "sentence_wers": sentence_wers,
+            "average_wer": average_wer,
+            "std_dev": std_dev,
+            "warning": warning
+        }
+    except Exception as e:
         return {
             "sentence_wers": [],
             "average_wer": 0.0,
-            "std_dev": 0.0
+            "std_dev": 0.0,
+            "error": str(e)
         }
 
-    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):
     try:
@@ -60,6 +86,11 @@ def process_files(reference_file, hypothesis_file):
         with open(hypothesis_file.name, 'r') as f:
             hypothesis_text = f.read()
 
+        if not reference_text or not hypothesis_text:
+            return {
+                "error": "Both reference and hypothesis files must contain text"
+            }
+
         wer_value = calculate_wer(reference_text, hypothesis_text)
         cer_value = calculate_cer(reference_text, hypothesis_text)
         sentence_wer_stats = calculate_sentence_wer(reference_text, hypothesis_text)
@@ -69,21 +100,39 @@ def process_files(reference_file, hypothesis_file):
             "CER": cer_value,
             "Sentence WERs": sentence_wer_stats["sentence_wers"],
             "Average WER": sentence_wer_stats["average_wer"],
-            "Standard Deviation": sentence_wer_stats["std_dev"]
+            "Standard Deviation": sentence_wer_stats["std_dev"],
+            "Warning": sentence_wer_stats.get("warning"),
+            "Error": sentence_wer_stats.get("error")
         }
     except Exception as e:
-        return {"error": str(e)}
+        return {
+            "WER": 0.0,
+            "CER": 0.0,
+            "Sentence WERs": [],
+            "Average WER": 0.0,
+            "Standard Deviation": 0.0,
+            "Error": str(e)
+        }
+
+def format_sentence_wer_stats(sentence_wers, average_wer, std_dev, warning, error):
+    md = ""
+
+    if error:
+        md += f"### Error\n{error}\n\n"
+    elif warning:
+        md += f"### Warning\n{warning}\n\n"
 
-def format_sentence_wer_stats(sentence_wers, average_wer, std_dev):
     if not sentence_wers:
-        return "All sentences match perfectly!"
+        md += "No sentences to compare"
+        return md
 
-    md = "### Sentence-level WER Analysis\n\n"
+    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():
@@ -130,18 +179,24 @@ def main():
 
         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"]
             }
 
+            error = result.get("Error")
+            warning = result.get("Warning")
+            sentence_wers = result.get("Sentence WERs", [])
+            average_wer = result.get("Average WER", 0.0)
+            std_dev = result.get("Standard Deviation", 0.0)
+
             wer_stats_md = format_sentence_wer_stats(
-                result["Sentence WERs"],
-                result["Average WER"],
-                result["Standard Deviation"]
+                sentence_wers,
+                average_wer,
+                std_dev,
+                warning,
+                error
             )
 
             return metrics, wer_stats_md