Add in option to ignore punctuation and case

For many applications, it may be useful to ignore the punctuation and/or case when evaluating word error rate. This PR adds checkboxes to ignore punctuation and case, and then applies the relevant transforms to the ground truth and hypothesis text.


I contemplated using jiwer's off the shelf transformations as defined here - https://jitsi.github.io/jiwer/reference/transformations/, which can directly be passed into the `process_words` function. However, this didn't have the option to remove punctuation.

Additionally, I also add typing to the python file and format the file.

app.py

@@ -1,38 +1,75 @@
+import typing as T
 import gradio as gr
-from jiwer import wer, process_words
+from jiwer import process_words, RemovePunctuation, ToLowerCase, Compose
 
-def make_string(words):
+
+def make_string(words: T.List[str]) -> str:
+    """Converts list of strings to a string"""
     return " ".join(words)
 
-# Function to highlight errors
-def highlight_errors(ground_truth, hypothesis):
+
+def highlight_errors(
+    ground_truth: str,
+    hypothesis: str,
+    remove_punctuation: bool,
+    to_lower_case: bool,
+) -> T.Tuple[str, float, int, int, int]:
+    """
+    Takes in a ground truth and hypothesis string, applies transformations as specified by
+    remove_punctuation and to_lower_case, and returns data to visualize word error rate.
+
+    Specifically, this returns an HTML string with insertions, deletions, and substitutions 
+    highlighted as well as the computed WER, and # of subsititutions, insertions, and deletions.
+    """
 
     highlighted_text = []
 
-    processed = process_words(ground_truth, hypothesis)
+    transforms = [
+        RemovePunctuation() if remove_punctuation else None,
+        ToLowerCase() if to_lower_case else None,
+    ]
+    transform = Compose([t for t in transforms if t is not None])
+
+    processed = process_words(
+        reference=transform(ground_truth), hypothesis=transform(hypothesis)
+    )
 
     # Process each alignment operation in measures
-    for alignment, ref, hyp in zip(processed.alignments, processed.references, processed.hypotheses):
+    for alignment, ref, hyp in zip(
+        processed.alignments, processed.references, processed.hypotheses
+    ):
         for chunk in alignment:
-            if chunk.type == 'equal':
+            if chunk.type == "equal":
                 # Add equal words without highlighting
-                highlighted_text.extend(ref[chunk.ref_start_idx:chunk.ref_end_idx])
+                highlighted_text.extend(ref[chunk.ref_start_idx : chunk.ref_end_idx])
 
-            elif chunk.type == 'insert':
+            elif chunk.type == "insert":
                 # Highlight inserted words in green
-                highlighted_text.append(f'<span style="color:green;">{make_string(hyp[chunk.hyp_start_idx:chunk.hyp_end_idx])}</span>')
+                highlighted_text.append(
+                    f'<span style="color:green;">'
+                    f"{make_string(hyp[chunk.hyp_start_idx:chunk.hyp_end_idx])}</span>"
+                )
 
-            elif chunk.type == 'substitute':
+            elif chunk.type == "substitute":
                 # Highlight substitutions in purple: ground truth is striked through
-                highlighted_text.append(f'<span style="color:purple;">{make_string(hyp[chunk.hyp_start_idx:chunk.hyp_end_idx])}</span>')  # Hypothesis word
-                highlighted_text.append(f'<span style="color:purple; text-decoration:line-through;">{make_string(ref[chunk.ref_start_idx:chunk.ref_end_idx])}</span>')  # Ground truth word
+                highlighted_text.append(
+                    f'<span style="color:purple;">'
+                    f"{make_string(hyp[chunk.hyp_start_idx:chunk.hyp_end_idx])}</span>"
+                )  # Hypothesis word
+                highlighted_text.append(
+                    f'<span style="color:purple; text-decoration:line-through;">'
+                    f"{make_string(ref[chunk.ref_start_idx:chunk.ref_end_idx])}</span>"
+                )  # Ground truth word
 
-            elif chunk.type == 'delete':
+            elif chunk.type == "delete":
                 # Highlight deleted words in red with strikethrough
-                highlighted_text.append(f'<span style="color:red; text-decoration:line-through;">{make_string(ref[chunk.ref_start_idx:chunk.ref_end_idx])}</span>')
+                highlighted_text.append(
+                    f'<span style="color:red; text-decoration:line-through;">'
+                    f"{make_string(ref[chunk.ref_start_idx:chunk.ref_end_idx])}</span>"
+                )
+
+    highlighted_text_str = make_string(highlighted_text)
 
-    highlighted_text_str = ' '.join(highlighted_text)
-    
     # Color Legend HTML
     legend_html = """
     <div style="margin-top: 10px;">
@@ -46,20 +83,32 @@ def highlight_errors(ground_truth, hypothesis):
     # Combine highlighted output and legend
     combined_output = f"{legend_html}<br>{highlighted_text_str}"
 
-    return combined_output, processed.wer, processed.substitutions, processed.insertions, processed.deletions
+    return (
+        combined_output,
+        processed.wer,
+        processed.substitutions,
+        processed.insertions,
+        processed.deletions,
+    )
+
 
 # Gradio Interface
 interface = gr.Interface(
     fn=highlight_errors,
-    inputs=["text", "text"],
+    inputs=[
+        gr.Textbox(label="Ground Truth"),
+        gr.Textbox(label="Hypothesis"),
+        gr.Checkbox(label="Ignore Punctuation"),
+        gr.Checkbox(label="Ignore Case"),
+    ],
     outputs=[
         gr.HTML(label="Highlighted Transcript"),
         gr.Number(label="Word Error Rate"),
         gr.Number(label="Substitutions"),
         gr.Number(label="Insertions"),
-        gr.Number(label="Deletions")
+        gr.Number(label="Deletions"),
     ],
-    title="WER Analysis"
+    title="WER Analysis",
 )
 
 interface.launch()