Upload 3 files

README.md

@@ -1,13 +1 @@
----
-title: Sammaali Similarity
-emoji: 👀
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 5.43.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Placeholder (unchanged from previous message).

app (1).py

@@ -0,0 +1,366 @@
+import os
+import math
+import re
+from functools import lru_cache
+from typing import Dict, List, Tuple, Any
+
+import numpy as np
+import gradio as gr
+
+# Lazy import to speed up cold start a bit
+_ST_MODEL = None
+_ST_NAME = os.getenv("SEM_MODEL_NAME", "sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+
+
+# -----------------------------
+# Arabic normalization utilities
+# -----------------------------
+
+_AR_DIACRITICS = re.compile(r"[ًٌٍَُِّْـ]")
+_AR_PUNCT = re.compile(r"[^\w\s]")
+_AR_SPACE = re.compile(r"\s+")
+
+def normalize_arabic(text: str, strict: bool = True) -> str:
+    """
+    Normalize Arabic text.
+    strict=True  : keep letters distinct, mainly remove diacritics + punctuation and collapse spaces.
+    strict=False : additionally unify common variants (ا/أ/إ/آ, ى→ي, ؤ→و, ئ→ي). Useful for semantic similarity.
+    """
+    if not isinstance(text, str):
+        text = "" if text is None else str(text)
+    t = text.strip()
+    # strip diacritics and tatweel
+    t = _AR_DIACRITICS.sub("", t)
+    t = t.replace("ـ", "")  # tatweel
+    if not strict:
+        # gentle letter unification for semantic mode
+        t = re.sub(r"[إأآا]", "ا", t)
+        t = t.replace("ى", "ي").replace("ؤ", "و").replace("ئ", "ي")
+        # keep 'ة' as-is; many curricula treat it distinctly from 'ه'
+    # punctuation → space, then collapse
+    t = _AR_PUNCT.sub(" ", t)
+    t = _AR_SPACE.sub(" ", t).strip()
+    return t
+
+
+def tok_words(text: str) -> List[str]:
+    # After normalization, simple whitespace split is reliable for Arabic WER
+    return [w for w in text.split() if w]
+
+
+_SEG_SPLIT = re.compile(r"[.!؟…]+")
+
+def segment_sentences(text: str) -> List[str]:
+    return [s.strip() for s in _SEG_SPLIT.split(text) if s.strip()]
+
+
+# -----------------------------
+# Literal similarity metrics
+# -----------------------------
+
+def _levenshtein(a: List[str] | str, b: List[str] | str) -> int:
+    """Works for char-level (str) or word-level (list[str]) with O(min(n,m)) memory."""
+    n, m = len(a), len(b)
+    if n == 0: return m
+    if m == 0: return n
+    # ensure a is the shorter for memory
+    if n > m:
+        a, b = b, a
+        n, m = m, n
+    prev = list(range(n + 1))
+    for j in range(1, m + 1):
+        curr = [j] + [0] * n
+        bj = b[j - 1]
+        for i in range(1, n + 1):
+            cost = 0 if a[i - 1] == bj else 1
+            curr[i] = min(prev[i] + 1, curr[i - 1] + 1, prev[i - 1] + cost)
+        prev = curr
+    return prev[n]
+
+
+def cer(reference: str, hypothesis: str) -> float:
+    if not reference:
+        return 0.0 if not hypothesis else 1.0
+    d = _levenshtein(reference, hypothesis)
+    return d / max(1, len(reference))
+
+
+def wer(ref_words: List[str], hyp_words: List[str]) -> float:
+    if not ref_words:
+        return 0.0 if not hyp_words else 1.0
+    d = _levenshtein(ref_words, hyp_words)
+    return d / max(1, len(ref_words))
+
+
+def _lcs_len(a: List[str], b: List[str]) -> int:
+    # standard DP (O(n*m)); fine for typical paragraph sizes
+    n, m = len(a), len(b)
+    if n == 0 or m == 0:
+        return 0
+    dp = [0] * (m + 1)
+    for i in range(1, n + 1):
+        prev = 0
+        ai = a[i - 1]
+        for j in range(1, m + 1):
+            tmp = dp[j]
+            if ai == b[j - 1]:
+                dp[j] = prev + 1
+            else:
+                dp[j] = max(dp[j], dp[j - 1])
+            prev = tmp
+    return dp[m]
+
+
+def rouge_l_f1(ref_words: List[str], hyp_words: List[str]) -> float:
+    lcs = _lcs_len(ref_words, hyp_words)
+    if lcs == 0:
+        return 0.0
+    prec = lcs / max(1, len(hyp_words))
+    rec  = lcs / max(1, len(ref_words))
+    if prec + rec == 0:
+        return 0.0
+    return (2 * prec * rec) / (prec + rec)
+
+
+def jaccard_char_3(a: str, b: str) -> float:
+    A = {a[i:i+3] for i in range(max(0, len(a) - 2))}
+    B = {b[i:i+3] for i in range(max(0, len(b) - 2))}
+    if not A and not B: return 1.0
+    if not A or not B:  return 0.0
+    return len(A & B) / len(A | B)
+
+
+# Default weights (tune on your dev set if needed)
+# 0.35*(1 - CER) + 0.35*(1 - WER) + 0.30*ROUGE-L
+W_CER, W_WER, W_RL = 0.35, 0.35, 0.30
+
+def literal_scores(reference: str, student: str) -> Dict[str, float]:
+    ref = normalize_arabic(reference, strict=True)
+    hyp = normalize_arabic(student,    strict=True)
+
+    c = cer(ref, hyp)
+    ref_w, hyp_w = tok_words(ref), tok_words(hyp)
+    w = wer(ref_w, hyp_w)
+    rl = rouge_l_f1(ref_w, hyp_w)
+    jac3 = jaccard_char_3(ref, hyp)
+
+    literal_score = W_CER*(1 - c) + W_WER*(1 - w) + W_RL*rl
+    return {
+        "CER": float(c),
+        "WER": float(w),
+        "ROUGE_L": float(rl),
+        "Jaccard3": float(jac3),
+        "LiteralScore": float(literal_score)
+    }
+
+
+# -----------------------------
+# Semantic similarity (Sentence-Transformers)
+# -----------------------------
+
+@lru_cache(maxsize=1)
+def _get_semantic_model():
+    global _ST_MODEL
+    if _ST_MODEL is None:
+        from sentence_transformers import SentenceTransformer, util  # local import
+        _ST_MODEL = SentenceTransformer(_ST_NAME)
+    return _ST_MODEL
+
+
+def semantic_score(reference: str, student: str) -> Dict[str, float]:
+    model = _get_semantic_model()
+    ref = normalize_arabic(reference, strict=False)
+    hyp = normalize_arabic(student,    strict=False)
+    # Sentence-level embeddings of the entire text
+    emb = model.encode([ref, hyp], normalize_embeddings=True, convert_to_numpy=True)
+    sim = float(np.clip(np.dot(emb[0], emb[1]), -1.0, 1.0))
+    return {"SemanticSimilarity": sim}
+
+
+# -----------------------------
+# Segment (sentence/verse) scoring
+# -----------------------------
+
+def _length_weighted_avg(pairs: List[Tuple[str, str]], mode: str) -> float:
+    """
+    Compute a length-weighted average score over aligned segments.
+    """
+    total_chars = 0
+    accum = 0.0
+    for r, h in pairs:
+        L = literal_scores(r, h)["LiteralScore"]
+        S = semantic_score(r, h)["SemanticSimilarity"]
+        if mode == "literal":
+            s = L
+        elif mode == "understanding":
+            s = S
+        else:  # default hybrid in simple avg
+            s = (L + S) / 2.0
+        w = max(1, len(normalize_arabic(r, strict=True)))
+        accum += w * s
+        total_chars += w
+    if total_chars == 0:
+        return 0.0
+    return accum / total_chars
+
+
+def score_long(reference_text: str, student_text: str, *, mode: str = "hybrid") -> float:
+    ref_segs = segment_sentences(reference_text)
+    hyp_segs = segment_sentences(student_text)
+    if not ref_segs:
+        return 0.0
+    common = min(len(ref_segs), len(hyp_segs))
+    pairs: List[Tuple[str, str]] = list(zip(ref_segs[:common], hyp_segs[:common]))
+    if len(ref_segs) > common:
+        pairs += [(r, "") for r in ref_segs[common:]]
+
+    # Compute length-weighted stats
+    total_len = 0
+    accum = 0.0
+    for r, h in pairs:
+        L = literal_scores(r, h)["LiteralScore"]
+        S = semantic_score(r, h)["SemanticSimilarity"]
+        if mode == "literal":
+            s = L
+        elif mode == "understanding":
+            s = S
+        else:  # hybrid -> use product per your instruction
+            s = L * S
+        w = max(1, len(normalize_arabic(r, strict=True)))
+        accum += w * s
+        total_len += w
+    if total_len == 0:
+        return 0.0
+    return max(0.0, min(1.0, accum / total_len))
+
+
+# -----------------------------
+# Final hybrid grade and letter
+# -----------------------------
+
+def clamp01(x: float) -> float:
+    return max(0.0, min(1.0, float(x)))
+
+def hybrid_grade(literal: float, semantic: float) -> float:
+    # Simple mean (can be tuned): equal weight to literal accuracy and understanding
+    return float((literal + semantic) / 2.0)
+
+
+# Two rubrics (thresholds) — tweak if you have empirical calibration
+RUBRIC = {
+    "literal": {
+        "ممتاز": (0.90, 1.00),
+        "جيد جداً": (0.80, 0.90),
+        "جيد": (0.70, 0.80),
+        "تحتاج إعادة": (0.00, 0.70),
+    },
+    "semantic": {
+        "ممتاز": (0.88, 1.00),
+        "جيد جداً": (0.82, 0.88),
+        "جيد": (0.75, 0.82),
+        "تحتاج إعادة": (0.00, 0.75),
+    },
+}
+
+def _grade_letter(score: float, kind: str) -> str:
+    for letter, (lo, hi) in RUBRIC[kind].items():
+        if lo <= score <= hi:
+            return letter
+    return "تحتاج إعادة"
+
+
+def final_result(reference_text: str, student_text: str, *,
+                 mode: str = "hybrid",
+                 use_segments: bool = False) -> Dict[str, Any]:
+    """
+    mode: 'literal' | 'understanding' | 'hybrid'
+    use_segments: True → sentence/verse-level length-weighted scoring
+    """
+    if use_segments:
+        main = score_long(reference_text, student_text, mode=mode)
+    else:
+        L = literal_scores(reference_text, student_text)["LiteralScore"]
+        S = semantic_score(reference_text, student_text)["SemanticSimilarity"]
+        if mode == "literal":
+            main = L
+        elif mode == "understanding":
+            main = S
+        else:
+            main = hybrid_grade(L, S)
+    main = clamp01(main)
+
+    Ld = literal_scores(reference_text, student_text)
+    Sd = semantic_score(reference_text, student_text)
+
+    # choose rubric mapping
+    rubric_kind = "semantic" if mode == "understanding" else "literal"
+    letter = _grade_letter(float(main), rubric_kind)
+
+    return {
+        "score": float(main),
+        "letter": letter,
+        "details": {
+            **Ld,
+            **Sd
+        }
+    }
+
+
+# -----------------------------
+# Gradio UI + API
+# -----------------------------
+
+EXAMPLE_REF = "الذكاء الاصطناعي يساعد الطلاب على التعلم من خلال توفير محتوى تفاعلي وتقييمات فورية."
+EXAMPLE_STD = "الذكاء الاصطناعي يدعم تعلم الطلاب بتقديم محتوى تفاعلي وتقويمات سريعة."
+
+def score_api(reference_text: str, student_text: str, mode: str, use_segments: bool) -> Dict[str, Any]:
+    return final_result(reference_text, student_text, mode=mode, use_segments=use_segments)
+
+def score_api_batch(pairs: List[Dict[str, Any]], mode: str, use_segments: bool) -> List[Dict[str, Any]]:
+    """
+    pairs: list of {"reference": "...", "student": "..."}
+    """
+    out = []
+    for item in pairs or []:
+        ref = item.get("reference", "")
+        std = item.get("student", "")
+        out.append(final_result(ref, std, mode=mode, use_segments=use_segments))
+    return out
+
+
+with gr.Blocks(fill_height=True, title="Samaali — Memorization Scoring") as demo:
+    gr.Markdown("### Samaali — Memorization Scoring (ASR/OCR Post‑Processing Stage)")
+    with gr.Row():
+        ref = gr.Textbox(label="Original Text (from OCR)", lines=8, value=EXAMPLE_REF)
+        std = gr.Textbox(label="Student Recitation (ASR post‑processed)", lines=8, value=EXAMPLE_STD)
+    with gr.Row():
+        mode = gr.Radio(
+            choices=["hybrid", "literal", "understanding"],
+            value="hybrid",
+            label="Scoring Mode"
+        )
+        use_segments = gr.Checkbox(value=False, label="Use sentence/verse segments (length‑weighted)")
+    with gr.Row():
+        btn = gr.Button("Score", variant="primary")
+        clear = gr.Button("Clear")
+    score_out = gr.JSON(label="Result (score ∈ [0,1], letter, metrics)")
+
+    btn.click(fn=score_api, inputs=[ref, std, mode, use_segments], outputs=[score_out], api_name="score")
+    clear.click(lambda: ("", "", "hybrid", False), None, [ref, std, mode, use_segments])
+
+    # Hidden batch endpoint for programmatic access
+    hidden_pairs = gr.State([])
+    hidden_mode = gr.State("hybrid")
+    hidden_segments = gr.State(False)
+    hidden_btn = gr.Button(visible=False)
+    hidden_btn.click(
+        fn=score_api_batch,
+        inputs=[hidden_pairs, hidden_mode, hidden_segments],
+        outputs=[gr.JSON()],
+        api_name="score_batch"
+    )
+
+
+if __name__ == "__main__":
+    # Spaces will call `python app.py`; Gradio handles serving.
+    demo.queue(max_size=16).launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.29.0
+sentence-transformers>=2.2.2
+torch
+numpy