update code for website

Dockerfile

@@ -17,10 +17,10 @@ RUN pip3 install --upgrade pip
 
 RUN pip3 install -r requirements.txt
 
-EXPOSE 8501
+# Note: HF Spaces uses `sdk: gradio` (see README.md) and ignores this Dockerfile —
+# it's kept only for local/dev `docker build && docker run` testing.
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+HEALTHCHECK CMD curl --fail http://localhost:7860/ || exit 1
 
-# WORKDIR /app/src
-# ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
-ENTRYPOINT ["streamlit", "run", "src/app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["python3", "src/app.py"]

README.md

@@ -2,10 +2,12 @@
 title: StatDetectLLM — Detecting AI-Generated Text with Statistical Guarantees
 colorFrom: blue
 colorTo: pink
-sdk: docker
-app_port: 8501
+sdk: gradio
+sdk_version: 5.31.0
+app_file: src/app.py
 tags:
-- streamlit
+- gradio
+- zero-gpu
 pinned: true
 license: apache-2.0
 emoji: 🚀

requirements.txt

@@ -1,6 +1,6 @@
 # requirements.txt
-altair
-streamlit
+gradio==5.31.0
+spaces>=0.30.0
 pandas==2.3.1
 torch==2.8.0
 numpy==2.1.3
@@ -8,4 +8,4 @@ transformers==4.55.2
 peft==0.17.1
 tqdm
 scikit-learn
-huggingface_hub
+huggingface_hub

src/FineTune/model.py

@@ -11,7 +11,7 @@ def calculate_MMD_loss(human_crit, sample_crit):
     mmd_loss = human_crit.mean() - sample_crit.mean()
     return mmd_loss
 
-def from_pretrained(cls, model_name, kwargs, cache_dir):
+def from_pretrained(cls, model_name, kwargs, cache_dir, device=None):
     # use local model if it exists
     if "/" in model_name:
         local_path = os.path.join(cache_dir, model_name.split("/")[1])
@@ -19,8 +19,18 @@ def from_pretrained(cls, model_name, kwargs, cache_dir):
         local_path = os.path.join(cache_dir, model_name)
 
     if os.path.exists(local_path):
-        return cls.from_pretrained(local_path, **kwargs)
-    return cls.from_pretrained(model_name, **kwargs, cache_dir=cache_dir, device_map='auto')
+        return cls.from_pretrained(local_path, **kwargs, trust_remote_code=True)
+
+    remote_kwargs = dict(kwargs, cache_dir=cache_dir, trust_remote_code=True)
+    if device is not None:
+        # Pin the whole model to a single device instead of device_map='auto'.
+        # 'auto' lets accelerate split the model across GPU/CPU/disk when
+        # memory is tight at load time, which then makes a later `.to(device)`
+        # raise "You can't move a model that has some modules offloaded to
+        # cpu or disk." Forcing everything onto one device up front avoids
+        # that split entirely.
+        remote_kwargs["device_map"] = {"": device}
+    return cls.from_pretrained(model_name, **remote_kwargs)
 
 model_fullnames = {  
     'gemma-1b': 'google/gemma-3-1b-pt',
@@ -76,7 +86,7 @@ class ComputeStat(nn.Module):
                 model_kwargs.update(dict(torch_dtype=torch.float16))
             if torch.__version__ >= '2.0.0' and 'gemma' in model_name:
                 model_kwargs.update({'attn_implementation': 'sdpa'})
-            model = from_pretrained(AutoModelForCausalLM, model_fullname, model_kwargs, cache_dir)
+            model = from_pretrained(AutoModelForCausalLM, model_fullname, model_kwargs, cache_dir, device=device)
             print(f'Moving model to {device}...', end='', flush=True)
             start = time.time()
             model.to(device)
@@ -181,10 +191,14 @@ class ComputeStat(nn.Module):
         # 2. 加载 scoring_model
         scoring_dir = os.path.join(load_directory, "scoring_model")
         model.scoring_model = AutoPeftModelForCausalLM.from_pretrained(
-            scoring_dir, 
-            device_map="auto", 
-            low_cpu_mem_usage=True, 
-            use_safetensors=True
+            scoring_dir,
+            # Same fix as `from_pretrained()` above: pin to model.device
+            # instead of 'auto' so this adapter checkpoint can't end up
+            # split across devices from the reference model it sits next to.
+            device_map={"": model.device},
+            low_cpu_mem_usage=True,
+            use_safetensors=True,
+            trust_remote_code=True,
         )
 
         # 3. 加载所有 null_distr

src/FineTune/model.py.bak

@@ -0,0 +1,304 @@
+import torch
+from torch import nn
+from peft import get_peft_model, LoraConfig, TaskType, AutoPeftModelForCausalLM
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import time
+import json
+
+import os
+
+def calculate_MMD_loss(human_crit, sample_crit):
+    mmd_loss = human_crit.mean() - sample_crit.mean()
+    return mmd_loss
+
+def from_pretrained(cls, model_name, kwargs, cache_dir):
+    # use local model if it exists
+    if "/" in model_name:
+        local_path = os.path.join(cache_dir, model_name.split("/")[1])
+    else:
+        local_path = os.path.join(cache_dir, model_name)
+
+    if os.path.exists(local_path):
+        return cls.from_pretrained(local_path, **kwargs)
+    return cls.from_pretrained(model_name, **kwargs, cache_dir=cache_dir, device_map='auto')
+
+model_fullnames = {  
+    'gemma-1b': 'google/gemma-3-1b-pt',
+}
+float16_models = []
+
+def get_model_fullname(model_name):
+    return model_fullnames[model_name] if model_name in model_fullnames else model_name
+
+def load_tokenizer(model_name, for_dataset, cache_dir):
+    model_fullname = get_model_fullname(model_name)
+    optional_tok_kwargs = {}
+    if for_dataset in ['pubmed']:
+        optional_tok_kwargs['padding_side'] = 'left'
+    else:
+        optional_tok_kwargs['padding_side'] = 'right'
+    base_tokenizer = from_pretrained(AutoTokenizer, model_fullname, optional_tok_kwargs, cache_dir=cache_dir)
+    if base_tokenizer.pad_token_id is None:
+        base_tokenizer.pad_token_id = base_tokenizer.eos_token_id
+        if '13b' in model_fullname:
+            base_tokenizer.pad_token_id = 0
+    return base_tokenizer
+
+def get_sampling_discrepancy_analytic(logits_ref, logits_score, labels):
+    if logits_ref.size(-1) != logits_score.size(-1):
+        vocab_size = min(logits_ref.size(-1), logits_score.size(-1))
+        logits_ref = logits_ref[:, :, :vocab_size]
+        logits_score = logits_score[:, :, :vocab_size]
+
+    labels = labels.unsqueeze(-1) if labels.ndim == logits_score.ndim - 1 else labels
+    lprobs_score = torch.log_softmax(logits_score, dim=-1)
+    probs_ref = torch.softmax(logits_ref, dim=-1)
+    
+    log_likelihood = lprobs_score.gather(dim=-1, index=labels).squeeze(-1)
+    mean_ref = (probs_ref * lprobs_score).sum(dim=-1)
+    var_ref = (probs_ref * torch.square(lprobs_score)).sum(dim=-1) - torch.square(mean_ref)
+    discrepancy = (log_likelihood.sum(dim=-1) - mean_ref.sum(dim=-1)) / var_ref.sum(dim=-1).clamp_min(0.0001).sqrt()
+    
+    return discrepancy, log_likelihood.sum(dim=-1)
+
+class ComputeStat(nn.Module):
+    def __init__(self, model_name, dataset='xsum', device='cuda', cache_dir='./models'):
+        super().__init__()
+        self.device = device
+        self.reference_model_name = get_model_fullname(model_name)
+        self.scoring_model_name = get_model_fullname(model_name)
+        
+        def load_model(model_name, device, cache_dir):
+            model_fullname = get_model_fullname(model_name)
+            print(f'Loading model {model_fullname}...')
+            model_kwargs = {}
+            if model_name in float16_models:
+                model_kwargs.update(dict(torch_dtype=torch.float16))
+            if torch.__version__ >= '2.0.0' and 'gemma' in model_name:
+                model_kwargs.update({'attn_implementation': 'sdpa'})
+            model = from_pretrained(AutoModelForCausalLM, model_fullname, model_kwargs, cache_dir)
+            print(f'Moving model to {device}...', end='', flush=True)
+            start = time.time()
+            model.to(device)
+            print(f'DONE ({time.time() - start:.2f}s)')
+            return model
+        
+        # load scoring model
+        self.scoring_tokenizer = load_tokenizer(model_name, dataset, cache_dir)
+        scoring_model = load_model(model_name, device, cache_dir)
+        if model_name in ['gemma-1b']:
+            self.peft_config = LoraConfig(
+                task_type=TaskType.CAUSAL_LM,
+                inference_mode=False,
+                r=4,
+                lora_alpha=16,
+                lora_dropout=0.05,
+                target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+            )
+        else:
+            self.peft_config = LoraConfig(
+                task_type=TaskType.CAUSAL_LM, 
+                inference_mode=False, 
+                r=8, 
+                lora_alpha=32, 
+                lora_dropout=0.1, 
+            )
+        self.scoring_model = get_peft_model(scoring_model, self.peft_config)
+        
+        # load sampling model
+        self.reference_tokenizer = load_tokenizer(model_name, dataset, cache_dir)
+        reference_model = load_model(model_name, device, cache_dir)
+        self.reference_model = reference_model
+        self.reference_model.eval()
+        for p in self.reference_model.parameters():
+            p.requires_grad = False
+
+        total = sum(p.numel() for p in self.scoring_model.parameters())
+        trainable = sum(p.numel() for p in self.scoring_model.parameters() if p.requires_grad)
+        print(f"Trainable / total (parameters): {trainable}/{total}={trainable/total}")
+    
+    def set_criterion_fn(self, criterion_fn):
+        if criterion_fn == "mean":
+            self.criterion = 'mean'
+            self.criterion_fn = get_sampling_discrepancy_analytic
+        else:
+            raise ValueError(f"Unknown criterion function: {criterion_fn}")
+        
+    def print_gradient_requirement(self):
+        for name, param in self.named_parameters():
+            gradient_requirement = 'Requires Grad' if param.requires_grad else 'Does not require grad'
+            color_code = '\033[92m' if param.requires_grad else '\033[91m'  # Green for requires grad, red for does not require grad
+            reset_color = '\033[0m'  # Reset color after printing
+            print(f"{name}: {color_code}{gradient_requirement}{reset_color}")
+
+    def register_no_grad(self, module_names):
+        for name, param in self.named_parameters():
+            for selected_module in module_names:
+                # print(selected_module, name)
+                if selected_module in name:
+                    param.requires_grad = False
+
+    def save_pretrained(self, save_directory: str, save_null_distr_only=False):
+        """
+        Save the scoring model (with LoRA adapter) and all null_distr buffers in Hugging Face format.
+        """
+        os.makedirs(save_directory, exist_ok=True)
+
+        # 1. 保存 scoring_model (LoRA adapter + 基础模型)
+        if not save_null_distr_only:
+            scoring_dir = os.path.join(save_directory, "scoring_model")
+            self.scoring_model.save_pretrained(scoring_dir, safe_serialization=True)
+
+        # 2. 保存所有 null_distr_* buffers
+        null_distrs = {}
+        for buffer_name, buffer_value in self.named_buffers():
+            if buffer_name.startswith("null_distr_"):
+                domain = buffer_name.replace("null_distr_", "")
+                null_distrs[domain] = buffer_value.detach().cpu()
+        
+        if null_distrs:
+            torch.save(null_distrs, os.path.join(save_directory, "null_distrs.pt"))
+            print(f"✅ Saved {len(null_distrs)} null distributions: {list(null_distrs.keys())}")
+        
+        # 3. 保存配置信息（包括domain列表）
+        config = {
+            "domains": list(null_distrs.keys()),
+            "criterion": getattr(self, "criterion", None),
+        }
+        with open(os.path.join(save_directory, "config.json"), "w") as f:
+            json.dump(config, f)
+
+        print(f"✅ Model saved to {save_directory}")
+
+    @classmethod
+    def from_pretrained(cls, load_directory: str, *args, **kwargs):
+        """
+        Load the scoring model, reference model, and all null_distr buffers.
+        """
+        # 1. 初始化类
+        model = cls(*args, **kwargs)
+
+        # 2. 加载 scoring_model
+        scoring_dir = os.path.join(load_directory, "scoring_model")
+        model.scoring_model = AutoPeftModelForCausalLM.from_pretrained(
+            scoring_dir, 
+            device_map="auto", 
+            low_cpu_mem_usage=True, 
+            use_safetensors=True
+        )
+
+        # 3. 加载所有 null_distr
+        null_distrs_path = os.path.join(load_directory, "null_distrs.pt")
+        if os.path.exists(null_distrs_path):
+            null_distrs = torch.load(null_distrs_path, map_location="cpu")
+            for domain, null_distr in null_distrs.items():
+                model.set_null_distr(null_distr, domain)
+            print(f"✅ Restored {len(null_distrs)} null distributions: {list(null_distrs.keys())}")
+        
+        # 4. 加载配置信息
+        config_path = os.path.join(load_directory, "config.json")
+        if os.path.exists(config_path):
+            with open(config_path, "r") as f:
+                config = json.load(f)
+            if "criterion" in config and config["criterion"] is not None:
+                model.criterion = config["criterion"]
+            print(f"✅ Loaded config: {config}")
+
+        print(f"✅ Model loaded from {load_directory}")
+        return model
+    
+    def compute_stats(self, tokenized=None, labels=[""], training_module=False):
+        if training_module:
+            logits_score = self.scoring_model(tokenized.input_ids, attention_mask=tokenized.attention_mask).logits[:,:-1,:]
+            logits_ref = self.reference_model(tokenized.input_ids, attention_mask=tokenized.attention_mask).logits[:,:-1,:]
+            crit, SPO_input  = self.criterion_fn(logits_ref, logits_score, labels)
+        else:
+            with torch.no_grad(): # get reference
+                logits_score = self.scoring_model(tokenized.input_ids, attention_mask=tokenized.attention_mask).logits[:,:-1,:] # shape: [bsz, sentence_len, dim]
+                logits_ref = self.reference_model(tokenized.input_ids, attention_mask=tokenized.attention_mask).logits[:,:-1,:]
+                crit, SPO_input = self.criterion_fn(logits_ref, logits_score, labels)
+        return crit, SPO_input, logits_score
+
+    def forward(self, text, training_module=True):
+        original_text = text[0]
+        sampled_text = text[1]
+        
+        tokenized = self.scoring_tokenizer(original_text, return_tensors="pt", padding=True, return_token_type_ids=False).to(self.device)
+        labels = tokenized.input_ids[:, 1:] 
+        train_original_crit, _, _ = self.compute_stats(tokenized, labels, training_module=training_module)
+        
+        tokenized = self.scoring_tokenizer(sampled_text, return_tensors="pt", padding=True, return_token_type_ids=False).to(self.device)
+        labels = tokenized.input_ids[:, 1:]
+        train_sampled_crit, _, _ = self.compute_stats(tokenized, labels, training_module=training_module)
+        
+        MMDloss = calculate_MMD_loss(train_original_crit, train_sampled_crit)
+        output = dict(crit=[train_original_crit.detach(), train_original_crit, train_sampled_crit.detach(), train_sampled_crit], loss=MMDloss)
+        return output
+
+    def set_null_distr(self, null_distr: torch.Tensor, domain: str):
+        """
+        Set the null distribution tensor safely.
+        """
+        distr_name = f"null_distr_{domain}"
+        self.register_buffer(distr_name, torch.empty(0))
+
+        if not isinstance(null_distr, torch.Tensor):
+            null_distr = torch.tensor(null_distr)
+
+        # detach + clone + 移到正确设备
+        null_distr = null_distr.detach().clone().to(self.device)
+
+        # 直接覆盖 buffer，避免 delattr 带来的问题
+        self._buffers[distr_name] = null_distr
+        print(f"✅ Null distribution on {domain} with shape: {self._buffers[distr_name].shape} with mean {self._buffers[distr_name].mean():.4f} and std {self._buffers[distr_name].std():.4f}")
+
+    def compute_p_value(self, text, domain: str):
+        """
+        Compute p-value for given text using the null distribution of specified domain.
+        
+        Args:
+            text: Input text to compute score for
+            domain: Domain name to use for null distribution
+        """
+        tokenized = self.scoring_tokenizer(
+            text, 
+            return_tensors="pt", 
+            padding=True, 
+            return_token_type_ids=False
+        ).to(self.device)
+        labels = tokenized.input_ids[:, 1:] 
+        
+        with torch.inference_mode():
+            crit, _, _ = self.compute_stats(tokenized, labels, training_module=False)
+        
+        # 获取对应domain的null distribution
+        distr_name = f"null_distr_{domain}"
+        if not hasattr(self, distr_name):
+            raise ValueError(
+                f"No null distribution found for domain '{domain}'. "
+                f"Available domains: {self.get_available_domains()}"
+            )
+        null_distr = getattr(self, distr_name)
+        p_value = self.empirical_p_value(crit, null_distr)
+
+        return crit, p_value
+
+    def empirical_p_value(self, crit: torch.Tensor, null_distr: torch.Tensor):
+        # Compute p-value: (count + 1) / (total + 1)
+        total = null_distr.numel()
+        # count = (null_distr >= crit.unsqueeze(-1)).float().sum()   # slow computation
+        count = total - torch.searchsorted(null_distr, crit, right=False)[0]
+        p_value = (count + 1.0) / (total + 1.0)
+        # print(f"p_value (slow): {p_value} & p_value (fast): {(count + 1) / (total + 1)}", )
+        return p_value
+
+    def get_available_domains(self):
+        """
+        Get list of all available domains with null distributions.
+        """
+        domains = []
+        for buffer_name in self._buffers.keys():
+            if buffer_name.startswith("null_distr_"):
+                domain = buffer_name.replace("null_distr_", "")
+                domains.append(domain)
+        return domains

src/app.py

@@ -1,545 +1,478 @@
+"""
+DetectGPTPro — Gradio front end for AdaDetectGPT.
+
+Migrated from Streamlit so the Space can run on Hugging Face's ZeroGPU
+(dynamic, pay-per-call GPU allocation, which is only available to Gradio SDK
+Spaces). All detection logic still lives in FineTune/model.py, feedback.py,
+and stats.py, unchanged — this file only rebuilds the UI layer.
+
+See streamlit_backup/ (repo root) for the original Streamlit app.
+"""
+
 import os
+import time
 from pathlib import Path
 
-# -----------------
-# Get the directory where app.py is located
-# -----------------
 APP_DIR = Path(__file__).parent.resolve()
-
-account_name = 'mamba413'
-
-# -----------------
-# Fix Streamlit Permission Issues
-# -----------------
-# 在 HF Space 中，将 Streamlit 配置目录设置到可写位置
-if os.environ.get('SPACE_ID'):
-    os.environ['STREAMLIT_SERVER_FILE_WATCHER_TYPE'] = 'none'
-    os.environ['STREAMLIT_BROWSER_GATHER_USAGE_STATS'] = 'false'
-    os.environ['STREAMLIT_SERVER_ENABLE_CORS'] = 'false'
-    
-    # 设置 HuggingFace 缓存到可写目录
-    CACHE_DIR = '/tmp/huggingface_cache'
+ACCOUNT_NAME = "mamba413"
+
+# -----------------------------------------------------------------------
+# HF Space environment setup — point HF caches at a writable directory.
+# (Carried over as-is from the Streamlit app.)
+# -----------------------------------------------------------------------
+if os.environ.get("SPACE_ID"):
+    CACHE_DIR = "/tmp/huggingface_cache"
     os.makedirs(CACHE_DIR, exist_ok=True)
+    os.environ["HF_HOME"] = CACHE_DIR
+    os.environ["TRANSFORMERS_CACHE"] = CACHE_DIR
+    os.environ["HF_DATASETS_CACHE"] = CACHE_DIR
+    os.environ["HUGGINGFACE_HUB_CACHE"] = CACHE_DIR
 
-    os.environ['HF_HOME'] = CACHE_DIR
-    os.environ['TRANSFORMERS_CACHE'] = CACHE_DIR
-    os.environ['HF_DATASETS_CACHE'] = CACHE_DIR
-    os.environ['HUGGINGFACE_HUB_CACHE'] = CACHE_DIR
-    
-    # 设置可写的配置目录
-    streamlit_dir = Path('/tmp/.streamlit')
-    streamlit_dir.mkdir(exist_ok=True, parents=True)
-    # os.environ['STREAMLIT_HOME'] = '/tmp/.streamlit'
-
+import gradio as gr
 
-import streamlit as st
 from FineTune.model import ComputeStat
-import time
+from feedback import FeedbackManager
+from stats import StatsManager
 
-st.markdown(
-    """
-    <style>
-    /* Text area & text input */
-    textarea, input[type="text"] {
-        background-color: #f8fafc !important;
-        border: 1px solid #e5e7eb !important;
-        color: #111827 !important;
-    }
+# -----------------------------------------------------------------------
+# ZeroGPU support
+# -----------------------------------------------------------------------
+# `spaces` is preinstalled on every Gradio-SDK HF Space and is what lets a
+# Space request/release a GPU per call. It's a no-op outside ZeroGPU
+# hardware, but it isn't installed at all when running locally without the
+# `spaces` package — so fall back to a plain no-op decorator in that case.
+try:
+    import spaces
 
-    textarea::placeholder {
-        color: #9ca3af !important;
-    }
+    ZERO_GPU_AVAILABLE = True
+except ImportError:
+    ZERO_GPU_AVAILABLE = False
 
-    /* Selectbox */
-    div[data-testid="stSelectbox"] > div {
-        background-color: #f8fafc !important;
-        border: 1px solid #e5e7eb !important;
-    }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
+    class _SpacesShim:
+        """Stand-in for the `spaces` module when developing outside HF Spaces."""
 
-st.markdown(
-    """
-    <style>
-    /* Detect button */
-    div.stButton > button[kind="primary"] {
-        background-color: #fdae6b;
-        border: white;
-        color: black;
-        font-weight: 600;
-        height: 4.3rem;
-
-        font-size: 1.1rem;
-
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        gap: 0.55rem;
-    }
+        @staticmethod
+        def GPU(func=None, **_kwargs):
+            if func is not None:
+                return func
+            return lambda f: f
 
-    /* Icon inside Detect button */
-    div.stButton > button[kind="primary"] span {
-        font-size: 1.25rem;
-        line-height: 1;
-    }
+    spaces = _SpacesShim()
 
-    div.stButton > button[kind="primary"]:hover {
-        background-color: #fd8d3c;
-        border-color: white;
-    }
 
-    div.stButton > button[kind="primary"]:active {
-        background-color: #fd8d3c;
-        border-color: white;
-    }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
+def resolve_device() -> str:
+    """Pick an inference device, in priority order:
 
-# -----------------
-# Page Configuration
-# -----------------
-st.set_page_config(
-    page_title="DetectGPTPro",
-    page_icon="🕵️",
-)
-
-# -----------------
-# Model Loading (Cached)
-# -----------------
-@st.cache_resource
-def load_model(from_pretrained, base_model, cache_dir, device):
-    """
-    Load and cache the model to avoid reloading on every user interaction.
-    This function runs only once when the app starts or when parameters change.
+    1. `MODEL_DEVICE` env var, if the user wants to force one.
+    2. 'cuda' on a ZeroGPU Space (the `spaces` package manages the virtual device).
+    3. 'cpu' on any other HF Space (e.g. a plain CPU-tier deployment).
+    4. 'mps' / 'cpu' for local development on Apple Silicon / everything else.
     """
-    # is_hf_space = os.environ.get('SPACE_ID') is not None
-    is_hf_space = False
-    if is_hf_space:
-        cache_dir = '/tmp/huggingface_cache'
-        os.makedirs(cache_dir, exist_ok=True)
-
-        device = 'cpu'
-        print("Using **CPU** now!")
-
-        # 获取 HF Token（用于访问 gated 模型）
-        hf_token = os.environ.get('HF_TOKEN', None)
-        if hf_token:
-            # 也可以用 login 方式
-            try:
-                from huggingface_hub import login
-                login(token=hf_token)
-                print("✅ Successfully authenticated with HF token")
-            except Exception as e:
-                print(f"⚠️ HF login warning: {e}")
-        
-        # 🔥 新增：从 HF Hub 下载模型
-        # 检查是否是 HF Hub 路径（格式：username/repo-name）
-        is_hf_hub = '/' in from_pretrained and not from_pretrained.startswith('.')
-        if is_hf_hub:
-            from huggingface_hub import snapshot_download
-            print(f"📥 Downloading model from HuggingFace Hub: {from_pretrained}")
-            try:
-                # 下载整个仓库到本地
-                local_model_path = snapshot_download(
-                    repo_id=from_pretrained,
-                    cache_dir=cache_dir,
-                    token=hf_token,
-                    repo_type="model"
-                )
-                print(f"✅ Model downloaded to: {local_model_path}")
-                # 使用下载后的本地路径
-                from_pretrained = local_model_path
-            except Exception as e:
-                print(f"❌ Failed to download model: {e}")
-                raise
-    else:
-        cache_dir = cache_dir
-    
-    with st.spinner("🔄 Loading model... This may take a moment on first launch."):
-        model = ComputeStat.from_pretrained(
-            from_pretrained, 
-            base_model, 
-            device=device,
-            cache_dir=cache_dir
-        )
-        model.set_criterion_fn('mean')
+    explicit = os.environ.get("MODEL_DEVICE")
+    if explicit:
+        return explicit
+    if ZERO_GPU_AVAILABLE and os.environ.get("SPACE_ID"):
+        return "cuda"
+    if os.environ.get("SPACE_ID"):
+        return "cpu"
+    try:
+        import torch
+
+        if torch.backends.mps.is_available():
+            return "mps"
+    except Exception:
+        pass
+    return "cpu"
+
+
+# -----------------------------------------------------------------------
+# Configuration
+# -----------------------------------------------------------------------
+MODEL_CONFIG = {
+    "from_pretrained": "./src/FineTune/ckpt/",
+    "base_model": "gemma-1b",
+    "cache_dir": "../cache",
+    "device": resolve_device(),
+}
+
+DOMAINS = [
+    "General",
+    "Academia",
+    "Finance",
+    "Government",
+    "Knowledge",
+    "Legislation",
+    "Medicine",
+    "News",
+    "UserReview",
+]
+
+FEEDBACK_DATASET_ID = os.environ.get("FEEDBACK_DATASET_ID", f"{ACCOUNT_NAME}/user-feedback")
+
+
+# -----------------------------------------------------------------------
+# Model / manager loading (module-level singletons — loaded once at
+# process startup, same lifetime as st.cache_resource gave us before).
+# -----------------------------------------------------------------------
+def load_model():
+    print(f"🔄 Loading model on device='{MODEL_CONFIG['device']}' "
+          f"(ZeroGPU {'enabled' if ZERO_GPU_AVAILABLE else 'unavailable'})...")
+    model = ComputeStat.from_pretrained(
+        MODEL_CONFIG["from_pretrained"],
+        MODEL_CONFIG["base_model"],
+        device=MODEL_CONFIG["device"],
+        cache_dir=MODEL_CONFIG["cache_dir"],
+    )
+    model.set_criterion_fn("mean")
     return model
 
-# -----------------
-# Result Feedback Module Import
-# -----------------
-from feedback import FeedbackManager
-from stats import StatsManager
 
-# Initialize Feedback Manager with HF dataset
-# make sure HF_TOKEN is set to visit private repository
-FEEDBACK_DATASET_ID = os.environ.get('FEEDBACK_DATASET_ID', f'{account_name}/user-feedback')
+try:
+    model = load_model()
+    model_load_error = None
+except Exception as e:  # noqa: BLE001 — surfaced in the UI below
+    model = None
+    model_load_error = str(e)
+
 feedback_manager = FeedbackManager(
     dataset_repo_id=FEEDBACK_DATASET_ID,
-    hf_token=os.environ.get('HF_TOKEN'),
-    local_backup=False if os.environ.get('SPACE_ID') else True # 保留本地备份
+    hf_token=os.environ.get("HF_TOKEN"),
+    local_backup=not os.environ.get("SPACE_ID"),  # keep local backups off-Space
+)
+
+stats_manager = StatsManager(
+    dataset_repo_id=FEEDBACK_DATASET_ID,
+    hf_token=os.environ.get("HF_TOKEN"),
+    local_backup=not os.environ.get("SPACE_ID"),
 )
 
-@st.cache_resource
-def get_stats_manager():
-    return StatsManager(
-        dataset_repo_id=FEEDBACK_DATASET_ID,
-        hf_token=os.environ.get('HF_TOKEN'),
-        local_backup=False if os.environ.get('SPACE_ID') else True,
+
+# -----------------------------------------------------------------------
+# Inference — isolated in its own function and GPU-decorated so ZeroGPU
+# can allocate a GPU just for the duration of this call and release it
+# right after.
+#
+# `duration` reserves that many seconds of ZeroGPU quota *up front* for
+# every call, regardless of how long the call actually takes — so it
+# should track real measured inference time, not just be left generous.
+# Override with the ZERO_GPU_DURATION env var once you've profiled a
+# typical request (Settings on the Space, or locally via `time.time()`
+# around `_run_inference`).
+# -----------------------------------------------------------------------
+ZERO_GPU_DURATION = int(os.environ.get("ZERO_GPU_DURATION", "60"))
+
+
+@spaces.GPU(duration=ZERO_GPU_DURATION)
+def _run_inference(text: str, domain: str):
+    crit, p_value = model.compute_p_value(text, domain)
+    if hasattr(crit, "item"):
+        crit = crit.item()
+    if hasattr(p_value, "item"):
+        p_value = p_value.item()
+    return crit, p_value
+
+
+def _is_zero_gpu_quota_error(exc: Exception) -> bool:
+    message = str(exc).lower()
+    return "quota" in message and "gpu" in message
+
+
+def format_conclusion(p_value: float, alpha: float) -> str:
+    """Build the conclusion as a framed HTML card (rendered inside gr.Markdown,
+    which passes raw HTML through) so the verdict stands out instead of
+    blending into a single paragraph."""
+    is_flagged = p_value < alpha
+    verdict = "Text is likely LLM-generated." if is_flagged else \
+        "Fail to reject hypothesis that text is human-written."
+    comparison = "less" if is_flagged else "greater"
+    tone = "conclusion-card--flag" if is_flagged else "conclusion-card--clear"
+    icon = "🚨" if is_flagged else "✅"
+    return (
+        f'<div class="conclusion-card {tone}">'
+        f'<div class="conclusion-verdict">{icon} {verdict}</div>'
+        f'<div class="conclusion-detail">based on the observation that '
+        f'$p$-value {p_value:.3f} is {comparison} than significance level '
+        f'{alpha:.2f} 📊</div>'
+        f'</div>'
     )
 
-stats_manager = get_stats_manager()
 
-# -----------------
-# Configuration
-# -----------------
-MODEL_CONFIG = {
-    'from_pretrained': './src/FineTune/ckpt/',
-    'base_model': 'gemma-1b',
-    'cache_dir': '../cache', 
-    'device': 'cpu' if os.environ.get('SPACE_ID') else 'mps',
-    # 'device': 'cuda',
+INTERPRETATION_TEXT = """
+- **Interpretation**
+    - $p$-value: Lower $p$-value (closer to 0) indicates text is **more likely AI-generated**; Higher $p$-value (closer to 1) indicates text is **more likely human-written**.
+    - Significance Level (α): a threshold set by the user to determine the sensitivity of the detection. Lower α means stricter criteria for claiming the text is AI-generated.
+- **Suggestions for better detection**
+    - Provide longer text inputs for more reliable detection results.
+    - Select the domain that best matches the content of your text to improve detection accuracy.
+"""
+
+FOOTER_TEXT = (
+    "This tool is developed for research purposes only. The detection results are not "
+    "100% accurate and should not be used as the sole basis for any critical decisions. "
+    "Users are advised to use this tool responsibly and ethically."
+)
+
+REFERENCES_INTRO = "If you find this tool useful, please cite:"
+
+REFERENCES_BIBTEX = """@article{zhou2026detecting,
+  title={Detecting LLM-Generated Text with Performance Guarantees},
+  author={Zhou, Hongyi and Zhu, Jin and Yang, Ying and Shi, Chengchun},
+  journal={arXiv preprint arXiv:2601.06586},
+  year={2026}
 }
 
-DOMAINS = [
-    "General",
-    "Academia", 
-    "Finance", 
-    "Government", 
-    "Knowledge", 
-    "Legislation", 
-    "Medicine", 
-    "News", 
-    "UserReview"
-]
+@inproceedings{zhou2025adadetect,
+  title={AdaDetectGPT: Adaptive Detection of LLM-Generated Text with Statistical Guarantees},
+  author={Hongyi Zhou and Jin Zhu and Pingfan Su and Kai Ye and Ying Yang and Shakeel A O B Gavioli-Akilagun and Chengchun Shi},
+  booktitle={The Thirty-Ninth Annual Conference on Neural Information Processing Systems},
+  year={2025}
+}"""
+
+
+# -----------------------------------------------------------------------
+# Event handlers
+# -----------------------------------------------------------------------
+def run_detection(text: str, domain: str, alpha: float):
+    """Detect button handler: runs inference and refreshes all result widgets."""
+    if not text or not text.strip():
+        raise gr.Error("⚠️ Please enter some text before detecting.")
+
+    start_time = time.time()
+    try:
+        crit, p_value = _run_inference(text, domain)
+    except gr.Error:
+        raise
+    except Exception as e:  # noqa: BLE001 — surfaced to the user via gr.Error
+        if _is_zero_gpu_quota_error(e):
+            raise gr.Error(
+                "⏳ This Space's free GPU quota is used up for now — it resets "
+                "on a rolling basis, so please try again shortly."
+            )
+        raise gr.Error(f"Detection failed: {e}")
+    elapsed_time = time.time() - start_time
+
+    stats_manager.increment_detection()
+
+    detection_state = {
+        "text": text,
+        "domain": domain,
+        "statistics": crit,
+        "p_value": p_value,
+        "elapsed_time": elapsed_time,
+        "feedback_given": False,
+    }
 
-# Load model once at startup
-try:
-    model = load_model(
-        MODEL_CONFIG['from_pretrained'],
-        MODEL_CONFIG['base_model'],
-        MODEL_CONFIG['cache_dir'], 
-        MODEL_CONFIG['device']
+    return (
+        gr.update(value=format_conclusion(p_value, alpha), visible=True),
+        gr.update(visible=True),  # interpretation accordion
+        gr.update(value=f"⏱️ Processing time: {elapsed_time:.2f} seconds", visible=True),
+        gr.update(visible=True),  # feedback row
+        gr.update(visible=False),  # feedback thanks message
+        detection_state,
     )
-    model_loaded = True
-except Exception as e:
-    model_loaded = False
-    error_message = str(e)
-
-# =========== 🆕 session_state ===========
-if 'last_detection' not in st.session_state:
-    st.session_state.last_detection = None
-if 'feedback_given' not in st.session_state:
-    st.session_state.feedback_given = False
-if 'pending_toast' not in st.session_state:
-    st.session_state.pending_toast = None
-# ========================================
-
-# Show any pending toast (set by feedback buttons before st.rerun())
-if st.session_state.pending_toast:
-    _msg, _icon = st.session_state.pending_toast
-    st.toast(_msg, icon=_icon)
-    st.session_state.pending_toast = None
-
-# ----- Visit Counter -----
-# session_state resets on F5 / new tab, so this runs exactly once per browser session
-if 'visit_counted' not in st.session_state:
-    st.session_state.visit_counted = True
+
+
+def submit_feedback(feedback_type: str, detection_state: dict | None):
+    """Shared handler for the Expected / Unexpected feedback buttons."""
+    if not detection_state or detection_state.get("feedback_given"):
+        return gr.update(), gr.update(), detection_state
+
+    try:
+        success, message = feedback_manager.save_feedback(
+            detection_state["text"],
+            detection_state["domain"],
+            detection_state["statistics"],
+            detection_state["p_value"],
+            feedback_type,
+        )
+    except Exception as e:  # noqa: BLE001
+        raise gr.Error(f"Failed to save feedback: {e}")
+
+    if not success:
+        raise gr.Error(f"Failed to save feedback: {message}")
+
+    detection_state["feedback_given"] = True
+    thanks = "✅ Thank you for your feedback!" if feedback_type == "expected" \
+        else "📝 Feedback recorded! This will help us improve."
+    gr.Info(thanks)
+
+    return gr.update(visible=False), gr.update(value=thanks, visible=True), detection_state
+
+
+def on_load():
     stats_manager.increment_visit()
-# -------------------------
-
-# -----------------
-# Streamlit Layout
-# -----------------
-st.markdown(
-    "<h1 style='text-align: center;'> Detect AI-Generated Texts 🕵️ </h1>",
-    unsafe_allow_html=True,
-)
+    return f"{stats_manager.visit_count:,} visits"
 
-# st.markdown(
-#     """Pasted the text to be detected below and click the 'Detect' button to get the p-value. Use a better option may improve detection."""
-# )
-
-# Display model loading status
-if not model_loaded:
-    st.error(f"❌ Failed to load model: {error_message}")
-    st.stop()
-
-# -----------------
-# Main Interface
-# -----------------
-# --- Two columns: Input text & button | Result displays ---
-text_input = st.text_area(
-    label="📝 Input Text to be Detected",
-    placeholder="Paste your text here",
-    height=240,
-    label_visibility="hidden",
-)
 
-subcol11, subcol12, subcol13 = st.columns((1, 1, 1))
+# -----------------------------------------------------------------------
+# Styling — ported from the Streamlit app's injected CSS.
+# -----------------------------------------------------------------------
+CUSTOM_CSS = """
+#input-text textarea {
+    background-color: #f8fafc !important;
+    border: 1px solid #e5e7eb !important;
+    color: #111827 !important;
+}
+#detect-btn {
+    background-color: #fdae6b !important;
+    border-color: white !important;
+    color: black !important;
+    font-weight: 600 !important;
+    height: 4.3rem !important;
+    font-size: 1.1rem !important;
+}
+#detect-btn:hover {
+    background-color: #fd8d3c !important;
+}
+.conclusion-card {
+    background-color: #f8fafc;
+    border: 1px solid #e5e7eb;
+    border-left: 4px solid #94a3b8;
+    border-radius: 10px;
+    padding: 1rem 1.25rem;
+    margin-top: 0.5rem;
+}
+.conclusion-card.conclusion-card--flag {
+    border-left-color: #ef4444;
+    background-color: #fef2f2;
+}
+.conclusion-card.conclusion-card--clear {
+    border-left-color: #22c55e;
+    background-color: #f0fdf4;
+}
+.conclusion-verdict {
+    font-size: 1.05rem;
+    font-weight: 600;
+    color: #111827;
+    margin-bottom: 0.4rem;
+}
+.conclusion-detail {
+    color: #475569;
+    font-size: 0.9rem;
+}
+#stats-chip {
+    position: fixed;
+    top: 3.6rem;
+    right: 1rem;
+    font-size: 0.78rem;
+    color: #9ca3af;
+    z-index: 999;
+    text-align: right;
+}
+#app-footer {
+    position: fixed;
+    left: 0;
+    bottom: 0;
+    width: 100%;
+    background-color: white;
+    color: gray;
+    text-align: center;
+    padding: 4px 0;
+    border-top: 1px solid #e0e0e0;
+    z-index: 999;
+    font-size: 0.8rem;
+}
+/* Hide Gradio's own bottom bar ("Use via API · Built with Gradio · Settings")
+   so it doesn't overlap with our fixed disclaimer footer above. */
+footer, .footer {
+    display: none !important;
+}
+/* Leave room at the bottom of the page so content isn't hidden behind
+   the fixed footer. */
+.gradio-container {
+    padding-bottom: 2.5rem !important;
+}
+#references-box, #references-box * {
+    font-size: 0.78rem !important;
+}
+"""
 
-selected_domain = subcol11.selectbox(
-    label="💡 Domain that matches your text",
-    options=DOMAINS,
-    index=0,  # Default to General
-    # label_visibility="collapsed",
-    # label_visibility="hidden",
-)
+LATEX_DELIMITERS = [{"left": "$", "right": "$", "display": False}]
 
-detect_clicked = subcol12.button("🔍 Detect", type="primary", use_container_width=True)
 
-selected_level = subcol13.slider(
-    label="Significance level (α)",
-    min_value=0.01,
-    max_value=0.2,
-    value=0.05,
-    step=0.005,
-    # label_visibility="collapsed",
-)
+def build_interface() -> gr.Blocks:
+    if model is None:
+        with gr.Blocks(title="DetectGPTPro") as error_demo:
+            gr.Markdown(f"### ❌ Failed to load model\n\n```\n{model_load_error}\n```")
+        return error_demo
 
-# -----------------
-# Detection Logic
-# -----------------
-if detect_clicked:
-    if not text_input.strip():
-        st.warning("⚠️ Please enter some text before detecting.")
-    else:
-        # ========== Reset feedback state ==========
-        st.session_state.feedback_given = False
-        # ==========================================
-
-        # Start timing to decide whether to show progress bar
-        start_time = time.time()
-        
-        # Use a placeholder for dynamic updates
-        status_placeholder = st.empty()
-        result_placeholder = st.empty()
-        
-        try:
-            # Show spinner for quick operations (< 2 seconds expected)
-            with status_placeholder:
-                with st.spinner(f"🔍 Analyzing text in {selected_domain} domain..."):
-                    # Perform inference
-                    crit, p_value = model.compute_p_value(text_input, selected_domain)
-                    elapsed_time = time.time() - start_time
-            
-                    # Convert tensors to Python scalars if needed
-                    if hasattr(crit, 'item'):
-                        crit = crit.item()
-                    if hasattr(p_value, 'item'):
-                        p_value = p_value.item()
-
-            # Clear status and show results
-            status_placeholder.empty()
-
-            # ========== 🆕 保存检测结果到 session_state ==========
-            st.session_state.last_detection = {
-                'text': text_input,
-                'domain': selected_domain,
-                'statistics': crit,
-                'p_value': p_value,
-                'elapsed_time': elapsed_time
-            }
-
-            # Count detection once per unique detect action
-            _det_key = f'det_counted_{hash(text_input[:80])}'
-            if _det_key not in st.session_state:
-                st.session_state[_det_key] = True
-                stats_manager.increment_detection()
-
-            st.info(
-                f"""
-                **Conclusion**: 
-
-                    {'Text is likely LLM-generated.' if p_value < selected_level else 'Fail to reject hypothesis that text is human-written.'}
-
-                based on the observation that $p$-value {p_value:.3f} is {'less' if p_value < selected_level else 'greater'} than significance level {selected_level:.2f} 📊
-                """,
-                icon="💡"
+    with gr.Blocks(title="DetectGPTPro", css=CUSTOM_CSS) as demo:
+        detection_state = gr.State(None)
+
+        gr.Markdown("<h1 style='text-align: center;'>Detect AI-Generated Texts 🕵️</h1>")
+
+        text_input = gr.Textbox(
+            label="📝 Input Text to be Detected",
+            placeholder="Paste your text here",
+            lines=10,
+            elem_id="input-text",
+            show_label=False,
+        )
+
+        with gr.Row():
+            domain_dropdown = gr.Dropdown(
+                choices=DOMAINS, value="General",
+                label="💡 Domain that matches your text",
             )
-            st.markdown(
-                """
-                <style>
-                /* Tighten spacing inside Clarification / Citation expanders */
-                div[data-testid="stExpander"] {
-                    margin-top: -1.3rem;
-                }
-                div[data-testid="stExpander"] p,
-                div[data-testid="stExpander"] li {
-                    line-height: 1.35;
-                    margin-bottom: 0.1rem;
-                }
-
-                div[data-testid="stExpander"] ul {
-                    margin-top: 0.1rem;
-                }
-                </style>
-                """,
-                unsafe_allow_html=True
+            detect_btn = gr.Button("🔍 Detect", variant="primary", elem_id="detect-btn")
+            alpha_slider = gr.Slider(
+                minimum=0.01, maximum=0.2, value=0.05, step=0.005,
+                label="Significance level (α)",
             )
-            with st.expander("📋 Interpretation and Suggestions"):
-                st.markdown(
-                    """
-                    + Interpretation:
-                        - $p$-value: Lower $p$-value (closer to 0) indicates text is **more likely AI-generated**; Higher $p$-value (closer to 1) indicates text is **more likely human-written**.
-                        - Significance Level (α): a threshold set by the user to determine the sensitivity of the detection. Lower α means stricter criteria for claiming the text is AI-generated.
-
-                    + Suggestions for better detection:
-                        - Provide longer text inputs for more reliable detection results.
-                        - Select the domain that best matches the content of your text to improve detection accuracy.
-                    """
-                )
-
-
-            # Show detailed results
-            with result_placeholder:
-                st.caption(f"⏱️ Processing time: {elapsed_time:.2f} seconds")
-        
-        except Exception as e:
-            status_placeholder.empty()
-            st.error(f"❌ Error during detection: {str(e)}")
-            st.exception(e)
-
-# -----------------
-# Feedback UI (outside if detect_clicked — persists across all reruns via session_state)
-# -----------------
-if st.session_state.last_detection is not None and not st.session_state.feedback_given:
-    _ld = st.session_state.last_detection
-    st.markdown(
-        """
-        <style>
-        .fb-header { display: flex; align-items: center; gap: 0.4rem; margin-bottom: 0.3rem; }
-        .privacy-tip {
-            position: relative; display: inline-block;
-            cursor: help; color: #9ca3af; font-size: 0.9rem;
-        }
-        .privacy-tip .tip-text {
-            visibility: hidden; opacity: 0;
-            width: 240px; background-color: #374151; color: #f9fafb;
-            text-align: left; border-radius: 6px;
-            padding: 0.5rem 0.7rem; font-size: 0.78rem; line-height: 1.4;
-            position: absolute; z-index: 100;
-            bottom: 130%; left: 50%; transform: translateX(-50%);
-            transition: opacity 0.25s ease; pointer-events: none;
-        }
-        .privacy-tip:hover .tip-text { visibility: visible; opacity: 1; }
-        </style>
-        <div class="fb-header">
-          <strong>📝 Result Feedback</strong>: Does this detection result meet your expectations?
-          <span class="privacy-tip">🔒
-            <span class="tip-text">🔒 Your feedback is stored privately and will never be shared with third parties. It is used solely to improve detection accuracy.</span>
-          </span>
-        </div>
-        """,
-        unsafe_allow_html=True
-    )
-    feedback_col1, feedback_col2 = st.columns(2)
-    with feedback_col1:
-        if st.button("✅ Expected", use_container_width=True, type="secondary",
-                     key="expected_btn"):
-            try:
-                fb_success, fb_message = feedback_manager.save_feedback(
-                    _ld['text'], _ld['domain'], _ld['statistics'], _ld['p_value'], 'expected'
-                )
-                if fb_success:
-                    st.session_state.feedback_given = True
-                    st.session_state.pending_toast = ("Thank you for your feedback!", "✅")
-                    st.rerun()
-                else:
-                    st.error(f"Failed to save feedback: {fb_message}")
-            except Exception as e:
-                st.error(f"Failed to save feedback: {str(e)}")
-    with feedback_col2:
-        if st.button("❌ Unexpected", use_container_width=True, type="secondary",
-                     key="unexpected_btn"):
-            try:
-                fb_success, fb_message = feedback_manager.save_feedback(
-                    _ld['text'], _ld['domain'], _ld['statistics'], _ld['p_value'], 'unexpected'
-                )
-                if fb_success:
-                    st.session_state.feedback_given = True
-                    st.session_state.pending_toast = ("Feedback recorded! This will help us improve.", "📝")
-                    st.rerun()
-                else:
-                    st.error(f"Failed to save feedback: {fb_message}")
-            except Exception as e:
-                st.error(f"Failed to save feedback: {str(e)}")
-
-# with st.expander("📋 Citation"):
-#     st.markdown(
-#         """
-#         If you find this tool useful for you, please cite our paper: **[AdaDetectGPT: Adaptive Detection of LLM-Generated Text with Statistical Guarantees](https://arxiv.org/abs/2510.01268)**
-#         """
-#     )
-#     st.code(
-#         """
-# @inproceedings{zhou2024adadetectgpt,
-#   title={AdaDetectGPT: Adaptive Detection of LLM-Generated Text with Statistical Guarantees},
-#   author={Hongyi Zhou and Jin Zhu and Pingfan Su and Kai Ye and Ying Yang and Shakeel A O B Gavioli-Akilagun and Chengchun Shi},
-#   booktitle={The Thirty-Ninth Annual Conference on Neural Information Processing Systems},
-#   year={2025},
-# }
-#         """,
-#         language="bibtex"
-#     )
-
-# -----------------
-# Statistics Chip (fixed top-right)
-# -----------------
-st.markdown(
-    f"""
-    <style>
-    .stats-chip {{
-        position: fixed;
-        top: 3.6rem;
-        right: 1rem;
-        display: flex;
-        align-items: center;
-        gap: 0.35rem;
-        font-size: 0.78rem;
-        color: #9ca3af;
-        z-index: 999;
-        pointer-events: none;
-    }}
-    </style>
-    <div class="stats-chip">
-      <span>{stats_manager.visit_count:,} visits</span>
-    </div>
-    """,
-    unsafe_allow_html=True
-)
 
-# -----------------
-# Footer
-# -----------------
-st.markdown(
-    """
-    <style>
-    .footer {
-        position: fixed;
-        left: 0;
-        bottom: 0;
-        width: 100%;
-        background-color: white;
-        color: gray;
-        text-align: center;
-        padding: 1px;
-        border-top: 1px solid #e0e0e0;
-        z-index: 999;
-    }
-    
-    /* Add padding to main content to prevent overlap with fixed footer */
-    .main .block-container {
-        padding-bottom: 1px;
-    }
-    </style>
-    <div class='footer'>
-        <small> This tool is developed for research purposes only. The detection results are not 100% accurate and should not be used as the sole basis for any critical decisions. Users are advised to use this tool responsibly and ethically. </small>
-    </div>
-    """,
-    unsafe_allow_html=True
-)
+        conclusion_md = gr.Markdown(visible=False, latex_delimiters=LATEX_DELIMITERS)
+
+        with gr.Accordion("📋 Interpretation and Suggestions", open=False, visible=False) as interpretation_box:
+            gr.Markdown(INTERPRETATION_TEXT, latex_delimiters=LATEX_DELIMITERS)
+
+        elapsed_caption = gr.Markdown(visible=False)
+
+        gr.HTML(
+            '<div style="margin-top: 0.6rem;"><strong>📝 Result Feedback</strong>: '
+            'Does this detection result meet your expectations? '
+            '<span title="🔒 Your feedback is stored privately and will never be shared with '
+            'third parties. It is used solely to improve detection accuracy.">🔒</span></div>'
+        )
+        with gr.Row(visible=False) as feedback_row:
+            expected_btn = gr.Button("✅ Expected")
+            unexpected_btn = gr.Button("❌ Unexpected")
+        feedback_thanks = gr.Markdown(visible=False)
+
+        stats_chip = gr.Markdown(elem_id="stats-chip")
+
+        with gr.Accordion("📚 References", open=False, elem_id="references-box"):
+            gr.Markdown(REFERENCES_INTRO)
+            gr.Code(value=REFERENCES_BIBTEX, language=None, interactive=False, show_label=False)
+
+        detect_btn.click(
+            fn=run_detection,
+            inputs=[text_input, domain_dropdown, alpha_slider],
+            outputs=[conclusion_md, interpretation_box, elapsed_caption, feedback_row, feedback_thanks, detection_state],
+        )
+
+        expected_btn.click(
+            fn=lambda state: submit_feedback("expected", state),
+            inputs=[detection_state],
+            outputs=[feedback_row, feedback_thanks, detection_state],
+        )
+        unexpected_btn.click(
+            fn=lambda state: submit_feedback("unexpected", state),
+            inputs=[detection_state],
+            outputs=[feedback_row, feedback_thanks, detection_state],
+        )
+
+        gr.HTML(f'<div id="app-footer"><small>{FOOTER_TEXT}</small></div>')
+
+        # `demo.load` fires once per browser session (page load) — the closest
+        # Gradio equivalent to the Streamlit "count once per session" trick.
+        demo.load(fn=on_load, outputs=[stats_chip])
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = build_interface()
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+    )

streamlit_backup/Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10.8
+
+# CMD python download_private_model.py
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install --upgrade pip
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+# WORKDIR /app/src
+# ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["streamlit", "run", "src/app.py", "--server.port=8501", "--server.address=0.0.0.0"]

streamlit_backup/README.md

@@ -0,0 +1,19 @@
+---
+title: StatDetectLLM — Detecting AI-Generated Text with Statistical Guarantees
+colorFrom: blue
+colorTo: pink
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+pinned: true
+license: apache-2.0
+emoji: 🚀
+short_description: A cheap yet powerful detector for LLM-generated text
+---
+
+## Advantages of StatDetectLLM
+
+- ⚡ **Lightweight and cost-efficient**: Runs entirely on CPU and produces results within seconds, making it suitable for large-scale or resource-constrained deployments.
+- 💪 **High detection performance**: Achieves an AUC above 0.99 when detecting text generated by a wide range of state-of-the-art LLMs, including Grok, GPT, and Gemini.
+- 🔒 **Statistical guarantees**: Provides rigorous hypothesis-testing guarantees by controlling the test size at a user-specified nominal significance level, while maintaining detection power exceeding 90%.

streamlit_backup/README_BACKUP.md

@@ -0,0 +1,26 @@
+# Streamlit version — backup
+
+Snapshot of the CPU-only Streamlit app, taken 2026-08-11 before migrating to Gradio
+(for HF Spaces ZeroGPU support). Files here are exact copies of what shipped at that time:
+
+- `app.py` → was `src/app.py`
+- `requirements.txt` → repo root
+- `Dockerfile` → repo root
+- `README.md` → repo root (Space metadata: `sdk: docker`, port 8501)
+- `keep_alive.py` → was `keep-alive/keep_alive.py`
+
+## Restoring the Streamlit version
+
+```bash
+cp streamlit_backup/app.py src/app.py
+cp streamlit_backup/requirements.txt requirements.txt
+cp streamlit_backup/Dockerfile Dockerfile
+cp streamlit_backup/README.md README.md
+cp streamlit_backup/keep_alive.py keep-alive/keep_alive.py
+```
+
+`src/FineTune/model.py`, `src/feedback.py`, and `src/stats.py` were not touched by the
+Gradio migration and don't need restoring.
+
+Full history is also in git (`git log` on this repo) if you need anything beyond these
+five files.

streamlit_backup/app.py

@@ -0,0 +1,545 @@
+import os
+from pathlib import Path
+
+# -----------------
+# Get the directory where app.py is located
+# -----------------
+APP_DIR = Path(__file__).parent.resolve()
+
+account_name = 'mamba413'
+
+# -----------------
+# Fix Streamlit Permission Issues
+# -----------------
+# 在 HF Space 中，将 Streamlit 配置目录设置到可写位置
+if os.environ.get('SPACE_ID'):
+    os.environ['STREAMLIT_SERVER_FILE_WATCHER_TYPE'] = 'none'
+    os.environ['STREAMLIT_BROWSER_GATHER_USAGE_STATS'] = 'false'
+    os.environ['STREAMLIT_SERVER_ENABLE_CORS'] = 'false'
+    
+    # 设置 HuggingFace 缓存到可写目录
+    CACHE_DIR = '/tmp/huggingface_cache'
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    os.environ['HF_HOME'] = CACHE_DIR
+    os.environ['TRANSFORMERS_CACHE'] = CACHE_DIR
+    os.environ['HF_DATASETS_CACHE'] = CACHE_DIR
+    os.environ['HUGGINGFACE_HUB_CACHE'] = CACHE_DIR
+    
+    # 设置可写的配置目录
+    streamlit_dir = Path('/tmp/.streamlit')
+    streamlit_dir.mkdir(exist_ok=True, parents=True)
+    # os.environ['STREAMLIT_HOME'] = '/tmp/.streamlit'
+
+
+import streamlit as st
+from FineTune.model import ComputeStat
+import time
+
+st.markdown(
+    """
+    <style>
+    /* Text area & text input */
+    textarea, input[type="text"] {
+        background-color: #f8fafc !important;
+        border: 1px solid #e5e7eb !important;
+        color: #111827 !important;
+    }
+
+    textarea::placeholder {
+        color: #9ca3af !important;
+    }
+
+    /* Selectbox */
+    div[data-testid="stSelectbox"] > div {
+        background-color: #f8fafc !important;
+        border: 1px solid #e5e7eb !important;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.markdown(
+    """
+    <style>
+    /* Detect button */
+    div.stButton > button[kind="primary"] {
+        background-color: #fdae6b;
+        border: white;
+        color: black;
+        font-weight: 600;
+        height: 4.3rem;
+
+        font-size: 1.1rem;
+
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 0.55rem;
+    }
+
+    /* Icon inside Detect button */
+    div.stButton > button[kind="primary"] span {
+        font-size: 1.25rem;
+        line-height: 1;
+    }
+
+    div.stButton > button[kind="primary"]:hover {
+        background-color: #fd8d3c;
+        border-color: white;
+    }
+
+    div.stButton > button[kind="primary"]:active {
+        background-color: #fd8d3c;
+        border-color: white;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# -----------------
+# Page Configuration
+# -----------------
+st.set_page_config(
+    page_title="DetectGPTPro",
+    page_icon="🕵️",
+)
+
+# -----------------
+# Model Loading (Cached)
+# -----------------
+@st.cache_resource
+def load_model(from_pretrained, base_model, cache_dir, device):
+    """
+    Load and cache the model to avoid reloading on every user interaction.
+    This function runs only once when the app starts or when parameters change.
+    """
+    # is_hf_space = os.environ.get('SPACE_ID') is not None
+    is_hf_space = False
+    if is_hf_space:
+        cache_dir = '/tmp/huggingface_cache'
+        os.makedirs(cache_dir, exist_ok=True)
+
+        device = 'cpu'
+        print("Using **CPU** now!")
+
+        # 获取 HF Token（用于访问 gated 模型）
+        hf_token = os.environ.get('HF_TOKEN', None)
+        if hf_token:
+            # 也可以用 login 方式
+            try:
+                from huggingface_hub import login
+                login(token=hf_token)
+                print("✅ Successfully authenticated with HF token")
+            except Exception as e:
+                print(f"⚠️ HF login warning: {e}")
+        
+        # 🔥 新增：从 HF Hub 下载模型
+        # 检查是否是 HF Hub 路径（格式：username/repo-name）
+        is_hf_hub = '/' in from_pretrained and not from_pretrained.startswith('.')
+        if is_hf_hub:
+            from huggingface_hub import snapshot_download
+            print(f"📥 Downloading model from HuggingFace Hub: {from_pretrained}")
+            try:
+                # 下载整个仓库到本地
+                local_model_path = snapshot_download(
+                    repo_id=from_pretrained,
+                    cache_dir=cache_dir,
+                    token=hf_token,
+                    repo_type="model"
+                )
+                print(f"✅ Model downloaded to: {local_model_path}")
+                # 使用下载后的本地路径
+                from_pretrained = local_model_path
+            except Exception as e:
+                print(f"❌ Failed to download model: {e}")
+                raise
+    else:
+        cache_dir = cache_dir
+    
+    with st.spinner("🔄 Loading model... This may take a moment on first launch."):
+        model = ComputeStat.from_pretrained(
+            from_pretrained, 
+            base_model, 
+            device=device,
+            cache_dir=cache_dir
+        )
+        model.set_criterion_fn('mean')
+    return model
+
+# -----------------
+# Result Feedback Module Import
+# -----------------
+from feedback import FeedbackManager
+from stats import StatsManager
+
+# Initialize Feedback Manager with HF dataset
+# make sure HF_TOKEN is set to visit private repository
+FEEDBACK_DATASET_ID = os.environ.get('FEEDBACK_DATASET_ID', f'{account_name}/user-feedback')
+feedback_manager = FeedbackManager(
+    dataset_repo_id=FEEDBACK_DATASET_ID,
+    hf_token=os.environ.get('HF_TOKEN'),
+    local_backup=False if os.environ.get('SPACE_ID') else True # 保留本地备份
+)
+
+@st.cache_resource
+def get_stats_manager():
+    return StatsManager(
+        dataset_repo_id=FEEDBACK_DATASET_ID,
+        hf_token=os.environ.get('HF_TOKEN'),
+        local_backup=False if os.environ.get('SPACE_ID') else True,
+    )
+
+stats_manager = get_stats_manager()
+
+# -----------------
+# Configuration
+# -----------------
+MODEL_CONFIG = {
+    'from_pretrained': './src/FineTune/ckpt/',
+    'base_model': 'gemma-1b',
+    'cache_dir': '../cache', 
+    'device': 'cpu' if os.environ.get('SPACE_ID') else 'mps',
+    # 'device': 'cuda',
+}
+
+DOMAINS = [
+    "General",
+    "Academia", 
+    "Finance", 
+    "Government", 
+    "Knowledge", 
+    "Legislation", 
+    "Medicine", 
+    "News", 
+    "UserReview"
+]
+
+# Load model once at startup
+try:
+    model = load_model(
+        MODEL_CONFIG['from_pretrained'],
+        MODEL_CONFIG['base_model'],
+        MODEL_CONFIG['cache_dir'], 
+        MODEL_CONFIG['device']
+    )
+    model_loaded = True
+except Exception as e:
+    model_loaded = False
+    error_message = str(e)
+
+# =========== 🆕 session_state ===========
+if 'last_detection' not in st.session_state:
+    st.session_state.last_detection = None
+if 'feedback_given' not in st.session_state:
+    st.session_state.feedback_given = False
+if 'pending_toast' not in st.session_state:
+    st.session_state.pending_toast = None
+# ========================================
+
+# Show any pending toast (set by feedback buttons before st.rerun())
+if st.session_state.pending_toast:
+    _msg, _icon = st.session_state.pending_toast
+    st.toast(_msg, icon=_icon)
+    st.session_state.pending_toast = None
+
+# ----- Visit Counter -----
+# session_state resets on F5 / new tab, so this runs exactly once per browser session
+if 'visit_counted' not in st.session_state:
+    st.session_state.visit_counted = True
+    stats_manager.increment_visit()
+# -------------------------
+
+# -----------------
+# Streamlit Layout
+# -----------------
+st.markdown(
+    "<h1 style='text-align: center;'> Detect AI-Generated Texts 🕵️ </h1>",
+    unsafe_allow_html=True,
+)
+
+# st.markdown(
+#     """Pasted the text to be detected below and click the 'Detect' button to get the p-value. Use a better option may improve detection."""
+# )
+
+# Display model loading status
+if not model_loaded:
+    st.error(f"❌ Failed to load model: {error_message}")
+    st.stop()
+
+# -----------------
+# Main Interface
+# -----------------
+# --- Two columns: Input text & button | Result displays ---
+text_input = st.text_area(
+    label="📝 Input Text to be Detected",
+    placeholder="Paste your text here",
+    height=240,
+    label_visibility="hidden",
+)
+
+subcol11, subcol12, subcol13 = st.columns((1, 1, 1))
+
+selected_domain = subcol11.selectbox(
+    label="💡 Domain that matches your text",
+    options=DOMAINS,
+    index=0,  # Default to General
+    # label_visibility="collapsed",
+    # label_visibility="hidden",
+)
+
+detect_clicked = subcol12.button("🔍 Detect", type="primary", use_container_width=True)
+
+selected_level = subcol13.slider(
+    label="Significance level (α)",
+    min_value=0.01,
+    max_value=0.2,
+    value=0.05,
+    step=0.005,
+    # label_visibility="collapsed",
+)
+
+# -----------------
+# Detection Logic
+# -----------------
+if detect_clicked:
+    if not text_input.strip():
+        st.warning("⚠️ Please enter some text before detecting.")
+    else:
+        # ========== Reset feedback state ==========
+        st.session_state.feedback_given = False
+        # ==========================================
+
+        # Start timing to decide whether to show progress bar
+        start_time = time.time()
+        
+        # Use a placeholder for dynamic updates
+        status_placeholder = st.empty()
+        result_placeholder = st.empty()
+        
+        try:
+            # Show spinner for quick operations (< 2 seconds expected)
+            with status_placeholder:
+                with st.spinner(f"🔍 Analyzing text in {selected_domain} domain..."):
+                    # Perform inference
+                    crit, p_value = model.compute_p_value(text_input, selected_domain)
+                    elapsed_time = time.time() - start_time
+            
+                    # Convert tensors to Python scalars if needed
+                    if hasattr(crit, 'item'):
+                        crit = crit.item()
+                    if hasattr(p_value, 'item'):
+                        p_value = p_value.item()
+
+            # Clear status and show results
+            status_placeholder.empty()
+
+            # ========== 🆕 保存检测结果到 session_state ==========
+            st.session_state.last_detection = {
+                'text': text_input,
+                'domain': selected_domain,
+                'statistics': crit,
+                'p_value': p_value,
+                'elapsed_time': elapsed_time
+            }
+
+            # Count detection once per unique detect action
+            _det_key = f'det_counted_{hash(text_input[:80])}'
+            if _det_key not in st.session_state:
+                st.session_state[_det_key] = True
+                stats_manager.increment_detection()
+
+            st.info(
+                f"""
+                **Conclusion**: 
+
+                    {'Text is likely LLM-generated.' if p_value < selected_level else 'Fail to reject hypothesis that text is human-written.'}
+
+                based on the observation that $p$-value {p_value:.3f} is {'less' if p_value < selected_level else 'greater'} than significance level {selected_level:.2f} 📊
+                """,
+                icon="💡"
+            )
+            st.markdown(
+                """
+                <style>
+                /* Tighten spacing inside Clarification / Citation expanders */
+                div[data-testid="stExpander"] {
+                    margin-top: -1.3rem;
+                }
+                div[data-testid="stExpander"] p,
+                div[data-testid="stExpander"] li {
+                    line-height: 1.35;
+                    margin-bottom: 0.1rem;
+                }
+
+                div[data-testid="stExpander"] ul {
+                    margin-top: 0.1rem;
+                }
+                </style>
+                """,
+                unsafe_allow_html=True
+            )
+            with st.expander("📋 Interpretation and Suggestions"):
+                st.markdown(
+                    """
+                    + Interpretation:
+                        - $p$-value: Lower $p$-value (closer to 0) indicates text is **more likely AI-generated**; Higher $p$-value (closer to 1) indicates text is **more likely human-written**.
+                        - Significance Level (α): a threshold set by the user to determine the sensitivity of the detection. Lower α means stricter criteria for claiming the text is AI-generated.
+
+                    + Suggestions for better detection:
+                        - Provide longer text inputs for more reliable detection results.
+                        - Select the domain that best matches the content of your text to improve detection accuracy.
+                    """
+                )
+
+
+            # Show detailed results
+            with result_placeholder:
+                st.caption(f"⏱️ Processing time: {elapsed_time:.2f} seconds")
+        
+        except Exception as e:
+            status_placeholder.empty()
+            st.error(f"❌ Error during detection: {str(e)}")
+            st.exception(e)
+
+# -----------------
+# Feedback UI (outside if detect_clicked — persists across all reruns via session_state)
+# -----------------
+if st.session_state.last_detection is not None and not st.session_state.feedback_given:
+    _ld = st.session_state.last_detection
+    st.markdown(
+        """
+        <style>
+        .fb-header { display: flex; align-items: center; gap: 0.4rem; margin-bottom: 0.3rem; }
+        .privacy-tip {
+            position: relative; display: inline-block;
+            cursor: help; color: #9ca3af; font-size: 0.9rem;
+        }
+        .privacy-tip .tip-text {
+            visibility: hidden; opacity: 0;
+            width: 240px; background-color: #374151; color: #f9fafb;
+            text-align: left; border-radius: 6px;
+            padding: 0.5rem 0.7rem; font-size: 0.78rem; line-height: 1.4;
+            position: absolute; z-index: 100;
+            bottom: 130%; left: 50%; transform: translateX(-50%);
+            transition: opacity 0.25s ease; pointer-events: none;
+        }
+        .privacy-tip:hover .tip-text { visibility: visible; opacity: 1; }
+        </style>
+        <div class="fb-header">
+          <strong>📝 Result Feedback</strong>: Does this detection result meet your expectations?
+          <span class="privacy-tip">🔒
+            <span class="tip-text">🔒 Your feedback is stored privately and will never be shared with third parties. It is used solely to improve detection accuracy.</span>
+          </span>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    feedback_col1, feedback_col2 = st.columns(2)
+    with feedback_col1:
+        if st.button("✅ Expected", use_container_width=True, type="secondary",
+                     key="expected_btn"):
+            try:
+                fb_success, fb_message = feedback_manager.save_feedback(
+                    _ld['text'], _ld['domain'], _ld['statistics'], _ld['p_value'], 'expected'
+                )
+                if fb_success:
+                    st.session_state.feedback_given = True
+                    st.session_state.pending_toast = ("Thank you for your feedback!", "✅")
+                    st.rerun()
+                else:
+                    st.error(f"Failed to save feedback: {fb_message}")
+            except Exception as e:
+                st.error(f"Failed to save feedback: {str(e)}")
+    with feedback_col2:
+        if st.button("❌ Unexpected", use_container_width=True, type="secondary",
+                     key="unexpected_btn"):
+            try:
+                fb_success, fb_message = feedback_manager.save_feedback(
+                    _ld['text'], _ld['domain'], _ld['statistics'], _ld['p_value'], 'unexpected'
+                )
+                if fb_success:
+                    st.session_state.feedback_given = True
+                    st.session_state.pending_toast = ("Feedback recorded! This will help us improve.", "📝")
+                    st.rerun()
+                else:
+                    st.error(f"Failed to save feedback: {fb_message}")
+            except Exception as e:
+                st.error(f"Failed to save feedback: {str(e)}")
+
+# with st.expander("📋 Citation"):
+#     st.markdown(
+#         """
+#         If you find this tool useful for you, please cite our paper: **[AdaDetectGPT: Adaptive Detection of LLM-Generated Text with Statistical Guarantees](https://arxiv.org/abs/2510.01268)**
+#         """
+#     )
+#     st.code(
+#         """
+# @inproceedings{zhou2024adadetectgpt,
+#   title={AdaDetectGPT: Adaptive Detection of LLM-Generated Text with Statistical Guarantees},
+#   author={Hongyi Zhou and Jin Zhu and Pingfan Su and Kai Ye and Ying Yang and Shakeel A O B Gavioli-Akilagun and Chengchun Shi},
+#   booktitle={The Thirty-Ninth Annual Conference on Neural Information Processing Systems},
+#   year={2025},
+# }
+#         """,
+#         language="bibtex"
+#     )
+
+# -----------------
+# Statistics Chip (fixed top-right)
+# -----------------
+st.markdown(
+    f"""
+    <style>
+    .stats-chip {{
+        position: fixed;
+        top: 3.6rem;
+        right: 1rem;
+        display: flex;
+        align-items: center;
+        gap: 0.35rem;
+        font-size: 0.78rem;
+        color: #9ca3af;
+        z-index: 999;
+        pointer-events: none;
+    }}
+    </style>
+    <div class="stats-chip">
+      <span>{stats_manager.visit_count:,} visits</span>
+    </div>
+    """,
+    unsafe_allow_html=True
+)
+
+# -----------------
+# Footer
+# -----------------
+st.markdown(
+    """
+    <style>
+    .footer {
+        position: fixed;
+        left: 0;
+        bottom: 0;
+        width: 100%;
+        background-color: white;
+        color: gray;
+        text-align: center;
+        padding: 1px;
+        border-top: 1px solid #e0e0e0;
+        z-index: 999;
+    }
+    
+    /* Add padding to main content to prevent overlap with fixed footer */
+    .main .block-container {
+        padding-bottom: 1px;
+    }
+    </style>
+    <div class='footer'>
+        <small> This tool is developed for research purposes only. The detection results are not 100% accurate and should not be used as the sole basis for any critical decisions. Users are advised to use this tool responsibly and ethically. </small>
+    </div>
+    """,
+    unsafe_allow_html=True
+)

streamlit_backup/keep_alive.py

@@ -0,0 +1,47 @@
+"""
+keep_alive.py — Pings the HF Space to prevent sleep after 48h inactivity.
+
+The script:
+  1. Hits the Streamlit health endpoint to verify the Space is alive
+  2. Hits the main app page to simulate a user visit (counts as activity)
+
+Usage:
+    python keep_alive.py
+
+Schedule via GitHub Actions (.github/workflows/keep_alive.yml) — runs every 23 hours.
+"""
+import urllib.request
+import urllib.error
+from datetime import datetime, timezone
+
+SPACE_APP_URL = "https://stats-powered-ai-statdetectllm.hf.space"
+HEALTH_URL    = f"{SPACE_APP_URL}/_stcore/health"
+
+
+def ping(url: str, label: str) -> bool:
+    """Send a GET request to url and print the result. Returns True on HTTP 2xx."""
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+    try:
+        req = urllib.request.Request(
+            url,
+            headers={"User-Agent": "keep-alive-bot/1.0"},
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            if 200 <= resp.status < 300:
+                print(f"[{ts}] OK  {label}: HTTP {resp.status}")
+                return True
+            else:
+                print(f"[{ts}] WARN {label}: unexpected HTTP {resp.status}")
+                return False
+    except urllib.error.URLError as e:
+        print(f"[{ts}] FAIL {label}: {e}")
+        return False
+    except Exception as e:
+        print(f"[{ts}] FAIL {label}: unexpected error: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    ok1 = ping(HEALTH_URL,    "Health check  ")
+    ok2 = ping(SPACE_APP_URL, "App page visit")
+    raise SystemExit(0 if (ok1 and ok2) else 1)

streamlit_backup/requirements.txt

@@ -0,0 +1,11 @@
+# requirements.txt
+altair
+streamlit
+pandas==2.3.1
+torch==2.8.0
+numpy==2.1.3
+transformers==4.55.2
+peft==0.17.1
+tqdm
+scikit-learn
+huggingface_hub