Upload 13 files

Dockerfile

@@ -0,0 +1,24 @@
+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 -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"]

README.md

@@ -1,5 +1,5 @@
 ---
-title: AdaDetectGPT
+title: DetectGPTProMax
 emoji: 🐨
 colorFrom: blue
 colorTo: pink

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

src/FineTune/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+ckpt/*
+logs/*/
+models/*/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

src/FineTune/ckpt/config.json

@@ -0,0 +1 @@
+{"domains": ["Academia", "Finance", "Government", "Knowledge", "Legislation", "Medicine", "News", "UserReview", "General"], "criterion": "mean"}

src/FineTune/ckpt/null_distrs.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b54878910ccb7bcd7575dc032dccdd61e8ad604e5e195922c0051564ef8acd81
+size 3030341

src/FineTune/ckpt/scoring_model/README.md

@@ -0,0 +1,202 @@
+---
+base_model: google/gemma-3-1b-pt
+library_name: peft
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.15.2

src/FineTune/ckpt/scoring_model/adapter_config.json

@@ -0,0 +1,36 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "google/gemma-3-1b-pt",
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 4,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "k_proj",
+    "o_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_rslora": false
+}

src/FineTune/ckpt/scoring_model/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e74e22eead36ed3eef207c50d0ead88ea37f7748a0a0148be6dbc0a5d4701e37
+size 3009096

src/FineTune/model.py

@@ -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

@@ -0,0 +1,406 @@
+import os
+from pathlib import Path
+
+# -----------------
+# Get the directory where app.py is located
+# -----------------
+APP_DIR = Path(__file__).parent.resolve()
+
+# -----------------
+# 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
+
+# -----------------
+# Page Configuration
+# -----------------
+st.set_page_config(
+    page_title="AdaDetectGPT",
+    page_icon="🔍",
+    layout="wide"
+)
+
+# -----------------
+# 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
+
+# Initialize Feedback Manager with HF dataset
+# 请将 'your-username/your-dataset-name' 替换为您的实际 HF 数据集仓库 ID
+# 确保在环境变量中设置了 HF_TOKEN 以访问私有数据集
+FEEDBACK_DATASET_ID = os.environ.get('FEEDBACK_DATASET_ID', 'mamba413/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 # 保留本地备份
+)
+
+# -----------------
+# 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
+# ========================================
+
+# -----------------
+# Streamlit Layout
+# -----------------
+_, col0, _ = st.columns((1, 5, 1))
+with col0:
+    st.markdown(
+        "<h1 style='text-align: center; color: #0072C3;'>AdaDetectGPT: Adaptive LLM's Texts Detection</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 ---
+col1, col2 = st.columns((1, 1))
+
+with col1:
+    text_input = st.text_area(
+        label="",
+        placeholder="Paste your text to be detected here",
+        help="Typically, providing text with a longer content would get a more reliable result.",
+        height=200,
+    )
+    
+    detect_clicked = st.button("Detect", type="primary", use_container_width=True)
+
+    selected_domain = st.selectbox(
+        label="⚙️ Domain (Optional)",
+        options=DOMAINS,
+        index=0,  # Default to General
+        help="💡 **Tip:** Select the domain that best matches your text for improving detection accuracy. Default is 'General' that means consider all domains."
+    )
+
+with col2:
+    statistics_ph = st.empty()
+    statistics_ph.text_input(
+        label="Statistics",
+        value="",
+        disabled=True,
+        help="Statistics will appear here after clicking the Detect button.",
+    )
+    
+    pvalue_ph = st.empty()
+    pvalue_ph.text_input(
+        label="p-value",
+        value="",
+        disabled=True,
+        help="p-value will appear here after clicking the Detect button.",
+    )
+
+# -----------------
+# 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
+            }
+
+            # Update score displays
+            with col2:
+                statistics_ph.text_input(
+                    label="Statistics",
+                    value=f"{crit:.6f}",
+                    disabled=True,
+                    help="Detection statistics will appear here after clicking Detect.",
+                )
+                
+                pvalue_ph.text_input(
+                    label="p-value",
+                    value=f"{p_value:.6f}",
+                    disabled=True,
+                    help="p-value will appear here after clicking Detect.",
+                )
+
+                st.info(
+                    """
+                    **📊 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**
+                    - Generally, p-value < 0.05 suggests the text may be LLM-generated
+                    """,
+                    icon="💡"
+                )
+
+                # ========== 🆕 Feedback buttons (moved here for better UX) ==========
+                st.markdown("**📝 Result Feedback**: Does this detection result meet your expectations?")
+                
+                current_text = text_input
+                current_domain = selected_domain
+                current_statistics = crit
+                current_pvalue = p_value
+                feedback_col1, feedback_col2 = st.columns(2)
+                
+                with feedback_col1:
+                    if st.button("✅ Expected", use_container_width=True, type="secondary", key=f"expected_btn_{hash(text_input[:50])}"):
+                        try:
+                            success, message = feedback_manager.save_feedback(
+                                current_text,
+                                current_domain,
+                                current_statistics,
+                                current_pvalue,
+                                'expected'
+                            )
+                            if success:
+                                st.success("✅ Thank you for your feedback!")
+                                st.caption(f"💾 {message}")
+                            else:
+                                st.error(f"Failed to save feedback: {message}")
+                        except Exception as e:
+                            st.error(f"Failed to save feedback: {str(e)}")
+                            import traceback
+                            st.code(traceback.format_exc())
+                
+                with feedback_col2:
+                    if st.button("❌ Unexpected", use_container_width=True, type="secondary", key=f"unexpected_btn_{hash(text_input[:50])}"):
+                        try:
+                            success, message = feedback_manager.save_feedback(
+                                current_text,
+                                current_domain,
+                                current_statistics,
+                                current_pvalue,
+                                'unexpected'
+                            )
+                            if success:
+                                st.warning("❌ Feedback recorded! This will help us improve.")
+                                st.caption(f"💾 {message}")
+                            else:
+                                st.error(f"Failed to save feedback: {message}")
+                        except Exception as e:
+                            st.error(f"Failed to save feedback: {str(e)}")
+                            import traceback
+                            st.code(traceback.format_exc())
+                
+                if st.session_state.feedback_given:
+                    st.success("✅ Feedback submitted successfully!")
+                # ============================================
+
+            # 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)
+
+# ========== 🆕 Citation and paper reference section ==========
+# st.markdown("---")
+# st.markdown(
+#     """
+#      📄 **Citation** 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)**
+#     """
+# )
+# with st.expander("📋 BibTeX Citation"):
+#     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 (Accepted)},
+#   year={2025},
+# }
+#         """,
+#         language="bibtex"
+#     )
+
+# -----------------
+# Footer
+# -----------------
+st.markdown(
+    """
+    <style>
+    .footer {
+        position: fixed;
+        left: 0;
+        bottom: 0;
+        width: 100%;
+        background-color: white;
+        color: gray;
+        text-align: center;
+        padding: 10px;
+        border-top: 1px solid #e0e0e0;
+        z-index: 999;
+    }
+    
+    /* Add padding to main content to prevent overlap with fixed footer */
+    .main .block-container {
+        padding-bottom: 60px;
+    }
+    </style>
+    <div class='footer'>
+        <small>Powered by Adaptive LLM Text Detection | For research purposes only</small>
+    </div>
+    """,
+    unsafe_allow_html=True
+)

src/feedback.py

@@ -0,0 +1,272 @@
+import os
+import json
+from datetime import datetime
+from pathlib import Path
+from huggingface_hub import HfApi, upload_file, hf_hub_download
+from typing import Optional
+import pandas as pd
+
+class FeedbackManager:
+    """管理用户反馈，支持保存到 Hugging Face 私有数据集"""
+    
+    def __init__(
+        self, 
+        dataset_repo_id: str = None,
+        hf_token: str = None,
+        local_backup: bool = True
+    ):
+        """
+        初始化 FeedbackManager
+        
+        Args:
+            dataset_repo_id: Hugging Face 数据集仓库 ID (格式: username/dataset-name)
+            hf_token: Hugging Face API token (用于私有数据集)
+            local_backup: 是否在本地保留备份
+        """
+        self.dataset_repo_id = dataset_repo_id
+        self.hf_token = hf_token or os.environ.get('HF_TOKEN')
+        self.local_backup = local_backup
+        
+        # 初始化 HF API
+        if self.dataset_repo_id and self.hf_token:
+            self.api = HfApi(token=self.hf_token)
+            # 确保数据集存在
+            self._ensure_dataset_exists()
+        else:
+            self.api = None
+            print("⚠️ No HF dataset configured. Will only save locally.")
+        
+        # 设置本地存储路径
+        if os.environ.get('SPACE_ID'):
+            self.local_dir = Path('/tmp/feedback_data')
+        else:
+            self.local_dir = Path(__file__).parent / 'feedback_data'
+        
+        self.local_dir.mkdir(exist_ok=True, parents=True)
+        self.local_file = self.local_dir / 'user_feedback.json'
+        
+    def _ensure_dataset_exists(self):
+        """确保 HF 数据集存在，如果不存在则创建"""
+        try:
+            from huggingface_hub import create_repo
+            # 尝试创建数据集仓库（如果已存在会抛出异常）
+            try:
+                create_repo(
+                    repo_id=self.dataset_repo_id,
+                    token=self.hf_token,
+                    private=True,
+                    repo_type="dataset"
+                )
+                print(f"✅ Created new private dataset: {self.dataset_repo_id}")
+                
+                # 创建初始的 README.md
+                readme_content = f"""---
+license: mit
+---
+
+# AdaDetectGPT User Feedback Dataset
+
+This dataset contains user feedback from the AdaDetectGPT detection system.
+
+## Data Format
+
+Each entry contains:
+- `timestamp`: When the feedback was submitted
+- `text`: The text that was analyzed
+- `domain`: The domain selected for analysis
+- `statistics`: The computed statistics value
+- `p_value`: The p-value from the detection
+- `feedback`: User feedback (expected/unexpected)
+"""
+                readme_file = self.local_dir / 'README.md'
+                readme_file.write_text(readme_content)
+                
+                upload_file(
+                    path_or_fileobj=str(readme_file),
+                    path_in_repo="README.md",
+                    repo_id=self.dataset_repo_id,
+                    repo_type="dataset",
+                    token=self.hf_token
+                )
+                
+            except Exception as e:
+                if "already exists" not in str(e):
+                    print(f"⚠️ Dataset check: {e}")
+                    
+        except Exception as e:
+            print(f"⚠️ Could not verify dataset: {e}")
+    
+    def _load_existing_data(self) -> list:
+        """从 HF 数据集加载现有数据"""
+        existing_data = []
+        
+        # 首先尝试从 HF 数据集加载
+        if self.api and self.dataset_repo_id:
+            try:
+                # 下载现有的反馈文件
+                local_path = hf_hub_download(
+                    repo_id=self.dataset_repo_id,
+                    filename="feedback_data.json",
+                    repo_type="dataset",
+                    token=self.hf_token,
+                    cache_dir=str(self.local_dir)
+                )
+                with open(local_path, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+                print(f"📥 Loaded {len(existing_data)} existing feedback entries from HF")
+            except Exception as e:
+                # 文件可能还不存在
+                if "404" not in str(e):
+                    print(f"⚠️ Could not load from HF dataset: {e}")
+        
+        # 如果 HF 加载失败，尝试本地文件
+        if not existing_data and self.local_file.exists():
+            try:
+                with open(self.local_file, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+                print(f"📥 Loaded {len(existing_data)} existing feedback entries from local")
+            except Exception as e:
+                print(f"⚠️ Could not load local data: {e}")
+        
+        return existing_data
+    
+    def save_feedback(
+        self, 
+        text: str, 
+        domain: str, 
+        statistics: float, 
+        p_value: float, 
+        feedback_type: str
+    ) -> tuple[bool, str]:
+        """
+        保存用户反馈到 HF 数据集和/或本地文件
+        
+        Args:
+            text: 被检测的文本
+            domain: 选择的领域
+            statistics: 统计值
+            p_value: p值
+            feedback_type: 'expected' 或 'unexpected'
+            
+        Returns:
+            (success, message): 是否成功和相关消息
+        """
+        # 准备反馈数据
+        feedback_entry = {
+            'timestamp': datetime.now().isoformat(),
+            'text': text,
+            'domain': domain,
+            'statistics': float(statistics),
+            'p_value': float(p_value),
+            'feedback': feedback_type
+        }
+        
+        # 加载现有数据
+        feedback_data = self._load_existing_data()
+        
+        # 添加新反馈
+        feedback_data.append(feedback_entry)
+        
+        success = False
+        messages = []
+        
+        # 保存到本地（作为备份）
+        if self.local_backup:
+            try:
+                with open(self.local_file, 'w', encoding='utf-8') as f:
+                    json.dump(feedback_data, f, ensure_ascii=False, indent=2)
+                messages.append(f"💾 Local backup saved")
+                success = True
+            except Exception as e:
+                messages.append(f"❌ Local save failed: {e}")
+        
+        # 上传到 HF 数据集
+        if self.api and self.dataset_repo_id:
+            try:
+                # 保存为 JSON 文件
+                upload_file(
+                    path_or_fileobj=str(self.local_file),
+                    path_in_repo="feedback_data.json",
+                    repo_id=self.dataset_repo_id,
+                    repo_type="dataset",
+                    token=self.hf_token,
+                    commit_message=f"Add feedback: {feedback_type} at {feedback_entry['timestamp']}"
+                )
+                
+                # 同时创建/更新 CSV 版本（方便查看）
+                df = pd.DataFrame(feedback_data)
+                csv_file = self.local_dir / 'feedback_data.csv'
+                df.to_csv(csv_file, index=False)
+                
+                upload_file(
+                    path_or_fileobj=str(csv_file),
+                    path_in_repo="feedback_data.csv",
+                    repo_id=self.dataset_repo_id,
+                    repo_type="dataset",
+                    token=self.hf_token,
+                    commit_message=f"Update CSV: {len(feedback_data)} total entries"
+                )
+                
+                messages.append(f"☁️ Uploaded to HF dataset: {self.dataset_repo_id}")
+                success = True
+                
+            except Exception as e:
+                messages.append(f"⚠️ HF upload failed: {e}")
+                # 如果 HF 上传失败但本地保存成功，仍然返回成功
+                success = success or self.local_backup
+        
+        return success, " | ".join(messages)
+    
+    def get_feedback_stats(self) -> dict:
+        """获取反馈统计信息"""
+        feedback_data = self._load_existing_data()
+        
+        if not feedback_data:
+            return {
+                'total_count': 0,
+                'expected_count': 0,
+                'unexpected_count': 0,
+                'domains': {}
+            }
+        
+        df = pd.DataFrame(feedback_data)
+        stats = {
+            'total_count': len(df),
+            'expected_count': len(df[df['feedback'] == 'expected']),
+            'unexpected_count': len(df[df['feedback'] == 'unexpected']),
+            'domains': df['domain'].value_counts().to_dict() if 'domain' in df.columns else {}
+        }
+        
+        return stats
+
+
+# 便捷函数（向后兼容）
+_default_manager: Optional[FeedbackManager] = None
+
+def init_feedback_manager(dataset_repo_id: str = None, hf_token: str = None):
+    """初始化全局反馈管理器"""
+    global _default_manager
+    _default_manager = FeedbackManager(
+        dataset_repo_id=dataset_repo_id,
+        hf_token=hf_token
+    )
+    return _default_manager
+
+def save_feedback(text: str, domain: str, statistics: float, p_value: float, feedback_type: str):
+    """
+    使用默认管理器保存反馈（向后兼容）
+    """
+    global _default_manager
+    if _default_manager is None:
+        # 从环境变量读取配置
+        dataset_repo_id = os.environ.get('FEEDBACK_DATASET_ID')
+        _default_manager = FeedbackManager(dataset_repo_id=dataset_repo_id)
+    
+    success, message = _default_manager.save_feedback(
+        text, domain, statistics, p_value, feedback_type
+    )
+    
+    if not success:
+        raise Exception(f"Failed to save feedback: {message}")
+    
+    return message