README.md
24.8 KB · 617 lines · markdown Raw
1 ---
2 library_name: transformers
3 license: apache-2.0
4 license_link: https://huggingface.co/Qwen/Qwen3.6-27B/blob/main/LICENSE
5 pipeline_tag: image-text-to-text
6 base_model:
7 - Qwen/Qwen3.6-27B
8 tags:
9 - unsloth
10 - qwen
11 - qwen3_5
12 ---
13 # Read our How to [Run Qwen3.6 MTP Guide!](https://unsloth.ai/docs/models/qwen3.6#mtp-guide)
14 <div>
15 <p style="margin: 0 0 0px 0; margin-top: 0px;">
16 <em>See <a href="https://unsloth.ai/docs/basics/unsloth-dynamic-v2.0-gguf">Unsloth Dynamic 2.0 GGUFs</a> for our quantization benchmarks.</em>
17 </p>
18 <div style="display: flex; gap: 5px; align-items: center; margin-bottom: 0px;">
19 <a href="https://github.com/unslothai/unsloth/">
20 <img src="https://github.com/unslothai/unsloth/raw/main/images/unsloth%20new%20logo.png" width="133">
21 </a>
22 <a href="https://discord.gg/unsloth">
23 <img src="https://github.com/unslothai/unsloth/raw/main/images/Discord%20button.png" width="173">
24 </a>
25 <a href="https://unsloth.ai/docs/models/qwen3.6">
26 <img src="https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/images/documentation%20green%20button.png" width="143">
27 </a>
28 </div>
29 <ul style="margin: 0;">
30 <li>MTP enables ~1.5-2x faster inference with no accuracy loss.
31 <li>You can now run Qwen3.6 MTP GGUFs in <a href="https://unsloth.ai/docs/new/studio">Unsloth Studio</a>
32 <li>Unsloth Studio auto sets the ideal MTP settings for your hardware (Mac, CPU, GPU):
33
34 <img width="600" alt="qwen3.6 mtp in unsloth studio" src="https://cdn-uploads.huggingface.co/production/uploads/62ecdc18b72a69615d6bd857/wZH__3vbqI29xJyMyZDjh.gif" />
35
36 ### To run in llama.cpp:
37
38 ```bash
39 apt-get update
40 apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
41 git clone https://github.com/ggml-org/llama.cpp
42 cmake llama.cpp -B llama.cpp/build \
43 -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
44 cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
45 cp llama.cpp/build/bin/llama-* llama.cpp
46 ```
47
48 ```bash
49 export LLAMA_CACHE="unsloth/Qwen3.6-27B-MTP-GGUF"
50 ./llama.cpp/llama-server \
51 -hf unsloth/Qwen3.6-27B-MTP-GGUF:UD-Q4_K_XL \
52 -ngl 99 -c 8192 -fa on -np 1 \
53 --spec-type draft-mtp --spec-draft-n-max 2
54 ```
55 Set `-DGGML_CUDA=OFF` for CPU/Metal. `-np > 1` and `--mmproj` are not yet supported with MTP.
56 </div>
57
58 ---
59 - Developer Role Support so Qwen3.6 can work in <a href="https://unsloth.ai/docs/basics/codex">Codex</a>, OpenCode and more!
60 - Qwen3.6 can now be run and fine-tuned in <a href="https://unsloth.ai/docs/new/studio">Unsloth Studio</a>. <a href="https://unsloth.ai/docs/models/qwen3.6">Read our guide</a>.
61 - Tool calling improvements: Makes parsing nested objects to make tool calling succeed more.
62 ---
63
64 # Qwen3.6-27B
65
66 <img width="400px" src="https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.6/logo.png">
67
68 [![Qwen Chat](https://img.shields.io/badge/%F0%9F%92%9C%EF%B8%8F%20Qwen%20Chat%20-536af5)](https://chat.qwen.ai)
69
70 > [!Note]
71 > This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format.
72 >
73 > These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, KTransformers, etc.
74
75 Following the February release of the Qwen3.5 series, we're pleased to share the first open-weight variant of Qwen3.6. Built on direct feedback from the community, Qwen3.6 prioritizes stability and real-world utility, offering developers a more intuitive, responsive, and genuinely productive coding experience.
76
77 ## Qwen3.6 Highlights
78
79 This release delivers substantial upgrades, particularly in
80
81 - **Agentic Coding:** the model now handles frontend workflows and repository-level reasoning with greater fluency and precision.
82 - **Thinking Preservation:** we've introduced a new option to retain reasoning context from historical messages, streamlining iterative development and reducing overhead.
83
84 ![Benchmark Results](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3.6/Figures/qwen3.6_27b_score.png)
85
86 For more details, please refer to our blog post [Qwen3.6-27B](https://qwen.ai/blog?id=qwen3.6-27b).
87
88 ## Model Overview
89
90 - Type: Causal Language Model with Vision Encoder
91 - Training Stage: Pre-training & Post-training
92 - Language Model
93 - Number of Parameters: 27B
94 - Hidden Dimension: 5120
95 - Token Embedding: 248320 (Padded)
96 - Number of Layers: 64
97 - Hidden Layout: 16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
98 - Gated DeltaNet:
99 - Number of Linear Attention Heads: 48 for V and 16 for QK
100 - Head Dimension: 128
101 - Gated Attention:
102 - Number of Attention Heads: 24 for Q and 4 for KV
103 - Head Dimension: 256
104 - Rotary Position Embedding Dimension: 64
105 - Feed Forward Network:
106 - Intermediate Dimension: 17408
107 - LM Output: 248320 (Padded)
108 - MTP: trained with multi-steps
109 - Context Length: 262,144 natively and extensible up to 1,010,000 tokens.
110
111
112 ## Benchmark Results
113
114 ### Language
115
116 ### Vision Language
117
118
119 ## Quickstart
120
121 For streamlined integration, we recommend using Qwen3.6 via APIs. Below is a guide to use Qwen3.6 via OpenAI-compatible API.
122
123 ### Serving Qwen3.6
124
125 Qwen3.6 can be served via APIs with popular inference frameworks.
126 In the following, we show example commands to launch OpenAI-Compatible API servers for Qwen3.6 models.
127
128 > [!Important]
129 > Inference efficiency and throughput vary significantly across frameworks.
130 > We recommend using the latest framework versions to ensure optimal performance and compatibility.
131 > For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, KTransformers or vLLM are strongly recommended.
132
133 > [!Important]
134 > The model has a default context length of 262,144 tokens.
135 > If you encounter out-of-memory (OOM) errors, consider reducing the context window.
136 > However, because Qwen3.6 leverages extended context for complex tasks, we advise maintaining a context length of at least 128K tokens to preserve thinking capabilities.
137
138 #### SGLang
139
140 [SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models.
141 `sglang>=0.5.10` is recommended for Qwen3.6, which can be installed using the following command in a fresh environment:
142 ```shell
143 uv pip install sglang[all]
144 ```
145 See [its documentation](https://docs.sglang.ai/get_started/install.html) for more details.
146
147 The following will create API endpoints at `http://localhost:8000/v1`:
148
149 - **Standard Version**: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
150
151 ```shell
152 python -m sglang.launch_server --model-path Qwen/Qwen3.6-27B --port 8000 --tp-size 8 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3
153 ```
154
155 - **Tool Use**: To support tool use, you can use the following command.
156
157 ```shell
158 python -m sglang.launch_server --model-path Qwen/Qwen3.6-27B --port 8000 --tp-size 8 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder
159 ```
160
161 - **Multi-Token Prediction (MTP)**: The following command is recommended for MTP:
162
163 ```shell
164 python -m sglang.launch_server --model-path Qwen/Qwen3.6-27B --port 8000 --tp-size 8 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --speculative-algo NEXTN --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4
165 ```
166
167 For detailed deployment guide, see the [SGLang Qwen3.5 Cookbook](https://lmsysorg.mintlify.app/cookbook/llm/Qwen/Qwen3.5).
168
169 #### vLLM
170
171 [vLLM](https://github.com/vllm-project/vllm) is a high-throughput and memory-efficient inference and serving engine for LLMs.
172 `vllm>=0.19.0` is recommended for Qwen3.6, which can be installed using the following command in a fresh environment:
173 ```shell
174 uv pip install vllm --torch-backend=auto
175 ```
176 See [its documentation](https://docs.vllm.ai/en/stable/getting_started/installation/index.html) for more details.
177
178
179 The following will create API endpoints at `http://localhost:8000/v1`:
180
181 - **Standard Version**: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
182
183 ```shell
184 vllm serve Qwen/Qwen3.6-27B --port 8000 --tensor-parallel-size 8 --max-model-len 262144 --reasoning-parser qwen3
185 ```
186
187 - **Tool Call**: To support tool use, you can use the following command.
188
189 ```shell
190 vllm serve Qwen/Qwen3.6-27B --port 8000 --tensor-parallel-size 8 --max-model-len 262144 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder
191 ```
192
193 - **Multi-Token Prediction (MTP)**: The following command is recommended for MTP:
194
195 ```shell
196 vllm serve Qwen/Qwen3.6-27B --port 8000 --tensor-parallel-size 8 --max-model-len 262144 --reasoning-parser qwen3 --speculative-config '{"method":"qwen3_next_mtp","num_speculative_tokens":2}'
197 ```
198
199 - **Text-Only**: The following command skips the vision encoder and multimodal profiling to free up memory for additional KV cache:
200
201 ```shell
202 vllm serve Qwen/Qwen3.6-27B --port 8000 --tensor-parallel-size 8 --max-model-len 262144 --reasoning-parser qwen3 --language-model-only
203 ```
204
205 For detailed deployment guide, see the [vLLM Qwen3.5 Recipe](https://docs.vllm.ai/projects/recipes/en/latest/Qwen/Qwen3.5.html).
206
207 #### KTransformers
208
209 [KTransformers](https://github.com/kvcache-ai/ktransformers) is a flexible framework for experiencing cutting-edge LLM inference optimizations with CPU-GPU heterogeneous computing.
210 For running Qwen3.6 with KTransformers, see the [KTransformers Deployment Guide](https://github.com/kvcache-ai/ktransformers/blob/main/doc/en/Qwen3.5.md).
211
212 #### Hugging Face Transformers
213
214 Hugging Face Transformers contains a _lightweight_ server which can be used for quick testing and moderate load deployment.
215 The latest `transformers` is required for Qwen3.6:
216 ```shell
217 pip install "transformers[serving]"
218 ```
219 See [its documentation](https://huggingface.co/docs/transformers/main/serving) for more details. Please also make sure torchvision and pillow are installed.
220
221 Then, run `transformers serve` to launch a server with API endpoints at `http://localhost:8000/v1`; it will place the model on accelerators if available:
222 ```shell
223 transformers serve Qwen/Qwen3.6-27B --port 8000 --continuous-batching
224 ```
225
226 ### Using Qwen3.6 via the Chat Completions API
227
228 The chat completions API is accessible via standard HTTP requests or OpenAI SDKs.
229 Here, we show examples using the OpenAI Python SDK.
230
231 Before starting, make sure it is installed and the API key and the API base URL is configured, e.g.:
232 ```shell
233 pip install -U openai
234
235 # Set the following accordingly
236 export OPENAI_BASE_URL="http://localhost:8000/v1"
237 export OPENAI_API_KEY="EMPTY"
238 ```
239
240 > [!Tip]
241 > We recommend using the following set of sampling parameters for generation
242 > - Thinking mode for general tasks: `temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0`
243 > - Thinking mode for precise coding tasks (e.g. WebDev): `temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0`
244 > - Instruct (or non-thinking) mode: `temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
245 >
246 > Please note that the support for sampling parameters varies according to inference frameworks.
247
248 > [!Important]
249 > Qwen3.6 models operate in thinking mode by default, generating thinking content signified by `<think>\n...</think>\n\n` before producing the final responses.
250 > To disable thinking content and obtain direct response, refer to the examples [here](#instruct-or-non-thinking-mode).
251
252
253 #### Text-Only Input
254
255 ```python
256 from openai import OpenAI
257 # Configured by environment variables
258 client = OpenAI()
259
260 messages = [
261 {"role": "user", "content": "Type \"I love Qwen3.6\" backwards"},
262 ]
263
264 chat_response = client.chat.completions.create(
265 model="Qwen/Qwen3.6-27B",
266 messages=messages,
267 max_tokens=81920,
268 temperature=1.0,
269 top_p=0.95,
270 presence_penalty=0.0,
271 extra_body={
272 "top_k": 20,
273 },
274 )
275 print("Chat response:", chat_response)
276 ```
277
278
279 #### Image Input
280
281 ```python
282 from openai import OpenAI
283 # Configured by environment variables
284 client = OpenAI()
285
286 messages = [
287 {
288 "role": "user",
289 "content": [
290 {
291 "type": "image_url",
292 "image_url": {
293 "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/CI_Demo/mathv-1327.jpg"
294 }
295 },
296 {
297 "type": "text",
298 "text": "The centres of the four illustrated circles are in the corners of the square. The two big circles touch each other and also the two little circles. With which factor do you have to multiply the radii of the little circles to obtain the radius of the big circles?\nChoices:\n(A) $\\frac{2}{9}$\n(B) $\\sqrt{5}$\n(C) $0.8 \\cdot \\pi$\n(D) 2.5\n(E) $1+\\sqrt{2}$"
299 }
300 ]
301 }
302 ]
303
304 response = client.chat.completions.create(
305 model="Qwen/Qwen3.6-27B",
306 messages=messages,
307 max_tokens=81920,
308 temperature=1.0,
309 top_p=0.95,
310 presence_penalty=0.0,
311 extra_body={
312 "top_k": 20,
313 },
314 )
315 print("Chat response:", chat_response)
316 ```
317
318 #### Video Input
319
320 ```python
321 from openai import OpenAI
322 # Configured by environment variables
323 client = OpenAI()
324
325 messages = [
326 {
327 "role": "user",
328 "content": [
329 {
330 "type": "video_url",
331 "video_url": {
332 "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/video/N1cdUjctpG8.mp4"
333 }
334 },
335 {
336 "type": "text",
337 "text": "How many porcelain jars were discovered in the niches located in the primary chamber of the tomb?"
338 }
339 ]
340 }
341 ]
342
343 # When vLLM is launched with `--media-io-kwargs '{"video": {"num_frames": -1}}'`,
344 # video frame sampling can be configured via `extra_body` (e.g., by setting `fps`).
345 # This feature is currently supported only in vLLM.
346 #
347 # By default, `fps=2` and `do_sample_frames=True`.
348 # With `do_sample_frames=True`, you can customize the `fps` value to set your desired video sampling rate.
349 response = client.chat.completions.create(
350 model="Qwen/Qwen3.6-27B",
351 messages=messages,
352 max_tokens=81920,
353 temperature=1.0,
354 top_p=0.95,
355 presence_penalty=0.0,
356 extra_body={
357 "top_k": 20,
358 "mm_processor_kwargs": {"fps": 2, "do_sample_frames": True},
359 },
360 )
361
362 print("Chat response:", chat_response)
363 ```
364
365
366 #### Instruct (or Non-Thinking) Mode
367
368 > [!Important]
369 > Qwen3.6 does not officially support the soft switch of Qwen3, i.e., `/think` and `/nothink`.
370
371 Qwen3.6 will think by default before response.
372 You can obtain direct response from the model without thinking by configuring the API parameters.
373 For example,
374 ```python
375 from openai import OpenAI
376 # Configured by environment variables
377 client = OpenAI()
378
379 messages = [
380 {
381 "role": "user",
382 "content": [
383 {
384 "type": "image_url",
385 "image_url": {
386 "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.6/demo/RealWorld/RealWorld-04.png"
387 }
388 },
389 {
390 "type": "text",
391 "text": "Where is this?"
392 }
393 ]
394 }
395 ]
396
397 chat_response = client.chat.completions.create(
398 model="Qwen/Qwen3.6-27B",
399 messages=messages,
400 max_tokens=32768,
401 temperature=1.0,
402 top_p=1.0,
403 presence_penalty=2.0,
404 extra_body={
405 "top_k": 40,
406 "chat_template_kwargs": {"enable_thinking": False},
407 },
408 )
409 print("Chat response:", chat_response)
410 ```
411
412 > [!Note]
413 > If you are using APIs from Alibaba Cloud Model Studio, in addition to changing `model`, please use `"enable_thinking": False` instead of `"chat_template_kwargs": {"enable_thinking": False}`.
414
415 #### Preserve Thinking
416
417 By default, only the thinking blocks generated in handling the latest user message is retained, resulting in a pattern commonly as interleaved thinking.
418 Qwen3.6 has been additionally trained to preserve and leverage thinking traces from historical messages.
419 You can enable this behavior by setting the `preserve_thinking` option:
420 ```python
421 from openai import OpenAI
422 # Configured by environment variables
423 client = OpenAI()
424
425 messages = [...]
426
427 chat_response = client.chat.completions.create(
428 model="Qwen/Qwen3.6-27B",
429 messages=messages,
430 max_tokens=32768,
431 temperature=0.6,
432 top_p=0.95,
433 presence_penalty=0.0,
434 extra_body={
435 "top_k": 20,
436 "chat_template_kwargs": {"preserve_thinking": True},
437 },
438 )
439 print("Chat response:", chat_response)
440 ```
441
442 > [!Note]
443 > If you are using APIs from Alibaba Cloud Model Studio, in addition to changing `model`, please use `"preserve_thinking": True` instead of `"chat_template_kwargs": {"preserve_thinking": False}`.
444
445
446 This capability is particularly beneficial for agent scenarios, where maintaining full reasoning context can enhance decision consistency and, in many cases, reduce overall token consumption by minimizing redundant reasoning. Additionally, it can improve KV cache utilization, optimizing inference efficiency in both thinking and non-thinking modes.
447
448
449 ## Agentic Usage
450
451 Qwen3.6 excels in tool calling capabilities.
452
453 ### Qwen-Agent
454
455 We recommend using [Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) to quickly build Agent applications with Qwen3.6.
456
457 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.
458 ```python
459 import os
460 from qwen_agent.agents import Assistant
461
462 # Define LLM
463 # Using Alibaba Cloud Model Studio
464 llm_cfg = {
465 # Use the OpenAI-compatible model service provided by DashScope:
466 'model': 'Qwen3.6-27B',
467 'model_type': 'qwenvl_oai',
468 'model_server': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
469 'api_key': os.getenv('DASHSCOPE_API_KEY'),
470
471 'generate_cfg': {
472 'use_raw_api': True,
473 # When using Dash Scope OAI API, pass the parameter of whether to enable thinking mode in this way
474 'extra_body': {
475 'enable_thinking': True,
476 'preserve_thinking': True,
477 },
478 },
479 }
480
481 # Using OpenAI-compatible API endpoint.
482 # functionality of the deployment frameworks and let Qwen-Agent automate the related operations.
483 #
484 # llm_cfg = {
485 # # Use your own model service compatible with OpenAI API by vLLM/SGLang:
486 # 'model': 'Qwen/Qwen3.6-27B',
487 # 'model_type': 'qwenvl_oai',
488 # 'model_server': 'http://localhost:8000/v1', # api_base
489 # 'api_key': 'EMPTY',
490 #
491 # 'generate_cfg': {
492 # 'use_raw_api': True,
493 # # When using vLLM/SGLang OAI API, pass the parameter of whether to enable thinking mode in this way
494 # 'extra_body': {
495 # 'chat_template_kwargs': {'enable_thinking': True, 'preserve_thinking': True}
496 # },
497 # },
498 # }
499
500 # Define Tools
501 tools = [
502 {'mcpServers': { # You can specify the MCP configuration file
503 "filesystem": {
504 "command": "npx",
505 "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/xxxx/Desktop"]
506 }
507 }
508 }
509 ]
510
511 # Define Agent
512 bot = Assistant(llm=llm_cfg, function_list=tools)
513
514 # Streaming generation
515 messages = [{'role': 'user', 'content': 'Help me organize my desktop.'}]
516 for responses in bot.run(messages=messages):
517 pass
518 print(responses)
519
520 # Streaming generation
521 messages = [{'role': 'user', 'content': 'Develop a dog website and save it on the desktop'}]
522 for responses in bot.run(messages=messages):
523 pass
524 print(responses)
525 ```
526
527 ### Qwen Code
528
529
530 [Qwen Code](https://github.com/QwenLM/qwen-code) is an open-source AI agent for the terminal, optimized for Qwen models. It helps you understand large codebases, automate tedious work, and ship faster.
531
532 For more information, please refer to [Qwen Code](https://qwenlm.github.io/qwen-code-docs/).
533
534 ## Processing Ultra-Long Texts
535
536 Qwen3.6 natively supports context lengths of up to 262,144 tokens.
537 For long-horizon tasks where the total length (including both input and output) exceeds this limit, we recommend using RoPE scaling techniques to handle long texts effectively., e.g., YaRN.
538
539 YaRN is currently supported by several inference frameworks, e.g., `transformers`, `vllm`, `ktransformers` and `sglang`.
540 In general, there are two approaches to enabling YaRN for supported frameworks:
541
542 - Modifying the model configuration file:
543 In the `config.json` file, change the `rope_parameters` fields in `text_config` to:
544 ```json
545 {
546 "mrope_interleaved": true,
547 "mrope_section": [
548 11,
549 11,
550 10
551 ],
552 "rope_type": "yarn",
553 "rope_theta": 10000000,
554 "partial_rotary_factor": 0.25,
555 "factor": 4.0,
556 "original_max_position_embeddings": 262144,
557 }
558 ```
559
560 - Passing command line arguments:
561
562 For `vllm`, you can use
563 ```shell
564 VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve ... --hf-overrides '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --max-model-len 1010000
565 ```
566
567 For `sglang` and `ktransformers`, you can use
568 ```shell
569 SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server ... --json-model-override-args '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --context-length 1010000
570 ```
571
572 > [!NOTE]
573 > 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.**
574 > We advise modifying the `rope_parameters` configuration only when processing long contexts is required.
575 > It is also recommended to modify the `factor` as needed. For example, if the typical context length for your application is 524,288 tokens, it would be better to set `factor` as 2.0.
576
577 ## Best Practices
578
579 To achieve optimal performance, we recommend the following settings:
580
581 1. **Sampling Parameters**:
582 - We suggest using the following sets of sampling parameters depending on the mode and task type:
583 - **Thinking mode for general tasks**:
584 `temperature=1.0`, `top_p=0.95`, `top_k=20`, `min_p=0.0`, `presence_penalty=0.0`, `repetition_penalty=1.0`
585 - **Thinking mode for precise coding tasks (e.g., WebDev)**:
586 `temperature=0.6`, `top_p=0.95`, `top_k=20`, `min_p=0.0`, `presence_penalty=0.0`, `repetition_penalty=1.0`
587 - **Instruct (or non-thinking) mode**:
588 `temperature=0.7`, `top_p=0.80`, `top_k=20`, `min_p=0.0`, `presence_penalty=1.5`, `repetition_penalty=1.0`
589 - 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.
590
591 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 81,920 tokens. This provides the model with sufficient space to generate detailed and comprehensive responses, thereby enhancing its overall performance.
592
593 3. **Standardize Output Format**: We recommend using prompts to standardize model outputs when benchmarking.
594 - **Math Problems**: Include "Please reason step by step, and put your final answer within \boxed{}." in the prompt.
595 - **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"`."
596
597 4. **Long Video Understanding**: To optimize inference efficiency for plain text and images, the `size` parameter in the released `video_preprocessor_config.json` is conservatively configured. It is recommended to set the `longest_edge` parameter in the video_preprocessor_config file to 469,762,048 (corresponding to 224k video tokens) to enable higher frame-rate sampling for hour-scale videos and thereby achieve superior performance. For example,
598 ```json
599 {"longest_edge": 469762048, "shortest_edge": 4096}
600 ```
601
602 Alternatively, override the default values via engine startup parameters. For implementation details, refer to: [vLLM](https://github.com/vllm-project/vllm/pull/34330) / [SGLang](https://github.com/sgl-project/sglang/pull/18467).
603
604
605 ### Citation
606
607 If you find our work helpful, feel free to give us a cite.
608
609 ```bibtex
610 @misc{Qwen3.6-27B,
611 title = {{Qwen3.6-27B}: Flagship-Level Coding in a {27B} Dense Model},
612 author = {{Qwen Team}},
613 month = {April},
614 year = {2026},
615 url = {https://qwen.ai/blog?id=qwen3.6-27b}
616 }
617 ```