Update app.py

app.py

@@ -1,86 +1,136 @@
 import streamlit as st
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
-import evaluate
+import logging
+import pandas as pd
+import plotly.express as px
+from models.translation_loader import TranslationLoader
+from evaluators.evaluator import TranslationEvaluator
 
-# Page configuration
-st.set_page_config(
-    page_title="Turkish Translation Evaluator",
-    layout="wide",
-    initial_sidebar_state="expanded"
+# ────────── Logging ──────────
+logging.basicConfig(
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    level=logging.INFO
 )
+logger = logging.getLogger(__name__)
 
+# ────────── Cached Loader/Evaluator ──────────
 @st.cache_resource
-def load_translation_pipeline():
-    model_name = "facebook/m2m100_418M"
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForSeq2SeqLM.from_pretrained(
-        model_name,
-        device_map="auto",
-        load_in_8bit=True,
-        torch_dtype="auto"
+def load_resources():
+    loader = TranslationLoader(
+        model_name="facebook/nllb-200-distilled-600M",
+        quantize=True
     )
-    translator = pipeline(
-        "translation",
-        model=model,
-        tokenizer=tokenizer,
-        src_lang="auto",
-        tgt_lang="tr",
-        device_map="auto"
-    )
-    return translator
+    evaluator = TranslationEvaluator()
+    return loader, evaluator
 
-@st.cache_resource
-def load_metrics():
+# ────────── Sidebar Model Info ──────────
+def display_model_info(info):
+    st.sidebar.markdown("### Model Info")
+    st.sidebar.write(f"**Model:** {info['model_name']}")
+    st.sidebar.write(f"**8-bit Quantized:** {info['quantized']}")
+    st.sidebar.write(f"**Device:** {info['device']}")
+
+# ────────── Single‐text Processing ──────────
+def process_text(src, ref, loader, evaluator, metrics):
+    # 1) Translate
+    out = loader.translate(src, tgt_lang="tur_Latn")
+    hyp = out[0]["translation_text"] if isinstance(out, list) else out["translation_text"]
+    # 2) Evaluate
+    scores = evaluator.evaluate([src], [ref or ""], [hyp])
     return {
-        "bleu": evaluate.load("bleu"),
-        "bertscore": evaluate.load("bertscore"),
-        "bertturk": evaluate.load("bertscore"),
-        "comet": evaluate.load("comet", module_type="metric")
+        "source": src,
+        "reference": ref,
+        "hypothesis": hyp,
+        **{m: scores[m] for m in metrics}
     }
 
-translator = load_translation_pipeline()
-metrics = load_metrics()
+def _show_single_results(res):
+    left, right = st.columns(2)
+    with left:
+        st.markdown("**Source:**")
+        st.write(res["source"])
+        st.markdown("**Hypothesis (TR):**")
+        st.write(res["hypothesis"])
+        if res["reference"]:
+            st.markdown("**Reference (TR):**")
+            st.write(res["reference"])
+    with right:
+        st.markdown("### Scores")
+        df = pd.DataFrame({k: [v] for k, v in res.items() if k in ["BLEU","BERTScore","BERTurk","COMET"]})
+        st.table(df)
+
+# ────────── Batch‐CSV Processing ──────────
+def process_file(uploaded, loader, evaluator, metrics, batch_size):
+    df = pd.read_csv(uploaded)
+    if not {"src","ref_tr"}.issubset(df.columns):
+        raise ValueError("CSV must have `src` and `ref_tr` columns")
+    prog = st.progress(0)
+    results = []
+    total = len(df)
+    for i in range(0, total, batch_size):
+        batch = df.iloc[i : i + batch_size]
+        srcs = batch["src"].tolist()
+        refs = batch["ref_tr"].tolist()
+        # translate batch
+        outs = loader.translate(srcs, tgt_lang="tur_Latn")
+        hyps = [o["translation_text"] for o in outs]
+        # evaluate each item individually
+        for s, r, h in zip(srcs, refs, hyps):
+            sc = evaluator.evaluate([s], [r], [h])
+            entry = {"src": s, "ref_tr": r, "hyp_tr": h}
+            entry.update({m: sc[m] for m in metrics})
+            results.append(entry)
+        prog.progress(min(i + batch_size, total) / total)
+    return pd.DataFrame(results)
+
+def _show_batch_viz(df, metrics):
+    for m in metrics:
+        st.markdown(f"#### {m} Distribution")
+        fig = px.histogram(df, x=m)
+        st.plotly_chart(fig, use_container_width=True)
+
+# ────────── Main ──────────
+def main():
+    st.set_page_config(page_title="🔤 Translation→Turkish Quality", layout="wide")
+    st.title("🔤 Translation → TR Quality & COMET")
+    st.markdown("Enter text or upload a CSV to translate into Turkish and evaluate with BLEU, BERTScore, BERTurk & COMET.")
+
+    # Sidebar
+    with st.sidebar:
+        st.header("Settings")
+        metrics = st.multiselect(
+            "Select metrics",
+            ["BLEU", "BERTScore", "BERTurk", "COMET"],
+            default=["BLEU","BERTScore","COMET"]
+        )
+        batch_size = st.slider("Batch size", 1, 32, 8)
+        loader, evaluator = load_resources()
+        display_model_info(loader.get_info())
 
-st.title("🔤 Turkish Translation & Evaluation")
+    # Tabs
+    tab1, tab2 = st.tabs(["Single Sentence", "Batch CSV"])
 
-with st.form("translate_form"):
-    input_text = st.text_area("Input text (any language)", height=150)
-    ref_text = st.text_area("Reference Turkish translation (optional)", height=150)
-    submit = st.form_submit_button("Translate & Evaluate")
+    with tab1:
+        src = st.text_area("Source sentence (any language):", height=150)
+        ref = st.text_area("Turkish reference (optional):", height=100)
+        if st.button("Evaluate"):
+            with st.spinner("Translating & evaluating…"):
+                res = process_text(src, ref, loader, evaluator, metrics)
+            _show_single_results(res)
 
-if submit:
-    if not input_text.strip():
-        st.error("Please provide input text to translate.")
-    else:
-        with st.spinner("Translating..."):
-            out = translator(input_text, max_length=512)
-            translation = out[0]["translation_text"]
-        st.subheader("Model Translation (Turkish)")
-        st.markdown(f"> {translation}")
+    with tab2:
+        uploaded = st.file_uploader("Upload CSV with `src` & `ref_tr` columns", type=["csv"])
+        if uploaded:
+            with st.spinner("Processing file…"):
+                df_res = process_file(uploaded, loader, evaluator, metrics, batch_size)
+            st.markdown("### Batch Results")
+            st.dataframe(df_res, use_container_width=True)
+            _show_batch_viz(df_res, metrics)
+            st.download_button("Download CSV", df_res.to_csv(index=False), "results.csv")
 
-        if ref_text.strip():
-            preds = [translation]
-            refs = [[ref_text]]
-            # BLEU
-            bleu_score = metrics["bleu"].compute(predictions=preds, references=refs)["bleu"] * 100
-            st.metric("BLEU-4", f"{bleu_score:.2f}")
-            # BERTScore (multilingual)
-            bs = metrics["bertscore"].compute(predictions=preds, references=[ref_text], lang="tr")
-            st.metric("BERTScore (f1)", f"{bs['f1'][0]*100:.2f}")
-            # BERTurk (Turkish BERTScore)
-            bt = metrics["bertturk"].compute(
-                predictions=preds,
-                references=[ref_text],
-                model_type="dbmdz/bert-base-turkish-cased"
-            )
-            st.metric("BERTurk (f1)", f"{bt['f1'][0]*100:.2f}")
-            # COMET
-            comet_out = metrics["comet"].compute(
-                model="Unbabel/wmt22-comet-da",
-                src=[input_text],
-                mt=preds,
-                ref=[ref_text]
-            )
-            st.metric("COMET", f"{comet_out['score'][0]:.2f}")
-        else:
-            st.info("No reference provided; skipping evaluation metrics.")
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        st.error(f"Unexpected error: {e}")
+        logger.exception("Unhandled exception")