Add files using upload-large-folder tool

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

assignment_sc_2/assignment_documentation.md

@@ -0,0 +1,250 @@
+# Text-Attributed Network Analysis Documentation
+
+This document explains how the implementation in `assignment_sc_2/code.py` addresses the assignment requirements and grading rubric.
+
+## 1. Objective
+
+The assignment analyzes a network of research papers where:
+
+- each node is a paper with metadata (`id`, `year`, `authors`, `title`, `abstract`),
+- each edge represents semantic similarity between two papers,
+- edge `weight` indicates tie strength (higher weight = stronger topical similarity).
+
+The code loads `aclbib.graphml`, extracts the Largest Connected Component (LCC), and performs:
+
+- weak/strong tie removal analysis,
+- centrality analysis,
+- centrality ranking correlation analysis,
+- optional temporal topic-shift analysis.
+
+---
+
+## 2. Rubric Coverage Summary
+
+### (Part 2, 30%) Weak/Strong Ties and LCC Dynamics
+
+Covered in `weaktie_analysis(LCC)`:
+
+- ties are ordered by weight to represent weak-to-strong and strong-to-weak removal,
+- two experiments are run:
+  - removing weakest ties first,
+  - removing strongest ties first,
+- after each single edge removal, LCC size is recomputed,
+- x-axis is fraction of ties removed,
+- y-axis is LCC size (number of nodes).
+
+Note: The implementation uses rank-based weak/strong definitions (by sorted weights). If explicit threshold-based counts are required by instructor policy, add a threshold rule (e.g., bottom/top quartile) and print those counts.
+
+### (Part 2, 35%) Centrality + Central Papers + Correlation + Interpretation
+
+Covered in `centrality_analysis(LCC)`:
+
+- computes degree, closeness, and betweenness centrality,
+- identifies top 10 papers for each metric,
+- outputs entries in `ID<TAB>Title` format,
+- converts centrality scores to ranking vectors,
+- computes Pearson correlation between metric rankings,
+- prints a correlation table,
+- identifies the lowest-correlation pair,
+- provides interpretation grounded in metric definitions.
+
+### (Part 2, 10%) Report Quality
+
+This markdown report provides:
+
+- clear method descriptions,
+- consistent structure by rubric item,
+- direct mapping from requirements to implementation,
+- interpretation guidance and limitations.
+
+### (Part 2, Optional Extra Credit, 50%) Research Evolution Analysis
+
+Covered in `research_evolution_analysis(G)`:
+
+- splits papers into before-2023 and after-2023 groups,
+- tokenizes title + abstract,
+- builds a shared global dictionary (vocabulary),
+- trains LDA models for both groups using same vocabulary,
+- obtains comparable topic-term matrices:
+  - `D` for pre-2023,
+  - `S` for post-2023,
+- computes topic shift using cosine similarity,
+- ranks potentially disappearing and emerging themes,
+- prints top words for contextual interpretation.
+
+---
+
+## 3. Detailed Methodology
+
+## 3.1 Data Loading and LCC Extraction
+
+1. Load graph from `aclbib.graphml`.
+2. Extract the largest connected component:
+   - this ensures path-based metrics (closeness, betweenness) are meaningful and comparable.
+
+---
+
+## 3.2 Weak vs Strong Tie Analysis
+
+### Definitions
+
+- Weak ties: lower edge weights (lower semantic similarity).
+- Strong ties: higher edge weights (higher semantic similarity).
+
+### Procedure
+
+1. Sort edges by weight ascending (`weak -> strong`).
+2. Create reversed order (`strong -> weak`).
+3. For each removal order:
+   - remove one edge at a time,
+   - recompute LCC size after each removal,
+   - record:
+     - fraction removed = removed_edges / total_edges,
+     - LCC size = number of nodes in current largest connected component.
+4. Plot both removal curves.
+
+### What this shows
+
+- If removing weak ties first rapidly fragments the network, weak ties are acting as bridges.
+- If removing strong ties first causes larger impact, strong ties are most critical to global cohesion.
+
+---
+
+## 3.3 Centrality Analysis
+
+### Metrics
+
+- Degree centrality: local connectivity prominence.
+- Closeness centrality: global proximity to all nodes.
+- Betweenness centrality: control over shortest-path flow.
+
+### Output
+
+- Top 10 papers for each metric, as `ID<TAB>Title`.
+- These lists identify influential papers under different notions of centrality.
+
+---
+
+## 3.4 Correlation Between Centrality Rankings
+
+The assignment requests correlation between rankings, not raw centrality values.
+
+### Procedure
+
+1. Convert each metric score map into rank vector (rank 1 = highest centrality).
+2. Compute Pearson correlation for each pair:
+   - Degree vs Closeness,
+   - Degree vs Betweenness,
+   - Closeness vs Betweenness.
+3. Build and print correlation table.
+4. Find lowest-correlation pair and print interpretation.
+
+### Interpretation principle
+
+Low correlation occurs when two metrics encode different structural roles, e.g.:
+
+- local popularity (degree) vs bridge control (betweenness),
+- global distance efficiency (closeness) vs brokerage roles (betweenness).
+
+---
+
+## 3.5 Optional Extra Credit: Research Evolution
+
+### Goal
+
+Trace thematic shifts in research trends before and after 2023.
+
+### Procedure
+
+1. Split nodes by publication year:
+   - before 2023,
+   - 2023 and later.
+2. Build documents from title + abstract.
+3. Tokenize and clean text.
+4. Create one shared vocabulary dictionary for both groups.
+5. Train two LDA models (same vocabulary, separate corpora).
+6. Extract topic-term matrices:
+   - `D` (pre-2023),
+   - `S` (post-2023).
+7. Compute shift score for each topic:
+   - shift = `1 - max cosine similarity` to any topic in opposite period.
+8. Rank:
+   - pre-2023 topics with highest shift (potentially disappearing),
+   - post-2023 topics with highest shift (potentially emerging).
+9. Print top words for each ranked topic.
+
+### Why this is valid
+
+- Shared vocabulary ensures `D` and `S` are directly comparable.
+- Cosine similarity captures semantic overlap between topic distributions.
+- Ranking by shift provides interpretable emergence/disappearance candidates.
+
+---
+
+## 4. Observed Results from Current Run
+
+The following results were generated by running:
+
+`python /home/mshahidul/readctrl/assignment_sc_2/code.py`
+
+### 4.1 Network and LCC Summary
+
+- LCC contains `1662` nodes and `26134` edges.
+- This indicates analysis is performed on a large connected core, suitable for centrality and connectivity experiments.
+
+### 4.2 Centrality Correlation Results
+
+Pearson correlation between centrality rankings:
+
+| Metric | Degree | Closeness | Betweenness |
+|---|---:|---:|---:|
+| Degree | 1.0000 | 0.9361 | 0.8114 |
+| Closeness | 0.9361 | 1.0000 | 0.7684 |
+| Betweenness | 0.8114 | 0.7684 | 1.0000 |
+
+- Lowest-correlation pair: **Closeness vs Betweenness** (`r = 0.7684`).
+- Interpretation: closeness captures global proximity, while betweenness captures shortest-path brokerage; these are related but not identical structural roles.
+
+### 4.3 Central Papers (Top-10) Highlights
+
+Across Degree, Closeness, and Betweenness top-10 lists, several papers repeatedly appear, including:
+
+- `ahuja-etal-2023-mega` (`{MEGA}: Multilingual Evaluation of Generative {AI}`),
+- `ding-etal-2020-discriminatively`,
+- `shin-etal-2020-autoprompt`,
+- `weller-etal-2020-learning`,
+- `qin-etal-2023-chatgpt`.
+
+This overlap suggests robust influence of these papers across local connectivity, global accessibility, and bridge-like structural importance.
+
+### 4.4 Optional Topic Evolution Results
+
+Topic matrices:
+
+- `D` (before 2023): shape `(5, 5000)`
+- `S` (after 2023): shape `(5, 5000)`
+
+Top potentially disappearing theme example:
+
+- Before Topic 4, shift `0.1912`, keywords:
+  `question, knowledge, event, performance, questions, task, graph, can`
+
+Top potentially emerging theme example:
+
+- After Topic 2, shift `0.1989`, keywords:
+  `llms, large, data, tasks, knowledge, reasoning, generation, performance`
+
+Interpretation: post-2023 topics show stronger emphasis on **LLMs**, reasoning, and generation-centered trends.
+
+---
+
+## 5. Limitations and Practical Notes
+
+- Weak/strong tie counts are currently implicit via sorted order; explicit threshold-based counts can be added if required.
+- Topic modeling quality depends on preprocessing and corpus size.
+- Interpretation quality in final report should connect output topics/central papers to real NLP/AI trends for stronger grading.
+
+---
+
+
+

assignment_sc_2/code.py

@@ -0,0 +1,320 @@
+# Author: Md. Shahidul Salim
+# Date: February 12, 2026
+
+import networkx as nx
+import pandas as pd
+from scipy.stats import pearsonr
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Extra credit imports
+from gensim.models.ldamodel import LdaModel
+from gensim.corpora.dictionary import Dictionary
+import nltk
+from nltk.tokenize import word_tokenize
+
+
+# Ensure NLTK resources are available
+try:
+    nltk.data.find("tokenizers/punkt")
+except LookupError:
+    nltk.download("punkt", quiet=True)
+
+try:
+    nltk.data.find("tokenizers/punkt_tab")
+except LookupError:
+    # Required by some NLTK versions.
+    nltk.download("punkt_tab", quiet=True)
+
+
+def _safe_int_year(value):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _rank_vector(scores, node_order):
+    """
+    Convert centrality scores to rank vectors (1 = highest centrality),
+    which matches the assignment requirement to correlate rankings.
+    """
+    series = pd.Series({node: scores[node] for node in node_order})
+    ranks = series.rank(method="average", ascending=False)
+    return [float(ranks[node]) for node in node_order]
+
+
+def _tokenize(text):
+    tokens = word_tokenize(text.lower())
+    return [tok for tok in tokens if tok.isalpha() and len(tok) > 2]
+
+
+# Part 1: Weak Tie Analysis
+def weaktie_analysis(LCC):
+    print("\n--- Starting Weak/Strong Tie Analysis ---")
+    edges_asc = sorted(
+        LCC.edges(data=True), key=lambda x: float(x[2].get("weight", 0.0))
+    )
+    edges_desc = list(reversed(edges_asc))
+    edge_weights = [float(data.get("weight", 0.0)) for _, _, data in edges_asc]
+    total_edges = len(edge_weights)
+
+    if total_edges == 0:
+        print("No ties found in the LCC; skipping weak/strong tie removal analysis.")
+        return
+
+    # Use median edge weight as the cutoff:
+    # weak ties: weight <= median, strong ties: weight > median.
+    median_weight = float(np.median(edge_weights))
+    weak_ties = [(u, v, d) for u, v, d in edges_asc if float(d.get("weight", 0.0)) <= median_weight]
+    strong_ties = [(u, v, d) for u, v, d in edges_asc if float(d.get("weight", 0.0)) > median_weight]
+
+    print(f"Total ties in LCC: {total_edges}")
+    print(f"Weak tie threshold (median weight): {median_weight:.4f}")
+    print(f"Number of weak ties (weight <= {median_weight:.4f}): {len(weak_ties)}")
+    print(f"Number of strong ties (weight > {median_weight:.4f}): {len(strong_ties)}")
+    print("Methodology: remove one tie per step and recompute LCC size after each removal.")
+
+    def get_lcc_sizes_by_single_removal(edge_list):
+        temp_graph = LCC.copy()
+        total_edges = len(edge_list)
+        fractions_removed = [0.0]
+        lcc_sizes = [len(max(nx.connected_components(temp_graph), key=len))]
+
+        for idx, (u, v, _) in enumerate(edge_list, start=1):
+            if temp_graph.has_edge(u, v):
+                temp_graph.remove_edge(u, v)
+
+            if temp_graph.number_of_nodes() > 0:
+                current_lcc = max(nx.connected_components(temp_graph), key=len)
+                lcc_sizes.append(len(current_lcc))
+            else:
+                lcc_sizes.append(0)
+            fractions_removed.append(idx / total_edges)
+
+        return fractions_removed, lcc_sizes
+
+    x_weak, y_weak = get_lcc_sizes_by_single_removal(edges_asc)
+    x_strong, y_strong = get_lcc_sizes_by_single_removal(edges_desc)
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(x_weak, y_weak, label="Removing Weakest First")
+    plt.plot(x_strong, y_strong, label="Removing Strongest First")
+    plt.xlabel("Fraction of Ties Removed")
+    plt.ylabel("LCC Size (Number of Nodes)")
+    plt.title("Impact of Weak vs Strong Tie Removal on LCC")
+    plt.legend()
+    plt.grid(True, linestyle="--", alpha=0.7)
+    plt.tight_layout()
+    plt.show()
+
+
+# Part 2: Centrality Analysis
+def centrality_analysis(LCC):
+    print("\n--- Starting Centrality Analysis ---")
+
+    degree = nx.degree_centrality(LCC)
+    closeness = nx.closeness_centrality(LCC)
+    betweenness = nx.betweenness_centrality(LCC)
+
+    nodes = list(LCC.nodes())
+    d_rank = _rank_vector(degree, nodes)
+    c_rank = _rank_vector(closeness, nodes)
+    b_rank = _rank_vector(betweenness, nodes)
+
+    corr_dc, _ = pearsonr(d_rank, c_rank)
+    corr_db, _ = pearsonr(d_rank, b_rank)
+    corr_cb, _ = pearsonr(c_rank, b_rank)
+
+    print("\nTable 1: Pearson Correlation between Centrality Measure Rankings")
+    table = pd.DataFrame(
+        {
+            "Metric": ["Degree", "Closeness", "Betweenness"],
+            "Degree": [1.0, corr_dc, corr_db],
+            "Closeness": [corr_dc, 1.0, corr_cb],
+            "Betweenness": [corr_db, corr_cb, 1.0],
+        }
+    )
+    print(table.to_string(index=False, float_format=lambda x: f"{x:.4f}"))
+
+    pair_corr = {
+        ("Degree", "Closeness"): corr_dc,
+        ("Degree", "Betweenness"): corr_db,
+        ("Closeness", "Betweenness"): corr_cb,
+    }
+    lowest_pair, lowest_value = min(pair_corr.items(), key=lambda x: x[1])
+    highest_pair, highest_value = max(pair_corr.items(), key=lambda x: x[1])
+    print(
+        f"\nLowest-correlation pair: {lowest_pair[0]} vs {lowest_pair[1]} "
+        f"(r = {lowest_value:.4f})"
+    )
+    print(
+        f"Highest-correlation pair: {highest_pair[0]} vs {highest_pair[1]} "
+        f"(r = {highest_value:.4f})"
+    )
+
+    explanations = {
+        frozenset(("Degree", "Closeness")): (
+            "Degree is local (immediate neighbors), while closeness captures "
+            "global shortest-path proximity to all nodes."
+        ),
+        frozenset(("Degree", "Betweenness")): (
+            "High degree does not always imply bridge-like behavior; betweenness "
+            "emphasizes control over shortest paths across communities."
+        ),
+        frozenset(("Closeness", "Betweenness")): (
+            "Closeness rewards overall proximity, while betweenness rewards "
+            "being on critical routes between other nodes."
+        ),
+    }
+    print(f"Interpretation: {explanations[frozenset(lowest_pair)]}")
+    print(
+        "Correlation quality note: values closer to 1 indicate stronger agreement "
+        "between ranking-based notions of node importance."
+    )
+
+    metrics = {"Degree": degree, "Closeness": closeness, "Betweenness": betweenness}
+    top_nodes_by_metric = {}
+    for metric_name, score_map in metrics.items():
+        print(f"\nTop 10 Papers for {metric_name} (ID<TAB>Title<TAB>Score):")
+        top_10 = sorted(score_map.items(), key=lambda x: x[1], reverse=True)[:10]
+        top_nodes_by_metric[metric_name] = [node_id for node_id, _ in top_10]
+        for node_id, _ in top_10:
+            title = LCC.nodes[node_id].get("title", "Unknown Title")
+            print(f"{node_id}\t{title}\t{score_map[node_id]:.6f}")
+
+    # Identify papers that appear in multiple top-10 lists (robust centrality evidence).
+    top_presence = {}
+    for metric_name, node_ids in top_nodes_by_metric.items():
+        for node_id in node_ids:
+            if node_id not in top_presence:
+                top_presence[node_id] = []
+            top_presence[node_id].append(metric_name)
+
+    repeated = [
+        (node_id, sorted(metric_names))
+        for node_id, metric_names in top_presence.items()
+        if len(metric_names) >= 2
+    ]
+    repeated.sort(key=lambda x: (-len(x[1]), x[0]))
+
+    if repeated:
+        print("\nPapers repeated across multiple centrality top-10 lists:")
+        for node_id, metric_names in repeated:
+            title = LCC.nodes[node_id].get("title", "Unknown Title")
+            print(f"{node_id}\t{title}\tappears in: {', '.join(metric_names)}")
+    else:
+        print("\nNo paper appears in more than one top-10 centrality list.")
+
+
+# Part 3: Research Evolution (Optional Extra Credit)
+def research_evolution_analysis(G, num_topics=5):
+    print("\n--- Optional: Research Evolution Analysis ---")
+
+    before_nodes = [n for n, d in G.nodes(data=True) if _safe_int_year(d.get("year")) < 2023]
+    after_nodes = [n for n, d in G.nodes(data=True) if _safe_int_year(d.get("year")) >= 2023]
+
+    before_docs = []
+    for n in before_nodes:
+        title = G.nodes[n].get("title", "")
+        abstract = G.nodes[n].get("abstract", "")
+        text = f"{title} {abstract}".strip()
+        tokens = _tokenize(text) if text else []
+        if tokens:
+            before_docs.append(tokens)
+
+    after_docs = []
+    for n in after_nodes:
+        title = G.nodes[n].get("title", "")
+        abstract = G.nodes[n].get("abstract", "")
+        text = f"{title} {abstract}".strip()
+        tokens = _tokenize(text) if text else []
+        if tokens:
+            after_docs.append(tokens)
+
+    if not before_docs or not after_docs:
+        print("Insufficient tokenized documents before/after 2023 for topic comparison.")
+        return
+
+    # Shared dictionary gives a single global vocabulary n for both matrices.
+    dictionary = Dictionary(before_docs + after_docs)
+    dictionary.filter_extremes(no_below=2, no_above=0.5, keep_n=5000)
+    if len(dictionary) == 0:
+        print("Vocabulary became empty after filtering; skipping extra credit analysis.")
+        return
+
+    before_corpus = [dictionary.doc2bow(doc) for doc in before_docs]
+    after_corpus = [dictionary.doc2bow(doc) for doc in after_docs]
+    before_corpus = [bow for bow in before_corpus if bow]
+    after_corpus = [bow for bow in after_corpus if bow]
+
+    if not before_corpus or not after_corpus:
+        print("Insufficient BOW documents after vocabulary filtering.")
+        return
+
+    lda_before = LdaModel(
+        corpus=before_corpus, id2word=dictionary, num_topics=num_topics, passes=10, random_state=42
+    )
+    lda_after = LdaModel(
+        corpus=after_corpus, id2word=dictionary, num_topics=num_topics, passes=10, random_state=42
+    )
+
+    # D and S correspond to topic-term probability matrices with shared vocabulary.
+    D = lda_before.get_topics()  # shape: (k1, n)
+    S = lda_after.get_topics()   # shape: (k2, n)
+    print(f"D matrix shape (before): {D.shape}")
+    print(f"S matrix shape (after): {S.shape}")
+
+    def cosine_similarity(a, b):
+        denom = np.linalg.norm(a) * np.linalg.norm(b)
+        if denom == 0:
+            return 0.0
+        return float(np.dot(a, b) / denom)
+
+    before_shift = []
+    for i in range(D.shape[0]):
+        sims = [cosine_similarity(D[i], S[j]) for j in range(S.shape[0])]
+        before_shift.append((i, 1.0 - max(sims) if sims else 1.0))
+
+    after_shift = []
+    for j in range(S.shape[0]):
+        sims = [cosine_similarity(S[j], D[i]) for i in range(D.shape[0])]
+        after_shift.append((j, 1.0 - max(sims) if sims else 1.0))
+
+    before_shift.sort(key=lambda x: x[1], reverse=True)
+    after_shift.sort(key=lambda x: x[1], reverse=True)
+
+    def top_words(topic_vec, topn=8):
+        idx = np.argsort(topic_vec)[::-1][:topn]
+        return ", ".join(dictionary[i] for i in idx)
+
+    print("\nPotentially disappearing themes (before topics with largest shift):")
+    for topic_id, shift_score in before_shift:
+        print(f"Before Topic {topic_id} | shift={shift_score:.4f} | {top_words(D[topic_id])}")
+
+    print("\nPotentially emerging themes (after topics with largest shift):")
+    for topic_id, shift_score in after_shift:
+        print(f"After Topic {topic_id} | shift={shift_score:.4f} | {top_words(S[topic_id])}")
+
+
+def main():
+    try:
+        G = nx.read_graphml("aclbib.graphml")
+    except Exception as e:
+        print(f"Error loading graph file: {e}")
+        return
+
+    LCC_nodes = max(nx.connected_components(G), key=len)
+    LCC = G.subgraph(LCC_nodes).copy()
+    print(
+        f"Network loaded. LCC contains {len(LCC.nodes())} nodes and "
+        f"{len(LCC.edges())} edges."
+    )
+
+    weaktie_analysis(LCC)
+    centrality_analysis(LCC)
+    research_evolution_analysis(G)
+
+
+if __name__ == "__main__":
+    main()

assignment_sc_2/rubric_points_explanation.md

@@ -0,0 +1,128 @@
+# Part 2 Rubric Explanation
+## 1) Weak/strong ties and LCC change during removal
+
+Tie strength is defined by edge `weight` in the LCC.
+
+- Weak ties: `weight <= median`
+- Strong ties: `weight > median`
+
+From the run output:
+I run two removal orders on the LCC:
+1. weakest to strongest  
+2. strongest to weakest
+
+After each edge removal, the LCC is recomputed and recorded (fraction removed vs. LCC size). This directly satisfies the rubric requirement to compare structural robustness under weak-first and strong-first deletions.
+Edges are removed one by one. After every removal, the LCC is recalculated and its size is stored as node count. The x-axis is fraction of ties removed, and the y-axis is LCC size.
+## 2) Centrality, top papers, and correlation analysis
+From the run output, the starting LCC is:
+Centrality is computed on the LCC using:
+- `1662` nodes
+- `26134` edges
+
+The code also prints exact weak/strong tie statistics:
+
+- total number of ties in the LCC: `26134`
+- weak-tie threshold (median weight): `0.6276`
+- number of weak ties (`weight <= 0.6276`): `13067`
+- number of strong ties (`weight > 0.6276`): `13067`
+
+So both tie classification and total weak/strong counts are explicitly reported before the stepwise removal process.
+
+## Centrality, central papers, interpretation, correlation
+
+Three centrality measures are computed on the LCC:
+- Degree
+- Closeness
+- Betweenness
+
+For each metric, top-10 papers are printed in `ID<TAB>Title` format. Correlation between ranking vectors is:
+For each one, top-10 papers are listed in `ID<TAB>Title` format.
+
+For correlation, I first convert centrality scores to ranking vectors and then compute Pearson correlation between rankings.
+
+Results from the run:
+| Metric | Degree | Closeness | Betweenness |
+|---|---:|---:|---:|
+| Degree | 1.0000 | 0.9361 | 0.8114 |
+| Closeness | 0.9361 | 1.0000 | 0.7684 |
+| Betweenness | 0.8114 | 0.7684 | 1.0000 |
+
+Lowest-correlation pair: **Closeness vs Betweenness (`0.7684`)**.
+- Degree vs Closeness: `0.9361`
+- Degree vs Betweenness: `0.8114`
+- Closeness vs Betweenness: `0.7684` (lowest)
+Interpretation: closeness captures global proximity, while betweenness captures bridge roles on shortest paths. A node can be globally near many others without being a major bridge, so these rankings diverge more than the other pairs.
+The output explicitly reports the lowest-correlation pair.
+Papers repeatedly appearing across top lists (e.g., `ahuja-etal-2023-mega`, `ding-etal-2020-discriminatively`, `qin-etal-2023-chatgpt`) indicate robust influence across multiple centrality notions.
+Lowest pair interpretation:
+## 3) Optional extra credit: theme shift before vs after 2023
+- closeness measures overall proximity in the graph
+- betweenness measures bridge role on shortest paths
+- these are related but different structural roles, so their rankings are less aligned
+I split papers into two periods (before 2023, and 2023+), build text from title+abstract, use one shared vocabulary, train LDA for both periods, and compare topic vectors by cosine similarity.
+Repeatedly central papers across top lists include:
+Output evidence:
+- `ahuja-etal-2023-mega`
+- `ding-etal-2020-discriminatively`
+- `shin-etal-2020-autoprompt`
+- `weller-etal-2020-learning`
+- `qin-etal-2023-chatgpt`
+
+The code also explicitly prints papers that appear in multiple metric top-10 lists (with metric names), which strengthens the evidence for identifying robustly central papers.
+
+
+## Optional Extra Credit (50%): Theme shift before and after 2023
+
+I compare two time groups: before 2023 and 2023+.
+
+Steps used:
+
+1. split papers by year  
+2. create text from title + abstract  
+3. tokenize and clean  
+4. build one shared vocabulary  
+5. train LDA for each period  
+6. extract topic-term matrices `D` (before) and `S` (after)  
+7. compare topics with cosine similarity and rank by shift score
+
+Run evidence:
+
+- `D` shape: `(5, 5000)`
+- `S` shape: `(5, 5000)`
+
+Examples from output:
+
+- emerging: `After Topic 2 | shift=0.1989 | llms, large, data, tasks, knowledge, reasoning, generation, performance`
+- disappearing: `Before Topic 4 | shift=0.1912 | question, knowledge, event, performance, questions, task, graph, can`
+
+This indicates a stronger LLM/reasoning focus in the later period.
+
+## Results (from current execution)
+
+- Network loaded successfully; LCC size is `1662` nodes and `26134` edges.
+- Weak/strong tie section reports:
+  - total ties: `26134`
+  - median-weight threshold: `0.6276`
+  - weak ties: `13067`
+  - strong ties: `13067`
+- Centrality ranking correlations:
+  - Degree-Closeness: `0.9361`
+  - Degree-Betweenness: `0.8114`
+  - Closeness-Betweenness: `0.7684`
+- Lowest-correlation pair: Closeness vs Betweenness.
+- Top-10 central papers were produced for all three metrics in `ID<TAB>Title` format.
+- Repeated papers across multiple centrality top-10 lists are explicitly reported.
+- Topic-evolution matrices were produced:
+  - `D` (before 2023): `(5, 5000)`
+  - `S` (2023+): `(5, 5000)`
+- Highest-shift emerging topic: After Topic 2 (`shift=0.1989`) with keywords around `llms`, `reasoning`, and `generation`.
+- Highest-shift disappearing topic: Before Topic 4 (`shift=0.1912`) with keywords around `question`, `knowledge`, and `graph`.
+- Topic matrices: `D` (before) = `(5, 5000)`, `S` (2023+) = `(5, 5000)`
+## Findings
+Conclusion: post-2023 topics shift toward LLM- and reasoning-centered themes, while earlier topics are more question/knowledge/graph-oriented.
+- The centrality rankings are strongly related overall, but not identical.
+- Degree and closeness are most aligned (`0.9361`), indicating that papers with strong local connectivity are often globally well-positioned.
+- Closeness and betweenness are least aligned (`0.7684`), showing that global proximity and bridge-role influence capture different node functions.
+- Repeated appearance of papers such as `ahuja-etal-2023-mega`, `ding-etal-2020-discriminatively`, and `qin-etal-2023-chatgpt` across multiple lists suggests robust influence across different centrality definitions.
+- Topic-shift outputs indicate post-2023 movement toward LLM-oriented and reasoning-heavy themes.
+- Overall, the network remains highly connected at baseline, and the analysis pipeline covers connectivity, influence, and temporal theme evolution in a consistent way.

assignment_sc_2/rubric_points_explanation.pdf

@@ -0,0 +1,137 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R /F3 5 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/Contents 12 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+5 0 obj
+<<
+/BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font
+>>
+endobj
+6 0 obj
+<<
+/Contents 13 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+7 0 obj
+<<
+/Contents 14 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+8 0 obj
+<<
+/Contents 15 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+9 0 obj
+<<
+/PageMode /UseNone /Pages 11 0 R /Type /Catalog
+>>
+endobj
+10 0 obj
+<<
+/Author (\(anonymous\)) /CreationDate (D:20260212152818-08'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260212152818-08'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (\(anonymous\)) /Trapped /False
+>>
+endobj
+11 0 obj
+<<
+/Count 4 /Kids [ 4 0 R 6 0 R 7 0 R 8 0 R ] /Type /Pages
+>>
+endobj
+12 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1311
+>>
+stream
+GauHL>ArL\'RoMS300IBA`?rd[6)fS[j-kh%spUrQbJhp^tU-[3mLRafC,t3BM.OAUacGn!ljDNhmn.n!?WE%]]LNUDfb^KR/dP$^&epA,FEt7]D:!,=(K'$$)U90A-C=?SWYPGn9=Z8Dn_P'/)5[q2T;;T\7#AJVDenb]q+m&PmRTfX'J8f_qeg.d#';*WXgf`(ZmqrK7Dn@PgLmA(d5Q_KP,NE)435?eN]!VHu,#]eJ]-7%FAhr?Z0kViSPO"Q!t@Cbr6bJ.DF3H_-*E.f\'e)#0ssTOVmph5^_s5%gTa#'rVQD?If91=euOT'C@_$"BMYT#'^6-5-PAp;O"t_CBe"_f,J9`pSN*68SS>=5:q+3F\]t"d.k8#P,?R\Gd9'q:Y;m>[-+FKbq$^JA(G).E(U=*%973N[)%gfK8Ho:%H.IeL1=(u&Dl_,#79btP["2:)%1OJ.*rt(XbATCMLZT<&>!rClsRq9]L(t%_f6]NOtA\rXugs6BI%@OU0-:)fnd!/B4GW8]FJo%hj]&XiTIAHJ([24!17'm?of(]+EJ&)5Ik9^ZQHZZ30#Qu_K]UcIKA,2J)6'3<.L''-6!M%f>aNDP(%u,5sKfspkUeNr`BAHEj>nm:$`f1^9JoCAo@bcfDl?iS-S8.6:9J%Er_G.e4Ps-Z8?Sm6EOU$\pWm@8JidW$M,ioG<#Q5<bYGEqkL),/9^m9'RoGfbr6tnIEG=]9[tmbZCD\U>BE49AJ)sK@q62''1U&\el6,#H;]-#2A^5,VD-&m*j=fQY/]WsdTjs1&?AQ>m9Q0JXgQj<@;W3_*5kH[X-[LA3e,]^8irp9>-t;I<Q@n1:s/&`dh1\<eR<([1/-S+">3DoB]Hb&9TgYTEHY.l@=/)$nQ7&&6GggB@M^H$@n.A>$99BbaQ1ghP9]*QMafr`H%j5X*jLH-qu"O0do#X)n_>Q,I>c:b/:7-d%;hUO5:%!ReuC;<fXgoS_Oh#`QiPlT#a,Rg9ZEgV&\chi4U>-!pGrbjf0o?TD?0&,C#XY#\cC;p/Cp_$*jdMNm6p?H`#Tuo1]o#qPLP/6huX#aD^Sq;%<4ePVpX-gC8lDdBlYK,pTW+U`;<cS6E#n.;L(QtL9Gi>/hOZ.Di4AD!Db5$(Pb)oC*Btj=g41<#@0-<=hWo+42.'OC+42S1_.rbfOPg*S\+XDXjSf%Pb\Ia]*[QSs%q/_:BM9s<[bRpanjb]>Y)sDa."aq=MdXWkPMe+'1Xh/H]+KUTo1h2g^D2.Pc0(jJir'MP8S"Fn`q!8K*C^DRR8%W;=ZeQ,:>u8iTbn?>l3+~>endstream
+endobj
+13 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1420
+>>
+stream
+GauHLgMZ%0&:Ml+bY%tL)gb$0'bgh?h$jp'Mf';ZoSY8[D/OJ(8];"_O7/19't$U_7R`gi&JJ*5F,"`r,Qih9RJED=!*;hgGg1cLYhT6M(HsCb_O'B;h&/;u%,F@>\-[d9$l1B#'70-6[FZDiP1]%+X>`SS8sl__'V3/4#:r+'WODsKZ1ER,]2r&)okMLXdok;2B:k&b@YI_Z_o1r#7/R]0nY[#16FB=b/?*l#Ds$-fDDEu`8HqGPj6KN)Tfc5(fl\kHdqf83KbpEIAkk.NZp>iY'aOu0$?P,?gjD"RB"rGKj_n5Vi7Gm(>SRO6>*Q!iN,oJm&PA`c&@)"!kA*gq/HcigicTAE2mD7-.f*e#O+Ns*.?PBN4bBJd.#Bp>[/,tf>I_^IeXCoOKA'a&Dj=%t&ADR&A6fY254Y5G]DXoG,&KFR"="uWVFKHeP\m*>Cd_QD%NsKjdK5OmL59m9$.0q'SLF3jhbV*kJ`jg2"J6;TNft;b%k*f'+3_;L;=VLU00`ciO;KIk;#),si#2FrT5c@mC!bH;)S[`GJg<B7qAqIt3:oWAB9@E^1P;&LhZ>Z8UD'CDHFV!W?kA$s%Ih_+2=NmkoH*E4pDb`W#9sC4(f]krC-G!(Dl`,XW4SBl\T2uJ8.4kP"Ou*(V`*2n9C$-ZPP6F`[.-%p:O2])T8DLVXJkkAe`tqAC<ZZ=LA`M=R1Mb"qp1F/:>IDbRXboC_)'LDO-J*f/Z:2aL=Ga\%pCE=%PB<dVXKS^G,N4VC-WXZ,^:#\7\DNp/=NK_7W<X*p@DUqk9X';B79-3R*&HFU7/Ge=qo>>qLOu:/<L:hS$s,HZQ&Xp(S-(q1mRQVcmsFbCVfToaebH%/;9nT;8@>uTlq1Y_[B5TG]Hj5ek%]mhW,ZUqDBR4c8Q[V,`"`9d:TDT4Z<k4(EdM,hinR?=kar'[*)!'D_'$`I,^3C9$\S.<1_8[leht);(=a7akn1W1/U[rq\sUnOVHMPdH5,)kT1\Z90_kd"[a5Io1?N/J#%.cCW5(O>]3s.2B=147OR+.:$%U<D"a*`H-TtJW+&b+]C3"L[%J5*J6jppT%rjN5VHt'D!>K^-jsM@$&Ek*M=%Pr:^j9;FMt=q1G+Ef'+eYPM;8V!baW7W<,HJqMiD#"Y[jPsZ>^fS/%6j/Zt4AT*MT4<5L=8,+>G.&PuA848/j%[=sQDe(5b'#0$E[UI^h]/MX"rbkA#5=W(K^IX7H_Oms*FLLDdK?XL@u&V3?XYcZ?0CF-d#UW;,LP?d+=Ph+I@AQ<S#l(6"JoB&@'&j0+I4,'iR:7dEDCoAtNW_'ado=%#/iITi:L!]dYVdLgl%@#`)1c+R#d+a")P3%Vj,,=)p2cf<sN@<uGO[WG;HHYW5deCq'C)`hsY^hSZ0Yo`gZiTb(Vk4T5/rWWu8:(@~>endstream
+endobj
+14 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1480
+>>
+stream
+GauI7?#T!f&;KZN/*<#_dPaie+RFm5O0d8,S0RDMdbaW99a:*M`&Y8)b%cG(NY<g_:V/>I77]!5j7+o]IV3I$*kb\S2ou)<VJu2I"6RLC"t[Cq@6/s8e$Et*Cbmj;0;I0\)%<:V-&\OcIRdalp"*r-7Ph988a5D`1SNDoBW(1P)_<jG)Un4:9`K_/&(\Z@oQn^)?t\Wh!PrZhHcpncFhV-eO1e`7cG7MJ_n]]R]$,hYP*`+(4K`+P>WEA%j+.&.+P%8U;902u_.Nj+-$(cWA-bC$J(-sX`3du^nSrY:)r85Z_s!%a@Nk_?i'duEL:hK@)'4PH[c._-i]L6c90j=!HGL>nn0A\H=Cka>*Ol<oE=H*^#+`Z-\0ta*G7?@-!-tjMg0d7E%TGr57FXs&8h7W2Bb5GY>@Z$T/S-jP(g2aW_P#$pk=1:22;H#8mh(Bl+3s35]Vc!^7Y;c-*MAJCP@5t`G<M(68ZCB.CKLnLJ4+-\F&q@R;H9*,9rrTEZkBAT@V.kQj9l350DPS$0o4kU!Q2Dlg=N>)HkIkD#s+<]6.E?+0KptD%rBl:aF,"_Aac2?QkIH(Q\.I14O8)jb^k6F-GM([I5`K2C^DA&8]i^s3p,4qB:bG-#tA3iAS'$,394C*C0OQuggcIfTYgGeO,[>M1Ij;=`I&*G<YStWjb.[8T11G^nS$oZ9HUSlf6ncER:@=:DKm63f1UFu/EA:ue39cO8'?L]lba\M<87a^oXE$4;6:ufc8k9-#M4.MhEsEGhCUd*SkFe"AP$`QmCf"#`baEH^2b=%hY^EJY+;id/ptOQoO6&trKi(]k;MX=EiA!ZU(<)RCDF:WGL35D6"fk^/qaF+U`uL]<s&\BDe1Z$gmUo#?bKtUFWa7e#D-)$jcrQSVAHdZk6ouh57!dGn(.r>ea^)e#Bc:L:!-Hd5uK.#5luGRUp=u[&[K2j&[K1kI^j^mgGhm?^S"_$[=h6EP^6\B-.GNN=d<RaT3u\d9+;)Jq@mKV76VD@[:,q%_iIn2Jk^+L&4:s>nNPU7EEF"VM0sU!A1jG&W2IMN7\:BtPfdZpdbmVCi/>1dfLWn99;]a(g`1j]'**_lJT=Ef0.p9RjpO3W//7B'bgJ5meG_.B_"1?PkBFmL;*Jm7`<%\23q/Y)A,OUjZeJ[O7-k&6_)a*d/X6X]1OJDm-SAW_kbt=3X.(4J`F(&i%+\Q9mVo<?05`SFWO:4/m]8C(QikqHKS+C_NXaSL'g9KE9/^8'5n_iW1kTr%N0dB>(N((L>i8@"+O'/_h'R/2NUk'F(5%bX222o^Gg`f$ma.+RH[dmI8E,%:LP:r;()QToBlms62nhU>G*GUr<C4Bf^"24H<nBQh*:5=[h.6P7="gZLF7X<rIFGk)Fn</XN35r"`kbO"#oj\nEmu83nJ+]Df:Hkc`"OFG*HLH2"eG1m*jeOV)P:V.;p0*_e*sol6pfa4Dd#=%mQ:P`rrT.HoW8~>endstream
+endobj
+15 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1219
+>>
+stream
+GauI69lK&M&;KZL'm"J#b8'-B-pS=!DAPI3=D[;u0=3R!\=lHIV!Rs8G:;.M\naBbMZs36J/WJ'5/VZf0F6ou28>=fi55nNqS[nQYf_L@-8Sae_/HBdQTKAH>XXcE*5r>PMtr%FMjWY_?()NeP>(BH=I4o>8f4\`Ed81rYH[l>LOSLLGR2XVGe('4bcfT.&)6G7pLpBROT`2EZ?APb.(M,X5mob2#aNeOSRD<hY75k>.s(Co11u$'hlCNMSMVDZ_<<,F7iTZ/Bo9c@]"WZiJb^/F@2Q09#H3R;6!\T5]"^dpQhBC.FY.'GUFrtl/?GK))e&*l]!C3^?D)Fl/O\_$9/O1U3B2M'+5rR1Tn2>3'Bf%efuU+KrAg[<%rj\:^5&7u"[(goVbLoW)dTKYUb$@%0a<9cC.4%&#ImBe_F?O81u(#\qfOZEm!SU=A:$oI'A6>e?<,'@O7%e3?Wt+K1O*&E*UcWq#s)\YNom[r4,I[34k,Q4?5:BBp71&-!.-#BZ([I$2&NY(.9Yd\Ti/a<?f0s-Nj!A1^5W)9>Nt<qj5!NS,cI6l;Rek,Y+E=E.PHBr7]TeB-q`n]"hg`BO`Cl"g4@Z^6qUBH_W?;gc>UEZhU!hFbI>N-c12HfK@l^C6u#A4?s=&9[LNR=XpDkK6c)DW?*IgWN5;-QK\XJS<l#eU]L$,_SnU3:e-$*kXV<*WC^G=;/O#.@UJm7I]ck=@\soN).W'n./kh$#B(+[LF*=n9s*CD3N&TsDLoR4$ad^Ub?7m:2-d9$G]8gmSb!0;5(8X7/c+6B+lNB[Mm-k@IaVn/G8"E_aVJN6Q14&jHIuI<ZXB(2@C^4@>/Z(I9Sq_kPpQKuWGoBu/r$RZJqeg8qSpT-O4!$ps-O"HU?IW>-J<%gg^FFgJF+1K2msNrh0VEb;0a(V+n_U"qT=[3mK^(.T:j)>dWgO\ujXk946m\hP_E,Gc4@fF,d@6S>I]C[:r`#DO1Nf*`b_-U]M`&,S=MrCmTAu5mH$_X=g/U!r3>`(9bK4oGS7FlhH5.#%Vg$plnFZ?CTT,TV?Y):ih7G!^ODjmC*>C^D:O)3]oENM&-b70nooAJ@I6LssU^.YpL,RAR[cBbX.-Pe@7X6[eO2A_f>EhH_qqghK\DhOIKnW,ubpSrFX*-H!W,Kc;dpYA?J7YQk$S>79r=:1gE1`S"G.odp^)t.;)DA9Y(8gW/(BA[Z!.BF"hu~>endstream
+endobj
+xref
+0 16
+0000000000 65535 f 
+0000000061 00000 n 
+0000000112 00000 n 
+0000000219 00000 n 
+0000000331 00000 n 
+0000000536 00000 n 
+0000000641 00000 n 
+0000000846 00000 n 
+0000001051 00000 n 
+0000001256 00000 n 
+0000001325 00000 n 
+0000001606 00000 n 
+0000001684 00000 n 
+0000003087 00000 n 
+0000004599 00000 n 
+0000006171 00000 n 
+trailer
+<<
+/ID 
+[<7b8e9ff53cd6975d4b04d04316e200e7><7b8e9ff53cd6975d4b04d04316e200e7>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 10 0 R
+/Root 9 0 R
+/Size 16
+>>
+startxref
+7482
+%%EOF

code/attribution_eval.py

@@ -0,0 +1,142 @@
+def return_prompts_attribution(reference_full_text, generated_summary, subclaims_json, difficulty_level):
+    return f'''
+### **SYSTEM / ROLE INSTRUCTION**
+
+You are a **medical factuality and attribution evaluator**.
+You will assess whether **unsupported subclaims** in a generated summary (those with `"result": 0"`) are *reasonable additions* based on the readability level (*easy / intermediate / hard*).
+
+The goal is to determine whether these **extra pieces of information** are acceptable simplifications or *hallucinations* that reduce factual faithfulness.
+
+---
+
+### **READABILITY & ATTRIBUTION GUIDELINES**
+
+| Level            | Audience                         | Content Goal                                                           | Allowable Additions                                                                |
+| :--------------- | :------------------------------- | :--------------------------------------------------------------------- | :--------------------------------------------------------------------------------- |
+| **Easy**         | General public                   | Simplify and clarify events                                            | Allow general background info or lay explanations, but not new facts or diagnoses. |
+| **Intermediate** | Educated layperson / med student | Add brief clarifications or causal context if consistent with the text | Allow inferred, non-contradictory context; avoid adding unconfirmed data.          |
+| **Hard**         | Medical professional             | Maintain factual precision                                             | No additions; everything must be supported by source text.                         |
+
+---
+
+### **INPUT FIELDS**
+
+**Reference full text:**
+{reference_full_text}
+
+**Generated summary ({difficulty_level}):**
+{generated_summary}
+
+**Subclaims and results:**
+{subclaims_json}
+
+---
+
+### **TASK INSTRUCTIONS**
+
+1. Focus only on subclaims with `"result": 0"` (not supported by the input text).
+2. For each unsupported subclaim:
+
+   * Judge whether adding it is **reasonable** for the given readability level.
+   * Choose one of: `"reasonable addition"`, `"unnecessary but harmless"`, `"misleading / hallucinated"`.
+   * Provide a **1–2 sentence justification** explaining your reasoning.
+3. After all evaluations, assign a **numerical attribution score (0–5)**:
+
+   * **5** = All additions are reasonable or harmless simplifications.
+   * **4** = Mostly reasonable; minor harmless additions.
+   * **3** = Some misleading or unjustified additions.
+   * **2** = Many factual inaccuracies.
+   * **1** = Serious hallucinations; distorts source meaning.
+   * **0** = Highly unfaithful; mostly invented content.
+4. End with an **overall explanation (3–5 sentences)** summarizing your reasoning and suggestions.
+
+---
+
+### **OUTPUT FORMAT (strict JSON)**
+
+```json
+{{
+  "evaluation_table": [
+    {{
+      "id": <subclaim_id>,
+      "subclaim": "<text>",
+      "evaluation": "<reasonable addition | unnecessary but harmless | misleading / hallucinated>",
+      "explanation": "<short justification>"
+    }}
+  ],
+  "attribution_score": <0-5>,
+  "overall_explanation": "<concise summary of your judgment>"
+}}
+```
+'''
+from openai import OpenAI
+import json
+file_path = "/home/mshahidul/api_new.json"
+with open(file_path, "r") as file:
+    api_keys = json.load(file)
+
+openai_api_key = api_keys.get("openai")
+
+client = OpenAI(api_key=openai_api_key)
+def openai_return(prompt):
+    response = client.chat.completions.create(
+        model="gpt-5-mini",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    cleaned_response = response.choices[0].message.content.strip().replace("```json", "").replace("```", "")
+    return json.loads(cleaned_response)
+
+
+import json
+file_path = "/home/mshahidul/readctrl/data/training_data_subclaim_verifier/synthetic_data_es_subclaims_100.json"
+
+with open(file_path, 'r') as f:
+    synthetic_data = json.load(f)
+
+file_path_qwen3_32B = "/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json"
+
+with open(file_path_qwen3_32B, 'r') as f:
+    qwen3_32B_results = json.load(f)
+
+# dict_keys(['id', 'full_text', 'ref_summary', 'readability_versions'])
+# print(f"Full text: {synthetic_data[0]['full_text']}")
+import os
+
+res=[]
+temp=""
+save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/resonability_check_100_gpt5_attribution.json"
+if os.path.exists(save_path):
+    with open(save_path, 'r') as f:
+        res = json.load(f)
+print(f"Resuming from {len(res)} entries")
+existing_check=set((entry['id'], entry['difficulty_level']) for entry in res)
+import tqdm
+for ind in tqdm.tqdm(range(len(res),100)):
+    for version in ["easy", "intermediate", "hard"]:
+        if (synthetic_data[ind]['id'], version) in existing_check:
+            print(f"Skipping {synthetic_data[ind]['id']}, {version}")
+            continue
+        ref_full_text_summary = (f"{synthetic_data[ind]['full_text']}")
+        generated_summary = (f"{synthetic_data[ind]['readability_versions'][version]['text']}")
+        subclaims_results = (f"{qwen3_32B_results[ind]['attribution']['results']}")
+        prompt = return_prompts_attribution(ref_full_text_summary, generated_summary, subclaims_results, version)
+        try:
+            ans=openai_return(prompt)
+            res.append({
+                "id": synthetic_data[ind]['id'],
+                "difficulty_level": version,
+                "response": ans
+            })
+            
+            if len(res)%2==0:
+                print(f"Completed {len(res)} out of 300")
+                with open(save_path, 'w') as outfile:
+                    json.dump(res, outfile, indent=2)
+        except Exception as e:
+            print(f"Error at index {ind}, version {version}: {e}")
+
+with open(save_path, 'w') as outfile:
+    json.dump(res, outfile, indent=2)

code/attribution_evalV2.py

@@ -0,0 +1,222 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "4"
+
+import json
+import torch
+from unsloth import FastLanguageModel
+import tqdm
+
+
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache the fine-tuned model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=8192,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+def build_inference_prompt(
+    reference_full_text,
+    generated_summary,
+    subclaim_id,
+    subclaim_text,
+    subclaim_result,
+    difficulty_level
+):
+    """
+    Build a standardized inference prompt for single‑subclaim evaluation.
+    Use after fine‑tuning to assess new examples consistently.
+    """
+
+    inference_prompt = f"""
+### **SYSTEM / ROLE INSTRUCTION**
+
+You are a **medical factuality and attribution evaluator**.
+You will analyze one subclaim from a generated medical summary.
+
+Each subclaim includes a `"result"` flag:
+- `1` → Supported by the reference text (no reasonableness check required)
+- `0` → Unsupported by the reference text (evaluate scope and validity)
+
+Your task is to decide, for unsupported subclaims, whether the new information
+is a *reasonable addition* given the specified readability level:
+**easy**, **intermediate**, or **hard**.
+
+---
+
+### **READABILITY GUIDELINES**
+
+| Level | Audience | Style | Allowable Additions |
+| :-- | :-- | :-- | :-- |
+| **Easy (FH 70–100)** | General public | Simple, concrete | Broad clarifications only; no factual innovations |
+| **Intermediate (FH 50–69)** | Educated nonspecialist | Moderate precision | Limited clarifications consistent with the text |
+| **Hard (FH 0–49)** | Professionals | Formal, technical | Must be strictly supported by evidence |
+
+---
+
+### **INPUT**
+
+Readability Level: {difficulty_level}
+
+Reference Full Text:
+{reference_full_text}
+
+Generated Summary:
+{generated_summary}
+
+Subclaim Info:
+{{
+  "subclaim_id": {subclaim_id},
+  "subclaim": "{subclaim_text}",
+  "result": {subclaim_result}
+}}
+
+---
+
+### **TASK INSTRUCTIONS**
+
+- If `"result": 1"`, respond with `"not_applicable"` and justify briefly
+  (e.g., *"supported, no evaluation required"*).
+- If `"result": 0"`, classify reasonableness:
+  - `"reasonable"` → legitimate simplification consistent with the readability level
+  - `"partially_reasonable"` → benign rephrasing
+  - `"unreasonable"` → misleading, speculative, or contradicted by the source
+
+Provide a **short 1–2 sentence justification**.
+
+---
+
+### **EXPECTED OUTPUT (JSON ONLY)**
+
+```json
+{{
+  "evaluation": {{
+    "subclaim_id": {subclaim_id},
+    "subclaim": "{subclaim_text}",
+    "result": {subclaim_result},
+    "reasonableness": "<reasonable | partially_reasonable | unreasonable | not_applicable>",
+    "justification": "<brief justification>"
+  }}
+}}
+""".strip()
+
+    return inference_prompt
+def infer_attribution_reasonableness(prompt: str, model_path: str):
+    """Run inference using the fine-tuned model with attribution prompt."""
+    model, tokenizer = load_finetuned_model(model_path)
+
+    messages = [{"role": "user", "content": prompt + "\n"}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=150,
+            temperature=0.2,
+            top_p=0.8,
+            top_k=5,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+    if "</think>" in output_text:
+        output_text = output_text.split("</think>")[-1].strip().replace("```json", "").replace("```", "")
+
+    try:
+        parsed = json.loads(output_text)
+    except Exception:
+        parsed = output_text
+    return parsed
+
+
+file_synth = "/home/mshahidul/readctrl/data/training_data_subclaim_verifier/synthetic_data_es_subclaims_100.json"
+file_qwen_results = "/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json"
+save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/attribution_resonability_results_100_qwen3-32B_v2.json"
+
+with open(file_synth, 'r') as f:
+    synthetic_data = json.load(f)
+with open(file_qwen_results, 'r') as f:
+    qwen3_32B_results = json.load(f) 
+dict1={}
+for item in qwen3_32B_results:
+    version=item['version']
+    dict1[(item['id'], version)] = item['attribution']['results']
+ 
+res = []
+if os.path.exists(save_path):
+    with open(save_path, 'r') as f:
+        res = json.load(f)
+print(f"🔁 Resuming from {len(res)} entries")
+
+existing = set((e["id"], e["difficulty_level"]) for e in res)
+
+for ind in tqdm.tqdm(range(0, 100)):
+    entry = synthetic_data[ind]
+    
+    for level in ["easy", "intermediate", "hard"]:
+        subclaims_results = dict1[(entry["id"], level)]
+        if (entry["id"], level) in existing:
+            print(f"⏭️ Skipping {entry['id']} ({level})")
+            continue
+
+        ref_full_text = entry["full_text"]
+        generated_summary = entry["readability_versions"][level]["text"]
+        temp=[]
+        for subclaim in subclaims_results:
+            subclaim_id = subclaim['subclaim']['id']
+            subclaim_text = subclaim['subclaim']['subclaim']
+            subclaim_result = subclaim['result']
+            prompt = build_inference_prompt(
+                ref_full_text,
+                generated_summary,
+                subclaim_id,
+                subclaim_text,
+                subclaim_result,
+                level
+            )
+            if subclaim_result=="1":
+                temp.append({
+                "subclaim_id": subclaim_id,
+                "subclaim_text": subclaim_text,
+                "response": "not_applicable"
+            })
+                continue
+            response = infer_attribution_reasonableness(prompt,"/home/mshahidul/readctrl_model/qwen3-32B_subclaims-attribution_resonability_check_8kCtx_v1")
+            temp.append({
+                "subclaim_id": subclaim_id,
+                "subclaim_text": subclaim_text,
+                "response": response
+            })
+        res.append({
+            "id": entry["id"],
+            "difficulty_level": level,
+            "results": temp
+        })
+        if len(res) % 10 == 0:
+            with open(save_path, 'w') as f:
+                json.dump(res, f, indent=2, ensure_ascii=False)
+            print(f"💾 Saved after {len(res)} entries")
+
+with open(save_path, 'w') as f:
+    json.dump(res, f, indent=2, ensure_ascii=False)
+
+

code/combine_docid_labels.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+EXPECTED_LABELS = (
+    "low_health_literacy",
+    "intermediate_health_literacy",
+    "proficient_health_literacy",
+)
+
+
+@dataclass
+class MergeStats:
+    total_rows: int = 0
+    total_doc_ids: int = 0
+    missing_label_rows: int = 0
+    unexpected_labels: int = 0
+    doc_ids_missing_some_labels: int = 0
+    doc_ids_fulltext_mismatch: int = 0
+    doc_ids_summary_mismatch: int = 0
+    doc_ids_fulltext_subclaims_mismatch: int = 0
+    doc_ids_summary_subclaims_mismatch: int = 0
+
+
+def _pick_first_non_empty(values: List[Optional[str]]) -> Optional[str]:
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value
+    for value in values:
+        if value is not None:
+            return value
+    return None
+
+
+def _normalize_text(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        return str(value)
+    return value
+
+
+def _normalize_string_list(value: Any) -> Optional[Tuple[str, ...]]:
+    if value is None:
+        return None
+    if not isinstance(value, list):
+        return (str(value),)
+    normalized: List[str] = []
+    for item in value:
+        if item is None:
+            continue
+        if isinstance(item, str):
+            normalized.append(item.strip())
+        else:
+            normalized.append(str(item).strip())
+    return tuple(normalized)
+
+
+def combine_by_doc_id(rows: List[Dict[str, Any]], keep_all_fields_per_label: bool = True) -> Tuple[List[Dict[str, Any]], MergeStats]:
+    stats = MergeStats(total_rows=len(rows))
+
+    grouped: Dict[int, List[Dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        doc_id = row.get("doc_id")
+        if doc_id is None:
+            continue
+        grouped[int(doc_id)].append(row)
+
+    stats.total_doc_ids = len(grouped)
+
+    combined: List[Dict[str, Any]] = []
+
+    for doc_id in sorted(grouped.keys()):
+        bucket = grouped[doc_id]
+
+        labels_map: Dict[str, Dict[str, Any]] = {}
+        fulltexts: List[Optional[str]] = []
+        summaries: List[Optional[str]] = []
+        fulltext_subclaims_sets: List[Optional[Tuple[str, ...]]] = []
+        summary_subclaims_sets: List[Optional[Tuple[str, ...]]] = []
+
+        for row in bucket:
+            label = row.get("label")
+            if not label:
+                stats.missing_label_rows += 1
+                continue
+            if label not in EXPECTED_LABELS:
+                stats.unexpected_labels += 1
+
+            fulltexts.append(_normalize_text(row.get("fulltext")))
+            summaries.append(_normalize_text(row.get("summary")))
+            fulltext_subclaims_sets.append(_normalize_string_list(row.get("fulltext_subclaims")))
+            summary_subclaims_sets.append(_normalize_string_list(row.get("summary_subclaims")))
+
+            label_payload: Dict[str, Any]
+            if keep_all_fields_per_label:
+                # Shared within a doc_id; keep them only once at top-level
+                label_payload = {
+                    k: v
+                    for k, v in row.items()
+                    if k
+                    not in (
+                        "doc_id",
+                        "label",
+                        "fulltext",
+                        "summary",
+                        "fulltext_subclaims",
+                        "summary_subclaims",
+                    )
+                }
+            else:
+                label_payload = {
+                    "diff_label_texts": row.get("diff_label_texts"),
+                    "diff_label_subclaims": row.get("diff_label_subclaims"),
+                }
+
+            labels_map[str(label)] = label_payload
+
+        chosen_fulltext = _pick_first_non_empty(fulltexts)
+        chosen_summary = _pick_first_non_empty(summaries)
+
+        chosen_fulltext_subclaims: Optional[List[str]] = None
+        for items in fulltext_subclaims_sets:
+            if items:
+                chosen_fulltext_subclaims = list(items)
+                break
+        chosen_summary_subclaims: Optional[List[str]] = None
+        for items in summary_subclaims_sets:
+            if items:
+                chosen_summary_subclaims = list(items)
+                break
+
+        distinct_fulltexts = {t.strip() for t in fulltexts if isinstance(t, str) and t.strip()}
+        distinct_summaries = {t.strip() for t in summaries if isinstance(t, str) and t.strip()}
+        if len(distinct_fulltexts) > 1:
+            stats.doc_ids_fulltext_mismatch += 1
+        if len(distinct_summaries) > 1:
+            stats.doc_ids_summary_mismatch += 1
+
+        distinct_fulltext_subclaims = {t for t in fulltext_subclaims_sets if t}
+        distinct_summary_subclaims = {t for t in summary_subclaims_sets if t}
+        if len(distinct_fulltext_subclaims) > 1:
+            stats.doc_ids_fulltext_subclaims_mismatch += 1
+        if len(distinct_summary_subclaims) > 1:
+            stats.doc_ids_summary_subclaims_mismatch += 1
+
+        missing_some = any(lbl not in labels_map for lbl in EXPECTED_LABELS)
+        if missing_some:
+            stats.doc_ids_missing_some_labels += 1
+
+        combined.append(
+            {
+                "doc_id": doc_id,
+                "fulltext": chosen_fulltext,
+                "fulltext_subclaims": chosen_fulltext_subclaims,
+                "summary": chosen_summary,
+                "summary_subclaims": chosen_summary_subclaims,
+                "labels": labels_map,
+            }
+        )
+
+    return combined, stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Combine per-label rows into a single object per doc_id. "
+            "Input is a JSON array with repeated doc_id for different labels."
+        )
+    )
+    parser.add_argument(
+        "--input",
+        required=True,
+        help="Path to input JSON file (list of rows)",
+    )
+    parser.add_argument(
+        "--output",
+        default=None,
+        help="Path to output JSON file. Default: same folder with *_by_docid.json suffix",
+    )
+    parser.add_argument(
+        "--minimal",
+        action="store_true",
+        help="Only keep diff_label_texts/diff_label_subclaims/fulltext_subclaims/summary_subclaims per label.",
+    )
+
+    args = parser.parse_args()
+    input_path = Path(args.input)
+    output_path = Path(args.output) if args.output else input_path.with_name(input_path.stem + "_by_docid.json")
+
+    rows = json.loads(input_path.read_text(encoding="utf-8"))
+    if not isinstance(rows, list):
+        raise SystemExit("Input JSON must be a list")
+
+    combined, stats = combine_by_doc_id(rows, keep_all_fields_per_label=not args.minimal)
+
+    output_path.write_text(
+        json.dumps(combined, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+    print("Wrote:", str(output_path))
+    print(
+        "Stats:",
+        json.dumps(
+            {
+                "total_rows": stats.total_rows,
+                "total_doc_ids": stats.total_doc_ids,
+                "missing_label_rows": stats.missing_label_rows,
+                "unexpected_labels": stats.unexpected_labels,
+                "doc_ids_missing_some_labels": stats.doc_ids_missing_some_labels,
+                "doc_ids_fulltext_mismatch": stats.doc_ids_fulltext_mismatch,
+                "doc_ids_summary_mismatch": stats.doc_ids_summary_mismatch,
+                "doc_ids_fulltext_subclaims_mismatch": stats.doc_ids_fulltext_subclaims_mismatch,
+                "doc_ids_summary_subclaims_mismatch": stats.doc_ids_summary_subclaims_mismatch,
+            },
+            indent=2,
+        ),
+    )
+
+
+if __name__ == "__main__":
+    main()

code/convert_awq.py

@@ -0,0 +1,35 @@
+import os
+# Set GPU environment variables
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+from awq import AutoAWQForCausalLM
+from transformers import AutoTokenizer
+
+# Paths
+model_path = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx_v2-bf16"
+quant_path = "/home/mshahidul/readctrl_model/full_model/qwen3-32B-subclaims-support-check-8b_ctx_AWQ"
+
+# Quantization configuration
+quant_config = {
+    "zero_point": True,
+    "q_group_size": 128,
+    "w_bit": 4,
+    "version": "GEMM"
+}
+
+# Load model and tokenizer
+print("Loading model...")
+model = AutoAWQForCausalLM.from_pretrained(model_path, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+
+# Quantize
+print("Starting quantization (this may take a while)...")
+# AutoAWQ uses a default calibration dataset (pile-val) 
+model.quantize(tokenizer, quant_config=quant_config)
+
+# Save quantized model
+print(f"Saving quantized model to {quant_path}...")
+model.save_quantized(quant_path)
+tokenizer.save_pretrained(quant_path)
+
+print("Quantization Complete!")

code/finetune-inference/convert_fp16.py

@@ -0,0 +1,60 @@
+import os
+import argparse
+# python /home/mshahidul/readctrl/code/finetune-inference/convert_fp16.py \
+# --model_path /home/mshahidul/readctrl_model/qwen3-32B_subclaims-attribution_resonability_check_8kCtx_v1
+# --save_path /home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-attribution_resonability_check_8kCtx_v1_BF16_merged 
+# --cuda_device 2
+parser = argparse.ArgumentParser()
+parser.add_argument("--model_path", type=str, required=True,
+                    help="Path to the fine-tuned model/adapter to convert.")
+parser.add_argument("--save_path", type=str, required=True,
+                    help="Path to save the converted BF16 model.")
+parser.add_argument("--msl", type=int, default=8192,
+                    help="Maximum sequence length for the model.")
+parser.add_argument("--cuda_device", type=str, default="2",
+                    help="CUDA device index to use.")
+args = parser.parse_args()
+
+# Set your GPU visibility as you did in your script
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda_device
+import torch
+from unsloth import FastLanguageModel
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+# Path to your current fine-tuned model/adapter
+# MODEL_PATH = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+
+# Path where you want to save the BF16 version
+# SAVE_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims_BF16_merged"
+
+def convert_and_save():
+    print(f"Loading model from: {args.model_path}")
+    
+    # 1. Load the model
+    # We explicitly set dtype=torch.bfloat16 to ensure the base is loaded correctly
+    # load_in_4bit must be False to allow for a clean 16-bit merge
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=args.model_path,
+        max_seq_length=args.msl,
+        dtype=torch.bfloat16, 
+        load_in_4bit=False,
+    )
+
+    print(f"Saving merged BF16 model to: {args.save_path}")
+    
+    # 2. Save using save_pretrained_merged
+    # 'merged_16bit' will save as float16 or bfloat16 depending on the loaded dtype.
+    # Since we loaded with torch.bfloat16, this will save in bfloat16.
+    model.save_pretrained_merged(
+        args.save_path,
+        tokenizer,
+        save_method="merged_16bit",
+    )
+    
+    print("Conversion complete. You can now use this path for vLLM or standard inference.")
+
+if __name__ == "__main__":
+    convert_and_save()

code/interface/annotators_v5.py

@@ -0,0 +1,266 @@
+import gradio as gr
+import json
+import os
+from datetime import datetime
+
+# --- PATH CONFIGURATION ---
+# DATA_PATH = "/home/mshahidul/readctrl/data/synthetic_dataset_diff_labels/syn_data_with_gs_summary_en_0_20.json"
+DATA_PATH = "/home/mshahidul/readctrl/data/synthetic_dataset_diff_labels/syn_data_diff_labels_bn_0_80.json"
+SAVE_ROOT = "/home/mshahidul/readctrl/data/annotators_validate_data_Bangla_(0_80)"
+os.makedirs(SAVE_ROOT, exist_ok=True)
+
+# --- UI HTML COMPONENTS (Kept same as original) ---
+GUIDE_HTML = """
+<div style="background-color: #f9f9f9; padding: 15px; border-left: 6px solid #4CAF50; border-radius: 4px; margin-bottom: 20px;">
+    <h3>Rating Guide: Medical Text Difficulty</h3>
+    <table style="width:100%; border-collapse: collapse; text-align: left;">
+        <tr style="background-color: #e8f5e9;">
+            <th style="padding: 8px; border: 1px solid #ddd;">Score</th>
+            <th style="padding: 8px; border: 1px solid #ddd;">Description</th>
+        </tr>
+        <tr><td><b>1</b></td><td><b>Very Easy:</b> Simple words, no medical jargon.</td></tr>
+        <tr><td><b>2</b></td><td><b>Easy:</b> Conversational medical terms.</td></tr>
+        <tr><td><b>3</b></td><td><b>Moderate:</b> Standard patient education material.</td></tr>
+        <tr><td><b>4</b></td><td><b>Hard:</b> Significant technical jargon.</td></tr>
+        <tr><td><b>5</b></td><td><b>Very Hard:</b> Specialist-level / Academic.</td></tr>
+    </table>
+</div>
+"""
+
+EXAMPLES_HTML = """
+<div style="background-color: #ffffff; padding: 15px; border: 1px solid #ddd; border-radius: 4px;">
+    <h3 style="color: #2e7d32;">Reference Examples</h3>
+    <div style="display: flex; gap: 15px;">
+        <div style="flex: 1; background-color: #f1f8e9; padding: 10px; border-radius: 4px;">
+            <h4>Level 1-2</h4>
+            <p>"She had a kidney problem... a big blood clot blocked veins in her brain."</p>
+        </div>
+        <div style="flex: 1; background-color: #ffebee; padding: 10px; border-radius: 4px;">
+            <h4>Level 4-5</h4>
+            <p>"Idiopathic NS inaugurated by cerebral venous thrombosis extended to the right jugular vein."</p>
+        </div>
+    </div>
+</div>
+"""
+def parse_diff_label_texts(raw_value):
+    """
+    Parse diff_label_texts that may be:
+    - dict (already parsed)
+    - JSON string
+    - Python-dict-like string (single quotes)
+    """
+    if isinstance(raw_value, dict):
+        return raw_value
+
+    if not isinstance(raw_value, str):
+        return {}
+
+    text = raw_value.strip()
+    if not text:
+        return {}
+
+    # Prefer strict JSON first; fall back to Python literal parsing.
+    try:
+        parsed = json.loads(text)
+        return parsed if isinstance(parsed, dict) else {}
+    except json.JSONDecodeError:
+        pass
+
+    try:
+        parsed = ast.literal_eval(text)
+        return parsed if isinstance(parsed, dict) else {}
+    except (ValueError, SyntaxError):
+        return {}
+import ast
+# --- DATA LOADING ---
+def normalize_dataset(raw_dataset):
+    """
+    Normalize different dataset layouts into a flat queue where each item has:
+    index, id, label, generated_summary.
+    """
+    normalized = []
+
+    for item in raw_dataset:
+ 
+
+        # New layout: {"diff_label_texts": {label: text, ...}}
+        diff_label_texts = item.get("diff_label_texts")
+        if isinstance(diff_label_texts, dict):
+            for label, text in diff_label_texts.items():
+                normalized.append({
+                    "index": item.get("index"),
+                    "id": item.get("id"),
+                    "label": label,
+                    "generated_summary": text
+                })
+            
+        else:
+            diff_label_texts = parse_diff_label_texts(item.get("diff_label_texts"))
+            for label, text in diff_label_texts.items():
+                normalized.append({
+                    "index": item.get("index"),
+                    "id": item.get("id"),
+                    "label": label,
+                    "generated_summary": text
+                })
+            
+
+
+    return normalized
+
+
+if os.path.exists(DATA_PATH):
+    with open(DATA_PATH, "r", encoding="utf-8") as f:
+        RAW_DATASET = json.load(f)
+        FULL_DATASET = normalize_dataset(RAW_DATASET)
+        print(len(FULL_DATASET))
+    assert FULL_DATASET, f"No valid items found in dataset: {DATA_PATH}"
+else:
+    assert False, f"Data file not found at {DATA_PATH}"
+
+# --- PERSISTENCE HELPERS ---
+def get_user_dir(username):
+    clean_username = "".join([c for c in username if c.isalnum() or c in (' ', '_', '-')]).strip() or "anonymous"
+    return os.path.join(SAVE_ROOT, clean_username)
+
+def save_state(user_dir, state_dict):
+    with open(os.path.join(user_dir, "state.json"), "w") as f:
+        json.dump(state_dict, f, indent=4)
+
+def load_state(user_dir):
+    state_path = os.path.join(user_dir, "state.json")
+    if os.path.exists(state_path):
+        with open(state_path, "r") as f:
+            return json.load(f)
+    return None
+
+# --- LOGIC FUNCTIONS ---
+def get_current_ui_values(state):
+    """Helper to get UI values for the current index, including previous ratings if they exist."""
+    idx = state['current_index']
+    current_item = state['queue'][idx]
+    
+    # Check if we already have a rating for this specific index
+    existing_rating = 3  # Default
+    for res in state['results']:
+        if res['queue_position'] == idx:
+            existing_rating = res['rating']
+            break
+            
+    progress = f"Item {idx + 1} of {len(state['queue'])}"
+    return current_item['generated_summary'], progress, existing_rating
+
+def start_session(username):
+    if not username:
+        gr.Warning("Please enter a username!")
+        return [gr.update()] * 5
+
+    user_dir = get_user_dir(username)
+    os.makedirs(user_dir, exist_ok=True)
+    existing_state = load_state(user_dir)
+    
+    if existing_state:
+        gr.Info(f"Welcome back! Resuming from item {existing_state['current_index'] + 1}.")
+        state = existing_state
+    else:
+        state = {
+            "username": username,
+            "current_index": 0,
+            "queue": list(FULL_DATASET),
+            "results": [],
+            "completed": False
+        }
+        save_state(user_dir, state)
+
+    text, progress, rating = get_current_ui_values(state)
+    return (gr.update(visible=False), gr.update(visible=True), text, progress, rating, state)
+
+def submit_rating(doc_slider, state):
+    if state is None: return "", "Error", 3, 3, None
+
+    user_dir = get_user_dir(state['username'])
+    idx = state['current_index']
+    current_item = state['queue'][idx]
+    
+    # Update existing rating if editing, otherwise append
+    new_result = {
+        "queue_position": idx,
+        "index": current_item.get('index', idx),
+        "doc_id": current_item.get('id', current_item.get('index', 'no_id')),
+        "label": current_item.get('label', 'no_label'),
+        "rating": doc_slider,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Logic to overwrite existing rating for this index
+    state['results'] = [r for r in state['results'] if r['queue_position'] != idx]
+    state['results'].append(new_result)
+    state['results'].sort(key=lambda x: x['queue_position']) # Keep sorted
+
+    if idx + 1 < len(state['queue']):
+        state['current_index'] += 1
+        save_state(user_dir, state)
+        # Save results file
+        with open(os.path.join(user_dir, "annotation_results.json"), "w") as f:
+            json.dump(state['results'], f, indent=4)
+            
+        text, progress, rating = get_current_ui_values(state)
+        return text, progress, rating, state
+    else:
+        state['completed'] = True
+        save_state(user_dir, state)
+        return "✅ ALL TASKS COMPLETED", "Status: Finished", 1, state
+
+def go_back(state):
+    if state is None or state['current_index'] <= 0:
+        gr.Warning("Already at the first item.")
+        return [gr.update()] * 3 + [state]
+
+    state['current_index'] -= 1
+    text, progress, rating = get_current_ui_values(state)
+    return text, progress, rating, state
+
+# --- UI INTERFACE ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    session_state = gr.State()
+
+    gr.Markdown("# Medical Text Readability Annotation")
+    
+    with gr.Accordion("Instructions & Calibration", open=False):
+        gr.HTML(GUIDE_HTML)
+        gr.HTML(EXAMPLES_HTML)
+
+    with gr.Column(visible=True) as intro_box:
+        username_input = gr.Textbox(label="Enter Your Name/ID", placeholder="e.g., user_101")
+        btn_start = gr.Button("Start / Resume Annotation", variant="primary")
+
+    with gr.Column(visible=False) as task_box:
+        progress_label = gr.Label(label="Overall Progress")
+        doc_display = gr.Textbox(interactive=False, lines=12, label="Medical Text")
+        doc_slider = gr.Slider(1, 5, step=1, label="Difficulty (1=Easy, 5=Hard)", value=3)
+        
+        with gr.Row():
+            btn_prev = gr.Button("⬅️ Previous", variant="secondary")
+            btn_submit = gr.Button("Submit & Next ➡️", variant="primary")
+
+    # --- EVENT HANDLERS ---
+    btn_start.click(
+        fn=start_session, 
+        inputs=[username_input],
+        outputs=[intro_box, task_box, doc_display, progress_label, doc_slider, session_state]
+    )
+    
+    btn_submit.click(
+        fn=submit_rating,
+        inputs=[doc_slider, session_state],
+        outputs=[doc_display, progress_label, doc_slider, session_state]
+    )
+
+    btn_prev.click(
+        fn=go_back,
+        inputs=[session_state],
+        outputs=[doc_display, progress_label, doc_slider, session_state]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/annotators_v5_tran_quality.py

@@ -0,0 +1,198 @@
+import gradio as gr
+import json
+import os
+from datetime import datetime
+
+# --- PATH CONFIGURATION ---
+# DATA_PATH = "/home/mshahidul/readctrl/data/synthetic_dataset_diff_labels/syn_data_with_gs_summary_en_0_20.json"
+DATA_PATH = "/home/mshahidul/readctrl/data/data_annotator_data/syn_data_diff_labels_en_0_80.json"
+SAVE_ROOT = "/home/mshahidul/readctrl/data/annotators_validate_data_(20_80)"
+os.makedirs(SAVE_ROOT, exist_ok=True)
+
+# --- UI HTML COMPONENTS (Kept same as original) ---
+GUIDE_HTML = """
+<div style="background-color: #f9f9f9; padding: 15px; border-left: 6px solid #4CAF50; border-radius: 4px; margin-bottom: 20px;">
+    <h3>Rating Guide: Medical Text Difficulty</h3>
+    <table style="width:100%; border-collapse: collapse; text-align: left;">
+        <tr style="background-color: #e8f5e9;">
+            <th style="padding: 8px; border: 1px solid #ddd;">Score</th>
+            <th style="padding: 8px; border: 1px solid #ddd;">Description</th>
+        </tr>
+        <tr><td><b>1</b></td><td><b>Very Easy:</b> Simple words, no medical jargon.</td></tr>
+        <tr><td><b>2</b></td><td><b>Easy:</b> Conversational medical terms.</td></tr>
+        <tr><td><b>3</b></td><td><b>Moderate:</b> Standard patient education material.</td></tr>
+        <tr><td><b>4</b></td><td><b>Hard:</b> Significant technical jargon.</td></tr>
+        <tr><td><b>5</b></td><td><b>Very Hard:</b> Specialist-level / Academic.</td></tr>
+    </table>
+</div>
+"""
+
+EXAMPLES_HTML = """
+<div style="background-color: #ffffff; padding: 15px; border: 1px solid #ddd; border-radius: 4px;">
+    <h3 style="color: #2e7d32;">Reference Examples</h3>
+    <div style="display: flex; gap: 15px;">
+        <div style="flex: 1; background-color: #f1f8e9; padding: 10px; border-radius: 4px;">
+            <h4>Level 1-2</h4>
+            <p>"She had a kidney problem... a big blood clot blocked veins in her brain."</p>
+        </div>
+        <div style="flex: 1; background-color: #ffebee; padding: 10px; border-radius: 4px;">
+            <h4>Level 4-5</h4>
+            <p>"Idiopathic NS inaugurated by cerebral venous thrombosis extended to the right jugular vein."</p>
+        </div>
+    </div>
+</div>
+"""
+
+# --- DATA LOADING ---
+if os.path.exists(DATA_PATH):
+    with open(DATA_PATH, "r") as f:
+        FULL_DATASET = json.load(f)
+        FULL_DATASET=FULL_DATASET[60:]
+else:
+    assert False, f"Data file not found at {DATA_PATH}"
+
+# --- PERSISTENCE HELPERS ---
+def get_user_dir(username):
+    clean_username = "".join([c for c in username if c.isalnum() or c in (' ', '_', '-')]).strip() or "anonymous"
+    return os.path.join(SAVE_ROOT, clean_username)
+
+def save_state(user_dir, state_dict):
+    with open(os.path.join(user_dir, "state.json"), "w") as f:
+        json.dump(state_dict, f, indent=4)
+
+def load_state(user_dir):
+    state_path = os.path.join(user_dir, "state.json")
+    if os.path.exists(state_path):
+        with open(state_path, "r") as f:
+            return json.load(f)
+    return None
+
+# --- LOGIC FUNCTIONS ---
+def get_current_ui_values(state):
+    """Helper to get UI values for the current index, including previous ratings if they exist."""
+    idx = state['current_index']
+    current_item = state['queue'][idx]
+    
+    # Check if we already have a rating for this specific index
+    existing_rating = 3  # Default
+    for res in state['results']:
+        if res['queue_position'] == idx:
+            existing_rating = res['rating']
+            break
+            
+    progress = f"Item {idx + 1} of {len(state['queue'])}"
+    return current_item['generated_summary'], progress, existing_rating
+
+def start_session(username):
+    if not username:
+        gr.Warning("Please enter a username!")
+        return [gr.update()] * 5
+
+    user_dir = get_user_dir(username)
+    os.makedirs(user_dir, exist_ok=True)
+    existing_state = load_state(user_dir)
+    
+    if existing_state:
+        gr.Info(f"Welcome back! Resuming from item {existing_state['current_index'] + 1}.")
+        state = existing_state
+    else:
+        state = {
+            "username": username,
+            "current_index": 0,
+            "queue": list(FULL_DATASET),
+            "results": [],
+            "completed": False
+        }
+        save_state(user_dir, state)
+
+    text, progress, rating = get_current_ui_values(state)
+    return (gr.update(visible=False), gr.update(visible=True), text, progress, rating, state)
+
+def submit_rating(doc_slider, state):
+    if state is None: return "", "Error", 3, 3, None
+
+    user_dir = get_user_dir(state['username'])
+    idx = state['current_index']
+    current_item = state['queue'][idx]
+    
+    # Update existing rating if editing, otherwise append
+    new_result = {
+        "queue_position": idx,
+        "doc_id": current_item.get('index', 'no_id'), 
+        "label": current_item.get('label', 'no_label'),
+        "rating": doc_slider,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Logic to overwrite existing rating for this index
+    state['results'] = [r for r in state['results'] if r['queue_position'] != idx]
+    state['results'].append(new_result)
+    state['results'].sort(key=lambda x: x['queue_position']) # Keep sorted
+
+    if idx + 1 < len(state['queue']):
+        state['current_index'] += 1
+        save_state(user_dir, state)
+        # Save results file
+        with open(os.path.join(user_dir, "annotation_results.json"), "w") as f:
+            json.dump(state['results'], f, indent=4)
+            
+        text, progress, rating = get_current_ui_values(state)
+        return text, progress, rating, state
+    else:
+        state['completed'] = True
+        save_state(user_dir, state)
+        return "✅ ALL TASKS COMPLETED", "Status: Finished", 1, state
+
+def go_back(state):
+    if state is None or state['current_index'] <= 0:
+        gr.Warning("Already at the first item.")
+        return [gr.update()] * 3 + [state]
+
+    state['current_index'] -= 1
+    text, progress, rating = get_current_ui_values(state)
+    return text, progress, rating, state
+
+# --- UI INTERFACE ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    session_state = gr.State()
+
+    gr.Markdown("# Medical Text Readability Annotation")
+    
+    with gr.Accordion("Instructions & Calibration", open=False):
+        gr.HTML(GUIDE_HTML)
+        gr.HTML(EXAMPLES_HTML)
+
+    with gr.Column(visible=True) as intro_box:
+        username_input = gr.Textbox(label="Enter Your Name/ID", placeholder="e.g., user_101")
+        btn_start = gr.Button("Start / Resume Annotation", variant="primary")
+
+    with gr.Column(visible=False) as task_box:
+        progress_label = gr.Label(label="Overall Progress")
+        doc_display = gr.Textbox(interactive=False, lines=12, label="Medical Text")
+        doc_slider = gr.Slider(1, 5, step=1, label="Difficulty (1=Easy, 5=Hard)", value=3)
+        
+        with gr.Row():
+            btn_prev = gr.Button("⬅️ Previous", variant="secondary")
+            btn_submit = gr.Button("Submit & Next ➡️", variant="primary")
+
+    # --- EVENT HANDLERS ---
+    btn_start.click(
+        fn=start_session, 
+        inputs=[username_input],
+        outputs=[intro_box, task_box, doc_display, progress_label, doc_slider, session_state]
+    )
+    
+    btn_submit.click(
+        fn=submit_rating,
+        inputs=[doc_slider, session_state],
+        outputs=[doc_display, progress_label, doc_slider, session_state]
+    )
+
+    btn_prev.click(
+        fn=go_back,
+        inputs=[session_state],
+        outputs=[doc_display, progress_label, doc_slider, session_state]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/instr

@@ -0,0 +1,107 @@
+
+
+#  gr.Markdown("# 🏥 Health Literacy Subclaim Annotation\n## Texts labeled as low health literacy include less information than those labeled as intermediate health literacy, and intermediate health literacy texts include less information than proficient health literacy texts.\nSome key information has already been pre-selected to ensure that each label contains a minimum required amount of information. If you believe additional information should be included for a given label, please select the corresponding checkboxes.")
+#     with gr.Accordion("📖 Read Instructions First", open=True):
+#                 gr.Markdown("""
+
+# ### Step 1: Read the Text Type
+
+# You will see **one text at a time**. At the top, the interface will tell you whether this is:
+
+# * **Full Text**, or
+# * **Gold Summary**
+
+# Please read the text carefully before selecting any subclaims.
+
+# ---
+
+# ### Step 2: Review the Subclaims
+
+# Below the text, you will see a list of **subclaims**.
+# Each subclaim represents one piece of information from the text.
+
+# **Example subclaims:**
+
+# * ☐ The patient has high blood pressure.
+# * ☐ The patient is 62 years old.
+# * ☐ The patient experiences chest pain when breathing.
+# * ☐ A chest X-ray shows pneumonia in the right lung.
+# * ☐ The COVID test result is negative.
+
+# ---
+
+# ### Step 3: Annotate for Each Health Literacy Label
+
+# You must select subclaims **separately for each label**.
+
+# #### Low Health Literacy
+
+# Select **only the most essential information** needed for basic understanding.
+
+# **Good selection example:**
+
+# * ☑ The patient has high blood pressure.
+# * ☑ A chest X-ray shows pneumonia in the right lung.
+
+# **Do NOT include:**
+
+# * Exact age
+# * Test details unless critical
+# * Extra clinical findings
+
+# ➡ Coverage should be **lowest**.
+
+# ---
+
+# #### Intermediate Health Literacy
+
+# Select the **core information plus some helpful details**.
+
+# **Good selection example:**
+
+# * ☑ The patient has high blood pressure.
+# * ☑ The patient experiences chest pain when breathing.
+# * ☑ A chest X-ray shows pneumonia in the right lung.
+# * ☑ The COVID test result is negative.
+
+# ➡ Coverage should be **more than low**, but **less than proficient**.
+
+# ---
+
+# #### Proficient Health Literacy
+
+# Select **all clinically relevant information**.
+
+# **Good selection example:**
+
+# * ☑ The patient has high blood pressure.
+# * ☑ The patient is 62 years old.
+# * ☑ The patient experiences chest pain when breathing.
+# * ☑ A chest X-ray shows pneumonia in the right lung.
+# * ☑ The COVID test result is negative.
+
+# ➡ Coverage should be **highest**.
+
+# ---
+
+# ### Step 4: Check Information Percentages
+
+# The interface shows the **percentage of selected information** for each label.
+
+# A correct annotation should follow this order:
+
+# > **Low % < Intermediate % < Proficient %**
+
+# ⚠️ If low health literacy has more information than intermediate or proficient, you will see a warning. Please revise your selections.
+
+# ---
+
+# ### Key Reminder
+
+# * Some subclaims may already be pre-selected to ensure **minimum required information**.
+# * Only add new subclaims if you believe they are appropriate for that label.
+# * When finished, submit and proceed to the **next instance**.
+
+
+
+#                 """)

code/interface/instructions

@@ -0,0 +1,43 @@
+# 📖 Annotation Guide: Health Literacy
+Welcome! Your task is to determine which pieces of information (subclaims) belong in different versions of a health text based on **Health Literacy levels**.
+## * **Pre-selections:** Some boxes are checked by default—these are the "minimum required" facts.
+## Sometimes, generated summaries with different labels contain all the information present in the gold summary.
+## In the case of full text, the amount of information included depends on the readability level. Texts with a low readability label contain less information than those with a proficient readability label.
+## Consistency: Any information listed under 'Low' should automatically also appear under 'Intermediate' and 'Proficient.
+---
+
+### 🟢 Step 1: Identify the Source
+Check the top of the interface. You are working with either:
+* **Full Text:** The original clinical document.
+* **Gold Summary:** A condensed version of the facts.
+
+### 🔍 Step 2: Review the Subclaims
+Subclaims are individual facts extracted from the text. 
+> *Example: "The patient is 62 years old" or "The X-ray shows pneumonia."*
+
+---
+
+### ⚖️ Step 3: Annotate by Literacy Level
+You must select checkboxes for **three different audiences**. The goal is to create a "ladder" of information:
+
+| Level | Goal | Inclusion Strategy |
+| :--- | :--- | :--- |
+| **🟢 Low** | **Basic Survival** | Only the absolute essentials. What must they know to stay safe? |
+| **🔵 Intermediate** | **Clear Context** | Core info + helpful context. Explain the "what" and "why." |
+| **🟣 Proficient** | **Full Detail** | Everything. Include clinical findings, ages, and specific test data. |
+
+---
+
+### 📊 Step 4: The Golden Rule (Check Your Percentages)
+To ensure high-quality data, your selections **must** follow this hierarchy:
+# **Low % < Intermediate % < Proficient %**
+
+⚠️ **Wait for the Green Light:** If the **Low** level contains more information than **Intermediate**, the system will show a warning. Adjust your checkboxes until the percentages flow from lowest to highest.
+
+---
+
+### 💡 Quick Tips
+
+* **Clinical Relevance:** For **Proficient**, include specific numbers (e.g., "140/90 mmHg") that might be too technical for **Low**.
+
+**Ready to start?** Scroll down to begin your first annotation.

code/interface/interface_correction_data.py

@@ -0,0 +1,210 @@
+import gradio as gr
+import json
+import os
+from openai import OpenAI
+
+# --- CONFIGURATION ---
+DATA_PATH = '/home/mshahidul/readctrl/data/annotators_validate_data_(20_80)/code/correction_evaluation_full_text_with_gs.json'
+SAVE_DIR = '/home/mshahidul/readctrl/data/annotators_validate_data_(20_80)/correction_data/'
+PROMPT_TEMPLATE_PATH = "/home/mshahidul/readctrl/prompts/syn_data_gen_diff_label_mod.txt"
+API_FILE_PATH = "/home/mshahidul/api_new.json"
+
+# --- INITIALIZATION ---
+# Load API Key
+with open(API_FILE_PATH, "r") as f:
+    api_keys = json.load(f)
+    client = OpenAI(api_key=api_keys["openai"])
+
+# Load Prompt Template
+with open(PROMPT_TEMPLATE_PATH, "r") as f:
+    PROMPT_TEMPLATE = f.read()
+
+def load_data():
+    if os.path.exists(DATA_PATH):
+        with open(DATA_PATH, 'r') as f:
+            return json.load(f)
+    return []
+
+DATA = load_data()
+
+# --- AI LOGIC ---
+def call_ai_processor(index, full_text, gold_summary):
+    """Calls GPT-5 (OpenAI API) and extracts the text for the current label."""
+    try:
+        item = DATA[index]
+        target_label = item.get('ai_label') # e.g., "low_health_literacy"
+        
+        # Note: 'source_language' should ideally be in your JSON. 
+        # Defaulting to English if not found.
+        source_lang = item.get('language', 'English') 
+
+        # Format the prompt
+        prompt = (PROMPT_TEMPLATE
+                  .replace("<<<FULL_TEXT>>>", full_text)
+                  .replace("<<<SOURCE_LANGUAGE>>>", source_lang)
+                  .replace("<<<GOLD_SUMMARY>>>", gold_summary)
+                  .replace("<<<TARGET_LABEL>>>", target_label))
+        # import ipdb; ipdb.set_trace()
+
+        response = client.chat.completions.create(
+            model="gpt-5-mini", # Change to "gpt-5" or specific model name when available
+            messages=[{"role": "user", "content": prompt}],
+            response_format={ "type": "json_object" }
+        )
+
+        content = json.loads(response.choices[0].message.content)
+        
+        # Extract only the text for the specific label we are currently editing
+        # target_label usually matches the keys: low_health_literacy, etc.
+        refined_text = content.get(target_label, "Error: Label not found in AI response.")
+        return refined_text
+    
+    except Exception as e:
+        return f"AI Error: {str(e)}"
+
+# --- DATA HELPERS ---
+def get_user_save_path(username):
+    clean_name = "".join([c for c in username if c.isalpha() or c.isdigit()]).rstrip()
+    return os.path.join(SAVE_DIR, f"final_corrected_{clean_name}.json")
+
+def load_user_results(username):
+    path = get_user_save_path(username)
+    if os.path.exists(path):
+        with open(path, 'r') as f:
+            return json.load(f)
+    return []
+
+def get_record(index):
+    if 0 <= index < len(DATA):
+        item = DATA[index]
+        ai_label = item.get('ai_label', '')
+        ai_text = item.get('diff_label_texts', {}).get(ai_label, "Text not found")
+        gold_summary = item.get('summary', '') # Added this for the AI prompt
+        
+        anno_info = (
+            f"Plaban: {item.get('category_plaban')} (Rating: {item.get('rating_plaban')})\n"
+            f"Mahi: {item.get('category_mahi')} (Rating: {item.get('rating_mahi')})\n"
+            f"Shama: {item.get('category_shama')} (Rating: {item.get('rating_shama')})"
+        )
+        
+        return (
+            item.get('doc_id'),
+            anno_info,
+            ai_label.replace("_", " ").title(),
+            item.get('fulltext'),
+            ai_text,
+            index,
+            gold_summary
+        )
+    return None
+
+def login_user(username):
+    if not username or len(username.strip()) == 0:
+        return gr.update(visible=True), gr.update(visible=False), 0, None, "", "", "", "", ""
+    
+    existing_data = load_user_results(username)
+    start_index = len(existing_data)
+    
+    if start_index >= len(DATA):
+        return gr.update(visible=False), gr.update(visible=True), start_index, "Finished!", "All caught up!", "No more data.", "No more data.", "", ""
+
+    record = get_record(start_index)
+    return (
+        gr.update(visible=False), 
+        gr.update(visible=True),  
+        start_index,              
+        record[0], record[1], record[2], record[3], record[4], record[6] 
+    )
+
+def save_and_next(username, index, corrected_text, is_ok):
+    user_results = load_user_results(username)
+    current_item = DATA[index]
+    
+    # If the user didn't type anything in manual_correction and hit "AI Text is OK", use original
+    final_text = current_item.get('diff_label_texts', {}).get(current_item['ai_label']) if is_ok else corrected_text
+    
+    result_entry = {
+        "doc_id": current_item['doc_id'],
+        "ai_label": current_item['ai_label'],
+        "status": "Approved" if is_ok else "Manually Corrected/AI Refined",
+        "final_text": final_text,
+        "original_ai_text": current_item.get('diff_label_texts', {}).get(current_item['ai_label'])
+    }
+    
+    user_results.append(result_entry)
+    
+    with open(get_user_save_path(username), 'w') as f:
+        json.dump(user_results, f, indent=4)
+    
+    next_index = index + 1
+    if next_index < len(DATA):
+        res = get_record(next_index)
+        return list(res) + [""] 
+    else:
+        return [None, "Finished!", "Finished!", "No more data.", "No more data.", next_index, "No more data.", ""]
+
+# --- GRADIO UI ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📝 AI Label Correction Interface (v2 with GPT-Refinement)")
+    
+    current_idx = gr.State(0)
+    user_session = gr.State("")
+    gold_summary_hidden = gr.State("") # To hold the summary for the AI prompt
+
+    with gr.Row() as login_row:
+        with gr.Column(scale=1):
+            user_input = gr.Textbox(label="Enter Username to Resume", placeholder="e.g., Shahidul")
+            btn_login = gr.Button("Start Annotation", variant="primary")
+
+    with gr.Column(visible=False) as main_container:
+        with gr.Row():
+            with gr.Column(scale=1):
+                doc_id_display = gr.Textbox(label="Document ID", interactive=False)
+                ai_label_display = gr.Label(label="Target AI Label")
+                annotator_stats = gr.Textbox(label="Human Annotator Ratings", lines=4, interactive=False)
+            
+            with gr.Column(scale=2):
+                full_text_display = gr.Textbox(label="Source Full Text", lines=10, interactive=False)
+
+        with gr.Row():
+            with gr.Column():
+                ai_generated_text = gr.Textbox(label="Original AI Text", lines=6, interactive=False)
+            with gr.Column():
+                manual_correction = gr.Textbox(label="AI Refinement / Manual Correction", placeholder="AI generated text will appear here...", lines=6)
+                btn_ai_check = gr.Button("✨ Check & Refine through AI", variant="secondary")
+
+        with gr.Row():
+            btn_ok = gr.Button("✅ Original Text is OK", variant="primary")
+            btn_fix = gr.Button("💾 Save Current Correction/AI Text", variant="stop")
+
+    # --- LOGIC ---
+    btn_login.click(
+        fn=login_user,
+        inputs=[user_input],
+        outputs=[login_row, main_container, current_idx, doc_id_display, annotator_stats, ai_label_display, full_text_display, ai_generated_text, gold_summary_hidden]
+    ).then(fn=lambda username: username, inputs=[user_input], outputs=[user_session])
+
+    # AI Regeneration Logic
+    btn_ai_check.click(
+        fn=call_ai_processor,
+        inputs=[current_idx, full_text_display, gold_summary_hidden],
+        outputs=[manual_correction]
+    )
+
+    action_inputs = [user_session, current_idx, manual_correction]
+    action_outputs = [doc_id_display, annotator_stats, ai_label_display, full_text_display, ai_generated_text, current_idx, gold_summary_hidden, manual_correction]
+
+    btn_ok.click(
+        fn=lambda user, idx, txt: save_and_next(user, idx, txt, True),
+        inputs=action_inputs,
+        outputs=action_outputs
+    )
+
+    btn_fix.click(
+        fn=lambda user, idx, txt: save_and_next(user, idx, txt, False),
+        inputs=action_inputs,
+        outputs=action_outputs
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/t.py

@@ -0,0 +1,8 @@
+from gradio_client import Client
+
+client = Client("https://23833b5a465382100f.gradio.live/")
+result = client.predict(
+	message="Hello!!",
+	api_name="/chat_predict"
+)
+print(result)

code/interface/translate_gemma.py

@@ -0,0 +1,78 @@
+import gradio as gr
+from openai import OpenAI
+import base64
+import io
+
+# Initialize the client pointing to your vLLM server
+client = OpenAI(
+    base_url="http://172.16.34.29:8006/v1",
+    api_key="vllm-token", 
+)
+
+def encode_image_to_base64(image):
+    """Converts PIL image to raw base64 string (no data-uri prefix)."""
+    if image is None:
+        return None
+    buffered = io.BytesIO()
+    image.save(buffered, format="JPEG")
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+def run_translation(source_code, target_code, text_input, image_input):
+    # Construct the base dictionary
+    # The schema requires all these keys to be present in the mapping
+    payload = {
+        "source_lang_code": source_code,
+        "target_lang_code": target_code,
+        "text": None,
+        "image": None
+    }
+
+    if image_input is not None:
+        payload["type"] = "image"
+        payload["image"] = encode_image_to_base64(image_input)
+    else:
+        if not text_input.strip():
+            return "Please provide text or an image."
+        payload["type"] = "text"
+        payload["text"] = text_input
+
+    try:
+        # Crucial: We pass the payload as the single item in the content list
+        response = client.chat.completions.create(
+            model="translate_gemma",
+            messages=[{
+                "role": "user", 
+                "content": [payload]  # vLLM expects exactly [ { ... } ]
+            }],
+            max_tokens=500
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"⚠️ Error: {str(e)}"
+
+# --- Gradio UI Layout ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🌍 TranslateGemma 27B")
+    gr.Markdown("Corrected schema for vLLM inference.")
+    
+    with gr.Row():
+        src_code = gr.Textbox(label="Source Language Code", value="en")
+        tgt_code = gr.Textbox(label="Target Language Code", value="bn")
+
+    with gr.Row():
+        with gr.Column():
+            text_box = gr.Textbox(label="Text Input", placeholder="Type English here...", lines=5)
+            image_box = gr.Image(label="Image Input", type="pil")
+            submit_btn = gr.Button("Translate", variant="primary")
+        
+        with gr.Column():
+            output_box = gr.Textbox(label="Bangla Translation", interactive=False, lines=10)
+
+    submit_btn.click(
+        fn=run_translation,
+        inputs=[src_code, tgt_code, text_box, image_box],
+        outputs=output_box
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/translation_quality.py

@@ -0,0 +1,253 @@
+import gradio as gr
+import json
+import os
+from datetime import datetime
+
+
+def sanitize_username(username: str) -> str:
+    """Make username safe for filesystem paths."""
+    if not username:
+        return ""
+    username = username.strip()
+    safe = "".join(ch for ch in username if ch.isalnum() or ch in ("_", "-"))
+    return safe
+
+def get_user_session_file(username):
+    safe = sanitize_username(username)
+    return os.path.join(SAVE_DIR, f"ratings_{safe}.json")
+
+language="Bengali"
+if language=="Chinese":
+    language_code="ch"
+elif language=="Hindi":
+    language_code="hi"
+elif language=="Bengali":
+    language_code="be"
+else:
+    assert False, "Unsupported language"
+
+
+# Load translation dataset
+TRANSLATION_PATH = f"/home/mshahidul/readctrl/data/translated_data/translation_english2bangla_v1.json"
+with open(TRANSLATION_PATH, "r", encoding="utf-8") as f:
+    translation_dataset = json.load(f)[:50]
+
+# Load source dataset for English fulltext
+SRC_PATH = f"/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_en.json"
+with open(SRC_PATH, "r", encoding="utf-8") as f:
+    src_dataset = json.load(f)[:50]
+
+# Merge datasets by index (assume same order)
+dataset = [
+    {
+        "src_fulltext": src_dataset[i]["fulltext"],
+        "translated_fulltext": translation_dataset[i]["fulltext_translated"]["translated_medical_note"],
+        "id": translation_dataset[i]["id"]
+    }
+    for i in range(min(len(src_dataset), len(translation_dataset)))
+]
+
+# 2. Configuration for saving
+SAVE_DIR = f"/home/mshahidul/readctrl/data/translated_data/rating_info/{language_code}"
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+SESSION_FILE = None  # Will be set per user
+
+RATING_OPTIONS = [
+    ("1 - Poor (Incorrect/Nonsense)", 1),
+    ("2 - Fair (Understandable but awkward)", 2),
+    ("3 - Good (Accurate/Perfect)", 3)
+]
+
+custom_css = """
+.small-header { font-size: 0.85rem !important; font-weight: 600; margin-bottom: -10px; color: #555; }
+.nav-row { background-color: #f9f9f9; padding: 10px; border-radius: 8px; margin-bottom: 15px; }
+"""
+
+def save_rating_to_json(data_item, username):
+    session_file = get_user_session_file(username)
+    output_data = []
+    if os.path.exists(session_file):
+        with open(session_file, "r", encoding="utf-8") as f:
+            try:
+                output_data = json.load(f)
+            except json.JSONDecodeError:
+                output_data = []
+
+    # Backward/forward compatibility: support either list[record] or dict with "records".
+    if isinstance(output_data, dict):
+        records = output_data.get("records", [])
+    else:
+        records = output_data if isinstance(output_data, list) else []
+
+    # Keep a single record per index (update if it already exists).
+    new_index = data_item.get("index")
+    updated = False
+    for i, rec in enumerate(records):
+        if isinstance(rec, dict) and rec.get("index") == new_index:
+            records[i] = data_item
+            updated = True
+            break
+    if not updated:
+        records.append(data_item)
+
+    payload = {
+        "username": sanitize_username(username) or username,
+        "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "records": records,
+    }
+    with open(session_file, "w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=4)
+
+
+def load_user_records(username):
+    session_file = get_user_session_file(username)
+    if not os.path.exists(session_file):
+        return []
+    try:
+        with open(session_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            records = data.get("records", [])
+        else:
+            records = data
+        return records if isinstance(records, list) else []
+    except Exception:
+        return []
+
+def load_example(index):
+    total = len(dataset)
+    index = max(0, min(index, total - 1))
+    item = dataset[index]
+    progress_pct = (index / total) * 100
+    progress_text = f"Sample {index + 1} of {total} ({progress_pct:.1f}%)"
+    src_fulltext = item["src_fulltext"]
+    translated_fulltext = item["translated_fulltext"]
+    return (
+        src_fulltext,           # src_display
+        translated_fulltext,    # eng_display
+        None,                   # rating_dropdown (clears selection)
+        index,                  # current_index
+        progress_text,          # progress_display
+        progress_pct,           # progress_bar
+        index + 1               # jump_input
+    )
+
+def get_last_index_for_user(username):
+    if not username:
+        return 0
+    records = load_user_records(username)
+    done_indices = set()
+    for rec in records:
+        if isinstance(rec, dict) and isinstance(rec.get("index"), int):
+            done_indices.add(rec["index"])
+
+    # Resume means: first unannotated sample in order.
+    for i in range(len(dataset)):
+        if i not in done_indices:
+            return i
+    # Completed.
+    return len(dataset)
+
+
+def load_example_or_done(index):
+    if index >= len(dataset):
+        total = len(dataset)
+        progress_text = f"✅ Completed all {total} samples"
+        return (
+            "✅ ALL DONE",
+            "✅ ALL DONE",
+            None,
+            total,
+            progress_text,
+            100,
+            total,
+        )
+    return load_example(index)
+
+def next_item(index, rating, src_txt, eng_txt, username):
+    if rating is None:
+        raise gr.Error("Please select a rating before proceeding!")
+    if not username:
+        raise gr.Error("Please enter your username!")
+    safe_user = sanitize_username(username)
+    if not safe_user:
+        raise gr.Error("Username must contain letters/numbers (optionally _ or -).")
+    record = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "index": index,
+        "src_text": src_txt,
+        "translated_text": eng_txt,
+        "rating": rating,
+        "username": safe_user
+    }
+    save_rating_to_json(record, safe_user)
+    gr.Info(f"Saved record {index + 1} for {safe_user}.")
+
+    # After saving, resume at first unannotated index.
+    next_idx = get_last_index_for_user(safe_user)
+    return load_example_or_done(next_idx)
+
+def jump_to_instance(target_index):
+    return load_example_or_done(target_index - 1)
+
+with gr.Blocks(css=custom_css) as demo:
+    username_box = gr.Textbox(label="Enter your username", value="", interactive=True)
+    login_btn = gr.Button("Start/Resume Session", variant="primary")
+    current_index = gr.State(0)
+    total_count = len(dataset)
+    gr.Markdown(f"### Translation Quality Annotation")
+    with gr.Row(elem_classes="nav-row"):
+        with gr.Column(scale=2):
+            progress_bar = gr.Slider(label="Progress", minimum=0, maximum=100, value=0, interactive=False)
+            progress_display = gr.Markdown(f"Sample 1 of {total_count} (0.0%)")
+        with gr.Column(scale=1):
+            jump_input = gr.Number(label="Jump to Sample #", value=1, precision=0)
+            jump_btn = gr.Button("Go", size="sm")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("##### Source Fulltext (English)")
+            src_display = gr.Textbox(value=dataset[0]["src_fulltext"], interactive=False, lines=12, show_label=False)
+        with gr.Column():
+            gr.Markdown("##### Fulltext Translation (Bangla)")
+            eng_display = gr.Textbox(value=dataset[0]["translated_fulltext"], interactive=False, lines=12, show_label=False)
+    rating_dropdown = gr.Dropdown(choices=RATING_OPTIONS, label="Select Rating")
+    with gr.Row():
+        prev_btn = gr.Button("⬅ Previous (Review)", variant="secondary")
+        submit_btn = gr.Button("Save & Next ➡", variant="primary")
+
+    def login_user(username):
+        safe_user = sanitize_username(username)
+        if not safe_user:
+            raise gr.Error("Please enter a valid username (letters/numbers, _ or -).")
+        idx = get_last_index_for_user(safe_user)
+        return load_example_or_done(idx)
+
+    login_btn.click(
+        fn=login_user,
+        inputs=[username_box],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    submit_btn.click(
+        fn=next_item,
+        inputs=[current_index, rating_dropdown, src_display, eng_display, username_box],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    # 2. Update Prev Button: removed tr_display from outputs
+    prev_btn.click(
+        fn=lambda idx: load_example_or_done(idx - 1),
+        inputs=[current_index],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    # 3. Update Jump Button: removed tr_display from outputs
+    jump_btn.click(
+        fn=jump_to_instance,
+        inputs=[jump_input],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/translation_quality_v2.py

@@ -0,0 +1,251 @@
+import gradio as gr
+import json
+import os
+from datetime import datetime
+
+
+def sanitize_username(username: str) -> str:
+    """Make username safe for filesystem paths."""
+    if not username:
+        return ""
+    username = username.strip()
+    safe = "".join(ch for ch in username if ch.isalnum() or ch in ("_", "-"))
+    return safe
+
+def get_user_session_file(username):
+    safe = sanitize_username(username)
+    return os.path.join(SAVE_DIR, f"ratings_{safe}.json")
+
+language="Bengali"
+if language=="Chinese":
+    language_code="ch"
+elif language=="Hindi":
+    language_code="hi"
+elif language=="Bengali":
+    language_code="be"
+else:
+    assert False, "Unsupported language"
+
+
+# Load translation dataset (EN -> BN fulltext/summary)
+TRANSLATION_PATH = (
+    "/home/mshahidul/readctrl/data/translated_data/translation_wo_judge/"
+    "multiclinsum_gs_train_en2bn_gemma(0_200).json"
+)
+with open(TRANSLATION_PATH, "r", encoding="utf-8") as f:
+    translation_dataset = json.load(f)
+
+dataset = [
+    {
+        "src_fulltext": item.get("fulltext", ""),
+        "translated_fulltext": item.get("translated_fulltext", ""),
+        "id": item.get("id"),
+    }
+    for item in translation_dataset
+][:50]
+
+# 2. Configuration for saving
+SAVE_DIR = f"/home/mshahidul/readctrl/data/translated_data/rating_info_v2/{language_code}"
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+SESSION_FILE = None  # Will be set per user
+
+RATING_OPTIONS = [
+    ("1 - Poor (Incorrect/Nonsense)", 1),
+    ("2 - Fair (Understandable but awkward)", 2),
+    ("3 - Good (Accurate/Perfect)", 3)
+]
+
+custom_css = """
+.small-header { font-size: 0.85rem !important; font-weight: 600; margin-bottom: -10px; color: #555; }
+.nav-row { background-color: #f9f9f9; padding: 10px; border-radius: 8px; margin-bottom: 15px; }
+"""
+
+def save_rating_to_json(data_item, username):
+    session_file = get_user_session_file(username)
+    output_data = []
+    if os.path.exists(session_file):
+        with open(session_file, "r", encoding="utf-8") as f:
+            try:
+                output_data = json.load(f)
+            except json.JSONDecodeError:
+                output_data = []
+
+    # Backward/forward compatibility: support either list[record] or dict with "records".
+    if isinstance(output_data, dict):
+        records = output_data.get("records", [])
+    else:
+        records = output_data if isinstance(output_data, list) else []
+
+    # Keep a single record per index (update if it already exists).
+    new_index = data_item.get("index")
+    updated = False
+    for i, rec in enumerate(records):
+        if isinstance(rec, dict) and rec.get("index") == new_index:
+            records[i] = data_item
+            updated = True
+            break
+    if not updated:
+        records.append(data_item)
+
+    payload = {
+        "username": sanitize_username(username) or username,
+        "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "records": records,
+    }
+    with open(session_file, "w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=4)
+
+
+def load_user_records(username):
+    session_file = get_user_session_file(username)
+    if not os.path.exists(session_file):
+        return []
+    try:
+        with open(session_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            records = data.get("records", [])
+        else:
+            records = data
+        return records if isinstance(records, list) else []
+    except Exception:
+        return []
+
+def load_example(index):
+    total = len(dataset)
+    index = max(0, min(index, total - 1))
+    item = dataset[index]
+    progress_pct = (index / total) * 100
+    progress_text = f"Sample {index + 1} of {total} ({progress_pct:.1f}%)"
+    src_fulltext = item["src_fulltext"]
+    translated_fulltext = item["translated_fulltext"]
+    return (
+        src_fulltext,           # src_display
+        translated_fulltext,    # eng_display
+        None,                   # rating_dropdown (clears selection)
+        index,                  # current_index
+        progress_text,          # progress_display
+        progress_pct,           # progress_bar
+        index + 1               # jump_input
+    )
+
+def get_last_index_for_user(username):
+    if not username:
+        return 0
+    records = load_user_records(username)
+    done_indices = set()
+    for rec in records:
+        if isinstance(rec, dict) and isinstance(rec.get("index"), int):
+            done_indices.add(rec["index"])
+
+    # Resume means: first unannotated sample in order.
+    for i in range(len(dataset)):
+        if i not in done_indices:
+            return i
+    # Completed.
+    return len(dataset)
+
+
+def load_example_or_done(index):
+    if index >= len(dataset):
+        total = len(dataset)
+        progress_text = f"✅ Completed all {total} samples"
+        return (
+            "✅ ALL DONE",
+            "✅ ALL DONE",
+            None,
+            total,
+            progress_text,
+            100,
+            total,
+        )
+    return load_example(index)
+
+def next_item(index, rating, src_txt, eng_txt, username):
+    if rating is None:
+        raise gr.Error("Please select a rating before proceeding!")
+    if not username:
+        raise gr.Error("Please enter your username!")
+    safe_user = sanitize_username(username)
+    if not safe_user:
+        raise gr.Error("Username must contain letters/numbers (optionally _ or -).")
+    record = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "index": index,
+        "src_text": src_txt,
+        "translated_text": eng_txt,
+        "rating": rating,
+        "username": safe_user
+    }
+    save_rating_to_json(record, safe_user)
+    gr.Info(f"Saved record {index + 1} for {safe_user}.")
+
+    # After saving, resume at first unannotated index.
+    next_idx = get_last_index_for_user(safe_user)
+    return load_example_or_done(next_idx)
+
+def jump_to_instance(target_index):
+    return load_example_or_done(target_index - 1)
+
+with gr.Blocks(css=custom_css) as demo:
+    username_box = gr.Textbox(label="Enter your username", value="", interactive=True)
+    login_btn = gr.Button("Start/Resume Session", variant="primary")
+    current_index = gr.State(0)
+    total_count = len(dataset)
+    gr.Markdown("## Translation Quality Annotation")
+    gr.Markdown("Data generated by TranslateGemma.")
+    with gr.Row(elem_classes="nav-row"):
+        with gr.Column(scale=2):
+            progress_bar = gr.Slider(label="Progress", minimum=0, maximum=100, value=0, interactive=False)
+            progress_display = gr.Markdown(f"Sample 1 of {total_count} (0.0%)")
+        with gr.Column(scale=1):
+            jump_input = gr.Number(label="Jump to Sample #", value=1, precision=0)
+            jump_btn = gr.Button("Go", size="sm")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("##### Source Fulltext (English)")
+            src_display = gr.Textbox(value=dataset[0]["src_fulltext"], interactive=False, lines=12, show_label=False)
+        with gr.Column():
+            gr.Markdown("##### Fulltext Translation (Bangla)")
+            eng_display = gr.Textbox(value=dataset[0]["translated_fulltext"], interactive=False, lines=12, show_label=False)
+    rating_dropdown = gr.Dropdown(choices=RATING_OPTIONS, label="Select Rating")
+    with gr.Row():
+        prev_btn = gr.Button("⬅ Previous (Review)", variant="secondary")
+        submit_btn = gr.Button("Save & Next ➡", variant="primary")
+
+    def login_user(username):
+        safe_user = sanitize_username(username)
+        if not safe_user:
+            raise gr.Error("Please enter a valid username (letters/numbers, _ or -).")
+        idx = get_last_index_for_user(safe_user)
+        return load_example_or_done(idx)
+
+    login_btn.click(
+        fn=login_user,
+        inputs=[username_box],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    submit_btn.click(
+        fn=next_item,
+        inputs=[current_index, rating_dropdown, src_display, eng_display, username_box],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    # 2. Update Prev Button: removed tr_display from outputs
+    prev_btn.click(
+        fn=lambda idx: load_example_or_done(idx - 1),
+        inputs=[current_index],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+    # 3. Update Jump Button: removed tr_display from outputs
+    jump_btn.click(
+        fn=jump_to_instance,
+        inputs=[jump_input],
+        outputs=[src_display, eng_display, rating_dropdown, current_index, progress_display, progress_bar, jump_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

code/interface/vllm_app.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from openai import OpenAI
+
+# Initialize the client
+client = OpenAI(
+    base_url="http://localhost:8004/v1",
+    api_key="token-not-needed",
+)
+
+def predict(message, history):
+    history_openai_format = []
+    
+    # Manually build the history to ensure it's clean
+    for pair in history:
+        # pair[0] is User, pair[1] is Assistant
+        if len(pair) >= 2:
+            history_openai_format.append({"role": "user", "content": str(pair[0])})
+            history_openai_format.append({"role": "assistant", "content": str(pair[1])})
+    
+    # Add the current message
+    history_openai_format.append({"role": "user", "content": message})
+
+    # Create the completion request
+    response = client.chat.completions.create(
+        model="Qwen/Qwen3-30B-A3B-Instruct-2507",
+        messages=history_openai_format,
+        temperature=0.7,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+# Launch the Gradio ChatInterface without the 'type' argument
+demo = gr.ChatInterface(
+    fn=predict,
+    title="Qwen3 vLLM Chat",
+    description="Interface for Qwen/Qwen3-30B-A3B-Instruct-2507 running on vLLM",
+    examples=["What is the capital of France?", "Write a Python function for quicksort."]
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

code/interface/vllm_app_v2.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+"""Example for starting a Gradio OpenAI Chatbot Webserver
+Start vLLM API server:
+    vllm serve meta-llama/Llama-2-7b-chat-hf
+
+Start Gradio OpenAI Chatbot Webserver:
+    python /home/mshahidul/readctrl/code/interface/vllm_app_v2.py \
+                    -m Qwen/Qwen3-30B-A3B-Instruct-2507 --model-url http://172.16.34.29:8004/v1
+
+Note that `pip install --upgrade gradio` is needed to run this example.
+More details: https://github.com/gradio-app/gradio
+
+If your antivirus software blocks the download of frpc for gradio,
+you can install it manually by following these steps:
+
+1. Download this file: https://cdn-media.huggingface.co/frpc-gradio-0.3/frpc_linux_amd64
+2. Rename the downloaded file to: frpc_linux_amd64_v0.3
+3. Move the file to this location: /home/user/.cache/huggingface/gradio/frpc
+"""
+
+import argparse
+
+import gradio as gr
+from openai import OpenAI
+
+
+def predict(message, history, client, model_name, temp, stop_token_ids):
+    messages = [
+        {"role": "system", "content": "You are a great AI assistant."},
+        *history,
+        {"role": "user", "content": message},
+    ]
+
+    # Send request to OpenAI API (vLLM server)
+    stream = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        temperature=temp,
+        stream=True,
+        extra_body={
+            "repetition_penalty": 1,
+            "stop_token_ids": [int(id.strip()) for id in stop_token_ids.split(",")]
+            if stop_token_ids
+            else [],
+        },
+    )
+
+    # Collect all chunks and concatenate them into a full message
+    full_message = ""
+    for chunk in stream:
+        full_message += chunk.choices[0].delta.content or ""
+
+    # Return the full message as a single response
+    return full_message
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Chatbot Interface with Customizable Parameters"
+    )
+    parser.add_argument(
+        "--model-url", type=str, default="http://localhost:8000/v1", help="Model URL"
+    )
+    parser.add_argument(
+        "-m", "--model", type=str, required=True, help="Model name for the chatbot"
+    )
+    parser.add_argument(
+        "--temp", type=float, default=0.8, help="Temperature for text generation"
+    )
+    parser.add_argument(
+        "--stop-token-ids", type=str, default="", help="Comma-separated stop token IDs"
+    )
+    parser.add_argument("--host", type=str, default=None)
+    parser.add_argument("--port", type=int, default=8001)
+    return parser.parse_args()
+
+
+def build_gradio_interface(client, model_name, temp, stop_token_ids):
+    def chat_predict(message, history):
+        return predict(message, history, client, model_name, temp, stop_token_ids)
+
+    return gr.ChatInterface(
+        fn=chat_predict,
+        title="Chatbot Interface",
+        description="A simple chatbot powered by vLLM",
+        fill_height=True,
+    )
+
+
+def main():
+    # Parse the arguments
+    args = parse_args()
+
+    # Set OpenAI's API key and API base to use vLLM's API server
+    openai_api_key = "EMPTY"
+    openai_api_base = args.model_url
+
+    # Create an OpenAI client
+    client = OpenAI(api_key=openai_api_key, base_url=openai_api_base)
+
+    # Define the Gradio chatbot interface using the predict function
+    gradio_interface = build_gradio_interface(
+        client, args.model, args.temp, args.stop_token_ids
+    )
+
+    gradio_interface.queue().launch(
+        server_name=args.host, server_port=args.port, share=True
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+# python /home/mshahidul/readctrl/code/interface/vllm_app_v2.py --model Qwen/Qwen3-30B-A3B-Instruct-2507 --model-url http://localhost:8004/v1

code/key_subclaims_extract.py

@@ -0,0 +1,109 @@
+from openai import OpenAI
+import json
+import os
+import tqdm
+
+# --- 1. Load Paths and Data ---
+data_path = '/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_syn_data_with_gs_summary_en.json'
+prompt_path = "/home/mshahidul/readctrl/prompts/minimum_info_extract _v2"
+api_file = "/home/mshahidul/api_new.json"
+save_path = "/home/mshahidul/readctrl/data/key_subclaims_testing/key_subclaims.json"
+
+# Load the dataset
+with open(data_path, 'r') as f:
+    dataset = json.load(f)
+
+# Load the prompt template
+with open(prompt_path, "r") as f:
+    prompt_template = f.read()
+
+# Load API Key
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+client = OpenAI(api_key=openai_api_key)
+
+# --- 2. Helper Functions ---
+def openai_return(prompt, model="gpt-5"):
+    """Send a prompt to GPT and parse strictly formatted JSON."""
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant that outputs strictly in JSON format."},
+                {"role": "user", "content": prompt}
+            ],
+            response_format={"type": "json_object"} 
+        )
+        content = response.choices[0].message.content.strip()
+        return json.loads(content)
+    except Exception as e:
+        print(f"⚠️ Error processing API response: {e}")
+        return {"error": str(e), "raw_content": content if 'content' in locals() else None}
+
+def format_subclaims(subclaim_list, prefix):
+    """Formats subclaims with IDs (e.g., ST-1, GS-1) for better LLM tracking."""
+    if not isinstance(subclaim_list, list):
+        return str(subclaim_list)
+    return "\n".join([f"{prefix}-{i+1}: {text}" for i, text in enumerate(subclaim_list)])
+
+# --- 3. Main Processing Loop ---
+res = []
+if os.path.exists(save_path):
+    with open(save_path, "r") as f:
+        res = json.load(f)
+
+# Start from where we left off
+start_index = len(res)
+num_to_process = 100
+
+for i in tqdm.tqdm(range(start_index, min(start_index + num_to_process, len(dataset)))):
+    item = dataset[i]
+    
+    # 1. Extract raw data
+    source_text = item.get('fulltext', '')
+    source_subclaims_list = item.get('fulltext_subclaims', [])
+    gold_summary = item.get('summary', '')
+    gold_subclaims_list = item.get('summary_subclaims', [])
+
+    # 2. Format specifically for the prompt (Mapping IDs like ST-1, GS-1)
+    # This helps the LLM return the IDs you requested in your Output Format
+    source_subclaims_formatted = format_subclaims(source_subclaims_list, "ST")
+    gold_subclaims_formatted = format_subclaims(gold_subclaims_list, "GS")
+
+    # 3. Inject into prompt
+    prompt = prompt_template.replace("<<SOURCE_TEXT>>", source_text)\
+                             .replace("<<SOURCE_TEXT_SUBCLAIMS>>", source_subclaims_formatted)\
+                             .replace("<<GOLD_SUMMARY>>", gold_summary)\
+                             .replace("<<GOLD_SUMMARY_SUBCLAIMS>>", gold_subclaims_formatted)
+
+    # 4. Call API
+    api_response = openai_return(prompt)
+    
+    # 5. Build full result object
+    result_entry = {
+        "index": i,
+        "original_id": item.get('id'),
+        "input_data": {
+            "source_text": source_text,
+            "source_subclaims": source_subclaims_list,
+            "gold_summary": gold_summary,
+            "gold_subclaims": gold_subclaims_list
+        },
+        "llm_output": api_response
+    }
+    
+    res.append(result_entry)
+
+    # Autosave every 5 samples
+    if len(res) % 5 == 0:
+        with open(save_path, "w") as f:
+            json.dump(res, f, indent=2, ensure_ascii=False)
+
+# Final Save
+with open(save_path, "w") as f:
+    json.dump(res, f, indent=2, ensure_ascii=False)
+
+print(f"\n✅ Finished! Processed {len(res) - start_index} new samples.")
+print(f"Total samples in {save_path}: {len(res)}")

code/literacy_thresholds.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+from statistics import median, quantiles
+
+
+LABEL_ORDER = ["low", "intermediate", "proficient"]
+ORDERED_METRICS = {"source_coverage", "completeness"}
+
+
+def normalize_label(key: str) -> str:
+    key_l = key.lower()
+    for label in LABEL_ORDER:
+        if label in key_l:
+            return label
+    return key_l
+
+
+def five_number_summary(values):
+    if not values:
+        return None
+    q1, _, q3 = quantiles(values, n=4, method="inclusive")
+    return {
+        "min": min(values),
+        "q1": q1,
+        "median": median(values),
+        "q3": q3,
+        "max": max(values),
+    }
+
+
+def remove_outliers_iqr(values):
+    if len(values) < 4:
+        return values, 0
+    q1, _, q3 = quantiles(values, n=4, method="inclusive")
+    iqr = q3 - q1
+    if math.isclose(iqr, 0.0):
+        return values, 0
+    lower = q1 - 1.5 * iqr
+    upper = q3 + 1.5 * iqr
+    filtered = [v for v in values if lower <= v <= upper]
+    return filtered, len(values) - len(filtered)
+
+
+def parse_scores(data, metrics):
+    grouped = {label: {m: [] for m in metrics} for label in LABEL_ORDER}
+    for item in data:
+        levels = item.get("literacy_levels") or {}
+        for key, payload in levels.items():
+            label = normalize_label(key)
+            if label not in grouped:
+                continue
+            scores = (payload or {}).get("scores") or {}
+            for m in metrics:
+                if m in scores and scores[m] is not None:
+                    grouped[label][m].append(scores[m])
+    return grouped
+
+
+def suggest_thresholds(per_label_summaries, label_order):
+    thresholds = {}
+    for metric in per_label_summaries:
+        thresholds[metric] = {}
+        for i in range(len(label_order) - 1):
+            lower_label = label_order[i]
+            upper_label = label_order[i + 1]
+            lower = per_label_summaries[metric].get(lower_label)
+            upper = per_label_summaries[metric].get(upper_label)
+            if not lower or not upper:
+                thresholds[metric][f"{lower_label}_to_{upper_label}"] = None
+                continue
+            if lower["q3"] < upper["q1"]:
+                boundary = (lower["q3"] + upper["q1"]) / 2
+            else:
+                boundary = (lower["median"] + upper["median"]) / 2
+            thresholds[metric][f"{lower_label}_to_{upper_label}"] = boundary
+    return thresholds
+
+
+def print_summary(metrics, cleaned_by_label, outlier_counts, summaries):
+    for label in LABEL_ORDER:
+        print(f"\nLabel: {label}")
+        for m in metrics:
+            vals = cleaned_by_label[label][m]
+            summary = summaries[m].get(label)
+            removed = outlier_counts[label][m]
+            print(f"  Metric: {m}")
+            print(f"    Count (after outliers): {len(vals)}")
+            print(f"    Outliers removed: {removed}")
+            if summary:
+                print(
+                    "    Five-number summary: "
+                    f"min={summary['min']:.4f}, "
+                    f"q1={summary['q1']:.4f}, "
+                    f"median={summary['median']:.4f}, "
+                    f"q3={summary['q3']:.4f}, "
+                    f"max={summary['max']:.4f}"
+                )
+            else:
+                print("    Five-number summary: n/a")
+
+
+def medians_in_order(summaries, metric, label_order):
+    medians = []
+    for label in label_order:
+        summary = summaries.get(metric, {}).get(label)
+        if not summary:
+            return False
+        medians.append(summary["median"])
+    return medians[0] <= medians[1] <= medians[2]
+
+
+def enforce_ordered_metrics(metrics, grouped, cleaned, outlier_counts, summaries):
+    for metric in metrics:
+        if metric not in ORDERED_METRICS:
+            continue
+        if medians_in_order(summaries, metric, LABEL_ORDER):
+            continue
+        for label in LABEL_ORDER:
+            raw_values = grouped[label][metric]
+            cleaned[label][metric] = raw_values
+            outlier_counts[label][metric] = 0
+            if raw_values:
+                summaries[metric][label] = five_number_summary(raw_values)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compute five-number summaries by literacy label with outlier removal."
+    )
+    parser.add_argument(
+        "--input",
+        default="/home/mshahidul/readctrl/data/factual_testing/full_details_evaluation_0_80_qwen3-30B_v2.json",
+        help="Path to JSON evaluation file.",
+    )
+    parser.add_argument(
+        "--metrics",
+        default="factual_attribution,completeness,source_coverage",
+        help="Comma-separated metrics to analyze.",
+    )
+    args = parser.parse_args()
+
+    metrics = [m.strip() for m in args.metrics.split(",") if m.strip()]
+    with open(args.input, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    grouped = parse_scores(data, metrics)
+    cleaned = {label: {} for label in LABEL_ORDER}
+    outlier_counts = {label: {} for label in LABEL_ORDER}
+    summaries = {m: {} for m in metrics}
+
+    for label in LABEL_ORDER:
+        for m in metrics:
+            values = grouped[label][m]
+            filtered, removed = remove_outliers_iqr(values)
+            cleaned[label][m] = filtered
+            outlier_counts[label][m] = removed
+            if filtered:
+                summaries[m][label] = five_number_summary(filtered)
+
+    enforce_ordered_metrics(metrics, grouped, cleaned, outlier_counts, summaries)
+
+    print_summary(metrics, cleaned, outlier_counts, summaries)
+    thresholds = suggest_thresholds(summaries, LABEL_ORDER)
+
+    print("\nSuggested thresholds (based on cleaned quartiles/medians):")
+    for m in metrics:
+        print(f"  Metric: {m}")
+        for k, v in thresholds[m].items():
+            if v is None:
+                print(f"    {k}: n/a")
+            else:
+                print(f"    {k}: {v:.4f}")
+
+
+if __name__ == "__main__":
+    main()

code/literacy_thresholds_v2.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+from statistics import median, quantiles
+
+
+LABEL_ORDER = ["low", "intermediate", "proficient"]
+TARGET_METRIC = "source_coverage"
+ORDERED_METRICS = {TARGET_METRIC}
+
+
+def normalize_label(key: str) -> str:
+    key_l = key.lower()
+    for label in LABEL_ORDER:
+        if label in key_l:
+            return label
+    return key_l
+
+
+def five_number_summary(values):
+    if not values:
+        return None
+    q1, _, q3 = quantiles(values, n=4, method="inclusive")
+    return {
+        "min": min(values),
+        "q1": q1,
+        "median": median(values),
+        "q3": q3,
+        "max": max(values),
+    }
+
+
+def remove_outliers_iqr(values):
+    if len(values) < 4:
+        return values, 0
+    q1, _, q3 = quantiles(values, n=4, method="inclusive")
+    iqr = q3 - q1
+    if math.isclose(iqr, 0.0):
+        return values, 0
+    lower = q1 - 1.5 * iqr
+    upper = q3 + 1.5 * iqr
+    filtered = [v for v in values if lower <= v <= upper]
+    return filtered, len(values) - len(filtered)
+
+
+def parse_scores(data, metrics):
+    grouped = {label: {m: [] for m in metrics} for label in LABEL_ORDER}
+    for item in data:
+        levels = item.get("literacy_levels") or {}
+        for key, payload in levels.items():
+            label = normalize_label(key)
+            if label not in grouped:
+                continue
+            scores = (payload or {}).get("scores") or {}
+            for m in metrics:
+                if m in scores and scores[m] is not None:
+                    grouped[label][m].append(scores[m])
+    return grouped
+
+
+def suggest_thresholds(per_label_summaries, label_order):
+    thresholds = {}
+    for metric in per_label_summaries:
+        thresholds[metric] = {}
+        for i in range(len(label_order) - 1):
+            lower_label = label_order[i]
+            upper_label = label_order[i + 1]
+            lower = per_label_summaries[metric].get(lower_label)
+            upper = per_label_summaries[metric].get(upper_label)
+            if not lower or not upper:
+                thresholds[metric][f"{lower_label}_to_{upper_label}"] = None
+                continue
+            if lower["q3"] < upper["q1"]:
+                boundary = (lower["q3"] + upper["q1"]) / 2
+            else:
+                boundary = (lower["median"] + upper["median"]) / 2
+            thresholds[metric][f"{lower_label}_to_{upper_label}"] = boundary
+    return thresholds
+
+
+def print_summary(metrics, cleaned_by_label, outlier_counts, summaries):
+    for label in LABEL_ORDER:
+        print(f"\nLabel: {label}")
+        for m in metrics:
+            vals = cleaned_by_label[label][m]
+            summary = summaries[m].get(label)
+            removed = outlier_counts[label][m]
+            print(f"  Metric: {m}")
+            print(f"    Count (after outliers): {len(vals)}")
+            print(f"    Outliers removed: {removed}")
+            if summary:
+                print(
+                    "    Five-number summary: "
+                    f"min={summary['min']:.4f}, "
+                    f"q1={summary['q1']:.4f}, "
+                    f"median={summary['median']:.4f}, "
+                    f"q3={summary['q3']:.4f}, "
+                    f"max={summary['max']:.4f}"
+                )
+            else:
+                print("    Five-number summary: n/a")
+
+
+def medians_in_order(summaries, metric, label_order):
+    medians = []
+    for label in label_order:
+        summary = summaries.get(metric, {}).get(label)
+        if not summary:
+            return False
+        medians.append(summary["median"])
+    return medians[0] <= medians[1] <= medians[2]
+
+
+def enforce_ordered_metrics(metrics, grouped, cleaned, outlier_counts, summaries):
+    for metric in metrics:
+        if metric not in ORDERED_METRICS:
+            continue
+        if medians_in_order(summaries, metric, LABEL_ORDER):
+            continue
+        for label in LABEL_ORDER:
+            raw_values = grouped[label][metric]
+            cleaned[label][metric] = raw_values
+            outlier_counts[label][metric] = 0
+            if raw_values:
+                summaries[metric][label] = five_number_summary(raw_values)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compute five-number summaries for source_coverage by literacy label."
+    )
+    parser.add_argument(
+        "--input",
+        default="/home/mshahidul/readctrl/data/factual_testing/full_details_evaluation_0_80_qwen3-30B_v2.json",
+        help="Path to JSON evaluation file.",
+    )
+    args = parser.parse_args()
+
+    metrics = [TARGET_METRIC]
+    with open(args.input, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    grouped = parse_scores(data, metrics)
+    cleaned = {label: {} for label in LABEL_ORDER}
+    outlier_counts = {label: {} for label in LABEL_ORDER}
+    summaries = {m: {} for m in metrics}
+
+    for label in LABEL_ORDER:
+        for m in metrics:
+            values = grouped[label][m]
+            filtered, removed = remove_outliers_iqr(values)
+            cleaned[label][m] = filtered
+            outlier_counts[label][m] = removed
+            if filtered:
+                summaries[m][label] = five_number_summary(filtered)
+
+    enforce_ordered_metrics(metrics, grouped, cleaned, outlier_counts, summaries)
+
+    print_summary(metrics, cleaned, outlier_counts, summaries)
+    thresholds = suggest_thresholds(summaries, LABEL_ORDER)
+
+    print("\nSuggested thresholds (based on cleaned quartiles/medians):")
+    for m in metrics:
+        print(f"  Metric: {m}")
+        for k, v in thresholds[m].items():
+            if v is None:
+                print(f"    {k}: n/a")
+            else:
+                print(f"    {k}: {v:.4f}")
+
+
+if __name__ == "__main__":
+    main()

code/old/FH_es.py

@@ -0,0 +1,86 @@
+import re
+
+# --- Spanish tokenization ---
+WORD_RE = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
+
+def _tokenize_words_es(text: str):
+    return WORD_RE.findall(text)
+
+def _count_sentences_es(text: str) -> int:
+    # Count sentences via ., !, ?, … and Spanish ¡¿
+    sentences = re.split(r"[.!?…]+|[¡¿]", text)
+    return max(1, sum(1 for s in sentences if s.strip()))
+
+# --- Syllable counting ---
+try:
+    import pyphen
+    _dic = pyphen.Pyphen(lang='es')  # or 'es_ES'
+
+    def count_syllables_es(word: str) -> int:
+        # Use hyphenation positions; count pieces
+        hyph = _dic.inserted(word)
+        return max(1, hyph.count('-') + 1)
+except Exception:
+    # Heuristic fallback (handles hiatus and silent 'u' roughly)
+    def count_syllables_es(word: str) -> int:
+        w = word.lower()
+
+        # Treat final 'y' as vowel 'i'
+        w = re.sub(r'y$', 'i', w)
+
+        # Remove silent 'u' before e/i in 'que/qui/gue/gui' (but not 'güe/güi')
+        w = re.sub(r'que', 'qe', w)
+        w = re.sub(r'qui', 'qi', w)
+        w = re.sub(r'gue', 'ge', w)
+        w = re.sub(r'gui', 'gi', w)
+
+        vowels = set("aeiouáéíóúü")
+        strong = set("aáeéoóíú")  # accented í/ú behave like strong (hiatus)
+        n = len(w)
+        i = 0
+        syll = 0
+        while i < n:
+            if w[i] not in vowels:
+                i += 1
+                continue
+            # collect contiguous vowels
+            j = i + 1
+            while j < n and w[j] in vowels:
+                j += 1
+            seq = w[i:j]
+            # one nucleus by default
+            nuclei = 1
+            # split on strong-strong boundaries (ae, ea, ao, oa, eo, oe, and cases with í/ú)
+            for k in range(len(seq) - 1):
+                if seq[k] in strong and seq[k + 1] in strong:
+                    nuclei += 1
+            syll += nuclei
+            i = j
+        return max(1, syll)
+
+# --- Fernández–Huerta (FH) ---
+def fernandez_huerta(text: str) -> float | None:
+    """
+    Fernández–Huerta readability for Spanish.
+    Higher = easier. Typical range ~0–100.
+    """
+    words = _tokenize_words_es(text)
+    n_words = len(words)
+    if n_words == 0:
+        return None
+    n_sentences = _count_sentences_es(text)
+    n_syllables = sum(count_syllables_es(w) for w in words)
+
+    # FH = 206.84 - 0.60 * (P) - 1.02 * (F)
+    # P = (syllables/words)*100, F = words/sentence
+    fh = 206.84 - 0.60 * ((n_syllables / n_words) * 100.0) - 1.02 * (n_words / n_sentences)
+    return round(fh, 2)
+
+# --- Quick check ---
+# if __name__ == "__main__":
+#     text_easy = "El corazón es un órgano que bombea sangre. En este caso, funciona bien."
+#     text_medium = "El corazón del paciente muestra una función adecuada, aunque se observaron pequeños cambios que deben revisarse."
+#     text_hard = "La evaluación cardiológica indicó una función sistólica preservada, con alteraciones discretas en la relajación diastólica."
+#     print("Easy FH:", fernandez_huerta(text_easy))
+#     print("Medium FH:", fernandez_huerta(text_medium))
+#     print("Hard FH:", fernandez_huerta(text_hard))

code/old/FH_esV2.py

@@ -0,0 +1,39 @@
+import re
+import separasilabas
+
+def count_words(text):
+    text = ''.join(filter(lambda x: not x.isdigit(), text))
+    clean = re.compile(r'\W+')
+    text = clean.sub(' ', text).strip()
+    return len(text.split()) if len(text.split()) > 0 else 1
+
+def count_sentences(text):
+    text = text.replace("\n", "")
+    sentence_end = re.compile(r'[.:;!?\)\()]')
+    sentences = sentence_end.split(text)
+    sentences = list(filter(None, sentences))
+    return len(sentences) if len(sentences) > 0 else 1
+
+def count_all_syllables(text):
+    clean = re.compile(r'\W+')
+    words = clean.sub(' ', text).strip().split()
+    silabizer = separasilabas.silabizer()
+    total = 0
+    for word in words:
+        total += len(silabizer(word))
+    return total if total > 0 else 1
+
+def Pval(text):
+    syllables = count_all_syllables(text)
+    words = count_words(text)
+    return round(syllables / words, 2)
+
+def Fval(text):
+    sentences = count_sentences(text)
+    words = count_words(text)
+    return round(words / sentences, 2)
+
+def fernandez_huerta(text):
+    return round(206.84 - 60 * Pval(text) - 1.02 * Fval(text), 2)
+
+

code/old/FH_fr.py

@@ -0,0 +1,86 @@
+import re
+try:
+    import pyphen
+    _hyph_fr = pyphen.Pyphen(lang='fr')  # or 'fr_FR'
+except Exception:
+    _hyph_fr = None
+
+# --- Basic French tokenization ---
+WORD_RE_FR = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿœŒÆæ]+", re.UNICODE)
+
+def tokenize_words_fr(text: str):
+    return WORD_RE_FR.findall(text)
+
+def count_sentences_fr(text: str):
+    # Split on ., !, ?, … ; keep it simple
+    parts = re.split(r"[.!?…]+", text)
+    return max(1, sum(1 for p in parts if p.strip()))
+
+def count_syllables_fr(word: str) -> int:
+    if _hyph_fr:
+        # Pyphen gives hyphenation points; count pieces as syllables (approx)
+        hyph = _hyph_fr.inserted(word)
+        return max(1, hyph.count('-') + 1)
+    # Fallback: simple vowel-group heuristic (rougher)
+    groups = re.findall(r"[aeiouyAEIOUYàâäéèêëîïôöùûüÿœAEIOUYÀÂÄÉÈÊËÎÏÔÖÙÛÜŸŒ]+", word)
+    return max(1, len(groups))
+
+# --- FRE-FR (Kandel & Moles) ---
+def flesch_kandel_moles_fr(text: str):
+    words = tokenize_words_fr(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_fr(text)
+    syl = sum(count_syllables_fr(w) for w in words)
+    P = (syl / W) * 100.0  # syllables per 100 words
+    F = W / S              # words per sentence
+    score = 207.0 - 1.015 * F - 0.736 * P
+    return round(score, 2)
+
+# --- LIX / RIX ---
+def lix(text: str):
+    words = tokenize_words_fr(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_fr(text)
+    long_words = sum(1 for w in words if len(w) > 6)
+    return round((W / S) + (100.0 * long_words / W), 2)
+
+def rix(text: str):
+    words = tokenize_words_fr(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_fr(text)
+    long_words = sum(1 for w in words if len(w) > 6)
+    return round(long_words / S, 2)
+
+# --- Band checks ---
+FRE_FR_BANDS = {
+    'B1': (70, 100),
+    'B2': (60, 70),
+    'B3': (45, 60),
+}
+LIX_BANDS = {
+    'B1': (20, 35),
+    'B2': (35, 45),
+    'B3': (45, 60),
+}
+
+def in_band(score, band, bands, delta=0.0):
+    if score is None:
+        return False
+    lo, hi = bands[band]
+    return (lo - delta) <= score <= (hi + delta)
+
+# Example
+# if __name__ == "__main__":
+#     txt = "Le patient se porte bien. Les examens sont rassurants, sans signes d’infection. Un suivi simple est recommandé."
+#     fre = flesch_kandel_moles_fr(txt)
+#     lx = lix(txt)
+#     rx = rix(txt)
+#     print("FRE-FR:", fre, "B1?", in_band(fre, 'B1', FRE_FR_BANDS, delta=1.0))
+#     print("LIX:", lx, "B1?", in_band(lx, 'B1', LIX_BANDS, delta=2.0))
+#     print("RIX:", rx)

code/old/FH_pt.py

@@ -0,0 +1,87 @@
+import re
+try:
+    import pyphen
+    _hyph_pt_br = pyphen.Pyphen(lang='pt_BR')
+    _hyph_pt_pt = pyphen.Pyphen(lang='pt_PT')
+except Exception:
+    _hyph_pt_br = _hyph_pt_pt = None
+
+# --- Tokenization ---
+WORD_RE_PT = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿ]+", re.UNICODE)  # includes áâãà ç éê í óôõ ú ü etc.
+
+def tokenize_words_pt(text: str):
+    return WORD_RE_PT.findall(text)
+
+def count_sentences_pt(text: str):
+    # Keep it simple: ., !, ?, … as boundaries
+    parts = re.split(r"[.!?…]+", text)
+    return max(1, sum(1 for p in parts if p.strip()))
+
+def count_syllables_pt(word: str) -> int:
+    # Prefer hyphenation dictionaries (pt_BR first, then pt_PT)
+    if _hyph_pt_br or _hyph_pt_pt:
+        hyph = (_hyph_pt_br or _hyph_pt_pt).inserted(word)
+        return max(1, hyph.count('-') + 1)
+    # Fallback: vowel-group heuristic (rough)
+    groups = re.findall(r"[aeiouyAEIOUYàáâãéêíóôõúüÀÁÂÃÉÊÍÓÔÕÚÜ]+", word)
+    return max(1, len(groups))
+
+# --- Flesch Reading Ease (Portuguese adaptation) ---
+def flesch_portuguese(text: str):
+    words = tokenize_words_pt(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_pt(text)
+    syl = sum(count_syllables_pt(w) for w in words)
+    F = W / S               # words per sentence
+    P = syl / W             # syllables per word
+    score = 248.835 - 1.015 * F - 84.6 * P
+    return round(score, 2)
+
+# --- LIX / RIX ---
+def lix(text: str):
+    words = tokenize_words_pt(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_pt(text)
+    long_words = sum(1 for w in words if len(w) > 6)
+    return round((W / S) + (100.0 * long_words / W), 2)
+
+def rix(text: str):
+    words = tokenize_words_pt(text)
+    W = len(words)
+    if W == 0:
+        return None
+    S = count_sentences_pt(text)
+    long_words = sum(1 for w in words if len(w) > 6)
+    return round(long_words / S, 2)
+
+# --- Band checks ---
+FRE_PT_BANDS = {
+    'B1': (70, 100),
+    'B2': (60, 70),
+    'B3': (45, 60),
+}
+LIX_BANDS = {
+    'B1': (20, 35),
+    'B2': (35, 45),
+    'B3': (45, 60),
+}
+
+def in_band(score, band, bands, delta=0.0):
+    if score is None:
+        return False
+    lo, hi = bands[band]
+    return (lo - delta) <= score <= (hi + delta)
+
+# Example
+if __name__ == "__main__":
+    txt = "O paciente está bem. Os exames não mostram sinais de infecção. Recomenda-se apenas acompanhamento."
+    fre = flesch_portuguese(txt)
+    lx = lix(txt)
+    rx = rix(txt)
+    print("FRE-PT:", fre, "B1?", in_band(fre, 'B1', FRE_PT_BANDS, delta=1.0))
+    print("LIX:", lx, "B1?", in_band(lx, 'B1', LIX_BANDS, delta=2.0))
+    print("RIX:", rx)

code/old/generate_thinking_data.ipynb

@@ -0,0 +1,442 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d3bff56e",
+   "metadata": {},
+   "source": [
+    "https://lmarena.ai/c/9fa09cff-fb85-4719-80db-188a19de0803"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a11463f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import random\n",
+    "from typing import List, Dict, Any, Optional\n",
+    "\n",
+    "# Your existing prompts for different readability levels\n",
+    "PROMPTS = {\n",
+    "    \"easy\": '''\n",
+    "You are an assistant that rewrites Spanish texts to make them very simple and easy to understand.\n",
+    "Your goal is to rewrite the provided input text for younger readers (Fernández Huerta 70–100; grade 5–7).\n",
+    "Use short sentences, simple words, and friendly tone. Avoid technical or complex expressions.\n",
+    "Keep all important factual details, but remove jargon.\n",
+    "Return only the rewritten text without commentary.\n",
+    "''',\n",
+    "    \"intermediate\": '''\n",
+    "You are an assistant specialized in rewriting Spanish texts with medium readability.\n",
+    "Your task is to rewrite the provided input text for general or high‑school‑level readers (Fernández Huerta 50–70; grade 8–12).\n",
+    "Use clear and complete sentences, moderately complex vocabulary, and structured narration.\n",
+    "Retain all relevant medical or factual information, but phrase it in accessible language.\n",
+    "Return only the rewritten text with no explanations.\n",
+    "''',\n",
+    "    \"hard\": '''\n",
+    "You are an assistant that rewrites Spanish medical texts with professional, technical precision.\n",
+    "Rewrite the following input text using specialized, academic terminology and information‑dense phrasing.\n",
+    "The output must target a Fernández Huerta readability index between 0 and 50 (university/professional level).\n",
+    "Use clinical vocabulary, formal register, and detailed description of pathophysiology, procedures, and findings.\n",
+    "Return only the rewritten text.\n",
+    "'''\n",
+    "}\n",
+    "\n",
+    "# Thinking templates for processing medical reports\n",
+    "THINKING_TEMPLATES = {\n",
+    "    \"input_analysis\": [\n",
+    "        \"\"\"Estoy analizando este informe médico. Primero debo identificar:\n",
+    "1. Datos del paciente: {patient_info}\n",
+    "2. Diagnóstico principal: {diagnosis}\n",
+    "3. Síntomas y signos clínicos: {symptoms}\n",
+    "4. Pruebas realizadas: {tests}\n",
+    "5. Tratamiento: {treatment}\n",
+    "\n",
+    "Ahora debo adaptar esta información al nivel de lectura solicitado: {difficulty}.\"\"\",\n",
+    "\n",
+    "        \"\"\"Este es un informe médico que necesito reescribir. Contiene:\n",
+    "- Información clínica sobre {diagnosis}\n",
+    "- Terminología médica como: {medical_terms}\n",
+    "- Datos técnicos que debo {action} según el nivel {difficulty}\n",
+    "Mi objetivo es mantener la precisión médica mientras ajusto la complejidad del lenguaje.\"\"\"\n",
+    "    ],\n",
+    "    \n",
+    "    \"easy\": [\n",
+    "        \"\"\"Para nivel fácil (FH 70-100), debo:\n",
+    "1. Cambiar \"{medical_term}\" por \"{simple_term}\"\n",
+    "2. Dividir oraciones largas en frases cortas\n",
+    "3. Eliminar jerga médica innecesaria\n",
+    "4. Usar palabras que un niño de 10-12 años entienda\n",
+    "5. Mantener la historia clara y simple\n",
+    "\n",
+    "Voy a contar esto como una historia sobre {patient_description} que {simple_story}.\"\"\",\n",
+    "\n",
+    "        \"\"\"Necesito simplificar mucho este texto:\n",
+    "- Cambiar términos médicos complejos por palabras cotidianas\n",
+    "- Usar máximo 10-15 palabras por oración\n",
+    "- Explicar todo como si fuera para un niño\n",
+    "- Mantener solo la información esencial\n",
+    "- Hacer que suene amigable y no aterrador\"\"\",\n",
+    "    ],\n",
+    "    \n",
+    "    \"intermediate\": [\n",
+    "        \"\"\"Para nivel intermedio (FH 50-70), mi estrategia es:\n",
+    "1. Mantener algunos términos médicos pero explicarlos brevemente\n",
+    "2. Usar oraciones de complejidad media (15-20 palabras)\n",
+    "3. Estructurar la información en párrafos lógicos\n",
+    "4. Incluir detalles relevantes sin ser excesivamente técnico\n",
+    "5. Vocabulario apropiado para estudiantes de secundaria\n",
+    "\n",
+    "El texto debe ser informativo pero accesible, manteniendo {key_concepts} pero explicando {complex_terms}.\"\"\",\n",
+    "\n",
+    "        \"\"\"Nivel intermedio requiere equilibrio:\n",
+    "- Puedo usar términos como \"{medical_term}\" pero debo contextualizarlos\n",
+    "- Las oraciones pueden ser más complejas pero claras\n",
+    "- Incluir información sobre causas y efectos\n",
+    "- Mantener estructura narrativa coherente\n",
+    "- Apropiado para lectores con educación media\"\"\",\n",
+    "    ],\n",
+    "    \n",
+    "    \"hard\": [\n",
+    "        \"\"\"Para nivel profesional (FH 0-50), debo maximizar la precisión técnica:\n",
+    "1. Usar nomenclatura médica internacional: {technical_terms}\n",
+    "2. Incluir todos los valores de laboratorio y mediciones específicas\n",
+    "3. Emplear terminología especializada sin simplificación\n",
+    "4. Formato de historia clínica hospitalaria\n",
+    "5. Densidad informativa máxima\n",
+    "\n",
+    "Estructuraré según: Anamnesis → Exploración física → Pruebas complementarias → Diagnóstico → Plan terapéutico.\"\"\",\n",
+    "\n",
+    "        \"\"\"Reescritura altamente técnica requerida:\n",
+    "- Incorporar clasificaciones internacionales (CIE-10, DSM-5, etc.)\n",
+    "- Detallar fisiopatología y mecanismos moleculares\n",
+    "- Usar abreviaturas médicas estándar\n",
+    "- Incluir diagnósticos diferenciales\n",
+    "- Lenguaje de publicación científica\n",
+    "- Máxima densidad de información médica especializada\"\"\",\n",
+    "    ]\n",
+    "}\n",
+    "\n",
+    "class MedicalReportProcessor:\n",
+    "    \"\"\"Process medical reports and create training data with thinking mode.\"\"\"\n",
+    "    \n",
+    "    def __init__(self, original_report: str):\n",
+    "        \"\"\"\n",
+    "        Initialize with the original medical report.\n",
+    "        \n",
+    "        Args:\n",
+    "            original_report: The original medical report text to be rewritten\n",
+    "        \"\"\"\n",
+    "        self.original_report = original_report\n",
+    "        self.medical_entities = self.extract_medical_entities(original_report)\n",
+    "    \n",
+    "    def extract_medical_entities(self, text: str) -> Dict[str, List[str]]:\n",
+    "        \"\"\"Extract medical entities from the report.\"\"\"\n",
+    "        # This is a simplified extraction - you might want to use a medical NER model\n",
+    "        entities = {\n",
+    "            \"diagnosis\": [],\n",
+    "            \"symptoms\": [],\n",
+    "            \"medications\": [],\n",
+    "            \"tests\": [],\n",
+    "            \"medical_terms\": []\n",
+    "        }\n",
+    "        \n",
+    "        # Common medical terms to look for\n",
+    "        diagnosis_keywords = [\"diagnóstico\", \"síndrome\", \"enfermedad\", \"trastorno\", \"patología\", \n",
+    "                             \"neurofibromatosis\", \"nf1\", \"tdah\", \"déficit\"]\n",
+    "        symptom_keywords = [\"dolor\", \"mancha\", \"nódulo\", \"bulto\", \"lesión\", \"síntoma\",\n",
+    "                           \"retraso\", \"dificultad\", \"problema\"]\n",
+    "        medication_keywords = [\"medicamento\", \"tratamiento\", \"terapia\", \"metilfenidato\", \"fármaco\"]\n",
+    "        test_keywords = [\"biopsia\", \"ecografía\", \"análisis\", \"prueba\", \"examen\", \"resonancia\"]\n",
+    "        \n",
+    "        text_lower = text.lower()\n",
+    "        \n",
+    "        # Extract based on keywords\n",
+    "        for keyword in diagnosis_keywords:\n",
+    "            if keyword in text_lower:\n",
+    "                entities[\"diagnosis\"].append(keyword)\n",
+    "        \n",
+    "        for keyword in symptom_keywords:\n",
+    "            if keyword in text_lower:\n",
+    "                entities[\"symptoms\"].append(keyword)\n",
+    "        \n",
+    "        for keyword in medication_keywords:\n",
+    "            if keyword in text_lower:\n",
+    "                entities[\"medications\"].append(keyword)\n",
+    "        \n",
+    "        for keyword in test_keywords:\n",
+    "            if keyword in text_lower:\n",
+    "                entities[\"tests\"].append(keyword)\n",
+    "        \n",
+    "        # Extract all medical terms\n",
+    "        all_medical = diagnosis_keywords + symptom_keywords + medication_keywords + test_keywords\n",
+    "        for term in all_medical:\n",
+    "            if term in text_lower:\n",
+    "                entities[\"medical_terms\"].append(term)\n",
+    "        \n",
+    "        return entities\n",
+    "    \n",
+    "    def generate_input_thinking(self, difficulty: str) -> str:\n",
+    "        \"\"\"Generate thinking for understanding the input medical report.\"\"\"\n",
+    "        template = random.choice(THINKING_TEMPLATES[\"input_analysis\"])\n",
+    "        \n",
+    "        thinking = template.format(\n",
+    "            patient_info=\"paciente de 18 años\" if \"18 años\" in self.original_report else \"paciente\",\n",
+    "            diagnosis=\", \".join(self.medical_entities[\"diagnosis\"][:2]) or \"condición médica\",\n",
+    "            symptoms=\", \".join(self.medical_entities[\"symptoms\"][:3]) or \"síntomas diversos\",\n",
+    "            tests=\", \".join(self.medical_entities[\"tests\"][:2]) or \"estudios clínicos\",\n",
+    "            treatment=\", \".join(self.medical_entities[\"medications\"][:2]) or \"tratamiento\",\n",
+    "            difficulty=difficulty,\n",
+    "            medical_terms=\", \".join(self.medical_entities[\"medical_terms\"][:3]),\n",
+    "            action=\"simplificar mucho\" if difficulty == \"easy\" else \"adaptar\" if difficulty == \"intermediate\" else \"tecnificar\"\n",
+    "        )\n",
+    "        \n",
+    "        return thinking\n",
+    "    \n",
+    "    def generate_output_thinking(self, difficulty: str, rewritten_text: str) -> str:\n",
+    "        \"\"\"Generate thinking for the rewriting process.\"\"\"\n",
+    "        template = random.choice(THINKING_TEMPLATES[difficulty])\n",
+    "        \n",
+    "        # Customize based on difficulty\n",
+    "        if difficulty == \"easy\":\n",
+    "            thinking = template.format(\n",
+    "                medical_term=self.medical_entities[\"medical_terms\"][0] if self.medical_entities[\"medical_terms\"] else \"término médico\",\n",
+    "                simple_term=\"enfermedad\" if \"neurofibromatosis\" in self.medical_entities[\"diagnosis\"] else \"problema de salud\",\n",
+    "                patient_description=\"un joven\",\n",
+    "                simple_story=\"tenía una enfermedad especial desde pequeño\"\n",
+    "            )\n",
+    "        elif difficulty == \"intermediate\":\n",
+    "            thinking = template.format(\n",
+    "                key_concepts=\", \".join(self.medical_entities[\"diagnosis\"][:2]) or \"conceptos médicos principales\",\n",
+    "                complex_terms=\", \".join(self.medical_entities[\"medical_terms\"][:3]) or \"terminología especializada\",\n",
+    "                medical_term=self.medical_entities[\"medical_terms\"][0] if self.medical_entities[\"medical_terms\"] else \"término médico\"\n",
+    "            )\n",
+    "        else:  # hard\n",
+    "            thinking = template.format(\n",
+    "                technical_terms=\", \".join(self.medical_entities[\"medical_terms\"][:5]) or \"terminología especializada\"\n",
+    "            )\n",
+    "        \n",
+    "        return thinking\n",
+    "    \n",
+    "    def create_training_example(self, difficulty: str, rewritten_text: str, fh_score: float) -> Dict:\n",
+    "        \"\"\"Create a complete training example with thinking.\"\"\"\n",
+    "        \n",
+    "        # Generate system message\n",
+    "        system_content = PROMPTS[difficulty].strip()\n",
+    "        \n",
+    "        # Generate thinking for input and output\n",
+    "        input_thinking = self.generate_input_thinking(difficulty)\n",
+    "        output_thinking = self.generate_output_thinking(difficulty, rewritten_text)\n",
+    "        \n",
+    "        # Create the message structure\n",
+    "        messages = [\n",
+    "            {\n",
+    "                \"content\": f\"reasoning language: Spanish\\n\\n{system_content}\",\n",
+    "                \"role\": \"system\",\n",
+    "                \"thinking\": None\n",
+    "            },\n",
+    "            {\n",
+    "                \"content\": f\"Please rewrite the following medical report to achieve a Fernández Huerta score of {fh_score:.1f} (difficulty level: {difficulty}):\\n\\n{self.original_report}\",\n",
+    "                \"role\": \"user\",\n",
+    "                \"thinking\": input_thinking\n",
+    "            },\n",
+    "            {\n",
+    "                \"content\": rewritten_text,\n",
+    "                \"role\": \"assistant\",\n",
+    "                \"thinking\": output_thinking\n",
+    "            }\n",
+    "        ]\n",
+    "        \n",
+    "        return {\"messages\": messages}\n",
+    "\n",
+    "def process_medical_dataset_with_original(\n",
+    "    original_reports: List[str],\n",
+    "    readability_versions_list: List[Dict],\n",
+    "    include_variations: bool = True\n",
+    ") -> List[Dict]:\n",
+    "    \"\"\"\n",
+    "    Process medical dataset with original reports and create training data.\n",
+    "    \n",
+    "    Args:\n",
+    "        original_reports: List of original medical reports\n",
+    "        readability_versions_list: List of dictionaries with readability versions\n",
+    "        include_variations: Whether to include cross-difficulty variations\n",
+    "    \n",
+    "    Returns:\n",
+    "        List of training examples with thinking mode\n",
+    "    \"\"\"\n",
+    "    training_dataset = []\n",
+    "    \n",
+    "    for original_report, versions_dict in zip(original_reports, readability_versions_list):\n",
+    "        processor = MedicalReportProcessor(original_report)\n",
+    "        readability_versions = versions_dict.get(\"readability_versions\", {})\n",
+    "        \n",
+    "        # Create training examples for each difficulty level\n",
+    "        for difficulty, content in readability_versions.items():\n",
+    "            rewritten_text = content[\"text\"]\n",
+    "            fh_score = content[\"FH_score\"]\n",
+    "            \n",
+    "            training_example = processor.create_training_example(\n",
+    "                difficulty=difficulty,\n",
+    "                rewritten_text=rewritten_text,\n",
+    "                fh_score=fh_score\n",
+    "            )\n",
+    "            \n",
+    "            training_dataset.append(training_example)\n",
+    "        \n",
+    "        # Optionally create cross-difficulty variations\n",
+    "        if include_variations:\n",
+    "            difficulties = list(readability_versions.keys())\n",
+    "            \n",
+    "            # Create some mixed examples (e.g., easy to hard, hard to intermediate)\n",
+    "            for _ in range(2):  # Create 2 variations per report\n",
+    "                source_diff = random.choice(difficulties)\n",
+    "                target_diff = random.choice([d for d in difficulties if d != source_diff])\n",
+    "                \n",
+    "                # Use source difficulty text as \"original\" for variation\n",
+    "                source_text = readability_versions[source_diff][\"text\"]\n",
+    "                target_text = readability_versions[target_diff][\"text\"]\n",
+    "                target_fh = readability_versions[target_diff][\"FH_score\"]\n",
+    "                \n",
+    "                # Create processor for this variation\n",
+    "                var_processor = MedicalReportProcessor(source_text)\n",
+    "                variation_example = var_processor.create_training_example(\n",
+    "                    difficulty=target_diff,\n",
+    "                    rewritten_text=target_text,\n",
+    "                    fh_score=target_fh\n",
+    "                )\n",
+    "                \n",
+    "                training_dataset.append(variation_example)\n",
+    "    \n",
+    "    return training_dataset\n",
+    "\n",
+    "# Example usage\n",
+    "if __name__ == \"__main__\":\n",
+    "    # Example original medical reports (these would be your actual original reports)\n",
+    "    original_medical_reports = [\n",
+    "        \"\"\"Paciente masculino de 18 años con diagnóstico molecular confirmado de Neurofibromatosis tipo 1 \n",
+    "        (deleción exones 5-47 del gen NF1), que presenta antecedentes de retraso del desarrollo psicomotor \n",
+    "        global diagnosticado a los 3 años, trastorno específico del lenguaje de tipo expresivo que requirió \n",
+    "        intervención fonoaudiológica, y TDAH en tratamiento con metilfenidato 20mg/día con buena respuesta. \n",
+    "        Hallazgos oftalmológicos incluyen nódulos de Lisch bilaterales, astigmatismo miópico compuesto y \n",
+    "        euriblefaron bilateral. Motivo de consulta actual: aparición de placa eritematosa de 3cm en muslo \n",
+    "        izquierdo de 12 meses de evolución y múltiples nódulos subcutáneos móviles no dolorosos en región \n",
+    "        supraciliar derecha, occipital y muñeca izquierda. Examen físico revela macrocefalia (PC 59cm, >p97), \n",
+    "        15 máculas café con leche >1.5cm, efélides axilares e inguinales bilaterales, y 3 máculas \n",
+    "        rojo-azuladas deprimidas de 0.5-1cm en región lumbar y pectoral derecha. Estudios histopatológicos \n",
+    "        confirman neurofibromas con inmunohistoquímica S100(+), SOX10(+). Ecografía de partes blandas \n",
+    "        muestra lesiones hipoecoicas bien delimitadas compatibles con neurofibromas subcutáneos.\"\"\"\n",
+    "    ]\n",
+    "    \n",
+    "    # Your readability versions data\n",
+    "    readability_data = [\n",
+    "        {\n",
+    "            \"readability_versions\": {\n",
+    "                \"easy\": {\n",
+    "                    \"text\": \"Un joven de 18 años tenía una enfermedad llamada Neurofibromatosis tipo 1 desde que era bebé. Esta enfermedad produce manchas café con leche en la piel y pequeños bultos. Durante su infancia tuvo algunas dificultades para hablar y moverse bien, por lo que recibió terapias especiales. En la adolescencia le dieron medicamentos para mejorar su concentración. A los 18 años fue al dermatólogo porque le salió una nueva mancha en el muslo y algunos bultos en la piel. Le hicieron exámenes y confirmaron que eran parte de su enfermedad. Los médicos clasificaron los distintos tipos de manchas y bultos que tenía en la piel.\",\n",
+    "                    \"FH_score\": 77.16\n",
+    "                },\n",
+    "                \"intermediate\": {\n",
+    "                    \"text\": \"Un joven de 18 años con Neurofibromatosis tipo 1, diagnosticada desde el primer año de vida, había presentado dificultades motoras y del lenguaje durante la infancia, además de problemas visuales como nódulos de Lisch y astigmatismo. Fue tratado por Trastorno por Déficit Atencional con buenos resultados académicos. Consultó en Dermatología por una nueva mancha en el muslo izquierdo y la aparición de nódulos en zonas como la muñeca y el cuero cabelludo. En el examen se observaron manchas café con leche, pecas en las axilas y varios bultos pequeños bajo la piel. Se realizaron biopsias y ecografías que confirmaron que las lesiones correspondían a diferentes tipos de neurofibromas superficiales, los cuales fueron clasificados según su forma y localización.\",\n",
+    "                    \"FH_score\": 62.77\n",
+    "                },\n",
+    "                \"hard\": {\n",
+    "                    \"text\": \"Varón de 18 años con diagnóstico clínico y molecular de Neurofibromatosis tipo 1 (deleción de exones 5-47 del gen NF1), con antecedentes de retraso psicomotor global, trastorno específico del lenguaje expresivo, TDAH tratado con metilfenidato y hallazgos oftalmológicos compatibles con NF1 (nódulos de Lisch, astigmatismo y euriblefaron). Acude a Dermatología por aparición de placa rosada en muslo izquierdo de un año de evolución y nódulos subcutáneos móviles en región supraciliar derecha, occipital y muñeca. El examen físico revela macrocefalia, múltiples máculas café con leche, efélides axilares y máculas rojo-azuladas deprimidas en región lumbar y pectoral. Las biopsias cutáneas y ecografía de nódulos confirmaron neurofibromas superficiales. Según la clasificación de García-Martínez et al., se diagnosticaron simultáneamente neurofibromas subcutáneos nodulares, cutáneos pseudoatróficos y cutáneos rojo-azulados, evidenciando la heterogeneidad fenotípica de la enfermedad en un mismo paciente.\",\n",
+    "                    \"FH_score\": 39.94\n",
+    "                }\n",
+    "            }\n",
+    "        }\n",
+    "    ]\n",
+    "    \n",
+    "    # Process the dataset with original reports\n",
+    "    training_dataset = process_medical_dataset_with_original(\n",
+    "        original_reports=original_medical_reports,\n",
+    "        readability_versions_list=readability_data,\n",
+    "        include_variations=True\n",
+    "    )\n",
+    "    \n",
+    "    # Save the training dataset\n",
+    "    with open(\"medical_report_finetuning_with_thinking.jsonl\", \"w\", encoding=\"utf-8\") as f:\n",
+    "        for example in training_dataset:\n",
+    "            f.write(json.dumps(example, ensure_ascii=False) + \"\\n\")\n",
+    "    \n",
+    "    # Print example for verification\n",
+    "    print(\"Example training data with original medical report:\")\n",
+    "    print(json.dumps(training_dataset[0], ensure_ascii=False, indent=2))\n",
+    "    \n",
+    "    # Print statistics\n",
+    "    print(f\"\\n📊 Dataset Statistics:\")\n",
+    "    print(f\"Total training examples: {len(training_dataset)}\")\n",
+    "    print(f\"Number of messages per example: {len(training_dataset[0]['messages'])}\")\n",
+    "    print(f\"All examples have thinking: {all('thinking' in msg for ex in training_dataset for msg in ex['messages'])}\")\n",
+    "    \n",
+    "    # Validate the structure\n",
+    "    for i, example in enumerate(training_dataset):\n",
+    "        assert len(example['messages']) == 3, f\"Example {i} doesn't have 3 messages\"\n",
+    "        assert example['messages'][0]['role'] == 'system', f\"Example {i} first message is not system\"\n",
+    "        assert example['messages'][1]['role'] == 'user', f\"Example {i} second message is not user\"\n",
+    "        assert example['messages'][2]['role'] == 'assistant', f\"Example {i} third message is not assistant\"\n",
+    "        assert 'thinking' in example['messages'][1], f\"Example {i} user message missing thinking\"\n",
+    "        assert 'thinking' in example['messages'][2], f\"Example {i} assistant message missing thinking\"\n",
+    "    \n",
+    "    print(\"✅ All validation checks passed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "123b65b3",
+   "metadata": {},
+   "source": [
+    "Example training data with original medical report:\n",
+    "{\n",
+    "  \"messages\": [\n",
+    "    {\n",
+    "      \"content\": \"reasoning language: Spanish\\n\\nYou are an assistant that rewrites Spanish texts to make them very simple and easy to understand.\\nYour goal is to rewrite the provided input text for younger readers (Fernández Huerta 70–100; grade 5–7).\\nUse short sentences, simple words, and friendly tone. Avoid technical or complex expressions.\\nKeep all important factual details, but remove jargon.\\nReturn only the rewritten text without commentary.\",\n",
+    "      \"role\": \"system\",\n",
+    "      \"thinking\": null\n",
+    "    },\n",
+    "    {\n",
+    "      \"content\": \"Please rewrite the following medical report to achieve a Fernández Huerta score of 77.2 (difficulty level: easy):\\n\\nPaciente masculino de 18 años con diagnóstico molecular confirmado de Neurofibromatosis tipo 1 \\n        (deleción exones 5-47 del gen NF1), que presenta antecedentes de retraso del desarrollo psicomotor \\n        global diagnosticado a los 3 años, trastorno específico del lenguaje de tipo expresivo que requirió \\n        intervención fonoaudiológica, y TDAH en tratamiento con metilfenidato 20mg/día con buena respuesta. \\n        Hallazgos oftalmológicos incluyen nódulos de Lisch bilaterales, astigmatismo miópico compuesto y \\n        euriblefaron bilateral. Motivo de consulta actual: aparición de placa eritematosa de 3cm en muslo \\n        izquierdo de 12 meses de evolución y múltiples nódulos subcutáneos móviles no dolorosos en región \\n        supraciliar derecha, occipital y muñeca izquierda. Examen físico revela macrocefalia (PC 59cm, >p97), \\n        15 máculas café con leche >1.5cm, efélides axilares e inguinales bilaterales, y 3 máculas \\n        rojo-azuladas deprimidas de 0.5-1cm en región lumbar y pectoral derecha. Estudios histopatológicos \\n        confirman neurofibromas con inmunohistoquímica S100(+), SOX10(+). Ecografía de partes blandas \\n        muestra lesiones hipoecoicas bien delimitadas compatibles con neurofibromas subcutáneos.\",\n",
+    "      \"role\": \"user\",\n",
+    "      \"thinking\": \"Estoy analizando este informe médico. Primero debo identificar:\\n1. Datos del paciente: paciente de 18 años\\n2. Diagnóstico principal: diagnóstico, trastorno\\n3. Síntomas y signos clínicos: dolor, nódulo, retraso\\n4. Pruebas realizadas: ecografía, examen\\n5. Tratamiento: tratamiento, metilfenidato\\n\\nAhora debo adaptar esta información al nivel de lectura solicitado: easy.\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"content\": \"Un joven de 18 años tenía una enfermedad llamada Neurofibromatosis tipo 1 desde que era bebé. Esta enfermedad produce manchas café con leche en la piel y pequeños bultos. Durante su infancia tuvo algunas dificultades para hablar y moverse bien, por lo que recibió terapias especiales. En la adolescencia le dieron medicamentos para mejorar su concentración. A los 18 años fue al dermatólogo porque le salió una nueva mancha en el muslo y algunos bultos en la piel. Le hicieron exámenes y confirmaron que eran parte de su enfermedad. Los médicos clasificaron los distintos tipos de manchas y bultos que tenía en la piel.\",\n",
+    "      \"role\": \"assistant\",\n",
+    "      \"thinking\": \"Necesito simplificar mucho este texto:\\n- Cambiar términos médicos complejos por palabras cotidianas\\n- Usar máximo 10-15 palabras por oración\\n- Explicar todo como si fuera para un niño\\n- Mantener solo la información esencial\\n- Hacer que suene amigable y no aterrador\"\n",
+    "    }\n",
+    "  ]\n",
+    "}\n",
+    "\n",
+    "📊 Dataset Statistics:\n",
+    "Total training examples: 5\n",
+    "Number of messages per example: 3\n",
+    "All examples have thinking: True\n",
+    "✅ All validation checks passed!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "unsloth_latest",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/old/readability_controlv2.py

@@ -0,0 +1,69 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+import torch
+import time
+import random
+
+
+
+def initialize_and_touch(tensor):
+    tensor.zero_()
+    torch.cuda.synchronize()
+
+def dummy_compute(tensor):
+    result = torch.matmul(tensor, tensor.t())
+    torch.cuda.synchronize()
+    return result
+
+device = torch.device("cuda")
+total_memory = torch.cuda.get_device_properties(device).total_memory
+print(f"Total VRAM: {total_memory / (1024**3):.2f} GB")
+
+allocated_tensors = []
+chunk_size_bytes = 4 * 1024**3  # 4 GiB
+element_size = torch.tensor([], dtype=torch.float32).element_size()
+chunk_elements = chunk_size_bytes // element_size
+
+# Make the chunk roughly square
+side = int(chunk_elements ** 0.5)
+
+allocated = 0
+target = total_memory * 0.95
+
+print("Allocating and initializing memory...")
+while allocated < target:
+    try:
+        # Allocate a 2D tensor
+        chunk = torch.empty((side, side), dtype=torch.float32, device=device)
+        initialize_and_touch(chunk)
+        allocated_tensors.append(chunk)
+        allocated += chunk_size_bytes
+        print(f"Allocated: {allocated / (1024**3):.2f} GB", end='\r')
+    except RuntimeError as e:
+        if 'out of memory' in str(e).lower():
+            print(f"\nOut of memory after {allocated / (1024**3):.2f} GB")
+            break
+        else:
+            raise
+
+print(f"\nHolding {allocated / (1024**3):.2f} GB in {len(allocated_tensors)} chunks.")
+print("Running dummy compute every 30 seconds to show GPU utilization...")
+
+compute_interval = 30
+last_compute = time.time()
+
+while True:
+    now = time.time()
+    if now - last_compute >= compute_interval:
+        if allocated_tensors:
+            t = random.choice(allocated_tensors)
+            try:
+                side = min(t.shape[0], 8000)
+                _ = dummy_compute(t[:side, :side])
+                print(f"[{time.strftime('%H:%M:%S')}] GPU compute spike (util ↑)")
+            except Exception as e:
+                print(f"Compute failed (expected if chunk too big): {e}")
+        last_compute = now
+
+    time.sleep(1)

code/old/resonability_check_completeness_openai_V2.py

@@ -0,0 +1,140 @@
+import os, json
+def return_prompts(reference_summary, generated_summary, subclaims_json, difficulty_level):
+    prompt=f'''
+You are a **medical summarization quality evaluator**.
+Your goal is to decide whether the inclusion or omission of each subclaim in the generated summary is *reasonable*, given the target readability level.
+
+---
+
+### **Input**
+
+```
+Readability Level: {difficulty_level}
+
+Reference Summary:
+{reference_summary}
+
+Generated Summary:
+{generated_summary}
+
+Subclaims with Support Results:
+{subclaims_json}
+```
+
+---
+
+### **Task**
+
+For each subclaim:
+
+1. Read `result`:
+
+   * `1` = the subclaim is supported or clearly mentioned in the generated summary.
+   * `0` = the subclaim is missing or not supported.
+
+2. Based on readability level and medical relevance, decide whether this inclusion/omission is **reasonable**, **partially reasonable**, or **unreasonable**.
+
+3. Provide a short justification (1–2 sentences) explaining your reasoning.
+
+---
+
+### **Output Format**
+
+Return structured JSON:
+
+```json
+{{
+  "readability_level": "<easy/intermediate/hard>",
+  "evaluations": [
+    {{
+      "subclaim_id": <id>,
+      "subclaim_text": "<text>",
+      "result": <0 or 1>,
+      "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+      "justification": "<short explanation>"
+    }},
+    ...
+  ]
+}}
+```
+
+---
+
+### **Evaluation Guidelines**
+
+| Readability Level | Reasonable Omission                                          | Unreasonable Omission                             |
+| ----------------- | ------------------------------------------------------------ | ------------------------------------------------- |
+| **Easy**          | Technical, anatomical, quantitative, or procedural details.  | Key clinical findings, diagnoses, or outcomes.    |
+| **Intermediate**  | Minor imaging details or measurements.                       | Any main diagnostic finding or cause–effect link. |
+| **Hard**          | Very few omissions acceptable; mostly stylistic compression. | Any missing clinical or diagnostic information.   |
+
+'''
+    return prompt
+
+from openai import OpenAI
+
+file_path = "/home/mshahidul/api_new.json"
+with open(file_path, "r") as file:
+    api_keys = json.load(file)
+
+openai_api_key = api_keys.get("openai")
+
+client = OpenAI(api_key=openai_api_key)
+def openai_return(prompt):
+    response = client.chat.completions.create(
+        model="gpt-5",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    cleaned_response = response.choices[0].message.content.strip().replace("```json", "").replace("```", "")
+    return json.loads(cleaned_response)
+
+import json
+file_path = "/home/mshahidul/readctrl/data/training_data_subclaim_verifier/synthetic_data_es_subclaims_100.json"
+
+with open(file_path, 'r') as f:
+    synthetic_data = json.load(f)
+
+file_path_qwen3_32B = "/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json"
+
+with open(file_path_qwen3_32B, 'r') as f:
+    qwen3_32B_results = json.load(f)
+
+# dict_keys(['id', 'full_text', 'ref_summary', 'readability_versions'])
+# print(f"Full text: {synthetic_data[0]['full_text']}")
+res=[]
+save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/syn_data_resonability_check_20_gpt5.json"
+if os.path.exists(save_path):
+    with open(save_path, 'r') as f:
+        res = json.load(f)
+exist_check_ids = set([(item['id'], item['difficulty_level']) for item in res])
+print(f"Resuming from {len(res)} entries")
+import tqdm
+for ind in tqdm.tqdm(range(0,20)):
+    print(f"Processing index: {ind}")
+    for version in ["easy", "intermediate", "hard"]:
+        if (synthetic_data[ind]['id'], version) in exist_check_ids:
+            print(f"Skipping {synthetic_data[ind]['id']} {version}")
+            continue
+        ref_summary = (f"{synthetic_data[ind]['ref_summary']['text']}")
+        generated_summary = (f"{synthetic_data[ind]['readability_versions'][version]['text']}")
+        subclaims_results = (f"{qwen3_32B_results[ind]['completeness']['results']}")
+        try:
+            prompt = return_prompts(ref_summary, generated_summary, subclaims_results, version)
+            res.append({
+                "id": synthetic_data[ind]['id'],
+                "difficulty_level": version,
+                "reasonableness": openai_return(prompt)
+            })
+            if len(res)%2==0:
+                print(f"Completed {len(res)} out of 300")
+                with open(save_path, 'w') as outfile:
+                    json.dump(res, outfile, indent=2)
+        except Exception as e:
+            print(f"Error at {ind} {version}: {e}")
+        # print(prompt)
+        # assert False
+with open(save_path, 'w') as outfile:
+    json.dump(res, outfile, indent=2)

code/old/resonability_check_completeness_openai_V3.py

@@ -0,0 +1,140 @@
+import os, json
+def return_prompts(reference_summary, generated_summary, subclaims_json, difficulty_level):
+    prompt=f'''
+You are a **medical summarization quality evaluator**.
+Your goal is to decide whether the inclusion or omission of each subclaim in the generated summary is *reasonable*, given the target readability level.
+
+---
+
+### **Input**
+
+```
+Readability Level: {difficulty_level}
+
+Reference Summary:
+{reference_summary}
+
+Generated Summary:
+{generated_summary}
+
+Subclaims with Support Results:
+{subclaims_json}
+```
+
+---
+
+### **Task**
+
+For each subclaim:
+
+1. Read `result`:
+
+   * `1` = the subclaim is supported or clearly mentioned in the generated summary.
+   * `0` = the subclaim is missing or not supported.
+
+2. Based on readability level and medical relevance, decide whether this inclusion/omission is **reasonable**, **partially reasonable**, or **unreasonable**.
+
+3. Provide a short justification (1–2 sentences) explaining your reasoning.
+
+---
+
+### **Output Format**
+
+Return structured JSON:
+
+```json
+{{
+  "readability_level": "<easy/intermediate/hard>",
+  "evaluations": [
+    {{
+      "subclaim_id": <id>,
+      "subclaim_text": "<text>",
+      "result": <0 or 1>,
+      "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+      "justification": "<short explanation>"
+    }},
+    ...
+  ]
+}}
+```
+
+---
+
+### **Evaluation Guidelines**
+
+| Readability Level | Reasonable Omission                                          | Unreasonable Omission                             |
+| ----------------- | ------------------------------------------------------------ | ------------------------------------------------- |
+| **Easy**          | Technical, anatomical, quantitative, or procedural details.  | Key clinical findings, diagnoses, or outcomes.    |
+| **Intermediate**  | Minor imaging details or measurements.                       | Any main diagnostic finding or cause–effect link. |
+| **Hard**          | Very few omissions acceptable; mostly stylistic compression. | Any missing clinical or diagnostic information.   |
+
+'''
+    return prompt
+
+from openai import OpenAI
+
+file_path = "/home/mshahidul/api_new.json"
+with open(file_path, "r") as file:
+    api_keys = json.load(file)
+
+openai_api_key = api_keys.get("openai")
+
+client = OpenAI(api_key=openai_api_key)
+def openai_return(prompt):
+    response = client.chat.completions.create(
+        model="gpt-5",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    cleaned_response = response.choices[0].message.content.strip().replace("```json", "").replace("```", "")
+    return json.loads(cleaned_response)
+
+import json
+file_path = "/home/mshahidul/readctrl/data/training_data_subclaim_verifier/synthetic_data_es_subclaims_100.json"
+
+with open(file_path, 'r') as f:
+    synthetic_data = json.load(f)
+
+file_path_qwen3_32B = "/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json"
+
+with open(file_path_qwen3_32B, 'r') as f:
+    qwen3_32B_results = json.load(f)
+
+# dict_keys(['id', 'full_text', 'ref_summary', 'readability_versions'])
+# print(f"Full text: {synthetic_data[0]['full_text']}")
+res=[]
+save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/syn_data_resonability_check_20_gpt5.json"
+if os.path.exists(save_path):
+    with open(save_path, 'r') as f:
+        res = json.load(f)
+exist_check_ids = set([(item['id'], item['difficulty_level']) for item in res])
+print(f"Resuming from {len(res)} entries")
+import tqdm
+for ind in tqdm.tqdm(range(0,20)):
+    print(f"Processing index: {ind}")
+    for version in ["easy", "intermediate", "hard"]:
+        if (synthetic_data[ind]['id'], version) in exist_check_ids:
+            print(f"Skipping {synthetic_data[ind]['id']} {version}")
+            continue
+        ref_summary = (f"{synthetic_data[ind]['ref_summary']['text']}")
+        generated_summary = (f"{synthetic_data[ind]['readability_versions'][version]['text']}")
+        subclaims_results = (f"{qwen3_32B_results[ind]['completeness']['results']}")
+        try:
+            prompt = return_prompts(ref_summary, generated_summary, subclaims_results, version)
+            res.append({
+                "id": synthetic_data[ind]['id'],
+                "difficulty_level": version,
+                "reasonableness": openai_return(prompt)
+            })
+            if len(res)%2==0:
+                print(f"Completed {len(res)} out of 300")
+                with open(save_path, 'w') as outfile:
+                    json.dump(res, outfile, indent=2)
+        except Exception as e:
+            print(f"Error at {ind} {version}: {e}")
+        # print(prompt)
+        # assert False
+with open(save_path, 'w') as outfile:
+    json.dump(res, outfile, indent=2)

code/old/synthetic_data_generationV3.py

@@ -0,0 +1,348 @@
+import os
+import json
+import time
+from openai import OpenAI
+import tqdm
+
+
+client = OpenAI(api_key=json.load(open('/home/mshahidul/api.json', 'r'))['openai_api_key'])
+
+
+# MODIFICATION: Create a dictionary to hold prompts for multiple languages.
+ALL_PROMPTS = {
+    "en": {
+        "B1": """You are a summarization assistant. Your single most important goal is to rewrite medical text for a first-grade reading level (ages 5-7, FKGL 1.0-4.0). Simplicity is more important than detail.
+
+Core Mandate:
+- TARGET AUDIENCE: A 6-year-old child.
+- PRIMARY GOAL: Extreme simplicity. If you must choose between accuracy of detail and simplicity, ALWAYS choose simplicity.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Keep almost all sentences under 10 words. Use very short, simple sentences.
+- VOCABULARY: Use only very common, everyday words that a first-grader would know. Avoid any medical or scientific terms. Instead of 'femur', say 'thigh bone'. Instead of 'benign', say 'not harmful'.
+- TONE: Be very gentle, calm, and reassuring. Like a kind doctor explaining something to a small child.
+- STRUCTURE: Use short paragraphs, often just one or two sentences long.
+- FOCUS: Only mention the most important one or two points from the original text. Omit all other details.
+
+- Never use emojis.
+- Do not explain pronunciation.
+- DO NOT use any medical jargon.
+""",
+    "B2": """You are a summarization assistant trained to rewrite medical summaries for a middle school reading level (ages 11–14, FKGL 6.0–9.0). Your goal is clarity for a teenager with a basic understanding of biology.
+
+Core Mandate:
+- TARGET AUDIENCE: A 14-year-old in a 9th-grade biology class.
+- PRIMARY GOAL: Clarity and straightforward explanation.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Vary sentence length, but aim for an average of 12-18 words. Avoid long, complex sentences.
+- VOCABULARY: You can use basic medical terms (e.g., 'biopsy', 'cells', 'tumor'), but you MUST explain them in simple terms immediately. For example: "A biopsy, which is when a small piece of tissue is taken for testing...".
+- TONE: Be empathetic but direct. Use an educational and informative tone, like a science teacher.
+- STRUCTURE: Organize the summary into logical paragraphs. You can use simple headings if it helps clarity (e.g., "What They Found," "What It Means").
+- FOCUS: Summarize the main findings and their implications. Omit minor or highly technical details.
+
+- Never use emojis.
+- Do not explain pronunciation.
+""",
+    "B3": """You are a summarization assistant trained to rewrite medical summaries for an educated, non-medical adult (ages 17+, FKGL 12.0+). Your goal is to be precise, comprehensive, and clear for a college-level reader.
+
+Core Mandate:
+- TARGET AUDIENCE: A curious college student or adult with no medical training.
+- PRIMARY GOAL: Precision and structured clarity.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Use clear, well-constructed sentences. Complex sentences are acceptable if they enhance clarity and precision.
+- VOCABULARY: Use correct medical terminology. You can assume the reader can understand terms from context or look them up, but for very specialized terms, provide a brief parenthetical explanation. For example: "...showed evidence of hyperplasia (an increase in the number of cells)."
+- TONE: Maintain a professional, empathetic, and respectful tone. Be authoritative but not clinical or cold.
+- STRUCTURE: Provide a detailed and structured summary. Use headings to organize information, such as "Background," "Key Findings," "Clinical Interpretation," and "Next Steps."
+- FOCUS: Be comprehensive and faithful to the source summary. Include important details, test results, and differential diagnoses mentioned in the source.
+
+- Never use emojis.
+- Do not explain pronunciation.
+"""
+    },
+    "es": {
+        "B1": """Eres un asistente de resumen. Tu único y más importante objetivo es reescribir texto médico para un nivel de lectura de primer grado (edades 5-7). La simplicidad es más importante que el detalle.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un niño de 6 años.
+- OBJETIVO PRIMARIO: Simplicidad extrema. Si debes elegir entre la precisión del detalle y la simplicidad, SIEMPRE elige la simplicidad.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Casi todas las oraciones deben tener menos de 10 palabras. Usa frases muy cortas y simples.
+- VOCABULARIO: Usa solo palabras cotidianas y muy comunes que un niño de primer grado conocería. Evita cualquier término médico o científico. En lugar de 'fémur', di 'hueso del muslo'. En lugar de 'benigno', di 'que no es dañino'.
+- TONO: Sé muy gentil, calmado y tranquilizador. Como un doctor amable explicándole algo a un niño pequeño.
+- ESTRUCTURA: Usa párrafos cortos, a menudo de solo una o dos oraciones.
+- ENFOQUE: Menciona solo el punto más importante o los dos puntos más importantes del texto original. Omite todos los demás detalles.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+- NO uses jerga médica.
+""",
+        "B2": """Eres un asistente de resumen entrenado para reescribir resúmenes médicos para un nivel de lectura de secundaria (edades 11–14). Tu objetivo es la claridad para un adolescente con conocimientos básicos de biología.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un estudiante de 14 años en una clase de biología de secundaria.
+- OBJETIVO PRIMARIO: Claridad y explicación directa.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Varía la longitud de las oraciones, pero busca un promedio de 12-18 palabras. Evita las oraciones largas y complejas.
+- VOCABULARIO: Puedes usar términos médicos básicos (ej., 'biopsia', 'células', 'tumor'), pero DEBES explicarlos en términos sencillos inmediatamente. Por ejemplo: "Una biopsia, que es cuando se toma un pequeño trozo de tejido para analizarlo...".
+- TONO: Sé empático pero directo. Usa un tono educativo e informativo, como un profesor de ciencias.
+- ESTRUCTURA: Organiza el resumen en párrafos lógicos. Puedes usar encabezados simples si ayuda a la claridad (ej., "Lo que Encontraron," "Qué Significa").
+- ENFOQUE: Resume los hallazgos principales y sus implicaciones. Omite detalles menores o muy técnicos.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+""",
+        "B3": """Eres un asistente de resumen entrenado para reescribir resúmenes médicos para un adulto educado no médico (edades 17+). Tu objetivo es ser preciso, completo y claro para un lector de nivel universitario.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un estudiante universitario o un adulto curioso sin formación médica.
+- OBJETIVO PRIMARIO: Precisión y claridad estructurada.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Usa oraciones claras y bien construidas. Las oraciones complejas son aceptables si mejoran la claridad y la precisión.
+- VOCABULARIO: Usa la terminología médica correcta. Puedes asumir que el lector puede entender los términos por el contexto o buscarlos, pero para términos muy especializados, proporciona una breve explicación entre paréntesis. Por ejemplo: "...mostró evidencia de hiperplasia (un aumento en el número de células)."
+- TONO: Mantén un tono profesional, empático y respetuoso. Sé autoritario pero no clínico o frío.
+- ESTRUCTURA: Proporciona un resumen detallado y estructurado. Usa encabezados para organizar la información, como "Contexto," "Hallazgos Clave," "Interpretación Clínica," y "Próximos Pasos."
+- ENFOQUE: Sé completo y fiel al resumen original. Incluye detalles importantes, resultados de pruebas y diagnósticos diferenciales mencionados en la fuente.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+"""
+    },
+"fr": {
+    "B1": """Vous êtes un assistant de résumé. Votre unique et plus important objectif est de réécrire un texte médical pour un niveau de lecture de cours préparatoire (âges 5-7). La simplicité est plus importante que le détail.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un enfant de 6 ans.
+- OBJECTIF PRINCIPAL : Simplicité extrême. Si vous devez choisir entre la précision des détails et la simplicité, choisissez TOUJOURS la simplicité.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Presque toutes les phrases doivent faire moins de 10 mots. Utilisez des phrases très courtes et simples.
+- VOCABULAIRE : Utilisez uniquement des mots très courants et quotidiens qu'un enfant de cet âge connaîtrait. Évitez tout terme médical ou scientifique. Au lieu de 'fémur', dites 'l'os de la cuisse'. Au lieu de 'bénin', dites 'pas dangereux'.
+- TON : Soyez très doux, calme et rassurant. Comme un médecin bienveillant qui explique quelque chose à un jeune enfant.
+- STRUCTURE : Utilisez des paragraphes courts, souvent composés d'une ou deux phrases seulement.
+- ENFOQUE : Mentionnez uniquement le ou les deux points les plus importants du texte original. Omettez tous les autres détails.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+- N'utilisez AUCUN jargon médical.
+""",
+    "B2": """Vous êtes un assistant de résumé entraîné à réécrire des résumés médicaux pour un niveau de lecture de collège (âges 11–14). Votre objectif est la clarté pour un adolescent ayant une compréhension de base de la biologie.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un adolescent de 14 ans en classe de biologie au collège.
+- OBJECTIF PRINCIPAL : Clarté et explication directe.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Variez la longueur des phrases, mais visez une moyenne de 12-18 mots. Évitez les phrases longues et complexes.
+- VOCABULAIRE : Vous pouvez utiliser des termes médicaux de base (ex: 'biopsie', 'cellules', 'tumeur'), mais vous DEVEZ les expliquer en termes simples immédiatement. Par exemple : "Une biopsie, c'est-à-dire quand on prélève un petit morceau de tissu pour l'analyser...".
+- TON : Soyez empathique mais direct. Adoptez un ton pédagogique et informatif, comme un professeur de sciences.
+- STRUCTURE : Organisez le résumé en paragraphes logiques. Vous pouvez utiliser des titres simples si cela améliore la clarté (ex: "Ce qu'ils ont trouvé", "Ce que cela signifie").
+- ENFOQUE : Résumez les principales observations et leurs implications. Omettez les détails mineurs ou très techniques.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+""",
+    "B3": """Vous êtes un assistant de résumé entraîné à réécrire des résumés médicaux pour un adulte éduqué non-médecin (âges 17+). Votre objectif est d'être précis, complet et clair pour un lecteur de niveau universitaire.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un étudiant ou un adulte curieux sans formation médicale.
+- OBJECTIF PRINCIPAL : Précision et clarté structurée.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Utilisez des phrases claires et bien construites. Les phrases complexes sont acceptables si elles améliorent la clarté et la précision.
+- VOCABULAIRE : Utilisez la terminologie médicale correcte. Vous pouvez supposer que le lecteur peut comprendre les termes par le contexte ou les rechercher, mais pour les termes très spécialisés, fournissez une brève explication entre parenthèses. Par exemple : "...montrait des signes d'hyperplasie (une augmentation du nombre de cellules)."
+- TON : Maintenez un ton professionnel, empathique et respectueux. Soyez directif mais ni clinique ni froid.
+- STRUCTURE : Fournissez un résumé détaillé et structuré. Utilisez des titres pour organiser l'information, tels que "Contexte", "Principales Observations", "Interprétation Clinique" et "Prochaines Étapes".
+- ENFOQUE : Soyez complet et fidèle au résumé source. Incluez les détails importants, les résultats des tests et les diagnostics différentiels mentionnés dans la source.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+"""
+},
+
+"pt": {
+    "B1": """Você é um assistente de resumo. O seu único e mais importante objetivo é reescrever textos médicos para um nível de leitura da primeira série (idades 5-7). A simplicidade é mais importante que os detalhes.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Uma criança de 6 anos.
+- OBJETIVO PRINCIPAL: Simplicidade extrema. Se tiver que escolher entre a precisão dos detalhes e a simplicidade, ESCOLHA SEMPRE a simplicidade.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Quase todas as frases devem ter menos de 10 palavras. Use frases muito curtas e simples.
+- VOCABULÁRIO: Use apenas palavras quotidianas e muito comuns que uma criança da primeira série conheceria. Evite qualquer termo médico ou científico. Em vez de 'fêmur', diga 'o osso da coxa'. Em vez de 'benigno', diga 'que não faz mal'.
+- TOM: Seja muito gentil, calmo e tranquilizador. Como um médico amável a explicar algo a uma criança pequena.
+- ESTRUTURA: Use parágrafos curtos, muitas vezes com apenas uma ou duas frases.
+- FOCO: Mencione apenas um ou dois dos pontos mais importantes do texto original. Omita todos os outros detalhes.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+- NÃO use NENHUM jargão médico.
+""",
+    "B2": """Você é um assistente de resumo treinado para reescrever resumos médicos para um nível de leitura do ensino fundamental II (idades 11–14). O seu objetivo é a clareza para um adolescente com conhecimentos básicos de biologia.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Um adolescente de 14 anos numa aula de biologia.
+- OBJETIVO PRINCIPAL: Clareza e explicação direta.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Varie o comprimento das frases, mas procure uma média de 12 a 18 palavras. Evite frases longas e complexas.
+- VOCABULÁRIO: Pode usar termos médicos básicos (ex: 'biópsia', 'células', 'tumor'), mas você DEVE explicá-los em termos simples imediatamente. Por exemplo: "Uma biópsia, que é quando um pequeno pedaço de tecido é retirado para ser analisado...".
+- TOM: Seja empático, mas direto. Use um tom educativo e informativo, como um professor de ciências.
+- ESTRUTURA: Organize o resumo em parágrafos lógicos. Pode usar títulos simples se isso ajudar na clareza (ex: "O que eles encontraram", "O que isso significa").
+- FOCO: Resuma os principais achados e as suas implicações. Omita detalhes menores ou muito técnicos.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+""",
+    "B3": """Você é um assistente de resumo treinado para reescrever resumos médicos para um adulto instruído, mas sem formação médica (idades 17+). O seu objetivo é ser preciso, abrangente e claro para um leitor de nível universitário.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Um estudante universitário ou adulto curioso sem formação médica.
+- OBJETIVO PRINCIPAL: Precisão e clareza estruturada.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Use frases claras e bem construídas. Frases complexas são aceitáveis se melhorarem a clareza e a precisão.
+- VOCABULÁRIO: Use a terminologia médica correta. Pode assumir que o leitor consegue entender os termos pelo contexto ou pesquisá-los, mas para termos muito especializados, forneça uma breve explicação entre parênteses. Por exemplo: "...mostrou evidência de hiperplasia (um aumento no número de células)."
+- TOM: Mantenha um tom profissional, empático e respeitoso. Seja confiante, mas não clínico ou frio.
+- ESTRUTURA: Forneça um resumo detalhado e estruturado. Use títulos para organizar a informação, como "Contexto", "Principais Achados", "Interpretação Clínica" e "Próximos Passos".
+- FOCO: Seja abrangente e fiel ao resumo original. Inclua detalhes importantes, resultados de testes e diagnósticos diferenciais mencionados na fonte.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+"""
+}
+
+}
+USER_PROMPT_TEMPLATES = {
+    "en": """Please rewrite the following expert summary for the specified target audience. Use the full article for context if needed.
+**Full Article Context:**
+{article}
+**Expert Summary to Rewrite:**
+{gold_summary}
+""",
+    "es": """Por favor, reescribe el siguiente resumen de experto para el público objetivo especificado. Usa el artículo completo como contexto si es necesario.
+**Contexto del Artículo Completo:**
+{article}
+**Resumen de Experto a Reescribir:**
+{gold_summary}
+""",
+    "fr": """Veuillez réécrire le résumé d'expert suivant pour le public cible spécifié. Utilisez l'article complet comme contexte si nécessaire.
+**Contexte de l'Article Complet :**
+{article}
+**Résumé d'Expert à Réécrire :**
+{gold_summary}
+""",
+    "pt": """Por favor, reescreva o seguinte resumo de especialista para o público-alvo especificado. Use o artigo completo como contexto, se necessário.
+**Contexto do Artigo Completo:**
+{article}
+**Resumo do Especialista a Ser Reescrito:**
+{gold_summary}
+"""
+}
+
+def generate_synthetic_summary(article, gold_summary, band, lang):
+    """Call an OpenAI model to generate a synthetic summary for a given readability band and language."""
+    prompts_for_lang = ALL_PROMPTS.get(lang)
+    user_prompt_template = USER_PROMPT_TEMPLATES.get(lang)
+    if not prompts_for_lang or not user_prompt_template:
+        raise ValueError(f"No prompts available for language: {lang}")
+    
+    system_prompt = prompts_for_lang[band]
+    user_prompt = user_prompt_template.format(article=article, gold_summary=gold_summary)
+    
+    for attempt in range(3):
+        try:
+            response = client.chat.completions.create(
+                model="gpt-4.1-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.3
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"API call failed on attempt {attempt + 1} for band {band}: {e}")
+            if attempt < 2:
+                time.sleep(5)
+            else:
+                print(f"Failed to generate summary for band {band} after 3 attempts.")
+                return None
+
+def build_synthetic_dataset(input_path, output_path, lang, max_samples=None):
+    """Generate a synthetic dataset from a JSON file for a specific language."""
+    results = []
+    processed_articles = set()
+    if os.path.exists(output_path):
+        with open(output_path, 'r', encoding='utf-8') as f:
+            try:
+                results = json.load(f)
+                processed_articles = {item['article'] for item in results}
+                print(f"Loaded {len(results)} existing records from {output_path}.")
+            except json.JSONDecodeError:
+                print(f"Warning: Could not decode JSON from {output_path}. Starting fresh.")
+                results = []
+
+    with open(input_path, "r", encoding='utf-8') as f:
+        data = json.load(f)
+        
+        items_to_process = [item for item in data if item["fulltext"] not in processed_articles]
+        print(f"Found {len(items_to_process)} new articles to process.")
+        
+        for item in tqdm.tqdm(items_to_process):
+            if max_samples and len(results) >= max_samples:
+                print(f"Reached max_samples limit of {max_samples}.")
+                break
+                
+            article, gold = item["fulltext"], item["summary"]
+            
+            synthetic_summaries = {}
+            all_bands_successful = True
+            for band in ["B1", "B2", "B3"]:
+                synthetic = generate_synthetic_summary(article, gold, band, lang=lang)
+                if synthetic:
+                    synthetic_summaries[band] = synthetic
+                else:
+                    all_bands_successful = False
+                    break
+            
+            if all_bands_successful:
+                results.append({
+                    "article": article,
+                    "gold_summary": gold,
+                    "synthetic_summary": synthetic_summaries
+                })
+
+            if len(results) % 5 == 0 and len(results) > len(processed_articles):
+                print(f"Processed {len(results)} total samples, saving progress...")
+                with open(output_path, "w", encoding='utf-8') as f:
+                    json.dump(results, f, ensure_ascii=False, indent=4)
+
+    print("Generation complete. Saving final dataset...")
+    with open(output_path, "w", encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=4)
+    print(f"Dataset saved to {output_path}")
+
+# --- Example Usage for English ---
+# To run for English, set lang = "en" and point to your English data file.
+lang = "pt" 
+path = f"/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_{lang}.json" 
+output_file = f"/home/mshahidul/readctrl/generating_data/{lang}_syntheticV1.json" 
+if os.path.exists(output_file):
+    temp=output_file.split("/")[-1].replace(".json","")
+    output_file = f"/home/mshahidul/readctrl/generating_data/{lang}_syntheticV{int(temp[-1])+1}.json"
+
+build_synthetic_dataset(path, output_file, lang=lang, max_samples=100)

code/old/sz_es.py

@@ -0,0 +1,68 @@
+import re
+import pyphen
+
+# --- Basic Spanish text stats ---
+_dic = pyphen.Pyphen(lang='es_ES')
+
+_word_re = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
+
+def _tokenize_words(text):
+    return _word_re.findall(text)
+
+def _count_sentences(text):
+    # Split on ., !, ?, and Spanish ¡¿ — keep it simple
+    parts = re.split(r"[.!?¡¿]+", text)
+    return max(1, sum(1 for p in parts if p.strip()))
+
+def _count_syllables_es(word):
+    parts = _dic.hyphenate(word)
+    return (len(parts) + 1) if parts else 1
+
+def _text_stats_es(text):
+    words = _tokenize_words(text)
+    W = len(words)
+    S = _count_sentences(text)
+    syl = sum(_count_syllables_es(w) for w in words) if W else 0
+    LW = sum(1 for w in words if len(w) > 6)  # LIX long words (>6 chars)
+    return W, S, syl, LW
+
+# --- Szigriszt–Pazos (INFLESZ) ---
+def szigriszt_pazos(text):
+    W, S, syl, _ = _text_stats_es(text)
+    if W == 0 or S == 0:
+        return None
+    # Reading ease: higher = easier
+    return 206.835 - 62.3 * (syl / W) - (W / S)
+
+# --- LIX (language-agnostic) ---
+def lix(text):
+    W, S, _, LW = _text_stats_es(text)
+    if W == 0 or S == 0:
+        return None
+    return (W / S) + (100.0 * LW / W)
+
+# Example bands (tune to your corpus)
+SZ_BANDS = {
+    'B1': (65, 100),  # easy to very easy
+    'B2': (55, 65),   # normal
+    'B3': (40, 55),   # somewhat hard
+}
+
+LIX_BANDS = {
+    'B1': (20, 35),   # easier
+    'B2': (35, 45),   # mid
+    'B3': (45, 60),   # harder
+}
+
+def in_band(score, band, bands, delta=0.0):
+    if score is None:
+        return False
+    lo, hi = bands[band]
+    return (lo - delta) <= score <= (hi + delta)
+
+# Example usage
+text = "Las vacunas salvan millones de vidas cada año. Son seguras y eficaces."
+sz = szigriszt_pazos(text)
+lx = lix(text)
+# print("Szigriszt:", sz, "B1?", in_band(sz, 'B1', SZ_BANDS, delta=2))
+# print("LIX:", lx, "B1?", in_band(lx, 'B1', LIX_BANDS, delta=2))

code/rc.py

@@ -0,0 +1,44 @@
+import os
+import json
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument("--g", type=str, default="2", help="GPU ID")
+args = parser.parse_args()
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = str(args.g)
+
+import torch
+import time
+
+# Set the specific GPU device (change the index if it's not GPU 0; check with nvidia-smi)
+# torch.cuda.set_device(0)
+
+# Get total memory in bytes (should be around 85e9 for A100 80GB, but use reported value)
+total_memory = torch.cuda.get_device_properties(0).total_memory
+
+# List to hold allocated tensors
+allocated_tensors = []
+
+# Chunk size: Allocate in 4GB chunks to avoid fragmentation issues (adjust if needed)
+chunk_size_bytes = 4 * 1024**3  # 4 GiB
+chunk_elements = chunk_size_bytes // torch.tensor([], dtype=torch.float32).element_size()
+
+try:
+    allocated = 0
+    while allocated < total_memory * 0.85:  # Allocate up to 95% to leave some headroom
+        chunk = torch.empty(chunk_elements, dtype=torch.float32, device='cuda')
+        allocated_tensors.append(chunk)
+        allocated += chunk_size_bytes
+        # Optional: Touch the memory to force allocation
+        chunk.zero_()
+        torch.cuda.synchronize()
+except RuntimeError as e:
+    if 'out of memory' in str(e).lower():
+        print(f"Allocated approximately {allocated / (1024**3):.2f} GB. Holding VRAM on A100.")
+    else:
+        raise e
+
+# Hold the memory indefinitely
+print("VRAM occupied. Running forever to hold it.")
+while True:
+    time.sleep(3600)  # Sleep 1 hour to minimize CPU usage; script will hold until killed

code/readability_final_res_process.ipynb

@@ -0,0 +1,349 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30a7b117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "# Define the file paths\n",
+    "file_paths = [\n",
+    "    '/home/mshahidul/readctrl/data/reasoning/refined_evaluated_support_0_100_qwen3-32B.json',\n",
+    "    '/home/mshahidul/readctrl/data/reasoning/refined_evaluated_support_100_200_qwen3-32B.json',\n",
+    "    '/home/mshahidul/readctrl/data/reasoning/refined_evaluated_support_200_300_qwen3-32B.json'\n",
+    "]\n",
+    "\n",
+    "merged_data = []\n",
+    "\n",
+    "# Loop through and append data\n",
+    "for file_path in file_paths:\n",
+    "    if os.path.exists(file_path):\n",
+    "        with open(file_path, 'r', encoding='utf-8') as f:\n",
+    "            data = json.load(f)\n",
+    "            # Assuming each file contains a list of objects\n",
+    "            if isinstance(data, list):\n",
+    "                merged_data.extend(data)\n",
+    "            else:\n",
+    "                merged_data.append(data)\n",
+    "        print(f\"Successfully loaded: {file_path}\")\n",
+    "    else:\n",
+    "        print(f\"Warning: File not found: {file_path}\")\n",
+    "\n",
+    "# Save the merged result\n",
+    "output_path = '/home/mshahidul/readctrl/data/reasoning/refined_evaluated_support_merged_0_300_qwen3-32B.json'\n",
+    "with open(output_path, 'w', encoding='utf-8') as f:\n",
+    "    json.dump(merged_data, f, indent=4)\n",
+    "\n",
+    "print(f\"\\nTotal records merged: {len(merged_data)}\")\n",
+    "print(f\"Merged file saved to: {output_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "27ab3270",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "# Define file paths\n",
+    "readability_path = '/home/mshahidul/readctrl/data/classified_readability/classified_multiclinsum_test_en.json'\n",
+    "reasoning_path = '/home/mshahidul/readctrl/data/reasoning/refined_evaluated_support_merged_0_300_qwen3-32B.json'\n",
+    "output_path = '/home/mshahidul/readctrl/data/reasoning/merged_readability_reasoning_en_final.json'\n",
+    "\n",
+    "# 1. Load the readability data and create a lookup map\n",
+    "with open(readability_path, 'r') as f:\n",
+    "    readability_data = json.load(f)\n",
+    "\n",
+    "# Create a dictionary for O(1) lookup: {id: score}\n",
+    "readability_lookup = {item['id']: item['readability_score'] for item in readability_data}\n",
+    "\n",
+    "# 2. Load the reasoning data\n",
+    "with open(reasoning_path, 'r') as f:\n",
+    "    reasoning_data = json.load(f)\n",
+    "\n",
+    "# 3. Merge the scores into the reasoning data\n",
+    "merged_count = 0\n",
+    "for entry in reasoning_data:\n",
+    "    entry_id = entry.get('id')\n",
+    "    if entry_id in readability_lookup:\n",
+    "        # Add the score to the existing dictionary\n",
+    "        entry['readability_score'] = readability_lookup[entry_id]\n",
+    "        merged_count += 1\n",
+    "    else:\n",
+    "        # Optional: Handle cases where an ID is missing in the readability file\n",
+    "        entry['readability_score'] = None\n",
+    "\n",
+    "# 4. Save the merged result\n",
+    "with open(output_path, 'w') as f:\n",
+    "    json.dump(reasoning_data, f, indent=4)\n",
+    "\n",
+    "print(f\"Successfully merged {merged_count} records. Saved to {output_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2ef2e0b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Threshold set to: 90.0%\n",
+      "Successfully saved 192 records to: /home/mshahidul/readctrl/data/final_result/processed_threshold_results.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "# Configuration\n",
+    "input_file = '/home/mshahidul/readctrl/data/reasoning/merged_readability_reasoning_en_final.json'\n",
+    "output_dir = '/home/mshahidul/readctrl/data/final_result'\n",
+    "output_filename = 'processed_threshold_results.json'\n",
+    "\n",
+    "# Set your threshold here (e.g., 0.90 for 90%, 0.85 for 85%)\n",
+    "SUPPORT_THRESHOLD = 0.90 \n",
+    "\n",
+    "def process_with_threshold(threshold):\n",
+    "    # Ensure the output folder exists\n",
+    "    if not os.path.exists(output_dir):\n",
+    "        os.makedirs(output_dir)\n",
+    "\n",
+    "    # Load the source data\n",
+    "    try:\n",
+    "        with open(input_file, 'r') as f:\n",
+    "            data = json.load(f)\n",
+    "    except FileNotFoundError:\n",
+    "        print(f\"Error: Source file not found at {input_file}\")\n",
+    "        return\n",
+    "\n",
+    "    final_output = []\n",
+    "\n",
+    "    for item in data:\n",
+    "        evals = item.get('subclaim_evaluations', [])\n",
+    "        \n",
+    "        if not evals:\n",
+    "            continue  # Skip items with no subclaims to evaluate\n",
+    "            \n",
+    "        # Calculate the percentage of supported subclaims\n",
+    "        supported_count = sum(1 for sub in evals if sub.get('support_label') == 'supported')\n",
+    "        support_ratio = supported_count / len(evals)\n",
+    "        \n",
+    "        # Keep if it meets the threshold (e.g., 0.90)\n",
+    "        if support_ratio >= threshold:\n",
+    "            clean_item = item.copy()\n",
+    "            \n",
+    "            # Map readability_score to difficulty\n",
+    "            score = clean_item.get('readability_score', 0)\n",
+    "            if score >= 4:\n",
+    "                clean_item['difficulty'] = 'easy'\n",
+    "            elif score == 3:\n",
+    "                clean_item['difficulty'] = 'medium'\n",
+    "            else:\n",
+    "                clean_item['difficulty'] = 'hard'\n",
+    "            \n",
+    "            # Add metadata about the support ratio for transparency\n",
+    "            clean_item['support_percentage'] = round(support_ratio * 100, 2)\n",
+    "            \n",
+    "            # Remove the subclaim_evaluations field\n",
+    "            if 'subclaim_evaluations' in clean_item:\n",
+    "                del clean_item['subclaim_evaluations']\n",
+    "            \n",
+    "            final_output.append(clean_item)\n",
+    "\n",
+    "    # Save to a single JSON file\n",
+    "    target_path = os.path.join(output_dir, output_filename)\n",
+    "    with open(target_path, 'w', encoding='utf-8') as out_f:\n",
+    "        json.dump(final_output, out_f, indent=4, ensure_ascii=False)\n",
+    "    \n",
+    "    print(f\"Threshold set to: {threshold * 100}%\")\n",
+    "    print(f\"Successfully saved {len(final_output)} records to: {target_path}\")\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    process_with_threshold(SUPPORT_THRESHOLD)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "295a4a2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Success! Merged data saved to: /home/mshahidul/readctrl/data/factual_testing/merged_evaluated_support_0_300.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "# List of file paths to merge\n",
+    "file_paths = [\n",
+    "    '/home/mshahidul/readctrl/data/factual_testing/evaluated_support_0_100_qwen3-32B.json',\n",
+    "    '/home/mshahidul/readctrl/data/factual_testing/evaluated_support_100_200_qwen3-32B.json',\n",
+    "    '/home/mshahidul/readctrl/data/factual_testing/evaluated_support_200_300_qwen3-32B.json'\n",
+    "]\n",
+    "\n",
+    "merged_data = []\n",
+    "\n",
+    "# Iterate through each file and append its contents to the list\n",
+    "for file_path in file_paths:\n",
+    "    if os.path.exists(file_path):\n",
+    "        with open(file_path, 'r', encoding='utf-8') as f:\n",
+    "            data = json.load(f)\n",
+    "            # If the JSON is a list, extend the merged list\n",
+    "            if isinstance(data, list):\n",
+    "                merged_data.extend(data)\n",
+    "            # If the JSON is a single dictionary, append it\n",
+    "            else:\n",
+    "                merged_data.append(data)\n",
+    "    else:\n",
+    "        print(f\"Warning: File not found - {file_path}\")\n",
+    "\n",
+    "# Save the combined data to a new file\n",
+    "output_file = '/home/mshahidul/readctrl/data/factual_testing/merged_evaluated_support_0_300.json'\n",
+    "\n",
+    "with open(output_file, 'w', encoding='utf-8') as f:\n",
+    "    json.dump(merged_data, f, indent=4)\n",
+    "\n",
+    "print(f\"Success! Merged data saved to: {output_file}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e7ba1534",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Updating scores for 100 documents...\n",
+      "Successfully updated scores for 100 documents.\n",
+      "File saved to: /home/mshahidul/readctrl/data/reasoning/updated_scores/refined_v2_full_evaluation_200_300_qwen3-32B.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "def calculate_scores(data):\n",
+    "    \"\"\"\n",
+    "    Recalculates factual_attribution and completeness scores based on \n",
+    "    the updated labels in attribution_details and completeness_details.\n",
+    "    \"\"\"\n",
+    "    updated_count = 0\n",
+    "\n",
+    "    for doc in data:\n",
+    "        # 1. Recalculate Factual Attribution Score\n",
+    "        attribution_list = doc.get('attribution_details', [])\n",
+    "        if attribution_list:\n",
+    "            supported_attr = sum(1 for item in attribution_list if item.get('label') == 'supported')\n",
+    "            doc['scores']['factual_attribution'] = supported_attr / len(attribution_list)\n",
+    "        else:\n",
+    "            doc['scores']['factual_attribution'] = 0.0\n",
+    "\n",
+    "        # 2. Recalculate Completeness Score\n",
+    "        completeness_list = doc.get('completeness_details', [])\n",
+    "        if completeness_list:\n",
+    "            supported_comp = sum(1 for item in completeness_list if item.get('present_in_summary') == 'supported')\n",
+    "            doc['scores']['completeness'] = supported_comp / len(completeness_list)\n",
+    "        else:\n",
+    "            doc['scores']['completeness'] = 0.0\n",
+    "            \n",
+    "        updated_count += 1\n",
+    "\n",
+    "    return data, updated_count\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    # parser = argparse.ArgumentParser(description=\"Update scores in refined clinical evaluation JSON.\")\n",
+    "    # parser.add_argument(\"--input_file\", type=str, required=True, help=\"Path to the refined JSON file.\")\n",
+    "    # parser.add_argument(\"--output_file\", type=str, help=\"Path to save the updated JSON. If omitted, overwrites input.\")\n",
+    "    # args = parser.parse_args()\n",
+    "    input_file = '/home/mshahidul/readctrl/data/reasoning/refined_v2_full_evaluation_200_300_qwen3-32B.json'\n",
+    "    output_path = \"/home/mshahidul/readctrl/data/reasoning/updated_scores\"\n",
+    "    output_file = os.path.join(output_path, os.path.basename(input_file))\n",
+    "    # Load data\n",
+    "    with open(input_file, 'r') as f:\n",
+    "        data = json.load(f)\n",
+    "\n",
+    "    print(f\"Updating scores for {len(data)} documents...\")\n",
+    "    \n",
+    "    # Process\n",
+    "    updated_data, count = calculate_scores(data)\n",
+    "\n",
+    "   \n",
+    "    \n",
+    "    # Save results\n",
+    "    with open(output_file, 'w') as f:\n",
+    "        json.dump(updated_data, f, indent=2, ensure_ascii=False)\n",
+    "\n",
+    "    print(f\"Successfully updated scores for {count} documents.\")\n",
+    "    print(f\"File saved to: {output_file}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "612109dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['index', 'id', 'fulltext', 'fulltext_subclaims', 'summary', 'summary_subclaims', 'diff_label_texts', 'diff_label_subclaims', 'readability_score'])\n",
+      "dict_keys(['low_health_literacy', 'intermediate_health_literacy', 'proficient_health_literacy'])\n",
+      "dict_keys(['low_health_literacy', 'intermediate_health_literacy', 'proficient_health_literacy'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# /home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_syn_data_with_gs_summary_en.json\n",
+    "import json\n",
+    "with open('/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_syn_data_with_gs_summary_en.json', 'r') as f:\n",
+    "    anno_data = json.load(f)\n",
+    "print(anno_data[0].keys())\n",
+    "print(anno_data[0]['diff_label_texts'].keys())\n",
+    "print(anno_data[0]['diff_label_subclaims'].keys())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "un",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/test.ipynb

@@ -0,0 +1,64 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25745a03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# /home/mshahidul/readctrl/data/translated_data/translation_wo_judge/multiclinsum_gs_train_en2bn_gemma(0_200).json\n",
+    "import json\n",
+    "with open(\"/home/mshahidul/readctrl/data/translated_data/translation_wo_judge/multiclinsum_gs_train_en2bn_gemma(0_200).json\", \"r\") as f:\n",
+    "    data = json.load(f)\n",
+    "\n",
+    "for item in data:\n",
+    "    \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a170a10b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'14-year-old previously healthy adolescent who presented to the Primary Emergency Care Service (PEC) of Osorno with a 11-day history of a predominantly nocturnal irritative cough. Symptomatic treatment was indicated, evolving with dyspnoea and orthopnoea. He presented to the Emergency Department of the Osorno Base Hospital (OBH), with severe respiratory distress, intolerance to supine position, and abdominal pain. He was admitted to the Paediatric Intensive Care Unit (PICU), tachycardic, hypertensive, polypneic, oxygen saturation 96% with FiO2 35%, rosy, hydrated and well perfused, with flat jugular veins, small bilateral supraclavicular lymphadenopathies. The thorax was without retraction of soft tissue, maintained in a genupectoral position, with decreased pulmonary murmurs in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The soft abdomen was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and the cardiac auscultation had muffled tones, without breath sounds. The abdominal soft tissue was not easily depressible and sensitive in both hypochondria, with doubtful visceral enlargements and no injuries. The chest radiograph showed a superior mediastinal mass and atelectasis of the right middle lobe associated with ipsilateral pleural effusion. Contrast-enhanced chest X-ray was not performed due to contraindication of anaesthesia, as stated in the summary of transfer from OBH. He was transferred in a serious condition to the PICU HBV, with a Mediastinal Compression Syndrome, with clinical suspicion of non-Hodgkin lymphoma. He was evaluated by the paediatric haemato-oncology, paediatric surgery, paediatric intensive care, imaging, radiotherapy and paediatric oncology teams, with a normal pulmonary murmur in both bases, and\\n\\nA nephrological evaluation was performed, which confirmed renal failure secondary to tumor lysis syndrome, without dialysis urgency and tendency to hypertension, with creatinine 1.54 mg/dL, phosphemia 11 mg/dL, without hypernatremia. It continued with hyperhydration, diuretic (furosemide) and antihypertensive (amlodipine). From the respiratory point of view, it presented oxygen requirement, with FIO2 35% by mask of Venturi, suspending this supply on the third day of admission. It evolved with episodes of psychomotor agitation, associated to the diagnosis in process, which was treated according to the institutional protocol of psychomotor agitation, with psychological and psychiatric support, with satisfactory evolution. On the third day of admission and treatment a CT scan of the thorax, abdomen and pelvis was performed with contrast, observing an increase in the size of the thymus, of homogeneous aspect, probably in the context of a lymphoproliferative process and findings suggestive of pulmonary thromboembolism. The angioCT of the thorax showed thrombosis of the jugular vein, extensive bilateral pleural effusion associated to atelectatic phenomena in both bases, with signs of medical bilateral nephrosis. Anticoagulation with enoxaparin (1 mg/kg dose, every 12 hours) was indicated for twenty days. Then the angioCT of control showed resolution of the thrombosis.On the fourth day of admission and treatment, a diagnostic and extension study was performed, which included, among others, a complete biochemical profile including lipid profile, granulopoietic hyperplasia of the bone marrow (myelogram), flow cytometry (bone marrow) in which no cells with a predominant clonal or neoplastic immunophenotype of haemological lineage were observed, flow cytometry in peripheral blood negative for neoplastic cells, cytological of pleural fluid negative for neoplastic cells, flow cytometry of pleural fluid without evidence of haemological neoplasia. It was presented to the paediatric oncological committee, highlighting that it was not possible to take a biopsy of the tumour given that the mediastinal mass disappeared with the cytoreductive treatment, assuming the diagnosis of lymphoblastic lymphoma by the clinical picture and the response to treatment, according to the PINDA 0516 protocol. This protocol contemplates in Induction IA eight doses of Lasp E. coli of 10,000 IU/m2. Having received seven doses of L-asp and with a cumulative dose of ninety thousand international units plus glucocorticoid (prednisone), presented a picture of decline, vomiting, abdominal pain and mild dehydration. There was suspicion of pancreatitis, which was ruled out by normal amylase/lipase values and normal hepatic tests. At that time it had plasma electrolyte profile with hyponatraemia of 126 mOsm/kg and urinary osmolality of 510 mOsm/kg, both normal values. With hyponatraemia and hypertriglyceridaemia, there was suspicion of RAM of pseudohyponatraemia secondary to hypertriglyceridaemia associated to L-asp. It was evaluated by Gastroenterology and Endocrinology, indicating a diet low in refined sugars and rich in fiber, fibrates (ciprofibrato 100 mg oral daily) and omega 3 (4 g oral daily), until triglyceride values of 300 mg/dL were achieved. Two weeks later the triglycerides had a value of 79 mg/dL. Ciprofibrato and omega3 were suspended, indicating prophylactic use associated to corticoid and L-asp treatment. A total of twelve doses of L-asp were completed with a cumulative dose of one hundred and eighty four thousand international units corresponding to the induction protocol. The suspicion of RAM was subjected to causality evaluation, with the modified Karch and Lasagna algorithm by WHO5, which resulted in “Definitive” RAM for the association of L-asp and Prednisone\\n'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "txt"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "unsloth",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/text_classifier/dspy.ipynb

@@ -0,0 +1,224 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8a9d70f0",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import dspy\n",
+        "import json\n",
+        "from typing import Literal\n",
+        "from dspy.teleprompt import BootstrapFewShotWithRandomSearch\n",
+        "from dspy.evaluate import Evaluate\n",
+        "\n",
+        "# --- 1. LLM Configuration ---\n",
+        "api_file = \"/home/mshahidul/api_new.json\"\n",
+        "with open(api_file, \"r\") as f:\n",
+        "    api_keys = json.load(f)\n",
+        "openai_api_key = api_keys[\"openai\"]\n",
+        "\n",
+        "# Student: Local vLLM (Deployment Model)\n",
+        "vllm_model = dspy.LM(\n",
+        "    model='Qwen/Qwen3-30B-A3B-Instruct-2507',\n",
+        "    api_base=\"http://172.16.34.29:8030/v1\",\n",
+        "    api_key=\"EMPTY\",\n",
+        "    temperature=0.0\n",
+        ")\n",
+        "\n",
+        "# Teacher: OpenAI (High-quality rationale generation)\n",
+        "# Note: Ensure 'gpt-5' is the correct model name in your environment (usually 'gpt-4-turbo' or 'gpt-4o')\n",
+        "openai_model_teacher = dspy.LM(model='gpt-5', api_key=openai_api_key)\n",
+        "openai_model_student = dspy.LM(model='gpt-5-mini', api_key=openai_api_key)\n",
+        "\n",
+        "# Default LM for DSPy runtime\n",
+        "# Use the local vLLM for fast iteration; switch to openai_model_student if needed.\n",
+        "# dspy.configure(lm=vllm_model)\n",
+        "dspy.configure(lm=openai_model_student)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "0f350ef4",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class HealthLiteracySignature(dspy.Signature):\n",
+        "    \"\"\"\n",
+        "    Classify the health literacy level of a generated text \n",
+        "    based on the original full source text.\n",
+        "    \"\"\"\n",
+        "    full_text = dspy.InputField(desc=\"The original clinical or source medical text.\")\n",
+        "    generated_text = dspy.InputField(desc=\"The rewritten medical text to classify for health literacy based on the original source text.\")\n",
+        "    \n",
+        "    # Using Literal ensures the output is constrained to your three categories\n",
+        "    literacy_label = dspy.OutputField(desc=\"One of: low_health_literacy, intermediate_health_literacy, proficient_health_literacy\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e369f8e8",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class HealthLiteracyClassifier(dspy.Module):\n",
+        "    def __init__(self):\n",
+        "        super().__init__()\n",
+        "        # Use ChainOfThought for better reasoning on medical jargon\n",
+        "        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)\n",
+        "\n",
+        "    def forward(self, full_text, generated_text):\n",
+        "        return self.classifier(full_text=full_text, generated_text=generated_text)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "055542d5",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def prepare_data(raw_data):\n",
+        "    dataset = []\n",
+        "    for item in raw_data:\n",
+        "        example = dspy.Example(\n",
+        "            full_text=item['fulltext'],\n",
+        "            generated_text=item['diff_label_texts'],\n",
+        "            literacy_label=item['label'] # Matches the Signature field\n",
+        "        ).with_inputs('full_text', 'generated_text')\n",
+        "        dataset.append(example)\n",
+        "    return dataset[:100], dataset[100:]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e570be47",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import json\n",
+        "path = \"/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json\"\n",
+        "raw_data = json.load(open(path))\n",
+        "trainset, testset = prepare_data(raw_data)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "39e90da8",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def health_literacy_metric(gold, pred, trace=None):\n",
+        "    # Use 'literacy_label' because that is what's in your Signature\n",
+        "    if not pred or not hasattr(pred, 'literacy_label'):\n",
+        "        return False\n",
+        "    \n",
+        "    # Standardize both for comparison\n",
+        "    gold_label = str(gold.literacy_label).strip().lower()\n",
+        "    pred_label = str(pred.literacy_label).strip().lower()\n",
+        "    \n",
+        "    return gold_label == pred_label\n",
+        "\n",
+        "optimizer = BootstrapFewShotWithRandomSearch(\n",
+        "    metric=health_literacy_metric,\n",
+        "    max_bootstrapped_demos=3,\n",
+        "    num_candidate_programs=8, \n",
+        "    teacher_settings=dict(lm=openai_model_teacher)\n",
+        ")\n",
+        "\n",
+        "# 3. Compile! This creates the \"optimized prompt\"\n",
+        "compiled_classifier = optimizer.compile(HealthLiteracyClassifier(), trainset=trainset)\n",
+        "\n",
+        "evaluator = Evaluate(devset=testset, metric=health_literacy_metric, num_threads=1, display_progress=True)\n",
+        "accuracy_score = evaluator(compiled_classifier)\n",
+        "compiled_classifier.save(\"health_literacy_model.json\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "425291ff",
+      "metadata": {},
+      "source": [
+        "## "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "id": "f8ae33e8",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "vllm-gpt-oss-20b_teacher-gpt5_v1\n",
+            "{'accuracy_score': 78.57, 'num_results': 84}\n",
+            "vllm-gemma-3-12b-it_teacher-gpt5_v1\n",
+            "{'accuracy_score': 79.76, 'num_results': 84}\n",
+            "vllm-Qwen2.5-7B-Instruct_teacher-gpt5_v1\n",
+            "{'accuracy_score': 59.52, 'num_results': 84}\n",
+            "student-gpt5-mini_teacher-gpt5_(fulltxt+gen_sum)\n",
+            "{'score': 88.1, 'results': 84}\n",
+            "vllm-Meta-Llama-3.1-8B-Instruct_teacher-gpt5_v1\n",
+            "{'accuracy_score': 78.57, 'num_results': 84}\n",
+            "vllm-phi-4_teacher-gpt5_v1\n",
+            "{'accuracy_score': 73.81, 'num_results': 84}\n",
+            "vllm-qwen3-8b_teacher-gpt5_v1\n",
+            "{'accuracy_score': 73.81, 'num_results': 84}\n",
+            "student-gpt5-mini_teacher-gpt5_v1\n",
+            "{'accuracy_score': 78.57, 'num_results': 84}\n"
+          ]
+        }
+      ],
+      "source": [
+        "# /home/mshahidul/readctrl/code/text_classifier/dspy_model\n",
+        "import os,json\n",
+        "folders = os.listdir(\"/home/mshahidul/readctrl/code/text_classifier/dspy_model\")\n",
+        "for folder in folders:\n",
+        "    if os.path.isdir(f\"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder}\"):\n",
+        "        files = os.listdir(f\"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder}\")\n",
+        "        for file in files:\n",
+        "            if file.endswith(\"accuracy.json\"):\n",
+        "                path=(f\"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder}/{file}\")\n",
+        "                print(path.split(\"/\")[-2])\n",
+        "                data = json.load(open(f\"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder}/{file}\"))\n",
+        "                print(data)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4c236110",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "unsloth",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

code/text_classifier/qwen3_(4b)_instruct.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+from datasets import load_dataset
+from unsloth import FastLanguageModel
+from trl import SFTConfig, SFTTrainer
+
+from unsloth.chat_templates import get_chat_template, train_on_responses_only
+
+MODEL_NAME = "unsloth/Qwen3-8B"
+DATA_PATH = "verified_combined_0-80.json"
+TEST_DATA_PATH = "verified_combined_0-80_test.json"
+MAX_SEQ_LENGTH = 4096
+FP16_SAVE_DIR = "/home/mshahidul/readctrl_model/full_model/classifier_model"
+TEST_SPLIT_RATIO = 0.1
+SPLIT_SEED = 3407
+
+SYSTEM_PROMPT = (
+    "You are an expert medical editor and Health Literacy specialist. "
+    "Classify the health literacy level of the provided text."
+)
+
+USER_PROMPT = """Classify the health literacy level of the rewritten text.
+
+Labels:
+- low_health_literacy: very simple, living-room language, minimal jargon.
+- intermediate_health_literacy: standard public-friendly language, limited jargon.
+- proficient_health_literacy: technical, clinical, or academic language.
+
+Input:
+Full Source Text:
+<<<FULLTEXT>>>
+
+Rewritten Text:
+<<<DIFF_LABEL_TEXTS>>>
+
+Output: Return only one label string from the list above."""
+
+
+def build_messages(fulltext: str, diff_label_texts: str, label: str):
+    user_content = USER_PROMPT.replace("<<<FULLTEXT>>>", fulltext).replace(
+        "<<<DIFF_LABEL_TEXTS>>>", diff_label_texts
+    )
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": user_content},
+        {"role": "assistant", "content": label},
+    ]
+
+
+def main():
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=MODEL_NAME,
+        max_seq_length=MAX_SEQ_LENGTH,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=32,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        lora_alpha=32,
+        lora_dropout=0,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=3407,
+        use_rslora=False,
+        loftq_config=None,
+    )
+
+    tokenizer = get_chat_template(tokenizer, chat_template="qwen3-instruct")
+    dataset = load_dataset("json", data_files=DATA_PATH, split="train")
+    split = dataset.train_test_split(test_size=TEST_SPLIT_RATIO, seed=SPLIT_SEED)
+    train_dataset = split["train"]
+    test_dataset = split["test"]
+    test_dataset.to_json(TEST_DATA_PATH)
+
+    def formatting_prompts_func(examples):
+        texts = []
+        for fulltext, diff_label_texts, label in zip(
+            examples["fulltext"],
+            examples["diff_label_texts"],
+            examples["label"],
+        ):
+            messages = build_messages(fulltext, diff_label_texts, label)
+            text = tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=False
+            )
+            texts.append(text)
+        return {"text": texts}
+
+    train_dataset = train_dataset.map(formatting_prompts_func, batched=True)
+
+    trainer = SFTTrainer(
+        model=model,
+        processing_class=tokenizer,
+        train_dataset=train_dataset,
+        eval_dataset=None,
+        args=SFTConfig(
+            dataset_text_field="text",
+            per_device_train_batch_size=64,
+            gradient_accumulation_steps=16,
+            warmup_steps=5,
+            # max_steps=60,
+            num_train_epochs=1,
+            learning_rate=2e-4,
+            logging_steps=1,
+            optim="adamw_8bit",
+            weight_decay=0.001,
+            lr_scheduler_type="linear",
+            seed=3407,
+            report_to="none",
+        ),
+    )
+
+    trainer = train_on_responses_only(
+        trainer,
+        instruction_part="<|im_start|>user\n",
+        response_part="<|im_start|>assistant\n",
+    )
+
+    trainer.train()
+
+    os.makedirs(FP16_SAVE_DIR, exist_ok=True)
+    model.save_pretrained_merged(
+        FP16_SAVE_DIR,
+        tokenizer,
+        save_method="merged_16bit",
+    )
+
+
+if __name__ == "__main__":
+    main()

code/text_classifier/test_saved_dspy_vllm_gen_text_only.py

@@ -0,0 +1,193 @@
+import argparse
+import json
+import os
+import traceback
+import urllib.error
+import urllib.request
+
+import dspy
+from dspy.evaluate import Evaluate
+
+
+DEFAULT_API_BASE = "http://172.16.34.22:8040/v1"
+DEFAULT_MODEL_PATH = (
+    "/home/mshahidul/readctrl/code/text_classifier/dspy_model/vllm-Meta-Llama-3.1-8B-Instruct_teacher-gpt5_v1/model.json"
+)
+DEFAULT_TEST_PATH = "/home/mshahidul/readctrl/code/text_classifier/data/verified_combined_0-80_clean200.json"
+DEFAULT_OUTPUT_PATH = (
+    "/home/mshahidul/readctrl/code/text_classifier/accuracy/"
+    "vllm-llama-3.1-8b-awq-int4_teacher-gpt5_v1_clean200_eval.json"
+)
+
+
+class HealthLiteracySignature(dspy.Signature):
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    literacy_label = dspy.OutputField(
+        desc=(
+            "Classification: low_health_literacy (simple words, no jargon), "
+            "intermediate_health_literacy (moderate technicality), or "
+            "proficient_health_literacy (highly technical/original level)."
+        )
+    )
+
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, generated_text):
+        return self.classifier(generated_text=generated_text)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Load a saved DSPy model and evaluate on test set."
+    )
+    parser.add_argument("--model-path", default=DEFAULT_MODEL_PATH)
+    parser.add_argument("--test-path", default=DEFAULT_TEST_PATH)
+    parser.add_argument(
+        "--api-base",
+        default=os.environ.get("VLLM_API_BASE", DEFAULT_API_BASE),
+    )
+    parser.add_argument("--num-threads", type=int, default=1)
+    parser.add_argument("--output-path", default=DEFAULT_OUTPUT_PATH)
+    parser.add_argument(
+        "--provide-traceback",
+        action="store_true",
+        help="Print full traceback if runtime error happens.",
+    )
+    return parser.parse_args()
+
+
+def check_api_base(api_base):
+    models_url = api_base.rstrip("/") + "/models"
+    req = urllib.request.Request(models_url, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            if resp.status >= 400:
+                raise RuntimeError(
+                    f"Endpoint reachable but unhealthy: {models_url} (status={resp.status})"
+                )
+    except urllib.error.URLError as exc:
+        raise ConnectionError(
+            "Cannot reach OpenAI-compatible endpoint. "
+            f"api_base={api_base}. "
+            "Start your vLLM server or pass correct --api-base."
+        ) from exc
+
+
+def load_testset(path):
+    examples = []
+    if path.endswith(".jsonl"):
+        with open(path, "r") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                record = json.loads(line)
+                example = dspy.Example(
+                    generated_text=record["generated_text"],
+                    literacy_label=record["literacy_label"],
+                ).with_inputs("generated_text")
+                examples.append(example)
+    else:
+        with open(path, "r") as f:
+            records = json.load(f)
+        for record in records:
+            text = record.get("generated_text", record.get("diff_label_texts"))
+            label = record.get("literacy_label", record.get("label"))
+            if not text or not label:
+                continue
+            example = dspy.Example(
+                generated_text=text,
+                literacy_label=label,
+            ).with_inputs("generated_text")
+            examples.append(example)
+    return examples
+
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, "literacy_label"):
+        return False
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    return gold_label in pred_label
+
+
+def load_compiled_classifier(path):
+    if hasattr(dspy, "load"):
+        try:
+            return dspy.load(path)
+        except Exception as exc:
+            print(
+                f"[warning] dspy.load failed ({type(exc).__name__}); "
+                "trying module.load(...)"
+            )
+
+    classifier = HealthLiteracyClassifier()
+    try:
+        classifier.load(path)
+    except Exception as exc:
+        raise RuntimeError(f"Failed to load compiled model from {path}") from exc
+    return classifier
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.exists(args.model_path):
+        raise FileNotFoundError(f"Model file not found: {args.model_path}")
+    if not os.path.exists(args.test_path):
+        raise FileNotFoundError(f"Test file not found: {args.test_path}")
+
+    try:
+        check_api_base(args.api_base)
+
+        lm = dspy.LM(
+            model="openai/dspy",
+            api_base=args.api_base,
+            api_key="EMPTY",
+            temperature=0.0,
+        )
+        dspy.configure(lm=lm)
+
+        testset = load_testset(args.test_path)
+        compiled_classifier = load_compiled_classifier(args.model_path)
+
+        evaluator = Evaluate(
+            devset=testset,
+            metric=health_literacy_metric,
+            num_threads=args.num_threads,
+            display_progress=True,
+        )
+        evaluation_result = evaluator(compiled_classifier)
+        accuracy_score = (
+            float(evaluation_result.score)
+            if hasattr(evaluation_result, "score")
+            else float(evaluation_result)
+        )
+
+        output_data = {
+            "model_path": args.model_path,
+            "test_path": args.test_path,
+            "accuracy_score": accuracy_score,
+            "num_results": len(getattr(evaluation_result, "results", []) or []),
+        }
+
+        os.makedirs(os.path.dirname(args.output_path), exist_ok=True)
+        with open(args.output_path, "w") as f:
+            json.dump(output_data, f, indent=2)
+
+        print(evaluation_result)
+        print(json.dumps(output_data, indent=2))
+    except Exception as exc:
+        print(f"[error] {type(exc).__name__}: {exc}")
+        if args.provide_traceback:
+            traceback.print_exc()
+        raise
+
+
+if __name__ == "__main__":
+    main()

code/text_classifier/text_classifier_dspy.py

@@ -0,0 +1,216 @@
+import dspy
+import json
+import os
+import random
+from typing import Literal
+from dspy.teleprompt import BootstrapFewShotWithRandomSearch
+from dspy.evaluate import Evaluate
+
+# --- 1. LLM Configuration ---
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+# Student: Local vLLM (Deployment Model)
+vllm_model = dspy.LM(
+    model='Qwen/Qwen3-30B-A3B-Instruct-2507',
+    api_base="http://172.16.34.29:8030/v1",
+    api_key="EMPTY",
+    temperature=0.0
+)
+
+# Teacher: OpenAI (High-quality rationale generation)
+# Note: Ensure 'gpt-5' is the correct model name in your environment (usually 'gpt-4-turbo' or 'gpt-4o')
+openai_model_teacher = dspy.LM(model='gpt-5', api_key=openai_api_key)
+openai_model_student = dspy.LM(model='gpt-5-mini', api_key=openai_api_key)
+
+# Default LM for DSPy runtime
+# Use the local vLLM for fast iteration; switch to openai_model_student if needed.
+# dspy.configure(lm=vllm_model)
+dspy.configure(lm=openai_model_student)
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence 
+    structure of 'generated_text' relative to 'full_text' to determine 
+    the health literacy level.
+    """
+    full_text = dspy.InputField(desc="Original clinical or medical source text containing jargon and technical details.")
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    
+    literacy_label = dspy.OutputField(
+        desc="Classification: low_health_literacy (simple words, no jargon), intermediate_health_literacy (moderate technicality), or proficient_health_literacy (highly technical/original level)."
+    )
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        # Use ChainOfThought for better reasoning on medical jargon
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, full_text, generated_text):
+        return self.classifier(full_text=full_text, generated_text=generated_text)
+
+def prepare_data(raw_data, seed=42, train_ratio=0.6):
+    labels = [
+        "low_health_literacy",
+        "intermediate_health_literacy",
+        "proficient_health_literacy",
+    ]
+    rng = random.Random(seed)
+    buckets = {label: [] for label in labels}
+    for item in raw_data:
+        label = item.get("label")
+        if label not in buckets:
+            continue
+        example = dspy.Example(
+            full_text=item["fulltext"],
+            generated_text=item["diff_label_texts"],
+            literacy_label=label,  # Matches the Signature field
+        ).with_inputs("full_text", "generated_text")
+        buckets[label].append(example)
+
+    min_count = min(len(buckets[label]) for label in labels)
+    if min_count == 0:
+        raise ValueError("One or more labels has no examples; cannot balance.")
+
+    per_label_total = min_count
+    per_label_train = int(round(per_label_total * train_ratio))
+    per_label_train = max(1, min(per_label_train, per_label_total - 1))
+
+    trainset = []
+    testset = []
+    for label in labels:
+        rng.shuffle(buckets[label])
+        selected = buckets[label][:per_label_total]
+        trainset.extend(selected[:per_label_train])
+        testset.extend(selected[per_label_train:per_label_total])
+
+    rng.shuffle(trainset)
+    rng.shuffle(testset)
+    return trainset, testset
+
+
+import json
+path = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json"
+raw_data = json.load(open(path))
+trainset, testset = prepare_data(raw_data)
+
+def _example_to_dict(example):
+    return {
+        "full_text": example.full_text,
+        "generated_text": example.generated_text,
+        "literacy_label": example.literacy_label,
+    }
+
+def save_jsonl(path, examples):
+    with open(path, "w") as f:
+        for ex in examples:
+            f.write(json.dumps(_example_to_dict(ex), ensure_ascii=False) + "\n")
+
+train_path = "/home/mshahidul/readctrl/code/text_classifier/train.jsonl"
+test_path = "/home/mshahidul/readctrl/code/text_classifier/test.jsonl"
+save_jsonl(train_path, trainset)
+save_jsonl(test_path, testset)
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, 'literacy_label'):
+        return False
+    
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    
+    # Simple inclusion check helps if the LLM gets wordy
+    return gold_label in pred_label
+
+optimizer = BootstrapFewShotWithRandomSearch(
+    metric=health_literacy_metric,
+    max_bootstrapped_demos=3,
+    num_candidate_programs=8, 
+    teacher_settings=dict(lm=openai_model_teacher)
+)
+
+# 3. Compile! This creates the "optimized prompt"
+compiled_classifier = optimizer.compile(HealthLiteracyClassifier(), trainset=trainset)
+
+evaluator = Evaluate(devset=testset, metric=health_literacy_metric, num_threads=1, display_progress=True)
+evaluation_result = evaluator(compiled_classifier)
+accuracy_score = (
+    float(evaluation_result.score)
+    if hasattr(evaluation_result, "score")
+    else float(evaluation_result)
+)
+
+def _extract_usage(record):
+    if isinstance(record, dict):
+        usage = record.get("usage")
+        if usage:
+            return usage
+        response = record.get("response")
+        if isinstance(response, dict) and response.get("usage"):
+            return response["usage"]
+    return None
+
+def calc_cost_usd(lm, price_in_per_1m, price_out_per_1m, price_cached_in_per_1m=None):
+    prompt_tokens = 0
+    completion_tokens = 0
+    cached_tokens = 0
+    for record in getattr(lm, "history", []) or []:
+        usage = _extract_usage(record)
+        if not usage:
+            continue
+        prompt_tokens += int(usage.get("prompt_tokens", usage.get("input_tokens", 0)) or 0)
+        completion_tokens += int(usage.get("completion_tokens", usage.get("output_tokens", 0)) or 0)
+        cached_tokens += int(usage.get("cached_tokens", usage.get("prompt_tokens_cached", 0)) or 0)
+    cost = (prompt_tokens / 1_000_000) * price_in_per_1m
+    cost += (completion_tokens / 1_000_000) * price_out_per_1m
+    if price_cached_in_per_1m is not None:
+        cost += (cached_tokens / 1_000_000) * price_cached_in_per_1m
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "cached_tokens": cached_tokens,
+        "cost_usd": cost,
+    }
+
+# Fill these with current OpenAI pricing (USD per 1M tokens).
+GPT5_PRICE_INPUT_PER_1M = 1.25
+GPT5_PRICE_OUTPUT_PER_1M = 10.0
+GPT5_MINI_PRICE_INPUT_PER_1M = 0.25
+GPT5_MINI_PRICE_OUTPUT_PER_1M = 2.0
+
+teacher_cost = calc_cost_usd(
+    openai_model_teacher,
+    GPT5_PRICE_INPUT_PER_1M,
+    GPT5_PRICE_OUTPUT_PER_1M,
+)
+student_cost = calc_cost_usd(
+    openai_model_student,
+    GPT5_MINI_PRICE_INPUT_PER_1M,
+    GPT5_MINI_PRICE_OUTPUT_PER_1M,
+)
+
+cost_report = {
+    "gpt-5": teacher_cost,
+    "gpt-5-mini": student_cost,
+}
+folder_name="student-gpt5-mini_teacher-gpt5_v1"
+os.makedirs(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}", exist_ok=True)
+compiled_classifier.save(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/model.json")
+
+print(evaluation_result)
+print(json.dumps(cost_report, indent=2))
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/accuracy.json", "w") as f:
+    json.dump(
+        {
+            "accuracy_score": accuracy_score,
+            "num_results": len(getattr(evaluation_result, "results", []) or []),
+        },
+        f,
+        indent=2,
+    )
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/cost.json", "w") as f:
+    json.dump(cost_report, f, indent=2)

code/text_classifier/text_classifier_dspy_load_and_infer_full.py

@@ -0,0 +1,353 @@
+import argparse
+import json
+import os
+from collections import Counter
+from typing import Dict, List, Tuple
+
+import dspy
+from tqdm import tqdm
+
+
+API_FILE = "/home/mshahidul/api_new.json"
+DEFAULT_MODEL_PATH = "/home/mshahidul/readctrl/code/text_classifier/dspy_model/student-gpt5-mini_teacher-gpt5_v1/model.json"
+DEFAULT_DATASET_PATH = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json"
+DEFAULT_OUTPUT_PATH = "/home/mshahidul/readctrl/code/text_classifier/dspy_model/student-gpt5-mini_teacher-gpt5_v1/full_dataset_accuracy.json"
+DEFAULT_PREDICTIONS_PATH = "/home/mshahidul/readctrl/code/text_classifier/dspy_model/student-gpt5-mini_teacher-gpt5_v1/full_dataset_predictions.json"
+DEFAULT_CLEAN_DATASET_PATH = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80_clean200.json"
+DEFAULT_REMOVED_PATH = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80_removed21.json"
+VALID_LABELS = {
+    "low_health_literacy",
+    "intermediate_health_literacy",
+    "proficient_health_literacy",
+}
+LABEL_ORDER = {
+    "low_health_literacy": 0,
+    "intermediate_health_literacy": 1,
+    "proficient_health_literacy": 2,
+}
+
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence
+    structure of 'generated_text' to determine the health literacy level.
+    """
+
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    literacy_label = dspy.OutputField(
+        desc=(
+            "Classification: low_health_literacy (simple words, no jargon), "
+            "intermediate_health_literacy (moderate technicality), or "
+            "proficient_health_literacy (highly technical/original level)."
+        )
+    )
+
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, generated_text):
+        return self.classifier(generated_text=generated_text)
+
+
+def load_openai_key(api_file: str) -> str:
+    with open(api_file, "r") as f:
+        api_keys = json.load(f)
+    if "openai" not in api_keys:
+        raise KeyError(f"'openai' key is missing in {api_file}")
+    return api_keys["openai"]
+
+
+def normalize_label(text: str) -> str:
+    return str(text or "").strip().lower()
+
+
+def is_correct(gold_label: str, predicted_label: str) -> bool:
+    gold = normalize_label(gold_label)
+    pred = normalize_label(predicted_label)
+    return gold in pred
+
+
+def extract_predicted_label(predicted_text: str) -> str:
+    pred = normalize_label(predicted_text)
+    matched = [label for label in VALID_LABELS if label in pred]
+    if len(matched) == 1:
+        return matched[0]
+    return ""
+
+
+def misclassification_severity(gold_label: str, predicted_label: str) -> int:
+    gold = LABEL_ORDER.get(gold_label)
+    pred = LABEL_ORDER.get(predicted_label)
+    if gold is None or pred is None:
+        # Unknown/unparseable predictions are treated as worst.
+        return 3
+    return abs(gold - pred)
+
+
+def load_full_examples(dataset_path: str):
+    with open(dataset_path, "r") as f:
+        raw_data = json.load(f)
+
+    examples = []
+    for idx, item in enumerate(raw_data):
+        label = item.get("label")
+        text = item.get("diff_label_texts")
+        if label in VALID_LABELS and text:
+            examples.append(
+                {
+                    "index": idx,
+                    "generated_text": text,
+                    "gold_label": label,
+                    "doc_id": item.get("doc_id"),
+                    "raw_item": item,
+                }
+            )
+    if not examples:
+        raise ValueError("No valid labeled examples found in dataset.")
+    return examples
+
+
+def choose_indices_to_remove(
+    predictions: List[Dict], remove_count: int
+) -> Tuple[List[Dict], List[int]]:
+    def _rank_key(p: Dict):
+        return (
+            0 if not p["exact_correct"] else 1,
+            -p["severity"],
+            0 if not p["predicted_label"] else 1,
+            -len(normalize_label(p["raw_prediction_text"])),
+            p["index"],
+        )
+
+    label_sequence = sorted(VALID_LABELS, key=lambda x: LABEL_ORDER[x])
+    per_label_all = {label: [] for label in label_sequence}
+    per_label_mis = {label: [] for label in label_sequence}
+    for p in predictions:
+        label = p["gold_label"]
+        if label in per_label_all:
+            per_label_all[label].append(p)
+            if not p["exact_correct"]:
+                per_label_mis[label].append(p)
+
+    for label in label_sequence:
+        per_label_all[label].sort(key=_rank_key)
+        per_label_mis[label].sort(key=_rank_key)
+
+    # Balanced quota (approximately equal removals per label).
+    num_labels = len(label_sequence)
+    base_quota = remove_count // num_labels
+    remainder = remove_count % num_labels
+    quotas = {label: base_quota for label in label_sequence}
+
+    # Assign remainder to labels with more misclassified candidates first.
+    remainder_order = sorted(
+        label_sequence,
+        key=lambda label: (-len(per_label_mis[label]), LABEL_ORDER[label]),
+    )
+    for label in remainder_order[:remainder]:
+        quotas[label] += 1
+
+    removed = []
+    removed_indices_set = set()
+
+    # First pass: satisfy each label quota with misclassified items.
+    for label in label_sequence:
+        take = min(quotas[label], len(per_label_mis[label]))
+        for item in per_label_mis[label][:take]:
+            removed.append(item)
+            removed_indices_set.add(item["index"])
+
+    # Second pass: if some quotas could not be met, fill within those labels
+    # using next-worst remaining items (can include correctly classified).
+    for label in label_sequence:
+        needed = quotas[label] - sum(1 for x in removed if x["gold_label"] == label)
+        if needed <= 0:
+            continue
+        candidates = [
+            x for x in per_label_all[label] if x["index"] not in removed_indices_set
+        ]
+        for item in candidates[:needed]:
+            removed.append(item)
+            removed_indices_set.add(item["index"])
+
+    # Final pass: if still short (edge cases), fill globally by worst rank.
+    if len(removed) < remove_count:
+        remaining_global = sorted(
+            (p for p in predictions if p["index"] not in removed_indices_set),
+            key=_rank_key,
+        )
+        need = remove_count - len(removed)
+        for item in remaining_global[:need]:
+            removed.append(item)
+            removed_indices_set.add(item["index"])
+
+    # Keep deterministic order in output by rank.
+    removed = sorted(removed, key=_rank_key)[:remove_count]
+    removed_indices = sorted(p["index"] for p in removed)
+    return removed, removed_indices
+
+
+def run_inference(
+    model_path: str,
+    dataset_path: str,
+    output_path: str,
+    predictions_path: str,
+    clean_dataset_path: str,
+    removed_path: str,
+    target_clean_size: int,
+):
+    openai_api_key = load_openai_key(API_FILE)
+    student_lm = dspy.LM(model="gpt-5-mini", api_key=openai_api_key)
+    dspy.configure(lm=student_lm)
+
+    classifier = HealthLiteracyClassifier()
+    classifier.load(model_path)
+
+    examples = load_full_examples(dataset_path)
+    total = len(examples)
+    if target_clean_size <= 0 or target_clean_size >= total:
+        raise ValueError(
+            f"target_clean_size must be between 1 and {total - 1}, got {target_clean_size}"
+        )
+
+    remove_count = total - target_clean_size
+    correct = 0
+    label_totals = Counter()
+    label_correct = Counter()
+    predictions = []
+
+    for idx, ex in enumerate(
+        tqdm(examples, desc="Classifying full dataset", unit="sample"), start=1
+    ):
+        pred = classifier(generated_text=ex["generated_text"])
+        raw_pred_label = getattr(pred, "literacy_label", "")
+        pred_label = extract_predicted_label(raw_pred_label)
+        gold_label = ex["gold_label"]
+        exact_correct = pred_label == gold_label
+        lenient_correct = is_correct(gold_label, raw_pred_label)
+        severity = (
+            misclassification_severity(gold_label, pred_label) if not exact_correct else 0
+        )
+
+        label_totals[gold_label] += 1
+        if lenient_correct:
+            correct += 1
+            label_correct[gold_label] += 1
+
+        predictions.append(
+            {
+                "index": ex["index"],
+                "doc_id": ex["doc_id"],
+                "gold_label": gold_label,
+                "predicted_label": pred_label,
+                "raw_prediction_text": raw_pred_label,
+                "lenient_correct": lenient_correct,
+                "exact_correct": exact_correct,
+                "severity": severity,
+                "generated_text": ex["generated_text"],
+            }
+        )
+
+        if idx % 10 == 0 or idx == total:
+            tqdm.write(f"Processed {idx}/{total}")
+
+    accuracy = correct / total if total else 0.0
+    exact_accuracy = (
+        sum(1 for p in predictions if p["exact_correct"]) / total if total else 0.0
+    )
+    per_label_accuracy = {
+        label: (
+            (label_correct[label] / label_totals[label]) if label_totals[label] else 0.0
+        )
+        for label in sorted(VALID_LABELS)
+    }
+    removed_examples, removed_indices = choose_indices_to_remove(predictions, remove_count)
+    removed_index_set = set(removed_indices)
+    clean_dataset = [
+        p["raw_item"]
+        for p in examples
+        if p["index"] not in removed_index_set
+    ]
+    removed_dataset = [
+        p["raw_item"]
+        for p in examples
+        if p["index"] in removed_index_set
+    ]
+
+    report = {
+        "model_path": model_path,
+        "dataset_path": dataset_path,
+        "num_examples": total,
+        "num_correct": correct,
+        "lenient_accuracy": accuracy,
+        "exact_accuracy": exact_accuracy,
+        "per_label_accuracy": per_label_accuracy,
+        "target_clean_size": target_clean_size,
+        "removed_count": remove_count,
+        "clean_dataset_size": len(clean_dataset),
+        "removed_dataset_size": len(removed_dataset),
+        "removed_misclassified_count": sum(
+            1 for p in removed_examples if not p["exact_correct"]
+        ),
+        "removed_per_label": dict(
+            Counter(p["gold_label"] for p in removed_examples)
+        ),
+    }
+
+    for path in [
+        output_path,
+        predictions_path,
+        clean_dataset_path,
+        removed_path,
+    ]:
+        output_dir = os.path.dirname(path)
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+
+    with open(output_path, "w") as f:
+        json.dump(report, f, indent=2)
+    with open(predictions_path, "w") as f:
+        json.dump(predictions, f, indent=2)
+    with open(clean_dataset_path, "w") as f:
+        json.dump(clean_dataset, f, indent=2, ensure_ascii=False)
+    with open(removed_path, "w") as f:
+        json.dump(removed_dataset, f, indent=2, ensure_ascii=False)
+
+    print(json.dumps(report, indent=2))
+    print(f"Saved predictions to: {predictions_path}")
+    print(f"Saved clean dataset to: {clean_dataset_path}")
+    print(f"Saved removed examples to: {removed_path}")
+    print(f"Saved report to: {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Load a compiled DSPy classifier and evaluate on full dataset."
+    )
+    parser.add_argument("--model-path", default=DEFAULT_MODEL_PATH)
+    parser.add_argument("--dataset-path", default=DEFAULT_DATASET_PATH)
+    parser.add_argument("--output-path", default=DEFAULT_OUTPUT_PATH)
+    parser.add_argument("--predictions-path", default=DEFAULT_PREDICTIONS_PATH)
+    parser.add_argument("--clean-dataset-path", default=DEFAULT_CLEAN_DATASET_PATH)
+    parser.add_argument("--removed-path", default=DEFAULT_REMOVED_PATH)
+    parser.add_argument("--target-clean-size", type=int, default=200)
+    args = parser.parse_args()
+
+    run_inference(
+        model_path=args.model_path,
+        dataset_path=args.dataset_path,
+        output_path=args.output_path,
+        predictions_path=args.predictions_path,
+        clean_dataset_path=args.clean_dataset_path,
+        removed_path=args.removed_path,
+        target_clean_size=args.target_clean_size,
+    )
+
+
+if __name__ == "__main__":
+    main()

code/text_classifier/text_classifier_dspy_only_gen_text.py

@@ -0,0 +1,212 @@
+import dspy
+import json
+import os
+import random
+from typing import Literal
+from dspy.teleprompt import BootstrapFewShotWithRandomSearch
+from dspy.evaluate import Evaluate
+
+# --- 1. LLM Configuration ---
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+# Student: Local vLLM (Deployment Model)
+vllm_model = dspy.LM(
+    model='Qwen/Qwen3-30B-A3B-Instruct-2507',
+    api_base="http://172.16.34.29:8030/v1",
+    api_key="EMPTY",
+    temperature=0.0
+)
+
+# Teacher: OpenAI (High-quality rationale generation)
+# Note: Ensure 'gpt-5' is the correct model name in your environment (usually 'gpt-4-turbo' or 'gpt-4o')
+openai_model_teacher = dspy.LM(model='gpt-5', api_key=openai_api_key)
+openai_model_student = dspy.LM(model='gpt-5-mini', api_key=openai_api_key)
+
+# Default LM for DSPy runtime
+# Use the local vLLM for fast iteration; switch to openai_model_student if needed.
+# dspy.configure(lm=vllm_model)
+dspy.configure(lm=openai_model_student)
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence 
+    structure of 'generated_text' to determine the health literacy level.
+    """
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    
+    literacy_label = dspy.OutputField(
+        desc="Classification: low_health_literacy (simple words, no jargon), intermediate_health_literacy (moderate technicality), or proficient_health_literacy (highly technical/original level)."
+    )
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        # Use ChainOfThought for better reasoning on medical jargon
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, generated_text):
+        return self.classifier(generated_text=generated_text)
+
+def prepare_data(raw_data, seed=42, train_ratio=0.6):
+    labels = [
+        "low_health_literacy",
+        "intermediate_health_literacy",
+        "proficient_health_literacy",
+    ]
+    rng = random.Random(seed)
+    buckets = {label: [] for label in labels}
+    for item in raw_data:
+        label = item.get("label")
+        if label not in buckets:
+            continue
+        example = dspy.Example(
+            generated_text=item["diff_label_texts"],
+            literacy_label=label,  # Matches the Signature field
+        ).with_inputs("generated_text")
+        buckets[label].append(example)
+
+    min_count = min(len(buckets[label]) for label in labels)
+    if min_count == 0:
+        raise ValueError("One or more labels has no examples; cannot balance.")
+
+    per_label_total = min_count
+    per_label_train = int(round(per_label_total * train_ratio))
+    per_label_train = max(1, min(per_label_train, per_label_total - 1))
+
+    trainset = []
+    testset = []
+    for label in labels:
+        rng.shuffle(buckets[label])
+        selected = buckets[label][:per_label_total]
+        trainset.extend(selected[:per_label_train])
+        testset.extend(selected[per_label_train:per_label_total])
+
+    rng.shuffle(trainset)
+    rng.shuffle(testset)
+    return trainset, testset
+
+
+import json
+path = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json"
+raw_data = json.load(open(path))
+trainset, testset = prepare_data(raw_data)
+
+def _example_to_dict(example):
+    return {
+        "generated_text": example.generated_text,
+        "literacy_label": example.literacy_label,
+    }
+
+def save_jsonl(path, examples):
+    with open(path, "w") as f:
+        for ex in examples:
+            f.write(json.dumps(_example_to_dict(ex), ensure_ascii=False) + "\n")
+
+train_path = "/home/mshahidul/readctrl/code/text_classifier/train.jsonl"
+test_path = "/home/mshahidul/readctrl/code/text_classifier/test.jsonl"
+save_jsonl(train_path, trainset)
+save_jsonl(test_path, testset)
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, 'literacy_label'):
+        return False
+    
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    
+    # Simple inclusion check helps if the LLM gets wordy
+    return gold_label in pred_label
+
+optimizer = BootstrapFewShotWithRandomSearch(
+    metric=health_literacy_metric,
+    max_bootstrapped_demos=3,
+    num_candidate_programs=8, 
+    teacher_settings=dict(lm=openai_model_teacher)
+)
+
+# 3. Compile! This creates the "optimized prompt"
+compiled_classifier = optimizer.compile(HealthLiteracyClassifier(), trainset=trainset)
+
+evaluator = Evaluate(devset=testset, metric=health_literacy_metric, num_threads=1, display_progress=True)
+evaluation_result = evaluator(compiled_classifier)
+accuracy_score = (
+    float(evaluation_result.score)
+    if hasattr(evaluation_result, "score")
+    else float(evaluation_result)
+)
+
+def _extract_usage(record):
+    if isinstance(record, dict):
+        usage = record.get("usage")
+        if usage:
+            return usage
+        response = record.get("response")
+        if isinstance(response, dict) and response.get("usage"):
+            return response["usage"]
+    return None
+
+def calc_cost_usd(lm, price_in_per_1m, price_out_per_1m, price_cached_in_per_1m=None):
+    prompt_tokens = 0
+    completion_tokens = 0
+    cached_tokens = 0
+    for record in getattr(lm, "history", []) or []:
+        usage = _extract_usage(record)
+        if not usage:
+            continue
+        prompt_tokens += int(usage.get("prompt_tokens", usage.get("input_tokens", 0)) or 0)
+        completion_tokens += int(usage.get("completion_tokens", usage.get("output_tokens", 0)) or 0)
+        cached_tokens += int(usage.get("cached_tokens", usage.get("prompt_tokens_cached", 0)) or 0)
+    cost = (prompt_tokens / 1_000_000) * price_in_per_1m
+    cost += (completion_tokens / 1_000_000) * price_out_per_1m
+    if price_cached_in_per_1m is not None:
+        cost += (cached_tokens / 1_000_000) * price_cached_in_per_1m
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "cached_tokens": cached_tokens,
+        "cost_usd": cost,
+    }
+
+# Fill these with current OpenAI pricing (USD per 1M tokens).
+GPT5_PRICE_INPUT_PER_1M = 1.25
+GPT5_PRICE_OUTPUT_PER_1M = 10.0
+GPT5_MINI_PRICE_INPUT_PER_1M = 0.25
+GPT5_MINI_PRICE_OUTPUT_PER_1M = 2.0
+
+teacher_cost = calc_cost_usd(
+    openai_model_teacher,
+    GPT5_PRICE_INPUT_PER_1M,
+    GPT5_PRICE_OUTPUT_PER_1M,
+)
+student_cost = calc_cost_usd(
+    openai_model_student,
+    GPT5_MINI_PRICE_INPUT_PER_1M,
+    GPT5_MINI_PRICE_OUTPUT_PER_1M,
+)
+
+cost_report = {
+    "gpt-5": teacher_cost,
+    "gpt-5-mini": student_cost,
+}
+folder_name="student-gpt5-mini_teacher-gpt5_v1"
+os.makedirs(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}", exist_ok=True)
+compiled_classifier.save(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/model.json")
+
+print(evaluation_result)
+print(json.dumps(cost_report, indent=2))
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/accuracy.json", "w") as f:
+    json.dump(
+        {
+            "accuracy_score": accuracy_score,
+            "num_results": len(getattr(evaluation_result, "results", []) or []),
+        },
+        f,
+        indent=2,
+    )
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/cost.json", "w") as f:
+    json.dump(cost_report, f, indent=2)

code/text_classifier/text_classifier_dspy_vllm.py

@@ -0,0 +1,207 @@
+import dspy
+import json
+import os
+import random
+from typing import Literal
+from dspy.teleprompt import BootstrapFewShotWithRandomSearch
+from dspy.evaluate import Evaluate
+
+# --- 1. LLM Configuration ---
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+# Student: Local vLLM (Deployment Model)
+vllm_model = dspy.LM(
+    model="openai/dspy",
+    api_base="http://172.16.34.29:8030/v1",
+    api_key="EMPTY",
+    temperature=0.0
+)
+
+# Teacher: OpenAI (High-quality rationale generation)
+# Note: Ensure 'gpt-5' is the correct model name in your environment (usually 'gpt-4-turbo' or 'gpt-4o')
+openai_model_teacher = dspy.LM(model="gpt-5", api_key=openai_api_key)
+
+# Default LM for DSPy runtime
+# Use the local vLLM for fast iteration.
+dspy.configure(lm=vllm_model)
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence 
+    structure of 'generated_text' relative to 'full_text' to determine 
+    the health literacy level.
+    """
+    full_text = dspy.InputField(desc="Original clinical or medical source text containing jargon and technical details.")
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    
+    literacy_label = dspy.OutputField(
+        desc="Classification: low_health_literacy (simple words, no jargon), intermediate_health_literacy (moderate technicality), or proficient_health_literacy (highly technical/original level)."
+    )
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        # Use ChainOfThought for better reasoning on medical jargon
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, full_text, generated_text):
+        return self.classifier(full_text=full_text, generated_text=generated_text)
+
+def prepare_data(raw_data, seed=42, train_ratio=0.6):
+    labels = [
+        "low_health_literacy",
+        "intermediate_health_literacy",
+        "proficient_health_literacy",
+    ]
+    rng = random.Random(seed)
+    buckets = {label: [] for label in labels}
+    for item in raw_data:
+        label = item.get("label")
+        if label not in buckets:
+            continue
+        example = dspy.Example(
+            full_text=item["fulltext"],
+            generated_text=item["diff_label_texts"],
+            literacy_label=label,  # Matches the Signature field
+        ).with_inputs("full_text", "generated_text")
+        buckets[label].append(example)
+
+    min_count = min(len(buckets[label]) for label in labels)
+    if min_count == 0:
+        raise ValueError("One or more labels has no examples; cannot balance.")
+
+    per_label_total = min_count
+    per_label_train = int(round(per_label_total * train_ratio))
+    per_label_train = max(1, min(per_label_train, per_label_total - 1))
+
+    trainset = []
+    testset = []
+    for label in labels:
+        rng.shuffle(buckets[label])
+        selected = buckets[label][:per_label_total]
+        trainset.extend(selected[:per_label_train])
+        testset.extend(selected[per_label_train:per_label_total])
+
+    rng.shuffle(trainset)
+    rng.shuffle(testset)
+    return trainset, testset
+
+
+import json
+path = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json"
+raw_data = json.load(open(path))
+trainset, testset = prepare_data(raw_data)
+
+def _example_to_dict(example):
+    return {
+        "full_text": example.full_text,
+        "generated_text": example.generated_text,
+        "literacy_label": example.literacy_label,
+    }
+
+def save_jsonl(path, examples):
+    with open(path, "w") as f:
+        for ex in examples:
+            f.write(json.dumps(_example_to_dict(ex), ensure_ascii=False) + "\n")
+
+train_path = "/home/mshahidul/readctrl/code/text_classifier/train.jsonl"
+test_path = "/home/mshahidul/readctrl/code/text_classifier/test.jsonl"
+save_jsonl(train_path, trainset)
+save_jsonl(test_path, testset)
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, 'literacy_label'):
+        return False
+    
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    
+    # Simple inclusion check helps if the LLM gets wordy
+    return gold_label in pred_label
+
+optimizer = BootstrapFewShotWithRandomSearch(
+    metric=health_literacy_metric,
+    max_bootstrapped_demos=3,
+    num_candidate_programs=8, 
+    teacher_settings=dict(lm=openai_model_teacher)
+)
+
+# 3. Compile! This creates the "optimized prompt"
+compiled_classifier = optimizer.compile(HealthLiteracyClassifier(), trainset=trainset)
+
+evaluator = Evaluate(devset=testset, metric=health_literacy_metric, num_threads=1, display_progress=True)
+evaluation_result = evaluator(compiled_classifier)
+accuracy_score = (
+    float(evaluation_result.score)
+    if hasattr(evaluation_result, "score")
+    else float(evaluation_result)
+)
+
+def _extract_usage(record):
+    if isinstance(record, dict):
+        usage = record.get("usage")
+        if usage:
+            return usage
+        response = record.get("response")
+        if isinstance(response, dict) and response.get("usage"):
+            return response["usage"]
+    return None
+
+def calc_cost_usd(lm, price_in_per_1m, price_out_per_1m, price_cached_in_per_1m=None):
+    prompt_tokens = 0
+    completion_tokens = 0
+    cached_tokens = 0
+    for record in getattr(lm, "history", []) or []:
+        usage = _extract_usage(record)
+        if not usage:
+            continue
+        prompt_tokens += int(usage.get("prompt_tokens", usage.get("input_tokens", 0)) or 0)
+        completion_tokens += int(usage.get("completion_tokens", usage.get("output_tokens", 0)) or 0)
+        cached_tokens += int(usage.get("cached_tokens", usage.get("prompt_tokens_cached", 0)) or 0)
+    cost = (prompt_tokens / 1_000_000) * price_in_per_1m
+    cost += (completion_tokens / 1_000_000) * price_out_per_1m
+    if price_cached_in_per_1m is not None:
+        cost += (cached_tokens / 1_000_000) * price_cached_in_per_1m
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "cached_tokens": cached_tokens,
+        "cost_usd": cost,
+    }
+
+# Fill these with current OpenAI pricing (USD per 1M tokens).
+GPT5_PRICE_INPUT_PER_1M = 1.25
+GPT5_PRICE_OUTPUT_PER_1M = 10.0
+
+teacher_cost = calc_cost_usd(
+    openai_model_teacher,
+    GPT5_PRICE_INPUT_PER_1M,
+    GPT5_PRICE_OUTPUT_PER_1M,
+)
+
+cost_report = {
+    "gpt-5": teacher_cost,
+}
+folder_name = "vllm-qwen3-8b_teacher-gpt5_v1"
+os.makedirs(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}", exist_ok=True)
+compiled_classifier.save(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/model.json")
+
+print(evaluation_result)
+
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/accuracy.json", "w") as f:
+    json.dump(
+        {
+            "accuracy_score": accuracy_score,
+            "num_results": len(getattr(evaluation_result, "results", []) or []),
+        },
+        f,
+        indent=2,
+    )
+print(json.dumps(cost_report, indent=2))
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/cost.json", "w") as f:
+    json.dump(cost_report, f, indent=2)

code/text_classifier/text_classifier_dspy_vllm_gen_text_only.py

@@ -0,0 +1,203 @@
+import dspy
+import json
+import os
+import random
+from typing import Literal
+from dspy.teleprompt import BootstrapFewShotWithRandomSearch
+from dspy.evaluate import Evaluate
+
+# --- 1. LLM Configuration ---
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+# Student: Local vLLM (Deployment Model)
+vllm_model = dspy.LM(
+    model="openai/dspy",
+    api_base="http://172.16.34.21:8040/v1",
+    api_key="EMPTY",
+    temperature=0.0
+)
+folder_name = "vllm-llama-3.1-8b-awq-int4_teacher-gpt5_v1"
+# Teacher: OpenAI (High-quality rationale generation)
+# Note: Ensure 'gpt-5' is the correct model name in your environment (usually 'gpt-4-turbo' or 'gpt-4o')
+openai_model_teacher = dspy.LM(model="gpt-5", api_key=openai_api_key)
+
+# Default LM for DSPy runtime
+# Use the local vLLM for fast iteration.
+dspy.configure(lm=vllm_model)
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence
+    structure of 'generated_text' to determine the health literacy level.
+    """
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+
+    literacy_label = dspy.OutputField(
+        desc="Classification: low_health_literacy (simple words, no jargon), intermediate_health_literacy (moderate technicality), or proficient_health_literacy (highly technical/original level)."
+    )
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        # Use ChainOfThought for better reasoning on medical jargon
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, generated_text):
+        return self.classifier(generated_text=generated_text)
+
+def prepare_data(raw_data, seed=42, train_ratio=0.6):
+    labels = [
+        "low_health_literacy",
+        "intermediate_health_literacy",
+        "proficient_health_literacy",
+    ]
+    rng = random.Random(seed)
+    buckets = {label: [] for label in labels}
+    for item in raw_data:
+        label = item.get("label")
+        if label not in buckets:
+            continue
+        example = dspy.Example(
+            generated_text=item["diff_label_texts"],
+            literacy_label=label,  # Matches the Signature field
+        ).with_inputs("generated_text")
+        buckets[label].append(example)
+
+    min_count = min(len(buckets[label]) for label in labels)
+    if min_count == 0:
+        raise ValueError("One or more labels has no examples; cannot balance.")
+
+    per_label_total = min_count
+    per_label_train = int(round(per_label_total * train_ratio))
+    per_label_train = max(1, min(per_label_train, per_label_total - 1))
+
+    trainset = []
+    testset = []
+    for label in labels:
+        rng.shuffle(buckets[label])
+        selected = buckets[label][:per_label_total]
+        trainset.extend(selected[:per_label_train])
+        testset.extend(selected[per_label_train:per_label_total])
+
+    rng.shuffle(trainset)
+    rng.shuffle(testset)
+    return trainset, testset
+
+
+import json
+path = "/home/mshahidul/readctrl/code/text_classifier/verified_combined_0-80.json"
+raw_data = json.load(open(path))
+trainset, testset = prepare_data(raw_data)
+
+def _example_to_dict(example):
+    return {
+        "generated_text": example.generated_text,
+        "literacy_label": example.literacy_label,
+    }
+
+def save_jsonl(path, examples):
+    with open(path, "w") as f:
+        for ex in examples:
+            f.write(json.dumps(_example_to_dict(ex), ensure_ascii=False) + "\n")
+
+train_path = "/home/mshahidul/readctrl/code/text_classifier/train.jsonl"
+test_path = "/home/mshahidul/readctrl/code/text_classifier/test.jsonl"
+save_jsonl(train_path, trainset)
+save_jsonl(test_path, testset)
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, 'literacy_label'):
+        return False
+    
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    
+    # Simple inclusion check helps if the LLM gets wordy
+    return gold_label in pred_label
+
+optimizer = BootstrapFewShotWithRandomSearch(
+    metric=health_literacy_metric,
+    max_bootstrapped_demos=3,
+    num_candidate_programs=8, 
+    teacher_settings=dict(lm=openai_model_teacher)
+)
+
+# 3. Compile! This creates the "optimized prompt"
+compiled_classifier = optimizer.compile(HealthLiteracyClassifier(), trainset=trainset)
+
+evaluator = Evaluate(devset=testset, metric=health_literacy_metric, num_threads=1, display_progress=True)
+evaluation_result = evaluator(compiled_classifier)
+accuracy_score = (
+    float(evaluation_result.score)
+    if hasattr(evaluation_result, "score")
+    else float(evaluation_result)
+)
+
+def _extract_usage(record):
+    if isinstance(record, dict):
+        usage = record.get("usage")
+        if usage:
+            return usage
+        response = record.get("response")
+        if isinstance(response, dict) and response.get("usage"):
+            return response["usage"]
+    return None
+
+def calc_cost_usd(lm, price_in_per_1m, price_out_per_1m, price_cached_in_per_1m=None):
+    prompt_tokens = 0
+    completion_tokens = 0
+    cached_tokens = 0
+    for record in getattr(lm, "history", []) or []:
+        usage = _extract_usage(record)
+        if not usage:
+            continue
+        prompt_tokens += int(usage.get("prompt_tokens", usage.get("input_tokens", 0)) or 0)
+        completion_tokens += int(usage.get("completion_tokens", usage.get("output_tokens", 0)) or 0)
+        cached_tokens += int(usage.get("cached_tokens", usage.get("prompt_tokens_cached", 0)) or 0)
+    cost = (prompt_tokens / 1_000_000) * price_in_per_1m
+    cost += (completion_tokens / 1_000_000) * price_out_per_1m
+    if price_cached_in_per_1m is not None:
+        cost += (cached_tokens / 1_000_000) * price_cached_in_per_1m
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "cached_tokens": cached_tokens,
+        "cost_usd": cost,
+    }
+
+# Fill these with current OpenAI pricing (USD per 1M tokens).
+GPT5_PRICE_INPUT_PER_1M = 1.25
+GPT5_PRICE_OUTPUT_PER_1M = 10.0
+
+teacher_cost = calc_cost_usd(
+    openai_model_teacher,
+    GPT5_PRICE_INPUT_PER_1M,
+    GPT5_PRICE_OUTPUT_PER_1M,
+)
+
+cost_report = {
+    "gpt-5": teacher_cost,
+}
+
+os.makedirs(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}", exist_ok=True)
+compiled_classifier.save(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/model.json")
+
+print(evaluation_result)
+
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/accuracy.json", "w") as f:
+    json.dump(
+        {
+            "accuracy_score": accuracy_score,
+            "num_results": len(getattr(evaluation_result, "results", []) or []),
+        },
+        f,
+        indent=2,
+    )
+print(json.dumps(cost_report, indent=2))
+with open(f"/home/mshahidul/readctrl/code/text_classifier/dspy_model/{folder_name}/cost.json", "w") as f:
+    json.dump(cost_report, f, indent=2)

code/text_classifier/text_classifier_dspy_vllm_test_cpp.py

@@ -0,0 +1,115 @@
+import json
+import os
+
+import dspy
+from dspy.evaluate import Evaluate
+
+
+LLM_CPP_API_BASE = os.environ.get("LLM_CPP_API_BASE", "http://172.16.34.21:8034/v1")
+MODEL_PATH = (
+    "/home/mshahidul/readctrl/code/text_classifier/dspy_model/vllm-Meta-Llama-3.1-8B-Instruct_teacher-gpt5_v1/model.json"
+)
+TEST_PATH = "/home/mshahidul/readctrl/code/text_classifier/test.jsonl"
+
+
+llama_cpp_lm = dspy.LM(
+    model="openai/dspy",
+    api_base=LLM_CPP_API_BASE,
+    api_key="EMPTY",
+    temperature=0.0,
+)
+dspy.configure(lm=llama_cpp_lm)
+
+
+class HealthLiteracySignature(dspy.Signature):
+    """
+    Analyze the linguistic complexity, use of medical jargon, and sentence
+    structure of 'generated_text' to determine the health literacy level.
+    """
+
+    generated_text = dspy.InputField(
+        desc="A version of the source text rewritten for a specific audience."
+    )
+    literacy_label = dspy.OutputField(
+        desc=(
+            "Classification: low_health_literacy (simple words, no jargon), "
+            "intermediate_health_literacy (moderate technicality), or "
+            "proficient_health_literacy (highly technical/original level)."
+        )
+    )
+
+
+class HealthLiteracyClassifier(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.classifier = dspy.ChainOfThought(HealthLiteracySignature)
+
+    def forward(self, generated_text):
+        return self.classifier(generated_text=generated_text)
+
+
+def load_testset(path):
+    examples = []
+    with open(path, "r") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            record = json.loads(line)
+            example = dspy.Example(
+                generated_text=record["generated_text"],
+                literacy_label=record["literacy_label"],
+            ).with_inputs("generated_text")
+            examples.append(example)
+    return examples
+
+
+def health_literacy_metric(gold, pred, trace=None):
+    if not pred or not hasattr(pred, "literacy_label"):
+        return False
+
+    gold_label = str(gold.literacy_label).strip().lower()
+    pred_label = str(pred.literacy_label).strip().lower()
+    return gold_label in pred_label
+
+
+def load_compiled_classifier(path):
+    if hasattr(dspy, "load"):
+        try:
+            return dspy.load(path)
+        except Exception:
+            pass
+    classifier = HealthLiteracyClassifier()
+    try:
+        classifier.load(path)
+    except Exception as exc:
+        raise RuntimeError(f"Failed to load compiled model from {path}") from exc
+    return classifier
+
+
+def main():
+    if not os.path.exists(MODEL_PATH):
+        raise FileNotFoundError(f"Model file not found: {MODEL_PATH}")
+    if not os.path.exists(TEST_PATH):
+        raise FileNotFoundError(f"Test file not found: {TEST_PATH}")
+
+    testset = load_testset(TEST_PATH)
+    compiled_classifier = load_compiled_classifier(MODEL_PATH)
+
+    evaluator = Evaluate(
+        devset=testset,
+        metric=health_literacy_metric,
+        num_threads=1,
+        display_progress=True,
+    )
+    evaluation_result = evaluator(compiled_classifier)
+    accuracy_score = (
+        float(evaluation_result.score)
+        if hasattr(evaluation_result, "score")
+        else float(evaluation_result)
+    )
+    print(evaluation_result)
+    print(f"accuracy_score: {accuracy_score}")
+
+
+if __name__ == "__main__":
+    main()

code/translation_quality_check/calc_comet_bertscore_from_jsonl.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""
+Compute BERTScore and COMET from saved translations.jsonl output.
+
+Expected JSONL fields per row:
+- target_language_file
+- direction (e.g., en_to_es)
+- source_text
+- reference_text
+- hypothesis_text
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Calculate COMET and BERTScore from translations.jsonl"
+    )
+    parser.add_argument(
+        "--input-jsonl",
+        default="/home/mshahidul/readctrl/code/translation_quality_check/run_20260214_201430/translations.jsonl",
+        help="Path to translations.jsonl",
+    )
+    parser.add_argument(
+        "--output-json",
+        default="",
+        help="Output JSON path (default: beside input as score_comet_bertscore.json)",
+    )
+    parser.add_argument(
+        "--output-csv",
+        default="",
+        help="Output CSV path (default: beside input as score_comet_bertscore.csv)",
+    )
+    parser.add_argument(
+        "--summary-csv",
+        default="",
+        help="Optional summary.csv to update with bertscore_f1 and comet",
+    )
+    parser.add_argument(
+        "--skip-bertscore",
+        action="store_true",
+        help="Skip BERTScore",
+    )
+    parser.add_argument(
+        "--skip-comet",
+        action="store_true",
+        help="Skip COMET",
+    )
+    parser.add_argument(
+        "--comet-model",
+        default="Unbabel/wmt22-comet-da",
+        help="COMET model name for download_model",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=8,
+        help="Batch size for COMET prediction",
+    )
+    return parser.parse_args()
+
+
+def load_jsonl(path: Path) -> List[dict]:
+    rows: List[dict] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON at line {line_no} in {path}: {exc}") from exc
+    return rows
+
+
+def direction_target_lang(direction: str) -> str:
+    # Expected format: src_to_tgt
+    parts = direction.split("_to_")
+    if len(parts) != 2:
+        return "en"
+    return parts[1].strip().lower()
+
+
+def compute_bertscore(
+    hyps: List[str], refs: List[str], target_lang: str
+) -> Optional[float]:
+    try:
+        from bert_score import score as bert_score_fn  # type: ignore
+    except Exception as exc:
+        print(
+            "[WARN] Could not import bert_score. "
+            "Install with: pip install bert-score\n"
+            f"       Details: {exc}"
+        )
+        return None
+    # BERTScore supports short language codes like en/es/fr/pt.
+    _, _, f1 = bert_score_fn(hyps, refs, lang=target_lang, verbose=False)
+    return round(float(f1.mean().item()), 6)
+
+
+def compute_comet(
+    srcs: List[str],
+    hyps: List[str],
+    refs: List[str],
+    model_name: str,
+    batch_size: int,
+) -> Optional[float]:
+    try:
+        from comet import download_model, load_from_checkpoint  # type: ignore
+    except Exception as exc:
+        print(
+            "[WARN] Could not import comet. "
+            "Install with: pip install unbabel-comet\n"
+            f"       Details: {exc}"
+        )
+        return None
+
+    model_path = download_model(model_name)
+    comet_model = load_from_checkpoint(model_path)
+    data = [{"src": s, "mt": h, "ref": r} for s, h, r in zip(srcs, hyps, refs)]
+    result = comet_model.predict(
+        data,
+        batch_size=batch_size,
+        gpus=1 if os.environ.get("CUDA_VISIBLE_DEVICES") else 0,
+    )
+    return round(float(result.system_score), 6)
+
+
+def write_json(path: Path, payload: dict) -> None:
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+
+
+def write_csv(path: Path, rows: List[dict]) -> None:
+    cols = [
+        "language_file",
+        "direction",
+        "n_samples",
+        "bertscore_f1",
+        "comet",
+    ]
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=cols)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def maybe_update_summary_csv(summary_path: Path, metrics_rows: List[dict]) -> Path:
+    metric_lookup: Dict[Tuple[str, str], dict] = {
+        (row["language_file"], row["direction"]): row for row in metrics_rows
+    }
+    with summary_path.open("r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        src_rows = list(reader)
+        cols = list(reader.fieldnames or [])
+
+    if "bertscore_f1" not in cols:
+        cols.append("bertscore_f1")
+    if "comet" not in cols:
+        cols.append("comet")
+
+    out_rows: List[dict] = []
+    for row in src_rows:
+        key = (row.get("language_file", ""), row.get("direction", ""))
+        m = metric_lookup.get(key)
+        if m:
+            row["bertscore_f1"] = m.get("bertscore_f1", "")
+            row["comet"] = m.get("comet", "")
+        out_rows.append(row)
+
+    out_path = summary_path.with_name(f"{summary_path.stem}_with_comet_bertscore.csv")
+    with out_path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=cols)
+        writer.writeheader()
+        writer.writerows(out_rows)
+    return out_path
+
+
+def main() -> None:
+    args = parse_args()
+    input_path = Path(args.input_jsonl)
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input not found: {input_path}")
+
+    out_json = (
+        Path(args.output_json)
+        if args.output_json
+        else input_path.with_name("score_comet_bertscore.json")
+    )
+    out_csv = (
+        Path(args.output_csv)
+        if args.output_csv
+        else input_path.with_name("score_comet_bertscore.csv")
+    )
+
+    rows = load_jsonl(input_path)
+    if not args.skip_bertscore:
+        print("[info] BERTScore enabled")
+    if not args.skip_comet:
+        print("[info] COMET enabled")
+    groups: Dict[Tuple[str, str], List[dict]] = defaultdict(list)
+    for r in rows:
+        lang_file = str(r.get("target_language_file", "")).strip()
+        direction = str(r.get("direction", "")).strip()
+        if not lang_file or not direction:
+            continue
+        groups[(lang_file, direction)].append(r)
+
+    score_rows: List[dict] = []
+    payload = {
+        "input_jsonl": str(input_path),
+        "scores": {},
+    }
+
+    for (lang_file, direction), group_rows in sorted(groups.items()):
+        srcs = [str(x.get("source_text", "")) for x in group_rows]
+        refs = [str(x.get("reference_text", "")) for x in group_rows]
+        hyps = [str(x.get("hypothesis_text", "")) for x in group_rows]
+
+        tgt_lang = direction_target_lang(direction)
+        bert = None if args.skip_bertscore else compute_bertscore(hyps, refs, tgt_lang)
+        comet = None
+        if not args.skip_comet:
+            comet = compute_comet(
+                srcs=srcs,
+                hyps=hyps,
+                refs=refs,
+                model_name=args.comet_model,
+                batch_size=args.batch_size,
+            )
+
+        row = {
+            "language_file": lang_file,
+            "direction": direction,
+            "n_samples": len(group_rows),
+            "bertscore_f1": bert if bert is not None else "",
+            "comet": comet if comet is not None else "",
+        }
+        score_rows.append(row)
+        payload["scores"].setdefault(lang_file, {})[direction] = {
+            "n_samples": len(group_rows),
+            "bertscore_f1": bert,
+            "comet": comet,
+        }
+        print(
+            f"[done] {lang_file} {direction}: "
+            f"bertscore_f1={row['bertscore_f1']} comet={row['comet']}"
+        )
+
+    write_json(out_json, payload)
+    write_csv(out_csv, score_rows)
+    print(f"\nSaved JSON: {out_json}")
+    print(f"Saved CSV:  {out_csv}")
+
+    if args.summary_csv:
+        summary_path = Path(args.summary_csv)
+        if not summary_path.exists():
+            raise FileNotFoundError(f"summary.csv not found: {summary_path}")
+        merged_path = maybe_update_summary_csv(summary_path, score_rows)
+        print(f"Saved merged summary: {merged_path}")
+
+
+if __name__ == "__main__":
+    main()

code/translation_quality_check/eval_gpt52_translation.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Evaluate GPT-5.2 translation quality on MultiClinSum files.
+
+What this script does:
+1) Loads EN/ES/FR/PT json files (expects fields like id/fulltext/summary)
+2) Aligns EN with each non-EN language by shared numeric case id
+3) Samples N aligned instances per language pair
+4) Runs bidirectional translation with GPT-5.2:
+   - EN -> X
+   - X -> EN
+5) Reports common MT metrics used in top venues:
+   - BLEU (sacreBLEU)
+   - chrF++ (sacreBLEU chrF)
+   - COMET (if installed)
+   - BERTScore F1 (if installed)
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import random
+import re
+import sys
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from openai import OpenAI
+import sacrebleu
+
+
+ID_NUM_RE = re.compile(r"_(\d+)\.txt$")
+
+
+@dataclass
+class Example:
+    case_id: str
+    text: str
+    raw_id: str
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="GPT-5.2 translation evaluation")
+    parser.add_argument(
+        "--en-file",
+        default="/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_en.json",
+        help="Path to English json file",
+    )
+    parser.add_argument(
+        "--es-file",
+        default="/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_es.json",
+        help="Path to Spanish json file",
+    )
+    parser.add_argument(
+        "--fr-file",
+        default="/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_fr.json",
+        help="Path to French json file",
+    )
+    parser.add_argument(
+        "--pt-file",
+        default="/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_pt.json",
+        help="Path to Portuguese json file",
+    )
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=20,
+        help="Samples per language pair",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument(
+        "--model",
+        default="gpt-5.2",
+        help="OpenAI model name",
+    )
+    parser.add_argument(
+        "--max-chars",
+        type=int,
+        default=2500,
+        help="Character cap per sample to control cost/latency",
+    )
+    parser.add_argument(
+        "--api-file",
+        default="/home/mshahidul/api_new.json",
+        help="JSON file containing API keys (expects key 'openai')",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="/home/mshahidul/readctrl/code/translation_quality_check",
+        help="Directory to save outputs",
+    )
+    parser.add_argument(
+        "--skip-comet",
+        action="store_true",
+        help="Skip COMET even if installed",
+    )
+    parser.add_argument(
+        "--skip-bertscore",
+        action="store_true",
+        help="Skip BERTScore even if installed",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.0,
+        help="Decoding temperature",
+    )
+    parser.add_argument(
+        "--save-every",
+        type=int,
+        default=10,
+        help="Checkpoint save interval (in translated instances)",
+    )
+    return parser.parse_args()
+
+
+def load_json(path: str) -> List[dict]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def normalize_case_id(raw_id: str) -> str:
+    m = ID_NUM_RE.search(raw_id)
+    if m:
+        return m.group(1)
+    return raw_id
+
+
+def dataset_to_examples(rows: List[dict], field: str) -> Dict[str, Example]:
+    out: Dict[str, Example] = {}
+    for row in rows:
+        raw_id = str(row.get("id", ""))
+        case_id = normalize_case_id(raw_id)
+        text = row.get(field)
+        if text is None:
+            text = row.get("summary") or row.get("fulltext") or ""
+        text = str(text).strip()
+        if not text:
+            continue
+        out[case_id] = Example(case_id=case_id, text=text, raw_id=raw_id)
+    return out
+
+
+def truncate_text(text: str, max_chars: int) -> str:
+    if max_chars <= 0:
+        return text
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars].rstrip() + " ..."
+
+
+def translate_one(
+    client: OpenAI,
+    model: str,
+    text: str,
+    src_lang_name: str,
+    tgt_lang_name: str,
+    temperature: float,
+) -> str:
+    system = (
+        "You are a professional medical translator for clinical text. "
+        "Your top priority is fidelity and patient-safety: do not hallucinate, "
+        "do not add, remove, infer, or normalize medical content that is not explicitly present. "
+        "Preserve the original meaning, uncertainty, negation, severity, temporality, "
+        "numbers, units, dosages, lab values, abbreviations, named entities, and terminology. "
+        "If a term is ambiguous, keep the closest literal translation rather than guessing. "
+        "Keep formatting and sentence boundaries as close as possible to the source. "
+        "Return only the translated text, with no explanation."
+    )
+    user = (
+        f"Translate the following medical text from {src_lang_name} to {tgt_lang_name}.\n"
+        "Strict rules: no extra information, no paraphrased additions, no clinical assumptions.\n\n"
+        f"{text}"
+    )
+    response = client.responses.create(
+        model=model,
+        input=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+    )
+    return response.output_text.strip()
+
+
+def compute_bleu_chrf(hypotheses: List[str], references: List[str]) -> Dict[str, float]:
+    bleu = sacrebleu.corpus_bleu(hypotheses, [references]).score
+    chrf = sacrebleu.corpus_chrf(hypotheses, [references]).score
+    return {"bleu": round(bleu, 4), "chrf++": round(chrf, 4)}
+
+
+def maybe_compute_bertscore(
+    hypotheses: List[str],
+    references: List[str],
+    target_lang: str,
+) -> Optional[float]:
+    try:
+        from bert_score import score as bert_score_fn  # type: ignore
+    except Exception:
+        return None
+    _, _, f1 = bert_score_fn(hypotheses, references, lang=target_lang, verbose=False)
+    return round(float(f1.mean().item()), 6)
+
+
+def maybe_compute_comet(
+    sources: List[str],
+    hypotheses: List[str],
+    references: List[str],
+) -> Optional[float]:
+    try:
+        from comet import download_model, load_from_checkpoint  # type: ignore
+    except Exception:
+        return None
+    model_path = download_model("Unbabel/wmt22-comet-da")
+    comet_model = load_from_checkpoint(model_path)
+    data = [{"src": s, "mt": h, "ref": r} for s, h, r in zip(sources, hypotheses, references)]
+    result = comet_model.predict(data, batch_size=8, gpus=1 if os.environ.get("CUDA_VISIBLE_DEVICES") else 0)
+    return round(float(result.system_score), 6)
+
+
+def ensure_dir(path: str) -> None:
+    Path(path).mkdir(parents=True, exist_ok=True)
+
+
+def persist_outputs(
+    json_path: Path,
+    details_path: Path,
+    csv_path: Path,
+    all_results: dict,
+    detailed_rows: List[dict],
+    summary_rows: List[dict],
+) -> None:
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(all_results, f, ensure_ascii=False, indent=2)
+
+    with open(details_path, "w", encoding="utf-8") as f:
+        for row in detailed_rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    cols = [
+        "language_file",
+        "direction",
+        "n_samples",
+        "bleu",
+        "chrf++",
+        "bertscore_f1",
+        "comet",
+        "elapsed_sec",
+    ]
+    with open(csv_path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=cols)
+        writer.writeheader()
+        if summary_rows:
+            writer.writerows(summary_rows)
+
+
+def resolve_openai_api_key(api_file: str) -> str:
+    # Keep same loading pattern used in diff_label_text_creation_bangla.py.
+    with open(api_file, "r", encoding="utf-8") as f:
+        api_keys = json.load(f)
+    return str(api_keys["openai"])
+
+
+def main() -> None:
+    args = parse_args()
+    api_key = resolve_openai_api_key(args.api_file)
+
+    rng = random.Random(args.seed)
+    client = OpenAI(api_key=api_key)
+
+    en_rows = load_json(args.en_file)
+    lang_files = {"es": args.es_file, "fr": args.fr_file, "pt": args.pt_file}
+
+    field = "fulltext"
+    en_map = dataset_to_examples(en_rows, field)
+    lang_maps = {
+        lang: dataset_to_examples(load_json(path), field)
+        for lang, path in lang_files.items()
+    }
+
+    lang_name = {"en": "English", "es": "Spanish", "fr": "French", "pt": "Portuguese"}
+    bert_lang = {"en": "en", "es": "es", "fr": "fr", "pt": "pt"}
+
+    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+    run_dir = Path(args.output_dir) / f"run_{timestamp}"
+    ensure_dir(str(run_dir))
+
+    all_results = {
+        "run_time_utc": datetime.utcnow().isoformat(),
+        "settings": {
+            "model": args.model,
+            "field": field,
+            "num_samples": args.num_samples,
+            "max_chars": args.max_chars,
+            "seed": args.seed,
+            "files": {
+                "en": args.en_file,
+                "es": args.es_file,
+                "fr": args.fr_file,
+                "pt": args.pt_file,
+            },
+        },
+        "scores": {},
+    }
+
+    detailed_rows: List[dict] = []
+    summary_rows: List[dict] = []
+    all_results["partial_scores"] = {}
+
+    json_path = run_dir / "scores.json"
+    details_path = run_dir / "translations.jsonl"
+    csv_path = run_dir / "summary.csv"
+
+    for tgt_lang, tgt_map in lang_maps.items():
+        common_ids = sorted(set(en_map.keys()) & set(tgt_map.keys()))
+        if not common_ids:
+            print(f"[WARN] No aligned IDs between en and {tgt_lang}. Skipping.")
+            continue
+        k = min(args.num_samples, len(common_ids))
+        sampled_ids = rng.sample(common_ids, k=k)
+
+        pair_results = {}
+        print(f"[INFO] Evaluating EN <-> {tgt_lang.upper()} with {k} samples")
+
+        directions = [("en", tgt_lang), (tgt_lang, "en")]
+        for src_lang, out_lang in directions:
+            sources: List[str] = []
+            refs: List[str] = []
+            hyps: List[str] = []
+
+            start = time.time()
+            for idx, case_id in enumerate(sampled_ids, start=1):
+                src_ex = en_map[case_id] if src_lang == "en" else tgt_map[case_id]
+                ref_ex = tgt_map[case_id] if out_lang == tgt_lang else en_map[case_id]
+
+                src_text = truncate_text(src_ex.text, args.max_chars)
+                ref_text = truncate_text(ref_ex.text, args.max_chars)
+
+                hyp = translate_one(
+                    client=client,
+                    model=args.model,
+                    text=src_text,
+                    src_lang_name=lang_name[src_lang],
+                    tgt_lang_name=lang_name[out_lang],
+                    temperature=args.temperature,
+                )
+
+                sources.append(src_text)
+                refs.append(ref_text)
+                hyps.append(hyp)
+
+                detailed_rows.append(
+                    {
+                        "target_language_file": tgt_lang,
+                        "direction": f"{src_lang}_to_{out_lang}",
+                        "case_id": case_id,
+                        "src_raw_id": src_ex.raw_id,
+                        "ref_raw_id": ref_ex.raw_id,
+                        "source_text": src_text,
+                        "reference_text": ref_text,
+                        "hypothesis_text": hyp,
+                    }
+                )
+                print(
+                    f"  [{src_lang}->{out_lang}] {idx}/{k} done "
+                    f"(case_id={case_id})"
+                )
+
+                if args.save_every > 0 and (idx % args.save_every == 0):
+                    partial_key = f"{tgt_lang}:{src_lang}_to_{out_lang}"
+                    all_results["partial_scores"][partial_key] = {
+                        "completed": idx,
+                        "total": k,
+                        **compute_bleu_chrf(hyps, refs),
+                    }
+                    persist_outputs(
+                        json_path=json_path,
+                        details_path=details_path,
+                        csv_path=csv_path,
+                        all_results=all_results,
+                        detailed_rows=detailed_rows,
+                        summary_rows=summary_rows,
+                    )
+                    print(
+                        f"    [checkpoint] saved at {idx}/{k} "
+                        f"for {src_lang}->{out_lang}"
+                    )
+
+            metric_dict = compute_bleu_chrf(hyps, refs)
+            if not args.skip_bertscore:
+                bs = maybe_compute_bertscore(hyps, refs, bert_lang[out_lang])
+                metric_dict["bertscore_f1"] = bs if bs is not None else None
+            if not args.skip_comet:
+                comet = maybe_compute_comet(sources, hyps, refs)
+                metric_dict["comet"] = comet if comet is not None else None
+
+            metric_dict["n_samples"] = k
+            metric_dict["elapsed_sec"] = round(time.time() - start, 2)
+            key = f"{src_lang}_to_{out_lang}"
+            pair_results[key] = metric_dict
+
+            summary_rows.append(
+                {
+                    "language_file": tgt_lang,
+                    "direction": key,
+                    **metric_dict,
+                }
+            )
+
+        all_results["scores"][tgt_lang] = pair_results
+
+    persist_outputs(
+        json_path=json_path,
+        details_path=details_path,
+        csv_path=csv_path,
+        all_results=all_results,
+        detailed_rows=detailed_rows,
+        summary_rows=summary_rows,
+    )
+
+    print("\n=== Translation Evaluation Complete ===")
+    print(f"Run directory: {run_dir}")
+    print(f"Scores JSON:   {json_path}")
+    print(f"Summary CSV:   {csv_path}")
+    print(f"Details JSONL: {details_path}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.")
+        sys.exit(130)

code/validation/data_gen_subclaims_support_valid_ch_gpt5.py

@@ -0,0 +1,56 @@
+from openai import OpenAI
+import json, os
+
+with open("/home/mshahidul/readctrl/prompts/subclaim_result_generate_gpt5.txt", "r") as f:
+    prompt_template = f.read()
+
+
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+client = OpenAI(api_key=openai_api_key)
+
+
+def openai_return(prompt, model="gpt-5"):
+    """Send a prompt to GPT and parse JSON."""
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    content = response.choices[0].message.content.strip()
+    cleaned = content.replace("```json", "").replace("```", "").strip()
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        print("⚠️ JSON parse failed — storing raw text.")
+        return cleaned
+
+with open("/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json", "r") as f:
+    data = json.load(f)
+
+save_path="/home/mshahidul/readctrl/data/model_validity_check/subclaims_support_validity_check_gt_gpt5(1-5).json"
+res=[]
+if os.path.exists(save_path):
+    with open(save_path, "r") as f:
+        res = json.load(f)
+import tqdm
+for i in tqdm.tqdm(range(5)):
+    for label in ["easy", "intermediate", "hard"]:
+        new_prompt = prompt_template.replace("<<<DOCUMENT>>>",data[i]['fulltext']).replace("<<<SUBCLAIMS>>>", json.dumps(data[i][f'{label}_subclaims'], indent=2, ensure_ascii=False))
+        # import ipdb; ipdb.set_trace()
+        sample = openai_return(new_prompt, model="gpt-5")
+
+        res.append(sample)
+        if len(res) % 2 == 0:
+            with open(save_path, "w") as f:
+                json.dump(res, f, indent=2, ensure_ascii=False)
+            print(f"Saved {len(res)} samples so far.")
+
+with open(save_path, "w") as f:
+    json.dump(res, f, indent=2, ensure_ascii=False)
+

code/validation/subclaims_extr_valid_check_gpt5.py

@@ -0,0 +1,56 @@
+from openai import OpenAI
+import json, os
+
+with open("/home/mshahidul/readctrl/prompts/subclaims_extraction_vali.txt", "r") as f:
+    prompt_template = f.read()
+
+
+api_file = "/home/mshahidul/api_new.json"
+with open(api_file, "r") as f:
+    api_keys = json.load(f)
+openai_api_key = api_keys["openai"]
+
+client = OpenAI(api_key=openai_api_key)
+
+
+def openai_return(prompt, model="gpt-5"):
+    """Send a prompt to GPT and parse JSON."""
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    content = response.choices[0].message.content.strip()
+    cleaned = content.replace("```json", "").replace("```", "").strip()
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        print("⚠️ JSON parse failed — storing raw text.")
+        return cleaned
+
+with open("/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json", "r") as f:
+    data = json.load(f)
+
+save_path="/home/mshahidul/readctrl/data/model_validity_check/subclaims_validity_check_v1.json"
+res=[]
+if os.path.exists(save_path):
+    with open(save_path, "r") as f:
+        res = json.load(f)
+import tqdm
+for i in tqdm.tqdm(range(5)):
+    for label in ["easy", "intermediate", "hard"]:
+        new_prompt = prompt_template.replace("<<<TEXT>>>",data[i][f"{label}_text"]).replace("<<<SUBCLAIMS>>>", json.dumps(data[i][f"{label}_subclaims"], indent=2, ensure_ascii=False))
+        # import ipdb; ipdb.set_trace()
+        sample = openai_return(new_prompt, model="gpt-5")
+
+        res.append(sample)
+        if len(res) % 2 == 0:
+            with open(save_path, "w") as f:
+                json.dump(res, f, indent=2, ensure_ascii=False)
+            print(f"Saved {len(res)} samples so far.")
+
+with open(save_path, "w") as f:
+    json.dump(res, f, indent=2, ensure_ascii=False)
+