Upload app.py

app.py

@@ -0,0 +1,569 @@
+# -*- coding: utf-8 -*-
+"""faster_whisper_large_v3_post_processwith_advanced. ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1-rZQ9JZaDiAZfrH4yoan2Cwv6pdhoOF1
+
+# import lib and models
+"""
+
+# Commented out IPython magic to ensure Python compatibility.
+# %%capture
+# !pip install transformers datasets soundfile torch
+# !pip install pyxDamerauLevenshtein
+# !pip install evaluate torchaudio soundfile
+# !pip install jiwer
+# !pip install textdistance
+# !pip install -q bert-score sentence-transformers
+# !pip install faster-whisper
+
+import torch
+import soundfile as sf
+from datasets import load_dataset
+import evaluate
+import torchaudio
+import editdistance
+from difflib import SequenceMatcher
+from IPython.display import display, HTML
+import numpy as np
+import pandas as pd
+import re
+import nltk
+nltk.download('punkt')
+nltk.download('punkt_tab')
+from collections import Counter
+from bert_score import score
+import textdistance
+from sentence_transformers import SentenceTransformer, util
+from faster_whisper import WhisperModel
+
+sbert_model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
+
+"""# Whisper"""
+
+dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = WhisperModel("large-v3", device=str(dev), compute_type="int8")
+
+segments, info = model.transcribe(
+    "Test1.m4a",
+    word_timestamps=True,             # ← مهم جداً
+    vad_filter=True,                  # اختياري: فلترة الصمت/الضوضاء
+    vad_parameters={"min_silence_duration_ms": 200},
+)
+segments = list(segments)
+
+def clean_ar_token(t: str) -> str:
+    t = t.strip()
+    # إزالة محارف غير حرفية على الأطراف
+    t = re.sub(r'^[^\w\u0600-\u06FF]+|[^\w\u0600-\u06FF]+$', '', t)
+    return t
+
+# نجمع الكلمات بترتيبها
+words = []
+for seg in segments:
+    if seg.words:
+        for w in seg.words:
+            tok = clean_ar_token(w.word)
+            if tok:
+                words.append(tok)
+
+transcript = " ".join(words)
+
+# تنظيف نهائي
+transcript = re.sub(r"\s+", " ", transcript).strip()
+transcript = re.sub(r"\s+([،,\.!?؟])", r"\1", transcript)
+
+print(transcript)
+
+reference_text = "التصلب اللويحي المتعدد: يظهر المرض بين سن (30 - 40) وهو تنكس عصبي، سببه: فقدان خلايا الدبق قليلة الاستطالات، وتفككها إلى صفائح متصلّبة نتيجة مرض مناعي ذاتي كما في الشكل المجاور، تنتج الأعراض من زوال غمد النخاعين في مناطق متعددة من المادة البيضاء للجهاز العصبي المركزي. فيحسّ المريض بصدمة كهربائية عند تحريك العنق." # Replace with your reference text
+predicted_text = transcript
+wer_metric = evaluate.load("wer")
+cer_metric = evaluate.load("cer")
+
+wer_score = wer_metric.compute(predictions=[predicted_text], references=[reference_text])
+cer_score = cer_metric.compute(predictions=[predicted_text], references=[reference_text])
+
+edit_distance = editdistance.eval(predicted_text, reference_text)
+
+print(" WER - نسبة الخطأ في الكلمات: {:.2%}".format(wer_score))
+print(" CER - نسبة الخطأ في الحروف: {:.2%}".format(cer_score))
+print(f" Edit Distance - عدد التعديلات المطلوبة: {edit_distance}")
+
+"""# post Process
+
+## text analysis
+
+### normalize and tokenization
+"""
+
+def normalize_arabic(text):
+    # إزالة التشكيل والترقيم وتوحيد بعض الأشكال
+    text = re.sub(r"[ًٌٍَُِّْـ]", "", text)
+    text = re.sub(r"[“”\"',:؛؟.!()\[\]{}،\-–—_]", " ", text)
+    text = re.sub(r"[إأٱآا]", "ا", text)
+    text = text.replace("ة", "ه").replace("ى", "ي")
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+def simple_tokenize(text):
+    return nltk.word_tokenize(normalize_arabic(text))
+
+def align_texts(ref_tokens, hyp_tokens):
+    import difflib
+    sm = difflib.SequenceMatcher(None, ref_tokens, hyp_tokens)
+    aligned = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        aligned.append({'type': tag, 'ref': ref_tokens[i1:i2], 'hyp': hyp_tokens[j1:j2], 'ref_idx': (i1, i2), 'hyp_idx': (j1, j2)})
+    return aligned
+
+"""### soundex and Levenshtein similarity"""
+
+def arabic_soundex(word):
+    word = normalize_arabic(word)
+    replacements = {
+        'بف': 'b', 'جشص': 'j', 'دض': 'd', 'طت': 't', 'قغ': 'q', 'كخ': 'k', 'سصز': 's',
+        'ثذظ': 'z', 'ح': 'h', 'ع': 'a', 'م': 'm', 'ن': 'n', 'ل': 'l', 'ر': 'r',
+        'ه': 'h', 'و': 'w', 'ي': 'y'
+    }
+    result = ""
+    for c in word:
+        for group, rep in replacements.items():
+            if c in group:
+                result += rep
+                break
+    return result
+
+def phonetic_similarity(w1, w2):
+    return arabic_soundex(w1) == arabic_soundex(w2)
+
+def is_levenshtein_1(w1, w2):
+    return textdistance.levenshtein(w1, w2) == 1
+
+"""### number study"""
+
+AR_DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩", "0123456789")
+
+# تحويل "١٢٣" -> "123"
+def normalize_digits(s: str) -> str:
+    return s.translate(AR_DIGITS)
+
+# قاموس مبسّط للوحدات والعشرات والمئات (تكمله تدريجيًا حسب كتابك)
+UNITS = {"صفر":0,"واحد":1,"واحدة":1,"اثنان":2,"اثنين":2,"اثنتان":2,"اثنتين":2,
+         "ثلاث":3,"ثلاثة":3,"أربع":4,"اربعة":4,"أربعة":4,"خمس":5,"خمسة":5,
+         "ست":6,"ستة":6,"سبع":7,"سبعة":7,"ثمان":8,"ثماني":8,"ثمانية":8,
+         "تسع":9,"تسعة":9}
+TENS  = {"عشر":10,"عشرة":10,"عشرون":20,"عشرين":20,"ثلاثون":30,"ثلاثين":30, "الثلاثين":30,
+         "أربعون":40,"اربعون":40,
+         "الأربعين":30,
+         "خمسون":50,"ستون":60,"سبعون":70,"ثمانون":80,"تسعون":90}
+HUND = {"مئة":100,"مائه":100,"مائة":100,"مئه":100,"مئ":100}
+SCALE = {"ألف":1000,"الف":1000,"ألاف":1000,"آلاف":1000,"مليون":10**6,"مليار":10**9}
+
+def normalize_ar_orth(text: str) -> str:
+    text = re.sub(r"[ًٌٍَُِّْـ]", "", text)
+    text = re.sub(r"[“”\",:؛؟.!()\[\]{}،\-–—_]", " ", text)
+    # همزات وتطبيع بسيط
+    text = re.sub("[إأٱآا]", "ا", text)
+    text = text.replace("ة","ه").replace("ى","ي")
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+def words_to_number(tokens):
+    """محول مبسّط: يدعم تركيب مثل: 'مئه و ثلاثه و عشرون'، طوّره حسب نصوصك."""
+    total = 0; current = 0
+    for w in tokens:
+        if w in UNITS: current += UNITS[w]
+        elif w in TENS: current += TENS[w]
+        elif w in HUND: current += HUND[w]
+        elif w in SCALE:
+            current = max(1, current) * SCALE[w]
+            total += current; current = 0
+        elif w == "و":
+            continue
+        else:
+            # كلمة ليست رقم؛ انهي التجميع الحالي
+            total += current; current = 0
+    total += current
+    return total if total != 0 else None
+
+def to_numeric_value(token: str):
+    """يحاول تحويل التوكن إلى قيمة رقمية (digit أو كلمات)."""
+    t = normalize_ar_orth(token)
+    d = normalize_digits(t)
+    if re.fullmatch(r"\d+", d):  # رقم مباشرة
+        return int(d)
+    # حوّل كلمة/جملة أرقام
+    toks = t.split()
+    val = words_to_number(toks)
+    return val
+
+def is_number_token(w):
+    return to_numeric_value(w) is not None
+
+"""### SBERT and MARBERT-CLS"""
+
+from transformers import AutoTokenizer, AutoModel
+import torch
+from sentence_transformers import util
+
+_mar_name = "UBC-NLP/MARBERT"
+_mar_tok = AutoTokenizer.from_pretrained(_mar_name)
+_mar_model = AutoModel.from_pretrained(_mar_name)
+
+def marbert_cls_similarity(a: str, b: str) -> float:
+    if not a or not b: return 0.0
+    with torch.no_grad():
+        ta = _mar_tok(a, return_tensors='pt', truncation=True, padding=True)
+        tb = _mar_tok(b, return_tensors='pt', truncation=True, padding=True)
+        ea = _mar_model(**ta).last_hidden_state[:,0,:]
+        eb = _mar_model(**tb).last_hidden_state[:,0,:]
+        sim = util.cos_sim(ea, eb).item()
+        # تحويل من [-1..1] إلى [0..1] اختياري:
+        return (sim + 1) / 2
+
+def multi_bert_similarity(a: str, b: str):
+    if not a or not b:
+        return {"sbert":0.0, "marbert":0.0, "max":0.0, "avg":0.0}
+    sbert_sim = float(util.pytorch_cos_sim(sbert_model.encode(a, convert_to_tensor=True),
+                                           sbert_model.encode(b, convert_to_tensor=True)))
+    marbert_sim = marbert_cls_similarity(a, b)
+    vals = [sbert_sim, marbert_sim]
+    return {
+        "sbert": sbert_sim,
+        "marbert": marbert_sim,
+        "max": max(vals),
+        "avg": sum(vals)/len(vals)
+    }
+
+"""### Whisper predections and trust"""
+
+def clean_ar_token(t: str) -> str:
+    t = t.strip()
+    t = re.sub(r'^[^\w\u0600-\u06FF]+|[^\w\u0600-\u06FF]+$', '', t)
+    t = normalize_ar_orth(t)
+    return t
+
+def extract_word_conf_table(segments):
+    rows = []
+    for seg in segments:
+        for w in (seg.words or []):
+            rows.append({
+                "seg_start": float(seg.start),
+                "seg_end": float(seg.end),
+                "word_start": float(w.start),
+                "word_end": float(w.end),
+                "word": clean_ar_token(w.word),
+                "prob": float(w.probability),
+            })
+    return pd.DataFrame(rows)
+
+def build_asr_token_conf(df_words: pd.DataFrame, hyp_tokens: list):
+    """
+    يحوّل كلمات ASR (مع احتمالاتها) إلى قائمة احتمالات/مدد align مع hyp_tokens
+    سياسة التجميع: لو انقسمت كلمة إل�� عدة توكنات ننسخ نفس prob، ولو اندمجت عدة كلمات في توكن واحد نأخذ 'أقل' احتمال (تحفظًا).
+    """
+    toks_probs = []
+    toks_durs  = []
+    idx = 0
+    for _, row in df_words.iterrows():
+        w = row["word"]
+        prob = row["prob"]
+        dur  = (row["word_end"] - row["word_start"]) * 1000.0  # ms
+        # نفترض أن tokenizer عندنا لا يجزّئ الكلمة العربية غالبًا
+        # لكن لضمان التوافق:
+        sub_toks = [w]  # يمكن استبدالها بـ simple_tokenize(w) إذا أردت
+        for _ in sub_toks:
+            toks_probs.append(prob)
+            toks_durs.append(dur)
+            idx += 1
+
+    # مواءمة الطول مع hyp_tokens
+    L = len(hyp_tokens)
+    if len(toks_probs) >= L:
+        toks_probs = toks_probs[:L]
+        toks_durs  = toks_durs[:L]
+    else:
+        pad = L - len(toks_probs)
+        toks_probs += [None]*pad
+        toks_durs  += [None]*pad
+
+    # عتبات ديناميكية حسب التسجيل
+    arr = np.array([p for p in toks_probs if p is not None])
+    if arr.size:
+        low_t  = float(np.quantile(arr, 0.15))
+        high_t = float(np.quantile(arr, 0.70))
+    else:
+        low_t, high_t = 0.5, 0.85
+
+    asr_token_conf = {
+        i: {"prob": toks_probs[i], "duration_ms": toks_durs[i]}
+        for i in range(L)
+    }
+    return asr_token_conf, low_t, high_t
+
+"""### desicion gate"""
+
+def gate_by_word_conf(base_decision: str, prob: float, sbert_sim: float,
+                      is_short: bool, lev1: bool, duration_ms: float = None,
+                      low_t: float = 0.6, high_t: float = 0.9, sbert_lo=0.60):
+
+    band = "mid"
+    if prob is not None:
+        if prob <= low_t:  band = "low"
+        elif prob >= high_t: band = "high"
+
+    very_short = (duration_ms is not None and duration_ms < 120)  # 120ms قابل للتعديل
+
+    if band == "low":
+        if is_short and lev1:
+            return 'ASR error (low p + short+lev1)'
+        if very_short:
+            return 'ASR error (low p + very short)'
+        if sbert_sim >= sbert_lo:
+            return 'ASR error (low p + semantic)'
+        return 'ASR error (low p)'
+
+    if band == "high":
+        # لا نمنح ASR بسهولة — اترك القرار الأصلي (غالبًا يميل لخطأ حفظ عند اختلاف دلالي واضح)
+        return base_decision
+
+    return base_decision
+
+"""### classify pairs (numbers, short/long words, semantic)"""
+
+def classify_pair(ref_w, hyp_w, bert_scores, phon_sim, lev1, short_word,
+                  bert_thresh=0.75, max_bert=0.85):
+    # 1) فرع الأرقام
+    ref_num = to_numeric_value(ref_w)
+    hyp_num = to_numeric_value(hyp_w)
+    if ref_num is not None or hyp_num is not None:
+        if (ref_num is not None) and (hyp_num is not None):
+            if ref_num == hyp_num:
+                return 'ASR error (numbers equal)'
+        # لو أحدهما رقم والآخر لا، غالبًا ليس ASR — نكمل بقية الإشارات
+
+    # 2) كلمات قصيرة + Lev=1
+    if short_word and lev1:
+        return 'ASR error (short+lev1)'
+
+    # 3) قرار دلالي (نعتمد SBERT أساسًا + MARBERT مكمل)
+    avg_ok = bert_scores["avg"] >= bert_thresh
+    max_ok = bert_scores["max"] >  max_bert
+    if (phon_sim or lev1) and avg_ok or max_ok:
+        return 'ASR error (semantic/phonetic)'
+
+    return 'Memorization error'
+
+"""## Judge function"""
+
+def classify_alignment_optimized(aligned, ref_tokens, hyp_tokens,
+                                 bert_thresh=0.75, max_bert=0.85,
+                                 asr_token_conf=None, low_high=None):
+    """
+    - aligned: مخرجات align_texts (مع ref_idx/hyp_idx)
+    - ref_tokens, hyp_tokens: قوائم التوكنات بعد التطبيع
+    - asr_token_conf: dict من فهرس توكن ASR -> {"prob":.., "duration_ms":..}
+    - low_high: (low_t, high_t) عتبات ديناميكية مسبقة. إن لم تُمرَّر تُستنتج من asr_token_conf.
+    """
+    # استنتاج عتبات ديناميكية إذا توفرت
+    if low_high is None:
+        if asr_token_conf:
+            probs = [v["prob"] for v in asr_token_conf.values() if v["prob"] is not None]
+            if probs:
+                low_t  = float(np.quantile(probs, 0.15))
+                high_t = float(np.quantile(probs, 0.70))
+            else:
+                low_t, high_t = 0.5, 0.85
+        else:
+            low_t, high_t = 0.5, 0.85
+    else:
+        low_t, high_t = low_high
+
+    results = []
+    for entry in aligned:
+        tag = entry['type']
+        i1, i2 = entry.get('ref_idx', (None,None))
+        j1, j2 = entry.get('hyp_idx', (None,None))
+
+        if tag == 'equal':
+            for ref_w, hyp_w in zip(entry['ref'], entry['hyp']):
+                results.append({'ASR_word': hyp_w, 'GT_word': ref_w,
+                                'status': 'Correct', 'reason': ''})
+        elif tag in ['replace', 'delete', 'insert']:
+            max_len = max(len(entry['ref']), len(entry['hyp']))
+            for k in range(max_len):
+                ref_w = entry['ref'][k] if k < len(entry['ref']) else ''
+                hyp_w = entry['hyp'][k] if k < len(entry['hyp']) else ''
+
+                if not ref_w and not hyp_w:
+                    continue
+
+                # التشابهات
+                phon_sim = phonetic_similarity(ref_w, hyp_w) if ref_w and hyp_w else False
+                lev1 = is_levenshtein_1(ref_w, hyp_w) if ref_w and hyp_w else False
+                bert_scores = multi_bert_similarity(ref_w, hyp_w) if ref_w and hyp_w else {"sbert":0,"marbert":0,"max":0,"avg":0}
+                short_word = bool(ref_w and hyp_w and max(len(ref_w), len(hyp_w)) <= 6)
+
+                # قرار أساسي
+                if ref_w and hyp_w:
+                    base_status = classify_pair(ref_w, hyp_w, bert_scores, phon_sim, lev1, short_word,
+                                                bert_thresh, max_bert)
+                elif hyp_w == '':
+                    base_status = 'Missing (possible omission)'
+                elif ref_w == '':
+                    base_status = 'Extra (possible ASR insertion)'
+                else:
+                    base_status = 'Undefined Case'
+
+                # دمج ثقة كلمة ASR (إن توفرت)
+                word_prob = None
+                word_dur  = None
+                hyp_abs_idx = None
+                if (j1 is not None) and (j2 is not None):
+                    hyp_abs_idx = j1 + k
+                    if asr_token_conf and hyp_abs_idx in asr_token_conf:
+                        word_prob = asr_token_conf[hyp_abs_idx].get("prob")
+                        word_dur  = asr_token_conf[hyp_abs_idx].get("duration_ms")
+
+                final_status = base_status
+                if ref_w and hyp_w:
+                    final_status = gate_by_word_conf(
+                        base_decision=base_status,
+                        prob=word_prob,
+                        sbert_sim=bert_scores["sbert"],
+                        is_short=short_word,
+                        lev1=lev1,
+                        duration_ms=word_dur,
+                        low_t=low_t,
+                        high_t=high_t,
+                        sbert_lo=0.60
+                    )
+
+                reason = (f'Phonetic={phon_sim}, Lev1={lev1}, '
+                          f'SBERT={bert_scores["sbert"]:.2f}, '
+                          f'MARBERT={bert_scores["marbert"]:.2f}, '
+                          f'MAX={bert_scores["max"]:.2f}, '
+                          f'AVG={bert_scores["avg"]:.2f}, short={short_word}, '
+                          f'prob={None if word_prob is None else round(word_prob,2)}, '
+                          f'dur_ms={None if word_dur is None else int(word_dur)}, '
+                          f'low_t={round(low_t,2)}, high_t={round(high_t,2)}')
+
+                results.append({'ASR_word': hyp_w, 'GT_word': ref_w,
+                                'status': final_status, 'reason': reason})
+    return results
+
+"""# results
+
+## first result without token probability from faster whisper
+"""
+
+# Pipeline execution:
+ref_tokens = simple_tokenize(reference_text)
+hyp_tokens = simple_tokenize(predicted_text)
+aligned = align_texts(ref_tokens, hyp_tokens)
+results1 = classify_alignment_optimized(aligned, ref_tokens, hyp_tokens)
+
+df = pd.DataFrame(results1)
+pd.set_option('display.max_colwidth', 200)
+display(df)
+
+"""## map for each token probability of the word in whisper"""
+
+# 3) (اختياري) خريطة ثقة الكلمات من faster-whisper
+df_words = extract_word_conf_table(segments)   # segments من faster_whisper مع word_timestamps=True
+asr_token_conf, low_t, high_t = build_asr_token_conf(df_words, hyp_tokens)
+
+df_words
+
+"""## second results with map token"""
+
+results2 = classify_alignment_optimized(aligned, ref_tokens, hyp_tokens,
+                                       bert_thresh=0.75, max_bert=0.85,
+                                       asr_token_conf=asr_token_conf, low_high=(low_t, high_t))
+
+df = pd.DataFrame(results2)
+pd.set_option('display.max_colwidth', 200)
+display(df)
+
+"""## apply the missing and wrongs"""
+
+corrected_hyp_tokens = hyp_tokens.copy()
+
+for entry in results2:
+    asr_word = entry['ASR_word']
+    gt_word = entry['GT_word']
+    status = entry['status']
+
+    # Find the index of the asr_word in the original hyp_tokens
+    try:
+        # We need to find the specific occurrence if there are duplicates.
+        # This simple approach assumes unique words or works for the first occurrence.
+        # A more robust approach might track indices during the alignment.
+        if asr_word in corrected_hyp_tokens:
+            idx_in_hyp = corrected_hyp_tokens.index(asr_word)
+            if status.startswith('ASR error'):
+                corrected_hyp_tokens[idx_in_hyp] = gt_word
+            elif status == 'Memorization error':
+                # الكلمة يلي قالها خطا (يعني كانت  memorization error)
+                corrected_hyp_tokens[idx_in_hyp] = f"({asr_word})" # Mark memorization errors
+        # else: word was deleted/inserted, no direct replacement needed in this loop
+    except Exception as e:
+        print(f" Error processing {asr_word}: {e}")
+
+corrected_text = ' '.join(corrected_hyp_tokens)
+
+print("\n the result :")
+print(corrected_text)
+
+def highlight_word_diff(ref_word, pred_word):
+    s = SequenceMatcher(None, ref_word, pred_word)
+    ref_colored = ""
+    pred_colored = ""
+
+    for tag, i1, i2, j1, j2 in s.get_opcodes():
+        ref_part = ref_word[i1:i2]
+        pred_part = pred_word[j1:j2]
+        if tag == 'equal':
+            ref_colored += ref_part
+            pred_colored += pred_part
+        elif tag == 'replace':
+            ref_colored += ''.join([f'<span style="background: #ffeaea; color: #b30000; border-radius:2px;">{c}</span>' for c in ref_part])
+            pred_colored += ''.join([f'<span style="background: #ffeaea; color: #b30000; border-radius:2px;">{c}</span>' for c in pred_part])
+        elif tag == 'delete':
+            ref_colored += ''.join([f'<span style="background: #fff3cd; color:#ff9800; border-radius:2px;">{c}</span>' for c in ref_part])
+        elif tag == 'insert':
+            pred_colored += ''.join([f'<span style="background: #e3f1fc; color:#0069c0; border-radius:2px;">{c}</span>' for c in pred_part])
+    return ref_colored, pred_colored
+
+def diff_colored_chars(ref, pred):
+    ref_words = ref.split()
+    pred_words = pred.split()
+    s = SequenceMatcher(None, ref_words, pred_words)
+    ref_html = ""
+    pred_html = ""
+
+    for tag, i1, i2, j1, j2 in s.get_opcodes():
+        if tag == 'equal':
+            ref_html += ' '.join([w for w in ref_words[i1:i2]]) + " "
+            pred_html += ' '.join([w for w in pred_words[j1:j2]]) + " "
+        elif tag == 'replace':
+            for rw, pw in zip(ref_words[i1:i2], pred_words[j1:j2]):
+                rw_c, pw_c = highlight_word_diff(rw, pw)
+                ref_html += f'<span style="padding:2px 4px; margin:1px; border-radius:2px;">{rw_c}</span> '
+                pred_html += f'<span style="padding:2px 4px; margin:1px; border-radius:2px;">{pw_c}</span> '
+        elif tag == 'insert':
+            pred_html += ' '.join([f'<span style="background: #e3f1fc; color:#0069c0; border-radius:2px;">{w}</span>' for w in pred_words[j1:j2]]) + " "
+        elif tag == 'delete':
+            ref_html += ' '.join([f'<span style="background: #fff3cd; color:#ff9800; border-radius:2px;">{w}</span>' for w in ref_words[i1:i2]]) + " "
+
+    display(HTML(f"""<div style="font-family: 'Cairo', Tahoma, Arial; font-size:20px; direction:rtl;">
+    <b>النص المرجعي:</b><br>{ref_html}<br><br>
+    <b>النص الناتج:</b><br>{pred_html}
+    </div>"""))
+
+reference_text = normalize_arabic(reference_text)
+diff_colored_chars(reference_text, corrected_text)
+