qwen

README.md

@@ -0,0 +1,26 @@
+---
+title: Cardiology AI - Qwen
+emoji: 🌌
+colorFrom: purple
+colorTo: indigo
+sdk: gradio
+sdk_version: "5.25.0"
+app_file: app.py
+pinned: false
+hardware: zero-a10g
+secrets:
+  - HF_TOKEN
+---
+
+# 🌌 Cardiology AI Assistant — Qwen3-4B
+
+RAG-based cardiology Q&A over the **2024 ESC Guidelines**.
+
+- **Retriever:** MedCPT (CPU)
+- **Reranker:** BAAI/bge-reranker-base
+- **Generator:** Qwen/Qwen3-4B-Instruct-2507 (ZeroGPU)
+
+## Setup
+1. Upload `2024ESC-compressed.pdf` to the Space repo root.
+2. Add `HF_TOKEN` in **Settings → Secrets** (Qwen is a gated model).
+3. Hardware: ZeroGPU (requires HF Pro).

app.py

@@ -0,0 +1,212 @@
+"""
+Cardiology AI Assistant — Alibaba Qwen3-4B-Instruct
+Hugging Face ZeroGPU Space (free shared A100)
+
+ZeroGPU rules applied:
+  - No bitsandbytes quantization
+  - Model loads to CPU at startup in float16
+  - @spaces.GPU decorator borrows GPU only during inference
+"""
+
+import os, gc, torch, warnings
+import spaces                               # ← ZeroGPU magic
+from typing import List
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_core.embeddings import Embeddings
+from sentence_transformers import CrossEncoder
+import gradio as gr
+
+warnings.filterwarnings("ignore")
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+MODEL_NAME = "Qwen/Qwen3-4B-Instruct-2507"
+PDF_PATH   = "./2024ESC-compressed.pdf"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# MEDCPT EMBEDDINGS  (CPU)
+# ══════════════════════════════════════════════════════════════════════════════
+class MedCPTEmbeddings(Embeddings):
+    def __init__(self, load_article_encoder: bool = True):
+        print("⚙️  Initializing MedCPT on CPU...")
+        self.models = {
+            "qry_tok": AutoTokenizer.from_pretrained("ncbi/MedCPT-Query-Encoder"),
+            "qry_mod": AutoModel.from_pretrained("ncbi/MedCPT-Query-Encoder"),
+        }
+        if load_article_encoder:
+            self.models["art_tok"] = AutoTokenizer.from_pretrained("ncbi/MedCPT-Article-Encoder")
+            self.models["art_mod"] = AutoModel.from_pretrained("ncbi/MedCPT-Article-Encoder")
+
+    def embed_documents(self, texts):
+        all_embeddings = []
+        for i in range(0, len(texts), 8):
+            batch = texts[i: i + 8]
+            inputs = self.models["art_tok"](
+                batch, max_length=512, padding=True, truncation=True, return_tensors="pt"
+            )
+            with torch.no_grad():
+                out = self.models["art_mod"](**inputs)
+                all_embeddings.extend(out.last_hidden_state[:, 0, :].tolist())
+        return all_embeddings
+
+    def embed_query(self, text):
+        inputs = self.models["qry_tok"](
+            [text], max_length=512, padding=True, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            out = self.models["qry_mod"](**inputs)
+            return out.last_hidden_state[:, 0, :][0].tolist()
+
+    def unload_article_encoder(self):
+        if "art_mod" in self.models:
+            del self.models["art_mod"], self.models["art_tok"]
+            gc.collect()
+
+# ══════════════════════════════════════════════════════════════════════════════
+# STARTUP
+# ══════════════════════════════════════════════════════════════════════════════
+print("📂 Loading PDF with PyMuPDF...")
+loader    = PyMuPDFLoader(PDF_PATH)
+documents = loader.load()
+print(f"✅ Loaded {len(documents)} pages.")
+
+print("✂️  Splitting...")
+splitter = RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=64)
+chunks   = splitter.split_documents(documents)
+
+print("🧠 Building MedCPT vector store (CPU)...")
+emb = MedCPTEmbeddings(load_article_encoder=True)
+vectorstore = FAISS.from_documents(chunks, emb)
+retriever   = vectorstore.as_retriever(search_kwargs={"k": 20})
+emb.unload_article_encoder()
+print("✅ Vector store ready.")
+
+print("⚖️  Loading CrossEncoder (CPU init)...")
+reranker = CrossEncoder("BAAI/bge-reranker-base", device="cpu")
+
+print("🚀 Loading Qwen3-4B in float16 (CPU)...")
+tokenizer = AutoTokenizer.from_pretrained(
+    MODEL_NAME, token=HF_TOKEN, trust_remote_code=True
+)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    token=HF_TOKEN,
+    torch_dtype=torch.float16,
+    low_cpu_mem_usage=True,
+    trust_remote_code=True,
+)
+model.eval()
+print("✅ Qwen3 ready (CPU). GPU borrowed per request via ZeroGPU.")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# GPU FUNCTIONS
+# ═════════════════════════════════════════════════════════════════��════════════
+
+@spaces.GPU
+def rerank_docs(query: str, docs):
+    reranker.model.to("cuda")
+    scores = reranker.predict([[query, d.page_content] for d in docs])
+    reranker.model.to("cpu")
+    torch.cuda.empty_cache()
+    return scores
+
+@spaces.GPU
+def llm_generate(messages: list) -> str:
+    model.to("cuda")
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(text, return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        generated_ids = model.generate(
+            **inputs,
+            max_new_tokens=512,
+            do_sample=True,
+            temperature=0.7,
+            top_p=0.8,
+            top_k=20,
+            repetition_penalty=1.05,
+        )
+    input_len = inputs["input_ids"].shape[1]
+    answer = tokenizer.decode(generated_ids[0][input_len:], skip_special_tokens=True)
+    del inputs, generated_ids
+    model.to("cpu")
+    torch.cuda.empty_cache()
+    return answer
+
+# ══════════════════════════════════════════════════════════════════════════════
+# RAG PIPELINE
+# ══════════════════════════════════════════════════════════════════════════════
+def rag_query_stream(query: str):
+    yield "⏳ **Status:** 🔍 Retrieving documents from VectorDB...\n\n---\n"
+    candidates = retriever.invoke(query)
+
+    yield "⏳ **Status:** 📊 Reranking with CrossEncoder (ZeroGPU)...\n\n---\n"
+    scores = rerank_docs(query, candidates)
+    ranked   = sorted(zip(scores, candidates), key=lambda x: x[0], reverse=True)
+    top_docs = [doc for _, doc in ranked[:4]]
+    context  = "\n\n".join(d.page_content for d in top_docs)
+    pages    = ", ".join(str(d.metadata.get("page", "?")) for d in top_docs)
+
+    yield "⏳ **Status:** 🧠 Generating with Qwen3 (ZeroGPU A100)...\n\n---\n"
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a medical expert assistant specialising in cardiology. "
+                "Answer the user's question using ONLY the context provided. "
+                "If the answer is not in the context, say you don't know.\n\n"
+                f"Context:\n{context}"
+            ),
+        },
+        {"role": "user", "content": query},
+    ]
+    answer = llm_generate(messages)
+    yield f"### 🌌 Answer\n\n{answer}\n\n📄 **Source Pages:** {pages}\n"
+
+# ══════════════════════════════════════════════════════════════════════════════
+# GRADIO UI
+# ══════════════════════════════════════════════════════════════════════════════
+def gradio_wrapper(query):
+    if not query or not query.strip():
+        yield "⚠️ Please enter a valid question."
+        return
+    yield from rag_query_stream(query)
+
+qwen_theme = gr.themes.Soft(
+    primary_hue="violet",
+    secondary_hue="indigo",
+    neutral_hue="slate",
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "sans-serif"],
+).set(
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+)
+
+with gr.Blocks(theme=qwen_theme) as demo:
+    gr.Markdown("# 🌌 Cardiology AI Assistant (ESC 2024)")
+    gr.Markdown("### ⚡ Powered by Alibaba Qwen3-4B · HF ZeroGPU")
+    gr.Markdown(
+        "Ask questions based on the **2024 ESC Medical Guidelines**. "
+        "Uses RAG with MedCPT embeddings, Cross-Encoder reranking, and Qwen3-4B generation."
+    )
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(
+                label="Your Clinical Question",
+                placeholder="e.g., What are the class I recommendations for anticoagulation in AF?",
+                lines=3,
+            )
+            submit_btn = gr.Button("Analyze Guidelines", variant="primary")
+    output_text = gr.Markdown(label="Assistant Response")
+    gr.Examples(
+        examples=[
+            "What are the class I recommendations for anticoagulation in AF?",
+            "Summarize the treatment algorithm for chronic heart failure.",
+            "What is the target LDL-C for very high-risk patients?",
+        ],
+        inputs=input_text,
+    )
+    submit_btn.click(gradio_wrapper, inputs=input_text, outputs=output_text)
+
+demo.queue().launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,11 @@
+transformers>=4.41.2
+accelerate
+langchain
+langchain-community
+langchain-core
+langchain-text-splitters
+faiss-cpu
+sentence-transformers
+pymupdf
+torch
+huggingface_hub