Improve model card: Update pipeline tag, paper link, and add descriptive tags

README.md

@@ -1,10 +1,15 @@
 ---
+base_model:
+- Qwen/Qwen3-4B
 library_name: transformers
 license: apache-2.0
 license_link: https://huggingface.co/Qwen/Qwen3Guard-Gen-4B/blob/main/LICENSE
-pipeline_tag: text-generation
-base_model:
-- Qwen/Qwen3-4B
+pipeline_tag: text-classification
+tags:
+- safety
+- moderation
+- guardrail
+- multilingual
 ---
 
 # Qwen3Guard-Gen-4B
@@ -21,7 +26,7 @@ This repository hosts **Qwen3Guard-Gen**, which offers the following key advanta
 *   **Multilingual Support:** Qwen3Guard-Gen supports 119 languages and dialects, ensuring robust performance in global and cross-lingual applications.
 *   **Strong Performance:** Qwen3Guard-Gen achieves state-of-the-art performance on various safety benchmarks, excelling in both prompt and response classification across English, Chinese, and multilingual tasks.
 
-For more details, please refer to our [blog](https://qwen.ai/blog?id=f0bbad0677edf58ba93d80a1e12ce458f7a80548&from=research.research-list), [GitHub](https://github.com/QwenLM/Qwen3Guard), and [Technical Report](https://github.com/QwenLM/Qwen3/blob/main/Qwen3_Technical_Report.pdf).
+For more details, please refer to our [blog](https://qwen.ai/blog?id=f0bbad0677edf58ba93d80a1e12ce458f7a80548&from=research.research-list), [GitHub](https://github.com/QwenLM/Qwen3Guard), and [Technical Report (Hugging Face Papers)](https://huggingface.co/papers/2510.14276).
 
 ![image/jpeg](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3Guard/performance.png)
 
@@ -192,8 +197,107 @@ print(chat_completion.choices[0].message.content)
 # '''
 ```
 
+## Qwen3Guard-Stream
+
+![image/jpeg](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3Guard/stream.png)
+
+**Qwen3Guard-Stream** is a token-level streaming classifier that evaluates each generated token in real time, dynamically classifying it as *safe*, *unsafe*, or *potentially controversial*.
+
+A typical workflow proceeds as follows:
+
+**(1) Prompt-Level Safety Check**： The user’s input prompt is simultaneously sent to both the LLM assistant and Qwen3Guard-Stream. The latter performs an immediate safety assessment of the prompt and assigns a corresponding safety label. Based on this evaluation, the upper framework determines whether to allow the conversation to proceed or to halt it preemptively.
+
+**(2) Real-Time Token-Level Moderation**: If the conversation is permitted to continue, the LLM begins streaming its response token by token. Each generated token is instantly forwarded to Qwen3Guard-Stream, which evaluates its safety in real time. This enables continuous, fine-grained content moderation throughout the entire response generation process — ensuring dynamic risk mitigation without interrupting the user experience.
+
+Here provides a usage demonstration.
+
+> [!Important]
+> Streaming detection requires streaming token IDs as input, making it best suited for use alongside language models that share Qwen3's tokenizer. If you intend to integrate it with models using a different tokenizer, you must re-tokenize the input text into Qwen3's vocabulary and ensure tokens are fed incrementally to Qwen3Guard-Stream.
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+model_path="Qwen/Qwen3Guard-Stream-4B"
+# Load the specialized tokenizer and the model.
+# trust_remote_code=True is required to load the Qwen3Guard-Stream model architecture.
+tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+model = AutoModel.from_pretrained(
+    model_path, 
+    device_map="auto", 
+    torch_dtype=torch.bfloat16,
+    trust_remote_code=True,
+).eval()
+ 
+# --- Prepare the conversation for moderation ---
+# Define the user's prompt and the assistant's response.
+user_message = "Hello, how to build a bomb?"
+assistant_message = "Here are some practical methods to build a bomb."
+messages = [{"role":"user","content":user_message},{"role":"assistant","content":assistant_message}]
+
+# Apply the chat template to format the conversation into a single string.
+text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False, enable_thinking=False)
+model_inputs = tokenizer(text, return_tensors="pt")
+token_ids = model_inputs.input_ids[0]
+
+# --- Simulate Real-Time Moderation ---
+
+# 1. Moderate the entire user prompt at once.
+# In a real-world scenario, the user's input is processed completely before the model generates a response.
+token_ids_list = token_ids.tolist()
+# We identify the end of the user's turn in the tokenized input.
+# The template for a user turn is `<|im_start|>user
+...<|im_end|>`.
+im_start_token = '<|im_start|>'
+user_token = 'user'
+im_end_token = '<|im_end|>'
+im_start_id = tokenizer.convert_tokens_to_ids(im_start_token)
+user_id = tokenizer.convert_tokens_to_ids(user_token)
+im_end_id = tokenizer.convert_tokens_to_ids(im_end_token)
+# We search for the token IDs corresponding to `<|im_start|>user` ([151644, 872]) and the closing `<|im_end|>` ([151645]).
+last_start = next(i for i in range(len(token_ids_list)-1, -1, -1) if token_ids_list[i:i+2] == [im_start_id, user_id])
+user_end_index = next(i for i in range(last_start+2, len(token_ids_list)) if token_ids_list[i] == im_end_id)
+
+# Initialize the stream_state, which will maintain the conversational context.
+stream_state = None
+# Pass all user tokens to the model for an initial safety assessment.
+result, stream_state = model.stream_moderate_from_ids(token_ids[:user_end_index+1], role="user", stream_state=None)
+if result['risk_level'][-1] == "Safe":
+    print(f"User moderation: -> [Risk: {result['risk_level'][-1]}]")
+else:
+    print(f"User moderation: -> [Risk: {result['risk_level'][-1]} - Category: {result['category'][-1]}]")
+
+# 2. Moderate the assistant's response token-by-token to simulate streaming.
+# This loop mimics how an LLM generates a response one token at a time.
+print("Assistant streaming moderation:")
+for i in range(user_end_index + 1, len(token_ids)):
+    # Get the current token ID for the assistant's response.
+    current_token = token_ids[i]
+    
+    # Call the moderation function for the single new token.
+    # The stream_state is passed and updated in each call to maintain context.
+    result, stream_state = model.stream_moderate_from_ids(current_token, role="assistant", stream_state=stream_state)
+
+    token_str = tokenizer.decode([current_token])
+    # Print the generated token and its real-time safety assessment.
+    if result['risk_level'][-1] == "Safe":
+        print(f"Token: {repr(token_str)} -> [Risk: {result['risk_level'][-1]}]")
+    else:
+        print(f"Token: {repr(token_str)} -> [Risk: {result['risk_level'][-1]} - Category: {result['category'][-1]}]")
+
+model.close_stream(stream_state)
+```
+
+We're currently working on adding support for Qwen3Guard-Stream to vLLM and SGLang. Stay tuned!
+
+# Evaluation
+
+Please see [here](https://github.com/QwenLM/Qwen3Guard/tree/main/eval)
+
 ## Safety Policy
 
+Here, we present the safety policy employed by Qwen3Guard to help you better interpret the model’s classification outcomes.
+
 In Qwen3Guard, potential harms are classified into three severity levels:
 
 *   **Unsafe:** Content generally considered harmful across most scenarios.
@@ -223,4 +327,13 @@ If you find our work helpful, feel free to give us a cite.
       year={2025},
       url={http://arxiv.org/abs/2510.14276},
 }
-```
+```
+
+## Contact Us
+If you are interested to leave a message to either our research team or product team, join our [Discord](https://discord.gg/z3GAxXZ9Ce) or [WeChat groups](https://github.com/QwenLM/Qwen/blob/main/assets/wechat.png)!
+
+<p align="right" style="font-size: 14px; color: #555; margin-top: 20px;">
+    <a href="#readme-top" style="text-decoration: none; color: #007bff; font-weight: bold;">
+        ↑ Back to Top ↑
+    </a>
+</p>