Update README.md

README.md

@@ -1,56 +1,30 @@
 ---
-library_name: transformers
 license: apache-2.0
-license_link: https://huggingface.co/Qwen/Qwen3-30B-A3B/blob/main/LICENSE
 pipeline_tag: text-generation
 base_model:
-- Qwen/Qwen3-30B-A3B-Base
+- Qwen/Qwen3-30B-A3B
 ---
 
-# Qwen3-30B-A3B
-<a href="https://chat.qwen.ai/" target="_blank" style="margin: 2px;">
-    <img alt="Chat" src="https://img.shields.io/badge/%F0%9F%92%9C%EF%B8%8F%20Qwen%20Chat%20-536af5" style="display: inline-block; vertical-align: middle;"/>
-</a>
+# Rubric Generator
 
-## Qwen3 Highlights
+This is the official checkpoint of the rubric generator trained using the method proposed in [**Learning Query-Specific Rubrics from Human Preferences for DeepResearch Report Generation**](https://arxiv.org/pdf/2602.03619).
+Our rubric generator was trained based on [Qwen3-30B-A3B](https://huggingface.co/Qwen/Qwen3-30B-A3B).
 
-Qwen3 is the latest generation of large language models in Qwen series, offering a comprehensive suite of dense and mixture-of-experts (MoE) models. Built upon extensive training, Qwen3 delivers groundbreaking advancements in reasoning, instruction-following, agent capabilities, and multilingual support, with the following key features:
-
-- **Uniquely support of seamless switching between thinking mode** (for complex logical reasoning, math, and coding) and **non-thinking mode** (for efficient, general-purpose dialogue) **within single model**, ensuring optimal performance across various scenarios.
-- **Significantly enhancement in its reasoning capabilities**, surpassing previous QwQ (in thinking mode) and Qwen2.5 instruct models (in non-thinking mode) on mathematics, code generation, and commonsense logical reasoning.
-- **Superior human preference alignment**, excelling in creative writing, role-playing, multi-turn dialogues, and instruction following, to deliver a more natural, engaging, and immersive conversational experience.
-- **Expertise in agent capabilities**, enabling precise integration with external tools in both thinking and unthinking modes and achieving leading performance among open-source models in complex agent-based tasks.
-- **Support of 100+ languages and dialects** with strong capabilities for **multilingual instruction following** and **translation**.
-
-## Model Overview
-
-**Qwen3-30B-A3B** has the following features:
-- Type: Causal Language Models
-- Training Stage: Pretraining & Post-training
-- Number of Parameters: 30.5B in total and 3.3B activated
-- Number of Paramaters (Non-Embedding): 29.9B
-- Number of Layers: 48
-- Number of Attention Heads (GQA): 32 for Q and 4 for KV
-- Number of Experts: 128
-- Number of Activated Experts: 8
-- Context Length: 32,768 natively and [131,072 tokens with YaRN](#processing-long-texts). 
-
-For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our [blog](https://qwenlm.github.io/blog/qwen3/), [GitHub](https://github.com/QwenLM/Qwen3), and [Documentation](https://qwen.readthedocs.io/en/latest/).
-
-## Quickstart
-
-The code of Qwen3-MoE has been in the latest Hugging Face `transformers` and we advise you to use the latest version of `transformers`.
-
-With `transformers<4.51.0`, you will encounter the following error:
-```
-KeyError: 'qwen3_moe'
-```
+## Quick Start
 
 The following contains a code snippet illustrating how to use the model generate content based on given inputs. 
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
+import re
+import json
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--query", type=str, required=True, help="The report generation query") # string, research query
+args = parser.parse_args()
+query = args.query
 
-model_name = "Qwen/Qwen3-30B-A3B"
+model_name = "fdu-lcz/rubric_generator"
 
 # load the tokenizer and the model
 tokenizer = AutoTokenizer.from_pretrained(model_name)
@@ -61,293 +35,227 @@ model = AutoModelForCausalLM.from_pretrained(
 )
 
 # prepare the model input
-prompt = "Give me a short introduction to large language model."
-messages = [
-    {"role": "user", "content": prompt}
-]
-text = tokenizer.apply_chat_template(
-    messages,
-    tokenize=False,
-    add_generation_prompt=True,
-    enable_thinking=True # Switches between thinking and non-thinking modes. Default is True.
-)
-model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+zh_system_prompt = """
+你是一位专业的评分标准（rubric）撰写专家。你的任务是根据给定的**报告生成类问题（report-generation query）**，生成一套自洽的评估标准（rubrics），用于判断一个回答（生成的报告）的质量。
 
-# conduct text completion
-generated_ids = model.generate(
-    **model_inputs,
-    max_new_tokens=32768
-)
-output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
+由于没有 reference_answer，你需要**直接根据 query 的内容**推断理想回答应具备的特征，包括目标、结构、信息覆盖范围与表达要求。
 
-# parsing thinking content
-try:
-    # rindex finding 151668 (</think>)
-    index = len(output_ids) - output_ids[::-1].index(151668)
-except ValueError:
-    index = 0
+评分标准包含但不限于以下方面：
 
-thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
-content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
+* 内容的事实相关性与准确性
+* 报告的结构与逻辑组织
+* 信息的完整性与深度
+* 推理过程与论证合理性
+* 表达的清晰性与连贯性
+* 语气、风格与报告意图的匹配度（如总结、分析、建议等）
 
-print("thinking content:", thinking_content)
-print("content:", content)
-```
+每个评分项必须是**自包含的**，让非专业读者也能独立理解，无需额外查阅资料。每条描述必须以以下前缀之一开头：
+“关键标准: …”
+“重要标准: …”
+“可选标准: …”
+“错误标准: …”
 
-For deployment, you can use `sglang>=0.4.6.post1` or `vllm>=0.8.5` or to create an OpenAI-compatible API endpoint:
-- SGLang:
-    ```shell
-    python -m sglang.launch_server --model-path Qwen/Qwen3-30B-A3B --reasoning-parser qwen3
-    ```
-- vLLM:
-    ```shell
-    vllm serve Qwen/Qwen3-30B-A3B --enable-reasoning --reasoning-parser deepseek_r1
-    ```
+---
 
-For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3.
+**输入：**
+● query：完整的报告生成请求文本
 
-## Switching Between Thinking and Non-Thinking Mode
+**评分项总数：**
+● 根据 query 的复杂度，选择 7 至 20 个 rubric 项。
 
-> [!TIP]
-> The `enable_thinking` switch is also available in APIs created by SGLang and vLLM. 
-> Please refer to our documentation for [SGLang](https://qwen.readthedocs.io/en/latest/deployment/sglang.html#thinking-non-thinking-modes) and [vLLM](https://qwen.readthedocs.io/en/latest/deployment/vllm.html#thinking-non-thinking-modes) users.
+**每个 rubric 项包含：**
+● title（标题，中文，2–6 个词）
+● description（描述）：一句话，中文，以类别前缀开头，明确说明应在生成报告中观察到的具体要素
+● weight（权重）：权重，数字
 
-### `enable_thinking=True`
+* 关键 / 重要 / 可选 分别取 1–5（5 表示最重要）
+* 错误 取 –1 或 –2（表示负面扣分项）
 
-By default, Qwen3 has thinking capabilities enabled, similar to QwQ-32B. This means the model will use its reasoning abilities to enhance the quality of generated responses. For example, when explicitly setting `enable_thinking=True` or leaving it as the default value in `tokenizer.apply_chat_template`, the model will engage its thinking mode.
+---
 
-```python
-text = tokenizer.apply_chat_template(
-    messages,
-    tokenize=False,
-    add_generation_prompt=True,
-    enable_thinking=True  # True is the default value for enable_thinking
-)
-```
+**类别说明：**
 
-In this mode, the model will generate think content wrapped in a `<think>...</think>` block, followed by the final response.
+* **关键标准**：报告必须包含的核心事实、结构或目标要素；缺失则回答无效（权重 5）
+* **重要标准**：关键推理、完整性或清晰度；对质量影响较大（权重 3–4）
+* **可选标准**：表达风格或深度上的加分项（权重 1–2）
+* **错误标准**：常见错误或遗漏项，明确指出“未提及”或“错误推荐”（权重 –1 或 –2）
 
-> [!NOTE]
-> For thinking mode, use `Temperature=0.6`, `TopP=0.95`, `TopK=20`, and `MinP=0` (the default setting in `generation_config.json`). **DO NOT use greedy decoding**, as it can lead to performance degradation and endless repetitions. For more detailed guidance, please refer to the [Best Practices](#best-practices) section.
+---
 
+**其他指导：**
 
-### `enable_thinking=False`
+* 如果报告应包含结论或建议，加入：
+`关键标准: 包含有证据支持的清晰结论。`（必须包含有证据支持的清晰结论）
+* 如果报告需要解释或论证，加入：
+`重要标准: 解释关键点背后的推理，并提供支持性论据。`
+* 如果报告需有清晰结构，加入：
+`关键标准: 以清晰的章节和逻辑流程组织内容。`
+* 如果报告有特定语体要求（如学术、政策、商业等），加入：
+`重要标准: 保持与报告上下文一致的专业和客观语气。`
+* 如果需要简洁表达，加入：
+`可选标准: 保持简洁，避免冗余。`
 
-We provide a hard switch to strictly disable the model's thinking behavior, aligning its functionality with the previous Qwen2.5-Instruct models. This mode is particularly useful in scenarios where disabling thinking is essential for enhancing efficiency.
+---
 
-```python
-text = tokenizer.apply_chat_template(
-    messages,
-    tokenize=False,
-    add_generation_prompt=True,
-    enable_thinking=False  # Setting enable_thinking=False disables thinking mode
-)
-```
+**输出要求：**
 
-In this mode, the model will not generate any think content and will not include a `<think>...</think>` block.
+* 输出一个 JSON 数组，格式为[{…}, {…}, …]，每个 JSON 对象对应一个 rubric 项
+* 每个 JSON 对象必须只包含三个键：`title`、`description`、`weight`
+* 不得包含多余键或复制大段 query 内容
+* 每个 description 必须以类别前缀开头
+* **重要格式说明：** 在 description 或 title 的文本中，如果需要引用内容或使用引号，**请务必使用单引号（'）**，严禁使用双引号（"），以免破坏 JSON 格式。例如：使用 '米其林星级' 而不是 "米其林星级"。
 
-> [!NOTE]
-> For non-thinking mode, we suggest using `Temperature=0.7`, `TopP=0.8`, `TopK=20`, and `MinP=0`. For more detailed guidance, please refer to the [Best Practices](#best-practices) section.
+---
 
-### Advanced Usage: Switching Between Thinking and Non-Thinking Modes via User Input
+**总结：**
+你的任务是——**仅根据 query 内容推断出理想报告应具备的关键特征**，并据此构建一套结构化、有权重的 rubric JSON，用于系统评估报告生成结果的质量。
 
-We provide a soft switch mechanism that allows users to dynamically control the model's behavior when `enable_thinking=True`. Specifically, you can add `/think` and `/no_think` to user prompts or system messages to switch the model's thinking mode from turn to turn. The model will follow the most recent instruction in multi-turn conversations.
+请仅返回所请求的 JSON 数组，不要返回任何额外文本或说明。
 
-Here is an example of a multi-turn conversation:
+query:
+"""
 
-```python
-from transformers import AutoModelForCausalLM, AutoTokenizer
+en_system_prompt = """
+You are a professional rubric-writing expert. Your task is to generate a coherent and self-contained set of evaluation rubrics based on a given **report-generation query**, which will be used to assess the quality of a generated response (i.e., a report).
 
-class QwenChatbot:
-    def __init__(self, model_name="Qwen/Qwen3-30B-A3B"):
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.model = AutoModelForCausalLM.from_pretrained(model_name)
-        self.history = []
-
-    def generate_response(self, user_input):
-        messages = self.history + [{"role": "user", "content": user_input}]
-
-        text = self.tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True
-        )
-
-        inputs = self.tokenizer(text, return_tensors="pt")
-        response_ids = self.model.generate(**inputs, max_new_tokens=32768)[0][len(inputs.input_ids[0]):].tolist()
-        response = self.tokenizer.decode(response_ids, skip_special_tokens=True)
-
-        # Update history
-        self.history.append({"role": "user", "content": user_input})
-        self.history.append({"role": "assistant", "content": response})
-
-        return response
-
-# Example Usage
-if __name__ == "__main__":
-    chatbot = QwenChatbot()
-
-    # First input (without /think or /no_think tags, thinking mode is enabled by default)
-    user_input_1 = "How many r's in strawberries?"
-    print(f"User: {user_input_1}")
-    response_1 = chatbot.generate_response(user_input_1)
-    print(f"Bot: {response_1}")
-    print("----------------------")
-
-    # Second input with /no_think
-    user_input_2 = "Then, how many r's in blueberries? /no_think"
-    print(f"User: {user_input_2}")
-    response_2 = chatbot.generate_response(user_input_2)
-    print(f"Bot: {response_2}") 
-    print("----------------------")
-
-    # Third input with /think
-    user_input_3 = "Really? /think"
-    print(f"User: {user_input_3}")
-    response_3 = chatbot.generate_response(user_input_3)
-    print(f"Bot: {response_3}")
-```
+Since no reference answer is provided, you must **infer the characteristics of an ideal answer directly from the query**, including its objectives, structure, information coverage, and expression requirements.
 
-> [!NOTE]
-> For API compatibility, when `enable_thinking=True`, regardless of whether the user uses `/think` or `/no_think`, the model will always output a block wrapped in `<think>...</think>`. However, the content inside this block may be empty if thinking is disabled.
-> When `enable_thinking=False`, the soft switches are not valid. Regardless of any `/think` or `/no_think` tags input by the user, the model will not generate think content and will not include a `<think>...</think>` block.
+The evaluation rubrics should include, but are not limited to, the following aspects:
 
-## Agentic Use
+* Factual relevance and accuracy of the content  
+* Structure and logical organization of the report  
+* Completeness and depth of information  
+* Soundness of reasoning and argumentation  
+* Clarity and coherence of expression  
+* Appropriateness of tone and style with respect to the report's intent (e.g., summary, analysis, recommendation)
 
-Qwen3 excels in tool calling capabilities. We recommend using [Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) to make the best use of agentic ability of Qwen3. Qwen-Agent encapsulates tool-calling templates and tool-calling parsers internally, greatly reducing coding complexity.
+Each rubric item must be **self-contained**, so that a non-expert reader can understand it independently without additional context.  
+Each description must begin with one of the following prefixes:
 
-To define the available tools, you can use the MCP configuration file, use the integrated tool of Qwen-Agent, or integrate other tools by yourself.
-```python
-from qwen_agent.agents import Assistant
-
-# Define LLM
-llm_cfg = {
-    'model': 'Qwen3-30B-A3B',
-
-    # Use the endpoint provided by Alibaba Model Studio:
-    # 'model_type': 'qwen_dashscope',
-    # 'api_key': os.getenv('DASHSCOPE_API_KEY'),
-
-    # Use a custom endpoint compatible with OpenAI API:
-    'model_server': 'http://localhost:8000/v1',  # api_base
-    'api_key': 'EMPTY',
-
-    # Other parameters:
-    # 'generate_cfg': {
-    #         # Add: When the response content is `<think>this is the thought</think>this is the answer;
-    #         # Do not add: When the response has been separated by reasoning_content and content.
-    #         'thought_in_content': True,
-    #     },
-}
+- ``Key Criterion: ...''
+- ``Important Criterion: ...''
+- ``Optional Criterion: ...''
+- ``Error Criterion: ...''
 
-# Define Tools
-tools = [
-    {'mcpServers': {  # You can specify the MCP configuration file
-            'time': {
-                'command': 'uvx',
-                'args': ['mcp-server-time', '--local-timezone=Asia/Shanghai']
-            },
-            "fetch": {
-                "command": "uvx",
-                "args": ["mcp-server-fetch"]
-            }
-        }
-    },
-  'code_interpreter',  # Built-in tools
-]
+---
 
-# Define Agent
-bot = Assistant(llm=llm_cfg, function_list=tools)
+### **Input:**
+* query: the full text of the report-generation request
 
-# Streaming generation
-messages = [{'role': 'user', 'content': 'https://qwenlm.github.io/blog/ Introduce the latest developments of Qwen'}]
-for responses in bot.run(messages=messages):
-    pass
-print(responses)
-```
+### **Number of Rubric Items:**
+* Select between 7 and 20 rubric items depending on the complexity of the query.
+
+### **Each rubric item must include:**
+* `title` (2-6 words)  
+* `description`: one sentence, starting with a category prefix and clearly stating what should be observed in the generated report  
+* `weight`: a numeric value
+
+* Key / Important / Optional criteria take values from 1-5 (5 = most important)  
+* Error criteria take values of -1 or -2 (indicating penalties)
+
+---
+
+### **Category Definitions:**
 
-## Processing Long Texts
+* **Key Criterion**: Core facts, structure, or objectives that must be present; missing them makes the answer invalid (weight = 5)
+* **Important Criterion**: Critical reasoning, completeness, or clarity that significantly affects quality (weight = 3-4)
+* **Optional Criterion**: Stylistic or depth-related enhancements (weight = 1-2)
+* **Error Criterion**: Common mistakes or omissions, explicitly indicating ``missing'' or ``incorrect'' elements (weight = -1 or -2)
 
-Qwen3 natively supports context lengths of up to 32,768 tokens. For conversations where the total length (including both input and output) significantly exceeds this limit, we recommend using RoPE scaling techniques to handle long texts effectively. We have validated the model's performance on context lengths of up to 131,072 tokens using the [YaRN](https://arxiv.org/abs/2309.00071) method.
+---
+
+### **Additional Guidelines:**
 
-YaRN is currently supported by several inference frameworks, e.g., `transformers` and `llama.cpp` for local use, `vllm` and `sglang` for deployment. In general, there are two approaches to enabling YaRN for supported frameworks:
+* If the report should include conclusions or recommendations, include:
+`Key Criterion: Includes a clear conclusion supported by evidence.`
+* If the report requires explanation or reasoning, include:
+`Important Criterion: Explains the reasoning behind key points and provides supporting arguments.`
+* If the report requires a clear structure, include:
+`Key Criterion: Organizes content with clear sections and logical flow.`
+* If the report has a specific tone (e.g., academic, policy-oriented, business), include:
+`Important Criterion: Maintains a professional and objective tone consistent with the report context.`
+* If conciseness is required, include:
+`Optional Criterion: Maintains conciseness and avoids redundancy.`
 
-- Modifying the model files:
-  In the `config.json` file, add the `rope_scaling` fields:
-    ```json
-    {
-        ...,
-        "rope_scaling": {
-            "rope_type": "yarn",
-            "factor": 4.0,
-            "original_max_position_embeddings": 32768
-        }
-    }
-    ```
-  For `llama.cpp`, you need to regenerate the GGUF file after the modification.
+---
 
-- Passing command line arguments:
+### **Output Requirements:**
 
-  For `vllm`, you can use
-    ```shell
-    vllm serve ... --rope-scaling '{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}' --max-model-len 131072
-    ```
+* Output a JSON array in the format: [{...}, {...}, ...], where each object corresponds to one rubric item
+* Each JSON object must contain **only** three keys: `title`, `description`, and `weight`
+* Do not include any extra keys or copy large portions of the query
+* Each `description` must begin with one of the required category prefixes
+* **Important formatting rule:**  
+If quotation marks are needed inside `title` or `description`, **use single quotes (' ') only**.  
+Do NOT use double quotes (" "), as they will break the JSON format.  
+Example: use 'Michelin star' instead of "Michelin star".
 
-  For `sglang`, you can use
-    ```shell
-    python -m sglang.launch_server ... --json-model-override-args '{"rope_scaling":{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}}'
-    ```
+---
 
-  For `llama-server` from `llama.cpp`, you can use
-    ```shell
-    llama-server ... --rope-scaling yarn --rope-scale 4 --yarn-orig-ctx 32768
-    ```
+### **Summary:**
+Your task is to **infer the essential qualities of an ideal report solely from the given query**, and construct a structured, weighted rubric in JSON format to evaluate report-generation quality.
 
-> [!IMPORTANT]
-> If you encounter the following warning
-> ```
-> Unrecognized keys in `rope_scaling` for 'rope_type'='yarn': {'original_max_position_embeddings'}
-> ```
-> please upgrade `transformers>=4.51.0`.
+Return **only** the requested JSON array. Do not include any additional explanations or text.
 
-> [!NOTE]
-> All the notable open-source frameworks implement static YaRN, which means the scaling factor remains constant regardless of input length, **potentially impacting performance on shorter texts.**
-> We advise adding the `rope_scaling` configuration only when processing long contexts is required. 
-> It is also recommended to modify the `factor` as needed. For example, if the typical context length for your application is 65,536 tokens, it would be better to set `factor` as 2.0. 
+query:
+"""
 
-> [!NOTE]
-> The default `max_position_embeddings` in `config.json` is set to 40,960. This allocation includes reserving 32,768 tokens for outputs and 8,192 tokens for typical prompts, which is sufficient for most scenarios involving short text processing. If the average context length does not exceed 32,768 tokens, we do not recommend enabling YaRN in this scenario, as it may potentially degrade model performance.
+messages = [
+    {"role": "system", "content": zh_system_prompt},   # Choose the system prompt based on the language of the query
+    # {"role": "system", "content": en_system_prompt},   # Choose the system prompt based on the language of the query
+    {"role": "user", "content": query}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=True # Switches between thinking and non-thinking modes. Default is True.
+)
+model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
 
-> [!TIP]
-> The endpoint provided by Alibaba Model Studio supports dynamic YaRN by default and no extra configuration is needed.
+# conduct text completion
+generated_ids = model.generate(
+    **model_inputs,
+    max_new_tokens=32768,
+    temperature=0.3,
+    top_p=0.95
+)
+output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
 
-## Best Practices
+# parsing thinking content
+try:
+    # rindex finding 151668 (</think>)
+    index = len(output_ids) - output_ids[::-1].index(151668)
+except ValueError:
+    index = 0
 
-To achieve optimal performance, we recommend the following settings:
+thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
+content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
 
-1. **Sampling Parameters**:
-   - For thinking mode (`enable_thinking=True`), use `Temperature=0.6`, `TopP=0.95`, `TopK=20`, and `MinP=0`. **DO NOT use greedy decoding**, as it can lead to performance degradation and endless repetitions.
-   - For non-thinking mode (`enable_thinking=False`), we suggest using `Temperature=0.7`, `TopP=0.8`, `TopK=20`, and `MinP=0`.
-   - For supported frameworks, you can adjust the `presence_penalty` parameter between 0 and 2 to reduce endless repetitions. However, using a higher value may occasionally result in language mixing and a slight decrease in model performance.
+print("thinking content:", thinking_content)
+print("content:", content)
 
-2. **Adequate Output Length**: We recommend using an output length of 32,768 tokens for most queries. For benchmarking on highly complex problems, such as those found in math and programming competitions, we suggest setting the max output length to 38,912 tokens. This provides the model with sufficient space to generate detailed and comprehensive responses, thereby enhancing its overall performance.
+if content.startswith('```json'):
+    json_str = re.search(r'```json(.*?)```', content, re.DOTALL).group(1).strip()
+    rubric_list = json.loads(json_str)
+else:
+    rubric_list = json.loads(content)
 
-3. **Standardize Output Format**: We recommend using prompts to standardize model outputs when benchmarking.
-   - **Math Problems**: Include "Please reason step by step, and put your final answer within \boxed{}." in the prompt.
-   - **Multiple-Choice Questions**: Add the following JSON structure to the prompt to standardize responses: "Please show your choice in the `answer` field with only the choice letter, e.g., `"answer": "C"`."
+print(rubric_list)
+print("rubric_count: ", len(rubric_list))
+```
 
-4. **No Thinking Content in History**: In multi-turn conversations, the historical model output should only include the final output part and does not need to include the thinking content. It is implemented in the provided chat template in Jinja2. However, for frameworks that do not directly use the Jinja2 chat template, it is up to the developers to ensure that the best practice is followed.
+If you want to employ the model with vLLM or SGlang, please refer to the official Qwen3 guidelines.
 
-### Citation
+## Citation
 
 If you find our work helpful, feel free to give us a cite.
 
 ```
-@misc{qwen3,
-    title  = {Qwen3},
-    url    = {https://qwenlm.github.io/blog/qwen3/},
-    author = {Qwen Team},
-    month  = {April},
-    year   = {2025}
+@article{lv2026learning,
+  title={Learning Query-Specific Rubrics from Human Preferences for DeepResearch Report Generation},
+  author={Lv, Changze and Zhou, Jie and Zhao, Wentao and Xu, Jingwen and Huang, Zisu and Tian, Muzhao and Dou, Shihan and Gui, Tao and Tian, Le and Zhou, Xiao and others},
+  journal={arXiv preprint arXiv:2602.03619},
+  year={2026}
 }
-```
+```