Upload 66 files

.gitattributes

@@ -35,3 +35,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 eval/output/ARCAGI-Qwen3-235B-A22B-Instruct-2507_details.jsonl filter=lfs diff=lfs merge=lfs -text
 eval/output/ARCAGI-Qwen3-235B-A22B-Instruct-2507.jsonl filter=lfs diff=lfs merge=lfs -text
+docs/source/assets/qwen-openllm-ui-demo.png filter=lfs diff=lfs merge=lfs -text

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/README.md

@@ -0,0 +1,50 @@
+# Qwen Documentation
+
+This is the source of the documentation at <https://qwen.readthedocs.io>.
+
+## Quick Start
+
+We use `sphinx` to manage the documentation and use the `furo` theme.
+To get started, simply run
+```bash
+pip install -r requirements-docs.txt
+```
+
+Then run `make html` or `sphinx-build -M html source build` and it will compile the docs and put it under the `build/html` directory.
+
+
+## Translation
+
+The documentation is available in both English and Simplified Chinese. We use
+`sphinx-intl` to work with Sphinx translation flow, following [this article](https://www.sphinx-doc.org/en/master/usage/advanced/intl.html).
+
+You need to install the Python package `sphinx-intl` before starting.
+
+1. After updating the English documentation, run `make gettext`, and the pot files will be placed in the `build/gettext` directory. `make gettext` can be slow if the doc is long.
+
+2. Use the generated pot files to update the po files:
+    ```bash
+    sphinx-intl update -p build/gettext -l zh_CN -w 0
+    ```
+
+3. Translate po files at `locales\zh_CN\LC_MESSAGES`. Pay attention to fuzzy matches (messages after `#, fuzzy`). Please be careful not to break reST notation.
+
+4. Build translated document: `make -e SPHINXOPTS="-D language='zh_CN'" html` or `sphinx-build -M html source build -D language=zh_CN`
+
+## Auto Build
+
+```bash
+pip install sphinx-autobuild
+```
+
+To autobuild the default version:
+```bash
+sphinx-autobuild source build/html
+```
+
+To autobuild the translated version:
+```bash
+sphinx-autobuild source build/html -D language=zh_CN --watch locales/zh_CN
+```
+
+By default, the doc is at `http://127.0.0.1:8000`

docs/locales/zh_CN/LC_MESSAGES/deployment/dstack.po

@@ -0,0 +1,169 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-07-28 10:50+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/deployment/dstack.rst:2 dfac4ff2e6e7425290c3cd12a2de701c
+msgid "dstack"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:4 2438a502621e4637bac3fa19171a5e53
+msgid "`dstack <https://github.com/dstackai/dstack>`__ is an open-source alternative to Kubernetes and Slurm, designed to simplify GPU allocation and AI workload orchestration for ML teams across top clouds, on-prem clusters, and accelerators."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:7 1ff23a34c6ec4236b5b9d73e7d1d6241
+msgid "Prerequisites"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:8 5f95e757ef4f4cba85ce773801be340d
+msgid "Before you start, install dstack by following the `installation instructions <https://dstack.ai/docs/installation/>`__. Once dstack server is up, you can initialize your workspace as shown below:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:17 ccf222149a8d43d2bf716c2a39956d77
+msgid "Deploy Qwen3-30B-A3B"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:19 45b4f1af973546ab9651757fcb13b9e9
+msgid "Deploy ``Qwen3-30B-A3B`` on instances available with cloud providers configured in your ``~/.dstack/server/config.yml`` file."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:21 8565ac9fdb394e32b10269087dfc18c7
+msgid "You can use ``SgLang``, ``TGI`` or ``vLLM`` to serve the model. Here we use ``SgLang`` as an example."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:23 9ed2f6fbcd3f408fa0d34a3199709122
+msgid "Create a `service <https://dstack.ai/docs/concepts/services/>`__ configuration file named ``serve-30b.dstack.yml`` with the following content:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:49 0973beefd01b4c8081a5d4d2113dc7c4
+msgid "For other inference backends such as vLLM or TGI, visit the `dstack Inference Examples <https://dstack.ai/examples/#inference>`__ documentation."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:51 826cb0f7e041443db0a8382fd918e3b7
+msgid "Go ahead and apply the service configuration:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:58 d16702dc64694eeaba319277a3ab4a03
+msgid "Access the Service"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:60 7edacaff1d53424190978e77cd557190
+msgid "After the service is successfully deployed, you can access the service's endpoint in the following ways:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst e83ef74bbe7e4e5eaf5f7a10773c9d46
+msgid "CURL"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:66 9f51986795d3414f96dd65790157e723
+msgid "Access through service endpoint at ``<dstack server URL>/proxy/services/<project name>/<run name>/``"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:84 9a8130ecf20c4e42ac9994e2145bfcec
+msgid "When starting the dstack server, an admin token is automatically generated:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst 94c7a3424a19432ebfc0a98eb0725d42
+msgid "Chat UI"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:93 5c7bb346537b456da005af909a333b09
+msgid "Access through dstack's Chat UI at ``<dstack server URL>/projects/<project name>/models/<run name>/``"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst 11cd02dcfb214277988135c49b839775
+msgid "Gateway"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:102 e1e19487dd6f4ae8b12f728b39bef5d6
+msgid "Running services for development purposes doesn't require setting up a gateway."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:104 bf94ccabbeaa491c9827e983e7f9950a
+msgid "However, you'll need a gateway in the following cases:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:106 15278aaab8214461b9fa17c95549f1cc
+msgid "To use auto-scaling or rate limits"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:107 5cf53dda95e24cfda6c3a62e32632461
+msgid "To enable HTTPS for the endpoint and map it to your domain"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:108 b91006984e1b42298a79360df47c942e
+msgid "If your service requires WebSockets"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:109 a0ecebb158d048b7bb366e166509ab31
+msgid "If your service cannot work with a path prefix"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:111 df78b814ee044508979d32d16c6fa418
+msgid "For detailed information about gateway configuration and usage, refer to the `dstack documentation on gateways <https://dstack.ai/docs/concepts/gateways/>`__."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:114 da366f09f068481898788356a2720d00
+msgid "Replicas and Auto Scaling"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:116 1814b084b9344951b8fda9bc315ff652
+msgid "You can auto scale the service by specifying additional configurations in the ``serve-30b.dstack.yml``."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:118 a2ca8abfc03b4008a679e44ed42a6224
+msgid "Set ``replicas: min..max`` to define the minimum and maximum number of replicas"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:119 8cfabedabf1f4d64bb6708f07852e3f8
+msgid "Configure ``scaling`` rules to determine when to scale up or down"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:121 fcd56774d834404fa6561d65b46afe74
+msgid "Below is a complete configuration example with auto-scaling enabled:"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:153 dd2ed9086cf5424ab14b641044da1279
+msgid "The scaling property requires a gateway to be set up."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:156 3986bd1e05de49048a64cdf4d6782f8a
+msgid "See also"
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:157 7dc365aeac714fa5ba2989f0cb1c7e9c
+msgid "**Fleets**: Create cloud and on-prem clusters using `Fleets <https://dstack.ai/docs/concepts/fleets/>`__."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:158 5e647ecf87164fccbe9589e3d9c540b9
+msgid "**Dev Environments**: Experiment and test before deploying to production using `Dev Environments <https://dstack.ai/docs/concepts/dev-environments/>`__."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:159 36774ccbc7e6446a9bfcdf029e13fe58
+msgid "**Tasks**: Schedule single node or distributed training using `Tasks <https://dstack.ai/docs/concepts/tasks/>`__."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:160 72cc0103fb1e4c82ae284fa1e3633bc4
+msgid "**Services**: Deploy models as secure, auto-scaling OpenAI-compatible endpoints using `Services <https://dstack.ai/docs/concepts/services/>`__."
+msgstr ""
+
+#: ../../source/deployment/dstack.rst:161 ba9f121d4831485e84c3cf922edc3982
+msgid "**Metrics**: Monitor performance with automatically tracked metrics via CLI or UI using `Metrics <https://dstack.ai/docs/guides/metrics/>`__."
+msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/deployment/openllm.po

@@ -0,0 +1,112 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/deployment/openllm.rst:2 986ea00cb5af4a0d82f974ed79a82430
+msgid "OpenLLM"
+msgstr "OpenLLM"
+
+#: ../../Qwen/source/deployment/openllm.rst:5 78be03fbdccb429892b03bf84596411b
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/deployment/openllm.rst:7 a001f11d1c5440188121d20b3baf59db
+msgid "OpenLLM allows developers to run Qwen2.5 models of different sizes as OpenAI-compatible APIs with a single command. It features a built-in chat UI, state-of-the-art inference backends, and a simplified workflow for creating enterprise-grade cloud deployment with Qwen2.5. Visit `the OpenLLM repository <https://github.com/bentoml/OpenLLM/>`_ to learn more."
+msgstr "OpenLLM 允许开发者通过一个命令运行不同大小的 Qwen2.5 模型，提供 OpenAI 兼容的 API。它具有内置的聊天 UI，先进的推理后端，以及简化的工作流程来使用 Qwen2.5 创建企业级云部署。访问 `OpenLLM 仓库 <https://github.com/bentoml/OpenLLM/>`_ 了解更多信息。"
+
+#: ../../Qwen/source/deployment/openllm.rst:10 229f89c3be65442bbe15905d75a0d13d
+msgid "Installation"
+msgstr "安装"
+
+#: ../../Qwen/source/deployment/openllm.rst:12 79421f700fbc426cb6ce9841aff67503
+msgid "Install OpenLLM using ``pip``."
+msgstr "使用 ``pip`` 安装 OpenLLM。"
+
+#: ../../Qwen/source/deployment/openllm.rst:18 69cfd6fe2e274173ad4065be91b71472
+msgid "Verify the installation and display the help information:"
+msgstr "验证安装并显示帮助信息："
+
+#: ../../Qwen/source/deployment/openllm.rst:25 503cae99b14c4ef4b322b8ec0bd2d32d
+msgid "Quickstart"
+msgstr "快速开始"
+
+#: ../../Qwen/source/deployment/openllm.rst:27 0ea788c801404d8780404611c87644b0
+msgid "Before you run any Qwen2.5 model, ensure your model repository is up to date by syncing it with OpenLLM's latest official repository."
+msgstr "在运行任何 Qwen2.5 模型之前，确保您的模型仓库与 OpenLLM 的最新官方仓库同步。"
+
+#: ../../Qwen/source/deployment/openllm.rst:33 8852ff46ecdb45b2bfc9885bbfaacb02
+msgid "List the supported Qwen2.5 models:"
+msgstr "列出支持的 Qwen2.5 模型："
+
+#: ../../Qwen/source/deployment/openllm.rst:39 3e4f6c11396844adb30d4e5812339484
+msgid "The results also display the required GPU resources and supported platforms:"
+msgstr "结果还会显示所需的 GPU 资源和支持的平台："
+
+#: ../../Qwen/source/deployment/openllm.rst:57 ac4c0db02f5249d5882940820779db9a
+msgid "To start a server with one of the models, use ``openllm serve`` like this:"
+msgstr "要使用其中一个模型来启动服务器，请使用 ``openllm serve`` 命令，例如："
+
+#: ../../Qwen/source/deployment/openllm.rst:63 0a1d3ec35c684e3bb3e971c916aa9be7
+msgid "By default, the server starts at ``http://localhost:3000/``."
+msgstr "默认情况下，服务器启动在 http://localhost:3000/。"
+
+#: ../../Qwen/source/deployment/openllm.rst:66 2e787de9a62f4342bdf8f88ee0df5379
+msgid "Interact with the model server"
+msgstr "与模型服务器交互"
+
+#: ../../Qwen/source/deployment/openllm.rst:68 b22802ad9027458bb30ea0da665fea36
+msgid "With the model server up and running, you can call its APIs in the following ways:"
+msgstr "服务器运行后，可以通过以下方式调用其 API："
+
+#: ../../Qwen/source/deployment/openllm.rst 76214ea690094930899d6f2eddcc1454
+msgid "CURL"
+msgstr "CURL"
+
+#: ../../Qwen/source/deployment/openllm.rst:74 42775a3df58f474782d29f2f82707bd9
+msgid "Send an HTTP request to its ``/generate`` endpoint via CURL:"
+msgstr "通过 CURL 向其 ``/generate`` 端点发送 HTTP 请求："
+
+#: ../../Qwen/source/deployment/openllm.rst 4f0ff3eee2ab49dda5a72bd611a9d45e
+msgid "Python client"
+msgstr "Python 客户端"
+
+#: ../../Qwen/source/deployment/openllm.rst:91 ce2e11a46e434798947b1e74ce82a19c
+msgid "Call the OpenAI-compatible endpoints with frameworks and tools that support the OpenAI API protocol. Here is an example:"
+msgstr "使用支持 OpenAI API 协议的框架和工具来调用。例如："
+
+#: ../../Qwen/source/deployment/openllm.rst 107921d1a855430ca70c8c163d37c7f2
+msgid "Chat UI"
+msgstr "聊天 UI"
+
+#: ../../Qwen/source/deployment/openllm.rst:118
+#: b92df2759cd54c2b8316e2a160ede656
+msgid "OpenLLM provides a chat UI at the ``/chat`` endpoint for the LLM server at http://localhost:3000/chat."
+msgstr "OpenLLM 为 LLM 服务器提供的聊天 UI 位于 ``/chat`` 端点���地址为 http://localhost:3000/chat。"
+
+#: ../../Qwen/source/deployment/openllm.rst:123
+#: 0d3fa679178f443caf9c87623001be1f
+msgid "Model repository"
+msgstr "模型仓库"
+
+#: ../../Qwen/source/deployment/openllm.rst:125
+#: 54d6a9bdcc064aeb95a23b60d3d575ab
+msgid "A model repository in OpenLLM represents a catalog of available LLMs. You can add your own repository to OpenLLM with custom Qwen2.5 variants for your specific needs. See our `documentation to learn details <https://github.com/bentoml/OpenLLM?tab=readme-ov-file#model-repository>`_."
+msgstr "OpenLLM 中的模型仓库表示可用的 LLM 目录。您可以为 OpenLLM 添加自定义的 Qwen2.5 模型仓库，以满足您的特定需求。请参阅 `我们的文档 <https://github.com/bentoml/OpenLLM?tab=readme-ov-file#model-repository>`_ 了解详细信息。"
+

docs/locales/zh_CN/LC_MESSAGES/deployment/sglang.po

@@ -0,0 +1,198 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-05-07 19:51+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/deployment/sglang.md:1 e05607ecb34c453aa8f805ea62edf34f
+msgid "SGLang"
+msgstr ""
+
+#: ../../source/deployment/sglang.md:3 54dde79baa664197a2f3a5bb52383b70
+msgid "[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models."
+msgstr "[SGLang](https://github.com/sgl-project/sglang) 是一个用于大型语言模型和视觉语言模型的快速推理框架。"
+
+#: ../../source/deployment/sglang.md:5 1ae08e7b1ffc4f0290eefb616eac1b63
+msgid "To learn more about SGLang, please refer to the [documentation](https://docs.sglang.ai/)."
+msgstr "要了解更多关于 SGLang 的信息，请参阅[官方文档](https://docs.sglang.ai/)。"
+
+#: ../../source/deployment/sglang.md:7 927f96387c844f79a7cfa592e64fc1b2
+msgid "Environment Setup"
+msgstr "环境配置"
+
+#: ../../source/deployment/sglang.md:9 e04e805b59364e96a366fa088fae04e4
+msgid "By default, you can install `sglang` with pip in a clean environment:"
+msgstr "默认情况下，你可以通过 pip 在新环境中安装 `sglang` ： "
+
+#: ../../source/deployment/sglang.md:15 fcb185985f1b4c1589200ac4af2a6aee
+msgid "If you have encountered issues in installation, please feel free to check the official document for installation ([link](https://docs.sglang.ai/start/install.html))."
+msgstr "如果在安装过程中遇到问题，请随时查阅官方安装文档（[链接](https://docs.sglang.ai/start/install.html)）"
+
+#: ../../source/deployment/sglang.md:17 a0f36bc7b4e24d598d381e2705f73eb1
+msgid "API Service"
+msgstr "API 服务"
+
+#: ../../source/deployment/sglang.md:19 4d7006fa87884605b48700b05f602bb1
+msgid "It is easy to build an OpenAI-compatible API service with SGLang, which can be deployed as a server that implements OpenAI API protocol. By default, it starts the server at `http://localhost:30000`.  You can specify the address with `--host` and `--port` arguments.  Run the command as shown below:"
+msgstr "借助 SGLang ，构建一个与OpenAI API兼容的API服务十分简便，该服务可以作为实现OpenAI API协议的服务器进行部署。默认情况下，它将在 `http://localhost:30000` 启动服务器。您可以通过 `--host` 和 `--port` 参数来自定义地址。请按照以下所示运行命令："
+
+#: ../../source/deployment/sglang.md:27 6d10b2003b9b4dd0b9dca0a2e8d33fd6
+msgid "By default, if the `--model-path` does not point to a valid local directory, it will download the model files from the Hugging Face Hub. To download model from ModelScope, set the following before running the above command:"
+msgstr "默认情况下，如果模型未指向有效的本地目录，它将从 Hugging Face Hub 下载模型文件。要从 ModelScope 下载模型，请在运行上述命令之前设置以下内容："
+
+#: ../../source/deployment/sglang.md:33 d3cee58928964c5dba7720884d6c5189
+msgid "For distributed inference with tensor parallelism, it is as simple as"
+msgstr "对于使用张量并行的分布式推理，操作非常简单："
+
+#: ../../source/deployment/sglang.md:37 4c8600c0f3ac4d0e803af9c089d73dae
+msgid "The above command will use tensor parallelism on 4 GPUs. You should change the number of GPUs according to your demand."
+msgstr "上述命令将在 4 块 GPU 上使用张量并行。您应根据需求调整 GPU 的数量。"
+
+#: ../../source/deployment/sglang.md:40 4ca7c9376bd84c65a877134047aeee37
+msgid "Basic Usage"
+msgstr "基本用法"
+
+#: ../../source/deployment/sglang.md:42 bd805ae178b6401c925a959334b64b88
+msgid "Then, you can use the [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) to communicate with Qwen:"
+msgstr "然后，您可以利用 [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) 来与Qwen进行对话："
+
+#: ../../source/deployment/sglang.md 2f867c83bdce4a4286842da69aa68640
+#: 418b07dd6a574642bfa89052103763e9
+msgid "curl"
+msgstr ""
+
+#: ../../source/deployment/sglang.md 14df52980bfe41689ac8dc8699be2134
+#: 7a50af3d10534acfbf980ac0d2ee92e5
+msgid "Python"
+msgstr ""
+
+#: ../../source/deployment/sglang.md:62 ../../source/deployment/sglang.md:126
+#: 669de086434740279e9cf7c54fb42e56 a3f9e92506374567a4660de9071567e8
+msgid "You can use the API client with the `openai` Python SDK as shown below:"
+msgstr "或者您可以如下面所示使用 `openai` Python SDK中的 API 客��端："
+
+#: ../../source/deployment/sglang.md:92 d8321f81e9624419b5e0fdb7012816e4
+msgid "While the default sampling parameters would work most of the time for thinking mode, it is recommended to adjust the sampling parameters according to your application,  and always pass the sampling parameters to the API."
+msgstr "虽然默认的采样参数在大多数情况下适用于思考模式，但建议根据您的应用调整采样参数，并始终将采样参数传递给 API。"
+
+#: ../../source/deployment/sglang.md:98 d6379b9f885748ca89bd3fe6c3362376
+msgid "Thinking & Non-Thinking Modes"
+msgstr "思考与非思考模式"
+
+#: ../../source/deployment/sglang.md:100 f82eb1dfcc934667ac5aee0600140794
+msgid "Qwen3 models will think before respond. This behavior could be controlled by either the hard switch, which could disable thinking completely, or the soft switch, where the model follows the instruction of the user on whether it should think."
+msgstr "Qwen3 模型会在回复前进行思考。这种行为可以通过硬开关（完全禁用思考）或软开关（模型遵循用户关于是否应该思考的指令）来控制。"
+
+#: ../../source/deployment/sglang.md:103 bac5d71126f04d149c0d674b7b2f7ec8
+msgid "The hard switch is available in SGLang through the following configuration to the API call. To disable thinking, use"
+msgstr "硬开关在 SGLang 中可以通过以下 API 调用配置使用。要禁用思考，请使用"
+
+#: ../../source/deployment/sglang.md:158 09ccfb31c140452399460ed1357afc28
+msgid "Please note that passing `enable_thinking` is not OpenAI API compatible. The exact method may differ among frameworks."
+msgstr "请注意，`enable_thinking`并非OpenAI API定义的参数，具体传入方式可能因推理框架不同而不同。"
+
+#: ../../source/deployment/sglang.md:163 650e618e24044303b48b6bc9d4ccc239
+msgid "To completely disable thinking, you could use [a custom chat template](../../source/assets/qwen3_nonthinking.jinja) when starting the model:"
+msgstr "要完全禁用思考，您可以在启动模型时使用[自定义聊天模板](../../source/assets/qwen3_nonthinking.jinja)："
+
+#: ../../source/deployment/sglang.md:169 9c0dc646158541a991045064cfa5b258
+msgid "The chat template prevents the model from generating thinking content, even if the user instructs the model to do so with `/think`."
+msgstr "该聊天模板会阻止模型生成思考内容，即使用户通过 `/think` 指示模型这样做。"
+
+#: ../../source/deployment/sglang.md:174 c23b692035b14b1099c8a148956457a5
+msgid "It is recommended to set sampling parameters differently for thinking and non-thinking modes."
+msgstr "建议为思考模式和非思考模式分别设置不同的采样参数。"
+
+#: ../../source/deployment/sglang.md:177 c5c258baa5fa46ccbadb58573699a0f1
+msgid "Parsing Thinking Content"
+msgstr "解析思考内容"
+
+#: ../../source/deployment/sglang.md:179 02d90ad41ecb4d51ae9f55458670843e
+msgid "SGLang supports parsing the thinking content from the model generation into structured messages:"
+msgstr "SGLang 支持将模型生成的思考内容解析为结构化消息："
+
+#: ../../source/deployment/sglang.md:184 854a73931a9e404b9942a10dd2702023
+msgid "The response message will have a field named `reasoning_content` in addition to `content`, containing the thinking content generated by the model."
+msgstr "响应消息除了包含 `content` 字段外，还会有一个名为 `reasoning_content` 的字段，其中包含模型生成的思考内容。"
+
+#: ../../source/deployment/sglang.md:187 0bae083925f64ec7984c1b7c86d00ac1
+msgid "Please note that this feature is not OpenAI API compatible."
+msgstr "请注意，此功能与 OpenAI API 规范不一致。"
+
+#: ../../source/deployment/sglang.md:191 f23a3deb557a4d808cef5bdaad6dcf16
+msgid "`enable_thinking=False` may not be compatible with this feature. If you need to pass `enable_thinking=False` to the API, please consider disabling parsing thinking content."
+msgstr "`enable_thinking=False` 可能与思考内容解析不兼容。如果需要向 API 传递 `enable_thinking=False`，请考虑禁用该功能。"
+
+#: ../../source/deployment/sglang.md:195 930b8e7391204fc68d6473fec1d2e4e0
+msgid "Parsing Tool Calls"
+msgstr "解析工具调用"
+
+#: ../../source/deployment/sglang.md:197 8fb5272b079543219b125e70da4f89d3
+msgid "SGLang supports parsing the tool calling content from the model generation into structured messages:"
+msgstr "SGLang 支持将模型生成的工具调用内容解析为结构化消息："
+
+#: ../../source/deployment/sglang.md:202 28ca5e5fc8694b839b91cb3f7f38a0cb
+msgid "For more information, please refer to [our guide on Function Calling](../framework/function_call.md)."
+msgstr "详细信息，请参阅[函数调用的指南](../framework/function_call.md#vllm)。"
+
+#: ../../source/deployment/sglang.md:204 59cd747bac244c57afc56b7f3d041df8
+msgid "Structured/JSON Output"
+msgstr "结构化/JSON输出"
+
+#: ../../source/deployment/sglang.md:206 4534e68747c041d5addd24c36fbc8250
+msgid "SGLang supports structured/JSON output.  Please refer to [SGLang's documentation](https://docs.sglang.ai/backend/structured_outputs.html#OpenAI-Compatible-API). Besides, it is also recommended to instruct the model to generate the specific format in the system message or in your prompt."
+msgstr "SGLang 支持结构化/JSON 输出。请参阅[SGLan文档](https://docs.sglang.ai/backend/structured_outputs.html#OpenAI-Compatible-API)。此外，还建议在系统消息或您的提示中指示模型生成特定格式。"
+
+#: ../../source/deployment/sglang.md:210 734cfd6d921e4706a07e112237b09b38
+msgid "Serving Quantized models"
+msgstr "部署量化模型"
+
+#: ../../source/deployment/sglang.md:212 e7b0890292ad44278e910b6ee97f6d2d
+msgid "Qwen3 comes with two types of pre-quantized models, FP8 and AWQ."
+msgstr "Qwen3 提供了两种类型的预量化模型：FP8 和 AWQ。"
+
+#: ../../source/deployment/sglang.md:214 0bb52b4e43504cb8ac143e594247a0e0
+msgid "The command serving those models are the same as the original models except for the name change:"
+msgstr "部署这些模型的命令与原始模型相同，只是名称有所更改："
+
+#: ../../source/deployment/sglang.md:223 714f8f196af24271b6967dd038614f88
+msgid "Context Length"
+msgstr "上下文长度"
+
+#: ../../source/deployment/sglang.md:225 ad211116852345b8bfb9bb9e58027486
+msgid "The context length for Qwen3 models in pretraining is up to 32,768 tokens. To handle context length substantially exceeding 32,768 tokens, RoPE scaling techniques should be applied. We have validated the performance of [YaRN](https://arxiv.org/abs/2309.00071), a technique for enhancing model length extrapolation, ensuring optimal performance on lengthy texts."
+msgstr "Qwen3 模型在预训练中的上下文长度最长为 32,768 个 token。为了处理显著超过 32,768 个 token 的上下文长度，应应用 RoPE 缩放技术。我们已经验证了 [YaRN](https://arxiv.org/abs/2309.00071) 的性能，这是一种增强模型长度外推的技术，可确保在长文本上的最佳性能。"
+
+#: ../../source/deployment/sglang.md:229 d243e7a41b214c289be782db495e82f4
+msgid "SGLang supports YaRN, which can be configured as"
+msgstr "SGLang 支持 YaRN，可以配置为"
+
+#: ../../source/deployment/sglang.md:235 c15ed6a15a714884ab3024654203ec06
+msgid "SGLang implements 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."
+msgstr "SGLang 实现了静态 YaRN，这意味着无论输入长度如何，缩放因子都保持不变，**这可能会对较短文本的性能产生影响。** 我们建议仅在需要处理长上下文时添加 `rope_scaling` 配置。还建议根据需要调整 `factor`。例如，如果您的应用程序的典型上下文长度为 65,536 个 token，则最好将 `factor` 设置为 2.0。"
+
+#: ../../source/deployment/sglang.md:241 e0528eb23e2a454585b46ef178d28a79
+msgid "The default `max_position_embeddings` in `config.json` is set to 40,960, which is used by SGLang. 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 and leave adequate room for model thinking. 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."
+msgstr "`config.json` 中的默认 `max_position_embeddings` 被设置为 40,960，SGLang 将使用该值。此分配包括为输出保留 32,768 个 token，为典型提示保留 8,192 个 token，这足以应对大多数涉及短文本处理的场景，并为模型思考留出充足空间。如果平均上下文长度不超过 32,768 个 token，我们不建议在此场景中启用 YaRN，因为这可能会降低模型性能。"
+
+#~ msgid "Please note that `sglang` relies on `flashinfer-python` and has strict dependencies on `torch` and its CUDA versions. Check the note in the official document for installation ([link](https://docs.sglang.ai/start/install.html)) for more help."
+#~ msgstr "请留意预构建的 `sglang` 依赖 `flashinfer-python`，并对`torch`和其CUDA版本有强依赖。请查看[官方文档](https://docs.sglang.ai/start/install.html)中的注意事项以获取有关安装的帮助。"
+
+#~ msgid "This feature has not been released. For more information, please see this [pull request](https://github.com/sgl-project/sglang/pull/5551)."
+#~ msgstr "此功能尚未发布。更多信息，请参阅此[pull request](https://github.com/sgl-project/sglang/pull/5551)。"
+

docs/locales/zh_CN/LC_MESSAGES/deployment/skypilot.po

@@ -0,0 +1,191 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/deployment/skypilot.rst:2 795ad4f30e27494d93675f71bb1a5cc4
+msgid "SkyPilot"
+msgstr ""
+
+#: ../../Qwen/source/deployment/skypilot.rst:5 aad807db94a24d868c9c1b364b47e152
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:8 d6bbf736584f4bbfa9c300d50a2ed669
+msgid "What is SkyPilot"
+msgstr "SkyPilot 是什么"
+
+#: ../../Qwen/source/deployment/skypilot.rst:10
+#: b66facae41bf493880e43044e2915a45
+msgid "SkyPilot is a framework for running LLMs, AI, and batch jobs on any cloud, offering maximum cost savings, the highest GPU availability, and managed execution. Its features include:"
+msgstr "SkyPilot 是一个可以在任何云上运行 LLM 、 AI 应用以及批量任务的框架，旨在实现最大程度的成本节省、最高的 GPU 可用性以及受管理的执行过程。其特性包括："
+
+#: ../../Qwen/source/deployment/skypilot.rst:14
+#: 621f021163c549d0aadb1c911a3a3ef5
+msgid "Get the best GPU availability by utilizing multiple resources pools across multiple regions and clouds."
+msgstr "通过跨区域和跨云充分利用多个资源池，以获得最佳的 GPU 可用性。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:16
+#: ea1723c3b5be454cad3219836f4386d8
+msgid "Pay absolute minimum — SkyPilot picks the cheapest resources across regions and clouds. No managed solution markups."
+msgstr "把费用降到最低—— SkyPilot 在各区域和云平台中为您挑选最便宜的资源。无需任何托管解决方案的额外加价。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:18
+#: e479693ecf08411ca35d8d0727c8f441
+msgid "Scale up to multiple replicas across different locations and accelerators, all served with a single endpoint"
+msgstr "将服务扩展到多个副本上，所有副本通过单一 endpoint 对外提供服务"
+
+#: ../../Qwen/source/deployment/skypilot.rst:20
+#: 1f9cdd2ae2544d1faa8a4c463ee0e42c
+msgid "Everything stays in your cloud account (your VMs & buckets)"
+msgstr "所有内容均保存在您的云账户中（包括您的虚拟机和 bucket ）"
+
+#: ../../Qwen/source/deployment/skypilot.rst:21
+#: 5bb9b617764942d989e5093463a359f0
+msgid "Completely private - no one else sees your chat history"
+msgstr "完全私密 - 没有其他人能看到您的聊天记录"
+
+#: ../../Qwen/source/deployment/skypilot.rst:24
+#: cf0c456ac72f40ac98790c11dc243317
+msgid "Install SkyPilot"
+msgstr "安装 SkyPilot"
+
+#: ../../Qwen/source/deployment/skypilot.rst:26
+#: 78d86c1fa8104b138b01aed640b262fc
+msgid "We advise you to follow the `instruction <https://skypilot.readthedocs.io/en/latest/getting-started/installation.html>`__ to install SkyPilot. Here we provide a simple example of using ``pip`` for the installation as shown below."
+msgstr "我们建议您按照 `指示 <https://skypilot.readthedocs.io/en/latest/getting-started/installation.html>`__ 安装 SkyPilot 。以下为您提供了一个使用 ``pip`` 进行安装的简单示例："
+
+#: ../../Qwen/source/deployment/skypilot.rst:38
+#: a7c88265bf404f55b85388c81a240199
+msgid "After that, you need to verify cloud access with a command like:"
+msgstr "随后，您需要用如下命令确认是否能使用云："
+
+#: ../../Qwen/source/deployment/skypilot.rst:44
+#: 72025dfba0144f63a720f6da0dd39bfa
+msgid "For more information, check the `official document <https://skypilot.readthedocs.io/en/latest/getting-started/installation.html>`__ and see if you have set up your cloud accounts correctly."
+msgstr "若需更多信息，请查阅官方文档，确认您的云账户设置是否正确无误。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:47
+#: 61be006061554e5ea40d55497e11e192
+msgid "Alternatively, you can also use the official docker image with SkyPilot master branch automatically cloned by running:"
+msgstr "或者，您也可以使用官方提供的 docker 镜像，可以自动克隆 SkyPilot 的主分支："
+
+#: ../../Qwen/source/deployment/skypilot.rst:63
+#: 4ae89fb44c6643a3a82fca5cee622af4
+msgid "Running Qwen2.5-72B-Instruct with SkyPilot"
+msgstr "使用 SkyPilot 运行 Qwen2.5-72B-Instruct "
+
+#: ../../Qwen/source/deployment/skypilot.rst:65
+#: 1bc4973c2eb745689ded0af54ba33e0e
+msgid "Start serving Qwen2.5-72B-Instruct on a single instance with any available GPU in the list specified in `serve-72b.yaml <https://github.com/skypilot-org/skypilot/blob/master/llm/qwen/serve-72b.yaml>`__ with a vLLM-powered OpenAI-compatible endpoint:"
+msgstr "`serve-72b.yaml <https://github.com/skypilot-org/skypilot/blob/master/llm/qwen/serve-72b.yaml>`__ 中列出了支持的 GPU 。您可使用配备这类 GPU 的单个运算实例来部署 Qwen2.5-72B-Instruct 服务。该服务由 vLLM 搭建，并与 OpenAI API 兼容。以下为部署方法："
+
+#: ../../Qwen/source/deployment/skypilot.rst:74
+#: ../../Qwen/source/deployment/skypilot.rst:123
+#: ac3692ed16974facbd58b6886cd111af b325de015e7b4bb0a91491d3f7418792
+msgid "**Before launching, make sure you have changed Qwen/Qwen2-72B-Instruct to Qwen/Qwen2.5-72B-Instruct in the YAML file.**"
+msgstr "**在启动之前，请先将 YAML 文件中的 Qwen/Qwen2-72B-Instruct 修改为 Qwen/Qwen2.5-72B-Instruct。**"
+
+#: ../../Qwen/source/deployment/skypilot.rst:76
+#: 6046b3c86fae4a43878fbadbeb33fbd8
+msgid "Send a request to the endpoint for completion:"
+msgstr "向该 endpoint 发送续写请求："
+
+#: ../../Qwen/source/deployment/skypilot.rst:90
+#: 2ec56c2028a94f568fd2c1a65063d25a
+msgid "Send a request for chat completion:"
+msgstr "向该 endpoint 发送对话续写请求"
+
+#: ../../Qwen/source/deployment/skypilot.rst:112
+#: c8e140ddfd914ff5a460621a7ca1891e
+msgid "Scale up the service with SkyPilot Serve"
+msgstr "使用 SkyPilot Serve 扩展服务规模"
+
+#: ../../Qwen/source/deployment/skypilot.rst:114
+#: 0db304ab396d45adb6017d78cd1ee4a2
+msgid "With `SkyPilot Serve <https://skypilot.readthedocs.io/en/latest/serving/sky-serve.html>`__, a serving library built on top of SkyPilot, scaling up the Qwen service is as simple as running:"
+msgstr "使用 `SkyPilot Serve <https://skypilot.readthedocs.io/en/latest/serving/sky-serve.html>`__ 扩展 Qwen 的服务规模非常容易，只需运行："
+
+#: ../../Qwen/source/deployment/skypilot.rst:125
+#: 25bbbf9e49be44d3899074ff97202d71
+msgid "This will start the service with multiple replicas on the cheapest available locations and accelerators. SkyServe will automatically manage the replicas, monitor their health, autoscale based on load, and restart them when needed."
+msgstr "这将启动服务，使用多个副本部署在最经济的可用位置和加速器上。 SkyServe 将自动管理这些副本，监控其健康状况，根据负载进行自动伸缩，并在必要时重启它们。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:130
+#: bda628bab7ef41a0918dc4b80a9b3cfe
+msgid "A single endpoint will be returned and any request sent to the endpoint will be routed to the ready replicas."
+msgstr "将返回一个 endpoint ，所有发送至该endpoint的请求都将被路由至就绪状态的副本。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:133
+#: b232dbbdcf674d56bcf9c0331c020864
+msgid "To check the status of the service, run:"
+msgstr "运行如下命令检查服务的状态："
+
+#: ../../Qwen/source/deployment/skypilot.rst:139
+#: 556b854caf7243fb93f253ebe2dc9033
+msgid "After a while, you will see the following output:"
+msgstr "很快，您将看到如下输出："
+
+#: ../../Qwen/source/deployment/skypilot.rst:152
+#: 5a6055c5a42c4b2db6693c1095688de8
+msgid "As shown, the service is now backed by 2 replicas, one on Azure and one on GCP, and the accelerator type is chosen to be **the cheapest available one** on the clouds. That said, it maximizes the availability of the service while minimizing the cost."
+msgstr "如下所示：该服务现由两个副本提供支持，一个位于 Azure 平台，另一个位于 GCP 平台。同时，已为服务选择云服务商提供的 **最经济实惠** 的加速器类型。这样既最大限度地提升了服务的可用性，又尽可能降低了成本。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:157
+#: a18533d33dc54a1091ded0b4bba0a1eb
+msgid "To access the model, we use a ``curl -L`` command (``-L`` to follow redirect) to send the request to the endpoint:"
+msgstr "要访问模型，我们使用带有 ``curl -L`` （用于跟随重定向），将请求发送到 endpoint ："
+
+#: ../../Qwen/source/deployment/skypilot.rst:182
+#: 34cd50fd79e24d8895075f7841b025e4
+msgid "Accessing Qwen2.5 with Chat GUI"
+msgstr "使用 Chat GUI 调用 Qwen2.5"
+
+#: ../../Qwen/source/deployment/skypilot.rst:184
+#: ca6994cda1cb469e83ce8c026bb67e42
+msgid "It is also possible to access the Qwen2.5 service with GUI by connecting a `FastChat GUI server <https://github.com/lm-sys/FastChat>`__ to the endpoint launched above (see `gui.yaml <https://github.com/skypilot-org/skypilot/blob/master/llm/qwen/gui.yaml>`__)."
+msgstr "可以通过 `FastChat <https://github.com/lm-sys/FastChat>`__ 来使用 GUI 调用 Qwen2.5 的服务："
+
+#: ../../Qwen/source/deployment/skypilot.rst:188
+#: 99a63e55ab5c46258c20ab89cdfa39dc
+msgid "Start the Chat Web UI:"
+msgstr "开启一个 Chat Web UI"
+
+#: ../../Qwen/source/deployment/skypilot.rst:194
+#: e61593a092c146f8a06af896d6af17f2
+msgid "**Before launching, make sure you have changed Qwen/Qwen1.5-72B-Chat to Qwen/Qwen2.5-72B-Instruct in the YAML file.**"
+msgstr "**在启动之前，请先将 YAML 文件中的 Qwen/Qwen1.5-72B-Chat 修改为 Qwen/Qwen2.5-72B-Instruct。**"
+
+#: ../../Qwen/source/deployment/skypilot.rst:196
+#: 9631068a8b424aa8af6dc6911daac7a9
+msgid "Then, we can access the GUI at the returned gradio link:"
+msgstr "随后，我们可以通过返回的 gradio 链接来访问 GUI ："
+
+#: ../../Qwen/source/deployment/skypilot.rst:202
+#: 1464a56dcd06404aafbe6d7d2c72212b
+msgid "Note that you may get better results by using a different temperature and top_p value."
+msgstr "你可以通过使用不同的温度和 top_p 值来尝试取得更好的结果。"
+
+#: ../../Qwen/source/deployment/skypilot.rst:205
+#: d257f49d835e4c12b28bc680bb78a9cb
+msgid "Summary"
+msgstr "总结"
+
+#: ../../Qwen/source/deployment/skypilot.rst:207
+#: 06b9684a19774eaba4f69862332c5166
+msgid "With SkyPilot, it is easy for you to deploy Qwen2.5 on any cloud. We advise you to read the official doc for more usages and updates. Check `this <https://skypilot.readthedocs.io/>`__ out!"
+msgstr "通过 SkyPilot ，你可以轻松地在任何云上部署 Qwen2.5 。我们建议您阅读 `官方文档 <https://skypilot.readthedocs.io/>`__ 了解更多用法和最新进展。"
+

docs/locales/zh_CN/LC_MESSAGES/deployment/tgi.po

@@ -0,0 +1,181 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/deployment/tgi.rst:2 2abcc96f9deb4b9187ac9d88fc69e929
+msgid "TGI"
+msgstr ""
+
+#: ../../Qwen/source/deployment/tgi.rst:5 2d124d7cb95f47388aa48c662932ef9b
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/deployment/tgi.rst:7 4e5d299c4fdd46d5aba38c9af5765792
+msgid "Hugging Face's Text Generation Inference (TGI) is a production-ready framework specifically designed for deploying and serving large language models (LLMs) for text generation tasks. It offers a seamless deployment experience, powered by a robust set of features:"
+msgstr "Hugging Face 的 Text Generation Inference (TGI) 是一个专为部署大规模语言模型 (Large Language Models, LLMs) 而设计的生产级框架。TGI提供了流畅的部署体验，并稳定支持如下特性："
+
+#: ../../Qwen/source/deployment/tgi.rst:9 ecd4fc11a95140959915d062791ceba1
+msgid "`Speculative Decoding <Speculative Decoding_>`_: Accelerates generation speeds."
+msgstr "`推测解码 (Speculative Decoding) <Speculative Decoding_>`_ ：提升生成速度。"
+
+#: ../../Qwen/source/deployment/tgi.rst:10 84590a56416348bf85b3f296cf57e257
+msgid "`Tensor Parallelism`_: Enables efficient deployment across multiple GPUs."
+msgstr "张量并行 (`Tensor Parallelism`_) ：高效多卡部署。"
+
+#: ../../Qwen/source/deployment/tgi.rst:11 a996d6ecd7b94c5cb9752d370f29a9b1
+msgid "`Token Streaming`_: Allows for the continuous generation of text."
+msgstr "流式生成 (`Token Streaming`_) ：支持持续性生成文本。"
+
+#: ../../Qwen/source/deployment/tgi.rst:12 8f591c045ba34f4581bb19652db9f9b3
+msgid "Versatile Device Support: Works seamlessly with `AMD`_, `Gaudi`_ and `AWS Inferentia`_."
+msgstr "灵活的硬件支持：与 `AMD`_ ， `Gaudi`_ 和 `AWS Inferentia`_ 无缝衔接。"
+
+#: ../../Qwen/source/deployment/tgi.rst:21 5e8a98b91fc146e0b581422faa683a18
+msgid "Installation"
+msgstr "安装"
+
+#: ../../Qwen/source/deployment/tgi.rst:23 684ef25bfb0e460999d6dcccce41b85f
+msgid "The easiest way to use TGI is via the TGI docker image. In this guide, we show how to use TGI with docker."
+msgstr "通过 TGI docker 镜像使用 TGI 轻而易举。本文将主要介绍 TGI 的 docker 用法。"
+
+#: ../../Qwen/source/deployment/tgi.rst:25 c563fa3eccb04d00a477c1d2e8b15c38
+msgid "It's possible to run it locally via Conda or build locally. Please refer to `Installation Guide <https://huggingface.co/docs/text-generation-inference/installation>`_  and `CLI tool <https://huggingface.co/docs/text-generation-inference/en/basic_tutorials/using_cli>`_ for detailed instructions."
+msgstr "也可通过 Conda 实机安装或搭建服务。请参考 `Installation Guide <https://huggingface.co/docs/text-generation-inference/installation>`_ 与 `CLI tool <https://huggingface.co/docs/text-generation-inference/en/basic_tutorials/using_cli>`_ 以了解详细说明。"
+
+#: ../../Qwen/source/deployment/tgi.rst:28 b55fc58ff4cb472abca08296409c7837
+msgid "Deploy Qwen2.5 with TGI"
+msgstr "通过 TGI 部署 Qwen2.5"
+
+#: ../../Qwen/source/deployment/tgi.rst:30 586a8425ec5d413592fd7daf579c7e87
+msgid "**Find a Qwen2.5 Model:** Choose a model from `the Qwen2.5 collection <https://huggingface.co/collections/Qwen/qwen25-66e81a666513e518adb90d9e>`_."
+msgstr "**选定 Qwen2.5 模型：** 从 `the Qwen2.5 collection <https://huggingface.co/collections/Qwen/qwen25-66e81a666513e518adb90d9e>`_ 中挑选模型。"
+
+#: ../../Qwen/source/deployment/tgi.rst:31 50fcab8da35941eca308786979dbaf38
+msgid "**Deployment Command:** Run the following command in your terminal, replacing ``model`` with your chosen Qwen2.5 model ID and ``volume`` with the path to your local data directory:"
+msgstr "**部署TGI服务：** 在终端中运行以下命令，注意替换 ``model`` 为选定的 Qwen2.5 模型 ID 、 ``volume`` 为本地的数据路径： "
+
+#: ../../Qwen/source/deployment/tgi.rst:42 2a800533a7d84bdeab1da0976b0cab53
+msgid "Using TGI API"
+msgstr "使用 TGI API"
+
+#: ../../Qwen/source/deployment/tgi.rst:44 f05d1ec08140452782d0659543fad7d1
+msgid "Once deployed, the model will be available on the mapped port (8080)."
+msgstr "一旦成功部署，API 将于选定的映射端口 (8080) 提供服务。"
+
+#: ../../Qwen/source/deployment/tgi.rst:46 f265dc1522b049c98ba31fd5d255c50f
+msgid "TGI comes with a handy API for streaming response:"
+msgstr "TGI 提供了简单直接的 API 支持流式生成："
+
+#: ../../Qwen/source/deployment/tgi.rst:54 e9cc4c0571b74bd08b2a59347503e653
+msgid "It's also available on OpenAI style API:"
+msgstr "也可使用 OpenAI 风格的 API 使用 TGI ："
+
+#: ../../Qwen/source/deployment/tgi.rst:73 5dc7e9c74fc04483ba8e5dcdd7052020
+msgid "The model field in the JSON is not used by TGI, you can put anything."
+msgstr "JSON 中的 model 字段不会被 TGI 识别，您可传入任意值。"
+
+#: ../../Qwen/source/deployment/tgi.rst:75 d60f837152014cda8baebc90d65d1cc0
+#, python-format
+msgid "Refer to the `TGI Swagger UI <https://huggingface.github.io/text-generation-inference/#/Text%20Generation%20Inference/completions>`_ for a complete API reference."
+msgstr "完整 API 文档，请查阅 `TGI Swagger UI <https://huggingface.github.io/text-generation-inference/#/Text%20Generation%20Inference/completions>`_ 。"
+
+#: ../../Qwen/source/deployment/tgi.rst:77 b59564031e5548088aef828f9753e337
+msgid "You can also use Python API:"
+msgstr "你也可以使用 Python 访问 API ："
+
+#: ../../Qwen/source/deployment/tgi.rst:106 62646cecb024479ebfeca5f3063e7322
+msgid "Quantization for Performance"
+msgstr "量化"
+
+#: ../../Qwen/source/deployment/tgi.rst:108 4a8d39bf37be4820afb230f9a977b431
+msgid "Data-dependent quantization (GPTQ and AWQ)"
+msgstr "依赖数据的量化方案（ GPTQ 与 AWQ ）"
+
+#: ../../Qwen/source/deployment/tgi.rst:110 ef2b18f47e4f4f7ebb017be628cb0be9
+msgid "Both GPTQ and AWQ models are data-dependent. The official quantized models can be found from `the Qwen2.5 collection`_ and you can also quantize models with your own dataset to make it perform better on your use case."
+msgstr "GPTQ 与 AWQ 均依赖数据进行量化。我们提供了预先量化好的模型，请于 `the Qwen2.5 collection`_ 查找。你也可以使用自己的数据集自行量化，以在你的场景中取得更好效果。"
+
+#: ../../Qwen/source/deployment/tgi.rst:112 53d94278a2e3409abb9980ebc7c96c24
+msgid "The following shows the command to start TGI with Qwen2.5-7B-Instruct-GPTQ-Int4:"
+msgstr "以下是通过 TGI 部署 Qwen2.5-7B-Instruct-GPTQ-Int4 的指令："
+
+#: ../../Qwen/source/deployment/tgi.rst:122 68ff8a07d0eb40cfa67d79e01adea070
+msgid "If the model is quantized with AWQ, e.g. Qwen/Qwen2.5-7B-Instruct-AWQ, please use ``--quantize awq``."
+msgstr "如果模型是 AWQ 量化的，如 Qwen/Qwen2.5-7B-Instruct-AWQ ，请使用 ``--quantize awq`` 。"
+
+#: ../../Qwen/source/deployment/tgi.rst:124 b4c3b82b1f2a43a8a02383fd0afbda5f
+msgid "Data-agnostic quantization"
+msgstr "不依赖数据的量化方案"
+
+#: ../../Qwen/source/deployment/tgi.rst:126 7a6b89c94b72407482b96790f5bbd272
+msgid "EETQ on the other side is not data dependent and can be used with any model. Note that we're passing in the original model (instead of a quantized model) with the ``--quantize eetq`` flag."
+msgstr "EETQ 是一种不依赖数据的量化方案，可直接用于任意模型。请注意，我们需要传入原始模型，并使用 ``--quantize eetq`` 标志。"
+
+#: ../../Qwen/source/deployment/tgi.rst:138 763166da65924887b3bba99ea4d2baab
+msgid "Multi-Accelerators Deployment"
+msgstr "多卡部署"
+
+#: ../../Qwen/source/deployment/tgi.rst:140 ddcfcff947894f168c7945ae9c42a579
+msgid "Use the ``--num-shard`` flag to specify the number of accelerators. Please also use ``--shm-size 1g`` to enable shared memory for optimal NCCL performance (`reference <https://github.com/huggingface/text-generation-inference?tab=readme-ov-file#a-note-on-shared-memory-shm>`__):"
+msgstr "使用 ``--num-shard`` 指定卡书数量。 请务必传入 ``--shm-size 1g`` 让 NCCL 发挥最好性能 (`说明 <https://github.com/huggingface/text-generation-inference?tab=readme-ov-file#a-note-on-shared-memory-shm>`__) ："
+
+#: ../../Qwen/source/deployment/tgi.rst:151 520c46fb404c4ec9bf89280e4a71f1e8
+msgid "Speculative Decoding"
+msgstr "推测性解码 (Speculative Decoding)"
+
+#: ../../Qwen/source/deployment/tgi.rst:153 74c6b65f76b74d56ad109af9da11f66e
+msgid "Speculative decoding can reduce the time per token by speculating on the next token. Use the ``--speculative-decoding`` flag, setting the value to the number of tokens to speculate on (default: 0 for no speculation):"
+msgstr "推测性解码 (Speculative Decoding) 通过预先推测下一 token 来节约每 token 需要的时间。使用 ``--speculative-decoding`` 设定预先推测 token 的数量 （默认为0，表示不预先推测）："
+
+#: ../../Qwen/source/deployment/tgi.rst:164 dee05ee0fb1a4f2da42b250192d943f5
+msgid "The overall performance of speculative decoding highly depends on the type of task. It works best for code or highly repetitive text."
+msgstr "推测性解码的加速效果依赖于任务类型，对于代码或重复性较高的文本生成任务，提速更明显。"
+
+#: ../../Qwen/source/deployment/tgi.rst:166 731f300bc1174589901dd5feb26e8b2f
+msgid "More context on speculative decoding can be found `here <https://huggingface.co/docs/text-generation-inference/conceptual/speculation>`__."
+msgstr "更多说明可查阅 `此文档 <https://huggingface.co/docs/text-generation-inference/conceptual/speculation>`__ 。"
+
+#: ../../Qwen/source/deployment/tgi.rst:170 65a7d5553dd145398f9705c1ee6c28f0
+msgid "Zero-Code Deployment with HF Inference Endpoints"
+msgstr "使用 HF Inference Endpoints 零代码部署"
+
+#: ../../Qwen/source/deployment/tgi.rst:172 721c3a7578f846ae8e21e595923e17e7
+msgid "For effortless deployment, leverage Hugging Face Inference Endpoints:"
+msgstr "使用 Hugging Face Inference Endpoints 不费吹灰之力："
+
+#: ../../Qwen/source/deployment/tgi.rst:174 7741607488d94a9f8be2ffcb6a5322fb
+msgid "**GUI interface:** `<https://huggingface.co/inference-endpoints/dedicated>`__"
+msgstr ""
+
+#: ../../Qwen/source/deployment/tgi.rst:175 02ff4520e66f4a42828483da7d25445f
+msgid "**Coding interface:** `<https://huggingface.co/blog/tgi-messages-api>`__"
+msgstr ""
+
+#: ../../Qwen/source/deployment/tgi.rst:177 d35f9dd4bc96400cb6c7584012d2df49
+msgid "Once deployed, the endpoint can be used as usual."
+msgstr "一旦部署成功，服务使用与本地无异。"
+
+#: ../../Qwen/source/deployment/tgi.rst:181 61c1b825bbf24be2aaaeb99de3f0660e
+msgid "Common Issues"
+msgstr "常见问题"
+
+#: ../../Qwen/source/deployment/tgi.rst:183 b55a2d286fc24dbe92b79ab5c010c7af
+msgid "Qwen2.5 supports long context lengths, so carefully choose the values for ``--max-batch-prefill-tokens``, ``--max-total-tokens``, and ``--max-input-tokens`` to avoid potential out-of-memory (OOM) issues. If an OOM occurs, you'll receive an error message upon startup. The following shows an example to modify those parameters:"
+msgstr "Qwen2.5 支持长上下文，谨慎设定 ``--max-batch-prefill-tokens`` ， ``--max-total-tokens`` 和 ``--max-input-tokens`` 以避免 out-of-memory (OOM) 。如 OOM ，你将在启动 TGI 时收到错误提示。以下为修改这些参数的示例："
+

docs/locales/zh_CN/LC_MESSAGES/deployment/vllm.po

@@ -0,0 +1,245 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 16:50+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/deployment/vllm.md:1 d5c0a6a59a4e4efdba77515c0c05f04a
+msgid "vLLM"
+msgstr ""
+
+#: ../../source/deployment/vllm.md:3 56317e0cd3104065a8496366f9bdcb67
+msgid "We recommend you trying [vLLM](https://github.com/vllm-project/vllm) for your deployment of Qwen.  It is simple to use, and it is fast with state-of-the-art serving throughput, efficient management of attention key value memory with PagedAttention, continuous batching of input requests, optimized CUDA kernels, etc.  To learn more about vLLM, please refer to the [paper](https://arxiv.org/abs/2309.06180) and [documentation](https://docs.vllm.ai/)."
+msgstr "我们建议您在部署 Qwen 时尝试使用 [vLLM](https://github.com/vllm-project/vllm)。它易于使用，且具有最先进的服务吞吐量、高效的注意力键值内存管理（通过PagedAttention实现）、连续批处理输入请求、优化的CUDA内核等功能。要了解更多关于vLLM的信息，请参阅 [论文](https://arxiv.org/abs/2309.06180) 和 [文档](https://docs.vllm.ai/)。"
+
+#: ../../source/deployment/vllm.md:7 81077ec6d7594b85b64857ee22883693
+msgid "Environment Setup"
+msgstr "环境配置"
+
+#: ../../source/deployment/vllm.md:9 f80ee07832674dbfb3c547d0bd003720
+msgid "By default, you can install `vllm` with pip in a clean environment:"
+msgstr "默认情况下，你可以通过 pip 在新环境中安装 `vllm` ： "
+
+#: ../../source/deployment/vllm.md:15 7c0520bacc8941108def669c821603a9
+msgid "Please note that the prebuilt `vllm` has strict dependencies on `torch` and its CUDA versions. Check the note in the official document for installation ([link](https://docs.vllm.ai/en/latest/getting_started/installation.html)) for more help."
+msgstr "请留意预构建的`vllm`对`torch`和其CUDA版本有强依赖。请查看[vLLM官方文档](https://docs.vllm.ai/en/latest/getting_started/installation.html)中的注意事项以获取有关安装的帮助。"
+
+#: ../../source/deployment/vllm.md:18 ab785eb82e7f40a08269510d1cb5610d
+msgid "API Service"
+msgstr "API 服务"
+
+#: ../../source/deployment/vllm.md:20 fa0b4510d60d489c94435c334100e413
+msgid "It is easy to build an OpenAI-compatible API service with vLLM, which can be deployed as a server that implements OpenAI API protocol. By default, it starts the server at `http://localhost:8000`.  You can specify the address with `--host` and `--port` arguments.  Run the command as shown below:"
+msgstr "借助vLLM，构建一个与OpenAI API兼容的API服务十分简便，该服务可以作为实现OpenAI API协议的服务器进行部署。默认情况下，它将在 `http://localhost:8000` 启动服务器。您可以通过 `--host` 和 `--port` 参数来自定义地址。请按照以下所示运行命令："
+
+#: ../../source/deployment/vllm.md:28 66e317eb19424af7a54eb52093e7945b
+msgid "By default, if the model does not point to a valid local directory, it will download the model files from the Hugging Face Hub. To download model from ModelScope, set the following before running the above command:"
+msgstr "默认情况下，如果模型未指向有效的本地目录，它将从 Hugging Face Hub 下载模型文件。要从 ModelScope 下载模型，请在运行上述命令之前设置以下内容："
+
+#: ../../source/deployment/vllm.md:34 4d9631b6922c4f08b9be1ec85a956309
+msgid "For distributed inference with tensor parallelism, it is as simple as"
+msgstr "对于使用张量并行的分布式推理，操作非常简单："
+
+#: ../../source/deployment/vllm.md:38 33cc8d44a1434af2af200659add2e57f
+msgid "The above command will use tensor parallelism on 4 GPUs. You should change the number of GPUs according to your demand."
+msgstr "上述命令将在 4 块 GPU 上使用张量并行。您应根据需求调整 GPU 的数量。"
+
+#: ../../source/deployment/vllm.md:41 605a634a44e3401ab46c77933aa2817e
+msgid "Basic Usage"
+msgstr "基本用法"
+
+#: ../../source/deployment/vllm.md:43 58fb05b376b545e4892584539004c4c8
+msgid "Then, you can use the [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) to communicate with Qwen:"
+msgstr "然后，您可以利用 [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) 来与Qwen进行对话："
+
+#: ../../source/deployment/vllm.md b9a21dd5fe924a36ae4d655aa7c2d127
+#: f95affb6c52340bd8623c319fa8a159f
+msgid "curl"
+msgstr ""
+
+#: ../../source/deployment/vllm.md 3c6242c05b90435dbf1c971ce061e127
+#: 92e58b5637bd4af1bc4df269071a3df5
+msgid "Python"
+msgstr ""
+
+#: ../../source/deployment/vllm.md:63 ../../source/deployment/vllm.md:129
+#: 12be4f0cf2b9495faee25799b266a799 855aea8cb2fa48f7a63c6a511cb03fd5
+msgid "You can use the API client with the `openai` Python SDK as shown below:"
+msgstr "或者您可以如下面所示使用 `openai` Python SDK中的 API 客户端："
+
+#: ../../source/deployment/vllm.md:93 85d6fac1e7e24de1983be918b3e0ea3e
+msgid "`vllm` will use the sampling parameters from the `generation_config.json` in the model files."
+msgstr "`vllm` 将使用模型文件中 `generation_config.json` 的采样参数。"
+
+#: ../../source/deployment/vllm.md:95 1323928e307d4ed9bcd1e538e61f0d2d
+msgid "While the default sampling parameters would work most of the time for thinking mode, it is recommended to adjust the sampling parameters according to your application,  and always pass the sampling parameters to the API."
+msgstr "虽然默认的采样参数在大多数情况下适用于思考模式，但建议根据您的应用调整采样参数，并始终将采样参数传递给 API。"
+
+#: ../../source/deployment/vllm.md:101 84e3b8ae27ab4242973d411876f79250
+msgid "Thinking & Non-Thinking Modes"
+msgstr "思考与非思考模式"
+
+#: ../../source/deployment/vllm.md:103 80dddb284cb8439399ad0e3c2227cc0e
+msgid "Qwen3 models will think before respond. This behavior could be controlled by either the hard switch, which could disable thinking completely, or the soft switch, where the model follows the instruction of the user on whether it should think."
+msgstr "Qwen3 模型会在回复前进行思考。这种行为可以通过硬开关（完全禁用思考）或软开关（模型遵循用户关于是否应该思考的指令）来控制。"
+
+#: ../../source/deployment/vllm.md:106 88d3ca0f6faf4b8b80012f0a1b3a53ea
+msgid "The hard switch is available in vLLM through the following configuration to the API call. To disable thinking, use"
+msgstr "硬开关在 vLLM 中可以通过以下 API 调用配置使用。要禁用思考，请使用"
+
+#: ../../source/deployment/vllm.md:162 bfc88862f9e5470e8d8e213003c310bc
+msgid "Please note that passing `enable_thinking` is not OpenAI API compatible. The exact method may differ among frameworks."
+msgstr "请注意，`enable_thinking`并非OpenAI API定义的参数，具体传入方式可能因推理框架不同而不同。"
+
+#: ../../source/deployment/vllm.md:167 1d3ab8c3e2d24c0d9961b38686661005
+msgid "To completely disable thinking, you could use [a custom chat template](../../source/assets/qwen3_nonthinking.jinja) when starting the model:"
+msgstr "要完全禁用思考，您可以在启动模型时使用[自定义聊天模板](../../source/assets/qwen3_nonthinking.jinja)："
+
+#: ../../source/deployment/vllm.md:173 495c3e31b2614dd8bad7f0eba0d48236
+msgid "The chat template prevents the model from generating thinking content, even if the user instructs the model to do so with `/think`."
+msgstr "该聊天模板会阻止模型生成思考内容，即使用户通过 `/think` 指示模型这样做。"
+
+#: ../../source/deployment/vllm.md:178 02a8fc8d1024402ebc4f9449aa2500f3
+msgid "It is recommended to set sampling parameters differently for thinking and non-thinking modes."
+msgstr "建议为思考模式和非思考模式分别设置不同的采样参数。"
+
+#: ../../source/deployment/vllm.md:182 35e320018c0646cb82ad0d2f9fc54ea8
+msgid "Parsing Thinking Content"
+msgstr "解析思考内容"
+
+#: ../../source/deployment/vllm.md:184 efeeeb8ff56e4f37af53bd7a6e440d65
+msgid "vLLM supports parsing the thinking content from the model generation into structured messages:"
+msgstr "vLLM 支持将模型生成的思考内容解析为结构化消息："
+
+#: ../../source/deployment/vllm.md:189 a79e5778da03462199a629ed038526a8
+msgid "Since vLLM 0.9.0, one can also use"
+msgstr "自 vLLM 0.9.0 版本，也可以使用"
+
+#: ../../source/deployment/vllm.md:194 7fdb9af5391b402280be7aeaa514dcd3
+msgid "The response message will have a field named `reasoning_content` in addition to `content`, containing the thinking content generated by the model."
+msgstr "响应消息除了包含 `content` 字段外，还会有一个名为 `reasoning_content` 的字段，其中包含模型生成的思考内容。"
+
+#: ../../source/deployment/vllm.md:197 7036cf771a4e4fddbcbf92cc52de59d0
+msgid "Please note that this feature is not OpenAI API compatible."
+msgstr "请注意，此功能与 OpenAI API 规范不一致。"
+
+#: ../../source/deployment/vllm.md:201 5e0250bbffa94e7dac6c9278e0d87ab6
+msgid "As of vLLM 0.8.5, `enable_thinking=False` is not compatible with this feature. If you need to pass `enable_thinking=False` to the API, you should disable parsing thinking content. This is resolved in vLLM 0.9.0 with the `qwen3` reasoning parser."
+msgstr "在 vLLM 0.8.5 版本中，`enable_thinking=False` 与此功能不兼容。如果需要向 API 传递 `enable_thinking=False`，则应禁用解析思考内容。此问题已在 vLLM 0.9.0 中通过 `qwen3` 思考解析器得到解决。"
+
+#: ../../source/deployment/vllm.md:206 aa45c227d5d040dea6522bf2a45576b0
+msgid "Parsing Tool Calls"
+msgstr "解析工具调用"
+
+#: ../../source/deployment/vllm.md:208 56c12209324f41fcbed13409de6d0aa5
+msgid "vLLM supports parsing the tool calling content from the model generation into structured messages:"
+msgstr "vLLM 支持将模型生成的工具调用内容解析为结构化消息："
+
+#: ../../source/deployment/vllm.md:213 7a12c4073d874bff81f012d7da241e9c
+msgid "For more information, please refer to [our guide on Function Calling](../framework/function_call.md#vllm)."
+msgstr "详细信息，请参阅[函数调用的指南](../framework/function_call.md#vllm)。"
+
+#: ../../source/deployment/vllm.md:215 827710cca0954bfaaeaa8a67fef1efa6
+msgid "Structured/JSON Output"
+msgstr "结构化/JSON输出"
+
+#: ../../source/deployment/vllm.md:217 ac630e8cc3b04ad8af427e677896b7ee
+msgid "vLLM supports structured/JSON output.  Please refer to [vLLM's documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#extra-parameters-for-chat-api) for the `guided_json` parameters. Besides, it is also recommended to instruct the model to generate the specific format in the system message or in your prompt."
+msgstr "vLLM 支持结构化/JSON 输出。请参照[vLLM文档](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#extra-parameters-for-chat-api)了解 `guided_json` 参数。此外，也建议在系统消息或用户提示中指示模型生成特定格式，避免仅依赖于推理参数配置。"
+
+#: ../../source/deployment/vllm.md:222 5534e3b2ef2242c69964016b526e1a01
+msgid "Serving Quantized models"
+msgstr "部署量化模型"
+
+#: ../../source/deployment/vllm.md:224 dbd8323a4bc6415da9fde179b23dac78
+msgid "Qwen3 comes with two types of pre-quantized models, FP8 and AWQ."
+msgstr "Qwen3 提供了两种类型的预量化模型：FP8 和 AWQ。"
+
+#: ../../source/deployment/vllm.md:226 1aedffe7b0874ac289badc829e035300
+msgid "The command serving those models are the same as the original models except for the name change:"
+msgstr "部署这些模型的命令与原始模型相同，只是名称有所更改："
+
+#: ../../source/deployment/vllm.md:236 6d91506e31194076857d992f51d3f336
+msgid "The FP8 models of Qwen3 are block-wise quant, which is supported on NVIDIA GPUs with compute capability > 8.9, that is, Ada Lovelace, Hopper, and later GPUs and runs as w8a8."
+msgstr "Qwen3 的 FP8 模型采用分块 (block-wise) 量化，该功能支持在 compute capability > 8.9 的 NVIDIA GPU 上运行，即 Ada Lovelace、Hopper 及更新的 GPU，并以 w8a8 方式运行。"
+
+#: ../../source/deployment/vllm.md:238 f26fbf5e37134274b435efaeada7af6b
+msgid "Since vLLM v0.9.0, FP8 Marlin has supported block-wise quants (running as w8a16) and you can also run Qwen3 FP8 models on Ampere cards."
+msgstr "从 vLLM v0.9.0 开始，FP8 Marlin 已支持分块量化（以 w8a16 方式运行），您还可以在 Ampere 显卡上运行 Qwen3 FP8 模型。"
+
+#: ../../source/deployment/vllm.md:242 dca096f25d794f88bb446eb2f39f3570
+msgid "If you encountered the following error when deploying the FP8 models, it indicates that the tensor parallel size does not agree with the model weights:"
+msgstr "如果在部署 FP8 模型时遇到以下错误，这表明张量并行大小与模型权重不匹配："
+
+#: ../../source/deployment/vllm.md:249 609be8d8c32f48c5ade0f1a32873bbf8
+msgid "We recommend lowering the degree of tensor parallel, e.g., `--tensor-parallel-size 4` or enabling expert parallel, e.g., `--tensor-parallel-size 8 --enable-expert-parallel`."
+msgstr "目前，我们建议降低张量并行的程度，例如使用 `--tensor-parallel-size 4`，或者启用专家并行，例如使用 `--tensor-parallel-size 8 --enable-expert-parallel`。"
+
+#: ../../source/deployment/vllm.md:252 027c1c2d8d6a46a78c69451e96b6544a
+msgid "Context Length"
+msgstr "上下文长度"
+
+#: ../../source/deployment/vllm.md:254 a9dd53625c294f8682cc2fbedce37f45
+msgid "The context length for Qwen3 models in pretraining is up to 32,768 tokens. To handle context length substantially exceeding 32,768 tokens, RoPE scaling techniques should be applied. We have validated the performance of [YaRN](https://arxiv.org/abs/2309.00071), a technique for enhancing model length extrapolation, ensuring optimal performance on lengthy texts."
+msgstr "Qwen3 模型在预训练中的上下文长度最长为 32,768 个 token。为了处理显著超过 32,768 个 token 的上下文长度，应应用 RoPE 缩放技术。我们已经验证了 [YaRN](https://arxiv.org/abs/2309.00071) 的性能，这是一种增强模型长度外推的技术，可确保在长文本上的最佳性能。"
+
+#: ../../source/deployment/vllm.md:258 988e60ef751944c09274ce28aecf3fac
+msgid "vLLM supports YaRN, which can be configured as"
+msgstr "vLLM 支持 YaRN，可以配置为"
+
+#: ../../source/deployment/vllm.md:264 7da95eb3121944859d583a7a5885c5c4
+msgid "vLLM implements 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."
+msgstr "vLLM 实现了静态 YaRN，这意味着无论输入长度如何，缩放因子都保持不变，**这可能会对较短文本的性能产生影响。** 我们建议仅在需要处理长上下文时添加 `rope_scaling` 配置。还建议根据需要调整 `factor`。例如，如果您的应用程序的典型上下文长度为 65,536 个 token，则最好将 `factor` 设置为 2.0。"
+
+#: ../../source/deployment/vllm.md:270 fa10485203e3408dabb81687868ce059
+msgid "The default `max_position_embeddings` in `config.json` is set to 40,960, which used by vLLM, if `--max-model-len` is not specified. 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 and leave adequate room for model thinking. 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."
+msgstr "如果未指定 `--max-model-len`，`config.json` 中的默认 `max_position_embeddings` 被设置为 40,960，vLLM 将使用该值。此分配包括为输出保留 32,768 个 token，为典型提示保留 8,192 个 token，这足以应对大多数涉及短文本处理的场景，并为模型思考留出充足空间。如果平均上下文长度不超过 32,768 个 token，我们不建议在此场景中启用 YaRN，因为这可能会降低模型性能。"
+
+#: ../../source/deployment/vllm.md:275 fe82482bd3e1406998560b372e2707df
+msgid "Python Library"
+msgstr "Python 库使用"
+
+#: ../../source/deployment/vllm.md:277 82fb6b76e9c24978b9bee04927b3d5d4
+msgid "vLLM can also be directly used as a Python library, which is convenient for offline batch inference but lack some API-only features, such as parsing model generation to structure messages."
+msgstr "vLLM 也可以直接用作 Python 库，这对离线批量推理非常方便，但缺少一些仅限 API 的功能，例如将模型生成解析为结构化消息。"
+
+#: ../../source/deployment/vllm.md:279 857f6312cd4e44ccb34197793db59165
+msgid "The following shows the basic usage of vLLM as a library:"
+msgstr "以下展示了将 vLLM 用作库的基本用法："
+
+#: ../../source/deployment/vllm.md:316 0c88c07558e04cbd8f2e6cf04091ef62
+msgid "Since vLLM v0.9.0, you can also use the `LLM.chat` interface which includes support for `chat_template_kwargs`:"
+msgstr "自 vLLM v0.9.0 开始，`LLM.chat` 支持 `chat_template_kwargs` 参数，因而也可以使用以下方法："
+
+#: ../../source/deployment/vllm.md:347 de026655e79449f28854a1cbcc182d9f
+msgid "FAQ"
+msgstr "常见问题解答"
+
+#: ../../source/deployment/vllm.md:349 30e351b0aebb4e71b187d74895124662
+msgid "You may encounter OOM issues that are pretty annoying. We recommend two arguments for you to make some fix."
+msgstr "您可能会遇到令人烦恼的OOM（内存溢出）问题。我们推荐您尝试两个参数进行修复。"
+
+#: ../../source/deployment/vllm.md:352 cc5e992512ff4aa9bdede2e3791264f3
+msgid "The first one is `--max-model-len`. Our provided default `max_position_embedding` is `40960` and thus the maximum length for the serving is also this value, leading to higher requirements of memory. Reducing it to a proper length for yourself often helps with the OOM issue."
+msgstr "第一个参数是 `--max-model-len` 。我们提供的默认最大位置嵌入（`max_position_embedding`）为 40960 ，因此服务时的最大长度也是这个值，这会导致更高的内存需求。将此值适当减小通常有助于解决OOM问题。"
+
+#: ../../source/deployment/vllm.md:355 9e8f5e6e064841de8bfa0f581f28c25b
+msgid "Another argument you can pay attention to is `--gpu-memory-utilization`. vLLM will pre-allocate this much GPU memory. By default, it is `0.9`. This is also why you find a vLLM service always takes so much memory. If you are in eager mode (by default it is not), you can level it up to tackle the OOM problem. Otherwise, CUDA Graphs are used, which will use GPU memory not controlled by vLLM, and you should try lowering it. If it doesn't work, you should try `--enforce-eager`, which may slow down inference, or reduce the `--max-model-len`."
+msgstr "另一个您可以关注的参数是 `--gpu-memory-utilization` 。 vLLM将预分配该参数指定比例的显存。默认情况下，该值为 `0.9`。这也是为什么您发现一个vLLM服务总是占用大量内存的原因。如果你使用了eager模式（默认不是），您可以将其调高以应对OOM问题。反之，vLLM会使用CUDA Graphs，而CUDA Graphs会额外占用不受vLLM管理的显存；此时，您应当尝试降低`--gpu-memory-utilization`。如果还是无法解决，可以尝试`--enforce-eager`（这会影响推理效率）或缩小`--max-model-len`。"
+
+#: ../../source/deployment/vllm.md:364 2dd3f6552c53423ca7ce0576047f2ab6
+msgid "For more usage guide with vLLM, please see vLLM's [Qwen3 Usage Guide](https://github.com/vllm-project/vllm/issues/17327)."
+msgstr "有关 vLLM 的更多使用指南，请参阅 vLLM 的[Qwen3 使用指南](https://github.com/vllm-project/vllm/issues/17327)。"
+

docs/locales/zh_CN/LC_MESSAGES/framework/Langchain.po

@@ -0,0 +1,57 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/framework/Langchain.rst:2 6f9b66430d9c495592b1e275fdfd7c9e
+msgid "Langchain"
+msgstr ""
+
+#: ../../Qwen/source/framework/Langchain.rst:5 1205af46f88e4d6681003403109385c3
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/framework/Langchain.rst:7 115ee7b1c8404629a8f98175264cc114
+msgid "This guide helps you build a question-answering application based on a local knowledge base using ``Qwen2.5-7B-Instruct`` with ``langchain``. The goal is to establish a knowledge base Q&A solution."
+msgstr "本教程旨在帮助您利用 ``Qwen2.5-7B-Instruct`` 与 ``langchain`` ，基于本地知识库构建问答应用。目标是建立一个知识库问答解决方案。"
+
+#: ../../Qwen/source/framework/Langchain.rst:12
+#: 7257b95612fb423bb9ca73212fd12a02
+msgid "Basic Usage"
+msgstr "基础用法"
+
+#: ../../Qwen/source/framework/Langchain.rst:14
+#: fecf7a682dcc4c15a53da1f7cdf145e5
+msgid "The implementation process of this project includes loading files -> reading text -> segmenting text -> vectorizing text -> vectorizing questions -> matching the top k most similar text vectors with the question vectors -> incorporating the matched text as context along with the question into the prompt -> submitting to the Qwen2.5-7B-Instruct to generate an answer. Below is an example:"
+msgstr "您可以仅使用您的文档配合 ``langchain`` 来构建一个问答应用。该项目的实现流程包括加载文件 -> 阅读文本 -> 文本分段 -> 文本向量化 -> 问题向量化 -> 将最相似的前k个文本向量与问题向量匹配 -> 将匹配的文本作为上下文连同问题一起纳入提示 -> 提交给Qwen2.5-7B-Instruct生成答案。以下是一个示例："
+
+#: ../../Qwen/source/framework/Langchain.rst:98
+#: 6ad1ebd2ef4a49f9aa66cfdf777e1290
+msgid "After loading the Qwen2.5-7B-Instruct model, you should specify the txt file for retrieval."
+msgstr "加载Qwen2.5-7B-Instruct模型后，您可以指定需要用于知识库问答的txt文件。"
+
+#: ../../Qwen/source/framework/Langchain.rst:274
+#: 00467b1e4e294a26b9f49886633331e0
+msgid "Next Step"
+msgstr "下一步"
+
+#: ../../Qwen/source/framework/Langchain.rst:276
+#: 15ed906687054af78545290ba0746380
+msgid "Now you can chat with Qwen2.5 use your own document. Continue to read the documentation and try to figure out more advanced usages of model retrieval!"
+msgstr "现在，您可以在您自己的文档上与Qwen2.5进行交流。继续阅读文档，尝试探索模型检索的更多高级用法！"
+

docs/locales/zh_CN/LC_MESSAGES/framework/LlamaIndex.po

@@ -0,0 +1,95 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:2
+#: 2e41f8696c20488d8593b670c6361edf
+msgid "LlamaIndex"
+msgstr "LlamaIndex"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:5
+#: 20b3836fd391457bb00bf75b61e23e0d
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:7
+#: 86d9e6f0684749aab40a9824cd026fa3
+msgid "To connect Qwen2.5 with external data, such as documents, web pages, etc., we offer a tutorial on `LlamaIndex <https://www.llamaindex.ai/>`__. This guide helps you quickly implement retrieval-augmented generation (RAG) using LlamaIndex with Qwen2.5."
+msgstr "为了实现 Qwen2.5 与外部数据（例如文档、网页等）的连接，我们提供了 `LlamaIndex <https://www.llamaindex.ai/>`__ 的详细教程。本指南旨在帮助用户利用 LlamaIndex 与 Qwen2.5 快速部署检索增强生成（RAG）技术。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:11
+#: 71ed222858054687a5b33222bb6ac086
+msgid "Preparation"
+msgstr "环境准备"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:13
+#: 161d9153d6484dd5a1f1bdb340847814
+msgid "To implement RAG, we advise you to install the LlamaIndex-related packages first."
+msgstr "为实现检索增强生成（RAG），我们建议您首先安装与 LlamaIndex 相关的软件包。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:16
+#: a8d6acb1001a42c88185b971ae2de3bf
+msgid "The following is a simple code snippet showing how to do this:"
+msgstr "以下是一个简单的代码示例："
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:25
+#: e441d3b8fb6d4a13b52e1560ef250b16
+msgid "Set Parameters"
+msgstr "设置参数"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:27
+#: c2481804c3f34c7f883eed92ffa3111e
+msgid "Now we can set up LLM, embedding model, and the related configurations. Qwen2.5-Instruct supports conversations in multiple languages, including English and Chinese. You can use the ``bge-base-en-v1.5`` model to retrieve from English documents, and you can download the ``bge-base-zh-v1.5`` model to retrieve from Chinese documents. You can also choose ``bge-large`` or ``bge-small`` as the embedding model or modify the context window size or text chunk size depending on your computing resources. Qwen2.5 model families support a maximum of 32K context window size (up to 128K for 7B, 14B, 32B, and 72B, requiring extra configuration)"
+msgstr "现在，我们可以设置语言模型和向量模型。Qwen2.5-Instruct支持包括英语和中文在内的多种语言对话。您可以使用 ``bge-base-en-v1.5`` 模型来检索英文文档，下载 ``bge-base-zh-v1.5`` 模型以检索中文文档。根据您的计算资源，您还可以选择 ``bge-large`` 或 ``bge-small`` 作为向量模型，或调整上下文窗口大小或文本块大小。Qwen2.5模型系列支持最大32K上下文窗口大小（7B 、14B 、32B 及 72B可扩展支持 128K 上下文，但需要额外配置）"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:85
+#: 74c35d5a03734c289d162dfa3813ada6
+msgid "Build Index"
+msgstr "构建索引"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:87
+#: c49859d4ea5f49dba1fa2263f3ae284d
+msgid "Now we can build index from documents or websites."
+msgstr "现在我们可以从文档或网站构建索引。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:89
+#: b460d000037e4266a4d9f43d38f1f9b0
+msgid "The following code snippet demonstrates how to build an index for files (regardless of whether they are in PDF or TXT format) in a local folder named 'document'."
+msgstr "以下代码片段展示了如何为本地名为'document'的文件夹中的文件（无论是PDF格式还是TXT格式）构建索引。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:102
+#: a416d18b227940e29fac1f59851ff8c4
+msgid "The following code snippet demonstrates how to build an index for the content in a list of websites."
+msgstr "以下代码片段展示了如何为一系列网站的内容构建索引。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:118
+#: 487cf928d048424fa1b50438f701137c
+msgid "To save and load the index, you can use the following code snippet."
+msgstr "要保存和加载已构建的索引，您可以使用以下代码示例。"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:132
+#: c68419c4318d46e891f5df9191be6d2d
+msgid "RAG"
+msgstr "检索增强（RAG）"
+
+#: ../../Qwen/source/framework/LlamaIndex.rst:134
+#: 8ad20a8f43fe496084a40f963ba97440
+msgid "Now you can perform queries, and Qwen2.5 will answer based on the content of the indexed documents."
+msgstr "现在您可以输入查询，Qwen2.5 将基于索引文档的内容提供答案。"
+

docs/locales/zh_CN/LC_MESSAGES/framework/function_call.po

@@ -0,0 +1,415 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 16:36+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/framework/function_call.md:6 10546d07829648458ac4f91b91967697
+msgid "Function Calling"
+msgstr "函数调用"
+
+#: ../../source/framework/function_call.md:9 97bb46c965d44cb4900c947356c571fd
+msgid "Preface"
+msgstr "前言"
+
+#: ../../source/framework/function_call.md:11 539a099d2e764c8181e17c9c41f8053b
+msgid "Function calling with large language models is a huge and evolving topic. It is particularly important for AI applications:"
+msgstr "使用大型语言模型进行函数调用 (Function Calling) 是一个庞大且不断发展的主题。这对AI应用尤为重要："
+
+#: ../../source/framework/function_call.md:13 96e919c9808842ddb3225121c70a350b
+msgid "either for AI-native applications that strive to work around the shortcomings of current AI technology,"
+msgstr "无论是为了绕过当前AI技术的局限性，而设计的原生AI应用，"
+
+#: ../../source/framework/function_call.md:14 e7f29fd2c11b413bb08860d1a1c8ad8d
+msgid "or for existing applications that seeks the integration of AI technology to improve performance, user interaction and experience, or efficiency."
+msgstr "还是为了提升性能、用户体验或效率，寻求整合AI技术的现有应用。"
+
+#: ../../source/framework/function_call.md:16 cc49601082014a989c503f4461c8a942
+msgid "We will talk about how Qwen3 can be used to support function calling and how it can be used to achieve your goals, from the inference usage for developing application to the inner workings for hardcore customizations.  In this guide,"
+msgstr "我们将讨论如何使用 Qwen3 来支持函数调用，以及如何利用它来实现您的目标，从用于开发应用程序的推理用法到针对硬核定制的内部工作机制。在本指南中，"
+
+#: ../../source/framework/function_call.md:18 bad8e302d5044edd80cb9da02c0f6dbe
+msgid "We will first demonstrate how to use function calling with Qwen3."
+msgstr "我们首先将展示如何使用Qwen3进行函数调用。"
+
+#: ../../source/framework/function_call.md:19 41f975e599264589af4819e9aee96f76
+msgid "Then, we will introduce the technical details on functional calling with Qwen3, which are mainly about the templates."
+msgstr "接着，我们将介绍使用Qwen3行函数调用的技术细节，主要涉及模板的使用。"
+
+#: ../../source/framework/function_call.md:21 cad1eaec5df646509123bd97566c69c5
+msgid "Before starting, there is one thing we have not yet introduced, that is ..."
+msgstr "在开始之前，还有一件事我们尚未介绍，那就是…"
+
+#: ../../source/framework/function_call.md:23 129f1c1d7bd7486f80955cda6cf77e3f
+msgid "What is function calling?"
+msgstr "什么是函数调用？"
+
+#: ../../source/framework/function_call.md:26 cdf0c1412f234bd8bcc386683a38b131
+msgid "There is another term \"tool use\" that may be used to refer to the same concept. While some may argue that tools are a generalized form of functions, at present, their difference exists only technically as different I/O types of programming interfaces."
+msgstr "这一概念也可能被称为“工具使用” (\"tool use\")。虽然有人认为“工具”是“函数”的泛化形式，但在当前，它们的区别仅在技术层面上，表现为编程接口的不同输入输出类型。"
+
+#: ../../source/framework/function_call.md:30 93085d6f71dd4349832e0c8832b57966
+msgid "Large language models (LLMs) are powerful things. However, sometimes LLMs by themselves are simply not capable enough."
+msgstr "大型语言模型（LLMs）确实强大。然而，有时候单靠大型语言模型的能力还是不够的。"
+
+#: ../../source/framework/function_call.md:32 d441a861290d4a0aaa6fea713b628287
+msgid "On the one hand, LLMs have inherent modeling limitations.  For one, they do not know things that are not in their training data, which include those happened after their training ended. In addition, they learn things in the way of likelihood, which suggests that they may not be precise enough for tasks with fixed rule sets, e.g., mathematical computation."
+msgstr "一方面，大型语言模型存在建模局限性。首先，对于训练数据中没有的信息，包括训练结束后发生的事情，它们并不了解。此外，它们通过概率方式学习，这意味着对于有固定规则集的任务，如数学计算，可能不够精确。"
+
+#: ../../source/framework/function_call.md:35 f52f0935e2a346e3b1631eeaf2223fb0
+msgid "On the other hand, it is not easy to use LLMs as a Plug-and-Play service programmatically with other things. LLMs mostly talk in words that are open to interpretation and thus ambiguous, while other software or applications or systems talk in code and through programming interfaces that are pre-defined and fixed and structured."
+msgstr "另一方面，将大型语言模型作为即插即用服务与其它系统进行编程式协作，并非易事。大型语言模型的表达多含主观解释成分，因而产生歧义；而其他软件、应用或系统则通过预定义、固定和结构化的代码及编程接口进行沟通。"
+
+#: ../../source/framework/function_call.md:38 4ff86e51b366418ba9cd2ff9a8fceb27
+msgid "To this end, function calling establishes a common protocol that specifies how LLMs should interact with the other things. The procedure is mainly as follows:"
+msgstr "为此，函数调用确立了一个通用协议，规定了大型语言模型应与其他实体互动的流程。主要流程如下："
+
+#: ../../source/framework/function_call.md:40 1bc24a6d6a5140cdb2f274b7df61a429
+msgid "The application provides a set of functions and the instructions of the functions to an LLM."
+msgstr "应用程序向大型语言模型提供一组函数及其使用说明。"
+
+#: ../../source/framework/function_call.md:41 8569c9c13fd34caab163f4f9154e45bc
+msgid "The LLM choose to or not to, or is forced to use one or many of the functions, in response to user queries."
+msgstr "大型语言模型根据用户查询，选择使用或不使用，或被迫使用一个或多个函数。"
+
+#: ../../source/framework/function_call.md:42 dac3cb931c3c4755b276886d5568340a
+msgid "If the LLM chooses to use the functions, it states how the functions should be used based on the function instructions."
+msgstr "如果大型语言模型选择使用这些函数，它会根据函数说明如何使用。"
+
+#: ../../source/framework/function_call.md:43 a6439df6e0354e96b321fbfaa260dbd1
+msgid "The chosen functions are used as such by the application and the results are obtained, which are then given to the LLM if further interaction is needed."
+msgstr "应用程序按照选择使用这些函数，并获取结果。如果需要进一步互动，结果将提供给大型语言模型。"
+
+#: ../../source/framework/function_call.md:45 8cef5c9125154720952742a4f51e19e2
+msgid "There are many ways for LLMs to understand and follow this protocol. As always, the key is prompt engineering or an internalized template known by the model. We recommend using Hermes-style tool use for Qwen3 to maximize function calling performance."
+msgstr "大型语言模型（LLMs）有许多方式来理解和遵循该协议。一如既往，关键在于提示工程或模型已内化的模板。我们建议对 Qwen3 使用 Hermes 风格的工具调用方法，以最大化函数调用性能。"
+
+#: ../../source/framework/function_call.md:49 486bf0eaff5449f3966f948cf341570f
+msgid "Inference with Function Calling"
+msgstr "使用函数调用进行推理"
+
+#: ../../source/framework/function_call.md:51 6d50be829cba4f43b587c494dc74a820
+msgid "As function calling is essentially implemented using prompt engineering, you could manually construct the model inputs for Qwen3 models. However, frameworks with function calling support can help you with all that laborious work."
+msgstr "由于函数调用本质上是通过提示工程实现的，您可以手动构建Qwen3模型的输入。但是，支持函数调用的框架可以帮助您完成所有繁重的工作。"
+
+#: ../../source/framework/function_call.md:54 5afa6df4e2d94df89b26b66bce596264
+msgid "In the following, we will introduce the usage (via dedicated function calling chat template) with"
+msgstr "接下来，我们将介绍（通过专用的函数调用模板）使用"
+
+#: ../../source/framework/function_call.md:55 380f90e66ba44ad686e981536dd29e12
+msgid "**Qwen-Agent**,"
+msgstr "**Qwen-Agent**，"
+
+#: ../../source/framework/function_call.md:56 79b6f6475bc64a7bbe397ba0c94d43b1
+msgid "**vLLM**."
+msgstr "**vLLM**。"
+
+#: ../../source/framework/function_call.md:58 30fff59c00c64a70821c167a944fd3f7
+msgid "The Example Case"
+msgstr "案例"
+
+#: ../../source/framework/function_call.md:60 2b4cdb8daedd4da49877af5ecc67ba8b
+msgid "Let's also use an example to demonstrate the inference usage. We assume **Python 3.11** is used as the programming language."
+msgstr "我们同样通过一个示例来展示推理的使用方法。假设我们使用的编程语言是**Python 3.11**。"
+
+#: ../../source/framework/function_call.md:63 ae5619a2a7ff41608d3420cd0caaba79
+msgid "**Scenario**: Suppose we would like to ask the model about the temperature of a location. Normally, the model would reply that it cannot provide real-time information. But we have two tools that can be used to obtain the current temperature of and the temperature at a given date of a city respectively, and we would like the model to make use of them."
+msgstr "**场景**：假设我们要询问模型某个地点的温度。通常��模型会回答无法提供实时信息。但我们有两个工具，可以分别获取城市的当前温度和指定日期的温度，我们希望模型能够利用这些工具。"
+
+#: ../../source/framework/function_call.md:67 2617f66327e64038a5933bd825f099b8
+msgid "To set up the example case, you can use the following code:"
+msgstr "为了这个示例案例，您可以使用以下代码："
+
+#: ../../source/framework/function_call.md a419b632036846fdb90427683502c597
+msgid "Preparation Code"
+msgstr "准备代码"
+
+#: ../../source/framework/function_call.md:173 77ce44e0fb3b43f6814da6a2ad36e511
+msgid "In particular, the tools should be described using JSON Schema and the messages should contain as much available information as possible. You can find the explanations of the tools and messages below:"
+msgstr "工具应使用JSON Schema进行描述，消息应包含尽可能多的有效信息。您可以在下面找到工具和消息的解释："
+
+#: ../../source/framework/function_call.md 48a8432a5d384a4ba10f39fcea96b825
+msgid "Example Tools"
+msgstr "示例工具"
+
+#: ../../source/framework/function_call.md:178 f18d3697d6c347a2b407b21ae874f865
+msgid "The tools should be described using the following JSON:"
+msgstr "工具应使用以下JSON进行描述："
+
+#: ../../source/framework/function_call.md:242 6e55bd9040be4bc296ed948788780347
+msgid "For each **tool**, it is a JSON object with two fields:"
+msgstr "对于每个**工具**，它是一个具有两个字段的JSON object："
+
+#: ../../source/framework/function_call.md:243 ae43f666fcab4e5b93ff009688305fce
+msgid "`type`: a string specifying the type of the tool, currently only `\"function\"` is valid"
+msgstr "`type`：string，用于指定工具类型，目前仅`\"function\"`有效"
+
+#: ../../source/framework/function_call.md:244 35cc77d63bf6455bb3376bec483b0f9b
+msgid "`function`: an object detailing the instructions to use the function"
+msgstr "`function`：object，详细说明了如何使用该函数"
+
+#: ../../source/framework/function_call.md:246 b6f78c8fbb9b40d5a6c0c10e5273b85e
+msgid "For each **function**, it is a JSON object with three fields:"
+msgstr "对于每个**function**，它是一个具有三个字段的JSON object："
+
+#: ../../source/framework/function_call.md:247 0905c8ca11bb4454abb26ba42a3b29c3
+msgid "`name`: a string indicating the name of the function"
+msgstr "`name`：string 表示函数名称"
+
+#: ../../source/framework/function_call.md:248 d787950be0144e0a83f18d7a06d43de0
+msgid "`description`: a string describing what the function is used for"
+msgstr "`description`：string 描述函数用途"
+
+#: ../../source/framework/function_call.md:249 ba88a6e75ae8462d892a3ec3e9a6edaa
+msgid "`parameters`: [a JSON Schema](https://json-schema.org/learn/getting-started-step-by-step) that specifies the parameters the function accepts. Please refer to the linked documentation for how to compose a JSON Schema. Notable fields include `type`, `required`, and `enum`."
+msgstr "`parameters`：[JSON Schema](https://json-schema.org/learn/getting-started-step-by-step)，用于指定函数接受的参数。请参阅链接文档以了解如何构建JSON Schema。值得注意的字段包括`type`、`required`和`enum`。"
+
+#: ../../source/framework/function_call.md:251 abd8fe46919340a582f532932f9c1b52
+msgid "Most frameworks use the tool format and some may use the function format. Which one to use should be obvious according to the naming."
+msgstr "大多数框架使用“工具”格式，有些可能使用“函数”格式。根据命名，应该很明显应该使用哪一个。"
+
+#: ../../source/framework/function_call.md 6c17006423714b9bb29379bd3674e1a0
+msgid "Example Messages"
+msgstr "示例消息"
+
+#: ../../source/framework/function_call.md:258 1cd11a9c9f9b4f2ba308599a87f82613
+msgid "Our query is `What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30.`."
+msgstr ""
+
+#: ../../source/framework/function_call.md:267 3f124f3c5ef54673bb6e12d8bd1bada3
+msgid "Qwen-Agent"
+msgstr ""
+
+#: ../../source/framework/function_call.md:269 761ea5172da64e9d8911cc567d7e7779
+msgid "[Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) is actually a Python Agent framework for developing AI applications. Although its intended use cases are higher-level than efficient inference, it does contain the **canonical implementation** of function calling for Qwen3. It provides the function calling ability for Qwen3 to an OpenAI-compatible API through templates that is transparent to users."
+msgstr "[Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) 实际上是一个用于开发AI应用的Python智能体框架。尽管其设计用例比高效推理更高级，但它确实包含了Qwen3函数调用的**规范实现**。基于OpenAI兼容API，它可以通过模板为Qwen3提供了对用户透明的的函数调用能力。"
+
+#: ../../source/framework/function_call.md:273 194c41677b7b4a6a81802980f4973988
+msgid "It is worth noting that for reasoning models like Qwen3, it is *not recommended* to use tool call template based on stopwords, such as ReAct, because the model may output stopwords in the thought section, potentially leading to unexpected behavior in tool calls."
+msgstr ""
+
+#: ../../source/framework/function_call.md:275 02e0092b1db04537bb75bb8a9728b0c9
+msgid "Before starting, let's make sure the latest library is installed:"
+msgstr "在开始之前，让我们确保已安装了最新的库："
+
+#: ../../source/framework/function_call.md:280
+#: ../../source/framework/function_call.md:450 8e49db2c62cc438193a1a385778c9908
+msgid "Preparing"
+msgstr "准备工作"
+
+#: ../../source/framework/function_call.md:282 1181a68368ce484f9beec38d971108aa
+msgid "Qwen-Agent can wrap an OpenAI-compatible API that does not support function calling. You can serve such an API with most inference frameworks or obtain one from cloud providers like DashScope or Together."
+msgstr "Qwen-Agent可以封装一个不支持函数调用的OpenAI兼容API。您可以使用大多数推理框架来提供此类API，或者从DashScope或Together等云提供商处获取一个。"
+
+#: ../../source/framework/function_call.md:285 d7708c50cf554212866c284d73a79c9e
+msgid "Assuming there is an OpenAI-compatible API at `http://localhost:8000/v1`, Qwen-Agent provides a shortcut function `get_chat_model` to obtain a model inference class with function calling support:"
+msgstr "假设在`http://localhost:8000/v1`处有一个OpenAI兼容API，Qwen-Agent提供了一个快捷函数`get_chat_model`，用于获取具有函数调用支持的模型推理类："
+
+#: ../../source/framework/function_call.md:302 e5676cec6583445888cf806ef54de829
+msgid "In the above, `model_server` is the `api_base` common used in other OpenAI-compatible API clients. It is advised to provide the `api_key` (but not via plaintext in the code), even if the API server does not check it, in which case, you can set it to anything. You can pass model parameters to the model by `generate_cfg`. Here we demonstrate how to control the think and no_think modes of Qwen3.  Different APIs may have different control methods."
+msgstr "在上述代码中，`model_server` 是其他兼容 OpenAI 的 API 客户端常用的 `api_base`。建议提供 `api_key`（但不要以代码中的明文形式提供），即使 API 服务器不检查它，在这种情况下，您可以将其设置为任意值。您可以通过 `generate_cfg` 将模型参数传递给模型。在此我们演示如何控制 Qwen3 的思考与非思考模式。不同的 API 可能有不同的控制方法。"
+
+#: ../../source/framework/function_call.md:307 42c1289baeef45b1a471e606bdafbe9a
+msgid "For model inputs, the common message structure for system, user, and assistant history should be used:"
+msgstr "对于模型输入，应使用系统、用户和助手历史记录的通用消息结构："
+
+#: ../../source/framework/function_call.md:313 64e0a941165d49299e80aa8270f10bfb
+msgid "At the time, Qwen-Agent works with functions instead of tools. This requires a small change to our tool descriptions, that is, extracting the function fields:"
+msgstr "目前，Qwen-Agent使用“函数”而非“工具”。这需要对我们工具描述进行一些小的更改，即提取函数字段："
+
+#: ../../source/framework/function_call.md:320
+#: ../../source/framework/function_call.md:482 6babaeb87a48402086b0db01d6a0c5e2
+msgid "Tool Calls and Tool Results"
+msgstr "工具调用和工具结果"
+
+#: ../../source/framework/function_call.md:322 53c98c106e2542f49d418348118717ea
+msgid "To interact with the model, the `chat` method should be used:"
+msgstr "为了与模型交互，应使用`chat`方法："
+
+#: ../../source/framework/function_call.md:333 a0e820c457e146298945b5df4cc918c5
+msgid "The `chat` method returns a generator of list, each of which may contain multiple messages."
+msgstr "`chat`方法返回一个列表的生成器，每个列表可能包含多条消息。"
+
+#: ../../source/framework/function_call.md:336 4627b7f2ddd9427aa10a127ea5d0d2b4
+msgid "The results of `no_think` mode:"
+msgstr ""
+
+#: ../../source/framework/function_call.md:344 bc34f89540c044d3809f29474f5cfe43
+msgid "The results of `think` mode:"
+msgstr ""
+
+#: ../../source/framework/function_call.md:353 89732d0ca8ce4d93b666cdd51f8e126a
+msgid "As we can see, Qwen-Agent attempts to parse the model generation in an easier to use structural format. The details related to function calls are placed in the `function_call` field of the messages:"
+msgstr "我们可以看到，Qwen-Agent试图以更易于使用的结构化格式解析模型生成。与函数调用相关的详细信息被放置在消息的`function_call`字段中："
+
+#: ../../source/framework/function_call.md:355 d08d78b0219a4bbda4b6431e7f661eaa
+msgid "`name`: a string representing the function to call"
+msgstr "`name`：代表要调用的函数的字符串"
+
+#: ../../source/framework/function_call.md:356 5a9245e840994576a89c28e4ce4f9378
+msgid "`arguments`: a JSON-formatted string representing the arguments the function should be called with"
+msgstr "`arguments`：表示函数应��有的参数的JSON格式字符串"
+
+#: ../../source/framework/function_call.md:358 e108e1ea05564aac9a398e1093dab1ce
+msgid "In the thinking mode, it will first generate a thought and then generate the tool call(s)."
+msgstr ""
+
+#: ../../source/framework/function_call.md:360 50cc88e82a004ab99199f46549f4aaa2
+msgid "Then comes the critical part -- checking and applying the function call:"
+msgstr "接下来是关键部分——检查和应用函数调用："
+
+#: ../../source/framework/function_call.md:376 6992f24f3f984594ac99e4267cd20144
+msgid "To get tool results:"
+msgstr "获取工具结果："
+
+#: ../../source/framework/function_call.md:377 23a3a2cbf74347948c6629be3d68be0f
+msgid "line 1: We should iterate the function calls in the order the model generates them."
+msgstr "第1行：我们应该按模型生成它们的顺序迭代函数调用。"
+
+#: ../../source/framework/function_call.md:378 762ba5a6310248dc886921fa542aa667
+msgid "line 2: We can check if a function call is needed as deemed by the model by checking the `function_call` field of the generated messages."
+msgstr "第2行：通过检查生成消息的`function_call`字段，我们可以查看是否需要按模型判断进行函数调用。"
+
+#: ../../source/framework/function_call.md:379 bfbb86b6b1b24ca598e6402043417cbf
+msgid "line 3-4: The related details including the name and the arguments of the function can also be found there, which are `name` and `arguments` respectively."
+msgstr "第3-4行：相关详情，包括函数名称和参数，也可以在那里找到，分别是`name`和`arguments`。"
+
+#: ../../source/framework/function_call.md:380 7d108413597041c48363681e79da9813
+msgid "line 6: With the details, one should call the function and obtain the results. Here, we assume there is a function named [`get_function_by_name`](#prepcode) to help us get the related function by its name."
+msgstr "第6行：有了这些细节，应该调用函数并获取结果。这里，我们假设有一个名为[`get_function_by_name`](#prepcode)的函数来帮助我们根据名称获取相关函数。"
+
+#: ../../source/framework/function_call.md:382 237839b4eb4048f6b22ab8d9c94f20c4
+msgid "line 8-12: With the result obtained, add the function result to the messages as `content` and with `role` as `\"function\"`."
+msgstr "第8-12行：获得结果后，将函数结果作为`content`添加到消息中，并将`role`设置为`\"function\"`。"
+
+#: ../../source/framework/function_call.md:384 556c8b3b12544c5ab2fb8e5d2b7a818c
+#, fuzzy
+msgid "Now the messages are:"
+msgstr "现在消息是"
+
+#: ../../source/framework/function_call.md:386
+#: ../../source/framework/function_call.md:421 dce3c134764b4690b2b0b37e36a9dbcb
+#: edd9cf9e63af4a869eb3e7bb07c88328
+msgid "`no_think` mode:"
+msgstr ""
+
+#: ../../source/framework/function_call.md:397
+#: ../../source/framework/function_call.md:428 2f611a03bd624b2db666fb07fa8f658d
+#: c18021fb05d5485ebe2e1afa6371ef65
+msgid "`think` mode:"
+msgstr ""
+
+#: ../../source/framework/function_call.md:409
+#: ../../source/framework/function_call.md:570 a5f394f05e9a4f80958a16e43ed31e7d
+msgid "Final Response"
+msgstr "最终响应"
+
+#: ../../source/framework/function_call.md:411 215d04b89c1749f99831d4baa72f678d
+msgid "Finally, run the model again to get the final model results:"
+msgstr "最后，再次运行模型以获取最终的模型结果："
+
+#: ../../source/framework/function_call.md:419 823711ca9c364335948f2e994740417e
+msgid "The final response should be like"
+msgstr "最终响应应如下所示"
+
+#: ../../source/framework/function_call.md:438 a5f84b2e746e4669bd836f43afaf16a2
+msgid "vLLM"
+msgstr ""
+
+#: ../../source/framework/function_call.md:440 4d64c942ff674ba88a9753c25635374d
+msgid "vLLM is a fast and easy-to-use library for LLM inference and serving. It uses the tokenizer from `transformers` to format the input, so we should have no trouble preparing the input. In addition, vLLm also implements helper functions so that generated tool calls can be parsed automatically if the format is supported."
+msgstr "vLLM 是一个快速且易于使用的库，用于大型语言模型的推理和部署。它使用 `transformers` 中的分词器来格式化输入，因此我们在准备输入时应该不会遇到任何问题。此外，vLLM 还实现了辅助函数，以便在支持的情况下自动解析生成的工具调用。"
+
+#: ../../source/framework/function_call.md:444 f65e19e7888c4d9ea42f4c82ca89b496
+msgid "`vllm` >= v0.8.5."
+msgstr ""
+
+#: ../../source/framework/function_call.md:446 6df4774659a84791b0dff63ed1b211c1
+msgid "For more information, check the [vLLM documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#tool-calling-in-the-chat-completion-api)."
+msgstr "更多信息，请查阅 [vLLM 文档](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#tool-calling-in-the-chat-completion-api)"
+
+#: ../../source/framework/function_call.md:448 c134b90394c941d49115838d2280a343
+msgid "We will use the OpenAI-Compatible API by `vllm` with the API client from the `openai` Python library."
+msgstr "在本指南中，我们将使用 `vllm` 提供的 OpenAI 兼容 API，并通过 `openai` Python 库的 API 客户端来进行操作。"
+
+#: ../../source/framework/function_call.md:452 401f8cd3cf204f459a7f7c42e7dc43e7
+msgid "For Qwen3, the chat template in tokenizer_config.json has already included support for the Hermes-style tool use. We simply need to start a OpenAI-compatible API with vLLM:"
+msgstr "对于 Qwen3，`tokenizer_config.json` 中的聊天模板已经包含了对 Hermes 风格工具调用的支持。我们只需要启动一个由 vLLM 提供的 OpenAI 兼容 API 即可："
+
+#: ../../source/framework/function_call.md:459 e27b0ff05a97431dbaa2a18d4e5b6ab5
+msgid "The inputs are the same with those in [the preparation code](#prepcode):"
+msgstr "输入与[准备代码](#prepcode)中的相同："
+
+#: ../../source/framework/function_call.md:466 bac07622ec554e9ba4090940724d8d21
+msgid "Let's also initialize the client:"
+msgstr "我们先初始化API客户端："
+
+#: ../../source/framework/function_call.md:484 46d45caf4eab44c69ad519d82e84818c
+msgid "We can use the create chat completions endpoint to query the model.  Here is an example of the `no_think` mode:"
+msgstr "我们可以使用create chat completions endpoint直接查询底层API。以下是使用非思考模式的例子："
+
+#: ../../source/framework/function_call.md:502 4198241de2fb4e4ba5433b0c579734e1
+msgid "vLLM should be able to parse the tool calls for us, and the main fields in the response (`response.choices[0]`) should be like"
+msgstr "vLLM应当可以为我们解析工具调用，回复的主要字段(`response.choices[0]`)应如下所示："
+
+#: ../../source/framework/function_call.md:529 050ffcaa034f4cd7b1405ab5a561b969
+msgid "Note that the function arguments are JSON-formatted strings, which Qwen-Agent follows."
+msgstr "请注意这里函数的参数是JSON格式字符串，Qwen-Agent与其一致。"
+
+#: ../../source/framework/function_call.md:531 e3012b896829473cb0e1802047f5819e
+msgid "As before, chances are that there are corner cases where tool calls are generated but they are malformed and cannot be parsed. For production code, we should try parsing by ourselves."
+msgstr "如前所述，有可能存在边界情况，模型生成了工具调用但格式不良也无法被解析。对于生产代码，我们需要尝试自行解析。"
+
+#: ../../source/framework/function_call.md:534 de4fb4d7f1b342e0849b049e81fb8585
+msgid "Then, we can obtain the tool results and add them to the messages as shown below:"
+msgstr "随后，我们可以调用工具并获得结果，然后将它们加入消息中："
+
+#: ../../source/framework/function_call.md:555 e5e63bf3a7e34d0683d244549cbbbce1
+msgid "It should be noted that the OpenAI API uses `tool_call_id` to identify the relation between tool results and tool calls."
+msgstr "这里需要注意OpenAI API使用`tool_call_id`字段来识别工具结果和工具调用间的联系。"
+
+#: ../../source/framework/function_call.md:557 deda1dccce204294ba69c74f24e4588f
+msgid "The messages are now like"
+msgstr "现在消息如下："
+
+#: ../../source/framework/function_call.md:572 2dd5c4ae2dd84633809c8365c10fdaa8
+msgid "Let's call the endpoint again to seed the tool results and get response:"
+msgstr "让我们再次查询接口，以给模型提供工具结果并获得回复："
+
+#: ../../source/framework/function_call.md:589 15f3ce61d4044fb1a06f75bdeb8140b2
+msgid "The final response (`response.choices[0].message.content`) should be like"
+msgstr "最终响应 (`response.choices[0].message.content`)应如"
+
+#: ../../source/framework/function_call.md:595 1e8b7940bbbc46a8bbafb59afb086819
+msgid "Finally"
+msgstr "最后"
+
+#: ../../source/framework/function_call.md:597 b588a910fcef435183d4d476851c10fb
+msgid "In whichever way you choose to use function calling with Qwen3, keep in mind that the limitation and the perks of prompt engineering applies:"
+msgstr "无论你选择哪种方式在Qwen3中使用函数调用，请记住提示工程的限制和优势适用："
+
+#: ../../source/framework/function_call.md:598 feaec442d07c4d3fa7e20d3dd9724db1
+msgid "It is not guaranteed that the model generation will always follow the protocol even with proper prompting or templates. Especially, for the templates that are more complex and relies more on the model itself to think and stay on track than the ones that are simpler and relies on the template and the use of control or special tokens. The latter one, of course, requires some kind of training. In production code, be prepared that if it breaks, countermeasures or rectifications are in place."
+msgstr "无法保证模型生成将始终遵循协议，即使有适当的提示或模板。特别是对于那些更复杂且更多依赖于模型本身思考和保持方向的模板，而非那些更简单且依赖于模板以及控制或特殊标记使用的模板。当然，后者需要某种训练。在生产代码中，要准备好如果出现问题，采取补救措施或修正措��。"
+
+#: ../../source/framework/function_call.md:602 d86a7ee6f6f64e40bea8bdb0991f3361
+msgid "If in certain scenarios, the generation is not up to expectation, you can refine the template to add more instructions or constraints. While the templates mentioned here are general enough, they may not be the best or the most specific or the most concise for your use cases. The ultimate solution is fine-tuning using your own data."
+msgstr "如果在某些场景下，生成结果未达到预期，你可以细化模板以添加更多指令或约束。尽管这里提到的模板足够通用，但对于你的具体使用案例，它们可能不是最佳的、最具体的或最简洁的。最终解决方案是使用你自己的数据进行微调。"
+
+#: ../../source/framework/function_call.md:606 e09bd8deef0e413698e55cc1dfbc3283
+msgid "Have fun prompting!"
+msgstr "享受提示的乐趣吧！"

docs/locales/zh_CN/LC_MESSAGES/framework/qwen_agent.po

@@ -0,0 +1,68 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-05-16 18:57+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/framework/qwen_agent.rst:2 74719c4bae294c5ea93e9f8542cef14c
+msgid "Qwen-Agent"
+msgstr "Qwen-Agent"
+
+#: ../../source/framework/qwen_agent.rst:4 2a3d08cd70a34436bf5d9e1617a4d392
+msgid "`Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ is a framework for developing LLM applications based on the instruction following, tool usage, planning, and memory capabilities of Qwen."
+msgstr "`Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ 是一个基于 Qwen 的指令跟随、工具使用、计划和记忆能力来开发 LLM 应用程序的框架。"
+
+#: ../../source/framework/qwen_agent.rst:8 ada0e9f26c6748768f66c1c62e4b6d75
+msgid "This is a simple tutorial on using Qwen-Agent to quickly experience the agentic capabilities of Qwen3. For more detailed information, please refer to `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ repository."
+msgstr "本教程展示基于 Qwen-Agent 快速体验 Qwen3 智能体能力的流程。更多信息请参考 `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ 仓库。"
+
+#: ../../source/framework/qwen_agent.rst:14 b0997eeb63844471b1637075add23cb0
+msgid "Installation"
+msgstr "安装"
+
+#: ../../source/framework/qwen_agent.rst:16 b6ba4e319cd24dee88d5cdbde60b096b
+msgid "Install the stable version from PyPI:"
+msgstr "从 PyPI 安装 Qwen-Agent 的稳定版本："
+
+#: ../../source/framework/qwen_agent.rst:29 3f5ac104f7a647b99b1146d72fdda96d
+msgid "Developing Your Own Agent"
+msgstr "开发您自己的智能体"
+
+#: ../../source/framework/qwen_agent.rst:31 e85c4ea6d3d9406da3823cb4f188ffc4
+msgid "Qwen3 excels in tool calling capabilities. Qwen-Agent encapsulates tool-calling templates and tool-calling parsers internally, greatly reducing coding complexity."
+msgstr "Qwen3 在工具调用能力方面表现出色。Qwen-Agent 内部封装了工具调用模板和工具调用解析器，大大降低了编码复杂性。"
+
+#: ../../source/framework/qwen_agent.rst:35 d63624897ee340fb8d31eeea6a02e995
+msgid "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."
+msgstr "要定义可用的工具，您可以使用 MCP 配置文件，使用 Qwen-Agent 的集成工具，或者自行集成其他工具。"
+
+#: ../../source/framework/qwen_agent.rst:112 ada0e9f26c6748768f66c1c62e4b6d75
+msgid "For more detailed examples and MCP cookbooks, please refer to `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ repository."
+msgstr "有关更详细的示例和 MCP 使用指南，请参阅 `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ 仓库。"
+
+#~ msgid "To be updated for Qwen3."
+#~ msgstr "仍需为Qwen3更新。"
+
+#~ msgid "Qwen-Agent provides atomic components such as LLMs and prompts, as well as high-level components such as Agents. The example below uses the Assistant component as an illustration, demonstrating how to add custom tools and quickly develop an agent that uses tools."
+#~ msgstr "Qwen-Agent 提供包括语言模型和提示词等原子级组件，及智能体等高级组件在内的多种组件。以下示例选取助理组件进行展示，阐述了如何整合自定义工具以及如何迅速开发出一个能够应用这些工具的代理程序。"
+
+#~ msgid "The framework also provides more atomic components for developers to combine. For additional showcases, please refer to `examples <https://github.com/QwenLM/Qwen-Agent/tree/main/examples>`__."
+#~ msgstr "该框架还为开发者提供了更多的原子组件以供组合使用。欲了解更多示例，请参见 `examples <https://github.com/QwenLM/Qwen-Agent/tree/main/examples>`__。"
+
+#~ msgid "This is the simplest tutorial on using Qwen-Agent to quickly experience the agentic capabilities of Qwen3. For more detailed information, please refer to `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ repository."
+#~ msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/getting_started/concepts.po

@@ -0,0 +1,497 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/getting_started/concepts.md:1
+#: 581ec8a4d8dd4b5a99caf167b796a6e9
+msgid "Key Concepts"
+msgstr "核心概念"
+
+#: ../../Qwen/source/getting_started/concepts.md:4
+#: fc803dd8f02a4caf9be29e42364659a0
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/getting_started/concepts.md:7
+#: 834244ff25a040fe91f63682732dd416
+msgid "Qwen"
+msgstr "通义千问 (Qwen)"
+
+#: ../../Qwen/source/getting_started/concepts.md:9
+#: ee9dee3630614908860b2144007186fd
+msgid "Qwen (Chinese: 通义千问; pinyin: _Tongyi Qianwen_) is the large language model and large multimodal model series of the Qwen Team, Alibaba Group.  Qwen is capable of natural language understanding, text generation, vision understanding, audio understanding, tool use, role play, playing as AI agent, etc.  Both language models and multimodal models are pre-trained on large-scale multilingual and multimodal data and post-trained on quality data for aligning to human preferences."
+msgstr "通义千问（英文： Qwen ；读作： _kùn_）是由阿里巴巴通义千问团队开发的大规模语言和多模态系列模型。通义千问可以执行自然语言理解、文本生成、视觉理解、音频理解、工具调用、角色扮演、智能体等多种任务。语言和多模态模型均在大规模、多语言、多模态数据上进行预训练，并在高质量语料上后训练以与人类偏好对齐。"
+
+#: ../../Qwen/source/getting_started/concepts.md:13
+#: 6a37d9a0b6e2414a9b7ede0e095476af
+msgid "There is the proprietary version and the open-weight version."
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:15
+#: 4fba11f4661b4e469f88dc3917b27427
+msgid "The proprietary versions include"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:16
+#: ../../Qwen/source/getting_started/concepts.md:31
+#: be8423cea0b447c2b15de596c120f541 d07679ae34d0463f96aeff896a759118
+msgid "Qwen: the language models"
+msgstr "通义千问 (Qwen)：语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:17
+#: a1461ec445034ba099aa58b1a13375a0
+#, fuzzy
+msgid "Qwen Max"
+msgstr "通义千问 (Qwen)"
+
+#: ../../Qwen/source/getting_started/concepts.md:18
+#: 19f8d7108d69464a8d1ce2980c1e4e92
+#, fuzzy
+msgid "Qwen Plus"
+msgstr "通义千问 (Qwen)"
+
+#: ../../Qwen/source/getting_started/concepts.md:19
+#: ede369bc8dd24052ad674131f4a3b68a
+msgid "Qwen Turbo"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:20
+#: ../../Qwen/source/getting_started/concepts.md:36
+#: ddb0acdec40b4f79a3e6517f86727e4b e4df2227d36a46ee8644ce77f9fc1dc0
+msgid "Qwen-VL: the vision-language models"
+msgstr "通义千问 VL (Qwen-VL): 视觉语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:21
+#: f9f5a5b50af44e90999a87661cdf4e5a
+msgid "Qwen-VL Max"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:22
+#: fd0074955211498c8520ef3405bf312f
+msgid "Qwen-VL Plus"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:23
+#: 40c8d32d570c4a76a5392c8e296c3793
+msgid "Qwen-VL OCR"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:24
+#: ../../Qwen/source/getting_started/concepts.md:39
+#: c0e45bd6e6b44ac7b18ef6a511c0999e f84666b662ab4d5ea41766d46f34fbc0
+msgid "Qwen-Audio: the audio-language models"
+msgstr "通义千问 Audio: 音频语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:25
+#: 0584dbb5e76949ea965661c535e982d7
+msgid "Qwen-Audio Turbo"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:26
+#: aa78dd31bce94f6db05be93976278455
+msgid "Qwen-Audio ASR"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:28
+#: df255434cec04d12b8e2d048d4e5baf8
+msgid "You can learn more about them at Alibaba Cloud Model Studio ([China Site](https://help.aliyun.com/zh/model-studio/getting-started/models#9f8890ce29g5u) \\[zh\\], [International Site](https://www.alibabacloud.com/en/product/modelstudio))."
+msgstr ""
+
+#: ../../Qwen/source/getting_started/concepts.md:30
+#: bc0fbc68d29b49da90efba3358f5013f
+msgid "The spectrum for the open-weight models spans over"
+msgstr "开源模型包括："
+
+#: ../../Qwen/source/getting_started/concepts.md:32
+#: e3107d97ea1b4e0284c2a33c0da02813
+msgid "[Qwen](https://github.com/QwenLM/Qwen): 1.8B, 7B, 14B, and 72B models"
+msgstr "[Qwen](https://github.com/QwenLM/Qwen): 1.8B、 7B、 14B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:33
+#: 8918b660d015430a8d14c3c62b87b19d
+msgid "[Qwen1.5](https://github.com/QwenLM/Qwen1.5/tree/v1.5): 0.5B, 1.8B, 4B, 14BA2.7B, 7B, 14B, 32B, 72B, and 110B models"
+msgstr "[Qwen1.5](https://github.com/QwenLM/Qwen1.5/tree/v1.5): 0.5B、 1.8B、 4B、 14BA2.7B、 7B、 14B、 32B、 72B 及 110B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:34
+#: c5ad94aa9d524a7290d9d0ec35321641
+msgid "[Qwen2](https://github.com/QwenLM/Qwen2/tree/v2.0): 0.5B, 1.5B, 7B, 57A14B, and 72B models"
+msgstr "[Qwen2](https://github.com/QwenLM/Qwen2/tree/v2.0): 0.5B、 1.5B、 7B、 57A14B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:35
+#: 5c38bd713ca847b4bb552971cdd75a99
+msgid "[Qwen2.5](https://github.com/QwenLM/Qwen2.5/): 0.5B, 1.5B, 3B, 7B, 14B, 32B, and 72B models"
+msgstr "[Qwen2.5](https://github.com/QwenLM/Qwen2.5/): 0.5B、 1.5B、 3B、 7B、 14B、 32B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:37
+#: aa36bbcafdf742a9addd2a7b32705a02
+msgid "[Qwen-VL](https://github.com/QwenLM/Qwen-VL): 7B-based models"
+msgstr "[Qwen-VL](https://github.com/QwenLM/Qwen-VL): 基于 7B 的模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:38
+#: 9d1d663950d34fefbfc7df37fa1def7a
+msgid "[Qwen2-VL](https://github.com/QwenLM/Qwen2-VL): 2B, 7B, and 72B-based models"
+msgstr "[Qwen-VL](https://github.com/QwenLM/Qwen2-VL): 基于 2B 、 7B 和 72B 的模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:40
+#: bb8a3431ea1f4cc99b4b8dd78e55d9ad
+msgid "[Qwen-Audio](https://github.com/QwenLM/Qwen-Audio): 7B-based model"
+msgstr "[Qwen-Audio](https://github.com/QwenLM/Qwen-Audio): 基于 7B 的模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:41
+#: 2421a5d0f547440bbf0211274bf44d5d
+msgid "[Qwen2-Audio](https://github.com/QwenLM/Qwen2-Audio): 7B-based models"
+msgstr "[Qwen2-Audio](https://github.com/QwenLM/Qwen2-Audio): 基于 7B 的模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:42
+#: df8610d7dfbf4651a955dc909b727061
+#, fuzzy
+msgid "Q*Q: the reasoning models"
+msgstr "通义千问 (Qwen)：语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:43
+#: 67e209da7f5848adab885598a9069f11
+#, fuzzy
+msgid "[QwQ-Preview](https://github.com/QwenLM/Qwen2.5/): 32B LLM"
+msgstr "[Qwen2.5-Coder](https://github.com/QwenLM/Qwen2.5-Coder): 7B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:44
+#: 4e9ad66b735a4109ab8ec727486c463c
+#, fuzzy
+msgid "[QVQ-Preview](https://github.com/QwenLM/Qwen2-VL): 72B VLM"
+msgstr "[Qwen-VL](https://github.com/QwenLM/Qwen-VL): 基于 7B 的模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:45
+#: 728cd9f1dc9d4502ad9a3702e802fc2e
+msgid "CodeQwen/Qwen-Coder: the language models for coding"
+msgstr "Code通义千问 / 通义千问Coder：代码语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:46
+#: 133fd513d7084b54bfe910fda13a42ec
+msgid "[CodeQwen1.5](https://github.com/QwenLM/CodeQwen1.5): 7B models"
+msgstr "[CodeQwen1.5](https://github.com/QwenLM/CodeQwen1.5): 7B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:47
+#: a903957acc0d458b8200788144be0b4d
+#, fuzzy
+msgid "[Qwen2.5-Coder](https://github.com/QwenLM/Qwen2.5-Coder): 0.5B, 1.5B, 3B, 7B, 14B, and 32B models"
+msgstr "[Qwen2.5](https://github.com/QwenLM/Qwen2.5/): 0.5B、 1.5B、 3B、 7B、 14B、 32B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:48
+#: 6c47a9310a6945719b35da4bff3e0c9e
+msgid "Qwen-Math: the language models for mathematics"
+msgstr "通义千问 Math：数学语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:49
+#: fadbf7de806d4f288fc4355b52bcc060
+msgid "[Qwen2-Math](https://github.com/QwenLM/Qwen2-Math): 1.5B, 7B, and 72B models"
+msgstr "[Qwen2-Math](https://github.com/QwenLM/Qwen2-Math)： 1.5B、 7B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:50
+#: 0066352e253345288d16bb1a8df40e1c
+msgid "[Qwen2.5-Math](https://github.com/QwenLM/Qwen2.5-Math): 1.5B, 7B, and 72B models"
+msgstr "[Qwen2.5-Math](https://github.com/QwenLM/Qwen2.5-Math)： 1.5B、 7B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:51
+#: b45ed6f1601c41f8a33f6b2b6ff8b47b
+#, fuzzy
+msgid "Qwen-Math-RM: the reward models for mathematics"
+msgstr "通义千问 Math：数学语言模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:52
+#: 286e8dd455ef4bab91821d399dd4a582
+#, fuzzy
+msgid "[Qwen2-Math-RM](https://github.com/QwenLM/Qwen2-Math): 72B models"
+msgstr "[Qwen2-Math](https://github.com/QwenLM/Qwen2-Math)： 1.5B、 7B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:53
+#: 81eb8401de1646309924a74e633b9b45
+#, fuzzy
+msgid "[Qwen2.5-Math-RM](https://github.com/QwenLM/Qwen2.5-Math): 72B models"
+msgstr "[Qwen2.5-Math](https://github.com/QwenLM/Qwen2.5-Math)： 1.5B、 7B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:54
+#: e0cd026299ba4809a86504afbe2dd8d5
+#, fuzzy
+msgid "[Qwen2.5-Math-PRM](https://github.com/QwenLM/Qwen2.5-Math): 7B and 72B models"
+msgstr "[Qwen2.5-Math](https://github.com/QwenLM/Qwen2.5-Math)： 1.5B、 7B 及 72B 模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:56
+#: acec8c22ff094ebe8295cad38ec7a8db
+msgid "**In this document, our focus is Qwen, the language models.**"
+msgstr "**本文档针对通义千问 (Qwen) 语言模型。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:58
+#: e1e6ade4e85b4975bf992ed0a9c99140
+msgid "Causal Language Models"
+msgstr "因果语言模型 (Causal Language Models)"
+
+#: ../../Qwen/source/getting_started/concepts.md:60
+#: 593921d01e7a41caa52eda69db81c908
+msgid "Causal language models, also known as autoregressive language models or decoder-only language models, are a type of machine learning model designed to predict the next token in a sequence based on the preceding tokens.  In other words, they generate text one token at a time, using the previously generated tokens as context.  The \"causal\" aspect refers to the fact that the model only considers the past context (the already generated tokens) when predicting the next token, not any future tokens."
+msgstr "因果语言模型 (causal Language Models)，也被称为自回归语言模型 (autoregressive language models) 或仅解码器语言模型 (decoder-only language models) ，是一种机器学习模型，旨在根据序列中的前导 token 预测下一个 token 。换句话说，它使用之前生成的 token 作为上下文，一次生成一个 token 的文本。\"因果\"方面指的是模型在预测下一个 token 时只考虑过去的上下文（即已生成的 token ），而不考虑任何未来的 token 。"
+
+#: ../../Qwen/source/getting_started/concepts.md:64
+#: 4b31da2c06c54107857edcb2764e0019
+msgid "Causal language models are widely used for various natural language processing tasks involving text completion and generation.  They have been particularly successful in generating coherent and contextually relevant text, making them a cornerstone of modern natural language understanding and generation systems."
+msgstr "因果语言模型被广泛用于涉及文本补全和生成的各种自然语言处理任务。它们在生成连贯且具有上下文关联性的文本方面尤其成功，这使得它们成为现代自然语言理解和生成系统的基础。"
+
+#: ../../Qwen/source/getting_started/concepts.md:67
+#: 98f73b1f049641038ec1b310a219b209
+msgid "**Takeaway: Qwen models are causal language models suitable for text completion.**"
+msgstr "**要点：Qwen 模型是适用于文本补全的因果语言模型。**"
+
+#: ../../Qwen/source/getting_started/concepts.md
+#: 2f5c19be905046e1ae669119e3bb6e7c
+msgid "Learn more about language models"
+msgstr "了解更多关于语言模型的信息"
+
+#: ../../Qwen/source/getting_started/concepts.md:71
+#: 557d7c8bafb94a34b76b6d96a3ce46ff
+msgid "They are three main kinds of models that are commonly referred to as language models in deep learning:"
+msgstr "在深度学习中，被称为语言模型的主要有三类："
+
+#: ../../Qwen/source/getting_started/concepts.md:72
+#: 89ef0f95d0f5492f877ddceb0233d2fc
+msgid "Sequence-to-sequence models: T5 and the likes"
+msgstr "序列到序列模型 (sequence-to-sequence models)：T5及其类似模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:74
+#: 80f14b7e5beb41d7920772b053681e24
+msgid "Sequence-to-sequence models use both an encoder to capture the entire input sequence and a decoder to generate an output sequence. They are widely used for tasks like machine translation, text summarization, etc."
+msgstr "序列到序列模型同时使用编码器来捕获整个输入序列，以及解码器来生成输出序列。它们广泛应用于诸如机器翻译、文本摘要等任务。"
+
+#: ../../Qwen/source/getting_started/concepts.md:77
+#: 0b15c87feae5409f80999e86ad5f5942
+msgid "Bidirectional models or encoder-only models: BERT and the likes"
+msgstr "双向模型 (bidirectional models) 或仅编码器模型 (encoder-only models) ：BERT及其类似模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:79
+#: 7439fe506ee64fbfaba86bb409cb76ca
+msgid "Bidirectional models can access both past and future context in a sequence during training. They cannot generate sequential outputs in real-time due to the need for future context. They are widely used as embedding models and subsequently used for text classification."
+msgstr "双向模型在训练期间可以访问序列中的过去和未来上下文。由于需要未来上下文，它们无法实时生成顺序输出。它们广泛用作嵌入模型，并随后用于文本分类。"
+
+#: ../../Qwen/source/getting_started/concepts.md:83
+#: c7f7ae809802445bbaafc7d7f783c71a
+msgid "Casual language models or decoder-only models: GPT and the likes"
+msgstr "因果语言模型 (casual language models) 或仅解码器模型 (decoder-only models) ：GPT及其类似模型"
+
+#: ../../Qwen/source/getting_started/concepts.md:85
+#: b2825bdbf41c485c849444fc734fde43
+msgid "Causal language models operate unidirectionally in a strictly forward direction, predicting each subsequent word based only on the previous words in the sequence.  This unidirectional nature ensures that the model's predictions do not rely on future context, making them suitable for tasks like text completion and generation."
+msgstr "因果语言模型以严格向前的单向方式运行，仅根据序列中的前导词汇预测每个后续词汇。这种单向性确保了模型的预测不依赖于未来上下文，使它们适合于文本补全和生成等任务。"
+
+#: ../../Qwen/source/getting_started/concepts.md:89
+#: 26bfa80a4e224b9ca3494f83fc37b0b6
+msgid "Pre-training & Base models"
+msgstr "预训练 (Pre-training) 和基模型 (Base models)"
+
+#: ../../Qwen/source/getting_started/concepts.md:91
+#: d75a1bc5132a43e8b41ce24b8021e7ab
+msgid "Base language models are foundational models trained on extensive corpora of text to predict the next word in a sequence.  Their main goal is to capture the statistical patterns and structures of language, enabling them to generate coherent and contextually relevant text.  These models are versatile and can be adapted to various natural language processing tasks through fine-tuning.  While adept at producing fluent text, they may require in-context learning or additional training to follow specific instructions or perform complex reasoning tasks effectively. For Qwen models, the base models are those without \"-Instruct\" indicators, such as Qwen2.5-7B and Qwen2.5-72B."
+msgstr "基础语言模型 (base language models) 是在大量文本语料库上训练的基本模型，用于预测序列中的下一个词。它们的主要目标是捕捉语言的统计模式和结构，使它们能够生成连贯且具有上下文关联性的文本。这些模型具有多功能性，可以通过微调适应各种自然语言处理任务。虽然擅长生成流畅的文本，但它们可能需要情境学习 (in-context learning)或额外训练才能遵循特定指令或有效执行复杂推理任务。对于 Qwen 模型，基础模型是指那些没有 \"-Instruct\" 标识符的模型，例如 Qwen2.5-7B 和 Qwen2.5-72B 。"
+
+#: ../../Qwen/source/getting_started/concepts.md:97
+#: 7f7321ea84f34e29beabf6122a77ec64
+msgid "**Takeaway: Use base models for in-context learning, downstream fine-tuning, etc.**"
+msgstr "**要点：使用基础模型进行情境学习、下游微调等。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:99
+#: b1d8ca8221c0494796dda85ac2456389
+msgid "Post-training & Instruction-tuned models"
+msgstr "后训练 (Post-training) 和指令微调模型 (Instruction-tuned models)"
+
+#: ../../Qwen/source/getting_started/concepts.md:101
+#: 2f55c1d2c9234c44ab55bf90fcb1b10f
+msgid "Instruction-tuned language models are specialized models designed to understand and execute specific instructions in conversational styles. These models are fine-tuned to interpret user commands accurately and can perform tasks such as summarization, translation, and question answering with improved accuracy and consistency.  Unlike base models, which are trained on large corpora of text, instruction-tuned models undergo additional training using datasets that contain examples of instructions and their desired outcomes, often in multiple turns. This kind of training makes them ideal for applications requiring targeted functionalities while maintaining the ability to generate fluent and coherent text. For Qwen models, the instruction-tuned models are those with the \"-Instruct\" suffix, such as Qwen2.5-7B-Instruct and Qwen2.5-72B-Instruct. [^instruct-chat]"
+msgstr "指令微调语言模型 (Instruction-tuned language models) 是专门设计用于理解并以对话风格执行特定指令的模型。这些模型经过微调，能准确地解释用户命令，并能以更高的准确性和一致性执行诸如摘要、翻译和问答等任务。与在大量文本语料库上训练的基础模型不同，指令调优模型会使用包含指令示例及其预期结果的数据集进行额外训练，通常涵盖多个回合。这种训练方式使它们非常适合需要特定功能的应用，同时保持生成流畅且连贯文本的能力。对于 Qwen 模型，指令调优模型是指带有 \"-Instruct\" 后缀的模型，例如 Qwen2.5-7B-Instruct 和 Qwen2.5-72B-Instruct 。 [^instruct-chat]"
+
+#: ../../Qwen/source/getting_started/concepts.md:107
+#: d5b5590ccf434715bd57d0746f196cfe
+msgid "**Takeaway: Use instruction-tuned models for conducting tasks in conversations, downstream fine-tuning, etc.**"
+msgstr "**要点：使用指令微调模型进行对话式的任务执行、下游微调等。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:112
+#: 5dc4cca1e5104c67b1a3bcdd004e7a9d
+msgid "Tokens & Tokenization"
+msgstr "Tokens & Tokenization"
+
+#: ../../Qwen/source/getting_started/concepts.md:114
+#: 9e3a74bf95fd40e49fef921a0d0df6ff
+msgid "Tokens represent the fundamental units that models process and generate.  They can represent texts in human languages (regular tokens) or represent specific functionality like keywords in programming languages (control tokens [^special]). Typically, a tokenizer is used to split text into regular tokens, which can be words, subwords, or characters depending on the specific tokenization scheme employed, and furnish the token sequence with control tokens as needed. The vocabulary size, or the total number of unique tokens a model recognizes, significantly impacts its performance and versatility.  Larger language models often use sophisticated tokenization methods to handle the vast diversity of human language while keeping the vocabulary size manageable. Qwen use a relatively large vocabulary of 151,646 tokens in total."
+msgstr "token 代表模型处理和生成的基本单位。它们可以表示人类语言中的文本（常规 token），或者表示特定功能，如编程语言中的关键字（控制 token [^special]）。通常，使用 tokenizer 将文本分割成常规 token ，这些 token 可以是单词、子词或字符，具体取决于所采用的特定 tokenization 方案，并按需为 token 序列添加控制 token 。词表大小，即模型识别的唯一 token 总数，对模型的性能和多功能性有重大影响。大型语言模型通常使用复杂的 tokenization 来处理人类语言的广阔多样性，同时保持词表大小可控。Qwen 词表相对较大，有 15 1646 个 token。"
+
+#: ../../Qwen/source/getting_started/concepts.md:123
+#: 9e1c049b23fc403ea61919a755ae865a
+msgid "**Takeaway: Tokenization method and vocabulary size is important.**"
+msgstr "**要点：tokenization 和词表大小很重要。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:125
+#: 0a01476839134505b1e2e004f67c876b
+msgid "Byte-level Byte Pair Encoding"
+msgstr "Byte-level Byte Pair Encoding"
+
+#: ../../Qwen/source/getting_started/concepts.md:127
+#: e461340d6e834aaeb233649a70618165
+msgid "Qwen adopts a subword tokenization method called Byte Pair Encoding (BPE), which attempts to learn the composition of tokens that can represent the text with the fewest tokens.  For example, the string \" tokenization\" is decomposed as \" token\" and \"ization\" (note that the space is part of the token). Especially, the tokenization of Qwen ensures that there is no unknown words and all texts can be transformed to token sequences."
+msgstr "Qwen采用了名为字节对编码（Byte Pair Encoding，简称BPE）的子词tokenization方法，这种方法试图学习能够用最少的 token 表示文本的 token 组合。例如，字符串\"tokenization\"被分解为\" token\"和\"ization\"（注意空格是 token 的一部分）。特别地，Qwen的 tokenization 确保了不存在未知词汇，并且所有文本都可以转换为 token 序列。"
+
+#: ../../Qwen/source/getting_started/concepts.md:131
+#: af40a128cbe44fb59a057f9477737197
+msgid "There are 151,643 tokens as a result of BPE in the vocabulary of Qwen, which is a large vocabulary efficient for diverse languages. As a rule of thumb, 1 token is 3~4 characters for English texts and 1.5~1.8 characters for Chinese texts."
+msgstr "Qwen词表中因BPE而产生的 token 数量为 15 1643 个，这是一个适用于多种语言的大词表。一般而言，对于英语文本，1个token大约是3~4个字符；而对于中文文本，则大约是1.5~1.8个汉字。"
+
+#: ../../Qwen/source/getting_started/concepts.md:134
+#: 3b92bf813f14474f842584fa9bf4fdee
+msgid "**Takeaway: Qwen processes texts in subwords and there are no unknown words.**"
+msgstr "**要点：Qwen 以子词形式处理文本，不存在未知词汇。**"
+
+#: ../../Qwen/source/getting_started/concepts.md
+#: b29e165e1810403dbcd90cfedd8c73a6
+msgid "Learn more about tokenization in Qwen"
+msgstr "了解更多"
+
+#: ../../Qwen/source/getting_started/concepts.md:137
+#: b7fa098dbce946c9847eb414f7d52b9e
+msgid "Qwen uses byte-level BPE (BBPE) on UTF-8 encoded texts.  It starts by treating each byte as a token and then iteratively merges the most frequent pairs of tokens occurring the texts into larger tokens until the desired vocabulary size is met."
+msgstr "Qwen 使用基于字节的BPE (BBPE) 对UTF-8编码的文本进行处理。它开始时将每个字节视为一个 token ，然后迭代地将文本中最频繁出现的 token 对合并成更大的 token，直到达到所需的词表大小。"
+
+#: ../../Qwen/source/getting_started/concepts.md:140
+#: 504bb23b689949dd9bbee78f97d7e0a0
+msgid "In byte-level BPE, minimum 256 tokens are needed to tokenize every piece of text and avoid the out of vocabulary (OOV) problem. In comparison, character-level BPE needs every Unicode character in its vocabulary to avoid OOV and the Unicode Standard contains 154,998 characters as of Unicode Version 16.0."
+msgstr "在基于字节的BPE中，至少需要256个 token 来对每段文本进行 tokenization，并避免未登录词（out of vocabulary, OOV）问题。相比之下，基于字符的 BPE 需要其词表中包含所有 Unicode 字符以避免未登录词，而截至 Unicode 版本16.0，Unicode标准包含 15 4998 个字符。"
+
+#: ../../Qwen/source/getting_started/concepts.md:143
+#: cfed44d0c905486cb7e12838014249e1
+msgid "One limitation to keep in mind for byte-level BPE is that the individual tokens in the vocabulary may not be seemingly semantically meaningful or even valid UTF-8 byte sequences, and in certain aspects, they should be viewed as a text compression scheme."
+msgstr "基于字节的BPE的一个限制是，词表中的个别 token 可能看似没有语义意义，甚至不是有效的 UTF-8 字节序列，在某些方面，它们应该被视为一种文本压缩方案。"
+
+#: ../../Qwen/source/getting_started/concepts.md:146
+#: 4c6140ebdb0742e199793a7da566943e
+msgid "Control Tokens & Chat Template"
+msgstr "控制 Token 和 对话模板"
+
+#: ../../Qwen/source/getting_started/concepts.md:148
+#: 7fab9c7227b94996bbdd30a2dd6a11cc
+msgid "Control tokens and chat templates both serve as mechanisms to guide the model's behavior and outputs."
+msgstr "控制 token 和对话模板都作为指导模型行为和输出的机制。"
+
+#: ../../Qwen/source/getting_started/concepts.md:150
+#: 9d38b62cddc34442bffc173b6c5e15ea
+msgid "Control tokens are special tokens inserted into the sequence that signifies meta information. For example, in pre-training, multiple documents may be packed into a single sequence. For Qwen, the control token \"<|endoftext|>\" is inserted after each document to signify that the document has ended and a new document will proceed."
+msgstr "控制token是插入到序列中的特殊token，表示元信息。例如，在预训练中，多个文档可以被打包成一个单一的序列。对于Qwen，控制令牌 \"<|endoftext|>\" 在每个文档后插入，表示文档已经结束，新的文档将开始。"
+
+#: ../../Qwen/source/getting_started/concepts.md:154
+#: aed5af70b3de447b9b3c1312f040f103
+msgid "Chat templates provide a structured format for conversational interactions, where predefined placeholders or prompts are used to elicit responses from the model that adhere to a desired dialogue flow or context. Different models may use different kinds of chat template to format the conversations.  It is crucial to use the designated one to ensure the precise control over the LLM's generation process."
+msgstr "对话模板为对话交互提供了结构化的格式，其中使用预定义的占位符或提示来从模型中引发遵循期望的对话流程或上下文的响应。不同的模型可能使用不同类型的对话模板来格式化对话。使用指定的模板对于确保对语言模型生成过程的精确控制至关重要。"
+
+#: ../../Qwen/source/getting_started/concepts.md:158
+#: 7acbb7b28f1746a8b779a004a7dc2d93
+msgid "Qwen uses the following format (ChatML[^chatml]), making use of control tokens to format each turn in the conversations"
+msgstr "Qwen使用以下格式（ChatML[^chatml]），利用控制 token 来格式化对话中的每一轮。"
+
+#: ../../Qwen/source/getting_started/concepts.md:163
+#: 33f3aee8869748fa9f7a51c7efa76338
+msgid "The user input take the role of `user` and the model generation takes the role of `assistant`.  Qwen also supports the meta message that instruct the model to perform specific actions or generate text with certain characteristics, such as altering tone, style, or content, which takes the role of `system` and the content defaults to \"You are Qwen, created by Alibaba Cloud. You are a helpful assistant.\""
+msgstr "用户输入扮演 `user` 的 role ，而模型生成则承担 `assistant` 的 role 。 Qwen 还支持元消息，该消息指导模型执行特定操作或生成具有特定特性的文本，例如改变语气、风格或内容，这将承担 `system` 的 role，且内容默认为 \"You are Qwen, created by Alibaba Cloud. You are a helpful assistant.\" 。"
+
+#: ../../Qwen/source/getting_started/concepts.md:166
+#: 0129cbc394614f5f94047592df13c9b6
+msgid "The following is a full example:"
+msgstr "下面为一个完整示例"
+
+#: ../../Qwen/source/getting_started/concepts.md:183
+#: 59bab0422fa34a19ab2995e6ff15dc56
+msgid "Starting from Qwen2.5, the Qwen model family including multimodal and specialized models will use a unified vocabulary, which contains control tokens from all subfamilies. There are 22 control tokens in the vocabulary of Qwen2.5, making the vocabulary size totaling 151,665:"
+msgstr "从 Qwen2.5 开始，Qwen 模型家族，包括多模态和专项模型，将使用统一的词汇表，其中包含了所有子系列的控制 token 。Qwen2.5 的词汇表中有 22 个控制 token，使得词汇表的总规模达到 15 1665 。"
+
+#: ../../Qwen/source/getting_started/concepts.md:185
+#: 701bd6f896634b0aaf2920d883268a16
+msgid "1 general: `<|endoftext|>`"
+msgstr "通用 token 1个：`<|endoftext|>`"
+
+#: ../../Qwen/source/getting_started/concepts.md:186
+#: 7e78239f93a245dbb046d4ae2afe8a72
+msgid "2 for chat: `<|im_start|>` and `<|im_end|>`"
+msgstr "对话 token 2个：`<|im_start|>` 和 `<|im_end|>`"
+
+#: ../../Qwen/source/getting_started/concepts.md:187
+#: eb686086dfe44d53a5cdfc98e9bbaad8
+msgid "2 for tool use: `<tool_call>` and `</tool_call>`"
+msgstr "工具调用 token 2个： `<tool_call>` 和 `</tool_call>`"
+
+#: ../../Qwen/source/getting_started/concepts.md:188
+#: c8259cada9e94790a759a4b1f8edaf2d
+msgid "11 for vision"
+msgstr "视觉相关 token 11个"
+
+#: ../../Qwen/source/getting_started/concepts.md:189
+#: 9b67870139b144c8ae4451e3deb1c1c5
+msgid "6 for coding"
+msgstr "代码相关 token 6个"
+
+#: ../../Qwen/source/getting_started/concepts.md:191
+#: 32c9581187f640d2a37cca85390bf1de
+msgid "**Takeaway: Qwen uses ChatML with control tokens for chat template.**"
+msgstr "**要点: Qwen 使用带有控制 token 的 ChatML 作为对话模板。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:195
+#: 74d8b323a0864a9c94a78f154a5c86c0
+msgid "Length Limit"
+msgstr "长度限制"
+
+#: ../../Qwen/source/getting_started/concepts.md:197
+#: 2833c71b35d94ff0b6825f86bc9be098
+msgid "As Qwen models are causal language models, in theory there is only one length limit of the entire sequence. However, since there is often packing in training and each sequence may contain multiple individual pieces of texts.  **How long the model can generate or complete ultimately depends on the use case and in that case how long each document (for pre-training) or each turn (for post-training) is in training.**"
+msgstr "由于 Qwen 模型是因果语言模型，理论上整个序列只有一个长度限制。然而，由于在训练中通常存在打包现象，每个序列可能包含多个独立的文本片段。**模型能够生成或完成的长度最终取决于具体的应用场景，以及在这种情况下，预训练时每份文档或后训练时每轮对话的长度。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:201
+#: 1d25c6232d924639b313a1a66d1990c9
+msgid "For Qwen2.5, the packed sequence length in training is 32,768 tokens.[^yarn] The maximum document length in pre-training is this length. The maximum message length for user and assistant is different in post-training. In general, the assistant message could be up to 8192 tokens."
+msgstr "对于Qwen2.5，在训练中的打包序列长度为 3 2768 个 token [^yarn]。预训练中的最大文档长度即为此长度。而后训练中，user和assistant的最大消息长度则有所不同。一般情况下，assistant消息长度可达 8192 个 token。"
+
+#: ../../Qwen/source/getting_started/concepts.md:209
+#: f39c2748eccb486794c941d23b23835c
+msgid "**Takeaway: Qwen2.5 models can process texts of 32K or 128K tokens and up to 8K tokens can be assistant output.**"
+msgstr "**要点：Qwen2 模型可以处理 32K 或 128K token 长的文本，其中 8K 长度可作为输出。**"
+
+#: ../../Qwen/source/getting_started/concepts.md:109
+#: 7195ff6a5d1a4e6881f272081c9885d7
+msgid "Previously, they are known as the chat models and with the \"-Chat\" suffix. Starting from Qwen2, the name is changed to follow the common practice. For Qwen, \"-Instruct\" and \"-Chat\" should be regarded as synonymous."
+msgstr "此前，它们被称为对话模型，并带有\"-Chat\"后缀。从Qwen2开始，名称变更为遵循通用做法。对于Qwen，\"-Instruct\"和\"-Chat\"应被视为同义词。"
+
+#: ../../Qwen/source/getting_started/concepts.md:121
+#: f50caec63c8948a894dbf8c718f0b2d8
+msgid "Control tokens can be called special tokens. However, the meaning of special tokens need to be interpreted based on the contexts: special tokens may contain extra regular tokens."
+msgstr "控制 token 也可以称为“特殊 token”。但是，特殊 token 的意义需要根据上下文进行解释：特殊 token 也可能包含额外的常规 token。"
+
+#: ../../Qwen/source/getting_started/concepts.md:193
+#: fc70e6f93b71452ca0d09aa0ff28dd54
+msgid "For historical reference only, ChatML is first described by the OpenAI Python SDK. The last available version is [this](https://github.com/openai/openai-python/blob/v0.28.1/chatml.md). Please also be aware that that document lists use cases intended for OpenAI models. For Qwen2.5 models, please only use as in our guide."
+msgstr "仅供历史参考，ChatML最初由OpenAI的Python SDK描述。可获取的最新版本是[这个](https//github.com/openai/openai-python/blob/v0.28.1/chatml.md)。请注意，该文档列出的应用案例是为OpenAI模型设计的。对于Qwen2.5模型，请仅按照我们的指南使用。"
+
+#: ../../Qwen/source/getting_started/concepts.md:206
+#: a08b83b36c2d4e8d8f3dbb020ecb37a2
+msgid "The sequence length can be extended to 131,072 tokens for Qwen2.5-7B, Qwen2.5-14B, Qwen2.5-32B, and Qwen2.5-72B models with YaRN.      Please refer to the model card on how to enable YaRN in vLLM."
+msgstr "使用YaRN，Qwen2.5-7B、Qwen2.5-14B、Qwen2.5-32B和Qwen2-72B模型的序列长度可以扩展到13 1072个token。请参考模型卡片了解如何在 vLLM 中启用 YaRN。"
+
+#~ msgid "There is the proprietary version hosted exclusively at [Alibaba Cloud \\[zh\\]](https://help.aliyun.com/zh/model-studio/developer-reference/tongyi-qianwen-llm/) and the open-weight version."
+#~ msgstr "通义千问分为[闭源](https://help.aliyun.com/zh/model-studio/developer-reference/tongyi-qianwen-llm/)和开源两大版本。"
+

docs/locales/zh_CN/LC_MESSAGES/getting_started/quantization_benchmark.po

@@ -0,0 +1,440 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:2
+#: 6d4d3bb3020f4e4d8dba0ca5778cdcae
+msgid "Performance of Quantized Models"
+msgstr "量化模型效果评估"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:5
+#: 3a541cd8cba74edf9b06b46f59eaaf38
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:7
+#: 3a95fc299de141dea4fc729ef907ce17
+msgid "This section reports the generation performance of quantized models (including GPTQ and AWQ) of the Qwen2 series. Specifically, we report:"
+msgstr "本部分介绍Qwen2量化模型（包括GPTQ与AWQ量化方案）的效果评估，有以下数据集"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:11
+#: 9386a3b95eb340568185da78224a1ccd
+msgid "MMLU (Accuracy)"
+msgstr "MMLU （准确率）"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:12
+#: 3cd93b881c90488895c61298104bc7fb
+msgid "C-Eval (Accuracy)"
+msgstr "C-Eval （准确率）"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:13
+#: 7ac4bb515b0a49699d4eb95fc433bb51
+msgid "IFEval (Strict Prompt-Level Accuracy)"
+msgstr "IFEval （提示词级的严格准确率，Strict Prompt-Level Accuracy）"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:15
+#: 08e3f35820344c93877618815650b866
+msgid "We use greedy decoding in evaluating all models."
+msgstr "所有模型均使用贪心解码。"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:18
+#: 9aec40221219455d8fc4e473e5acf09c
+msgid "Quantization"
+msgstr "量化模型"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:18
+#: 93f274f4751f445d85f04937b25c7f7d
+msgid "Average"
+msgstr "平均"
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:18
+#: 776612f5dd4a40d98976bdfe4896508c
+msgid "MMLU"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:18
+#: f6e8014116cf4179a934d601ee61d04d
+msgid "C-Eval"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:18
+#: 0c40e96c4a3b4cdeaaf1a95ff1aa8f98
+msgid "IFEval"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: 773ccb0f10bd4cf690e819af51c40e76
+msgid "Qwen2-72B-Instruct"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: 71e180f75e624b738d56ec2a1fad253c 7ebe73a2e96445c4bb733845c3190240
+#: bd5a3b8861d646fa9e8d8bc51bb1b80c cc79a78b34f94c18b7bdaf1bfcc8824d
+msgid "BF16"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:22
+#: 08517ffc3e6e4ceb812c3d8710307266 2e879d3d1fef4c878b097550d745e7ae
+msgid "81.3"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: f795aa42cf7d42ccb5a573a5f44be79f
+msgid "82.3"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: 01c54f3da3454e178a07a9f88ed5302b
+msgid "83.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:20
+#: 7651df5ccaa14b11a3a89827a5265ae8
+msgid "77.6"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:22
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:30
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:38
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:46
+#: 04de04c9ff3640f096301e76fdd291de 301aa8e494ff4fe4aefcc8cfb7a4c065
+#: d395be41cf144318a1faeccc6f6965c8 ec513d10a75d44b8bd134287a57b5cdd
+msgid "GPTQ-Int8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:22
+#: 411166db878d4d8f8515e9f5d78a651c
+msgid "80.7"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:22
+#: e63ce8a2f1cc4cec9b52521015e2aebe
+msgid "83.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:22
+#: e6be6c30e0d740d39c6c8807e2d4f5f8
+msgid "77.5"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:24
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:32
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:40
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:48
+#: 21720ff324814b2b865f37a40c3586b5 4644a49bcdfd457b84eb5b2771177d78
+#: 560dcb4bfa6e45088faefdb504d629a5 7044a0d2dd6945138ea385287ab5bf33
+msgid "GPTQ-Int4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:24
+#: 1cb55cd40b3c484d8213c15375b2ad68
+msgid "81.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:24
+#: 32b889d9ef014f2ab6be6881e20d40ae
+msgid "80.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:24
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:26
+#: ba86de9eb27b40e0ba6a57580aed89c3 eed2e99c0edc426e81ec24e961fe971e
+msgid "83.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:24
+#: ee3a3132082048d5b79721fa84f6f816
+msgid "78.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:26
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:34
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:42
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:50
+#: 632f832fc1f249fa92764538b698550d 8c7ccf4f75f44b27bb1b5aac544836cb
+#: b473937c2be94c3490483bb5a820e2fe bc1abd77dd27412992d21bda1831a2a8
+msgid "AWQ"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:26
+#: 2711a3f907224e51ba30818b2e730a30
+msgid "80.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:26
+#: ca9624c0258b425ba53f024b086c173a
+msgid "80.5"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:26
+#: 2f4b57d4394c4cb187407145ce8d5f1e
+msgid "76.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: 48cc75ed7bf04778b327c7b03d418e37
+msgid "Qwen2-7B-Instruct"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: 75182905b74a41099ff859fb86752e99
+msgid "66.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: 80cda712e9dc482fac24952d3bb27b28
+msgid "70.5"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: 0701d66bc3084aef8937e4b687705f37
+msgid "77.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:28
+#: 8efb5c133644420c808dfd78f8fcde2f
+msgid "53.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:30
+#: 2076e02516bd4ff1856bc12a8d6bd320
+msgid "66.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:30
+#: 588f4ad13845491d9589ea094265d532
+msgid "69.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:30
+#: 0c79963a231a402eb6db1671e851be38
+msgid "76.7"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:30
+#: 5d525163672f456289990489459466ae
+msgid "52.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:32
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:34
+#: 9283ca6491194b59a5edf57228f9b5af a4123c0691a442f6850ae25615c108af
+msgid "64.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:32
+#: 9e7ffb49aac34129894b0582c0d8aba1
+msgid "67.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:32
+#: 7c2fc310e5764b7fbf6034ffd3a5d26d
+msgid "75.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:32
+#: 33e6b6e590a64c08adccf0bb161c1046
+msgid "49.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:34
+#: b3cbe7665bdf4f4388f015fb6606540e
+msgid "67.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:34
+#: a47d3b52e80249f986c4339b9d3fff10
+msgid "73.6"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:34
+#: d76543cff2df434185fbe51712024679
+msgid "51.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: cee2c965036d41c6a93ffbf9a9788e4b
+msgid "Qwen2-1.5B-Instruct"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: 8c9d1cd8fb5a4d75b85d0edcb9ed69df
+msgid "48.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: f5e05b0942a24e2b9cac753932ad51c4
+msgid "52.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: c6f81ec529004598aa14c55228ff9538
+msgid "63.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:36
+#: 5b2b4092d04f4d02a56bd0df5807e2c5
+msgid "29.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:38
+#: 08d2bf82e83f4a889d622c72c1e1b3b2
+msgid "48.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:38
+#: 3d8ea738153f467ba55d50e6bf0f84c0
+msgid "53.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:38
+#: 8755d6c4c1e64cd38122f08a92bd90ca
+msgid "62.5"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:38
+#: 1c403dbb3692472a88706cb4b4a1f0f3
+msgid "28.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:40
+#: f3f43ea77edc4ff0969e2466e6fe13e1
+msgid "45.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:40
+#: 9d070c4b9f3e4fceb27b29ecdf90eb41
+msgid "50.7"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:40
+#: 24ff991704c440deb34b92512f89c371
+msgid "57.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:40
+#: b4645b7317a44cb795fc4190149dd0e0
+msgid "27.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:42
+#: eeee44d1d65647569999de94e72c00cb
+msgid "46.5"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:42
+#: 41630bee9142494c801083cd5d213dc0
+msgid "51.6"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:42
+#: 762395735fb34bccbc4d057968bbfbf1
+msgid "58.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:42
+#: f5915835bcb24051bebed452fc398728
+msgid "29.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: 39108e2a66444ca780a720f115251308
+msgid "Qwen2-0.5B-Instruct"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:50
+#: 2795adace57c401cb8bacc00082dfd53 a59271d53e434d17a8a0a19529158f2c
+msgid "34.4"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: c93982789e4e453eb5a02d64f02cb74f
+msgid "37.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: 213dfd43b2254a2caec1d4b1d231ed55
+msgid "45.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:44
+#: 11de22e2a04a4c04b0b91d09d028b853
+msgid "20.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:46
+#: 84b6570bcc8d4c6598336d5bc9b9d36a
+msgid "32.6"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:46
+#: b79e88232d114f43a179dcc5b0477c97
+msgid "35.6"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:46
+#: 1166b675e1e64e18a82c3219f321e248
+msgid "43.9"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:46
+#: fdf340d39b074778b55d36f477f8dc0a
+msgid "18.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:48
+#: ed930e1b13dd4c5caf80b2a180a1bcc3
+msgid "29.7"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:48
+#: c3d5617389634f7e96c66b4f869379a9
+msgid "33.0"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:48
+#: 4573b471c48d4028ad6fb378e75f40aa
+msgid "39.2"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:48
+#: c867c42e916f493b9715b1adf656ddcb
+msgid "16.8"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:50
+#: 20d4c89c335648bb93f07ebfb8ce9fce
+msgid "31.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:50
+#: 25400aeaf79d49cb914ffa5ff26bfe03
+msgid "42.1"
+msgstr ""
+
+#: ../../Qwen/source/getting_started/quantization_benchmark.rst:50
+#: d15e246b65b0427d970b78deffd8c2bc
+msgid "16.7"
+msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/getting_started/quickstart.po

@@ -0,0 +1,205 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 16:36+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/getting_started/quickstart.md:1
+#: a99b6a1db1374218a20b06bcd0c57957
+msgid "Quickstart"
+msgstr "快速开始"
+
+#: ../../source/getting_started/quickstart.md:3
+#: 1da6c3f04eb24db8b697e094163096a1
+msgid "This guide helps you quickly start using Qwen3.  We provide examples of [Hugging Face Transformers](https://github.com/huggingface/transformers) as well as [ModelScope](https://github.com/modelscope/modelscope), and [vLLM](https://github.com/vllm-project/vllm) for deployment."
+msgstr "本指南帮助您快速上手 Qwen3 的使用，并提供了如下示例： [Hugging Face Transformers](https://github.com/huggingface/transformers) 以及 [ModelScope](https://github.com/modelscope/modelscope) 和 [vLLM](https://github.com/vllm-project/vllm) 在部署时的应用实例。"
+
+#: ../../source/getting_started/quickstart.md:6
+#: 11c38e7141f941efb448e7099935b8a9
+msgid "You can find Qwen3 models in [the Qwen3 collection](https://huggingface.co/collections/Qwen/qwen3-67dd247413f0e2e4f653967f) at Hugging Face Hub and [the Qwen3 collection](https://www.modelscope.cn/collections/Qwen3-9743180bdc6b48) at ModelScope."
+msgstr "你可以在 Hugging Face Hub 的 [Qwen3 collection](https://huggingface.co/collections/Qwen/qwen3-67dd247413f0e2e4f653967f) 或 ModelScope 的 [Qwen3 collection](https://www.modelscope.cn/collections/Qwen3-9743180bdc6b48) 中寻找 Qwen3 模型。"
+
+#: ../../source/getting_started/quickstart.md:8
+#: 842c24eb7d30496baf9025af21ca1ed0
+msgid "Transformers"
+msgstr "Transformers"
+
+#: ../../source/getting_started/quickstart.md:10
+#: d0c61f87b0b347ae91e115ba60ebd46e
+msgid "To get a quick start with Qwen3, you can try the inference with `transformers` first. Make sure that you have installed `transformers>=4.51.0`. We advise you to use Python 3.10 or higher, and PyTorch 2.6 or higher."
+msgstr "要快速上手 Qwen3 ，我们建议您首先尝试使用 `transformers` 进行推理。请确保已安装了 `transformers>=4.51.0` 版本。我们建议您使用 Python 3.10 或以上版本， PyTorch 2.6 或以上版本。"
+
+#: ../../source/getting_started/quickstart.md:14
+#: a7fbb3d015b4440ca14ba00821f84fb0
+msgid "The following is a very simple code snippet showing how to run Qwen3-8B:"
+msgstr "以下是一个非常简单的代码片段示例，展示如何运行 Qwen3 模型："
+
+#: ../../source/getting_started/quickstart.md:63
+#: b55178516d31433c9ead5287e9abd3b4
+msgid "Qwen3 will think before respond, similar to QwQ models. This means the model will use its reasoning abilities to enhance the quality of generated responses. The model will first generate thinking content wrapped in a `<think>...</think>` block, followed by the final response."
+msgstr "Qwen3 将在实际回复前思考，与 QwQ 模型类似。这意味着模型将运用其推理能力来提升生成回复的质量。模型会首先生成包含在 `<think>...</think>` 块中的思考内容，随后给出最终回复。"
+
+#: ../../source/getting_started/quickstart.md:67
+#: e31fa076c2264d9fa2ae5d8516b7f4a7
+msgid "Hard Switch: To strictly disable the model's thinking behavior, aligning its functionality with the previous Qwen2.5-Instruct models, you can set `enable_thinking=False` when formatting the text."
+msgstr "硬开关：为了严格禁用模型的思考行为，使其功能与之前的Qwen2.5-Instruct模型保持一致，您可以在格式化文本时设置`enable_thinking=False`。"
+
+#: ../../source/getting_started/quickstart.md:77
+#: a6c11c7147e54cf9a86d65b4f80840c3
+msgid "It can be particularly useful in scenarios where disabling thinking is essential for enhancing efficiency."
+msgstr "在某些需要通过禁用思考来提升效率的场景中，这一功能尤其有用。"
+
+#: ../../source/getting_started/quickstart.md:79
+#: 57bd7b66fe3b4dbfabe7439dc67b7d5f
+msgid "Soft Switch: Qwen3 also understands the user's instruction on its thinking behavior, in particular, the soft switch `/think` and `/no_think`. You can add them 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."
+msgstr "软开关：Qwen3 还能够理解用户对其思考行为的指令，特别是软开关 `/think` 和 `/no_think`。您可以将这些指令添加到用户 (user) 或系统 (system) 消息中，以在对话轮次之间灵活切换模型的思考模式。在多轮对话中，模型将遵循最近的指令。"
+
+#: ../../source/getting_started/quickstart.md:85
+#: 73fa1ee92c7b4a71a2724aedb665dd1b
+msgid "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 section."
+msgstr "对于思考模式，使用 Temperature=0.6，TopP=0.95，TopK=20，以及 MinP=0（`generation_config.json` 中的默认设置）。不要使用贪婪解码，因为它可能导致性能下降和无尽的重复。更多详细指导，请参阅最佳实践部分。"
+
+#: ../../source/getting_started/quickstart.md:89
+#: 4ce3b1cf5e1349628a66c101432fd748
+msgid "For non-thinking mode, we suggest using Temperature=0.7, TopP=0.8, TopK=20, and MinP=0."
+msgstr "对于非思考模式，我们建议使用 Temperature=0.7，TopP=0.8，TopK=20，以及 MinP=0。"
+
+#: ../../source/getting_started/quickstart.md:93
+#: 34d138d1ca8c4ecab4002b354cfe64d2
+msgid "ModelScope"
+msgstr "魔搭 (ModelScope)"
+
+#: ../../source/getting_started/quickstart.md:95
+#: 0c25fecd5e42412a80214fbc35b08226
+msgid "To tackle with downloading issues, we advise you to try [ModelScope](https://github.com/modelscope/modelscope). Before starting, you need to install `modelscope` with `pip`."
+msgstr "为了解决下载问题，我们建议您尝试从 [ModelScope](https://github.com/modelscope/modelscope) 进行下载。开始之前，需要使用 `pip` 安装 `modelscope` 。"
+
+#: ../../source/getting_started/quickstart.md:98
+#: d8ccf4eafeb849ae8bd49d9fb2281c60
+msgid "`modelscope` adopts a programmatic interface similar (but not identical) to `transformers`. For basic usage, you can simply change the first line of code above to the following:"
+msgstr "`modelscope` 采用了与 `transformers` 类似（但不完全一致）的编程接口。对于基础使用，仅需将上面代码第一行做如下修改："
+
+#: ../../source/getting_started/quickstart.md:105
+#: f17c53400572487ca066135facd711bb
+msgid "For more information, please refer to [the documentation of `modelscope`](https://www.modelscope.cn/docs)."
+msgstr "欲获取更多信息，请参考 [`modelscope` 文档](https://www.modelscope.cn/docs)。"
+
+#: ../../source/getting_started/quickstart.md:107
+#: 6e3028c50b2146bd932d168662e57620
+msgid "OpenAI API Compatibility"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:109
+#: 046b0833e5b744cda72d7a7ef5672cc2
+msgid "You can serve Qwen3 via OpenAI-compatible APIs using frameworks such as vLLM, SGLang, and interact with the API using common HTTP clients or the OpenAI SDKs."
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:112
+#: 1542f3cbe7ba4adab50dfc85da110c36
+msgid "Here we take Qwen3-8B as an example to start the API:"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:114
+#: 4bfa52cf82914d73b0fcbbceafa4ff8a
+msgid "SGLang (`sglang>=0.4.6.post1` is required):"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:120
+#: cc7a9ae4d4fe4b86be41b376d7334024
+msgid "vLLM (`vllm>=0.8.5` is recommended):"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:126
+#: 7a690ab7e23f4505a355abd50e647101
+msgid "Then, you can use the [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) to communicate with Qwen:"
+msgstr "然后，可以使用 [\"create chat\" interface](https://platform.openai.com/docs/api-reference/chat/completions/create>) 来与 Qwen 进行交流："
+
+#: ../../source/getting_started/quickstart.md 9cd82768a97142acac1c2c63a05e1ad3
+msgid "curl"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md 7d220176fa6b4622ae74431873d49396
+msgid "Python"
+msgstr ""
+
+#: ../../source/getting_started/quickstart.md:146
+#: f55afdfc6fa54f468b1b554fab082263
+msgid "You can use the API client with the `openai` Python SDK as shown below:"
+msgstr "您可以按照下面所示的方式，使用 `openai` Python SDK中的客户端："
+
+#: ../../source/getting_started/quickstart.md:175
+#: d0370e64550a4c51b6146ad7dfb52f97
+msgid "While the soft switch is always available, the hard switch is also available in the API through the following configuration to the API call. For more usage, please refer to our document on [SGLang](../deployment/sglang) and [vLLM](../deployment/vllm)."
+msgstr "虽然软开关始终可用，但硬开关也可以通过以下 API 调用配置在 API 中使用。更多用法，请参阅我们关于 [SGLang](../deployment/sglang) 和 [vLLM](../deployment/vllm) 的文档。"
+
+#: ../../source/getting_started/quickstart.md:178
+#: e48c576eba5e4c5db9ef0a48882e18c2
+msgid "Thinking Budget"
+msgstr "思考预算"
+
+#: ../../source/getting_started/quickstart.md:180
+#: cc5be59588e34164b7f2e84a7d8b82c0
+msgid "Qwen3 supports the configuration of thinking budget. It is achieved by ending the thinking process once the budget is reached and guiding the model to generate the \"summary\" with an early-stopping prompt."
+msgstr "Qwen3 支持配置思考预算。其实现方式是，一旦达到预算，便结束思考过程，并通过提前停止提示引导模型生成“总结”。"
+
+#: ../../source/getting_started/quickstart.md:183
+#: 8a2760351bc04093adc5017b58ec4981
+msgid "Since this feature involves customization specific to each model, it is currently not available in the open-source frameworks and only implemented by [the Alibaba Cloud Model Studio API](https://www.alibabacloud.com/help/en/model-studio/deep-thinking#6f0633b9cdts1)."
+msgstr "由于此功能涉及针对模型的定制，目前在开源框架中不可用，仅由[阿里云百炼API](https://bailian.console.aliyun.com/?tab=doc#/doc/?type=model&url=https%3A%2F%2Fhelp.aliyun.com%2Fdocument_detail%2F2870973.html&renderType=iframe)实现。" 
+
+#: ../../source/getting_started/quickstart.md:185
+#: 01acc4a8caa443dc8da81862d2e7d6bb
+msgid "However, with existing open-source frameworks, one can generate twice to implement this feature as follows:"
+msgstr "然而，利用现有的开源框架，可以通过两次生成来实现此功能，具体如下："
+
+#: ../../source/getting_started/quickstart.md:186
+#: 677f5e6ad5b1416aa4bbadff3e6537a1
+msgid "For the first time, generate tokens up to the thinking budget and check if the thinking process is finished. If the thinking process is not finished, append the early-stopping prompt."
+msgstr "第一次生成时，生成的token数量达到思考预算，并检查思考过程是否完成。如果思考过程未完成，则追加提前停止提示。"
+
+#: ../../source/getting_started/quickstart.md:187
+#: 479c92c1bc9d4a74b18d5c175d1e6cda
+msgid "For the second time, continue generation until the end of the content or the upper length limit is fulfilled."
+msgstr "第二次生成时，继续生成直到内容结束或达到长度上限。"
+
+#: ../../source/getting_started/quickstart.md:189
+#: dd7834e30f9344ddad21792279ad4732
+msgid "The following snippet shows the implementation with Hugging Face Transformers:"
+msgstr "以下代码片段展示了使用Hugging Face Transformers的实现："
+
+#: ../../source/getting_started/quickstart.md:262
+#: 85f448fb112e4742bc5d4bd05979f30d
+msgid "You should see the output in the console like the following"
+msgstr "您应该会在控制台中看到类似以下的输出："
+
+#: ../../source/getting_started/quickstart.md:274
+#: 4fc4ae8cdbb54c8b97b2da717d61e42e
+msgid "For purpose of demonstration only, `thinking_budget` is set to 16. However, `thinking_budget` should not be set to that low in practice. We recommend tuning `thinking_budget` based on the latency users can accept and setting it higher than 1024 for meaningful improvements across tasks."
+msgstr "出于示例目的，`thinking_budget` 被设置为 16。然而，在实际应用中不应将其设置得如此低。我们建议根据用户可接受的延迟调整 `thinking_budget`，并将其设置为高于 1024，以在各项任务中获得有意义的改进。"
+
+#: ../../source/getting_started/quickstart.md:278
+#: f5b4018640c24a3cb6dd1e958f2860d9
+msgid "If thinking is not desired at all, developers should make use of the hard switch instead."
+msgstr "如果完全不需要思考，开发者应改用硬开关。"
+
+#: ../../source/getting_started/quickstart.md:281
+#: a6bbbe9da06c43c09cd3756e075e6103
+msgid "Next Step"
+msgstr "下一步"
+
+#: ../../source/getting_started/quickstart.md:283
+#: 40f5270a92bf490ab4fa0d6af2761044
+msgid "Now, you can have fun with Qwen3 models.  Would love to know more about its usage?  Feel free to check other documents in this documentation."
+msgstr "现在，您可以尽情探索 Qwen3 模型的各种用途。若想了解更多，请随时查阅本文档中的其他内容。"

docs/locales/zh_CN/LC_MESSAGES/getting_started/speed_benchmark.po

@@ -0,0 +1,1579 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-05-20 17:08+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/getting_started/speed_benchmark.md:1
+#: d7da8abe501c46e99fee28d56435b08b
+msgid "Speed Benchmark"
+msgstr "效率评估"
+
+#: ../../source/getting_started/speed_benchmark.md:3
+#: 478eb0d956db47ccafda9ec05e9c7253
+msgid "We report the speed performance of bfloat16 models and quantized models (including FP8, GPTQ, AWQ) of the Qwen3 series.  Specifically, we report the inference speed (tokens/s) as well as memory footprint (GB) under different context lengths."
+msgstr "本部分介绍 Qwen3 系列模型（原始模型和量化模型）的效率测试结果，包括推理速度(tokens/s)与不同上下文长度时的显存占用(GB)。"
+
+#: ../../source/getting_started/speed_benchmark.md:6
+#: c3e1ab9d5f8b4a54bff5d5a56ea6a2bb
+msgid "Environments"
+msgstr "环境配置"
+
+#: ../../source/getting_started/speed_benchmark.md:8
+#: 6b7764c599eb4693be742f161daf5cc4
+msgid "Hugging Face Transformers"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:10
+#: ../../source/getting_started/speed_benchmark.md:25
+#: aa80ee8b1abd4be1b0a9a88cff496938 c43bf971a253469c832f5e874eda86a9
+msgid "**Hardware**:"
+msgstr "**硬件**:"
+
+#: ../../source/getting_started/speed_benchmark.md:11
+#: ../../source/getting_started/speed_benchmark.md:26
+#: 471dbb8bd26c41a58f485dabf6643aa0
+msgid "NVIDIA H20 96GB"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:12
+#: 04347c8d74a44a18af8fb11cbf47bb42
+msgid "**Software for Non-AutoAWQ**:"
+msgstr "**非AutoAWQ的软件环境**:"
+
+#: ../../source/getting_started/speed_benchmark.md:13
+#: 5bf39b332ff04657838c29c627a0e3a6
+msgid "PyTorch 2.6.0"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:14
+#: e1ca0b138a5248a59f6fb59331ff09c1
+msgid "Flash Attention 2.7.4"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:15
+#: ../../source/getting_started/speed_benchmark.md:19
+#: ../../source/getting_started/speed_benchmark.md:29
+#: c763f81c0b2443d594f7b7c6c1cacce0
+msgid "Transformers 4.51.3"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:16
+#: 07c9d4a46b1446d9a334ad590b23ae8c
+msgid "GPTQModel 2.2.0+cu128torch2.6"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:17
+#: a13e8f4aa82f4693af93c20cda549afe
+msgid "**Software for AutoAWQ**:"
+msgstr "**AutoAWQ的软件环境**:"
+
+#: ../../source/getting_started/speed_benchmark.md:18
+#: ../../source/getting_started/speed_benchmark.md:28
+#: 14b90e1a69ce40f6a1edc3eb0fbf92b3
+msgid "PyTorch 2.6.0+cu124"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:20
+#: c8709c79343448838e2e6423ae888b6e
+msgid "AutoAWQ 0.2.9"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:21
+#: c8bd3eae4c8e497197bd3da6e79ded0a
+msgid "AutoAWQ_kernels 0.0.9"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:24
+#: cc0dad54e88d4e13857f3a45888b6030
+msgid "SGLang"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:27
+#: 931979d5babc4459940b65cc29f091b3
+msgid "**Software**:"
+msgstr "**软件环境**:"
+
+#: ../../source/getting_started/speed_benchmark.md:30
+#: 23713b47351b4b82949d982019a725b1
+msgid "SGLang 0.4.6.post1"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:31
+#: 8a1e4b407a5e46748b9fcbd29b7624ef
+msgid "SGL-kernel 0.1.0"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:32
+#: bc8a5ce98be34cd3987b015f51b607a1
+msgid "vLLM 0.7.2 (Required by SGLang for AWQ quantization)"
+msgstr "vLLM 0.7.2 (被SGLang AWQ量化依赖)"
+
+#: ../../source/getting_started/speed_benchmark.md:34
+#: 1b5176a8dd9647738f81c3f726f9e9dd
+msgid "Notes"
+msgstr "备注"
+
+#: ../../source/getting_started/speed_benchmark.md:36
+#: 5b67ede5b69845158d7de45576b5f511
+msgid "**Inference Speed (tokens/s)** is calculated as:"
+msgstr "**推理速度（tokens/s）** 的计算公式为："
+
+#: ../../source/getting_started/speed_benchmark.md:38
+#: 8d9cad9e886e4ba09e3a9907eecdc85e
+msgid "\\text{Speed} = \\frac{\\text{tokens}_{\\text{prompt}} + \\text{tokens}_{\\text{generation}}}{\\text{time}}"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:42
+#: 5e23850b08f54a5b93ca312f77ad16cb
+msgid "We use a **batch size of 1** and the **minimum number of GPUs** possible for evaluation."
+msgstr "batch size 设置为1，使用 GPU 数量尽可能少"
+
+#: ../../source/getting_started/speed_benchmark.md:44
+#: 25f5f831928e428a857e76cb66be39dc
+msgid "We test the **speed and memory usage** when generating **2048 tokens**, with input lengths of `1`, `6144`, `14336`, `30720`, `63488`, and `129024` tokens."
+msgstr "我们测试生成2048 tokens时的速度与显存占用，输入长度分别为1、6144、14336、30720、63488、129024 tokens（如受模型支持）。"
+
+#: ../../source/getting_started/speed_benchmark.md:47
+#: 11a1e0c5d8ec462987503d3eddf02e93
+msgid "**For SGLang**:"
+msgstr "**对于SGLang**:"
+
+#: ../../source/getting_started/speed_benchmark.md:48
+#: 39a19fc71e414215bfefe47fabd4f103
+msgid "**Memory usage** is not reported because SGLang pre-allocates all GPU memory.   By default, we set `mem_fraction_static=0.85`."
+msgstr "**内存使用情况**未报告，因为 SGLang 会预先分配所有 GPU 内存。默认情况下，我们设置 `mem_fraction_static=0.85`。"
+
+#: ../../source/getting_started/speed_benchmark.md:50
+#: 4dc120620fe04f8d929eb9a49e162384
+msgid "We configure `context_length=140000` and enable `enable_mixed_chunk=True`."
+msgstr "我们配置了 `context_length=140000` 并启用了 `enable_mixed_chunk=True`。"
+
+#: ../../source/getting_started/speed_benchmark.md:51
+#: f1912315cef646d885132a95c1bbfe61
+msgid "For **AWQ quantization**, we use the **awq_marlin** backend."
+msgstr "对于 **AWQ 量化**，我们使用 **awq_marlin** 后端。"
+
+#: ../../source/getting_started/speed_benchmark.md:52
+#: b71d9ac6ac2a4007b1bf5bcbbcc0a583
+msgid "We set `skip_tokenizer_init=True` and perform generation using `input_ids` instead of raw text prompts."
+msgstr "我们设置 `skip_tokenizer_init=True` 并使用 `input_ids` 进行生成，而不是使用原始文本提示。"
+
+#: ../../source/getting_started/speed_benchmark.md:54
+#: 68e13ce181df472fb7ac447baccccd5f
+msgid "**FP8 Performance in Transformers**: The inference speed of Transformers in FP8 mode is currently not optimal and requires further optimization."
+msgstr "**Transformers 中的 FP8 性能**：Transformers 在 FP8 模式下的推理速度目前不够理想，还需要进一步优化。"
+
+#: ../../source/getting_started/speed_benchmark.md:56
+#: eba091d7757241eba26249e3b4481358
+msgid "**GPTQ-INT4 Performance in SGLang**: The performance of GPTQ-INT4 in SGLang also needs improvement, and we are actively working with the team to enhance it."
+msgstr "**SGLang 中 GPTQ-INT4 的性能**：SGLang 中 GPTQ-INT4 的性能也需要改进，SGLang团队正提升其表现。"
+
+#: ../../source/getting_started/speed_benchmark.md:58
+#: 378478a6059142c4baa00ef74101c7f5
+msgid "Results"
+msgstr "结果"
+
+#: ../../source/getting_started/speed_benchmark.md:60
+#: e70ceb3f7c51413a9f385a49a32a5f53
+msgid "Qwen3-0.6B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:114
+#: 48d34c54a6f84a679798b6d6e10b9258
+msgid "Qwen3-0.6B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:169
+#: 6bbf0e62079c420ea3466b988c613429
+msgid "Qwen3-1.7B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:225
+#: d0b2aba9331646b28d3a8b2d75385d6c
+msgid "Qwen3-1.7B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:279
+#: 74e433c4044d4a06930966868db14258
+msgid "Qwen3-4B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:351
+#: 0fa507ce71d846688e57481c96114d58
+msgid "Qwen3-4B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:405
+#: dbffaaf4c5274194a1eb1ff640e86dea
+msgid "Qwen3-8B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:478
+#: f3be6cabb6db49769fd4d7f64e16391f
+msgid "Qwen3-8B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:533
+#: d08b7dfd146a4853a4d47c8f2a028cc4
+msgid "Qwen3-14B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:606
+#: 0fa507ce71d846688e57481c96114d58
+msgid "Qwen3-14B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:661
+#: 245c24c8822b4b95aa59bc31d3798e3b
+msgid "Qwen3-32B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:735
+#: f3be6cabb6db49769fd4d7f64e16391f
+msgid "Qwen3-32B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:789
+#: 35fe65bc8eac4fde92b4614a2875c78d
+msgid "Qwen3-30B-A3B (SGLang)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:861
+#: 31c35c93d04143bc9af6b4966beb6d1b
+msgid "Qwen3-30B-A3B (Transformers)"
+msgstr ""
+
+#: ../../source/getting_started/speed_benchmark.md:916
+#: c6f3063607fe403284c5aae77059b415
+msgid "Qwen3-235B-A22B (SGLang)"
+msgstr ""
+
+#~ msgid "To be updated for Qwen3."
+#~ msgstr "仍需为Qwen3更新。"
+
+#~ msgid "The environment of the evaluation with huggingface transformers is:"
+#~ msgstr "测试HuggingFace ``transformers`` 时的环境配置："
+
+#~ msgid "NVIDIA A100 80GB"
+#~ msgstr ""
+
+#~ msgid "CUDA 12.1"
+#~ msgstr ""
+
+#~ msgid "Pytorch 2.3.1"
+#~ msgstr ""
+
+#~ msgid "Flash Attention 2.5.8"
+#~ msgstr ""
+
+#~ msgid "Transformers 4.46.0"
+#~ msgstr ""
+
+#~ msgid "AutoGPTQ 0.7.1+cu121 (Compiled from source code)"
+#~ msgstr ""
+
+#~ msgid "AutoAWQ 0.2.6"
+#~ msgstr ""
+
+#~ msgid "The environment of the evaluation with vLLM is:"
+#~ msgstr "测试vLLM时的环境配置："
+
+#~ msgid "vLLM 0.6.3"
+#~ msgstr ""
+
+#~ msgid "Pytorch 2.4.0"
+#~ msgstr ""
+
+#~ msgid "Flash Attention 2.6.3"
+#~ msgstr ""
+
+#~ msgid "For vLLM, the memory usage is not reported because it pre-allocates all GPU memory. We use ``gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False`` by default."
+#~ msgstr "对于vLLM，由于GPU显存预分配，实际显存使用难以评估。默认情况下，统一设定为``gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False``。"
+
+#~ msgid "0.5B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Model"
+#~ msgstr "模型"
+
+#~ msgid "Input Length"
+#~ msgstr "输入长度"
+
+#~ msgid "Quantization"
+#~ msgstr "量化"
+
+#~ msgid "GPU Num"
+#~ msgstr "GPU数量"
+
+#~ msgid "Speed(tokens/s)"
+#~ msgstr "速度 (tokens/s)"
+
+#~ msgid "GPU Memory(GB)"
+#~ msgstr "显存占用 (GB)"
+
+#~ msgid "Note"
+#~ msgstr "注意："
+
+#~ msgid "Qwen2.5-0.5B-Instruct"
+#~ msgstr ""
+
+#~ msgid "1"
+#~ msgstr ""
+
+#~ msgid "BF16"
+#~ msgstr ""
+
+#~ msgid "47.40"
+#~ msgstr ""
+
+#~ msgid "0.97"
+#~ msgstr ""
+
+#~ msgid "GPTQ-Int8"
+#~ msgstr ""
+
+#~ msgid "35.17"
+#~ msgstr ""
+
+#~ msgid "0.64"
+#~ msgstr ""
+
+#~ msgid "auto_gptq==0.6.0+cu1210"
+#~ msgstr ""
+
+#~ msgid "GPTQ-Int4"
+#~ msgstr ""
+
+#~ msgid "50.60"
+#~ msgstr ""
+
+#~ msgid "0.48"
+#~ msgstr ""
+
+#~ msgid "AWQ"
+#~ msgstr ""
+
+#~ msgid "37.09"
+#~ msgstr ""
+
+#~ msgid "0.68"
+#~ msgstr ""
+
+#~ msgid "6144"
+#~ msgstr ""
+
+#~ msgid "47.45"
+#~ msgstr ""
+
+#~ msgid "1.23"
+#~ msgstr ""
+
+#~ msgid "36.47"
+#~ msgstr ""
+
+#~ msgid "0.90"
+#~ msgstr ""
+
+#~ msgid "48.89"
+#~ msgstr ""
+
+#~ msgid "0.73"
+#~ msgstr ""
+
+#~ msgid "37.04"
+#~ msgstr ""
+
+#~ msgid "0.72"
+#~ msgstr ""
+
+#~ msgid "14336"
+#~ msgstr ""
+
+#~ msgid "47.11"
+#~ msgstr ""
+
+#~ msgid "1.60"
+#~ msgstr ""
+
+#~ msgid "35.44"
+#~ msgstr ""
+
+#~ msgid "1.26"
+#~ msgstr ""
+
+#~ msgid "48.26"
+#~ msgstr ""
+
+#~ msgid "1.10"
+#~ msgstr ""
+
+#~ msgid "37.14"
+#~ msgstr ""
+
+#~ msgid "30720"
+#~ msgstr ""
+
+#~ msgid "47.16"
+#~ msgstr ""
+
+#~ msgid "2.34"
+#~ msgstr ""
+
+#~ msgid "36.25"
+#~ msgstr ""
+
+#~ msgid "2.01"
+#~ msgstr ""
+
+#~ msgid "49.22"
+#~ msgstr ""
+
+#~ msgid "1.85"
+#~ msgstr ""
+
+#~ msgid "36.90"
+#~ msgstr ""
+
+#~ msgid "1.84"
+#~ msgstr ""
+
+#~ msgid "0.5B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "311.55"
+#~ msgstr ""
+
+#~ msgid "257.07"
+#~ msgstr ""
+
+#~ msgid "260.93"
+#~ msgstr ""
+
+#~ msgid "261.95"
+#~ msgstr ""
+
+#~ msgid "304.79"
+#~ msgstr ""
+
+#~ msgid "254.10"
+#~ msgstr ""
+
+#~ msgid "257.33"
+#~ msgstr ""
+
+#~ msgid "259.80"
+#~ msgstr ""
+
+#~ msgid "290.28"
+#~ msgstr ""
+
+#~ msgid "243.69"
+#~ msgstr ""
+
+#~ msgid "247.01"
+#~ msgstr ""
+
+#~ msgid "249.58"
+#~ msgstr ""
+
+#~ msgid "264.51"
+#~ msgstr ""
+
+#~ msgid "223.86"
+#~ msgstr ""
+
+#~ msgid "226.50"
+#~ msgstr ""
+
+#~ msgid "229.84"
+#~ msgstr ""
+
+#~ msgid "1.5B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-1.5B-Instruct"
+#~ msgstr ""
+
+#~ msgid "39.68"
+#~ msgstr ""
+
+#~ msgid "2.95"
+#~ msgstr ""
+
+#~ msgid "32.62"
+#~ msgstr ""
+
+#~ msgid "1.82"
+#~ msgstr ""
+
+#~ msgid "43.33"
+#~ msgstr ""
+
+#~ msgid "1.18"
+#~ msgstr ""
+
+#~ msgid "31.70"
+#~ msgstr ""
+
+#~ msgid "1.51"
+#~ msgstr ""
+
+#~ msgid "40.88"
+#~ msgstr ""
+
+#~ msgid "3.43"
+#~ msgstr ""
+
+#~ msgid "31.46"
+#~ msgstr ""
+
+#~ msgid "2.30"
+#~ msgstr ""
+
+#~ msgid "43.96"
+#~ msgstr ""
+
+#~ msgid "1.66"
+#~ msgstr ""
+
+#~ msgid "32.30"
+#~ msgstr ""
+
+#~ msgid "1.63"
+#~ msgstr ""
+
+#~ msgid "40.43"
+#~ msgstr ""
+
+#~ msgid "4.16"
+#~ msgstr ""
+
+#~ msgid "31.06"
+#~ msgstr ""
+
+#~ msgid "3.03"
+#~ msgstr ""
+
+#~ msgid "43.66"
+#~ msgstr ""
+
+#~ msgid "2.39"
+#~ msgstr ""
+
+#~ msgid "32.39"
+#~ msgstr ""
+
+#~ msgid "2.36"
+#~ msgstr ""
+
+#~ msgid "38.59"
+#~ msgstr ""
+
+#~ msgid "5.62"
+#~ msgstr ""
+
+#~ msgid "31.04"
+#~ msgstr ""
+
+#~ msgid "4.49"
+#~ msgstr ""
+
+#~ msgid "35.68"
+#~ msgstr ""
+
+#~ msgid "3.85"
+#~ msgstr ""
+
+#~ msgid "31.95"
+#~ msgstr ""
+
+#~ msgid "3.82"
+#~ msgstr ""
+
+#~ msgid "1.5B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "183.33"
+#~ msgstr ""
+
+#~ msgid "201.67"
+#~ msgstr ""
+
+#~ msgid "217.03"
+#~ msgstr ""
+
+#~ msgid "213.74"
+#~ msgstr ""
+
+#~ msgid "176.68"
+#~ msgstr ""
+
+#~ msgid "192.83"
+#~ msgstr ""
+
+#~ msgid "206.63"
+#~ msgstr ""
+
+#~ msgid "203.64"
+#~ msgstr ""
+
+#~ msgid "168.69"
+#~ msgstr ""
+
+#~ msgid "183.69"
+#~ msgstr ""
+
+#~ msgid "195.88"
+#~ msgstr ""
+
+#~ msgid "192.64"
+#~ msgstr ""
+
+#~ msgid "152.04"
+#~ msgstr ""
+
+#~ msgid "162.82"
+#~ msgstr ""
+
+#~ msgid "173.57"
+#~ msgstr ""
+
+#~ msgid "170.20"
+#~ msgstr ""
+
+#~ msgid "3B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-3B-Instruct"
+#~ msgstr ""
+
+#~ msgid "30.80"
+#~ msgstr ""
+
+#~ msgid "5.95"
+#~ msgstr ""
+
+#~ msgid "25.69"
+#~ msgstr ""
+
+#~ msgid "3.38"
+#~ msgstr ""
+
+#~ msgid "35.21"
+#~ msgstr ""
+
+#~ msgid "2.06"
+#~ msgstr ""
+
+#~ msgid "25.29"
+#~ msgstr ""
+
+#~ msgid "2.50"
+#~ msgstr ""
+
+#~ msgid "32.20"
+#~ msgstr ""
+
+#~ msgid "6.59"
+#~ msgstr ""
+
+#~ msgid "24.69"
+#~ msgstr ""
+
+#~ msgid "3.98"
+#~ msgstr ""
+
+#~ msgid "34.47"
+#~ msgstr ""
+
+#~ msgid "2.67"
+#~ msgstr ""
+
+#~ msgid "24.86"
+#~ msgstr ""
+
+#~ msgid "2.62"
+#~ msgstr ""
+
+#~ msgid "31.72"
+#~ msgstr ""
+
+#~ msgid "7.47"
+#~ msgstr ""
+
+#~ msgid "24.70"
+#~ msgstr ""
+
+#~ msgid "4.89"
+#~ msgstr ""
+
+#~ msgid "34.36"
+#~ msgstr ""
+
+#~ msgid "3.58"
+#~ msgstr ""
+
+#~ msgid "25.19"
+#~ msgstr ""
+
+#~ msgid "3.54"
+#~ msgstr ""
+
+#~ msgid "25.37"
+#~ msgstr ""
+
+#~ msgid "9.30"
+#~ msgstr ""
+
+#~ msgid "21.67"
+#~ msgstr ""
+
+#~ msgid "6.72"
+#~ msgstr ""
+
+#~ msgid "23.60"
+#~ msgstr ""
+
+#~ msgid "5.41"
+#~ msgstr ""
+
+#~ msgid "24.56"
+#~ msgstr ""
+
+#~ msgid "5.37"
+#~ msgstr ""
+
+#~ msgid "3B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "127.61"
+#~ msgstr ""
+
+#~ msgid "150.02"
+#~ msgstr ""
+
+#~ msgid "168.20"
+#~ msgstr ""
+
+#~ msgid "165.50"
+#~ msgstr ""
+
+#~ msgid "123.15"
+#~ msgstr ""
+
+#~ msgid "143.09"
+#~ msgstr ""
+
+#~ msgid "159.85"
+#~ msgstr ""
+
+#~ msgid "156.38"
+#~ msgstr ""
+
+#~ msgid "117.35"
+#~ msgstr ""
+
+#~ msgid "135.50"
+#~ msgstr ""
+
+#~ msgid "149.35"
+#~ msgstr ""
+
+#~ msgid "147.75"
+#~ msgstr ""
+
+#~ msgid "105.88"
+#~ msgstr ""
+
+#~ msgid "118.38"
+#~ msgstr ""
+
+#~ msgid "129.28"
+#~ msgstr ""
+
+#~ msgid "127.19"
+#~ msgstr ""
+
+#~ msgid "7B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-7B-Instruct"
+#~ msgstr ""
+
+#~ msgid "40.38"
+#~ msgstr ""
+
+#~ msgid "14.38"
+#~ msgstr ""
+
+#~ msgid "31.55"
+#~ msgstr ""
+
+#~ msgid "8.42"
+#~ msgstr ""
+
+#~ msgid "43.10"
+#~ msgstr ""
+
+#~ msgid "5.52"
+#~ msgstr ""
+
+#~ msgid "32.03"
+#~ msgstr ""
+
+#~ msgid "5.39"
+#~ msgstr ""
+
+#~ msgid "38.76"
+#~ msgstr ""
+
+#~ msgid "15.38"
+#~ msgstr ""
+
+#~ msgid "31.26"
+#~ msgstr ""
+
+#~ msgid "9.43"
+#~ msgstr ""
+
+#~ msgid "38.27"
+#~ msgstr ""
+
+#~ msgid "6.52"
+#~ msgstr ""
+
+#~ msgid "32.37"
+#~ msgstr ""
+
+#~ msgid "6.39"
+#~ msgstr ""
+
+#~ msgid "29.78"
+#~ msgstr ""
+
+#~ msgid "16.91"
+#~ msgstr ""
+
+#~ msgid "26.86"
+#~ msgstr ""
+
+#~ msgid "10.96"
+#~ msgstr ""
+
+#~ msgid "28.70"
+#~ msgstr ""
+
+#~ msgid "8.05"
+#~ msgstr ""
+
+#~ msgid "30.23"
+#~ msgstr ""
+
+#~ msgid "7.92"
+#~ msgstr ""
+
+#~ msgid "18.83"
+#~ msgstr ""
+
+#~ msgid "19.97"
+#~ msgstr ""
+
+#~ msgid "17.59"
+#~ msgstr ""
+
+#~ msgid "14.01"
+#~ msgstr ""
+
+#~ msgid "18.45"
+#~ msgstr ""
+
+#~ msgid "11.11"
+#~ msgstr ""
+
+#~ msgid "19.11"
+#~ msgstr ""
+
+#~ msgid "10.98"
+#~ msgstr ""
+
+#~ msgid "7B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "84.28"
+#~ msgstr ""
+
+#~ msgid "122.01"
+#~ msgstr ""
+
+#~ msgid "154.05"
+#~ msgstr ""
+
+#~ msgid "148.10"
+#~ msgstr ""
+
+#~ msgid "80.70"
+#~ msgstr ""
+
+#~ msgid "112.38"
+#~ msgstr ""
+
+#~ msgid "141.98"
+#~ msgstr ""
+
+#~ msgid "137.64"
+#~ msgstr ""
+
+#~ msgid "77.69"
+#~ msgstr ""
+
+#~ msgid "105.25"
+#~ msgstr ""
+
+#~ msgid "129.35"
+#~ msgstr ""
+
+#~ msgid "124.91"
+#~ msgstr ""
+
+#~ msgid "70.33"
+#~ msgstr ""
+
+#~ msgid "90.71"
+#~ msgstr ""
+
+#~ msgid "108.30"
+#~ msgstr ""
+
+#~ msgid "104.66"
+#~ msgstr ""
+
+#~ msgid "63488"
+#~ msgstr ""
+
+#~ msgid "50.86"
+#~ msgstr ""
+
+#~ msgid "setting-64k"
+#~ msgstr "[设定3]"
+
+#~ msgid "60.52"
+#~ msgstr ""
+
+#~ msgid "67.97"
+#~ msgstr ""
+
+#~ msgid "66.42"
+#~ msgstr ""
+
+#~ msgid "129024"
+#~ msgstr ""
+
+#~ msgid "28.94"
+#~ msgstr ""
+
+#~ msgid "vllm==0.6.2, new sample config"
+#~ msgstr ""
+
+#~ msgid "25.97"
+#~ msgstr ""
+
+#~ msgid "26.37"
+#~ msgstr ""
+
+#~ msgid "26.57"
+#~ msgstr ""
+
+#~ msgid "[Setting-64k]=(gpu_memory_utilization=0.9 max_model_len=65536 enforce_eager=False)"
+#~ msgstr "[默认设定]=(gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False)"
+
+#~ msgid "[new sample config]: for vLLM, set the following sampling parameters: SamplingParams(temperature=0.7,top_p=0.8,top_k=20,repetition_penalty=1,presence_penalty=0,frequency_penalty=0,max_tokens=out_length)"
+#~ msgstr ""
+
+#~ msgid "14B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-14B-Instruct"
+#~ msgstr ""
+
+#~ msgid "24.74"
+#~ msgstr ""
+
+#~ msgid "28.08"
+#~ msgstr ""
+
+#~ msgid "18.84"
+#~ msgstr ""
+
+#~ msgid "16.11"
+#~ msgstr ""
+
+#~ msgid "25.89"
+#~ msgstr ""
+
+#~ msgid "9.94"
+#~ msgstr ""
+
+#~ msgid "19.23"
+#~ msgstr ""
+
+#~ msgid "9.79"
+#~ msgstr ""
+
+#~ msgid "20.51"
+#~ msgstr ""
+
+#~ msgid "29.50"
+#~ msgstr ""
+
+#~ msgid "17.80"
+#~ msgstr ""
+
+#~ msgid "17.61"
+#~ msgstr ""
+
+#~ msgid "20.06"
+#~ msgstr ""
+
+#~ msgid "11.36"
+#~ msgstr ""
+
+#~ msgid "19.21"
+#~ msgstr ""
+
+#~ msgid "11.22"
+#~ msgstr ""
+
+#~ msgid "13.92"
+#~ msgstr ""
+
+#~ msgid "12.66"
+#~ msgstr ""
+
+#~ msgid "19.98"
+#~ msgstr ""
+
+#~ msgid "13.79"
+#~ msgstr ""
+
+#~ msgid "13.81"
+#~ msgstr ""
+
+#~ msgid "14.17"
+#~ msgstr ""
+
+#~ msgid "13.67"
+#~ msgstr ""
+
+#~ msgid "8.20"
+#~ msgstr ""
+
+#~ msgid "36.85"
+#~ msgstr ""
+
+#~ msgid "7.77"
+#~ msgstr ""
+
+#~ msgid "24.88"
+#~ msgstr ""
+
+#~ msgid "8.14"
+#~ msgstr ""
+
+#~ msgid "18.71"
+#~ msgstr ""
+
+#~ msgid "8.31"
+#~ msgstr ""
+
+#~ msgid "18.57"
+#~ msgstr ""
+
+#~ msgid "14B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "46.30"
+#~ msgstr ""
+
+#~ msgid "70.40"
+#~ msgstr ""
+
+#~ msgid "98.02"
+#~ msgstr ""
+
+#~ msgid "92.66"
+#~ msgstr ""
+
+#~ msgid "43.83"
+#~ msgstr ""
+
+#~ msgid "64.33"
+#~ msgstr ""
+
+#~ msgid "86.10"
+#~ msgstr ""
+
+#~ msgid "83.11"
+#~ msgstr ""
+
+#~ msgid "41.91"
+#~ msgstr ""
+
+#~ msgid "59.21"
+#~ msgstr ""
+
+#~ msgid "76.85"
+#~ msgstr ""
+
+#~ msgid "74.03"
+#~ msgstr ""
+
+#~ msgid "37.18"
+#~ msgstr ""
+
+#~ msgid "49.23"
+#~ msgstr ""
+
+#~ msgid "60.91"
+#~ msgstr ""
+
+#~ msgid "59.01"
+#~ msgstr ""
+
+#~ msgid "26.85"
+#~ msgstr ""
+
+#~ msgid "32.83"
+#~ msgstr ""
+
+#~ msgid "37.67"
+#~ msgstr ""
+
+#~ msgid "36.71"
+#~ msgstr ""
+
+#~ msgid "14.53"
+#~ msgstr ""
+
+#~ msgid "15.10"
+#~ msgstr ""
+
+#~ msgid "15.13"
+#~ msgstr ""
+
+#~ msgid "15.25"
+#~ msgstr ""
+
+#~ msgid "32B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-32B-Instruct"
+#~ msgstr ""
+
+#~ msgid "17.54"
+#~ msgstr ""
+
+#~ msgid "61.58"
+#~ msgstr ""
+
+#~ msgid "14.52"
+#~ msgstr ""
+
+#~ msgid "33.56"
+#~ msgstr ""
+
+#~ msgid "19.20"
+#~ msgstr ""
+
+#~ msgid "18.94"
+#~ msgstr ""
+
+#~ msgid "14.60"
+#~ msgstr ""
+
+#~ msgid "18.67"
+#~ msgstr ""
+
+#~ msgid "12.49"
+#~ msgstr ""
+
+#~ msgid "63.72"
+#~ msgstr ""
+
+#~ msgid "11.61"
+#~ msgstr ""
+
+#~ msgid "35.86"
+#~ msgstr ""
+
+#~ msgid "13.42"
+#~ msgstr ""
+
+#~ msgid "21.09"
+#~ msgstr ""
+
+#~ msgid "20.81"
+#~ msgstr ""
+
+#~ msgid "8.95"
+#~ msgstr ""
+
+#~ msgid "67.31"
+#~ msgstr ""
+
+#~ msgid "8.53"
+#~ msgstr ""
+
+#~ msgid "39.28"
+#~ msgstr ""
+
+#~ msgid "9.48"
+#~ msgstr ""
+
+#~ msgid "24.67"
+#~ msgstr ""
+
+#~ msgid "9.71"
+#~ msgstr ""
+
+#~ msgid "24.39"
+#~ msgstr ""
+
+#~ msgid "5.59"
+#~ msgstr ""
+
+#~ msgid "74.47"
+#~ msgstr ""
+
+#~ msgid "5.42"
+#~ msgstr ""
+
+#~ msgid "46.45"
+#~ msgstr ""
+
+#~ msgid "5.79"
+#~ msgstr ""
+
+#~ msgid "31.84"
+#~ msgstr ""
+
+#~ msgid "5.85"
+#~ msgstr ""
+
+#~ msgid "31.56"
+#~ msgstr ""
+
+#~ msgid "32B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "22.13"
+#~ msgstr ""
+
+#~ msgid "setting1"
+#~ msgstr "[设定3]"
+
+#~ msgid "37.57"
+#~ msgstr ""
+
+#~ msgid "55.83"
+#~ msgstr ""
+
+#~ msgid "51.92"
+#~ msgstr ""
+
+#~ msgid "21.05"
+#~ msgstr ""
+
+#~ msgid "34.67"
+#~ msgstr ""
+
+#~ msgid "49.96"
+#~ msgstr ""
+
+#~ msgid "46.68"
+#~ msgstr ""
+
+#~ msgid "19.91"
+#~ msgstr ""
+
+#~ msgid "31.89"
+#~ msgstr ""
+
+#~ msgid "44.79"
+#~ msgstr ""
+
+#~ msgid "41.83"
+#~ msgstr ""
+
+#~ msgid "2"
+#~ msgstr ""
+
+#~ msgid "31.82"
+#~ msgstr ""
+
+#~ msgid "26.88"
+#~ msgstr ""
+
+#~ msgid "35.66"
+#~ msgstr ""
+
+#~ msgid "33.75"
+#~ msgstr ""
+
+#~ msgid "24.45"
+#~ msgstr ""
+
+#~ msgid "18.60"
+#~ msgstr ""
+
+#~ msgid "22.72"
+#~ msgstr ""
+
+#~ msgid "21.79"
+#~ msgstr ""
+
+#~ msgid "14.31"
+#~ msgstr ""
+
+#~ msgid "9.77"
+#~ msgstr ""
+
+#~ msgid "10.39"
+#~ msgstr ""
+
+#~ msgid "10.34"
+#~ msgstr ""
+
+#~ msgid "For context length 129024, the model needs to be predicted with the following config: \"model_max_length\"=131072"
+#~ msgstr ""
+
+#~ msgid "[Default Setting]=(gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False)"
+#~ msgstr "[默认设定]=(gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False)"
+
+#~ msgid "[Setting 1]=(gpu_memory_utilization=1.0 max_model_len=32768 enforce_eager=True)"
+#~ msgstr "[设定 3]=(gpu_memory_utilization=1.0 max_model_len=8192 enforce_eager=True)"
+
+#~ msgid "72B (Transformer)"
+#~ msgstr ""
+
+#~ msgid "Qwen2.5-72B-Instruct"
+#~ msgstr ""
+
+#~ msgid "8.73"
+#~ msgstr ""
+
+#~ msgid "136.20"
+#~ msgstr ""
+
+#~ msgid "8.66"
+#~ msgstr ""
+
+#~ msgid "72.61"
+#~ msgstr ""
+
+#~ msgid "11.07"
+#~ msgstr ""
+
+#~ msgid "39.91"
+#~ msgstr ""
+
+#~ msgid "11.50"
+#~ msgstr ""
+
+#~ msgid "39.44"
+#~ msgstr ""
+
+#~ msgid "140.00"
+#~ msgstr ""
+
+#~ msgid "77.81"
+#~ msgstr ""
+
+#~ msgid "7.56"
+#~ msgstr ""
+
+#~ msgid "42.50"
+#~ msgstr ""
+
+#~ msgid "8.17"
+#~ msgstr ""
+
+#~ msgid "42.13"
+#~ msgstr ""
+
+#~ msgid "3"
+#~ msgstr ""
+
+#~ msgid "4.25"
+#~ msgstr ""
+
+#~ msgid "149.14"
+#~ msgstr ""
+
+#~ msgid "4.66"
+#~ msgstr ""
+
+#~ msgid "82.55"
+#~ msgstr ""
+
+#~ msgid "5.27"
+#~ msgstr ""
+
+#~ msgid "46.86"
+#~ msgstr ""
+
+#~ msgid "5.57"
+#~ msgstr ""
+
+#~ msgid "46.38"
+#~ msgstr ""
+
+#~ msgid "2.94"
+#~ msgstr ""
+
+#~ msgid "164.79"
+#~ msgstr ""
+
+#~ msgid "94.75"
+#~ msgstr ""
+
+#~ msgid "3.14"
+#~ msgstr ""
+
+#~ msgid "62.57"
+#~ msgstr ""
+
+#~ msgid "3.23"
+#~ msgstr ""
+
+#~ msgid "61.64"
+#~ msgstr ""
+
+#~ msgid "72B (vLLM)"
+#~ msgstr ""
+
+#~ msgid "18.19"
+#~ msgstr ""
+
+#~ msgid "Setting 1"
+#~ msgstr "[设定3]"
+
+#~ msgid "4"
+#~ msgstr ""
+
+#~ msgid "31.37"
+#~ msgstr ""
+
+#~ msgid "Default"
+#~ msgstr ""
+
+#~ msgid "31.40"
+#~ msgstr ""
+
+#~ msgid "16.47"
+#~ msgstr ""
+
+#~ msgid "Setting 2"
+#~ msgstr "[设定2]"
+
+#~ msgid "44.30"
+#~ msgstr ""
+
+#~ msgid "29.90"
+#~ msgstr ""
+
+#~ msgid "29.37"
+#~ msgstr ""
+
+#~ msgid "13.88"
+#~ msgstr ""
+
+#~ msgid "Setting 3"
+#~ msgstr "[设定3]"
+
+#~ msgid "40.67"
+#~ msgstr ""
+
+#~ msgid "30.10"
+#~ msgstr ""
+
+#~ msgid "27.20"
+#~ msgstr ""
+
+#~ msgid "38.10"
+#~ msgstr ""
+
+#~ msgid "36.63"
+#~ msgstr ""
+
+#~ msgid "27.53"
+#~ msgstr ""
+
+#~ msgid "23.32"
+#~ msgstr ""
+
+#~ msgid "30.98"
+#~ msgstr ""
+
+#~ msgid "30.02"
+#~ msgstr ""
+
+#~ msgid "20.74"
+#~ msgstr ""
+
+#~ msgid "Setting 4"
+#~ msgstr "[设定3]"
+
+#~ msgid "16.27"
+#~ msgstr ""
+
+#~ msgid "19.84"
+#~ msgstr ""
+
+#~ msgid "19.32"
+#~ msgstr ""
+
+#~ msgid "12.68"
+#~ msgstr ""
+
+#~ msgid "Setting 5"
+#~ msgstr "[设定3]"
+
+#~ msgid "14.11"
+#~ msgstr ""
+
+#~ msgid "10.11"
+#~ msgstr ""
+
+#~ msgid "9.88"
+#~ msgstr ""
+
+#~ msgid "[Setting 1]=(gpu_memory_utilization=0.98 max_model_len=4096 enforce_eager=True)"
+#~ msgstr "[设定 1]=(gpu_memory_utilization=0.98 max_model_len=4096 enforce_eager=True)"
+
+#~ msgid "[Setting 2]=(gpu_memory_utilization=1.0 max_model_len=4096 enforce_eager=True)"
+#~ msgstr "[设定 2]=(gpu_memory_utilization=1.0 max_model_len=4096 enforce_eager=True)"
+
+#~ msgid "[Setting 3]=(gpu_memory_utilization=1.0 max_model_len=8192 enforce_eager=True)"
+#~ msgstr "[设定 3]=(gpu_memory_utilization=1.0 max_model_len=8192 enforce_eager=True)"
+
+#~ msgid "[Setting 4]=(gpu_memory_utilization=0.9 max_model_len=65536 enforce_eager=False)"
+#~ msgstr "[默认设定]=(gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False)"
+
+#~ msgid "[Setting 5]=(gpu_memory_utilization=0.9 max_model_len=131072 enforce_eager=False)"
+#~ msgstr "[默认设定]=(gpu_memory_utilization=0.9 max_model_len=32768 enforce_eager=False)"
+

docs/locales/zh_CN/LC_MESSAGES/getting_started/thinking_budget.po

@@ -0,0 +1,71 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 16:36+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/getting_started/thinking_budget.md:1
+#: 98870c0bf86c4c3b832204258d05c95c
+msgid "Thinking budget"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:3
+#: f3ac8e3721084db486cd5c8f99c40e68
+msgid "This example demonstrates the inference process with thinking budgets using Qwen3 series models. The process involves two steps:"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:4
+#: 9e573494a6294fe4b33fb9e20d2648a0
+msgid "the model generates reasoning content within the specified thinking budget"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:5
+#: 873d4d7b33e54257b32096a23f5bfbac
+msgid "append the reasoning content to the conversation context and call the model again to get the final response"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:7
+#: 3284c7a085b04934aaa32317c5c1a9b7
+msgid "Environment Setup"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:9
+#: 0c8eee4d2e06463ab03c7f8330a8ffd0
+msgid "`transformers >= 4.51.0`"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:10
+#: 1bb85d8dbe9f40d9a9f6da43ea92bc19
+msgid "`openai >= 1.65.0`"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:12
+#: 1fbbb06af9474e30a50db81b4733f931
+msgid "Basic Usage"
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:14
+#: b365e4aac4c047378fd3b09771987379
+msgid "First, you should start a Qwen3 model in thinking mode. You can refer to [Quickstart](https://github.com/QwenLM/Qwen3/blob/main/docs/source/getting_started/quickstart.md) for more details."
+msgstr ""
+
+#: ../../source/getting_started/thinking_budget.md:16
+#: 259a5805d2e3483aa6f4d056b7c9ce94
+msgid "Then, you can use the following code to call the model with thinking budgets."
+msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/index.po

@@ -0,0 +1,144 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/index.rst:34
+msgid "Getting Started"
+msgstr "快速开始"
+
+#: ../../Qwen/source/index.rst:44
+msgid "Inference"
+msgstr "推理"
+
+#: ../../Qwen/source/index.rst:51
+msgid "Run Locally"
+msgstr "本地运行"
+
+#: ../../Qwen/source/index.rst:60
+msgid "Deployment"
+msgstr "部署"
+
+#: ../../Qwen/source/index.rst:71
+msgid "Quantization"
+msgstr "量化"
+
+#: ../../Qwen/source/index.rst:80
+msgid "Training"
+msgstr "训练"
+
+#: ../../Qwen/source/index.rst:87
+msgid "Framework"
+msgstr "框架"
+
+#: ../../Qwen/source/index.rst:2 6e52d3a497924f828d4c6b9dd59370d5
+msgid "Welcome to Qwen!"
+msgstr "欢迎来到Qwen"
+
+#: ../../Qwen/source/index.rst:4 235805a6d4a34184821c0f4f81020ef1
+msgid "Qwen3"
+msgstr ""
+
+#: ../../Qwen/source/index.rst:11 b8a3aa3f31594232959a08d89e9dc7db
+msgid "Qwen is the large language model and large multimodal model series of the Qwen Team, Alibaba Group. Both language models and multimodal models are pretrained on large-scale multilingual and multimodal data and post-trained on quality data for aligning to human preferences. Qwen is capable of natural language understanding, text generation, vision understanding, audio understanding, tool use, role play, playing as AI agent, etc."
+msgstr "Qwen是阿里巴巴集团Qwen团队研发的大语言模型和大型多模态模型系列。无论是语言模型还是多模态模型，均在大规模多语言和多模态数据上进行预训练，并通过高质量数据进行后期微调以贴近人类偏好。Qwen具备自然语言理解、文本生成、视觉理解、音频理解、工具使用、角色扮演、作为AI Agent进行互动等多种能力。"
+
+#: ../../Qwen/source/index.rst:14 8735c67355064a97b2793b721a701b21
+msgid "The latest version, Qwen3, has the following features:"
+msgstr "最新版本Qwen3有以下特点："
+
+#: ../../Qwen/source/index.rst:16 1956d75084244379aad9503fcc572f00
+msgid "**Dense and Mixture-of-Experts (MoE) models**, available in 0.6B, 1.7B, 4B, 8B, 14B, 32B and 30B-A3B, 235B-A22B."
+msgstr "**全尺寸稠密与混合专家模型**：0.6B, 1.7B, 4B, 8B, 14B, 32B and 30B-A3B, 235B-A22B"
+
+#: ../../Qwen/source/index.rst:17 1fdf12161cd14663b67b2c08f9219ddb
+msgid "**Seamless switching between thinking mode** (for complex logical reasoning, math, and coding) and **non-thinking mode** (for efficient, general-purpose chat) **within a single model**, ensuring optimal performance across various scenarios."
+msgstr "支持在**思考模式**（用于复杂逻辑推理、数学和编码）和 **非思考模式** （用于高效通用对话）之间**无缝切换**，确保在各种场景下的最佳性能。"
+
+#: ../../Qwen/source/index.rst:18 189ff2a03ad249ef88202c34e9f8aa86
+msgid "**Significantly enhancement in 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."
+msgstr "**显著增强的推理能力**，在数学、代码生成和常识逻辑推理方面超越了之前的 QwQ（在思考模式下）和 Qwen2.5 指令模型（在非思考模式下）。"
+
+#: ../../Qwen/source/index.rst:19 64ebcda0381148cb8edf8d92b49469ea
+msgid "**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."
+msgstr "**卓越的人类偏好对齐**，在创意写作、角色扮演、多轮对话和指令跟随方面表现出色，提供更自然、更吸引人和更具沉浸感的对话体验。"
+
+#: ../../Qwen/source/index.rst:20 ec0ebb91f1ed491f8672aefef6307d85
+msgid "**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."
+msgstr "**擅长智能体能力**，可以在思考和非思考模式下精确集成外部工具，在复杂的基于代理的任务中在开源模型中表现领先。"
+
+#: ../../Qwen/source/index.rst:21 526b161edf284e1b913aabc7e7fcc77c
+msgid "**Support of 100+ languages and dialects** with strong capabilities for **multilingual instruction following** and **translation**."
+msgstr "**支持 100 多种语言和方言**，具有强大的多语言理解、推理、指令跟随和生成能力。"
+
+#: ../../Qwen/source/index.rst:23 79ed3f0e7da043bb8b53f510ed244814
+msgid "For more information, please visit our:"
+msgstr "想了解更多信息，欢迎访问："
+
+#: ../../Qwen/source/index.rst:25 b2e579ae57de4d2985ab1c350fdf2458
+msgid "`Blog <https://qwenlm.github.io/>`__"
+msgstr "`博客 <https://qwenlm.github.io/>`__"
+
+#: ../../Qwen/source/index.rst:26 406389fe90064e879bd28665a021ee7e
+msgid "`GitHub <https://github.com/QwenLM>`__"
+msgstr "`GitHub <https://github.com/QwenLM>`__"
+
+#: ../../Qwen/source/index.rst:27 714c64df6aed4e608571de0155199fef
+msgid "`Hugging Face <https://huggingface.co/Qwen>`__"
+msgstr "`Hugging Face <https://huggingface.co/Qwen>`__"
+
+#: ../../Qwen/source/index.rst:28 214e12e0b1c04b268582b2c46d22334d
+msgid "`ModelScope <https://modelscope.cn/organization/qwen>`__"
+msgstr "`ModelScope <https://modelscope.cn/organization/qwen>`__"
+
+#: ../../Qwen/source/index.rst:29 9c64e461dc3a440ab92d94887fe3d2d8
+msgid "`Qwen3 Collection <https://huggingface.co/collections/Qwen/qwen3-67dd247413f0e2e4f653967f>`__"
+msgstr ""
+
+#: ../../Qwen/source/index.rst:31 c6056edc8a3a4a12bd3a75eeb210f7a2
+msgid "Join our community by joining our `Discord <https://discord.gg/yPEP2vHTu4>`__ and `WeChat <https://github.com/QwenLM/Qwen/blob/main/assets/wechat.png>`__ group. We are looking forward to seeing you there!"
+msgstr "加入社区，加入 `Discord <https://discord.gg/yPEP2vHTu4>`__ 和 `微信群 <https://github.com/QwenLM/Qwen/blob/main/assets/wechat.png>`__ 。很期待见到你们！"
+
+#~ msgid "Web UI"
+#~ msgstr "Web UI"
+
+#~ msgid "Benchmark"
+#~ msgstr "评测"
+
+#~ msgid "Qwen2.5"
+#~ msgstr ""
+
+#~ msgid "Dense, easy-to-use, decoder-only language models, available in **0.5B**, **1.5B**, **3B**, **7B**, **14B**, **32B**, and **72B** sizes, and base and instruct variants."
+#~ msgstr "易于使用的仅解码器稠密语言模型，提供 **0.5B** 、**1.5B** 、**3B** 、**7B** 、**14B** 、**32B** 和 **72B** 共7种参数规模的模型，并且有基模型和指令微调模型两种变体（其中“ B ”表示“十亿”， 72B 即为 720 亿）"
+
+#~ msgid "Pretrained on our latest large-scale dataset, encompassing up to **18T** tokens."
+#~ msgstr "利用我们最新的数据集进行预训练，包含多达 18T tokens （其中“ T ”表示“万亿”， 18T 即为 18 万亿）"
+
+#~ msgid "Significant improvements in instruction following, generating long texts (over 8K tokens), understanding structured data (e.g, tables), and generating structured outputs especially JSON."
+#~ msgstr "在遵循指令、生成长文本（超过 8K tokens ）、理解结构化数据（例如，表格）以及生成结构化输出特别是 JSON 方面有了显著改进"
+
+#~ msgid "More resilient to the diversity of system prompts, enhancing role-play implementation and condition-setting for chatbots."
+#~ msgstr "更加适应多样化的系统提示，增强了角色扮演的实现和聊天机器人的背景设置。"
+
+#~ msgid "Context length support up to **128K** tokens and can generate up to **8K** tokens."
+#~ msgstr "支持最多达 **128K** tokens 的上下文长度，并能生成多达 **8K** tokens 的文本。"
+
+#~ msgid "Multilingual support for over **29** languages, including Chinese, English, French, Spanish, Portuguese, German, Italian, Russian, Japanese, Korean, Vietnamese, Thai, Arabic, and more."
+#~ msgstr "支持超过 **29** 种语言，包括中文、英文、法文、西班牙文、葡萄牙文、德文、意大利文、俄文、日文、韩文、越南文、泰文、阿拉伯文等。"
+
+#~ msgid "`Qwen2.5 Collection <https://huggingface.co/collections/Qwen/qwen25-66e81a666513e518adb90d9e>`__"
+#~ msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/inference/transformers.po

@@ -0,0 +1,205 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-05-29 14:27+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/inference/transformers.md:1 c178ffb3888f441180ecb4fca79195fd
+msgid "Transformers"
+msgstr ""
+
+#: ../../source/inference/transformers.md:3 c816184205fc456894a0b5b5f3dc4b80
+msgid "Transformers is a library of pretrained natural language processing for inference and training.  Developers can use Transformers to train models on their data, build inference applications, and generate texts with large language models."
+msgstr "Transformers 是一个用于推理和训练的预训练自然语言处理库。开发者可以使用 Transformers 在自己的数据上训练模型、构建推理应用，并通过大型语言模型生成文本。"
+
+#: ../../source/inference/transformers.md:6 373686a143e14f7a9fd059cddff449bf
+msgid "Environment Setup"
+msgstr "环境配置"
+
+#: ../../source/inference/transformers.md:8 7dfb38faea8f4eeda6072046cead1636
+msgid "`transformers>=4.51.0`"
+msgstr ""
+
+#: ../../source/inference/transformers.md:9 9d7e644e3ec840bead01f1ce246e9cd1
+msgid "`torch>=2.6` is recommended"
+msgstr "推荐使用 `torch>=2.6`"
+
+#: ../../source/inference/transformers.md:10 06da43b05cd94312a35c83fd485e617e
+msgid "GPU is recommended"
+msgstr "推荐使用 GPU"
+
+#: ../../source/inference/transformers.md:13 363ebf64fe2746ada9487ec3bf691ed8
+msgid "Basic Usage"
+msgstr "基本用法"
+
+#: ../../source/inference/transformers.md:15 356e5bca4faa4492b7ce0646fcb9dc12
+msgid "You can use the `pipeline()` interface or the `generate()` interface to generate texts with Qwen3 in transformers."
+msgstr "您可以使用 `pipeline()` 接口或 `generate()` 接口在 transformers 中通过 Qwen3 生成文本。"
+
+#: ../../source/inference/transformers.md:17 704e2d1659d94b6d911bd5e01ea63764
+msgid "In general, the pipeline interface requires less boilerplate code, which is shown here. The following shows a basic example using pipeline for multi-turn conversations:"
+msgstr "通常，pipeline 接口需要的样板代码更少，如下所示。以下展示了一个使用 pipeline 进行多轮对话的基本示例："
+
+#: ../../source/inference/transformers.md:44 2054af41b1de457a9f14ef6f8117772c
+msgid "There are some important parameters creating the pipeline:"
+msgstr "创建 pipeline 时有一些重要的参数："
+
+#: ../../source/inference/transformers.md:45 0127b56b938c496f91a8cc1642af1590
+msgid "**Model**: `model_name_or_path` could be a model ID like `Qwen/Qwen3-8B` or a local path."
+msgstr "**模型**：`model_name_or_path` 可以是像 `Qwen/Qwen3-8B` 这样的模型 ID，也可以是本地路径。"
+
+#: ../../source/inference/transformers.md:47 374ac106d4374722a5428c492a1865f8
+msgid "To download model files to a local directory, you could use"
+msgstr "要将模型文件下载到本地目录，可以使用"
+
+#: ../../source/inference/transformers.md:51 47239a7ef1124d22802c8f7d0d87b251
+msgid "You can also download model files using ModelScope if you are in mainland China"
+msgstr "如果您在中国大陆，还可以使用 ModelScope 下载模型文件"
+
+#: ../../source/inference/transformers.md:55 e787e9221bdc4e6aaf7f98ed97e726da
+msgid "**Device Placement**: `device_map=\"auto\"` will load the model parameters to multiple devices automatically, if available.  It relies on the `accelerate` package. If you would like to use a single device, you can pass `device` instead of device_map. `device=-1` or `device=\"cpu\"` indicates using CPU, `device=\"cuda\"` indicates using the current GPU, and `device=\"cuda:1\"` or `device=1` indicates using the second GPU. Do not use `device_map` and `device` at the same time!"
+msgstr "**设备分配**：如果可用，`device_map=\"auto\"` 将自动将模型参数加载到多个设备上。它依赖于 `accelerate` 包。如果您想使用单个设备，可以传递 `device` 而不是 `device_map`。`device=-1` 或 `device=\"cpu\"` 表示使用 CPU，`device=\"cuda\"` 表示使用当前 GPU，`device=\"cuda:1\"` 或 `device=1` 表示使用第二个 GPU。不要同时使用 `device_map` 和 `device`！"
+
+#: ../../source/inference/transformers.md:60 91247cdab1f142559217047bf9d36024
+msgid "**Compute Precision**: `torch_dtype=\"auto\"` will determine automatically the data type to use based on the original precision of the checkpoint and the precision your device supports. For modern devices, the precision determined will be `bfloat16`."
+msgstr "**计算精度**：`torch_dtype=\"auto\"` 将根据检查点的原始精度和设备支持的精度自动确定要使用的数���类型。对于现代设备，确定的精度将是 `bfloat16`。"
+
+#: ../../source/inference/transformers.md:63 65b419de7e784e8d8790aa319ad28c42
+msgid "If you don't pass `torch_dtype=\"auto\"`, the default data type is `float32`, which will take double the memory and be slower in computation."
+msgstr "如果您不传递 `torch_dtype=\"auto\"`，默认数据类型为 `float32`，这将占用两倍的内存并且计算速度较慢。"
+
+#: ../../source/inference/transformers.md:66 7e6c5bcd15bd4c62a4a3ff9f4643bf8e
+msgid "Calls to the text generation pipeline will use the generation configuration from the model file, e.g., `generation_config.json`.  This configuration could be overridden by passing arguments directly to the call. The default is equivalent to"
+msgstr "调用文本生成 pipeline 时，将使用模型文件中的生成配置，例如 `generation_config.json`。这些配置可以通过直接向调用传递参数来覆盖。默认配置等效于"
+
+#: ../../source/inference/transformers.md:73 3bc839021fe14d9c999929da1ee45547
+msgid "For the best practices in configuring generation parameters, please see the model card."
+msgstr "有关配置生成参数的最佳实践，请参阅模型卡片。"
+
+#: ../../source/inference/transformers.md:75 5cc87eccca0e4fb4bb67c2deafc72569
+msgid "Thinking & Non-Thinking Mode"
+msgstr "思考与非思考模式"
+
+#: ../../source/inference/transformers.md:77 5f78a0a90ae341c2ab26b525d8f618bb
+msgid "By default, Qwen3 model will think before response. It is also true for the `pipeline()` interface. To switch between thinking and non-thinking mode, two methods can be used"
+msgstr "默认情况下，Qwen3 模型会在回复前进行思考，`pipeline()` 接口也是如此。要切换思考与非思考模式，可以使用以下两种方法："
+
+#: ../../source/inference/transformers.md:80 2055152940d54de7ad900f6bfd2b0186
+msgid "Append a final assistant message, containing only `<think>\\n\\n</think>\\n\\n`.  This method is stateless, meaning it will only work for that single turn.  It will also strictly prevent the model from generating thinking content. For example,"
+msgstr "追加一条仅包含 `<think>\\n\\n</think>\\n\\n` 的最终助手 (assistant) 消息。此方法是无状态的，意味着它仅对当前轮对话生效，并且会严格阻止模型生成思考内容。例如："
+
+#: ../../source/inference/transformers.md:97 8c9c833fa8004aecb65eef07212a140b
+msgid "Add to the user (or the system) message, `/no_think` to disable thinking and `/think` to enable thinking. This method is stateful, meaning the model will follow the most recent instruction in multi-turn conversations."
+msgstr "在用户 (user) 或系统 (system) 消息中添加 `/no_think` 以禁用思考、添加 `/think` 以启用思考。此方法是有状态的，意味着在多轮对话中，模型将遵循最近的指令。您还可以使用自然语言指令。"
+
+#: ../../source/inference/transformers.md:113 957c3c1fa49a4b119c7fc78fa9419e45
+msgid "Parsing Thinking Content"
+msgstr "解析思考内容"
+
+#: ../../source/inference/transformers.md:115 938849b04bf649918c233707e408d21a
+msgid "If you would like a more structured assistant message format, you can use the following function to extract the thinking content into a field named `reasoning_content` which is similar to the format used by vLLM, SGLang, etc."
+msgstr "如果您希望获得更结构化的助手消息格式，可以使用以下函数将思考内容提取到名为 `reasoning_content` 的字段中，该字段的格式类似于 vLLM、SGLang 等使用的格式。"
+
+#: ../../source/inference/transformers.md:131 e46bd3b0ec974011b7c658ab29b2fdc1
+msgid "Parsing Tool Calls"
+msgstr "解析工具调用"
+
+#: ../../source/inference/transformers.md:133 d3d893f89e4149db823e418a5bd2d773
+msgid "For tool calling with Transformers, please refer to [our guide on Function Calling](../framework/function_call.md#hugging-face-transformers)."
+msgstr "有关使用 Transformers 进行工具调用的信息，请参阅[函数调用指南](../framework/function_call.md#hugging-face-transformers)。"
+
+#: ../../source/inference/transformers.md:135 304b7ec8d3d446b6ada27d48f128660d
+msgid "Serving Quantized models"
+msgstr "使用量化模型"
+
+#: ../../source/inference/transformers.md:137 b5f3ee666c3c475ba5282fd3bb184bbc
+msgid "Qwen3 comes with two types of pre-quantized models, FP8 and AWQ. The command serving those models are the same as the original models except for the name change:"
+msgstr "Qwen3 提供了两种类型的预量化模型：FP8 和 AWQ。使用这些模型的命令与原始模型相同，只是名称有所更改："
+
+#: ../../source/inference/transformers.md:155 6e6eb31d2af94ce1bc9a44d973d6febc
+msgid "FP8 computation is supported on NVIDIA GPUs with compute capability > 8.9, that is, Ada Lovelace, Hopper, and later GPUs."
+msgstr "FP8 计算在计算能力 > 8.9 的 NVIDIA GPU 上受支持，即 Ada Lovelace、Hopper 及更新的 GPU。"
+
+#: ../../source/inference/transformers.md:157 780916506f034d5bb663a2aa69083ee3
+msgid "For better performance, make sure `triton` and a CUDA compiler compatible with the CUDA version of `torch` in your environment are installed."
+msgstr "为了获得更好的性能，请确保安装了 `triton` 和与环境中 `torch` 的 CUDA 版本兼容的 CUDA 编译器。"
+
+#: ../../source/inference/transformers.md:161 17ad788596ef464db2b333ec10c91742
+msgid "As of 4.51.0, there are issues with Transformers when running those checkpoints **across GPUs**. The following method could be used to work around those issues:"
+msgstr "在 4.51.0 版本中，在**跨 GPU**的情况下运行 FP8 存在一些与 Transformers 相关的问题。可以使用以下方法来解决这些问题："
+
+#: ../../source/inference/transformers.md:163 2e4c2a9ab6864d7ca8a0f477dc888f75
+msgid "Set the environment variable `CUDA_LAUNCH_BLOCKING=1` before running the script; or"
+msgstr "在运行脚本之前设置环境变量 `CUDA_LAUNCH_BLOCKING=1`；或者"
+
+#: ../../source/inference/transformers.md:164 328f9a6a90094a3ca8c7f824ffbe641b
+msgid "Uncomment [this line](https://github.com/huggingface/transformers/blob/0720e206c6ba28887e4d60ef60a6a089f6c1cc76/src/transformers/integrations/finegrained_fp8.py#L340) in your local installation of `transformers`."
+msgstr "取消注释您本地安装的 `transformers` 中的[这一行](https://github.com/huggingface/transformers/blob/0720e206c6ba28887e4d60ef60a6a089f6c1cc76/src/transformers/integrations/finegrained_fp8.py#L340)。"
+
+#: ../../source/inference/transformers.md:168 a8ab4a05e34e4fd1b816388ca1c4614f
+msgid "Enabling Long Context"
+msgstr "启用长上下文"
+
+#: ../../source/inference/transformers.md:170 15c36696b02a45829c0158fc644af96f
+msgid "The maximum context length in pre-training for Qwen3 models is 32,768 tokens. It can be extended to 131,072 tokens with RoPE scaling techniques. We have validated the performance with YaRN."
+msgstr "Qwen3 模型在预训练中的最大上下文长度为 32,768 个 token。通过 RoPE 缩放技术，它可以扩展到 131,072 个 token。我们已使用 YaRN 验证了性能。"
+
+#: ../../source/inference/transformers.md:174 ff0ec1adc3e647f4b5ecf29adc14a5c6
+msgid "Transformers supports YaRN, which can be enabled either by modifying the model files or overriding the default arguments when loading the model."
+msgstr "Transformers 支持 YaRN，可以通过修改模型文件或在加载模型时覆盖默认参数来启用。"
+
+#: ../../source/inference/transformers.md:176 a28d0e27841343d7a3c94fd5f047b671
+msgid "Modifying the model files: In the `config.json` file, add the rope_scaling fields:"
+msgstr "修改模型文件：在 `config.json` 文件中，添加 rope_scaling 字段："
+
+#: ../../source/inference/transformers.md:187 50430e65309e453282eec582c6d74493
+msgid "Overriding the default arguments:"
+msgstr "覆盖默认参数："
+
+#: ../../source/inference/transformers.md:210 091b4560600b48aa9ba156da08c27fab
+msgid "As of Transformers 4.52.3, it will use `max_position_embeddings/rope_scaling.original_max_position_embeddings` as the `rope_scaling.factor` regradless of the specified `rope_scaling.factor`. See [this issue](https://github.com/huggingface/transformers/issues/38224) for more information."
+msgstr "在 Transformers 4.52.3 版本中，无论指定的 `rope_scaling.factor` 是多少，它都会使用 `max_position_embeddings/rope_scaling.original_max_position_embeddings` 作为 `rope_scaling.factor`。更多信息请参阅[此问题](https://github.com/huggingface/transformers/issues/38224 )。"
+
+#: ../../source/inference/transformers.md:214 62f158e126984c04a39ad039d42a4dc0
+msgid "Transformers implements 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."
+msgstr "Transformers 实现了静态 YaRN，这意味着无论输入长度如何，缩放因子保持不变，**这可能会对较短文本的性能产生影响。** 我们建议仅在需要处理长上下文时添加 `rope_scaling` 配置。还建议根据需要修改 `factor`。例如，如果您的应用程序的典型上下文长度为 65,536 个 token，则最好将 `factor` 设置为 2.0。"
+
+#: ../../source/inference/transformers.md:220 1c816d18902b4fad8eaaa3598459cc65
+msgid "Streaming Generation"
+msgstr "流式输出"
+
+#: ../../source/inference/transformers.md:222 2b79e8f552ae4399aa580e4b00ebc6bd
+msgid "With the help of `TextStreamer`, you can modify your chatting with Qwen3 to streaming mode.  It will print the response as being generated to the console or the terminal."
+msgstr "借助 `TextStreamer` ，您可以将与 Qwen3 的对话切换到流式传输模式。下面是一个关于如何使用它的示例："
+
+#: ../../source/inference/transformers.md:242 113734a6f14141a9a11cb3536cd37471
+msgid "Besides using `TextStreamer`, we can also use `TextIteratorStreamer` which stores print-ready text in a queue, to be used by a downstream application as an iterator:"
+msgstr "除了使用 `TextStreamer` 之外，我们还可以使用 `TextIteratorStreamer` ，它将可打印的文本存储在一个队列中，以便下游应用程序作为迭代器来使用："
+
+#: ../../source/inference/transformers.md:271 51fb3a808ca7448694b0cab5582025e3
+msgid "Batch Generation"
+msgstr "批处理"
+
+#: ../../source/inference/transformers.md:274 13ec723ad16648f593bdd5d75f125f93
+msgid "Batching is not automatically a win for performance."
+msgstr "批处理不总能提速。"
+
+#: ../../source/inference/transformers.md:300 1afe856936ef4a19a386f4ab9704dd0e
+msgid "FAQ"
+msgstr "常见问题解答"
+
+#: ../../source/inference/transformers.md:302 7175bda60e7a4796b9279b48116f819f
+msgid "You may find distributed inference with Transformers is not as fast as you would imagine. Transformers with `device_map=\"auto\"` does not apply tensor parallelism, and it only uses one GPU at a time. For Transformers with tensor parallelism, please refer to [its documentation](https://huggingface.co/docs/transformers/v4.51.3/en/perf_infer_gpu_multi)."
+msgstr "您可能会发现使用 Transformers 进行分布式推理的速度不如预期。Transformers 使用 `device_map=\"auto\"` 时并未应用张量并行 (Tensor Parallelism)，且一次仅使用一个 GPU。如需支持张量并行的 Transformers，请参阅[其文档](https://huggingface.co/docs/transformers/v4.51.3/en/perf_infer_gpu_multi)。"

docs/locales/zh_CN/LC_MESSAGES/quantization/awq.po

@@ -0,0 +1,107 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/quantization/awq.md:1 363514c3e24c4d2aa54832e85acf34ef
+msgid "AWQ"
+msgstr "AWQ"
+
+#: ../../Qwen/source/quantization/awq.md:4 36b5c0de1013499f9f1e41edf8fa28ca
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/quantization/awq.md:7 9d6a80a82b044628bc9c911785ac9160
+msgid "For quantized models, one of our recommendations is the usage of [AWQ](https://arxiv.org/abs/2306.00978) with [AutoAWQ](https://github.com/casper-hansen/AutoAWQ)."
+msgstr "对于量化模型，我们推荐使用 [AWQ](https://arxiv.org/abs/2306.00978) 结合 [AutoAWQ](https://github.com/casper-hansen/AutoAWQ) "
+
+#: ../../Qwen/source/quantization/awq.md:9 139542ed4b414cfb834b3fd81ea88d51
+msgid "**AWQ** refers to Activation-aware Weight Quantization, a hardware-friendly approach for LLM low-bit weight-only quantization."
+msgstr "**AWQ**即激活值感知的权重量化(Activation-aware Weight Quantization)，是一种针对LLM的低比特权重量化的硬件友好方法。"
+
+#: ../../Qwen/source/quantization/awq.md:11 9a2959bb9f984e36a299bc40abca9402
+msgid "**AutoAWQ** is an easy-to-use Python library for 4-bit quantized models.  AutoAWQ speeds up models by 3x and reduces memory requirements by 3x compared to FP16.  AutoAWQ implements the Activation-aware Weight Quantization (AWQ) algorithm for quantizing LLMs."
+msgstr "**AutoAWQ**是一个易于使用的工具包，用于4比特量化模型。相较于FP16，AutoAWQ能够将模型的运行速度提升3倍，并将内存需求降低至原来的三分之一。AutoAWQ实现了AWQ算法，可用于LLM的量化处理。"
+
+#: ../../Qwen/source/quantization/awq.md:15 4f9fcd93d1f44b48869224c0f4e8b76a
+msgid "In this document, we show you how to use the quantized model with Hugging Face `transformers` and also how to quantize your own model."
+msgstr "在本文档中，我们将向您展示如何在Hugging Face `transformers`框架下使用量化模型，以及如何对您自己的模型进行量化"
+
+#: ../../Qwen/source/quantization/awq.md:17 870ebc162f3749b48fe454df85aaaf4b
+msgid "Usage of AWQ Models with Hugging Face transformers"
+msgstr "在Hugging Face transformers中使用AWQ量化模型"
+
+#: ../../Qwen/source/quantization/awq.md:19 cc7bd785c7ac45a4980fbda683699e43
+msgid "Now, `transformers` has officially supported AutoAWQ, which means that you can directly use the quantized model with `transformers`.  The following is a very simple code snippet showing how to run `Qwen2.5-7B-Instruct-AWQ` with the quantized model:"
+msgstr "现在，`transformers`已经正式支持AutoAWQ，这意味着您可以直接在`transformers`中使用AWQ量化模型。以下是一个非常简单的代码片段，展示如何运行量化模型 `Qwen2.5-7B-Instruct-AWQ` ："
+
+#: ../../Qwen/source/quantization/awq.md:56 47826d51abf54ad8a89ef9b91127a700
+msgid "Usage of AWQ  Models with vLLM"
+msgstr "在vLLM中使用AWQ量化模型"
+
+#: ../../Qwen/source/quantization/awq.md:58 b7235ae8f8344dd4a3d2029bbe7a40fc
+msgid "vLLM has supported AWQ, which means that you can directly use our provided AWQ models or those quantized with `AutoAWQ` with vLLM. We recommend using the latest version of vLLM (`vllm>=0.6.1`) which brings performance improvements to AWQ models; otherwise, the performance might not be well-optimized."
+msgstr "vLLM已支持AWQ，您可以直接使用我们提供的AWQ量化模型或使用`AutoAWQ`量化的模型。我们建议使用最新版的vLLM (`vllm>=0.6.1`)，新版为AWQ量化模型提升了效率提；不然推理效率可能并为被良好优化（即效率可能较非量化模型低）。"
+
+#: ../../Qwen/source/quantization/awq.md:61 940ce8fdb5da442b99af2bc1739911c6
+msgid "Actually, the usage is the same with the basic usage of vLLM.  We provide a simple example of how to launch OpenAI-API compatible API with vLLM and `Qwen2.5-7B-Instruct-AWQ`:"
+msgstr "实际上，使用AWQ模型与vLLM的基本用法相同。我们提供了一个简单的示例，展示了如何通过vLLM启动与OpenAI API兼容的接口，并使用 `Qwen2.5-7B-Instruct-AWQ` 模型："
+
+#: ../../Qwen/source/quantization/awq.md:64 2d249915352049a6a8d5a06e1f4682ee
+msgid "Run the following in a shell to start an OpenAI-compatible API service:"
+msgstr "在终端中运行以下命令以开启OpenAI兼容API："
+
+#: ../../Qwen/source/quantization/awq.md:70 be7bfbb81698429cbfcbcd24d062fc08
+msgid "Then, you can call the API as"
+msgstr "随后，您可以这样调���API："
+
+#: ../../Qwen/source/quantization/awq.md:86 0dff7d5c7b044548a82e0ba68a043d80
+msgid "or you can use the API client with the `openai` Python package as shown below:"
+msgstr "或者你可以按照下面所示的方式，使用 `openai` Python包中的API客户端："
+
+#: ../../Qwen/source/quantization/awq.md:115 65f4d60502ee486382e9bda9a5a826bb
+msgid "Quantize Your Own Model with AutoAWQ"
+msgstr "使用AutoAWQ量化你的模型"
+
+#: ../../Qwen/source/quantization/awq.md:117 c7c42af91c1a419194d65200bcfa2f26
+#, fuzzy
+msgid "If you want to quantize your own model to AWQ quantized models, we advise you to use AutoAWQ."
+msgstr "如果您希望将自定义模型量化为AWQ量化模型，我们建议您使用AutoAWQ。推荐通过安装源代码来获取并安装该工具包的最新版本："
+
+#: ../../Qwen/source/quantization/awq.md:123 232e94883d044030b2193392788b9314
+msgid "Suppose you have finetuned a model based on `Qwen2.5-7B`, which is named `Qwen2.5-7B-finetuned`, with your own dataset, e.g., Alpaca.  To build your own AWQ quantized model, you need to use the training data for calibration.  Below, we provide a simple demonstration for you to run:"
+msgstr "假设你已经基于 `Qwen2.5-7B` 模型进行了微调，并将其命名为 `Qwen2.5-7B-finetuned` ，且使用的是你自己的数据集，比如Alpaca。若要构建你自己的AWQ量化模型，你需要使用训练数据进行校准。以下，我们将为你提供一个简单的演示示例以便运行："
+
+#: ../../Qwen/source/quantization/awq.md:141 5162195f32ee4ecba229aa137da1aba4
+msgid "Then you need to prepare your data for calibration.  What you need to do is just put samples into a list, each of which is a text.  As we directly use our finetuning data for calibration, we first format it with ChatML template.  For example,"
+msgstr "接下来，您需要准备数据以进行校准。您需要做的就是将样本放入一个列表中，其中每个样本都是一段文本。由于我们直接使用微调数据来进行校准，所以我们首先使用ChatML模板对其进行格式化。例如："
+
+#: ../../Qwen/source/quantization/awq.md:153 0d4736e90e0242a8be15533de3aab6ff
+msgid "where each `msg` is a typical chat message as shown below:"
+msgstr "其中每个 `msg` 是一个典型的聊天消息，如下所示："
+
+#: ../../Qwen/source/quantization/awq.md:163 79d86630600945ac85dbe13d07987016
+msgid "Then just run the calibration process by one line of code:"
+msgstr "然后只需通过一行代码运行校准过程："
+
+#: ../../Qwen/source/quantization/awq.md:169 1ae219a50508465b98e3b3398e631681
+msgid "Finally, save the quantized model:"
+msgstr "最后，保存量化模型："
+
+#: ../../Qwen/source/quantization/awq.md:176 58316c1a4172418aba9f37925963e17f
+msgid "Then you can obtain your own AWQ quantized model for deployment.  Enjoy!"
+msgstr "然后你就可以得到一个可以用于部署的AWQ量化模型。玩得开心！"
+

docs/locales/zh_CN/LC_MESSAGES/quantization/gptq.po

@@ -0,0 +1,229 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-28 19:42+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../Qwen/source/quantization/gptq.md:1 c90397f810fb44a0abba8dd02f998f1c
+msgid "GPTQ"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:4 b79afc46b0f9474fb0c83751625aefc5
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../Qwen/source/quantization/gptq.md:7 898494af2a944193880f27e2f90db4f4
+msgid "[GPTQ](https://arxiv.org/abs/2210.17323) is a quantization method for GPT-like LLMs, which uses one-shot weight quantization based on approximate second-order information. In this document, we show you how to use the quantized model with Hugging Face `transformers` and also how to quantize your own model with [AutoGPTQ](https://github.com/AutoGPTQ/AutoGPTQ)."
+msgstr "[GPTQ](https://arxiv.org/abs/2210.17323)是一种针对类GPT大型语言模型的量化方法，它基于近似二阶信息进行一次性权重量化。在本文档中，我们将向您展示如何使用 `transformers` 库加载并应用量化后的模型，同时也会指导您如何通过[AutoGPTQ](https://github.com/AutoGPTQ/AutoGPTQ)来对您自己的模型进行量化处理。"
+
+#: ../../Qwen/source/quantization/gptq.md:10 11b82020735d4828a4182cefbf98aeb1
+msgid "Usage of GPTQ Models with Hugging Face transformers"
+msgstr "在Hugging Face transformers中使用GPTQ模型"
+
+#: ../../Qwen/source/quantization/gptq.md:14 2e9481d850954772949dd33897e0b06b
+msgid "To use the official Qwen2.5 GPTQ models with `transformers`, please ensure that `optimum>=1.20.0` and compatible versions of `transformers` and `auto_gptq` are installed."
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:16 fe6662a312184d40b07d957f4c0888cc
+msgid "You can do that by"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:22 9f0ad8e2a26145cf8bd9d60305566771
+msgid "Now, `transformers` has officially supported AutoGPTQ, which means that you can directly use the quantized model with `transformers`.  For each size of Qwen2.5, we provide both Int4 and Int8 GPTQ quantized models. The following is a very simple code snippet showing how to run `Qwen2.5-7B-Instruct-GPTQ-Int4`:"
+msgstr "现在，`transformers` 正式支持了AutoGPTQ，这意味着您能够直接在`transformers`中使用量化后的模型。以下是一个非常简单的代码片段示例，展示如何运行  `Qwen2.5-7B-Instruct-GPTQ-Int4` （请注意，对于每种大小的Qwen2.5模型，我们都提供了Int4和Int8两种量化版本）："
+
+#: ../../Qwen/source/quantization/gptq.md:60 855686b8990f403bba151d8498947f23
+msgid "Usage of GPTQ Models with vLLM"
+msgstr "在vLLM中使用GPTQ模型"
+
+#: ../../Qwen/source/quantization/gptq.md:62 ad572c30a0904598b3cbeba7c38a607a
+msgid "vLLM has supported GPTQ, which means that you can directly use our provided GPTQ models or those trained with `AutoGPTQ` with vLLM. If possible, it will automatically use the GPTQ Marlin kernel, which is more efficient."
+msgstr "vLLM已支持GPTQ，您可以直接使用我们提供的GPTQ量化模型或使用`AutoGPTQ`量化的模型。我们建议使用最新版的vLLM。如有可能，其会自动使用效率更好的GPTQ Marlin实现。"
+
+#: ../../Qwen/source/quantization/gptq.md:65 09050876d2c04aee9b619d28d4f5589c
+msgid "Actually, the usage is the same with the basic usage of vLLM.  We provide a simple example of how to launch OpenAI-API compatible API with vLLM and `Qwen2.5-7B-Instruct-GPTQ-Int4`:"
+msgstr "实际上，使用GPTQ模型与vLLM的基本用法相同。我们提供了一个简单的示例，展示了如何通过vLLM启动与OpenAI API兼容的接口，并使用 `Qwen2.5-7B-Instruct-GPTQ-Int4` 模型："
+
+#: ../../Qwen/source/quantization/gptq.md:68 a31dd879cc444b5da8d16fb1705585a6
+msgid "Run the following in a shell to start an OpenAI-compatible API service:"
+msgstr "在终端中运行以下命令以开启OpenAI兼容API："
+
+#: ../../Qwen/source/quantization/gptq.md:74 9dfb41e03089473792928b05b1225de4
+msgid "Then, you can call the API as"
+msgstr "随后，您可以这样调用API："
+
+#: ../../Qwen/source/quantization/gptq.md:90 6b440bebe0d84118bb63ed9a7c169ab5
+msgid "or you can use the API client with the `openai` Python package as shown below:"
+msgstr "或者你可以按照下面所示的方式，使用 `openai` Python包中的API客户端："
+
+#: ../../Qwen/source/quantization/gptq.md:119 7ffaa1ca8b4740b98dc3f804348da523
+msgid "Quantize Your Own Model with AutoGPTQ"
+msgstr "使用AutoGPTQ量化你的模型"
+
+#: ../../Qwen/source/quantization/gptq.md:121 40bd0b11507c4f06be5a5918d0dc3bdb
+msgid "If you want to quantize your own model to GPTQ quantized models, we advise you to use AutoGPTQ.  It is suggested installing the latest version of the package by installing from source code:"
+msgstr "如果你想将自定义模型量化为GPTQ量化模型，我们建议你使用AutoGPTQ工具。推荐通过安装源代码的方式获取并安装最新版本的该软件包。"
+
+#: ../../Qwen/source/quantization/gptq.md:130 d6ebb03d51bf4e0686ae17ce3f0a34db
+msgid "Suppose you have finetuned a model based on `Qwen2.5-7B`, which is named `Qwen2.5-7B-finetuned`, with your own dataset, e.g., Alpaca.  To build your own GPTQ quantized model, you need to use the training data for calibration.  Below, we provide a simple demonstration for you to run:"
+msgstr "假设你已经基于 `Qwen2.5-7B` 模型进行了微调，并将该微调后的模型命名为 `Qwen2.5-7B-finetuned` ，且使用的是自己的数据集，比如Alpaca。要构建你自己的GPTQ量化模型，你需要使用训练数据进行校准。以下是一个简单的演示示例，供你参考运行："
+
+#: ../../Qwen/source/quantization/gptq.md:161 9c1b27cc38764332891a8a13175663fc
+msgid "However, if you would like to load the model on multiple GPUs, you need to use `max_memory` instead of `device_map`. Here is an example:"
+msgstr "但是，如果你想使用多GPU来读取模型，你需要使用 `max_memory` 而不是 `device_map`。下面是一段示例代码："
+
+#: ../../Qwen/source/quantization/gptq.md:172 c2a9a50734854c19acf3e623597aee80
+msgid "Then you need to prepare your data for calibration.  What you need to do is just put samples into a list, each of which is a text.  As we directly use our finetuning data for calibration, we first format it with ChatML template.  For example,"
+msgstr "接下来，你需要准备数据进行校准。你需要做的是将样本放入一个列表中，其中每个样本都是一段文本。由于我们直接使用微调数据进行校准，所以我们首先使用ChatML模板对它进行格式化处理。例如："
+
+#: ../../Qwen/source/quantization/gptq.md:188 7621f73d34d04dd791d2eda03edb0d06
+msgid "where each `msg` is a typical chat message as shown below:"
+msgstr "其中每个 `msg` 是一个典型的聊天消息，如下所示："
+
+#: ../../Qwen/source/quantization/gptq.md:198 293efa14ece74a0aa9cbf32ef21e6bcd
+msgid "Then just run the calibration process by one line of code:"
+msgstr "然后只需通过一行代码运行校准过程："
+
+#: ../../Qwen/source/quantization/gptq.md:209 919d7a77cc4a4ef084ee8e2240ff1797
+msgid "Finally, save the quantized model:"
+msgstr "最后，保存量化模型："
+
+#: ../../Qwen/source/quantization/gptq.md:216 b353bdf12d6148fdb0a77662f795ae7e
+msgid "It is unfortunate that the `save_quantized` method does not support sharding.  For sharding, you need to load the model and use `save_pretrained` from transformers to save and shard the model. Except for this, everything is so simple.  Enjoy!"
+msgstr "很遗憾， `save_quantized` 方法不支持模型分片。若要实现模型分片，您需要先加载模型，然后使用来自 `transformers` 库的 `save_pretrained` 方法来保存并分片模型。除此之外，一切操作都非常简单。祝您使用愉快！"
+
+#: ../../Qwen/source/quantization/gptq.md:222 caea6f76804e40daa394ae2e2d52a6ce
+msgid "Known Issues"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:224 07df69bd48d4445887b5c1fa09f2f0fb
+msgid "Qwen2.5-72B-Instruct-GPTQ-Int4 cannot stop generation properly"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:226
+#: ../../Qwen/source/quantization/gptq.md:235 a4f1c7b0cb5d49f2929ba5d1246e885d
+#: d2dbf88d06974152943e6ec405419390
+msgid "Model"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:226 cb9c0be91ecc46c3b6ecfa97a0a37dd7
+msgid "Qwen2.5-72B-Instruct-GPTQ-Int4"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:227
+#: ../../Qwen/source/quantization/gptq.md:236 c1fe04754a0642fa82ed425d6abaa487
+#: f3ff85cbbc47459fb36b5ad0e38b4a1b
+msgid "Framework"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:227 8a5a4fe9d7634cb1ac65025565c3593a
+#, fuzzy
+msgid "vLLM, AutoGPTQ (including Hugging Face transformers)"
+msgstr "在Hugging Face transformers中使用GPTQ模型"
+
+#: ../../Qwen/source/quantization/gptq.md:228
+#: ../../Qwen/source/quantization/gptq.md:237 320d56294cc4490f8b30ac523388bc44
+#: c04326d003f949a7b2b63c6c6cb20ac3
+msgid "Description"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:228 22f80d0679dc426dbbfb21b90b993a27
+msgid "Generation cannot stop properly. Continual generation after where it should stop, then repeated texts, either single character, a phrase, or paragraphs, are generated."
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:229
+#: ../../Qwen/source/quantization/gptq.md:238 255a7a8ac98b4d2da51f79f207be5901
+#: 673d23bf488840a2a32a18cd657f334f
+msgid "Workaround"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:229 c2171874ed804ffb826ac686128d7bff
+msgid "The following workaround could be considered"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:230 a59d6759991640609371bf7afd81e0b8
+msgid "Using the original model in 16-bit floating point"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:231 97134ed43ee3414199928d755c24544e
+msgid "Using the AWQ variants or llama.cpp-based models for reduced chances of abnormal generation"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:233 7c30819dea6c4cfb8eee98d0dd217bf9
+msgid "Qwen2.5-32B-Instruct-GPTQ-Int4 broken with vLLM on multiple GPUs"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:235 a4a641abd99a47049c1fd172e9cfa2be
+msgid "Qwen2.5-32B-Instruct-GPTQ-Int4"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:236 70216327dda349cabf03412f5fbe3114
+msgid "vLLM"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:237 8edf21882ff24358b736c73477cfba9d
+msgid "Deployment on multiple GPUs and only garbled text like `!!!!!!!!!!!!!!!!!!` could be generated."
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:238 10d9d8b3d8e74afea5ccd79bc698fb7c
+msgid "Each of the following workaround could be considered"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:239 33d1632f26f9423c847d06af7a5d107d
+msgid "Using the AWQ or GPTQ-Int8 variants"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:240 b27f1f32637349d09b8c74a2041a4d9b
+msgid "Using a single GPU"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:241 fc27883584a04682b9e28b2ccf51dc0e
+msgid "Using Hugging Face `transformers` if latency and throughput are not major concerns"
+msgstr ""
+
+#: ../../Qwen/source/quantization/gptq.md:244 5664e5bd63c845d49e8cfa75e789dfa3
+msgid "Troubleshooting"
+msgstr "问题排查"
+
+#: ../../Qwen/source/quantization/gptq.md 06f2358881134920ab43f4256ad6300e
+msgid "With `transformers` and `auto_gptq`, the logs suggest `CUDA extension not installed.` and the inference is slow."
+msgstr "在使用 `transformers` 和 `auto_gptq` 时，日志提示 `CUDA extension not installed.` 并且推理速度缓慢。"
+
+#: ../../Qwen/source/quantization/gptq.md:248 2d57d681b2d74c27b60523fa86676b6f
+msgid "`auto_gptq` fails to find a fused CUDA kernel compatible with your environment and falls back to a plain implementation. Follow its [installation guide](https://github.com/AutoGPTQ/AutoGPTQ/blob/main/docs/INSTALLATION.md) to install a pre-built wheel or try installing `auto_gptq` from source."
+msgstr "`auto_gptq` 未能找到与您的环境兼容的融合CUDA算子，因此退回到基础实现。请遵循其 [安装指南](https://github.com/AutoGPTQ/AutoGPTQ/blob/main/docs/INSTALLATION.md) 来安装预构建的 wheel 或尝试从源代码安装 `auto_gptq` 。"
+
+#: ../../Qwen/source/quantization/gptq.md 95b57d1a962c4dc7aa02a69a403e2376
+msgid "Self-quantized Qwen2.5-72B-Instruct-GPTQ with `vllm`, `ValueError: ... must be divisible by ...` is raised. The intermediate size of the self-quantized model is different from the official Qwen2.5-72B-Instruct-GPTQ models."
+msgstr "`vllm` 使用自行量化的 Qwen2.5-72B-Instruct-GPTQ 时，会引发 `ValueError: ... must be divisible by ...` 错误。自量化的模型的 intermediate size 与官方的 Qwen2.5-72B-Instruct-GPTQ 模型不同。"
+
+#: ../../Qwen/source/quantization/gptq.md:255 ecd9b51a549045949ff18fdb6226ddc8
+#, python-brace-format
+msgid "After quantization the size of the quantized weights are divided by the group size, which is typically 128. The intermediate size for the FFN blocks in Qwen2.5-72B is 29568. Unfortunately, {math}`29568 \\div 128 = 231`. Since the number of attention heads and the dimensions of the weights must be divisible by the tensor parallel size, it means you can only run the quantized model with `tensor_parallel_size=1`, i.e., one GPU card."
+msgstr "量化后，量化权重的大小将被 group size（通常为128）整除。Qwen2-72B 中FFN块的中间大小为29568。不幸的是， {math}`29568 \\div 128 = 231` 。由于注意力头的数量和权重的维度必须能够被张量并行大小整除，这意味着你只能使用 `tensor_parallel_size=1` ，即一张 GPU 卡，来运行量化的模型。"
+
+#: ../../Qwen/source/quantization/gptq.md:260 8b1c5e3934654679a2d85e3287cf9309
+#, python-brace-format
+msgid "A workaround is to make the intermediate size divisible by {math}`128 \\times 8 = 1024`. To achieve that, the weights should be padded with zeros. While it is mathematically equivalent before and after zero-padding the weights, the results may be slightly different in reality."
+msgstr "一个解决方案是使中间大小能够被 {math}`128 \\times 8 = 1024` 整除。为了达到这一目的，应该使用零值对权重进行填充。虽然在数学上，在对权重进行零填充前后是等价的，但在现实中结果可能会略有不同。"
+
+#: ../../Qwen/source/quantization/gptq.md:264 ae904f7ab91340c4a6831aef4de643ba
+msgid "Try the following:"
+msgstr "尝试以下方法："
+
+#: ../../Qwen/source/quantization/gptq.md:297 4cf8c516a2324e618d25333c84be9e6b
+msgid "This will save the padded checkpoint to the specified directory. Then, copy other files from the original checkpoint to the new directory and modify the `intermediate_size` in `config.json` to `29696`. Finally, you can quantize the saved model checkpoint."
+msgstr "这将会把填充后的检查点保存到指定的目录。然后，你需要从原始检查点复制其他文件到新目录，并将 `config.json` 中的 `intermediate_size` 修改为 `29696` 。最后，你可以量化保存的模型检查点。"
+

docs/locales/zh_CN/LC_MESSAGES/quantization/llama.cpp.po

@@ -0,0 +1,183 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-05-07 19:51+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/quantization/llama.cpp.md:1 91e2a69dab7145e39b9e203302a2639e
+msgid "llama.cpp"
+msgstr ""
+
+#: ../../source/quantization/llama.cpp.md:3 7ae5403049d44c0ca2396985312e1a36
+msgid "Quantization is a major topic for local inference of LLMs, as it reduces the memory footprint. Undoubtably, llama.cpp natively supports LLM quantization and of course, with flexibility as always."
+msgstr "量化(Quantization)是本地运行大规模语言模型的主要议题，因为它能减少内存占用。毫无疑问，llama.cpp原生支持大规模语言模型的量化，并且一如既往地保持了灵活性。"
+
+#: ../../source/quantization/llama.cpp.md:6 ae64a4f0deb944d99dc9db527fb13770
+msgid "At high-level, all quantization supported by llama.cpp is weight quantization:  Model parameters are quantized into lower bits, and in inference, they are dequantized and used in computation."
+msgstr "在高层次上，llama.cpp所支持的所有量化都是权重量化(weight quantization)：模型参数被量化为低位(bit)数，在推理过程中，它们会被反量化(dequantize)并用于计算。"
+
+#: ../../source/quantization/llama.cpp.md:9 384848aad7cb4457a6b39d80487ccfc4
+msgid "In addition, you can mix different quantization data types in a single quantized model, e.g., you can quantize the embedding weights using a quantization data type and other weights using a different one. With an adequate mixture of quantization types, much lower quantization error can be attained with just a slight increase of bit-per-weight. The example program `llama-quantize` supports many quantization presets, such as Q4_K_M and Q8_0."
+msgstr "此外，你可以在单一的量化模型中混合使用不同的量化数据类型，例如，你可以使用一种量化数据类型量化嵌入权重(embedding)，而使用另一种量化其他权重。通过适当的量化类型组合，只需略微增加bpw （bit-per-weight, 位权比），就能达到更低的量化误差。示例程序`llama-quantize`支持许多量化预设，如Q4_K_M和Q8_0。"
+
+#: ../../source/quantization/llama.cpp.md:13 0d6c25bebbf94dc8b1c0e9bec5788043
+msgid "If you find the quantization errors still more than expected, you can bring your own scales, e.g., as computed by AWQ, or use calibration data to compute an importance matrix using `llama-imatrix`, which can then be used during quantization to enhance the quality of the quantized models."
+msgstr "如果你发现量化误差仍然超出预期，你可以引入自己的量化尺度，例如由AWQ计算的，或者使用校准数据用`llama-imatrix`来计算一个“重要性矩阵”(importance matrix)，然后在量化过程中使用以提高量化模型的质量。"
+
+#: ../../source/quantization/llama.cpp.md:15 1543df272fe5426e94899b16cc1cd36e
+#, python-brace-format
+msgid "In this document, we demonstrate the common way to quantize your model and evaluate the performance of the quantized model. We will assume you have the example programs from llama.cpp at your hand. If you don't, check our guide [here](../run_locally/llama.cpp.html#getting-the-program){.external}."
+msgstr "在本文档中，我们将展示量化和评估量化模型性能的常见方法。我们会假设你手头有llama.cpp的示例程序。如果没有，请查看我们的[指南](../run_locally/llama.cpp.html#getting-the-program){.external}。"
+
+#: ../../source/quantization/llama.cpp.md:19 9245fc77ed6048e482ab7a046f8eb8cf
+msgid "Getting the GGUF"
+msgstr "获取GGUF"
+
+#: ../../source/quantization/llama.cpp.md:21 05e869b2fa3e459f8b640a59b88470d5
+msgid "Now, suppose you would like to quantize `Qwen3-8B`.  You need to first make a GGUF file as shown below:"
+msgstr "现在，假设你想量化`Qwen3-8B-Instruct`。你需要首先创建一个GGUF文件，如下所示："
+
+#: ../../source/quantization/llama.cpp.md:27 26b1f7e1a9004275a857c3be976c5e8b
+msgid "Since Qwen3 are trained using the bfloat16 precision, the following should keep most information on supported machines:"
+msgstr "由于 Qwen3 以 bfloat16 混合精度训练，以下方法在受支持的计算机上可保留完整参数信息："
+
+#: ../../source/quantization/llama.cpp.md:32 a2b26c45c99247f39ec8d90e92b7de07
+msgid "Sometimes, it may be better to use fp32 as the start point for quantization. In that case, use"
+msgstr "有时，可能最好将fp32作为量化的起点。在这种情况下，使用"
+
+#: ../../source/quantization/llama.cpp.md:38 0d6321f7482a499f80747d78f2d01033
+msgid "Quantizing the GGUF without Calibration"
+msgstr "无校准量化GGUF"
+
+#: ../../source/quantization/llama.cpp.md:40 807e22b6326346c99a29068b29aa2436
+msgid "For the simplest way, you can directly quantize the model to lower-bits based on your requirements.  An example of quantizing the model to 8 bits is shown below:"
+msgstr "最简单的方法是，你可以根据需求直接将模型量化到低位数。下面是一个将模型量化到8 bit的例子："
+
+#: ../../source/quantization/llama.cpp.md:46 66cadafa9bc84365a53f870e8f0548cb
+msgid "`Q8_0` is a code for a quantization preset. You can find all the presets in [the source code of `llama-quantize`](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/quantize.cpp). Look for the variable `QUANT_OPTIONS`. Common ones used for 8B models include `Q8_0`, `Q5_K_M`, and `Q4_K_M`.  The letter case doesn't matter, so `q8_0` or `q4_K_m` are perfectly fine."
+msgstr "`Q8_0`是一个量化预设的代号。你可以在[`llama-quantize`的源代码](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/quantize.cpp)中找到所有预设。寻找变量`QUANT_OPTIONS`。对于 8B 模型常用的包括`Q8_0`、`Q5_K_M`和`Q4_K_M`。字母大小写不重要，所以`q8_0`或`q4_K_m`都是可以接受的。"
+
+#: ../../source/quantization/llama.cpp.md:52 d4cce644d247439ebf58c01f1916aabe
+msgid "Now you can use the GGUF file of the quantized model with applications based on llama.cpp. Very simple indeed."
+msgstr "现在，你可以使用基于llama.cpp的应用程序中的量化模型的GGUF文件。确实很简单。"
+
+#: ../../source/quantization/llama.cpp.md:55 292de0cf1cfa48b1859c274185a456ac
+msgid "However, the accuracy of the quantized model could be lower than expected occasionally, especially for lower-bit quantization. The program may even prevent you from doing that."
+msgstr "然而，量化模型的准确性偶尔可能低于预期，特别是对于低位数量化。程序甚至可能阻止你这样做。"
+
+#: ../../source/quantization/llama.cpp.md:58 fc9efc3991b04d1192f26ea93635aaef
+msgid "There are several ways to improve quality of quantized models. A common way is to use a calibration dataset in the target domain to identify the weights that really matter and quantize the model in a way that those weights have lower quantization errors, as introduced in the next two methods."
+msgstr "有几种方法可以提高量化模型的质量。一种常见的方法是在目标域中使用校准数据集来识别真正重要的权重，并以这些权重具有较低量化误差的方式量化模型，如下两种方法中将介绍。"
+
+#: ../../source/quantization/llama.cpp.md:62 a1467369a0c04c0da45d555e43e42635
+msgid "Quantizing the GGUF with AWQ Scale"
+msgstr "使用AWQ尺度量化GGUF"
+
+#: ../../source/quantization/llama.cpp.md:65 2cc212d09e8d4e8b912c24dd2a27f35a
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../source/quantization/llama.cpp.md:68 da955f0aaa564ec4b5584fe4fb1fbda0
+msgid "To improve the quality of your quantized models, one possible solution is to apply the AWQ scale, following [this script](https://github.com/casper-hansen/AutoAWQ/blob/main/docs/examples.md#gguf-export). First, when you run `model.quantize()` with `autoawq`, remember to add `export_compatible=True` as shown below:"
+msgstr "为了提高量化模型的质量，一种可能的解决方案是应用AWQ尺度，遵循[这个脚本](https://github.com/casper-hansen/AutoAWQ/blob/main/docs/examples.md#gguf-export)。首先，当你使用`autoawq`运行`model.quantize()`时，记得添加`export_compatible=True`，如下所示："
+
+#: ../../source/quantization/llama.cpp.md:81 1be192c485db4fcd876568e9faacac4b
+msgid "The above code will not actually quantize the weights. Instead, it adjusts weights based on a dataset so that they are \"easier\" to quantize.[^AWQ]"
+msgstr "上述代码实际上不会量化权重。相反，它会根据数据集调整权重，使它们“更容易”量化。[^AWQ]"
+
+#: ../../source/quantization/llama.cpp.md:84 10aa1c71ed9d4553bab3d2bc5aba08e8
+msgid "Then, when you run `convert-hf-to-gguf.py`, remember to replace the model path with the path to the new model:"
+msgstr "然后，当你运行`convert-hf-to-gguf.py`时，记得将模型路径替换为新模型的路径："
+
+#: ../../source/quantization/llama.cpp.md:89 99b87ba88b84422983b60584515fc924
+msgid "Finally, you can quantize the model as in the last example:"
+msgstr "最后，你可以像最后一个例子那样量化模型："
+
+#: ../../source/quantization/llama.cpp.md:94 8c2b985fccf54302b8175a50f34304e8
+msgid "In this way, it should be possible to achieve similar quality with lower bit-per-weight."
+msgstr "这样，应该有可能以更低的bpw实现相似的质量。"
+
+#: ../../source/quantization/llama.cpp.md:100 b35ae6045d8045d6a4f6cfe0b8a86f5e
+msgid "Quantizing the GGUF with Importance Matrix"
+msgstr "使用重要性矩阵量化GGUF"
+
+#: ../../source/quantization/llama.cpp.md:102 2e5cafdf307d430d9e34e3bb2c60bbf2
+msgid "Another possible solution is to use the \"important matrix\"[^imatrix], following [this](https://github.com/ggml-org/llama.cpp/tree/master/tools/imatrix)."
+msgstr "另一个可能的解决方案是使用\"重要矩阵\"[^imatrix]，参照[这里](https://github.com/ggml-org/llama.cpp/tree/master/tools/imatrix)。"
+
+#: ../../source/quantization/llama.cpp.md:104 1aeee4c40d034cff890bc076983530e4
+msgid "First, you need to compute the importance matrix data of the weights of a model (`-m`) using a calibration dataset (`-f`):"
+msgstr "首先，你需要使用校准数据集（`-f`）计算模型权重的重要性矩阵数据（`-m`）："
+
+#: ../../source/quantization/llama.cpp.md:109 b679568784524852a1736d3be54ac50f
+msgid "The text is cut in chunks of length `--chunk` for computation. Preferably, the text should be representative of the target domain. The final results will be saved in a file named `Qwen3-8B-imatrix.dat` (`-o`), which can then be used:"
+msgstr "文本被切割成长度为`--chunk`的块进行计算。最好，文本应代表目标领域。最终结果将保存在名为`qwen3-8b-imatrix.dat`（`-o`）的文件中，然后可以使用："
+
+#: ../../source/quantization/llama.cpp.md:117 4f13b845d25a4beea4f072de70b95c32
+msgid "For lower-bit quantization mixtures for 1-bit or 2-bit, if you do not provide `--imatrix`, a helpful warning will be printed by `llama-quantize`."
+msgstr "对于1 bit或2 bit的低位数量化混合，如果你不提供`--imatrix`，`llama-quantize`将打印出有用的警告。"
+
+#: ../../source/quantization/llama.cpp.md:121 c3308e36443949e3be37bf1ceee2d56f
+msgid "Perplexity Evaluation"
+msgstr "困惑度(Perplexity)评估"
+
+#: ../../source/quantization/llama.cpp.md:123 5a84b0a3e7e647ed8f453baf9f9309c8
+msgid "`llama.cpp` provides an example program for us to calculate the perplexity, which evaluate how unlikely the given text is to the model. It should be mostly used for comparisons: the lower the perplexity, the better the model remembers the given text."
+msgstr "`llama.cpp`为我们提供了一个示例程序来计算困惑度，这评估了给定文本对模型而言的“不可能”程度。它主要用于比较：困惑度越低，模型对给定文本的记忆越好。"
+
+#: ../../source/quantization/llama.cpp.md:126 cf72d076477a42f497034e2f670c119d
+msgid "To do this, you need to prepare a dataset, say \"wiki test\"[^wiki].  You can download the dataset with:"
+msgstr "要做到这一点，你需要准备一个数据集，比如\"wiki测试集\"[^wiki]。你可以使用以下命令下载数据集："
+
+#: ../../source/quantization/llama.cpp.md:133 d16427f201af46c2bc8204d61b82f8b5
+msgid "Then you can run the test with the following command:"
+msgstr "然后你可以使用以下命令运行测试："
+
+#: ../../source/quantization/llama.cpp.md:137 56d6bd741ec64dee91a994c708620838
+msgid "Wait for some time and you will get the perplexity of the model. There are some numbers of different kinds of quantization mixture [here](https://github.com/ggml-org/llama.cpp/blob/master/tools/perplexity/README.md). It might be helpful to look at the difference and grab a sense of how that kind of quantization might perform."
+msgstr "稍等一段时间，你将得到模型的困惑度。[这里](https://github.com/ggml-org/llama.cpp/blob/master/tools/perplexity/README.md)提供了不同类型的量化模型的数值。观察差异可能有助于理解不同量化方式的潜在表现。"
+
+#: ../../source/quantization/llama.cpp.md:144 589fad71ce69495fa259e51035baf046
+msgid "Finally"
+msgstr "结束语"
+
+#: ../../source/quantization/llama.cpp.md:146 2ac61288357b43a3b6932b226a785bb1
+msgid "In this guide, we demonstrate how to conduct quantization and evaluate the perplexity with llama.cpp. For more information, please visit the [llama.cpp GitHub repo](https://github.com/ggml-org/llama.cpp)."
+msgstr "在本指南中，我们展示了如何使用llama.cpp进行量化和评估困惑度。更多信息，请访问[llama.cpp GitHub仓库](https://github.com/ggml-org/llama.cpp)。"
+
+#: ../../source/quantization/llama.cpp.md:149 8cb576b8079e4dfeaca0ab06f7d9f4e4
+#, fuzzy
+msgid "We usually quantize the fp16 model to 4, 5, 6, and 8-bit models with different quantization mixtures, but sometimes a particular mixture just does not work, so we don't provide those in our Hugging Face Hub. However, others in the community may have success, so if you haven't found what you need in our repos, look around."
+msgstr "我们通常将fp16模型量化为4、5、6和8位模型，采用不同的量化混合，但有时特定的混合就是不起作用，所以我们不在HuggingFace Hub中提供这些。但是，社区中的其他人可能会成功，因此，如果你在我们的仓库中没有找到所需的内容，请四处看看。"
+
+#: ../../source/quantization/llama.cpp.md:152 1b2b1b45246c4539bc30b684b818676f
+msgid "Enjoy your freshly quantized models!"
+msgstr "享受你新鲜量化的模型吧！"
+
+#: ../../source/quantization/llama.cpp.md:96 5d42d043024a4425a3b4d2d846c6aa59
+msgid "If you are interested in what this means, refer to [the AWQ paper](https://arxiv.org/abs/2306.00978).     Basically, important weights (called salient weights in the paper) are identified based on activations across data examples.     The weights are scaled accordingly such that the salient weights are protected even after quantization."
+msgstr "如果你对这意味着什么感兴趣，请参阅[AWQ论文](https://arxiv.org/abs/2306.00978)。基本上，根据数据实例上的激活，识别出重要的权重（在论文中称为显著权重）。相应地缩放权重，以便即使在量化后也能保护显著权重。"
+
+#: ../../source/quantization/llama.cpp.md:119 8b25ee3804f24fa798a79299899ab860
+msgid "Here, the importance matrix keeps record of how weights affect the output: the weight should be important is a slight change in its value causes huge difference in the results, akin to the [GPTQ](https://arxiv.org/abs/2210.17323) algorithm."
+msgstr "在这里，重要性矩阵记录了权重如何影响输出：如果权重的微小变化导致结果的巨大差异，则该权重应该是重要的，类似于[GPTQ](https://arxiv.org/abs/2210.17323)算法。"
+
+#: ../../source/quantization/llama.cpp.md:141 1fd3ddb3e40a47ffb4cc5a2604918ad7
+msgid "It is not a good evaluation dataset for instruct models though, but it is very common and easily accessible.      You probably want to use a dataset similar to your target domain."
+msgstr "虽然它不是指导模型的良好评估数据集，但它非常常见且易于访问。你可能希望使用与目标领域相似的数据集。"
+

docs/locales/zh_CN/LC_MESSAGES/run_locally/llama.cpp.po

@@ -0,0 +1,671 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-29 16:34+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/run_locally/llama.cpp.md:1 982af2ecb7ee4933a0dc9541c000ff4d
+msgid "llama.cpp"
+msgstr "llama.cpp"
+
+#: ../../source/run_locally/llama.cpp.md c1891b9c45ff48f0b0b350eedc1164ab
+msgid "llama.cpp as a C++ library"
+msgstr "llama.cpp作为C++库"
+
+#: ../../source/run_locally/llama.cpp.md:6 e2ddc412959146498ce64b91c05c3ca6
+msgid "Before starting, let's first discuss what is llama.cpp and what you should expect, and why we say \"use\" llama.cpp, with \"use\" in quotes. llama.cpp is essentially a different ecosystem with a different design philosophy that targets light-weight footprint, minimal external dependency, multi-platform, and extensive, flexible hardware support:"
+msgstr "开始之前，让我们先谈谈什么是llama.cpp，您应该期待什么，以及为什么我们说带引号“使用”llama.cpp。本质上，llama.cpp是一个不同的生态系统，具有不同的设计理念，旨在实现轻量级、最小外部依赖、多平台以及广泛灵活的硬件支持："
+
+#: ../../source/run_locally/llama.cpp.md:8 70559daade4b447fa28ea689bef9e2b5
+msgid "Plain C/C++ implementation without external dependencies"
+msgstr "纯粹的C/C++实现，没有外部依赖"
+
+#: ../../source/run_locally/llama.cpp.md:9 d070ffe26c1f47eda51a08029b95f0f4
+msgid "Support a wide variety of hardware:"
+msgstr "支持广泛的硬件："
+
+#: ../../source/run_locally/llama.cpp.md:10 f27c8b0b95eb4635a458312e82b71ed7
+msgid "AVX, AVX2 and AVX512 support for x86_64 CPU"
+msgstr "x86_64 CPU的AVX、AVX2和AVX512支持"
+
+#: ../../source/run_locally/llama.cpp.md:11 c09f100de65641c98c17a8c9fa927766
+msgid "Apple Silicon via Metal and Accelerate (CPU and GPU)"
+msgstr "通过Metal和Accelerate支持Apple Silicon（CPU和GPU）"
+
+#: ../../source/run_locally/llama.cpp.md:12 b17e1127c1c74536bc9c61507832f7f6
+msgid "NVIDIA GPU (via CUDA), AMD GPU (via hipBLAS), Intel GPU (via SYCL), Ascend NPU (via CANN), and Moore Threads GPU (via MUSA)"
+msgstr "NVIDIA GPU（通过CUDA）、AMD GPU（通过hipBLAS）、Intel GPU（通过SYCL）、昇腾NPU（通过CANN）和摩尔线程GPU（通过MUSA）"
+
+#: ../../source/run_locally/llama.cpp.md:13 8743a89578bd45afa1a17448258be6d2
+msgid "Vulkan backend for GPU"
+msgstr "GPU的Vulkan后端"
+
+#: ../../source/run_locally/llama.cpp.md:14 89e6275312504236829fd6eb4f910217
+msgid "Various quantization schemes for faster inference and reduced memory footprint"
+msgstr "多种量化方案以加快推理速度并减少内存占用"
+
+#: ../../source/run_locally/llama.cpp.md:15 c120b7fcdb184ceb869abb70bac6a1ab
+msgid "CPU+GPU hybrid inference to partially accelerate models larger than the total VRAM capacity"
+msgstr "CPU+GPU混合推理，以加速超过总VRAM容量的模型"
+
+#: ../../source/run_locally/llama.cpp.md:17 bc4a92209a1d4a06bfc727b84be29090
+msgid "It's like the Python frameworks `torch`+`transformers` or `torch`+`vllm` but in C++. However, this difference is crucial:"
+msgstr "它就像 Python 框架 `torch`+`transformers` 或 `torch`+`vllm` 的组合，但用的是 C++。然而，这一差异至关重要："
+
+#: ../../source/run_locally/llama.cpp.md:19 a30d578f68aa43ae8479a0082cbd2d93
+msgid "Python is an interpreted language:  The code you write is executed line-by-line on-the-fly by an interpreter.  You can run the example code snippet or script with an interpreter or a natively interactive interpreter shell. In addition, Python is learner friendly, and even if you don't know much before, you can tweak the source code here and there."
+msgstr "Python 是一种解释型语言：编写的代码会被解释器逐行实时执行。你可以使用解释器或原生交互式解释器终端来运行示例代码片段或脚本。此外，Python 对学习者非常友好，即使你之前了解不多，也可能修改源代码。"
+
+#: ../../source/run_locally/llama.cpp.md:23 5140d7332d874816bbf9ee3ceea88e37
+msgid "C++ is a compiled language:  The source code you write needs to be compiled beforehand, and it is translated to machine code and an executable program by a compiler. The overhead from the language side is minimal.  You do have source code for example programs showcasing how to use the library.  But it is not very easy to modify the source code if you are not verse in C++ or C."
+msgstr "C++ 是一种编译型语言：你编写的源代码需要预先编译，由编译器将其转换为机器码和可执行程序，来自语言层面的开销微乎其微。llama.cpp也提供���示例程序的源代码，展示了如何使用该库。但是，如果你不精通 C++ 或 C 语言，修改源代码并不容易。"
+
+#: ../../source/run_locally/llama.cpp.md:29 33262bc591a844159f033b5fe36324dd
+msgid "To use llama.cpp means that you use the llama.cpp library in your own program, like writing the source code of [Ollama](https://ollama.com/), [LM Studio](https://lmstudio.ai/), [GPT4ALL](https://www.nomic.ai/gpt4all), [llamafile](https://llamafile.ai/) etc. But that's not what this guide is intended or could do. Instead, here we introduce how to use the `llama-cli` example program, in the hope that you know that llama.cpp does support Qwen2.5 models and how the ecosystem of llama.cpp generally works."
+msgstr "真正使用 llama.cpp 意味着在自己的程序中使用 llama.cpp 库，就像编写 [Ollama](https://ollama.com/)、[LM Studio](https://lmstudio.ai/)、[GPT4ALL](https://www.nomic.ai/gpt4all)、[llamafile](https://llamafile.ai/) 等的源代码。但这并不是本指南的目的或所能做的。相反，这里我们介绍如何使用 `llama-cli` 示例程序，希望你能了解到 llama.cpp 支持 Qwen2.5 模型以及 llama.cpp 生态系统的一般工作原理。"
+
+#: ../../source/run_locally/llama.cpp.md:34 ed26c043c56143bb87185ff669d6d8cf
+msgid "In this guide, we will show how to \"use\" [llama.cpp](https://github.com/ggml-org/llama.cpp) to run models on your local machine, in particular, the `llama-cli` and the `llama-server` example program, which comes with the library."
+msgstr "在这份指南中，我们将讨论如何“使用” [llama.cpp](https://github.com/ggml-org/llama.cpp) 在您的本地机器上运行模型，特别是随库提供的 `llama-cli` 和 `llama-server` 示例程序。"
+
+#: ../../source/run_locally/llama.cpp.md:36 f2e1113691cc4c18b6bd46bdf8ea09ac
+msgid "The main steps are:"
+msgstr "主要步骤如下："
+
+#: ../../source/run_locally/llama.cpp.md:37 8e663f68bd6b407a840c8e1748865021
+msgid "Get the programs"
+msgstr "获取程序"
+
+#: ../../source/run_locally/llama.cpp.md:38 26e13906aeca465bbf9a0f3f2333c955
+msgid "Get the Qwen3 models in GGUF[^GGUF] format"
+msgstr "获取 GGUF[^GGUF] 格式的 Qwen3 模型"
+
+#: ../../source/run_locally/llama.cpp.md:39 3e904b0aec454270b7eca787f0fd0371
+msgid "Run the program with the model"
+msgstr "使用模型运行程序"
+
+#: ../../source/run_locally/llama.cpp.md:42 c4288c0e92f049dd9445f2b004aad048
+msgid "llama.cpp supports Qwen3 and Qwen3MoE from version `b5092`."
+msgstr "llama.cpp 自版本 `b5092` 支持 Qwen3 和 Qwen3MoE 。"
+
+#: ../../source/run_locally/llama.cpp.md:45 1088c7e273504ee8b1ea5c88464f9460
+msgid "Getting the Program"
+msgstr "获取程序"
+
+#: ../../source/run_locally/llama.cpp.md:47 768fb32dd36442eb9d03612cee4f7e78
+msgid "You can get the programs in various ways.  For optimal efficiency, we recommend compiling the programs locally, so you get the CPU optimizations for free. However, if you don't have C++ compilers locally, you can also install using package managers or downloading pre-built binaries.  They could be less efficient but for non-production example use, they are fine."
+msgstr "你可以通过多种方式获得 llama.cpp 中的程序。为了达到最佳效率，我们建议你本地编译程序，这样可以零成本享受CPU优化。但是，如果你的本地环境没有C++编译器，也可以使用包管理器安装或者下载预编译的二进制文件。虽然它们可能效率较低，但对于非生产用途的例子来说，它们已经足够好用了。"
+
+#: ../../source/run_locally/llama.cpp.md 023a89efd9914b62a95a70abbabe4fe5
+msgid "Compile Locally"
+msgstr "本地编译"
+
+#: ../../source/run_locally/llama.cpp.md:56 154aaf9730724f7c8f8cd80b01ea5b41
+msgid "Here, we show the basic command to compile `llama-cli` locally on **macOS** or **Linux**. For Windows or GPU users, please refer to [the guide from llama.cpp](https://github.com/ggml-org/llama.cpp/blob/master/docs/build.md)."
+msgstr "这里，我们将展示在 **macOS** 或 **Linux** 上本地编译 `llama-cli` 的基本命令。对于 Windows 用户或 GPU 用户，请参考[llama.cpp的指南](https://github.com/ggml-org/llama.cpp/blob/master/docs/build.md)。"
+
+#: ../../source/run_locally/llama.cpp.md 5d61b0f1887b497599be5723e08602a5
+msgid "Installing Build Tools"
+msgstr "安装构建工具"
+
+#: ../../source/run_locally/llama.cpp.md:63 772ed9c6cdfc4e28b35e0c50c9bc1051
+msgid "To build locally, a C++ compiler and a build system tool are required.  To see if they have been installed already, type `cc --version` or `cmake --version` in a terminal window."
+msgstr "要进行本地构建，你需要一个C++编译器和一个构建系统工具。在终端窗口中输入`cc --version`或`cmake --version`，看看这些工具是否已经安装好了。"
+
+#: ../../source/run_locally/llama.cpp.md:65 f271663e625a439695399a11779cb03e
+msgid "If installed, the build configuration of the tool will be printed to the terminal, and you are good to go!"
+msgstr "如果已安装，工具的构建配置信息将被打印到终端，那么你就可以开始了！"
+
+#: ../../source/run_locally/llama.cpp.md:66 774a4a0edb1444cebdde08038581c294
+msgid "If errors are raised, you need to first install the related tools:"
+msgstr "如果出现错误，说明你需要先安装相关工具："
+
+#: ../../source/run_locally/llama.cpp.md:67 6e1c6860a47d49e9bcc625eb8b3be542
+msgid "On macOS, install with the command `xcode-select --install`"
+msgstr "在macOS上，使用命令`xcode-select --install`来安装。"
+
+#: ../../source/run_locally/llama.cpp.md:68 186197e49f2542f4837c442b1529d739
+msgid "On Ubuntu, install with the command `sudo apt install build-essential`.  For other Linux distributions, the command may vary; the essential packages needed for this guide are `gcc` and `cmake`."
+msgstr "在Ubuntu上，使用命令`sudo apt install build-essential`来安装。对于其他Linux发行版，命令可能会有所不同；本指南所需的基本包是`gcc`和`cmake`。"
+
+#: ../../source/run_locally/llama.cpp.md a3d68cbcf5834203bc8fd5892edbc7dc
+msgid "Compiling the Program"
+msgstr "编译程序"
+
+#: ../../source/run_locally/llama.cpp.md:75 1be0da28ab7f4d46bcde3311153d5f0b
+msgid "For the first step, clone the repo and enter the directory:"
+msgstr "第一步是克隆仓库并进入该目录："
+
+#: ../../source/run_locally/llama.cpp.md:81 3c38e7800b984d63906d139d915cad3e
+msgid "Then, build llama.cpp using CMake:"
+msgstr "随后，使用 CMake 执行 llama.cpp 构建："
+
+#: ../../source/run_locally/llama.cpp.md:87 584374ec3d74489180ad99dd99aceaea
+msgid "The first command will check the local environment and determine which backends and features should be included. The second command will actually build the programs."
+msgstr "第一条命令将检查本地环境并确定需要包含的推理后端与特性。第二条命令将实际构建程序文件。"
+
+#: ../../source/run_locally/llama.cpp.md:90 f728bdbb8e234fbaab608a956c31463e
+msgid "To shorten the time, you can also enable parallel compiling based on the CPU cores you have, for example:"
+msgstr "为了缩短时间，你还可以根据你的CPU核心数开启并行编译，例如："
+
+#: ../../source/run_locally/llama.cpp.md:94 7fc43a28aadf4ab7aef94979d350c3e4
+msgid "This will build the programs with 8 parallel compiling jobs."
+msgstr "这将以8个并行编译任务来构建程序。"
+
+#: ../../source/run_locally/llama.cpp.md:96 89a5aaa7baa6455e9662a8e5e8204fd0
+msgid "The built programs will be in `./build/bin/`."
+msgstr "结果将存于 `./build/bin/` 。"
+
+#: ../../source/run_locally/llama.cpp.md 8073a459b60f4c5a994f10a61c7b9655
+msgid "Package Managers"
+msgstr "软件包管理器"
+
+#: ../../source/run_locally/llama.cpp.md:101 6883e24e533a4e028ceda9ac23037cfe
+msgid "For **macOS** and **Linux** users, `llama-cli` and `llama-server` can be installed with package managers including Homebrew, Nix, and Flox."
+msgstr "对于**macOS**和**Linux**用户，`llama-cli` 和 `llama-server` 可以通过包括 Homebrew、Nix 和 Flox 在内的软件包管理器进行安装。"
+
+#: ../../source/run_locally/llama.cpp.md:103 d59800138ade43daaf35404b86c4c1e0
+msgid "Here, we show how to install `llama-cli` and `llama-server` with Homebrew.  For other package managers, please check the instructions [here](https://github.com/ggml-org/llama.cpp/blob/master/docs/install.md)."
+msgstr "在这里，我们展示如何使用 Homebrew 安装 `llama-cli` 和 `llama-server` 。对于其他软件包管理器的安装，请查阅[这里的指南](https://github.com/ggml-org/llama.cpp/blob/master/docs/install.md)。"
+
+#: ../../source/run_locally/llama.cpp.md:106 09a865816ad04e0cb739ff081f6a3c5e
+msgid "Installing with Homebrew is very simple:"
+msgstr "使用 Homebrew 安装非常简单："
+
+#: ../../source/run_locally/llama.cpp.md:108 ec9e701fec054699882486d33cc6759d
+msgid "Ensure that Homebrew is available on your operating system.  If you don't have Homebrew, you can install it as in [its website](https://brew.sh/)."
+msgstr "请确保您的操作系统上已安装有 Homebrew。如果没有，您可以按照[官网](https://brew.sh/)上的指导进行安装。"
+
+#: ../../source/run_locally/llama.cpp.md:111 6828ec93205945358c02caa71b30db14
+msgid "Second, you can install the pre-built binaries, `llama-cli` and `llama-server` included, with a single command:"
+msgstr "其次，您只需一条命令即可安装预先编译好的二进制文件，其中包括 `llama-cli` 和 `llama-server` ："
+
+#: ../../source/run_locally/llama.cpp.md:116 735fa54f0a68459eb0a66c4b4b14ef2e
+msgid "Note that the installed binaries might not be built with the optimal compile options for your hardware, which can lead to poor performance. They also don't support GPU on Linux systems."
+msgstr "请注意，安装的二进制文件可能并未针对您的硬件优化编译选项，这可能导致性能不佳。此外，在 Linux 系统上它们也不支持 GPU。"
+
+#: ../../source/run_locally/llama.cpp.md 6a7aa0679f0f4ff08378e7085b5d9ca5
+msgid "Binary Release"
+msgstr "二进制文件"
+
+#: ../../source/run_locally/llama.cpp.md:122 747170630f41428fb98cfb26c0b2cbb4
+msgid "You can also download pre-built binaries from [GitHub Releases](https://github.com/ggml-org/llama.cpp/releases). Please note that those pre-built binaries files are architecture-, backend-, and os-specific.  If you are not sure what those mean, you probably don't want to use them and running with incompatible versions will most likely fail or lead to poor performance."
+msgstr "您还可以从[GitHub Release](https://github.com/ggml-org/llama.cpp/releases)下载预构建的二进制文件。请注意，这些预构建的二进制文件是特定于架构、后端和操作系统的。如果您不确定这些意味着什么，可能您并不想使用它们。使用不兼容的版本很可能导致运行失败或性能不佳。"
+
+#: ../../source/run_locally/llama.cpp.md:126 4d9c79d4a17544f8a82733204568b9e5
+msgid "The file name is like `llama-<version>-bin-<os>-<feature>-<arch>.zip`."
+msgstr "文件名类似于`llama-<version>-bin-<os>-<feature>-<arch>.zip`。"
+
+#: ../../source/run_locally/llama.cpp.md:128 9128b08da0aa4389b67870a64e80326b
+msgid "There are three simple parts:"
+msgstr "分为三个简单部分："
+
+#: ../../source/run_locally/llama.cpp.md:129 4e94cb63609a4cfb84a44730f2e45ec1
+msgid "`<version>`: the version of llama.cpp. The latest is preferred, but as llama.cpp is updated and released frequently, the latest may contain bugs. If the latest version does not work, try the previous release until it works."
+msgstr "`<version>`：llama.cpp的版本。建议使用最新版本，但鉴于llama.cpp频繁更新和发布，最新版本可能包含bug。如果最新版本无法正常工作，请尝试之前的版本直到找到能正常工作的为止。"
+
+#: ../../source/run_locally/llama.cpp.md:130 da97ae4a462c4b29a68a16f99d52b5a6
+msgid "`<os>`: the operating system. `win` for Windows; `macos` for macOS; `linux` for Linux."
+msgstr "`<os>`：操作系统。`win`代表Windows；`macos`代表macOS；`linux`代表Linux。"
+
+#: ../../source/run_locally/llama.cpp.md:131 a181b5105d9b4a3190c8bb4fc78647c6
+msgid "`<arch>`: the system architecture. `x64` for `x86_64`, e.g., most Intel and AMD systems, including Intel Mac; `arm64` for `arm64`, e.g., Apple Silicon or Snapdragon-based systems."
+msgstr "`<arch>`：系统架构。`x64`对应`x86_64`，例如大多数Intel和AMD系统，包括Intel Mac；`arm64`对应`arm64`，例如Apple Silicon或基于Snapdragon的系统。"
+
+#: ../../source/run_locally/llama.cpp.md:133 cc2af4ec4e6f4d2fafbf3b022280097b
+msgid "The `<feature>` part is somewhat complicated for Windows:"
+msgstr "`<feature>`部分对于Windows来说有些复杂："
+
+#: ../../source/run_locally/llama.cpp.md:134 fd08c220cf414c48a6a776c69170ffa1
+msgid "Running on CPU"
+msgstr "在CPU上运行"
+
+#: ../../source/run_locally/llama.cpp.md:135 2e0d36b4509e4a229ecf594f759092e0
+msgid "x86_64 CPUs: We suggest try the `avx2` one first."
+msgstr "x86_64 CPU：我们建议首先尝试`avx2`。"
+
+#: ../../source/run_locally/llama.cpp.md:136 57dbb29cef6f4962b76760fac98def5c
+msgid "`noavx`: No hardware acceleration at all."
+msgstr "`noavx`：完全无AVX硬件加速。"
+
+#: ../../source/run_locally/llama.cpp.md:137 a2ecf0f937994dbba85e1ca6c8423ea3
+msgid "`avx2`, `avx`, `avx512`: SIMD-based acceleration. Most modern desktop CPUs should support avx2, and some CPUs support `avx512`."
+msgstr "`avx2`，`avx`，`avx512`：基于SIMD的加速。大多数现代桌面CPU应该支持AVX2，部分CPU支持AVX512。"
+
+#: ../../source/run_locally/llama.cpp.md:138 85a4552c023a4ec0967e5f3127f3bf1f
+msgid "`openblas`: Relying on OpenBLAS for acceleration for prompt processing but not generation."
+msgstr "`openblas`：依赖OpenBLAS加速提示词(prompt)处理，但不涉及生成过程。"
+
+#: ../../source/run_locally/llama.cpp.md:139 5b0605a7a543494d985a78bb94d9d995
+msgid "arm64 CPUs: We suggest try the `llvm` one first."
+msgstr "arm64 CPU：我们建议首先尝试`llvm`。"
+
+#: ../../source/run_locally/llama.cpp.md:140 5800b70afa0d46fca439d90f6def1c36
+msgid "[`llvm` and `msvc`](https://github.com/ggml-org/llama.cpp/pull/7191) are different compilers"
+msgstr "[`llvm`和`msvc`](https://github.com/ggml-org/llama.cpp/pull/7191)是不同的编译器"
+
+#: ../../source/run_locally/llama.cpp.md:141 091caad783814d16ac4a4aaefd43f360
+msgid "Running on GPU: We suggest try the `cu<cuda_verison>` one for NVIDIA GPUs, `kompute` for AMD GPUs, and `sycl` for Intel GPUs first. Ensure that you have related drivers installed."
+msgstr "在GPU上运行：我们建议NVIDIA GPU先尝试`cu<cuda_verison>`，AMD GPU先尝试`kompute`，Intel GPU先尝试`sycl`。请确保已安装相关驱动程序。"
+
+#: ../../source/run_locally/llama.cpp.md:142 cb77636288d84a6ab7e6659d813d184e
+msgid "[`vulcan`](https://github.com/ggml-org/llama.cpp/pull/2059): support certain NVIDIA and AMD GPUs"
+msgstr "[`vulcan`](https://github.com/ggml-org/llama.cpp/pull/2059)：支持某些NVIDIA和AMD GPU"
+
+#: ../../source/run_locally/llama.cpp.md:143 3dcbdb057df64027af6da72b016a3ed1
+msgid "[`kompute`](https://github.com/ggml-org/llama.cpp/pull/4456): support certain NVIDIA and AMD GPUs"
+msgstr "[`kompute`](https://github.com/ggml-org/llama.cpp/pull/4456)：支持某些NVIDIA和AMD GPU"
+
+#: ../../source/run_locally/llama.cpp.md:144 0fdc7d54cbd4422ab690df1ac14f8052
+msgid "[`sycl`](https://github.com/ggml-org/llama.cpp/discussions/5138): Intel GPUs, oneAPI runtime is included"
+msgstr "[`sycl`](https://github.com/ggml-org/llama.cpp/discussions/5138)：Intel GPU，包含oneAPI运行时"
+
+#: ../../source/run_locally/llama.cpp.md:145 79941a71446c42eaa2375088cf24c41d
+msgid "`cu<cuda_verison>`: NVIDIA GPUs, CUDA runtime is not included. You can download the `cudart-llama-bin-win-cu<cuda_version>-x64.zip` and unzip it to the same directory if you don't have the corresponding CUDA toolkit installed."
+msgstr "`cu<cuda_verison>`：NVIDIA GPU，未包含CUDA运行时。如果您没有安装相应的CUDA工具包，可以下载`cudart-llama-bin-win-cu<cuda_version>-x64.zip`并将其解压到同一目录中。"
+
+#: ../../source/run_locally/llama.cpp.md:147 0cdf63d30fbc4aa3a94c25d7f7cf5824
+msgid "You don't have much choice for macOS or Linux."
+msgstr "对于macOS或Linux，您的选择不多。"
+
+#: ../../source/run_locally/llama.cpp.md:148 fdc3d523acac4789b7921e614fbc30a3
+msgid "Linux: only one prebuilt binary, `llama-<version>-bin-linux-x64.zip`, supporting CPU."
+msgstr "Linux：仅有一个预构建的二进制文件`llama-<version>-bin-linux-x64.zip`，支持CPU。"
+
+#: ../../source/run_locally/llama.cpp.md:149 af122ff340be459188638f019712eed1
+msgid "macOS: `llama-<version>-bin-macos-x64.zip` for Intel Mac with no GPU support; `llama-<version>-bin-macos-arm64.zip` for Apple Silicon with GPU support."
+msgstr "macOS：对于Intel Mac，使用`llama-<version>-bin-macos-x64.zip`（不支持GPU）；对于Apple Silicon，使用`llama-<version>-bin-macos-arm64.zip`（支持GPU）。"
+
+#: ../../source/run_locally/llama.cpp.md:151 a943b5242b7c40ce951c73a1781fc310
+msgid "After downloading the `.zip` file, unzip them into a directory and open a terminal at that directory."
+msgstr "下载`.zip`文件后，将其解压到一个目录中，并在该目录下打开终端。"
+
+#: ../../source/run_locally/llama.cpp.md:156 beb40484138f4256b0553f5a6b2e0475
+msgid "Getting the GGUF"
+msgstr "获取 GGUF"
+
+#: ../../source/run_locally/llama.cpp.md:158 54c848283fca422fb532af37cbe05e11
+msgid "GGUF[^GGUF] is a file format for storing information needed to run a model, including but not limited to model weights, model hyperparameters, default generation configuration, and tokenizer."
+msgstr "GGUF[^GGUF] 是一种文件格式，用于存储运行模型所需的信息，包括但不限于模型权重、模型超参数、默认生成配置和tokenzier。"
+
+#: ../../source/run_locally/llama.cpp.md:160 e32110eeef8c4b9db68a739e09739ac1
+msgid "You can use the official Qwen GGUFs from our Hugging Face Hub or prepare your own GGUF file."
+msgstr "您可以使用我们 Hugging Face Hub 上的官方 Qwen GGUF 文件，或者自己准备 GGUF 文件。"
+
+#: ../../source/run_locally/llama.cpp.md:162 bfacc2373da24a18bb9e2ebd7b290065
+msgid "Using the Official Qwen3 GGUFs"
+msgstr "使用官方 Qwen3 GGUF"
+
+#: ../../source/run_locally/llama.cpp.md:164 8da7612136d14b67a20fbcc70828c043
+msgid "We provide a series of GGUF models in our Hugging Face organization, and to search for what you need you can search the repo names with `-GGUF`."
+msgstr "在我们的 Hugging Face 组织中，我们提供了一系列 GGUF 模型。要查找您需要的模型，可以在仓库名称中搜索 `-GGUF`。"
+
+#: ../../source/run_locally/llama.cpp.md:166 dece3c73889d448ba9817e7a49dd932f
+msgid "Download the GGUF model that you want with `huggingface-cli` (you need to install it first with `pip install huggingface_hub`):"
+msgstr "使用 `huggingface-cli` 下载您想要的 GGUF 模型（首先需要通过 `pip install huggingface_hub` 进行安装）："
+
+#: ../../source/run_locally/llama.cpp.md:171 3b23d1e4d7d347e09cf5faeec61b82a8
+msgid "For example:"
+msgstr "比如："
+
+#: ../../source/run_locally/llama.cpp.md:176 4c6758f24a5143ce8da71d3b19f1f95e
+msgid "This will download the Qwen3-8B model in GGUF format quantized with the scheme Q4_K_M."
+msgstr "这将下载采用 Q4_K_M 方案量化的 GGUF 格式的 Qwen3-8B model 模型。"
+
+#: ../../source/run_locally/llama.cpp.md:178 234ea7b4b5a047a0ac20ba11857dbdc5
+msgid "Preparing Your Own GGUF"
+msgstr "准备您自己的 GGUF"
+
+#: ../../source/run_locally/llama.cpp.md:180 f74e9a53f77446e6b0cc27e9026e6165
+msgid "Model files from Hugging Face Hub can be converted to GGUF, using the `convert-hf-to-gguf.py` Python script. It does require you to have a working Python environment with at least `transformers` installed."
+msgstr "可以使用 `convert-hf-to-gguf.py` Python 脚本将来自 Hugging Face Hub 的模型文件转换为 GGUF。这确实需要您拥有一个工作中的 Python 环境，并至少安装了 `transformers`。"
+
+#: ../../source/run_locally/llama.cpp.md:183 ced933a20489466d98bfc3ef484baa3a
+msgid "Obtain the source file if you haven't already:"
+msgstr "如果尚未获取，请先获取源文件："
+
+#: ../../source/run_locally/llama.cpp.md:189 eb7dfdb39e034b318981c84cd112ac4e
+msgid "Suppose you would like to use Qwen3-8B you can make a GGUF file for the fp16 model as shown below:"
+msgstr "假设您想使用 Qwen3-8B，可以按照以下方式为 fp16 模型制作 GGUF 文件："
+
+#: ../../source/run_locally/llama.cpp.md:193 3baf125807e541399ced8f2cbdd9d338
+msgid "The first argument to the script refers to the path to the HF model directory or the HF model name, and the second argument refers to the path of your output GGUF file. Remember to create the output directory before you run the command."
+msgstr "脚本的第一个参数指的是 HF 模型目录或 HF 模型名称的路径，第二个参数指的是输出 GGUF 文件的路径。在运行命令前，请记得创建输出目录。"
+
+#: ../../source/run_locally/llama.cpp.md:196 a090bc60c62a41eead46c08d67ea8e7b
+msgid "The fp16 model could be a bit heavy for running locally, and you can quantize the model as needed. We introduce the method of creating and quantizing GGUF files in [this guide](../quantization/llama.cpp).  You can refer to that document for more information."
+msgstr "fp16 模型对于本地运行可能有些重，您可以根据需要对模型进行量化。我们在 [这份指南](../quantization/llama.cpp) 中介绍了创建和量化 GGUF 文件的方法。您可以参考该文档获取更多信息。"
+
+#: ../../source/run_locally/llama.cpp.md:201 d4e0affd46394ed08217eba6cde11e61
+msgid "Run Qwen with llama.cpp"
+msgstr "使用 llama.cpp 运行 Qwen"
+
+#: ../../source/run_locally/llama.cpp.md:204 9352e362c2a640a6984fa65f073dadf4
+msgid "Regarding switching between thinking and non-thinking modes, while the soft switch is always available, the hard switch implemented in the chat template is not exposed in llama.cpp. The quick workaround is to pass [a custom chat template](../../source/assets/qwen3_nonthinking.jinja) equivalent to always `enable_thinking=False` via `--chat-template-file`."
+msgstr "关于在思考模式和非思考模式之间切换，虽然软开关始终可用，但在聊天模板中实现的硬开关并未在 llama.cpp 中暴露。快速的解决方法是通过 `--chat-template-file` 传递一个等效于始终设置 `enable_thinking=False` 的[自定义聊天模板](../../source/assets/qwen3_nonthinking.jinja)。"
+
+#: ../../source/run_locally/llama.cpp.md:210 76c238d78e7247d0a71d75961415ed9e
+msgid "llama-cli"
+msgstr ""
+
+#: ../../source/run_locally/llama.cpp.md:212 4e4e1212c8b84613ad0da20c8e555aac
+msgid "[llama-cli](https://github.com/ggml-org/llama.cpp/tree/master/tools/main) is a console program which can be used to chat with LLMs. Simple run the following command where you place the llama.cpp programs:"
+msgstr "[llama-cli](https://github.com/ggml-org/llama.cpp/tree/master/tools/main) 是一个可用于与大型语言模型聊天的控制台程序。只需在放置 llama.cpp 程序的位置运行以下命令："
+
+#: ../../source/run_locally/llama.cpp.md:218 076c752f47bc46f1b0cbbf6425146f95
+msgid "Here are some explanations to the above command:"
+msgstr "以下是对上述命令的一些解释："
+
+#: ../../source/run_locally/llama.cpp.md:219 5f672fa5712c4bd5830c0b9aef7ae1de
+msgid "**Model**: llama-cli supports using model files from local path, remote URL, or Hugging Face hub."
+msgstr "**模型**：llama-cli 支持从本地路径、远程 URL 或 Hugging Face Hub 使用模型文件。"
+
+#: ../../source/run_locally/llama.cpp.md:220 0be28620c8b94dc89edef6d6f153dd81
+msgid "`-hf Qwen/Qwen3-8B-GGUF:Q8_0` in the above indicates we are using the model file from Hugging Face hub"
+msgstr "上面的 `-hf Qwen/Qwen3-8B-GGUF:Q8_0` 表示我们使用的是来自 Hugging Face Hub 的模型文件。"
+
+#: ../../source/run_locally/llama.cpp.md:221 53c0fb1b23794f59984dd71b9a2816c8
+msgid "To use a local path, pass `-m qwen3-8b-q8_0.gguf` instead"
+msgstr "要使用本地路径，传递 `-m qwen3-8b-q8_0.gguf` 即可。"
+
+#: ../../source/run_locally/llama.cpp.md:222 0223c894c4f74e2d85a4b59212f81165
+msgid "To use a remote URL, pass `-mu https://hf.co/Qwen/Qwen3-8B-GGUF/resolve/main/qwen3-8b-Q8_0.gguf?download=true` instead"
+msgstr "要使用远程 URL，传递 `-mu https://hf.co/Qwen/Qwen3-8B-GGUF/resolve/main/qwen3-8b-Q8_0.gguf?download=true` 即可。"
+
+#: ../../source/run_locally/llama.cpp.md:224 289230690cf14c909121197e999359fd
+msgid "**Speed Optimization**:"
+msgstr "**速度优化**："
+
+#: ../../source/run_locally/llama.cpp.md:225 1cbdfffaecc64d9cb7257ba9983505bd
+msgid "CPU: llama-cli by default will use CPU and you can change `-t` to specify how many threads you would like it to use, e.g., `-t 8` means using 8 threads."
+msgstr "CPU：llama-cli 默认会使用 CPU，您可以通过更改 `-t` 来指定希望使用的线程数，例如 `-t 8` 表示使用 8 个线程。"
+
+#: ../../source/run_locally/llama.cpp.md:226 29434d4331ee4edebaa04b2aded1c558
+msgid "GPU: If the programs are built with GPU support, you can use `-ngl`, which allows offloading some layers to the GPU for computation. If there are multiple GPUs, it will offload to all the GPUs. You can use `-dev` to control the devices used and `-sm` to control which kinds of parallelism is used. For example, `-ngl 99 -dev cuda0,cuda1 -sm row` means offload all layers to GPU 0 and GPU1 using the split mode row.  Adding `-fa` may also speed up the generation."
+msgstr "GPU：如果程序包含 GPU 支持，您可以使用 `-ngl`，它允许将一些层卸载到 GPU 进行计算。如果有多个 GPU，它会卸载到所有 GPU 上。您可以使用 `-dev` 控制使用的设备，并使用 `-sm` 控制使用的并行类型。例如，`-ngl 99 -dev cuda0,cuda1 -sm row` 表示使用 row 切分将所有层卸载到 GPU 0 和 GPU 1。添加 `-fa` 也可能加速生成。"
+
+#: ../../source/run_locally/llama.cpp.md:232 260ef13ac441480db43d88e837c4b428
+msgid "**Sampling Parameters**: llama.cpp supports [a variety of sampling methods](https://github.com/ggml-org/llama.cpp/tree/master/tools/main#generation-flags) and has default configuration for many of them. It is recommended to adjust those parameters according to the actual case and the recommended parameters from Qwen3 modelcard could be used as a reference. If you encounter repetition and endless generation, it is recommended to pass in addition `--presence-penalty` up to `2.0`."
+msgstr "**采样参数**：llama.cpp 支持[多种采样方法](https://github.com/ggml-org/llama.cpp/tree/master/tools/main#generation-flags)，并对其中许多方法有默认配置。建议根据实际情况调整这些参数，Qwen3 模型卡片中推荐的参数可作为参考。如果您遇到重复和无尽生成的情况，建议额外传递 `--presence-penalty`，最大值为 `2.0`。"
+
+#: ../../source/run_locally/llama.cpp.md:236 7adb408bb15d4f1a94704ccef38985b5
+msgid "**Context Management**: llama.cpp adopts the \"rotating\" context management by default. The `-c` controls the maximum context length (default 4096, 0 means loaded from model), and `-n` controls the maximum generation length each time (default -1 means infinite until ending, -2 means until context full). When the context is full but the generation doesn't end, the first `--keep` tokens (default 0, -1 means all) from the initial prompt is kept, and the first half of the rest is discarded. Then, the model continues to generate based on the new context tokens. You can set `--no-context-shift` to prevent this rotating behavior and the generation will stop once `-c` is reached."
+msgstr "**上下文管理**：llama.cpp 默认采用“轮换”上下文管理方式。`-c` 控制最大上下文长度（默认值 4096，0 表示从模型加载），`-n` 控制每次生成的最大长度（默认值 -1 表示无限生成直到结束，-2 表示直到上下文满）。当上下文已满但生成未结束时，初始提示中的前 `--keep` 个 token（默认值 0，-1 表示全部）会被保留，其余部分的前半部分会被丢弃。然后，模型基于新的上下文 token 继续生成。您可以设置 `--no-context-shift` 来防止这种轮换行为，一旦达到 `-c`，生成就会停止。"
+
+#: ../../source/run_locally/llama.cpp.md:242 7482a8749a8f48538ec10c7555c610be
+msgid "llama.cpp supports YaRN, which can be enabled by `-c 131072 --rope-scaling yarn --rope-scale 4 --yarn-orig-ctx 32768`."
+msgstr "llama.cpp 支持 YaRN，可以通过 `-c 131072 --rope-scaling yarn --rope-scale 4 --yarn-orig-ctx 32768` 启用。"
+
+#: ../../source/run_locally/llama.cpp.md:243 6348ba3506f44f9ebd560f06cf3a221e
+msgid "**Chat**: `--jinja` indicates using the chat template embedded in the GGUF which is preferred and `--color` indicates coloring the texts so that user input and model output can be better differentiated. If there is a chat template, like in Qwen3 models, llama-cli will enter chat mode automatically. To stop generation or exit press \"Ctrl+C\". You can use `-sys` to add a system prompt."
+msgstr "**聊天**：`--jinja` 表示使用嵌入在 GGUF 中的聊天模板（推荐），`--color` 表示对文本进行着色，以便更好地区分用户输入和模型输出。如果有聊天模板（如 Qwen3 模型中），llama-cli 将自动进入聊天模式。要停止生成或退出，请按 \"Ctrl+C\"。您可以使用 `-sys` 添加系统提示。"
+
+#: ../../source/run_locally/llama.cpp.md:249 4a1967a6131349e8a3ea16830b43994c
+msgid "llama-server"
+msgstr ""
+
+#: ../../source/run_locally/llama.cpp.md:251 8633e2b491b44b5e9affa24651305d51
+msgid "[llama-server](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) is a simple HTTP server, including a set of LLM REST APIs and a simple web front end to interact with LLMs using llama.cpp."
+msgstr "[llama-server](https://github.com/ggml-org/llama.cpp/tree/master/tools/server) 是一个简单的 HTTP 服务器，包含一组 LLM REST API 和一个简单的 Web 前端，用于通过 llama.cpp 与大型语言模型交互。"
+
+#: ../../source/run_locally/llama.cpp.md:253 ef67ce21ceb049b8ada65370e31c56ba
+msgid "The core command is similar to that of llama-cli. In addition, it supports thinking content parsing and tool call parsing."
+msgstr "其核心命令与 llama-cli 类似。此外，它还支持思考内容解析和工具调用解析。"
+
+#: ../../source/run_locally/llama.cpp.md:260 375210d2d2b440a482880a080082b7b6
+msgid "By default, the server will listen at `http://localhost:8080` which can be changed by passing `--host` and `--port`. The web front end can be assessed from a browser at `http://localhost:8080/`. The OpenAI compatible API is at `http://localhost:8080/v1/`."
+msgstr "默认情况下，服务器将在 `http://localhost:8080` 监听，可以通过传递 `--host` 和 `--port` 更改。Web 前端可以通过浏览器访问 `http://localhost:8080/`。兼容 OpenAI 的 API 位于 `http://localhost:8080/v1/`。"
+
+#: ../../source/run_locally/llama.cpp.md:265 067e74dbd5b64c51bd0fbf795867f643
+msgid "What's More"
+msgstr "还有更多"
+
+#: ../../source/run_locally/llama.cpp.md:267 47d05b10224e453e98b3a83ff1ed3a97
+msgid "If you still find it difficult to use llama.cpp, don't worry, just check out other llama.cpp-based applications. For example, Qwen3 has already been officially part of Ollama and LM Studio, which are platforms for your to search and run local LLMs."
+msgstr "如果你仍然觉得使用`llama-cli`有困难，别担心，可以尝试其他基于llama.cpp的应用程序。例如，Qwen3已经成为Ollama和LM Studio的官方组成部分，它们是用于搜索和运行本地LLM的平台。"
+
+#: ../../source/run_locally/llama.cpp.md:270 fd6b04dbca6348b99702fbbbc2f427f1
+msgid "Have fun!"
+msgstr "玩得开心！"
+
+#: ../../source/run_locally/llama.cpp.md:3 35adceca5d514edf9bfc686a8722a38f
+msgid "GPT-Generated Unified Format"
+msgstr ""
+
+#~ msgid "Previously, Qwen2 models generate nonsense like `GGGG...` with `llama.cpp` on GPUs. The workaround is to enable flash attention (`-fa`), which uses a different implementation, and offload the whole model to the GPU (`-ngl 80`) due to broken partial GPU offloading with flash attention."
+#~ msgstr "曾有一段时间，在 GPU 上用 `llama.cpp` 运行 Qwen2 模型会生成类似 `GGGG...` 的胡言乱语。一个权宜之计是开启 flash attention (`-fa`) 并将全模型加载到 GPU 上 (`-ngl 80`) 。前者使用不同的算法实现，后者避免触发 flash attention 在模型一部分 GPU 加载时的异常。"
+
+#~ msgid "Both should be no longer necessary after `b3370`, but it is still recommended enabling both for maximum efficiency."
+#~ msgstr "自版本 `b3370` 起，以上方案已非必需。但考虑最佳效率，仍建议使用两项参数。"
+
+#~ msgid "![llama-cli conversation start](../assets/imgs/llama-cli-cnv-start.png)"
+#~ msgstr ""
+
+#~ msgid "llama-cli conversation start"
+#~ msgstr "llama-cli 对话开始"
+
+#~ msgid "![llama-cli conversation chat](../assets/imgs/llama-cli-cnv-chat.png)"
+#~ msgstr ""
+
+#~ msgid "llama-cli conversation chat"
+#~ msgstr "llama-cli 对话聊天"
+
+#~ msgid "![llama-cli interactive first](../assets/imgs/llama-cli-if.png)"
+#~ msgstr ""
+
+#~ msgid "llama-cli interactive first"
+#~ msgstr "llama-cli 互动模式用户优先"
+
+#~ msgid "![llama-cli interactive](../assets/imgs/llama-cli-i.png)"
+#~ msgstr ""
+
+#~ msgid "llama-cli interactive"
+#~ msgstr "llama-cli 互动模式"
+
+#~ msgid "The main output is as follows: ![llama-cli](../assets/imgs/llama-cli.png)"
+#~ msgstr "主要输出如下所示： ![llama-cli](../assets/imgs/llama-cli.png)"
+
+#~ msgid "llama-cli"
+#~ msgstr ""
+
+#~ msgid "![llama-cli mid](../assets/imgs/llama-cli-mid.png)"
+#~ msgstr ""
+
+#~ msgid "llama-cli mid"
+#~ msgstr "llama-cli 中间"
+
+#~ msgid "Get the `llama-cli` program"
+#~ msgstr "获取 `llama-cli` 程序"
+
+#~ msgid "Remember that `llama-cli` is an example program, not a full-blown application. Sometimes it just does not work in the way you would like. This guide could also get quite technical sometimes. If you would like a smooth experience, check out the application mentioned above, which are much easier to \"use\"."
+#~ msgstr "请记住，`llama-cli` 只是一个示例程序，并非完整应用。有时候它可能无法完全按照您的期望运行。本指南有时会涉及一些技术细节。如果您希望获得流畅的体验，请尝试上述提到的应用，它们使用起来会更加便捷。"
+
+#~ msgid "Then use `make`:"
+#~ msgstr "然后运行 `make` 命令："
+
+#~ msgid "The command will only compile the parts needed for `llama-cli`. On macOS, it will enable Metal and Accelerate by default, so you can run with GPUs. On Linux, you won't get GPU support by default, but SIMD-optimization is enabled if available."
+#~ msgstr "该命令只会编译`llama-cli`所需的部件。在macOS上，默认情况下会启用Metal和Accelerate，因此你可以使用GPU运行。在Linux上，默认情况下你无法获得GPU支持，但如果可用，会启用CPU SIMD优化。"
+
+#~ msgid "There are other [example programs](https://github.com/ggerganov/llama.cpp/tree/master/tools) in llama.cpp. You can build them at once with simply (it may take some time):"
+#~ msgstr "在llama.cpp中还有其他的[示例程序](https://github.com/ggerganov/llama.cpp/tree/master/tools)，你可以一次构建它们（可能需要一些时间）："
+
+#~ msgid "or you can also compile only the one you need, for example:"
+#~ msgstr "你也可以只编译你需要的，例如："
+
+#~ msgid "Running the Model"
+#~ msgstr "运行模型"
+
+#~ msgid "Due to random sampling and source code updates, the generated content with the same command as given in this section may be different from what is shown in the examples."
+#~ msgstr "由于随机采样和源代码更新，使用本节中给出的相同命令生成的内容可能与示例中显示的不同。"
+
+#~ msgid "`llama-cli` provide multiple \"mode\" to \"interact\" with the model. Here, we demonstrate three ways to run the model, with increasing difficulty."
+#~ msgstr "`llama-cli` 提供多种“模式”来与模型进行“交互”。在这里，我们展示三种运行模型的方法，使用难度逐渐增加。"
+
+#~ msgid "Conversation Mode"
+#~ msgstr "对话模式"
+
+#~ msgid "For users, to achieve chatbot-like experience, it is recommended to commence in the conversation mode"
+#~ msgstr "对于普通用户来说，为了获得类似聊天机器人的体验，建议从对话模式开始。"
+
+#~ msgid "The program will first print metadata to the screen until you see the following:"
+#~ msgstr "程序首先会在屏幕上打印元数据，直到你看到以下内容："
+
+#~ msgid "Now, the model is waiting for your input, and you can chat with the model:"
+#~ msgstr "现在，模型正在等待你的输入，你可以与模型进行对话："
+
+#~ msgid "That's something, isn't it? You can stop the model generation anytime by Ctrl+C or Command+.  However, if the model generation is ended and the control is returned to you, pressing the combination will exit the program."
+#~ msgstr "这很有趣，对吧？你可以随时通过 Ctrl+C 或 Command+. 来停止模型生成。但是，如果模型生成结束并且控制权返回给你，按下组合键将会退出程序。"
+
+#~ msgid "So what does the command we used actually do?  Let's explain a little:"
+#~ msgstr "那么，我们使用的命令实际上做了什么呢？让我们来解释一下："
+
+#~ msgid "-m or --model"
+#~ msgstr "-m 或 --model"
+
+#~ msgid "Model path, obviously."
+#~ msgstr "显然，这是模型路径。"
+
+#~ msgid "-co or --color"
+#~ msgstr "-co 或 --color"
+
+#~ msgid "Colorize output to distinguish prompt and user input from generations. Prompt text is dark yellow; user text is green; generated text is white; error text is red."
+#~ msgstr "为输出着色以区分提示词、用户输入和生成的文本。提示文本为深黄色；用户文本为绿色；生成的文本为白色；错误文本为红色。"
+
+#~ msgid "-cnv or --conversation"
+#~ msgstr "-cnv 或 --conversation"
+
+#~ msgid "Run in conversation mode. The program will apply the chat template accordingly."
+#~ msgstr "在对话模式下运行。程序将相应地应用聊天模板。"
+
+#~ msgid "-p or --prompt"
+#~ msgstr "-p 或 --prompt"
+
+#~ msgid "In conversation mode, it acts as the system message."
+#~ msgstr "在对话模式下，它作为系统提示。"
+
+#~ msgid "-fa or --flash-attn"
+#~ msgstr "-fa 或 --flash-attn"
+
+#~ msgid "Enable Flash Attention if the program is compiled with GPU support."
+#~ msgstr "如果程序编译时支持 GPU，则启用Flash Attention注意力实现。"
+
+#~ msgid "-ngl or --n-gpu-layers"
+#~ msgstr "-ngl 或 --n-gpu-layers"
+
+#~ msgid "Layers to the GPU for computation if the program is compiled with GPU support."
+#~ msgstr "如果程序编译时支持 GPU，则将这么多层分配给 GPU 进行计算。"
+
+#~ msgid "-n or --predict"
+#~ msgstr "-n 或 --predict"
+
+#~ msgid "Number of tokens to predict."
+#~ msgstr "要预测的token数量。"
+
+#~ msgid "You can also explore other options by"
+#~ msgstr "你也可以通过以下方式探索其他选项："
+
+#~ msgid "Interactive Mode"
+#~ msgstr "互动模式"
+
+#~ msgid "The conversation mode hides the inner workings of LLMs. With interactive mode, you are made aware how LLMs work in the way to completion or continuation. The workflow is like"
+#~ msgstr "对话模式隐藏了大型语言模型（LLMs）的内部机制。在互动模式下，你可以直观地了解LLMs如何完成或继续生成文本。工作流程如下"
+
+#~ msgid "Give the model an initial prompt, and the model generates a completion."
+#~ msgstr "给模型一个初始提示，模型会生成续写文本。"
+
+#~ msgid "Interrupt the model generation any time or wait until the model generates a reverse prompt or an eos token."
+#~ msgstr "随时中断模型生成，或者等到模型生成反向提示(reverse prompt)或结束token（eos token）。"
+
+#~ msgid "Append new texts (with optional prefix and suffix), and then let the model continues the generation."
+#~ msgstr "添加新文本（可选前缀和后缀），然后让模型继续生成。"
+
+#~ msgid "Repeat Step 2. and Step 3."
+#~ msgstr "重复步骤2和步骤3。"
+
+#~ msgid "This workflow requires a different set of options, since you have to mind the chat template yourselves. To proper run the Qwen2.5 models, try the following:"
+#~ msgstr "此工作流程需要一组不同的选项，因为你必须自己管理聊天模板。为了正确运行Qwen2.5模型，请尝试以下操作："
+
+#~ msgid "We use some new options here:"
+#~ msgstr "我们在这里使用了一些新的选项："
+
+#~ msgid "-sp or --special"
+#~ msgstr "-sp 或 --special"
+
+#~ msgid "Show the special tokens."
+#~ msgstr "显示特殊token。"
+
+#~ msgid "-i or --interactive"
+#~ msgstr "-i 或 --interactive"
+
+#~ msgid "Enter interactive mode. You can interrupt model generation and append new texts."
+#~ msgstr "进入互动模式。你可以中断模型生成并添加新文本。"
+
+#~ msgid "-if or --interactive-first"
+#~ msgstr "-if 或 --interactive-first"
+
+#~ msgid "Immediately wait for user input. Otherwise, the model will run at once and generate based on the prompt."
+#~ msgstr "立即等待用户输入。否则，模型将立即运行并根据提示生成文本。"
+
+#~ msgid "In interactive mode, it is the contexts based on which the model predicts the continuation."
+#~ msgstr "在互动模式下，这是模型续写用的上文。"
+
+#~ msgid "--in-prefix"
+#~ msgstr ""
+
+#~ msgid "String to prefix user inputs with."
+#~ msgstr "用户输入附加的前缀字符串。"
+
+#~ msgid "--in-suffix"
+#~ msgstr ""
+
+#~ msgid "String to suffix after user inputs with."
+#~ msgstr "用户输入附加的后缀字符串。"
+
+#~ msgid "The result is like this:"
+#~ msgstr "结果如下："
+
+#~ msgid "We use `prompt`, `in-prefix`, and `in-suffix` together to implement the chat template (ChatML-like) used by Qwen2.5 with a system message. So the experience is very similar to the conversation mode: you just need to type in the things you want to ask the model and don't need to worry about the chat template once the program starts. Note that, there should not be a new line after user input according to the template, so remember to end your input with `/`."
+#~ msgstr "我们将 `prompt`、`in-prefix` 和 `in-suffix` 结合起来实现Qwen2.5使用的包含系统消息的聊天模板（类似ChatML）。这样的，体验与对话模式非常相似：你只需输入想要询问模型的内容，在程序启动后无需担心聊天模板。请注意，根据模板，用户输入后不应有换行符，所以请以 `/` 结束输入。"
+
+#~ msgid "Advanced Usage"
+#~ msgstr "高级用法"
+
+#~ msgid "Interactive mode can achieve a lot more flexible workflows, under the condition that the chat template is maintained properly throughout. The following is an example:"
+#~ msgstr "互动模式可以实现更灵活的工作流程，前提是整个过程中正确维护聊天模板。以下是一个示例："
+
+#~ msgid "In the above example, I set `--reverse-prompt` to `\"LLM\"` so that the generation is interrupted whenever the model generates `\"LLM\"`[^rp].  The in prefix and in suffix are also set to empty so that I can add content exactly I want. After every generation of `\"LLM\"`, I added the part `\"...not what you think...\"` which are not likely to be generated by the model. Yet the model can continue generation just as fluent, although the logic is broken the second time around. I think it's fun to play around."
+#~ msgstr "在上面的例子中，我将 `--reverse-prompt` 设置为 `\"LLM\"`，以便每当模型生成 `\"LLM\"` 时中断生成过程[^rp]。前缀和后缀也被设置为空，这样我可以精确地添加想要的内容。每次生成 `\"LLM\"` 后，我添加了 `\"...not what you think...\"` 的部分，这部分不太可能由模型生成。然而，模型仍能继续流畅生成，尽管第二次逻辑被破坏。这很有趣，值得探索。"
+
+#~ msgid "Non-interactive Mode"
+#~ msgstr "非交互模式"
+
+#~ msgid "You can also use `llama-cli` for text completion by using just the prompt. However, it also means you have to format the input properly and only one turn can be generated."
+#~ msgstr "你还可以仅使用提示词，通过`llama-cli`完成文本续写。但这也意味着你需要正确格式化输入，并且只能生成一次回应。"
+
+#~ msgid "The following is an example:"
+#~ msgstr "以下是一个示例："
+
+#~ msgid "The main output is as follows:"
+#~ msgstr "主要步骤如下："
+
+#~ msgid "In fact, you can start completion anywhere you want, even in the middle of an assistant message:"
+#~ msgstr "实际上，你可以从任何你想要的地方开始续写，即使是在assistant消息的中间："
+
+#~ msgid "Now you can use `llama-cli` in three very different ways! Try talk to Qwen2.5 and share your experience with the community!"
+#~ msgstr "现在你可以用三种截然不同的方式使用`llama-cli`了！试试和Qwen2.5对话，然后与社区分享你的体验吧！"
+
+#~ msgid "There are some gotchas in using `--reverse-prompt` as it matches tokens instead of strings. Since the same string can be tokenized differently in different contexts in BPE tokenization, some reverse prompts are never matched even though the string does exist in generation."
+#~ msgstr "`--reverse-prompt`在匹配时针对的是token而非字符串，因此使用时有一些需要注意的地方。由于BPE tokenizer在不同上下文中对相同字符串的tokenization结果可能不同，所以某些反向提示符即使在生成的文本中存在，也可能永远无法匹配成功。"
+

docs/locales/zh_CN/LC_MESSAGES/run_locally/mlx-lm.po

@@ -0,0 +1,90 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2024.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-29 16:34+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/run_locally/mlx-lm.md:1 47d6da370d364ad6a80f76d5d1f8a80d
+msgid "MLX LM"
+msgstr ""
+
+#: ../../source/run_locally/mlx-lm.md:4 f11e8701708e48559587dd3a8404be92
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../source/run_locally/mlx-lm.md:7 9ff094754ecc40b79c3bc6737d1264dc
+#, fuzzy
+msgid "[mlx-lm](https://github.com/ml-explore/mlx-examples/tree/main/llms) helps you run LLMs locally on Apple Silicon.  It is available at macOS.  It has already supported Qwen models and this time, we have also provided checkpoints that you can directly use with it."
+msgstr "[mlx-lm](https://github.com/ml-explore/mlx-examples/tree/main/llms)能让你在Apple Silicon上运行大型语言模型，适用于MacOS。mlx-lm已支持Qwen模型，此次我们提供直接可用的模型文件。"
+
+#: ../../source/run_locally/mlx-lm.md:11 df3a6d381ce44151b810ee2ca012c6d3
+msgid "Prerequisites"
+msgstr "准备工作"
+
+#: ../../source/run_locally/mlx-lm.md:13 2f6092faf4904990a208b2cecdc623b4
+msgid "The easiest way to get started is to install the `mlx-lm` package:"
+msgstr "首先需要安装`mlx-lm`包："
+
+#: ../../source/run_locally/mlx-lm.md:15 8ae883c84d7b435293dab8502884cec6
+msgid "with `pip`:"
+msgstr "使用`pip`："
+
+#: ../../source/run_locally/mlx-lm.md:21 0cd594d753fa478ca025271dca9af3b5
+msgid "with `conda`:"
+msgstr "使用`conda`："
+
+#: ../../source/run_locally/mlx-lm.md:27 a82de876ad354ca5ae7eb2cc9fad0f1e
+#, fuzzy
+msgid "Running with Qwen MLX Files"
+msgstr "使用Qwen MLX模型文件"
+
+#: ../../source/run_locally/mlx-lm.md:29 36d5c803c391420fabc5640f57a6509b
+msgid "We provide model checkpoints with `mlx-lm` in our Hugging Face organization, and to search for what you need you can search the repo names with `-MLX`."
+msgstr "我们已在Hugging Face提供了适用于`mlx-lm`的模型文件，请搜索带`-MLX`的存储库。"
+
+#: ../../source/run_locally/mlx-lm.md:31 916de6911595431f9ebf5cc3eec51fe3
+msgid "Here provides a code snippet with `apply_chat_template` to show you how to load the tokenizer and model and how to generate contents."
+msgstr "这里我们展示了一个代码样例，其中使用了`apply_chat_template`来应用对话模板。"
+
+#: ../../source/run_locally/mlx-lm.md:52 299ccc7dc4984f5e97c58b58a6216d69
+msgid "Make Your MLX files"
+msgstr "自行制作MLX格式模型"
+
+#: ../../source/run_locally/mlx-lm.md:54 433503979d404191b934cf5e1ed7f655
+#, fuzzy
+msgid "You can make MLX files with just one command:"
+msgstr "仅用一条命令即可制作mlx格式模型"
+
+#: ../../source/run_locally/mlx-lm.md:60 b2302dcae1074aff87fe3a1ec49c15f0
+msgid "where"
+msgstr "参数含义分别是"
+
+#: ../../source/run_locally/mlx-lm.md:62 cbb011f4b76346cca7369b0d7538f899
+msgid "`--hf-path`: the model name on Hugging Face Hub or the local path"
+msgstr "`--hf-path`: Hugging Face Hub上的模型名或本地路径"
+
+#: ../../source/run_locally/mlx-lm.md:63 16348ddca1e34966a51cb192d1c7d064
+msgid "`--mlx-path`: the path for output files"
+msgstr "`--mlx-path`: 输出模型文件的存储路径"
+
+#: ../../source/run_locally/mlx-lm.md:64 34f6d5f01dcb4381ade2da35c75ea566
+msgid "`-q`: enable quantization"
+msgstr "`-q`: 启用量化"
+
+#~ msgid "MLX-LM"
+#~ msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/run_locally/ollama.po

@@ -0,0 +1,102 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-04-29 16:34+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/run_locally/ollama.md:1 66b5f4776d0a45ec9a7ed2c147a6323e
+msgid "Ollama"
+msgstr "Ollama"
+
+#: ../../source/run_locally/ollama.md:4 1a60e4f166184588802505205b51ea7a
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../source/run_locally/ollama.md:7 06925624447242879d12bcbc3be61ce6
+#, fuzzy
+msgid "[Ollama](https://ollama.com/) helps you run LLMs locally with only a few commands. It is available at macOS, Linux, and Windows. Now, Qwen2.5 is officially on Ollama, and you can run it with one command:"
+msgstr "[Ollama](https://ollama.com/)帮助您通过少量命令即可在本地运行LLM。它适用于MacOS、Linux和Windows操作系统。现在，Qwen2.5正式上线Ollama，您只需一条命令即可运行它："
+
+#: ../../source/run_locally/ollama.md:15 1180461df89c41c586d499daf5c6e0a0
+msgid "Next, we introduce more detailed usages of Ollama for running Qwen2.5 models."
+msgstr "接着，我们介绍在Ollama使用Qwen2.5模型的更多用法"
+
+#: ../../source/run_locally/ollama.md:17 816ea502f0be44bcab371fd76e486618
+msgid "Quickstart"
+msgstr "快速开始"
+
+#: ../../source/run_locally/ollama.md:19 c6d1c533593b495da62c73c8434636f8
+msgid "Visit the official website [Ollama](https://ollama.com/) and click download to install Ollama on your device. You can also search models on the website, where you can find the Qwen2.5 models. Except for the default one, you can choose to run Qwen2.5-Instruct models of different sizes by:"
+msgstr "访问官方网站[Ollama](https://ollama.com/)，点击`Download`以在您的设备上安装Ollama。您还可以在网站上搜索模型，在这里您可以找到Qwen2.5系列模型。除了默认模型之外，您可以通过以下方式选择运行不同大小的Qwen2.5-Instruct模型："
+
+#: ../../source/run_locally/ollama.md:23 9f87565dcf4b44b8adce249c1863adbd
+msgid "`ollama run qwen2.5:0.5b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:24 dcd5286c72a2440fb0fc7bfd210dd8d9
+msgid "`ollama run qwen2.5:1.5b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:25 d2c13d08cad34893804497095676ddd4
+msgid "`ollama run qwen2.5:3b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:26 e4a8e4cbd090469e9094afae3abe30f7
+msgid "`ollama run qwen2.5:7b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:27 a97beb23d6074c2db90428b717ab61dd
+msgid "`ollama run qwen2.5:14b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:28 049274657be149b4976d722cd608eb09
+msgid "`ollama run qwen2.5:32b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:29 baec60a5ed5047e3bd080aa96cfc577b
+msgid "`ollama run qwen2.5:72b`"
+msgstr ""
+
+#: ../../source/run_locally/ollama.md:32 2f9ef84694f5446f87db2333336f93c9
+msgid "`ollama` does not host base models. Even though the tag may not have the instruct suffix, they are all instruct models."
+msgstr "`ollama`并不托管基模型。即便模型标签不带instruct后缀，实际也是instruct模型。"
+
+#: ../../source/run_locally/ollama.md:36 9545d728b8aa4163a66accdb54694caf
+msgid "Run Ollama with Your GGUF Files"
+msgstr "用Ollama运行你自己的GGUF文件"
+
+#: ../../source/run_locally/ollama.md:38 f5a073220da84c19975adcce41f76d5c
+msgid "Sometimes you don't want to pull models and you just want to use Ollama with your own GGUF files. Suppose you have a GGUF file of Qwen2.5, `qwen2.5-7b-instruct-q5_0.gguf`. For the first step, you need to create a file called `Modelfile`. The content of the file is shown below:"
+msgstr "有时您可能不想拉取模型，而是希望直接使用自己的GGUF文件来配合Ollama。假设您有一个名为`qwen2.5-7b-instruct-q5_0.gguf`的Qwen2.5的GGUF文件。在第一步中，您需要创建一个名为`Modelfile`的文件。该文件的内容如下所示："
+
+#: ../../source/run_locally/ollama.md:101 15e36d92505e4e21a2fe5dd07c5861e7
+#, fuzzy
+msgid "Then create the Ollama model by running:"
+msgstr "然后通过运行下列命令来创建一个ollama模型"
+
+#: ../../source/run_locally/ollama.md:107 4087d4c583fe44acb1456ca2412f8c85
+#, fuzzy
+msgid "Once it is finished, you can run your Ollama model by:"
+msgstr "完成后，你即可运行你的ollama模型："
+
+#: ../../source/run_locally/ollama.md:113 083503ce2e9d48eab757e8a4cf805d8d
+msgid "Tool Use"
+msgstr "工具调用"
+
+#: ../../source/run_locally/ollama.md:115 b7635c6f3ccc4294a2ba4a45f17ae163
+#, fuzzy
+msgid "Tool use is now supported Ollama and you should be able to run Qwen2.5 models with it. For more details, see our [function calling guide](../framework/function_call)."
+msgstr "Ollama现已支持工具调用，Qwen2.5也已适配。更多详情，请参阅我们的[函数调用指南](../framework/function_call)"
+

docs/locales/zh_CN/LC_MESSAGES/training/axolotl.po

@@ -0,0 +1,196 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 17:22+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/training/axolotl.md:1 1b87b5a4226b45abbb6838abc839c77f
+msgid "Axolotl"
+msgstr ""
+
+#: ../../source/training/axolotl.md:3 71774faa415944dda99259d64acab46d
+msgid "This guide will help you get started with post-training (SFT, RLHF, RM, PRM) for Qwen3 / Qwen3_MOE using Axolotl, and covers optimizations to enable for better performance."
+msgstr "本指南将帮助您使用 Axolotl 开始对 Qwen3 / Qwen3_MOE 进行后训练（SFT、RLHF、RM、PRM），并涵盖为提升性能而启用的优化。" 
+
+#: ../../source/training/axolotl.md:5 61072e56be004db9b403c1b2bf3f6f86
+msgid "Requirements"
+msgstr "要求"
+
+#: ../../source/training/axolotl.md:7 3ed2a27ad94a49d18b049abfceab7cc9
+msgid "**GPU:** NVIDIA Ampere (or newer) for `bf16` and `Flash Attention`, or AMD GPU"
+msgstr "**GPU:** 适用于 `bf16` 和 `Flash Attention` 的 NVIDIA Ampere（或更新架构），或 AMD GPU"
+
+#: ../../source/training/axolotl.md:8 e1b73a01085240da99d05fcf69fcebec
+msgid "**Python:** ≥3.11"
+msgstr ""
+
+#: ../../source/training/axolotl.md:9 dbe2c77d93064b8eb28e4d4351131887
+msgid "**CUDA:** ≥12.4 (for NVIDIA GPUs)"
+msgstr "**CUDA:** ≥12.4（适用于 NVIDIA GPU）"
+
+#: ../../source/training/axolotl.md:11 58c6d64b99cd4158ae6f2cc924dbac68
+msgid "Installation"
+msgstr "安装"
+
+#: ../../source/training/axolotl.md:13 9156474750754164bf51347eccd7537c
+msgid "You can install Axolotl using PyPI, Conda, Git, Docker, or launch a cloud environment."
+msgstr "您可以使用 PyPI、Conda、Git、Docker 安装 Axolotl，或者启动云环境。"
+
+#: ../../source/training/axolotl.md:16 24099b25e9fa4632b8467c7df11710bb
+msgid "Install PyTorch *before* installing Axolotl to ensure CUDA compatibility."
+msgstr "在安装 Axolotl *之前* 安装 PyTorch，以确保 CUDA 兼容性。"
+
+#: ../../source/training/axolotl.md:19 da17abd4fa654026826ec65f4e34714b
+msgid "For the latest instructions, see the official [Axolotl Installation Guide](https://docs.axolotl.ai/docs/installation.html)."
+msgstr "有关最新说明，请参阅官方 [Axolotl 安装指南](https://docs.axolotl.ai/docs/installation.html)。" 
+
+#: ../../source/training/axolotl.md:21 55210f52b4ba40a5aa3c5ba311a2ab3b
+msgid "Quickstart"
+msgstr "快速入门"
+
+#: ../../source/training/axolotl.md:23 46428d800a7542a48360ca78bbb35f56
+msgid "SFT"
+msgstr "SFT（监督微调）"
+
+#: ../../source/training/axolotl.md:25 34e7a9b5842b467f933f469465518b0d
+msgid "We have provided a sample YAML config for SFT with Qwen/Qwen3-32B: [SFT 32B QLoRA config](https://github.com/axolotl-ai-cloud/axolotl/blob/v0.9.2/examples/qwen3/32b-qlora.yaml)."
+msgstr "我们提供了一个使用 Qwen/Qwen3-32B 进行 SFT 的示例 YAML 配置文件：[SFT 32B QLoRA 配置](https://github.com/axolotl-ai-cloud/axolotl/blob/v0.9.2/examples/qwen3/32b-qlora.yaml)。" 
+
+#: ../../source/training/axolotl.md:37 2baa43f76e164e31a1a49d76cafe98a0
+msgid "To train a smaller model, edit the `base_model` in your config:"
+msgstr "要训练较小的模型，请编辑配置文件中的 `base_model`："
+
+#: ../../source/training/axolotl.md:44 34b2753404214dd5a082c4cd707a1e4f
+msgid "Qwen3 works with all Axolotl features including `Flash Attention`, `bf16`, `LoRA`, `torch_compile`, and `QLoRA`."
+msgstr "Qwen3 可以使用所有 Axolotl 功能，包括 `Flash Attention`、`bf16`、`LoRA`、`torch_compile` 和 `QLoRA`。"
+
+#: ../../source/training/axolotl.md:46 a17d3d2763fd4296ba39aa1f8389c0ff
+msgid "To run on more than single GPU, please take a look at the [Multi-GPU Training Guide](https://docs.axolotl.ai/docs/multi-gpu.html) or [Multi-node Training Guide](https://docs.axolotl.ai/docs/multi-node.html)."
+msgstr "如需在多块 GPU 上运行，请参阅 [多 GPU 训练指南](https://docs.axolotl.ai/docs/multi-gpu.html)  或 [多节点训练指南](https://docs.axolotl.ai/docs/multi-node.html)。" 
+
+#: ../../source/training/axolotl.md:48 87bdbf06d6984fbf801182a9c7c5e223
+msgid "RLHF"
+msgstr "RLHF（基于人类反馈的强化学习）"
+
+#: ../../source/training/axolotl.md:50 0803e7e908024353aa83e561576947cd
+msgid "See the [RLHF Guide](https://docs.axolotl.ai/docs/rlhf.html) for required dataset formats and examples for each method."
+msgstr "请参阅 [RLHF 指南](https://docs.axolotl.ai/docs/rlhf.html)，了解每种方法所需的数据集格式和示例。" 
+
+#: ../../source/training/axolotl.md:52 2c8dd42aca9e40bca82e2ba55ebbc431
+msgid "RM/PRM"
+msgstr "RM/PRM"
+
+#: ../../source/training/axolotl.md:54 237c06d3dc314873908ceb044e20f86d
+msgid "Please refer to the [Reward Modelling Guide](https://docs.axolotl.ai/docs/reward_modelling.html) for required dataset formats and config examples."
+msgstr "请参阅 [奖励建模指南](https://docs.axolotl.ai/docs/reward_modelling.html)，了解所需的数据集格式和配置示例。" 
+
+#: ../../source/training/axolotl.md:56 d9ab3c73710e40c2b16872cb2f83825a
+msgid "Dataset"
+msgstr "数据集"
+
+#: ../../source/training/axolotl.md:58 27d95366d2ab4355bcbe9dd3925ea98b
+msgid "By default, the example config uses the `mlabonne/FineTome-100k` dataset (from HuggingFace Hub). You can substitute any dataset of your own."
+msgstr ""msgstr "默认情况下，示例配置使用 `mlabonne/FineTome-100k` 数据集（来自 HuggingFace Hub）。您可以替换为您自己的任何数据集。"
+
+#: ../../source/training/axolotl.md:60 0820890dd0684961842626ae8f3c204d
+msgid "SFT Dataset Format"
+msgstr "SFT 数据集格式"
+
+#: ../../source/training/axolotl.md:62 9c7cc72200eb48e4b5cf6eaae4adf176
+msgid "Axolotl handles various SFT dataset formats, but the current **recommended** format (for use with `chat_template`) is the OpenAI Messages format:"
+msgstr "Axolotl 支持多种 SFT 数据集格式，但当前**推荐**的格式（用于 `chat_template`）是 OpenAI Messages 格式："
+
+#: ../../source/training/axolotl.md:81 8747795235ae444ebd02f9edeb5e2ee6
+msgid "Use this in your config:"
+msgstr "在您的配置中使用以下内容："
+
+#: ../../source/training/axolotl.md:89 dff75c48b8714b33a518e51198394e90
+msgid "You can also load datasets from multiple sources: HuggingFace Hub, local files, directories, S3, GCS, Azure, etc."
+msgstr "您还可以从多个来源加载数据集：HuggingFace Hub、本地文件、目录、S3、GCS、Azure 等。"
+
+#: ../../source/training/axolotl.md:91 de3c2c02c6b74de48b65cc85e4770280
+msgid "See the [Dataset Loading Guide](https://docs.axolotl.ai/docs/dataset_loading.html) for more details."
+msgstr "更多详细信息，请参阅[数据集加载指南](https://docs.axolotl.ai/docs/dataset_loading.html)。" 
+
+#: ../../source/training/axolotl.md:93 c0d462f8add64d4eb08c94e8abd88901
+msgid "To load different dataset formats, refer to the [SFT Dataset Formats Guide](https://docs.axolotl.ai/docs/dataset-formats/#supervised-fine-tuning-sft)."
+msgstr "要加载不同的数据集格式，请参阅[SFT 数据集格式指南](https://docs.axolotl.ai/docs/dataset-formats/#supervised-fine-tuning-sft)。" 
+
+#: ../../source/training/axolotl.md:95 78bfd0e6be834fb59053c8b79d3e01a2
+msgid "Optimizations"
+msgstr "性能优化"
+
+#: ../../source/training/axolotl.md:97 3b2c2c7c1c344278a858d11e5ee85c68
+msgid "With Qwen3/Qwen3_MOE, you can leverage Axolotl's custom optimizations for improved speed and reduced memory usage:"
+msgstr "通过 Qwen3/Qwen3_MOE，您可以利用 Axolotl 的自定义优化来提升速度并减少内存使用："
+
+#: ../../source/training/axolotl.md:99 5f8736c8f64b4179b17c3817544e6592
+msgid "[Cut Cross Entropy](https://docs.axolotl.ai/docs/custom_integrations.html#cut-cross-entropy)"
+msgstr ""
+
+#: ../../source/training/axolotl.md:100 0fc18a82a08944fcbd116650149c25a2
+msgid "[Liger Kernels](https://docs.axolotl.ai/docs/custom_integrations.html#liger-kernels)"
+msgstr ""
+
+#: ../../source/training/axolotl.md:101 8e1d0b958b5c46fc9586d48ce6fe1f5b
+msgid "(LoRA/QLoRA only): [LoRA Kernels Optimization](https://docs.axolotl.ai/docs/lora_optims.html)"
+msgstr "（仅限 LoRA/QLoRA）：[LoRA Kernels 优化](https://docs.axolotl.ai/docs/lora_optims.html)" 
+
+#: ../../source/training/axolotl.md:103 ef45fbcf05234378b002101dd5f2aeea
+msgid "Additional Suggestions"
+msgstr "附加建议"
+
+#: ../../source/training/axolotl.md:105 f2a5feccb57147f6bbc089d81a76a661
+msgid "Troubleshooting"
+msgstr "故障排除"
+
+#: ../../source/training/axolotl.md:107 0923468a1b75473c9e859969bc4636df
+msgid "Ensure your CUDA version matches your GPU and PyTorch version."
+msgstr "确保您的 CUDA 版本与您的 GPU 和 PyTorch 版本匹配。"
+
+#: ../../source/training/axolotl.md:108 ead86946b9ac4cad8e676dcc9151b6f6
+msgid "If running into out-of-memory issues, try reducing your batch size, enable the optimizations above, or reduce sequence length."
+msgstr "如果遇到内存不足的问题，可以尝试减少批处理大小、启用上述优化或缩短序列长度。"
+
+#: ../../source/training/axolotl.md:109 4a0c5c6c372e40dbbafb625dd721c283
+msgid "Qwen3 MoE may have slower training due to the upstream transformer's handling of MoE layers."
+msgstr "由于上游 Transformer 对 MoE 层的处理，Qwen3 MoE 的训练速度可能会较慢。"
+
+#: ../../source/training/axolotl.md:110 d9d43aa50a044428ab2b6ee60e801e62
+msgid "For help, check the help channel on [Axolotl Discord](https://discord.gg/7m9sfhzaf3) or create a Discussion on [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl)."
+msgstr "如需帮助，请查看 [Axolotl Discord](https://discord.gg/7m9sfhzaf3)  ���的帮助频道，或者在 [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl)  上创建讨论。"
+
+#: ../../source/training/axolotl.md:112 1d754e492c05455098ccadb7898d84d2
+msgid "Links"
+msgstr "外部链接"
+
+#: ../../source/training/axolotl.md:114 616dfc422c534617910f19025d01f66f
+msgid "[Axolotl Documentation](https://docs.axolotl.ai/)"
+msgstr ""
+
+#: ../../source/training/axolotl.md:115 5128337d00fb4437bb80829fca7472d1
+msgid "[Axolotl Discord](https://discord.gg/7m9sfhzaf3)"
+msgstr ""
+
+#: ../../source/training/axolotl.md:116 1478f8dbb7e2475b9b45bf20ffc19a23
+msgid "[Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl)"
+msgstr ""
+
+#: ../../source/training/axolotl.md:117 0aff5c30b6584517935a568adc11b2db
+msgid "[Axolotl Website](https://axolotl.ai)"
+msgstr ""

docs/locales/zh_CN/LC_MESSAGES/training/llama_factory.po

@@ -0,0 +1,120 @@
+# Copyright (C) 2024, Qwen Team, Alibaba Group.
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 17:22+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/training/llama_factory.md:1 d0b05b307a764e27badd1e3851ee03ec
+msgid "LLaMA-Factory"
+msgstr ""
+
+#: ../../source/training/llama_factory.md:4 72877ac996694cc9b526edd4e9c1dc0b
+msgid "To be updated for Qwen3."
+msgstr "仍需为Qwen3更新。"
+
+#: ../../source/training/llama_factory.md:7 61f6ef7f9ec1444fb656b86ab4a43985
+msgid "Here we provide a script for supervised finetuning Qwen2.5 with [LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory). This script for supervised finetuning (SFT) has the following features:"
+msgstr "我们将介绍如何使用 [LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory) 微调 Qwen2.5 模型。本脚本包含如下特点："
+
+#: ../../source/training/llama_factory.md:11 93803890d14b43028177b43a909ce704
+msgid "Support single-GPU and multi-GPU training;"
+msgstr "支持单卡和多卡分布式训练"
+
+#: ../../source/training/llama_factory.md:12 e3576e61279e4419a9ddd3f6947bd0b7
+msgid "Support full-parameter tuning, LoRA, Q-LoRA, Dora."
+msgstr "支持全参数微调、LoRA、Q-LoRA 和 DoRA 。"
+
+#: ../../source/training/llama_factory.md:14 54303164dd1940e1808ab0ddb944c951
+msgid "In the following, we introduce more details about the usage of the script."
+msgstr "下文将介绍更多关于脚本的用法。"
+
+#: ../../source/training/llama_factory.md:17 0b976ba2d67645b2b07fa974d1e064c4
+msgid "Installation"
+msgstr "安装"
+
+#: ../../source/training/llama_factory.md:19 bc2440d2953642258f37115052921826
+msgid "Before you start, make sure you have installed the following packages:"
+msgstr "开始之前，确保你已经安装了以下代码库："
+
+#: ../../source/training/llama_factory.md:21 d628d70296b94969912c03c18461e22c
+msgid "Follow the instructions of [LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory), and build the environment."
+msgstr "根据 [LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory) 官方指引构建好你的环境"
+
+#: ../../source/training/llama_factory.md:24 d1bc1de0521342e2adb683560a52e05b
+msgid "Install these packages (Optional):"
+msgstr "安装下列代码库（可选）："
+
+#: ../../source/training/llama_factory.md:31 dc2b9c3ca4da4d4597a47105ec1fd5b0
+msgid "If you want to use [FlashAttention-2](https://github.com/Dao-AILab/flash-attention), make sure your CUDA is 11.6 and above."
+msgstr "如你使用[FlashAttention-2](https://github.com/Dao-AILab/flash-attention)，请确保你的CUDA版本在11.6以上。"
+
+#: ../../source/training/llama_factory.md:35 c4924b4b72fe4b1a9a50f73b667b9506
+msgid "Data Preparation"
+msgstr "准备数据"
+
+#: ../../source/training/llama_factory.md:37 6195396b9f7549a9950684a17efa4516
+msgid "LLaMA-Factory provides several training datasets in `data` folder, you can use it directly. If you are using a custom dataset, please prepare your dataset as follows."
+msgstr "LLaMA-Factory 在 `data` 文件夹中提供了多个训练数据集，您可以直接使用它们。如果您打算使用自定义数据集，请按照以下方式准备您的数据集。"
+
+#: ../../source/training/llama_factory.md:41 6af76880ee36417ebda92078367d98fd
+msgid "Organize your data in a **json** file and put your data in `data` folder. LLaMA-Factory supports dataset in `alpaca` or `sharegpt` format."
+msgstr "请将您的数据以 **json** 格式进行组织，并将数据放入 `data` 文件夹中。LLaMA-Factory 支持以 `alpaca` 或 `sharegpt` 格式的数据集。"
+
+#: ../../source/training/llama_factory.md:45 e15403384b33491aae4d4176bec80372
+msgid "The dataset in `alpaca` format should follow the below format:"
+msgstr "`alpaca` 格式的数据集应遵循以下格式："
+
+#: ../../source/training/llama_factory.md:62 3c96d003cbbb4c9d84f2f7b167ac7769
+msgid "The dataset in `sharegpt` format should follow the below format:"
+msgstr "`sharegpt` 格式的数据集应遵循以下格式："
+
+#: ../../source/training/llama_factory.md:83 3a63faa0b27b4eed8a749f0c2a675be0
+msgid "Provide your dataset definition in `data/dataset_info.json` in the following format ."
+msgstr "在 `data/dataset_info.json` 文件中提供您的数据集定义，并采用以下格式："
+
+#: ../../source/training/llama_factory.md:86 0a137feb4ce546a0b3088df3351ca062
+msgid "For `alpaca` format dataset, the columns in `dataset_info.json` should be:"
+msgstr "对于 `alpaca` 格式的数据集，其 `dataset_info.json` 文件中的列应为："
+
+#: ../../source/training/llama_factory.md:102 ea7871bf433a4d28923766a9d2c6f3d3
+msgid "For `sharegpt` format dataset, the columns in `dataset_info.json` should be:"
+msgstr "对于 `sharegpt` 格式的数据集，`dataset_info.json` 文件中的列应该包括："
+
+#: ../../source/training/llama_factory.md:123 6663d2ca92084df0a554790ea925cfc0
+msgid "Training"
+msgstr "训练"
+
+#: ../../source/training/llama_factory.md:125 572abdbf356649b99438f85a507139f7
+msgid "Execute the following training command:"
+msgstr "执行下列命令："
+
+#: ../../source/training/llama_factory.md:165 83648e36173f48d99dbf7bb8540039e9
+msgid "and enjoy the training process. To make changes to your training, you can modify the arguments in the training command to adjust the hyperparameters. One argument to note is `cutoff_len`, which is the maximum length of the training data. Control this parameter to avoid OOM error."
+msgstr "并享受训练过程。若要调整您的训练，您可以通过修改训练命令中的参数来调整超参数。其中一个需要注意的参数是 `cutoff_len` ，它代表训练数据的最大长度。通过控制这个参数，可以避免出现OOM（内存溢出）错误。"
+
+#: ../../source/training/llama_factory.md:171 c23adcde6f2846399e3f93e6248e5e70
+msgid "Merge LoRA"
+msgstr "合并LoRA"
+
+#: ../../source/training/llama_factory.md:173 59e54104161841ff965c92211ff2cb8d
+msgid "If you train your model with LoRA, you probably need to merge adapter parameters to the main branch. Run the following command to perform the merging of LoRA adapters."
+msgstr "如果你使用 LoRA 训练模型，可能需要将adapter参数合并到主分支中。请运行以下命令以执行 LoRA adapter 的合并操作。"
+
+#: ../../source/training/llama_factory.md:188 cbdc1761ad20462d9e6318105f5bc6c9
+msgid "Conclusion"
+msgstr "结语"
+
+#: ../../source/training/llama_factory.md:190 bbf0315dc269432dba1a08679398477a
+msgid "The above content is the simplest way to use LLaMA-Factory to train Qwen. Feel free to dive into the details by checking the official repo!"
+msgstr "上述内容是使用LLaMA-Factory训练Qwen的最简单方法。 欢迎通过查看官方仓库深入了解详细信息！"
+

docs/locales/zh_CN/LC_MESSAGES/training/ms_swift.po

@@ -0,0 +1,271 @@
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 17:22+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/training/ms_swift.md:1 498aef3956544f9b97c7a47c66997ea2
+msgid "MS-SWIFT"
+msgstr "MS-SWIFT"
+
+#: ../../source/training/ms_swift.md:3 0a0330c78d8549d1be55501fdc352a15
+msgid "ModelScope SWIFT (**ms-swift**) is the large model and multimodal large model training and deployment framework provided by the [ModelScope community](https://modelscope.cn/)."
+msgstr "ModelScope SWIFT (**ms-swift**) 是由 `ModelScope 社区 [ModelScope community](https://modelscope.cn/) 提供的大模型和多模态大模型训练部署框架。"
+
+#: ../../source/training/ms_swift.md:5 6e980c27ae67400ca12c11fedf439af8
+msgid "GitHub repository: [ms-swift](https://github.com/modelscope/ms-swift)"
+msgstr "GitHub 仓库：[ms-swift](https://github.com/modelscope/ms-swift)"
+
+#: ../../source/training/ms_swift.md:7 43999693226b4bc1ba78d7f8addaa01d
+msgid "Features of using ms-swift for training LLM:"
+msgstr "使用 ms-swift 训练大语言模型的特性："
+
+#: ../../source/training/ms_swift.md:9 b76a71cc42244cccaf2b699e41ee9c7f
+msgid "**Model Types**: Supports 500+ plain-text large models and 200+ multimodal large models, covering the entire process from training to deployment."
+msgstr "**模型类型**：支持 500+ 纯文本大模型和 200+ 多模态大模型，覆盖从训练到部署全流程。"
+
+#: ../../source/training/ms_swift.md:10 f9a00d8a4789418abc700fd6774d784b
+msgid "**Hardware Support**: Compatible with CPUs, RTX series GPUs, T4/V100, A10/A100/H100, Ascend NPUs, MPS, and more."
+msgstr "**硬件支持**：兼容 CPU、RTX 系列 GPU、T4/V100、A10/A100/H100、Ascend NPU、MPS 等。"
+
+#: ../../source/training/ms_swift.md:11 ead5a56786bf46b3a94582164537526a
+msgid "**Training Methods**: Supports full-parameter fine-tuning, LoRA, QLoRA, DoRA, and other techniques."
+msgstr "**训练方法**：支持全参数微调、LoRA、QLoRA、DoRA 等技术。"
+
+#: ../../source/training/ms_swift.md:12 31ad671d19de412e9ad5dd76b933e615
+msgid "**Distributed Training**: Supports distributed training technologies such as DDP, device_map, DeepSpeed ZeRO-2/ZeRO-3, FSDP, and integrates parallelism techniques from Megatron, including Tensor Parallelism, Pipeline Parallelism, Sequence Parallelism, and Expert Parallelism."
+msgstr "**分布式训练**：支持分布式训练技术，如 DDP、device_map、DeepSpeed ZeRO-2/ZeRO-3、FSDP，并集成 Megatron 的并行技术，包括张量并行、流水线并行、序列并行和专家并行。"
+
+#: ../../source/training/ms_swift.md:13 0d6d437bf4fb4485ba4a3b1ad166558e
+msgid "**RLHF Training**: Supports human alignment methods like DPO, GRPO, DAPO, RM, PPO, KTO, etc., for both plain-text and multimodal large models."
+msgstr "**RLHF 训练**：支持纯文本和多模态大模型的人类对齐方法，如 DPO、GRPO、DAPO、RM、PPO、KTO 等。"
+
+#: ../../source/training/ms_swift.md:15 76bf873aaf8f495ca929ae422763046b
+msgid "This article will demonstrate runnable training demos and provide the format for custom datasets. It includes how to use ms-swift for SFT and GRPO on Qwen3-8B, as well as using Megatron-SWIFT (ms-swift's integration of Megatron-LM) for SFT on Qwen3-30B-A3B. Through expert parallelism technology, MoE model training can be accelerated by nearly 10 times."
+msgstr "本文将介绍可运行的训练示例，并提供自定义数据集的格式。内容包括如何使用 ms-swift 对 Qwen3-8B 进行 SFT 和 GRPO，以及使用 Megatron-SWIFT（ms-swift 集成的 Megatron-LM）对 Qwen3-30B-A3B 进行 SFT。通过专家并行技术，MoE 模型的训练速度可以提升近 10 倍。"
+
+#: ../../source/training/ms_swift.md:17 1d166ff43c03452780ae38d1c6cd91e9
+msgid "Before starting fine-tuning, ensure your environment is properly set up."
+msgstr "在开始微调之前，请确保您的环境已正确配置。"
+
+#: ../../source/training/ms_swift.md:32 8b5caa854cf641c489310f747ed205ba
+msgid "Supervised Fine-Tuning (SFT)"
+msgstr "监督微调 (SFT)"
+
+#: ../../source/training/ms_swift.md:34 ../../source/training/ms_swift.md:206
+#: 4ec49f5d7a1b4a9a9851cafafe9c7623
+msgid "Data Preparation"
+msgstr "数据准备"
+
+#: ../../source/training/ms_swift.md:36 c71be51476e04ab0884cd908b042e263
+msgid "The custom dataset format for SFT using ms-swift is as follows (the system field is optional). You can organize it into formats such as JSON, JSONL, or CSV. Specify `--dataset <dataset_path>` in the training script."
+msgstr "使用 ms-swift 进行 SFT 的自定义数据集格式如下（system 字段是可选的）。您可以将其组织为 JSON、JSONL 或 CSV 格式。在训练脚本中指定 `--dataset <dataset_path>`。"
+
+#: ../../source/training/ms_swift.md:38 5de2bd424af14c52b7d73385caca6fba
+msgid "For complete dataset formatting guidelines, see: [Custom Dataset Documentation](https://swift.readthedocs.io/en/latest/Customization/Custom-dataset.html)"
+msgstr "有关完整的数据集格式指南，请参考[自定义数据集文档](https://swift.readthedocs.io/zh-cn/latest/Customization/%E8%87%AA%E5%AE%9A%E4%B9%89%E6%95%B0%E6%8D%AE%E9%9B%86.html)。"
+
+#: ../../source/training/ms_swift.md:40 a6a72b65b49f4aa2948a3092e070bee9
+msgid "General format"
+msgstr "通用格式"
+
+#: ../../source/training/ms_swift.md:48 3e18752803b24196a4e2e307f2418469
+msgid "Format with think"
+msgstr "带有思考内容格式"
+
+#: ../../source/training/ms_swift.md:56 48aafb23741045c49e62aa67837ebb28
+msgid "If you want to train using data without a chain of thought but retain the model's reasoning ability, there are two approaches to minimize disruption during fine-tuning:"
+msgstr "如果您想使用不含思维链的数据进行训练，同时保留模型的推理能力，可以通过以下两种方法尽量减少微调期间的干扰："
+
+#: ../../source/training/ms_swift.md:58 ff2352eac1fd4e57987b02b2b2b294e4
+msgid "**Option 1**: During training, specify `--loss_scale ignore_empty_think` to ignore the loss calculation for `<think>\\n\\n</think>\\n\\n`, preventing the loss of reasoning ability. Refer to the training script [here](https://github.com/modelscope/ms-swift/blob/main/examples/train/think_model/qwen3_demo1.sh). The custom dataset format is as follows:"
+msgstr "**选项 1**：在训练期间，指定 `--loss_scale ignore_empty_think`，以忽略对 `<think>\\n\\n</think>\\n\\n` 的损失计算，从而避免推理能力的丧失。训练脚本请参考[这里](https://github.com/modelscope/ms-swift/blob/main/examples/train/think_model/qwen3_demo1.sh)。自定义数据集格式如下："
+
+#: ../../source/training/ms_swift.md:67 fb0799da5fad46129d4682ffb2003f8e
+msgid "**Option 2**: Add `/no_think` to the query in the dataset to avoid the loss of reasoning ability. Refer to the training script [here](https://github.com/modelscope/ms-swift/blob/main/examples/train/think_model/qwen3_demo2.sh). The custom dataset format is as follows:"
+msgstr "**选项 2**：在数据集的查询中添加 `/no_think`，以避免推理能力的丧失。训练脚本请参考[这里](https://github.com/modelscope/ms-swift/blob/main/examples/train/think_model/qwen3_demo2.sh)。自定义数据集格式如下："
+
+#: ../../source/training/ms_swift.md:76 70f3b79067e34c989d6c3235179eff69
+msgid "30-Minute Self-Cognition Fine-Tuning"
+msgstr "30分钟自我认知微调"
+
+#: ../../source/training/ms_swift.md:78 371e5bc107494dcd90a52569328a520d
+msgid "This section introduces a 30-minute self-cognition fine-tuning process for the Qwen3-8B model. The required GPU memory is 22GB, and it can be run on the A10 provided by [ModelScope's free compute resources](https://modelscope.cn/my/mynotebook)."
+msgstr "本节将介绍30分钟对 Qwen3-8B 进行自我认知微调。所需GPU显存为 22GB，可以在 ModelScope 提供的[免费算力](https://modelscope.cn/my/mynotebook) A10 中运行。"
+
+#: ../../source/training/ms_swift.md:80 18dff1bfb142418c85d00c3a2f520661
+msgid "After training, the model will identify itself as \"swift-robot,\" trained by \"swift,\" instead of its original self-cognition as \"Qwen,\" trained by Alibaba Cloud."
+msgstr "训练后，模型将不再认为自己是由“阿里云”训练的“Qwen”，而是由“swift”训练的“swift-robot”。"
+
+#: ../../source/training/ms_swift.md:82 2bf7287254bb432b9c29adc4f79014de
+msgid "If you need to train in an offline environment, you can manually download the model and dataset and specify `--model <model-path>` and `--dataset <dataset-dir>`. The dataset can be found on [Modelscope Hub](https://modelscope.cn/datasets/swift/self-cognition)."
+msgstr "如果需要在离线环境下进行训练，可以手动下载模型和数据集，并指定 `--model <model-path>` 和 `--dataset <dataset-dir>`。数据集可以在 [Modelscope Hub](https://modelscope.cn/datasets/swift/self-cognition) 上找到。"
+
+#: ../../source/training/ms_swift.md:84 b4dcc1d366304d0abbfa994d76646547
+msgid "For the meaning of each parameter in the training script, please refer to the [Command-line parameters documentation](https://swift.readthedocs.io/en/latest/Instruction/Command-line-parameters.html)."
+msgstr "关于训练脚本中各参数的含义，请参考[命令行参数文档](https://swift.readthedocs.io/en/latest/Instruction/Command-line-parameters.html)。"
+
+#: ../../source/training/ms_swift.md:114 185248e719634f389f7e85be89cbe7d0
+msgid "After fine-tuning, you can use the following script to test the fine-tuning results. Note that the `--adapters` section needs to be modified to the directory path of the last saved checkpoint:"
+msgstr "微调完成后，可以使��以下脚本来测试微调结果。注意，`--adapters` 部分需要修改为最后保存检查点的目录路径："
+
+#: ../../source/training/ms_swift.md:134 dd18bd5b0c9d4c8094e6b2c0b6c17ddc
+msgid "By default, ms-swift will use the ModelScope community to download models and datasets. If you want to use the HuggingFace community, you need to additionally specify `--use_hf true`."
+msgstr "默认情况下，ms-swift 会使用 ModelScope 社区下载模型和数据集。如果想使用 HuggingFace 社区，则需要额外指定 `--use_hf true`。"
+
+#: ../../source/training/ms_swift.md:136 0ad518fadd134498ad3a393397c6d2ae
+msgid "Merge LoRA weights:"
+msgstr "合并 LoRA 权重："
+
+#: ../../source/training/ms_swift.md:144 4c72b93b992a40d89d27857096f9ac94
+msgid "Push the model to ModelScope/HuggingFace:"
+msgstr "推送模型到 ModelScope/HuggingFace："
+
+#: ../../source/training/ms_swift.md:157 a10da08e671a464fa20ec51056dd16ef
+msgid "If you want to use multiple GPUs for training, the following provides a demo for multi-GPU training:"
+msgstr "如果要使用多 GPU 进行训练，以下提供了多 GPU 训练的示例："
+
+#: ../../source/training/ms_swift.md:191 a287c14468ed4625ad50eb75770e4481
+msgid "Reinforcement Learning (RL)"
+msgstr ""
+
+#: ../../source/training/ms_swift.md:193 007251dabc634a469f47dbdc443f44e5
+msgid "ms-swift supports RLHF methods such as DPO, GRPO, DAPO, PPO, KTO, and more. This section will focus on an example of using ms-swift to perform GRPO training for Qwen3-8B."
+msgstr "ms-swift 支持 DPO、GRPO、DAPO、PPO、KTO 等 RLHF 方法。本章将着重介绍使用 ms-swift 对 Qwen3-8B 进行 GRPO 训练。"
+
+#: ../../source/training/ms_swift.md:195 6747ebd5490a42fa9bbe39c71d42de64
+msgid "For detailed RLHF support information, please refer to: [Supported Features](https://swift.readthedocs.io/en/latest/Instruction/Pre-training-and-Fine-tuning.html)."
+msgstr "有关详细的 RLHF 支持信息，请参考[支持的功能](https://swift.readthedocs.io/zh-cn/latest/Instruction/%E9%A2%84%E8%AE%AD%E7%BB%83%E4%B8%8E%E5%BE%AE%E8%B0%83.html)。"
+
+#: ../../source/training/ms_swift.md:197 c40c7e8842a94cf7b8abb7006010b343
+msgid "Environment Setup"
+msgstr "环境设置"
+
+#: ../../source/training/ms_swift.md:199 b397dfabde0c4e099cb07fd0c3ab6630
+msgid "In addition to installing the ms-swift related dependencies introduced above, the following dependencies also need to be installed:"
+msgstr "除了安装上述介绍的 ms-swift 相关依赖项外，还需要安装以下依赖项："
+
+#: ../../source/training/ms_swift.md:208 06221d66d22741b49bb4ef2831dc0242
+msgid "The dataset format for GRPO training using ms-swift is similar to that of SFT, except that the assistant part of the last round is not required. If using accuracy as a reward, a `solution` column is needed to calculate the accuracy."
+msgstr "使用 ms-swift 进行 GRPO 训练的数据集格式与 SFT 类似，但不需要最后一轮的 assistant 部分。如果使用 accuracy 作为奖励，则需要一个 `solution` 列来计算准确率。"
+
+#: ../../source/training/ms_swift.md:210 fb274880c62c4cad8243cbbed73f2adc
+msgid "Example Dataset Formats:"
+msgstr "示例数据集格式："
+
+#: ../../source/training/ms_swift.md:218 5de2bd424af14c52b7d73385caca6fba
+msgid "For dataset preparation for other RLHF algorithms, see: [Custom Dataset Documentation](https://swift.readthedocs.io/en/latest/Customization/Custom-dataset.html#rlhf)."
+msgstr "关于其他 RLHF 算法的数据集准备，请参考[自定义数据集文档](https://swift.readthedocs.io/zh-cn/latest/Customization/%E8%87%AA%E5%AE%9A%E4%B9%89%E6%95%B0%E6%8D%AE%E9%9B%86.html#rlhf)。"
+
+#: ../../source/training/ms_swift.md:220 31d062ff29e14c53ad92ca6d5ab81c23
+msgid "Notes on Dataset Requirements:"
+msgstr "数据集要求的注意事项："
+
+#: ../../source/training/ms_swift.md:222 f6e1dbba72e9450984df10e9da1f4f4c
+msgid "**Reward Function Calculation**: The dataset format depends on the reward function being used. Additional columns may be required to support specific reward calculations. For instance:"
+msgstr "**奖励函数计算**：数据集格式取决于所使用的奖励函数。可能需要额外的列来支持特定的奖励计算。例如："
+
+#: ../../source/training/ms_swift.md:224 5b6d41c5b1734f1a87358fb5416c5888
+msgid "When using the built-in accuracy or cosine similarity reward, the dataset must include a `solution` column to calculate the accuracy of the responses."
+msgstr "当使用内置的 accuracy 或 cosine 奖励时，数据集必须包含一个 `solution` 列以计算回复的准确性。"
+
+#: ../../source/training/ms_swift.md:225 e1937a75effa48ffb42a3d463926c1b0
+msgid "Other columns in the dataset will be passed as `**kwargs` to the reward function for additional customization."
+msgstr "数据集中的其他列将作为 `**kwargs` 传递给奖励函数以实现进一步的自定义。"
+
+#: ../../source/training/ms_swift.md:227 63ee17a7a6b041a88daee17b96928659
+msgid "**Customizing the Reward Function**: To adapt the reward function to your specific needs, you can refer to the following resource: [External Reward Plugin](https://github.com/modelscope/ms-swift/tree/main/examples/train/grpo/plugin). This plugin provides examples and templates for implementing custom reward functions."
+msgstr "**自定义奖励函数**：为了根据您的具体需求调整奖励函数，可以参考链接[外部奖励插件](https://github.com/modelscope/ms-swift/tree/main/examples/train/grpo/plugin)。该插件提供了实现自定义奖励函数的示例和模板。"
+
+#: ../../source/training/ms_swift.md:229 05da2d673c94453cb2bee6c99e46c825
+msgid "During the training process, we use vLLM to accelerate the sampling process. By setting `num_infer_workers=8`, we deploy a vLLM engine for each device to speed up the sampling process."
+msgstr "在训练过程中，我们使用 vLLM 加速采样过程。通过设置 `num_infer_workers=8` ，我们为每个设备部署一个 vLLM 引擎以加快采样速度。"
+
+#: ../../source/training/ms_swift.md:270 5fe351e5c4f84018988f72da7c78005a
+msgid "Megatron-SWIFT"
+msgstr "Megatron-SWIFT"
+
+#: ../../source/training/ms_swift.md:272 b4dcc1d366304d0abbfa994d76646547
+msgid "ms-swift incorporates Megatron parallelism techniques to accelerate the training of large models. The supported models can be found in the [Supported Models Documentation](https://swift.readthedocs.io/en/latest/Instruction/Supported-models-and-datasets.html)."
+msgstr "ms-swift 引入了 Megatron 并行技术以加速大模型的训练。支持的模型可以在[支持的模型文档](https://swift.readthedocs.io/zh-cn/latest/Instruction/%E6%94%AF%E6%8C%81%E7%9A%84%E6%A8%A1%E5%9E%8B%E5%92%8C%E6%95%B0%E6%8D%AE%E9%9B%86.html)中找到。"
+
+#: ../../source/training/ms_swift.md:274 cacc805e7bae4869b249768ba0807ae1
+msgid "For environment preparation and the conversion between HF and MCore model weights, you can refer to the [Megatron-SWIFT Training Documentation](https://swift.readthedocs.io/en/latest/Instruction/Megatron-SWIFT-Training.html). These topics will not be elaborated here."
+msgstr "关于环境准备以及 HF 和 MCore 模型权重的转换，可以参考[Megatron-SWIFT训练文档](https://swift.readthedocs.io/zh-cn/latest/Instruction/Megatron-SWIFT%E8%AE%AD%E7%BB%83.html)。这里不展开介绍。"
+
+#: ../../source/training/ms_swift.md:276 e4b6d48e1f5440ddbc5602e6860f7971
+msgid "We will use Alibaba Cloud DLC to start the training The training environment consists of 2 machines with 8 * 80GiB A800 GPUs. For more information on multi-node startup methods, refer to [here](https://github.com/modelscope/ms-swift/tree/main/examples/train/multi-node)."
+msgstr "我们将使用阿里云 DLC 启动训练。训练环境由2台配备8卡 80GiB A800 GPU 组成。关于多节点启动方法的更多信息，请参考[这里](https://github.com/modelscope/ms-swift/tree/main/examples/train/multi-node)。"
+
+#: ../../source/training/ms_swift.md:316 62fd695e82d54817ae7e0a59ea0e0381
+msgid "The custom dataset format is the same as `swift sft`, which can be found in the previous section. Simply specify `--dataset <dataset_path>`."
+msgstr "自定义数据集格式与 `swift sft` 相同，详见之前章节。只需指定 `--dataset <dataset_path>` 即可。"
+
+#: ../../source/training/ms_swift.md:318 bd84ae8eeaf248ffb43acb334e7626e7
+msgid "The following is a comparison of training speed and GPU memory usage between `megatron sft` and `swift sft` for full-parameter fine-tuning of the Qwen3-30B-A3B model:"
+msgstr "使用 `megatron sft` 和 `swift sft` 在对 Qwen3-30B-A3B 模型进行全参数微调的训练速度和 GPU 显存使用对比情况如下："
+
+#: ../../source/training/ms_swift.md 6e220a7c28b14bcd85fd9af5804ab91e
+msgid "Megatron-LM"
+msgstr "Megatron-LM"
+
+#: ../../source/training/ms_swift.md d5ab9738de6241f5837c0d94ef9108d4
+msgid "DeepSpeed-ZeRO2"
+msgstr "DeepSpeed-ZeRO2"
+
+#: ../../source/training/ms_swift.md 301a5de6123c442b8ffa6711f4910363
+msgid "DeepSpeed-ZeRO3"
+msgstr "DeepSpeed-ZeRO3"
+
+#: ../../source/training/ms_swift.md 35818d0633704fd3a70482e77a32f892
+msgid "Training Speed"
+msgstr "训练速度"
+
+#: ../../source/training/ms_swift.md 6b8176dc1e724ccfbcea6ab0fec3f2d8
+msgid "9.6s/it"
+msgstr "9.6s/it"
+
+#: ../../source/training/ms_swift.md c344266bde2c4703bad8f2cd5b19a2ef
+msgid "-"
+msgstr ""
+
+#: ../../source/training/ms_swift.md 468b05aed5be4fcf9593ba2ad6545868
+msgid "91.2s/it"
+msgstr "91.2s/it"
+
+#: ../../source/training/ms_swift.md ffcfa71deee14901a6e96f3424251197
+msgid "GPU Memory Usage"
+msgstr "显存使用"
+
+#: ../../source/training/ms_swift.md 6c68f675c1c343debbebd40e725aa3af
+msgid "16 * 60GiB"
+msgstr "16 * 60GiB"
+
+#: ../../source/training/ms_swift.md 76e6265fbb52487fa8b3a8e5dd04e9bd
+msgid "OOM"
+msgstr "OOM"
+
+#: ../../source/training/ms_swift.md 676f4cc38dba4dd5b69e76186a6dc3a1
+msgid "16 * 80GiB"
+msgstr "16 * 80GiB"
+
+#: ../../source/training/ms_swift.md:325 ebfe245e509c4d17aa0977330d1b7668
+msgid "Conclusion"
+msgstr "总结"
+
+#: ../../source/training/ms_swift.md:327 0cd0194d11994c899616a43b9650c0b6
+msgid "The above is the best practice for training Qwen3 series models using ms-swift. If you encounter any difficulties during use, please join the discussion in [this issue](https://github.com/modelscope/ms-swift/issues/4030)."
+msgstr "以上为使用 ms-swift 训练 Qwen3 系列模型的最佳实践。如果在使用过程中遇到任何困难，请在[此 issue](https://github.com/modelscope/ms-swift/issues/4030)中参与讨论。"
+

docs/locales/zh_CN/LC_MESSAGES/training/unsloth.po

@@ -0,0 +1,200 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-07-28 10:50+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.17.0\n"
+
+#: ../../source/training/unsloth.md:1 857a9b310ad247a981ec378e5c624e94
+msgid "Unsloth"
+msgstr ""
+
+#: ../../source/training/unsloth.md:3 c75c1a88b89448cea8385c1269709dc0
+#, python-format
+msgid "This guide will teach you how to easily train Qwen3 models with Unsloth. Unsloth simplifies local model training, handling everything from loading and quantization to training, evaluation, running, and deployment with inference engines (Ollama, llama.cpp, vLLM). **Train Qwen** models 2× faster using 70% less VRAM."
+msgstr "本指南将教您如何使用 Unsloth 轻松训练 Qwen3 模型。Unsloth 简化了本地模型训练，涵盖了从加载、量化到训练、评估、运行以及通过推理引擎（如 Ollama、llama.cpp、vLLM）进行部署的所有内容。**训练 Qwen** 模型的速度提升 2 倍，同时使用减少 70% 的显存（VRAM）。"
+
+#: ../../source/training/unsloth.md:5 6ce37469f8434d82b0a1a807e2cc67ff
+msgid "**GitHub repo:** [Unsloth](https://github.com/unslothai/unsloth)"
+msgstr "**GitHub 仓库：** [Unsloth](https://github.com/unslothai/unsloth)"
+
+#: ../../source/training/unsloth.md:7 702fad6892df4185a3a130827d8c10bd
+msgid "⭐ Key Features"
+msgstr "⭐ 主要特性"
+
+#: ../../source/training/unsloth.md:8 7f46ea01deec495ba94b88c72fa5d557
+msgid "Supports full fine-tuning, pretraining, LoRA, QLoRA, 8-bit training & more"
+msgstr "支持全量微调、预训练、LoRA、QLoRA、8-bit 训练等"
+
+#: ../../source/training/unsloth.md:9 9d8a9bc65e6d4c6ba9bd4c25d1c07a4b
+msgid "Single and multi-GPU support (Linux, Windows, Colab, Kaggle; NVIDIA GPUs, soon AMD & Intel)"
+msgstr "支持单 GPU 和多 GPU（Linux、Windows、Colab、Kaggle；NVIDIA GPU，即将支持 AMD 和 Intel）"
+
+#: ../../source/training/unsloth.md:10 2c4fb728cbf443c9b69c58594202fff4
+msgid "Compatible with all transformer models: TTS, multimodal, STT, BERT, RL"
+msgstr "兼容所有 Transformer 模型：TTS、多模态、STT、BERT、RL"
+
+#: ../../source/training/unsloth.md:11 0a81b3f4ee664e2f9d3683d986e3a8e3
+msgid "RLHF support: GRPO, DPO, DAPO, RM, PPO, KTO, etc."
+msgstr "支持 RLHF：GRPO、DPO、DAPO、RM、PPO、KTO 等"
+
+#: ../../source/training/unsloth.md:12 30784cc59fff4cb39b180ea2fae50064
+msgid "Hand-written Triton kernels and a manual backprop engine ensure no accuracy degradation (0% approximation)."
+msgstr "手写 Triton 内核和手动反向传播引擎确保无精度损失（0% 近似）。"
+
+#: ../../source/training/unsloth.md:14 ad482aa635484a67896a0cfa126037a8
+msgid "Quickstart"
+msgstr "快速入门"
+
+#: ../../source/training/unsloth.md:15 884abdd5143c4f8b9e30a8831493e48f
+msgid "**Local Installation (Linux recommended):**"
+msgstr "**本地安装（推荐 Linux）：**"
+
+#: ../../source/training/unsloth.md:21 38492db20dcb4119b6712c633b05e090
+msgid "You can view Unsloth’s full [installation instructions here.](https://docs.unsloth.ai/get-started/installing-+-updating)"
+msgstr "您可以在此处查看 Unsloth 的完整[安装说明\[英文\]](https://docs.unsloth.ai/get-started/installing-+-updating)。"
+
+#: ../../source/training/unsloth.md:23 1fe28bbc6e9d418dbe6d870714d2e8dd
+msgid "Fine-tuning Qwen3 with Unsloth"
+msgstr "使用 Unsloth 微调 Qwen3"
+
+#: ../../source/training/unsloth.md:24 863559c6be5d4b8b9535ccf005d7f4ac
+#, python-format
+msgid "Unsloth makes Qwen3 fine-tuning 2× faster, uses 70% less VRAM, with 8× longer contexts. Qwen3 (14B) fits in a free 16 GB Colab Tesla T4 GPU."
+msgstr "Unsloth 使 Qwen3 的微调速度提升 2 倍，显存（VRAM）使用减少 70%，并支持 8 倍更长的上下文。Qwen3（14B）可轻松运行在免费的 16 GB 显存 Colab Tesla T4 GPU 上。"
+
+#: ../../source/training/unsloth.md:26 34d66ac952624c9e8978e1969fd27633
+#, python-format
+msgid "To retain Qwen3's reasoning capabilities, use a 75% reasoning to 25% non-reasoning dataset ratio (e.g., NVIDIA’s math‑reasoning dataset + Maxime’s FineTome)."
+msgstr "为了保留 Qwen3 的推理能力，建议使用 75% 推理类数据与 25% 非推理类数据的组合（例如，NVIDIA 的数学推理数据集 + Maxime 的 FineTome 数据集）。"
+
+#: ../../source/training/unsloth.md:28 c316c959303040ca952d24729f8fc0a4
+msgid "For more details, see Unsloth’s full [Qwen3 fine-tuning guide](https://docs.unsloth.ai/basics/qwen3-how-to-run-and-fine-tune#fine-tuning-qwen3-with-unsloth)."
+msgstr "更多详细信息，请参阅 Unsloth 完整的[Qwen3 微调指南\[英文\]](https://docs.unsloth.ai/basics/qwen3-how-to-run-and-fine-tune#fine-tuning-qwen3-with-unsloth)。"
+
+#: ../../source/training/unsloth.md:30 581ccade253e4145be58856901aeee91
+msgid "Colab Notebooks"
+msgstr ""
+
+#: ../../source/training/unsloth.md:31 f131a50d6c604bd3aa9a896500bd2cc2
+msgid "[Qwen3 (14B) Reasoning + Conversational](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(14B)-Reasoning-Conversational.ipynb)"
+msgstr ""
+
+#: ../../source/training/unsloth.md:32 fc6397fddd354fc1a44a4329dd4020d4
+msgid "[Qwen3 (4B) Advanced GRPO LoRA](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb)"
+msgstr ""
+
+#: ../../source/training/unsloth.md:33 061f4bf082fd435db514c9355e599453
+msgid "[Qwen3 (14B) Alpaca (Base model)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(14B)-Alpaca.ipynb)"
+msgstr ""
+
+#: ../../source/training/unsloth.md:35 c5bb61e8cb7e4e078956e837d033f339
+msgid "**Update Unsloth locally:**"
+msgstr "**在本地更新 Unsloth：**"
+
+#: ../../source/training/unsloth.md:41 4eb073fad2e344dba1f0fb622c18ccd2
+msgid "Fine-tuning Qwen3 MoE Models"
+msgstr "微调 Qwen3 MoE 模型"
+
+#: ../../source/training/unsloth.md:42 22755ac77e144d2aa7e959fa0a86aeaa
+msgid "Supported MoE models include 30B‑A3B and 235B‑A22B. Unsloth fine-tunes the 30B‑A3B model with just 17.5 GB VRAM. Router-layer fine-tuning is disabled by default."
+msgstr "支持的 MoE 模型包括 30B‑A3B 和 235B‑A22B。Unsloth 仅需 17.5 GB 显存即可微调 30B‑A3B 模型。默认情况下禁用路由层（router-layer）的微调。"
+
+#: ../../source/training/unsloth.md:44 19ffbd02f9ab44e78a2eae078de3bc4a
+msgid "Use `FastModel` for MoE fine-tuning:"
+msgstr "对 MoE 模型进行微调时，请使用 `FastModel`："
+
+#: ../../source/training/unsloth.md:58 55c17609e3844f57aa6a7f61b8e0629c
+msgid "Notebook Guide"
+msgstr "Notebook 指南"
+
+#: ../../source/training/unsloth.md:59 2897bf2a487d4f21ac0bcd8d1866f53e
+msgid "For an end-to-end walkthrough, see Unsloth’s [full end-to-end fine-tuning guide](https://docs.unsloth.ai/basics/reinforcement-learning-rl-guide)."
+msgstr "如需端到端的完整操作流程，请参阅 Unsloth 的[完整端到端微调指南\[英文\]](https://docs.unsloth.ai/basics/reinforcement-learning-rl-guide)。"
+
+#: ../../source/training/unsloth.md:61 919bfc2dc5f640a1a2c18af536e38529
+msgid "Open the notebook → click **Runtime ▸ Run all**."
+msgstr "打开 Notebook  → 点击 **Runtime ▸ Run all**。"
+
+#: ../../source/training/unsloth.md:62 76fed20c6fa048728023f2664089d991
+msgid "Adjust settings (e.g., model name, context length) directly in the notebook:"
+msgstr "直接在 Notebook 中调整设置（例如模型名称、上下文长度）："
+
+#: ../../source/training/unsloth.md:63 c60e9857fd4e44b794ccfd2cc5d15cbe
+msgid "`max_seq_length`: Recommended 2048 (Qwen3 supports up to 40960)."
+msgstr "`max_seq_length`：推荐值为 2048（Qwen3 最高支持 40960）。"
+
+#: ../../source/training/unsloth.md:64 e73b7cab67cc4eed802c6af5219f6cc6
+msgid "`load_in_4bit=True`: reduces memory usage by 4×."
+msgstr "`load_in_4bit=True`：将内存使用量减少为原来的四分之一。"
+
+#: ../../source/training/unsloth.md:65 06e12675ca494226a2731a616fbe8c01
+msgid "Enable full fine-tuning (`full_finetuning=True`) or 8-bit training (`load_in_8bit=True`)."
+msgstr "启用全量微调（`full_finetuning=True`）或 8-bit 训练（`load_in_8bit=True`）。"
+
+#: ../../source/training/unsloth.md:67 fcc086506d3f45b1bc0aee524dbc1cfe
+msgid "If you want to use models directly from [ModelScope](https://modelscope.cn/organization/unsloth), use:"
+msgstr "如果您想直接使用来自 [ModelScope](https://modelscope.cn/organization/unsloth) 的模型，请使用："
+
+#: ../../source/training/unsloth.md:85 9d6116efc01d44ff948af4e660045bb5
+msgid "RL & GRPO with Qwen3"
+msgstr "使用 Qwen3 进行强化学习（RL）与 GRPO"
+
+#: ../../source/training/unsloth.md:86 0afdabd0d4bf4ae7936b67de95c3ed3d
+msgid "You can also train Qwen models with reinforcement learning (RL) using Unsloth. Explore Unsloth’s advanced GRPO notebook, featuring proximity-based reward scoring and Hugging Face's Open‑R1 math dataset: [Qwen3 (4B) Advanced GRPO LoRA notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb)."
+msgstr "您还可以使用 Unsloth 通过强化学习（RL）来训练 Qwen 模型。探索 Unsloth 的进阶 GRPO Notebook，其中包含基于接近度的奖励评分和 Hugging Face 的 Open‑R1 数学数据集：[Qwen3 (4B) 进阶 GRPO LoRA Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb)。"
+
+#: ../../source/training/unsloth.md:87 4fc6252997454f769562fc37150d5bd1
+msgid "Proximity-based rewards for closer answers"
+msgstr "基于 Proximity 的奖励，对更接近正确答案的回答给予更高奖励"
+
+#: ../../source/training/unsloth.md:88 e38b7b9cb5ed447caeed00e37aa1f7e1
+msgid "Custom GRPO formatting and templates"
+msgstr "自定义 GRPO 格式和模板"
+
+#: ../../source/training/unsloth.md:89 feecf90a36cf40fab79713ed8c84dfa7
+msgid "Enhanced evaluation accuracy with regex matching"
+msgstr "通过正则表达式匹配提高评估准确性"
+
+#: ../../source/training/unsloth.md:91 c176e49b6e4a42a0b89ff7b180faf0bc
+msgid "Resources & Links"
+msgstr "资源与链接"
+
+#: ../../source/training/unsloth.md:92 d29d33008569432bbf59ffae56e62a48
+msgid "That’s how you can easily train Qwen models with Unsloth. If you need any help, join the discussion on Unsloth’s [Discord](https://discord.com/invite/unsloth) or [GitHub](https://github.com/unslothai/unsloth) pages."
+msgstr "这就是使用 Unsloth 轻松训练 Qwen 模型的方法。如果您需要任何帮助，请加入 Unsloth 的 [Discord](https://discord.com/invite/unsloth) 或 [GitHub](https://github.com/unslothai/unsloth) 页面参与讨论。"
+
+#: ../../source/training/unsloth.md:94 ff3536ed471841f7addfbcdb828dc11d
+msgid "**Links:**"
+msgstr "**链接：**"
+
+#: ../../source/training/unsloth.md:95 873de88c8178499f8b0262fe30dbf44c
+msgid "[Unsloth Documentation](https://docs.unsloth.ai/)"
+msgstr "[Unsloth 官方文档](https://docs.unsloth.ai/)"
+
+#: ../../source/training/unsloth.md:96 69437a5a07834f5ab79c96961dc95842
+msgid "[Unsloth Discord](https://discord.com/invite/unsloth)"
+msgstr ""
+
+#: ../../source/training/unsloth.md:97 3e8bbe8da0124e5d8ff71868e19141cd
+msgid "[Unsloth Website](https://unsloth.ai/)"
+msgstr "[Unsloth 官方站点](https://unsloth.ai/)"
+
+#: ../../source/training/unsloth.md:98 35c1f4a1bcf647f096bdee249fcabdaa
+msgid "[Unsloth Reddit](https://www.reddit.com/r/unsloth/)"
+msgstr ""
+

docs/locales/zh_CN/LC_MESSAGES/training/verl.po

@@ -0,0 +1,117 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2024, Qwen Team
+# This file is distributed under the same license as the Qwen package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Qwen \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 17:22+0800\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: zh_CN\n"
+"Language-Team: zh_CN <LL@li.org>\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.16.0\n"
+
+#: ../../source/training/verl.md:1 937d32044f9d4ce685b5c0d297d2c48d
+msgid "verl"
+msgstr ""
+
+#: ../../source/training/verl.md:3 11c0fdd831b444f28be5cce4fd8f8b38
+msgid "verl is a flexible, efficient and production-ready RL training library for large language models (LLMs)."
+msgstr "verl 是一个灵活、高效且被广泛使用的强化学习（RL）训练库，专为大型语言模型（LLM）设计。"
+
+#: ../../source/training/verl.md:5 64a80c70bd8a49cbb40d4acd035c6212
+msgid "verl is the open-source version of [HybridFlow: A Flexible and Efficient RLHF Framework](https://arxiv.org/abs/2409.19256v2) paper."
+msgstr "verl 是论文 [HybridFlow: A Flexible and Efficient RLHF Framework](https://arxiv.org/abs/2409.19256v2) 的开源实现"
+
+#: ../../source/training/verl.md:7 81aa9801baa54d72bef51c26925278d2
+msgid "GitHub repository: [verl](https://github.com/volcengine/verl)"
+msgstr "仓库地址：[verl](https://github.com/volcengine/verl)"
+
+#: ../../source/training/verl.md:9 2080b3c322ac41299917a122b4826994
+msgid "verl is flexible and easy to use with:"
+msgstr "verl 的灵活性和易用性体现在以下几个方面："
+
+#: ../../source/training/verl.md:11 564fbddc57ae43e090e24fe6426d670a
+msgid "**Easy extension of diverse RL algorithms**: The hybrid-controller programming model enables flexible representation and efficient execution of complex Post-Training dataflows. Build RL dataflows such as GRPO, PPO in a few lines of code."
+msgstr "**支持多样化的强化学习算法扩展**：verl 采用混合编程模型，结合了单一控制器和多控制器的优势，能够灵活表示和高效执行复杂的后训练数据流。用户只需几行代码即可构建强化学习数据流，例如 PPO、GRPO 等。"
+
+#: ../../source/training/verl.md:12 690f3983ad004db081baba2bc5d80d32
+msgid "**Seamless integration of existing LLM infra with modular APIs**: Decouples computation and data dependencies, enabling seamless integration with existing LLM frameworks, such as FSDP, Megatron-LM, vLLM, SGLang, etc"
+msgstr "**与现有大语言模型基础设施无缝集成**：verl 通过模块化 API 解耦计算和数据依赖，支持与 PyTorch FSDP、Megatron-LM、vLLM 等现有大语言模型框架无缝集成，且用户可以轻松扩展到其他训练和推理框架。"
+
+#: ../../source/training/verl.md:13 323cbf0f7b034e3aadaa3b86e4680058
+msgid "**Flexible device mapping**: Supports various placement of models onto different sets of GPUs for efficient resource utilization and scalability across different cluster sizes."
+msgstr "**灵活的设备映射和并行性**：verl 支持将模型放置到不同 GPU 集合上，以实现高效的资源利用和跨不同集群规模的可扩展性。"
+
+#: ../../source/training/verl.md:14 e76a04d1c8aa491e8d6ae1d24d3b71d8
+msgid "**Ready integration with popular HuggingFace models**: verl supports popular LLM models, including Qwen, Llama, and more."
+msgstr "**与热门 HuggingFace 模型的及时集成**：verl 支持多种流行的 LLM 模型，包括 Qwen、Llama 等。"
+
+#: ../../source/training/verl.md:16 acc32ec6e23248d1b3714424bcb868f5
+msgid "verl is fast with:"
+msgstr "verl 的高效性体现在以下几个方面："
+
+#: ../../source/training/verl.md:18 bdeb7205dbd04ab689ab15907fe8ced1
+msgid "**State-of-the-art throughput**: SOTA LLM training and inference engine integrations and SOTA RL throughput."
+msgstr "**最高效的吞吐量**：verl 集成了最先进的 LLM 训练和推理引擎，并实现了最先进的强化学习（RL）吞吐量。"
+
+#: ../../source/training/verl.md:19 314eba723e854d1ab020ec72a0251706
+msgid "**Efficient actor model resharding with 3D-HybridEngine**: Eliminates memory redundancy and significantly reduces communication overhead during transitions between training and generation phases."
+msgstr "**使用 3D-HybridEngine 实现高效的 Actor 模型分片**：消除内存冗余，并显著减少训练和生成阶段转换期间的通信开销。"
+
+#: ../../source/training/verl.md:21 d76b21e9b42c414283609c3846c1e75c
+msgid "Next, we will introduce how to use verl for training Qwen3 models."
+msgstr "接下来，我们将介绍如何使用 verl 训练 Qwen3 模型。"
+
+#: ../../source/training/verl.md:23 6924574168a841e39a4ef0dfb11e6439
+msgid "Reinforcement Learning (RL)"
+msgstr "强化学习（RL）"
+
+#: ../../source/training/verl.md:25 5dae4a3e148042c3b9a2d42e967f7798
+msgid "Now, verl supports various combinations of training frameworks and inference frameworks, including FSDP, Megatron-LM, vLLM, SGLang, etc. verl also supports training with multiple algorithms such as PPO, GRPO, DAPO, etc."
+msgstr "现在，verl 支持多种训练框架和推理框架的组合，包括 FSDP、Megatron-LM、vLLM、SGLang 等。此外，verl 还支持使用多种算法进行训练，例如 PPO、GRPO、DAPO 等。"
+
+#: ../../source/training/verl.md:27 5fe2ddcafab04734a5ce56358f213de2
+msgid "Step1: Environment and Training Preparation"
+msgstr "第一步：环境和训练准备"
+
+#: ../../source/training/verl.md:29 f5bd55e1b12e4cf0a5c77959e30a2add
+msgid "You can follow verl's [installation guide](https://verl.readthedocs.io/en/latest/start/install.html) to complete the environment configuration."
+msgstr "你可以按照 verl 的 [安装指南](https://verl.readthedocs.io/en/latest/start/install.html) 完成环境配置。"
+
+#: ../../source/training/verl.md:31 c5a07c1e71a44be699c2628b0af66fa7
+msgid "Data preparation can be done by running the following command:"
+msgstr "数据准备可以通过运行以下命令完成："
+
+#: ../../source/training/verl.md:39 e626176f3660473ba8a834ba471135eb
+msgid "Model download can be done using the following command:"
+msgstr "模型下载可以使用以下命令完成："
+
+#: ../../source/training/verl.md:45 fda85ea40df948188f0b765379c5f5b0
+msgid "Step2: Start Training"
+msgstr "第二步：开始训练"
+
+#: ../../source/training/verl.md:47 24994606b01b452abb1f3c487862bf57
+msgid "In verl, training frameworks and inference frameworks can be combined freely, as long as the training framework and inference framework themselves support model training and inference tasks, so that verl can support RL-related training."
+msgstr "在 verl 中，训练框架和推理框架可以自由组合，只要训练框架和推理框架本身支持模型训练和推理任务，verl 就能够支持与强化学习（RL）相关的训练。"
+
+#: ../../source/training/verl.md:49 3f8ac764b49c42a2bd5a673461866371
+msgid "Below is an example using FSDP and vLLM to demonstrate how to train Qwen3 models in verl. We chose Qwen3-1.7B as the example, as it only requires a single 80GB GPU and a machine with more than 64GB of memory to start training."
+msgstr "以下是一个使用 FSDP 和 vLLM 的示例，展示如何在 verl 中训练 Qwen3 模型。我们选择了Qwen3-1.7B作为例子，因为他仅需使用一张80GB显存的显卡，以及大于64G内存的机器即可开始训练。"
+
+#: ../../source/training/verl.md:92 8b8ed7d9463c4a8086d5fe1a452b34e0
+msgid "Finally"
+msgstr "结束语"
+
+#: ../../source/training/verl.md:94 294699cc5278422f85beebb282ad0c2a
+msgid "If you encounter any difficulties during use, please join the discussion at [GitHub](https://github.com/volcengine/verl/discussions)."
+msgstr "如果在使用过程中遇到任何困难，请在 [GitHub](https://github.com/volcengine/verl/discussions) 参与讨论。"
+

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/requirements-docs.txt

@@ -0,0 +1,5 @@
+furo
+myst-parser==4.0.0
+sphinx<8,>4.5.0
+sphinx-copybutton
+sphinx-design>=0.6.0

docs/source/_static/css/custom.css

@@ -0,0 +1,87 @@
+html {
+    font-size: 16px;
+}
+
+h1 {
+    font-size: 1.75rem;
+    line-height: 2.5rem;
+}
+
+h2 {
+    font-size: 1.5rem;
+    line-height: 2rem;
+}
+
+h3 {
+    font-size: 1.25rem;
+    line-height: 1.75rem;
+}
+
+h4 {
+    font-size: 1.125rem;
+    line-height: 1.5rem;
+}
+
+h5 {
+    font-size: 1rem;
+}
+
+h6 {
+    font-size: 0.75rem;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+    margin-top: 1.875rem;
+    margin-bottom: 1rem;
+}
+
+p strong {
+    font-weight: 500;
+}
+
+p:target {
+    background-color: var(--color-highlight-on-target);
+}
+
+details.sd-dropdown summary.sd-summary-title {
+    flex-direction: row-reverse;
+    font-weight: 500;
+    padding-left: 0;
+}
+
+details.sd-dropdown summary.sd-summary-title code.literal {
+    font-weight: bolder;
+    filter: brightness(95%);
+}
+
+details.sd-dropdown summary.sd-summary-title span.sd-summary-state-marker {
+    padding-left: 0.5em;
+    padding-right: 0.5em
+}
+
+details.sd-dropdown div.sd-summary-content {
+    padding-left: 2.5em;
+}
+
+pre.terminal {
+    font-size: 12px !important;
+    line-height: 16px;
+    background-color: black;
+    color: white;
+    padding: .5em;
+    text-wrap: wrap;
+    word-break: break-all;
+}
+
+pre.terminal span.system {
+    color: greenyellow
+}
+
+pre.terminal span.user {
+    color: yellowgreen
+}

docs/source/_static/design-tabs.js

@@ -0,0 +1,107 @@
+// @ts-check
+
+// Extra JS capability for selected tabs to be synced
+// The selection is stored in local storage so that it persists across page loads.
+
+/**
+ * @type {Record<string, HTMLElement[]>}
+ */
+let sd_id_to_elements = {};
+const storageKeyPrefix = "sphinx-design-tab-id-";
+
+/**
+ * Create a key for a tab element.
+ * @param {HTMLElement} el - The tab element.
+ * @returns {[string, string, string] | null} - The key.
+ *
+ */
+function create_key(el) {
+  let syncId = el.getAttribute("data-sync-id");
+  let syncGroup = el.getAttribute("data-sync-group");
+  if (!syncId || !syncGroup) return null;
+  return [syncGroup, syncId, syncGroup + "--" + syncId];
+}
+
+/**
+ * Initialize the tab selection.
+ *
+ */
+function ready() {
+  // Find all tabs with sync data
+
+  /** @type {string[]} */
+  let groups = [];
+
+  document.querySelectorAll(".sd-tab-label").forEach((label) => {
+    if (label instanceof HTMLElement) {
+      let data = create_key(label);
+      if (data) {
+        let [group, id, key] = data;
+
+        // add click event listener
+        // @ts-ignore
+        label.onclick = onSDLabelClick;
+
+        // store map of key to elements
+        if (!sd_id_to_elements[key]) {
+          sd_id_to_elements[key] = [];
+        }
+        sd_id_to_elements[key].push(label);
+
+        if (groups.indexOf(group) === -1) {
+          groups.push(group);
+          // Check if a specific tab has been selected via URL parameter
+          const tabParam = new URLSearchParams(window.location.search).get(
+            group
+          );
+          if (tabParam) {
+            console.log(
+              "sphinx-design: Selecting tab id for group '" +
+              group +
+              "' from URL parameter: " +
+              tabParam
+            );
+            window.sessionStorage.setItem(storageKeyPrefix + group, tabParam);
+          }
+        }
+
+        // Check is a specific tab has been selected previously
+        let previousId = window.sessionStorage.getItem(
+          storageKeyPrefix + group
+        );
+        if (previousId === id) {
+          // console.log(
+          //   "sphinx-design: Selecting tab from session storage: " + id
+          // );
+          // @ts-ignore
+          label.previousElementSibling.checked = true;
+        }
+      }
+    }
+  });
+}
+
+/**
+ *  Activate other tabs with the same sync id.
+ *
+ * @this {HTMLElement} - The element that was clicked.
+ */
+function onSDLabelClick() {
+  let data = create_key(this);
+  if (!data) return;
+  const top = this.parentElement?.offsetTop || 0;
+  console.log(top);
+  let [group, id, key] = data;
+  for (const label of sd_id_to_elements[key]) {
+    if (label === this) continue;
+    // @ts-ignore
+    label.previousElementSibling.checked = true;
+  }
+  const diff = (this.parentElement?.offsetTop || 0) - top;
+  if (diff !== 0) {
+    window.scrollBy({ left: 0, top: diff, behavior: "instant" });
+  }
+  window.sessionStorage.setItem(storageKeyPrefix + group, id);
+}
+
+document.addEventListener("DOMContentLoaded", ready, false);

docs/source/assets/qwen3_nonthinking.jinja

@@ -0,0 +1,86 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n<think>\n\n</think>\n\n' }}
+{%- endif %}

docs/source/conf.py

@@ -0,0 +1,120 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+
+import sys
+from sphinx.ext import autodoc
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+# -- Project information -----------------------------------------------------
+
+project = "C9-AI"
+copyright = "2025, C9-AI Team"
+author = "C9-AI Team"
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.intersphinx",
+    # "sphinx_copybutton",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "myst_parser",
+    "sphinx_design",
+]
+
+myst_enable_extensions = ["colon_fence", "attrs_block", "attrs_inline", "fieldlist"]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+# Exclude the prompt "$" when copying code
+copybutton_prompt_text = r"\$ "
+copybutton_prompt_is_regexp = True
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_title = project
+html_theme = "furo"
+# html_logo = 'assets/logo/qwen.png'
+# html_theme_options = {
+#     'path_to_docs': 'docs/source',
+#     'repository_url': 'https://github.com/QwenLM/Qwen2',
+#     # 'use_repository_button': True,
+# }
+html_sidebars = {
+    "**": [
+        "sidebar/scroll-start.html",
+        "sidebar/brand.html",
+        "sidebar/navigation.html",
+        "sidebar/ethical-ads.html",
+        "sidebar/scroll-end.html",
+    ]
+}
+
+# multi-language docs
+language = "en"
+locale_dirs = ["../locales/"]  # path is example but recommended.
+gettext_compact = False  # optional.
+gettext_uuid = True  # optional.
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+html_css_files = [
+    "css/custom.css",
+]
+# FIXME: figure out why this file is not copied
+html_js_files = [
+    "design-tabs.js",
+]
+
+# Mock out external dependencies here.
+autodoc_mock_imports = ["torch", "transformers"]
+
+for mock_target in autodoc_mock_imports:
+    if mock_target in sys.modules:
+        logger.info(
+            f"Potentially problematic mock target ({mock_target}) found; "
+            "autodoc_mock_imports cannot mock modules that have already "
+            "been loaded into sys.modules when the sphinx build starts."
+        )
+
+
+class MockedClassDocumenter(autodoc.ClassDocumenter):
+    """Remove note about base class when a class is derived from object."""
+
+    def add_line(self, line: str, source: str, *lineno: int) -> None:
+        if line == "   Bases: :py:class:`object`":
+            return
+        super().add_line(line, source, *lineno)
+
+
+autodoc.ClassDocumenter = MockedClassDocumenter
+
+navigation_with_keys = False

docs/source/deployment/dstack.rst

@@ -0,0 +1,161 @@
+dstack
+========
+
+`dstack <https://github.com/dstackai/dstack>`__ is an open-source alternative to Kubernetes and Slurm, designed to simplify GPU allocation and AI workload orchestration for ML teams across top clouds, on-prem clusters, and accelerators.
+
+Prerequisites
+----------------
+Before you start, install dstack by following the `installation instructions <https://dstack.ai/docs/installation/>`__. Once dstack server is up, you can initialize your workspace
+as shown below:
+
+.. code:: bash
+   
+   mkdir dstack-qwen-deploy && cd dstack-qwen-deploy
+   dstack init
+
+Deploy Qwen3-30B-A3B
+-----------------------------------------------
+
+Deploy ``Qwen3-30B-A3B`` on instances available with cloud providers configured in your ``~/.dstack/server/config.yml`` file.
+
+You can use ``SgLang``, ``TGI`` or ``vLLM`` to serve the model. Here we use ``SgLang`` as an example. 
+
+Create a `service <https://dstack.ai/docs/concepts/services/>`__ configuration file named ``serve-30b.dstack.yml`` with the following content:
+   
+.. code:: yaml
+
+    type: service
+    name: qwen3-30b-a3b
+
+    image: lmsysorg/sglang:latest
+    env:
+      - MODEL_ID=Qwen/Qwen3-30B-A3B
+
+    commands:
+      - python3 -m sglang.launch_server
+            --model-path $MODEL_ID
+            --port 8000
+            --trust-remote-code
+
+    port: 8000
+    model: Qwen/Qwen3-30B-A3B
+
+    resources:
+      gpu: 80GB:1
+      
+
+
+.. note::
+   For other inference backends such as vLLM or TGI, visit the `dstack Inference Examples <https://dstack.ai/examples/#inference>`__ documentation.
+
+Go ahead and apply the service configuration:
+
+.. code:: bash
+       
+    dstack apply -f serve-30b.dstack.yml
+
+Access the Service
+--------------------
+
+After the service is successfully deployed, you can access the service's endpoint in the following ways:
+
+.. tab-set::
+
+    .. tab-item:: CURL
+       
+      Access through service endpoint at ``<dstack server URL>/proxy/services/<project name>/<run name>/``
+
+      .. code:: bash
+
+            curl http://localhost:3000/proxy/services/main/qwen3-30b-a3b/v1/chat/completions \
+                -H 'Content-Type: application/json' \
+                -H 'Authorization: Bearer <dstack token>' \
+                -d '{
+                    "model": "Qwen/Qwen3-30B-A3B",
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": "Compose a poem that explains the concept of recursion in programming."
+                        }
+                    ]
+            }'
+
+      .. note::
+          When starting the dstack server, an admin token is automatically generated:
+
+          .. code:: bash 
+
+              The admin token is "bbae0f28-d3dd-4820-bf61-8f4bb40815da"
+              The server is running at http://127.0.0.1:3000/
+
+    .. tab-item:: Chat UI
+
+       Access through dstack's Chat UI at ``<dstack server URL>/projects/<project name>/models/<run name>/``
+
+       .. image:: https://dstack.ai/static-assets/static-assets/images//dstack-qwen-ui.png
+
+
+.. dropdown:: Gateway
+    :icon: info
+    :animate: fade-in
+
+    Running services for development purposes doesn't require setting up a gateway.
+
+    However, you'll need a gateway in the following cases:
+
+    * To use auto-scaling or rate limits
+    * To enable HTTPS for the endpoint and map it to your domain
+    * If your service requires WebSockets
+    * If your service cannot work with a path prefix
+
+    For detailed information about gateway configuration and usage, refer to the `dstack documentation on gateways <https://dstack.ai/docs/concepts/gateways/>`__.
+
+Replicas and Auto Scaling
+----------------------------------------
+
+You can auto scale the service by specifying additional configurations in the ``serve-30b.dstack.yml``. 
+
+- Set ``replicas: min..max`` to define the minimum and maximum number of replicas
+- Configure ``scaling`` rules to determine when to scale up or down
+
+Below is a complete configuration example with auto-scaling enabled:
+
+.. code:: yaml
+
+    type: service
+    name: qwen3-30b-a3b
+
+    image: lmsysorg/sglang:latest
+    env:
+      - MODEL_ID=Qwen/Qwen3-30B-A3B
+
+    commands:
+      - python3 -m sglang.launch_server
+            --model-path $MODEL_ID
+            --port 8000
+            --trust-remote-code
+
+    port: 8000
+    model: Qwen/Qwen3-30B-A3B
+
+    resources:
+      gpu: 80GB:1
+    
+    # Minimum and maximum number of replicas
+    replicas: 1..4
+    scaling:
+      # Requests per seconds
+      metric: rps
+      # Target metric value
+      target: 10
+
+.. note::
+   The scaling property requires a gateway to be set up.
+
+See also
+------------
+- **Fleets**: Create cloud and on-prem clusters using `Fleets <https://dstack.ai/docs/concepts/fleets/>`__.
+- **Dev Environments**: Experiment and test before deploying to production using `Dev Environments <https://dstack.ai/docs/concepts/dev-environments/>`__.
+- **Tasks**: Schedule single node or distributed training using `Tasks <https://dstack.ai/docs/concepts/tasks/>`__.
+- **Services**: Deploy models as secure, auto-scaling OpenAI-compatible endpoints using `Services <https://dstack.ai/docs/concepts/services/>`__.
+- **Metrics**: Monitor performance with automatically tracked metrics via CLI or UI using `Metrics <https://dstack.ai/docs/guides/metrics/>`__.

docs/source/deployment/openllm.rst

@@ -0,0 +1,125 @@
+OpenLLM
+=======
+
+.. attention:: 
+    To be updated for Qwen3.
+
+OpenLLM allows developers to run Qwen2.5 models of different sizes as OpenAI-compatible APIs with a single command. It features a built-in chat UI, state-of-the-art inference backends, and a simplified workflow for creating enterprise-grade cloud deployment with Qwen2.5. Visit `the OpenLLM repository <https://github.com/bentoml/OpenLLM/>`_ to learn more.
+
+Installation
+------------
+
+Install OpenLLM using ``pip``.
+
+.. code:: bash
+
+   pip install openllm
+
+Verify the installation and display the help information:
+
+.. code:: bash
+
+   openllm --help
+
+Quickstart
+----------
+
+Before you run any Qwen2.5 model, ensure your model repository is up to date by syncing it with OpenLLM's latest official repository.
+
+.. code:: bash
+
+   openllm repo update
+
+List the supported Qwen2.5 models:
+
+.. code:: bash
+
+   openllm model list --tag qwen2.5
+
+The results also display the required GPU resources and supported platforms:
+
+.. code:: bash
+
+   model    version                repo     required GPU RAM    platforms
+   -------  ---------------------  -------  ------------------  -----------
+   qwen2.5  qwen2.5:0.5b           default  12G                 linux
+            qwen2.5:1.5b           default  12G                 linux
+            qwen2.5:3b             default  12G                 linux
+            qwen2.5:7b             default  24G                 linux
+            qwen2.5:14b            default  80G                 linux
+            qwen2.5:14b-ggml-q4    default                      macos
+            qwen2.5:14b-ggml-q8    default                      macos
+            qwen2.5:32b            default  80G                 linux
+            qwen2.5:32b-ggml-fp16  default                      macos
+            qwen2.5:72b            default  80Gx2               linux
+            qwen2.5:72b-ggml-q4    default                      macos
+
+To start a server with one of the models, use ``openllm serve`` like this:
+
+.. code:: bash
+
+   openllm serve qwen2.5:7b
+
+By default, the server starts at ``http://localhost:3000/``.
+
+Interact with the model server
+------------------------------
+
+With the model server up and running, you can call its APIs in the following ways:
+
+.. tab-set::
+
+    .. tab-item:: CURL
+
+       Send an HTTP request to its ``/generate`` endpoint via CURL:
+
+       .. code-block:: bash
+
+            curl -X 'POST' \
+               'http://localhost:3000/api/generate' \
+               -H 'accept: text/event-stream' \
+               -H 'Content-Type: application/json' \
+               -d '{
+               "prompt": "Tell me something about large language models.",
+               "model": "Qwen/Qwen2.5-7B-Instruct",
+               "max_tokens": 2048,
+               "stop": null
+            }'
+
+    .. tab-item:: Python client
+
+       Call the OpenAI-compatible endpoints with frameworks and tools that support the OpenAI API protocol. Here is an example:
+
+       .. code-block:: python
+
+            from openai import OpenAI
+
+            client = OpenAI(base_url='http://localhost:3000/v1', api_key='na')
+
+            # Use the following func to get the available models
+            # model_list = client.models.list()
+            # print(model_list)
+
+            chat_completion = client.chat.completions.create(
+               model="Qwen/Qwen2.5-7B-Instruct",
+               messages=[
+                  {
+                        "role": "user",
+                        "content": "Tell me something about large language models."
+                  }
+               ],
+               stream=True,
+            )
+            for chunk in chat_completion:
+               print(chunk.choices[0].delta.content or "", end="")
+
+    .. tab-item:: Chat UI
+
+       OpenLLM provides a chat UI at the ``/chat`` endpoint for the LLM server at http://localhost:3000/chat.
+
+       .. image:: ../../source/assets/qwen-openllm-ui-demo.png
+
+Model repository
+----------------
+
+A model repository in OpenLLM represents a catalog of available LLMs. You can add your own repository to OpenLLM with custom Qwen2.5 variants for your specific needs. See our `documentation to learn details <https://github.com/bentoml/OpenLLM?tab=readme-ov-file#model-repository>`_.

docs/source/deployment/sglang.md

@@ -0,0 +1,244 @@
+# SGLang
+
+[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models.
+
+To learn more about SGLang, please refer to the [documentation](https://docs.sglang.ai/).
+
+## Environment Setup
+
+By default, you can install `sglang` with pip in a clean environment:
+
+```shell
+pip install "sglang[all]>=0.4.6.post1"
+```
+
+If you have encountered issues in installation, please feel free to check the official document for installation ([link](https://docs.sglang.ai/start/install.html)).
+
+## API Service
+
+It is easy to build an OpenAI-compatible API service with SGLang, which can be deployed as a server that implements OpenAI API protocol.
+By default, it starts the server at `http://localhost:30000`. 
+You can specify the address with `--host` and `--port` arguments. 
+Run the command as shown below:
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B
+```
+
+By default, if the `--model-path` does not point to a valid local directory, it will download the model files from the Hugging Face Hub.
+To download model from ModelScope, set the following before running the above command:
+```shell
+export SGLANG_USE_MODELSCOPE=true
+```
+
+For distributed inference with tensor parallelism, it is as simple as
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B --tensor-parallel-size 4
+```
+The above command will use tensor parallelism on 4 GPUs.
+You should change the number of GPUs according to your demand.
+
+### Basic Usage
+
+Then, you can use the [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) to communicate with Qwen:
+
+::::{tab-set}
+
+:::{tab-item} curl
+```shell
+curl http://localhost:30000/v1/chat/completions -H "Content-Type: application/json" -d '{
+  "model": "Qwen/Qwen3-8B",
+  "messages": [
+    {"role": "user", "content": "Give me a short introduction to large language models."}
+  ],
+  "temperature": 0.6,
+  "top_p": 0.95,
+  "top_k": 20,
+  "max_tokens": 32768
+}'
+```
+:::
+
+:::{tab-item} Python
+You can use the API client with the `openai` Python SDK as shown below:
+
+```python
+from openai import OpenAI
+# Set OpenAI's API key and API base to use SGLang's API server.
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:30000/v1"
+
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3-8B",
+    messages=[
+        {"role": "user", "content": "Give me a short introduction to large language models."},
+    ],
+    max_tokens=32768,
+    temperature=0.6,
+    top_p=0.95,
+    extra_body={
+        "top_k": 20,
+    }, 
+)
+print("Chat response:", chat_response)
+```
+::::
+
+:::{tip}
+While the default sampling parameters would work most of the time for thinking mode,
+it is recommended to adjust the sampling parameters according to your application, 
+and always pass the sampling parameters to the API.
+:::
+
+
+### Thinking & Non-Thinking Modes
+
+Qwen3 models will think before respond.
+This behavior could be controlled by either the hard switch, which could disable thinking completely, or the soft switch, where the model follows the instruction of the user on whether it should think.
+
+The hard switch is available in SGLang through the following configuration to the API call.
+To disable thinking, use
+
+::::{tab-set}
+
+:::{tab-item} curl
+```shell
+curl http://localhost:30000/v1/chat/completions -H "Content-Type: application/json" -d '{
+  "model": "Qwen/Qwen3-8B",
+  "messages": [
+    {"role": "user", "content": "Give me a short introduction to large language models."}
+  ],
+  "temperature": 0.7,
+  "top_p": 0.8,
+  "top_k": 20,
+  "max_tokens": 8192,
+  "presence_penalty": 1.5,
+  "chat_template_kwargs": {"enable_thinking": false}
+}'
+```
+:::
+
+:::{tab-item} Python
+You can use the API client with the `openai` Python SDK as shown below:
+
+```python
+from openai import OpenAI
+# Set OpenAI's API key and API base to use SGLang's API server.
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:30000/v1"
+
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3-8B",
+    messages=[
+        {"role": "user", "content": "Give me a short introduction to large language models."},
+    ],
+    max_tokens=8192,
+    temperature=0.7,
+    top_p=0.8,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20,
+        "chat_template_kwargs": {"enable_thinking": True},
+    },
+)
+print("Chat response:", chat_response)
+```
+::::
+
+:::{note}
+Please note that passing `enable_thinking` is not OpenAI API compatible.
+The exact method may differ among frameworks.
+:::
+
+:::{tip}
+To completely disable thinking, you could use [a custom chat template](../../source/assets/qwen3_nonthinking.jinja) when starting the model:
+
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B --chat-template ./qwen3_nonthinking.jinja
+```
+
+The chat template prevents the model from generating thinking content, even if the user instructs the model to do so with `/think`.
+:::
+
+
+:::{tip}
+It is recommended to set sampling parameters differently for thinking and non-thinking modes.
+:::
+
+### Parsing Thinking Content
+
+SGLang supports parsing the thinking content from the model generation into structured messages:
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B --reasoning-parser qwen3
+```
+
+The response message will have a field named `reasoning_content` in addition to `content`, containing the thinking content generated by the model.
+
+:::{note}
+Please note that this feature is not OpenAI API compatible.
+:::
+
+:::{important}
+`enable_thinking=False` may not be compatible with this feature.
+If you need to pass `enable_thinking=False` to the API, please consider disabling parsing thinking content.
+:::
+
+### Parsing Tool Calls
+
+SGLang supports parsing the tool calling content from the model generation into structured messages:
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B --tool-call-parser qwen25
+```
+
+For more information, please refer to [our guide on Function Calling](../framework/function_call.md).
+
+### Structured/JSON Output
+
+SGLang supports structured/JSON output. 
+Please refer to [SGLang's documentation](https://docs.sglang.ai/backend/structured_outputs.html#OpenAI-Compatible-API).
+Besides, it is also recommended to instruct the model to generate the specific format in the system message or in your prompt.
+
+### Serving Quantized models
+
+Qwen3 comes with two types of pre-quantized models, FP8 and AWQ.
+
+The command serving those models are the same as the original models except for the name change:
+```shell
+# For FP8 quantized model
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B-FP8
+
+# For AWQ quantized model
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B-AWQ
+```
+
+### Context Length
+
+The context length for Qwen3 models in pretraining is up to 32,768 tokens.
+To handle context length substantially exceeding 32,768 tokens, RoPE scaling techniques should be applied.
+We have validated the performance of [YaRN](https://arxiv.org/abs/2309.00071), a technique for enhancing model length extrapolation, ensuring optimal performance on lengthy texts.
+
+SGLang supports YaRN, which can be configured as
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-8B --json-model-override-args '{"rope_scaling":{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}}' --context-length 131072
+```
+
+:::{note}
+SGLang implements 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. 
+:::
+
+:::{note}
+The default `max_position_embeddings` in `config.json` is set to 40,960, which is used by SGLang.
+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 and leave adequate room for model thinking.
+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.
+:::

docs/source/deployment/skypilot.rst

@@ -0,0 +1,209 @@
+SkyPilot
+========
+
+.. attention:: 
+    To be updated for Qwen3.
+
+What is SkyPilot
+----------------
+
+SkyPilot is a framework for running LLMs, AI, and batch jobs on any
+cloud, offering maximum cost savings, the highest GPU availability, and
+managed execution. Its features include:
+
+-  Get the best GPU availability by utilizing multiple resources pools
+   across multiple regions and clouds.
+-  Pay absolute minimum — SkyPilot picks the cheapest resources across
+   regions and clouds. No managed solution markups.
+-  Scale up to multiple replicas across different locations and
+   accelerators, all served with a single endpoint
+-  Everything stays in your cloud account (your VMs & buckets)
+-  Completely private - no one else sees your chat history
+
+Install SkyPilot
+----------------
+
+We advise you to follow the
+`instruction <https://skypilot.readthedocs.io/en/latest/getting-started/installation.html>`__
+to install SkyPilot. Here we provide a simple example of using ``pip``
+for the installation as shown below.
+
+.. code:: bash
+
+   # You can use any of the following clouds that you have access to:
+   # aws, gcp, azure, oci, lamabda, runpod, fluidstack, paperspace,
+   # cudo, ibm, scp, vsphere, kubernetes
+   pip install "skypilot-nightly[aws,gcp]"
+
+After that, you need to verify cloud access with a command like:
+
+.. code:: bash
+
+   sky check
+
+For more information, check the `official document <https://skypilot.readthedocs.io/en/latest/getting-started/installation.html>`__ and see if you have
+set up your cloud accounts correctly.
+
+Alternatively, you can also use the official docker image with SkyPilot
+master branch automatically cloned by running:
+
+.. code:: bash
+
+   # NOTE: '--platform linux/amd64' is needed for Apple Silicon Macs
+   docker run --platform linux/amd64 \
+     -td --rm --name sky \
+     -v "$HOME/.sky:/root/.sky:rw" \
+     -v "$HOME/.aws:/root/.aws:rw" \
+     -v "$HOME/.config/gcloud:/root/.config/gcloud:rw" \
+     berkeleyskypilot/skypilot-nightly
+
+   docker exec -it sky /bin/bash
+
+Running Qwen2.5-72B-Instruct with SkyPilot
+------------------------------------------
+
+1. Start serving Qwen2.5-72B-Instruct on a single instance with any
+   available GPU in the list specified in
+   `serve-72b.yaml <https://github.com/skypilot-org/skypilot/blob/master/llm/qwen/serve-72b.yaml>`__
+   with a vLLM-powered OpenAI-compatible endpoint:
+   
+   .. code:: bash
+
+      sky launch -c qwen serve-72b.yaml
+
+   **Before launching, make sure you have changed Qwen/Qwen2-72B-Instruct to Qwen/Qwen2.5-72B-Instruct in the YAML file.**
+
+2. Send a request to the endpoint for completion:
+
+   .. code:: bash
+
+      IP=$(sky status --ip qwen)
+
+      curl -L http://$IP:8000/v1/completions \
+         -H "Content-Type: application/json" \
+         -d '{
+            "model": "Qwen/Qwen2.5-72B-Instruct",
+            "prompt": "My favorite food is",
+            "max_tokens": 512
+      }' | jq -r '.choices[0].text'
+
+3. Send a request for chat completion:
+
+   .. code:: bash
+
+      curl -L http://$IP:8000/v1/chat/completions \
+         -H "Content-Type: application/json" \
+         -d '{
+            "model": "Qwen/Qwen2.5-72B-Instruct",
+            "messages": [
+            {
+               "role": "system",
+               "content": "You are Qwen, created by Alibaba Cloud. You are a helpful and honest chat expert."
+            },
+            {
+               "role": "user",
+               "content": "What is the best food?"
+            }
+            ],
+            "max_tokens": 512
+      }' | jq -r '.choices[0].message.content'
+
+Scale up the service with SkyPilot Serve
+----------------------------------------
+
+1. With `SkyPilot
+   Serve <https://skypilot.readthedocs.io/en/latest/serving/sky-serve.html>`__,
+   a serving library built on top of SkyPilot, scaling up the Qwen
+   service is as simple as running:
+
+   .. code:: bash
+
+      sky serve up -n qwen ./serve-72b.yaml
+
+   **Before launching, make sure you have changed Qwen/Qwen2-72B-Instruct to Qwen/Qwen2.5-72B-Instruct in the YAML file.**
+
+   This will start the service with multiple replicas on the cheapest
+   available locations and accelerators. SkyServe will automatically manage
+   the replicas, monitor their health, autoscale based on load, and restart
+   them when needed.
+
+   A single endpoint will be returned and any request sent to the endpoint
+   will be routed to the ready replicas.
+
+2. To check the status of the service, run:
+
+   .. code:: bash
+
+      sky serve status qwen
+
+   After a while, you will see the following output:
+
+   ::
+
+      Services
+      NAME        VERSION  UPTIME  STATUS        REPLICAS  ENDPOINT            
+      Qwen  1        -       READY         2/2       3.85.107.228:30002  
+
+      Service Replicas
+      SERVICE_NAME  ID  VERSION  IP  LAUNCHED    RESOURCES                   STATUS REGION  
+      Qwen          1   1        -   2 mins ago  1x Azure({'A100-80GB': 8}) READY  eastus  
+      Qwen          2   1        -   2 mins ago  1x GCP({'L4': 8})          READY  us-east4-a 
+
+   As shown, the service is now backed by 2 replicas, one on Azure and one
+   on GCP, and the accelerator type is chosen to be **the cheapest
+   available one** on the clouds. That said, it maximizes the availability
+   of the service while minimizing the cost.
+
+3. To access the model, we use a ``curl -L`` command (``-L`` to follow
+   redirect) to send the request to the endpoint:
+
+   .. code:: bash
+
+      ENDPOINT=$(sky serve status --endpoint qwen)
+
+      curl -L http://$ENDPOINT/v1/chat/completions \
+         -H "Content-Type: application/json" \
+         -d '{
+            "model": "Qwen/Qwen2.5-72B-Instruct",
+            "messages": [
+            {
+               "role": "system",
+               "content": "You are Qwen, created by Alibaba Cloud. You are a helpful and honest code assistant expert in Python."
+            },
+            {
+               "role": "user",
+               "content": "Show me the python code for quick sorting a list of integers."
+            }
+            ],
+            "max_tokens": 512
+      }' | jq -r '.choices[0].message.content'
+
+Accessing Qwen2.5 with Chat GUI
+---------------------------------------------
+
+It is also possible to access the Qwen2.5 service with GUI by connecting a
+`FastChat GUI server <https://github.com/lm-sys/FastChat>`__ to the endpoint launched
+above (see `gui.yaml <https://github.com/skypilot-org/skypilot/blob/master/llm/qwen/gui.yaml>`__).
+
+1. Start the Chat Web UI:
+
+   .. code:: bash
+
+      sky launch -c qwen-gui ./gui.yaml --env ENDPOINT=$(sky serve status --endpoint qwen)
+
+   **Before launching, make sure you have changed Qwen/Qwen1.5-72B-Chat to Qwen/Qwen2.5-72B-Instruct in the YAML file.**
+
+2. Then, we can access the GUI at the returned gradio link:
+
+   ::
+
+      | INFO | stdout | Running on public URL: https://6141e84201ce0bb4ed.gradio.live
+
+   Note that you may get better results by using a different temperature and top_p value.
+
+Summary
+-------
+
+With SkyPilot, it is easy for you to deploy Qwen2.5 on any cloud. We
+advise you to read the official doc for more usages and updates.
+Check `this <https://skypilot.readthedocs.io/>`__ out!

docs/source/deployment/tgi.rst

@@ -0,0 +1,190 @@
+TGI
+=====================
+
+.. attention:: 
+    To be updated for Qwen3.
+
+Hugging Face's Text Generation Inference (TGI) is a production-ready framework specifically designed for deploying and serving large language models (LLMs) for text generation tasks. It offers a seamless deployment experience, powered by a robust set of features:
+
+* `Speculative Decoding <Speculative Decoding_>`_: Accelerates generation speeds.
+* `Tensor Parallelism`_: Enables efficient deployment across multiple GPUs.
+* `Token Streaming`_: Allows for the continuous generation of text.
+* Versatile Device Support: Works seamlessly with `AMD`_, `Gaudi`_ and `AWS Inferentia`_.
+
+.. _AMD: https://rocm.docs.amd.com/en/latest/how-to/rocm-for-ai/deploy-your-model.html#serving-using-hugging-face-tgi
+.. _Gaudi: https://github.com/huggingface/tgi-gaudi
+.. _AWS Inferentia: https://aws.amazon.com/blogs/machine-learning/announcing-the-launch-of-new-hugging-face-llm-inference-containers-on-amazon-sagemaker/#:~:text=Get%20started%20with%20TGI%20on%20SageMaker%20Hosting
+.. _Tensor Parallelism: https://huggingface.co/docs/text-generation-inference/conceptual/tensor_parallelism
+.. _Token Streaming: https://huggingface.co/docs/text-generation-inference/conceptual/streaming
+
+Installation
+-----------------
+
+The easiest way to use TGI is via the TGI docker image. In this guide, we show how to use TGI with docker.
+
+It's possible to run it locally via Conda or build locally. Please refer to `Installation Guide <https://huggingface.co/docs/text-generation-inference/installation>`_  and `CLI tool <https://huggingface.co/docs/text-generation-inference/en/basic_tutorials/using_cli>`_ for detailed instructions.
+
+Deploy Qwen2.5 with TGI
+-----------------------
+
+1. **Find a Qwen2.5 Model:** Choose a model from `the Qwen2.5 collection <https://huggingface.co/collections/Qwen/qwen25-66e81a666513e518adb90d9e>`_.
+2. **Deployment Command:** Run the following command in your terminal, replacing ``model`` with your chosen Qwen2.5 model ID and ``volume`` with the path to your local data directory:
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model
+
+
+Using TGI API
+-------------
+
+Once deployed, the model will be available on the mapped port (8080).
+
+TGI comes with a handy API for streaming response:
+
+.. code:: bash
+
+   curl http://localhost:8080/generate_stream -H 'Content-Type: application/json' \
+           -d '{"inputs":"Tell me something about large language models.","parameters":{"max_new_tokens":512}}'
+
+
+It's also available on OpenAI style API:
+
+.. code:: bash
+
+    curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
+      "model": "",
+      "messages": [
+        {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
+        {"role": "user", "content": "Tell me something about large language models."}
+      ],
+      "temperature": 0.7,
+      "top_p": 0.8,
+      "repetition_penalty": 1.05,
+      "max_tokens": 512
+    }'
+
+
+.. note::
+
+   The model field in the JSON is not used by TGI, you can put anything. 
+
+Refer to the `TGI Swagger UI <https://huggingface.github.io/text-generation-inference/#/Text%20Generation%20Inference/completions>`_ for a complete API reference.
+
+You can also use Python API:
+
+.. code:: python
+
+   from openai import OpenAI
+   
+   # initialize the client but point it to TGI
+   client = OpenAI(
+      base_url="http://localhost:8080/v1/",  # replace with your endpoint url
+      api_key="",  # this field is not used when running locally
+   )
+   chat_completion = client.chat.completions.create(
+      model="",  # it is not used by TGI, you can put anything
+      messages=[
+         {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
+         {"role": "user", "content": "Tell me something about large language models."},
+      ],
+      stream=True,
+      temperature=0.7,
+      top_p=0.8,
+      max_tokens=512,
+   )
+
+   # iterate and print stream
+   for message in chat_completion:
+      print(message.choices[0].delta.content, end="")
+
+
+Quantization for Performance
+----------------------------
+
+1. Data-dependent quantization (GPTQ and AWQ)
+
+Both GPTQ and AWQ models are data-dependent. The official quantized models can be found from `the Qwen2.5 collection`_ and you can also quantize models with your own dataset to make it perform better on your use case. 
+
+The following shows the command to start TGI with Qwen2.5-7B-Instruct-GPTQ-Int4:
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct-GPTQ-Int4
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model --quantize gptq
+
+
+If the model is quantized with AWQ, e.g. Qwen/Qwen2.5-7B-Instruct-AWQ, please use ``--quantize awq``.
+
+2. Data-agnostic quantization
+
+EETQ on the other side is not data dependent and can be used with any model. Note that we're passing in the original model (instead of a quantized model) with the ``--quantize eetq`` flag.
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model --quantize eetq
+
+
+
+Multi-Accelerators Deployment
+-----------------------------
+
+Use the ``--num-shard`` flag to specify the number of accelerators. Please also use ``--shm-size 1g`` to enable shared memory for optimal NCCL performance (`reference <https://github.com/huggingface/text-generation-inference?tab=readme-ov-file#a-note-on-shared-memory-shm>`__):
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model --num-shard 2
+
+
+Speculative Decoding
+--------------------
+
+Speculative decoding can reduce the time per token by speculating on the next token. Use the ``--speculative-decoding`` flag, setting the value to the number of tokens to speculate on (default: 0 for no speculation):
+
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model --speculate 2
+
+
+The overall performance of speculative decoding highly depends on the type of task. It works best for code or highly repetitive text.
+
+More context on speculative decoding can be found `here <https://huggingface.co/docs/text-generation-inference/conceptual/speculation>`__.
+
+
+Zero-Code Deployment with HF Inference Endpoints
+---------------------------------------------------
+
+For effortless deployment, leverage Hugging Face Inference Endpoints:
+
+- **GUI interface:** `<https://huggingface.co/inference-endpoints/dedicated>`__
+- **Coding interface:** `<https://huggingface.co/blog/tgi-messages-api>`__
+
+Once deployed, the endpoint can be used as usual.
+
+
+Common Issues
+----------------
+
+Qwen2.5 supports long context lengths, so carefully choose the values for ``--max-batch-prefill-tokens``, ``--max-total-tokens``, and ``--max-input-tokens`` to avoid potential out-of-memory (OOM) issues. If an OOM occurs, you'll receive an error message upon startup. The following shows an example to modify those parameters:
+
+.. code:: bash
+
+   model=Qwen/Qwen2.5-7B-Instruct
+   volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
+
+   docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:2.0 --model-id $model --max-batch-prefill-tokens 4096 --max-total-tokens 4096 --max-input-tokens 2048

docs/source/deployment/vllm.md

@@ -0,0 +1,364 @@
+# vLLM
+
+We recommend you trying [vLLM](https://github.com/vllm-project/vllm) for your deployment of Qwen. 
+It is simple to use, and it is fast with state-of-the-art serving throughput, efficient management of attention key value memory with PagedAttention, continuous batching of input requests, optimized CUDA kernels, etc. 
+To learn more about vLLM, please refer to the [paper](https://arxiv.org/abs/2309.06180) and [documentation](https://docs.vllm.ai/).
+
+## Environment Setup
+
+By default, you can install `vllm` with pip in a clean environment:
+
+```shell
+pip install "vllm>=0.8.5"
+```
+
+Please note that the prebuilt `vllm` has strict dependencies on `torch` and its CUDA versions.
+Check the note in the official document for installation ([link](https://docs.vllm.ai/en/latest/getting_started/installation.html)) for more help.
+
+## API Service
+
+It is easy to build an OpenAI-compatible API service with vLLM, which can be deployed as a server that implements OpenAI API protocol.
+By default, it starts the server at `http://localhost:8000`. 
+You can specify the address with `--host` and `--port` arguments. 
+Run the command as shown below:
+```shell
+vllm serve Qwen/Qwen3-8B
+```
+
+By default, if the model does not point to a valid local directory, it will download the model files from the Hugging Face Hub.
+To download model from ModelScope, set the following before running the above command:
+```shell
+export VLLM_USE_MODELSCOPE=true
+```
+
+For distributed inference with tensor parallelism, it is as simple as
+```shell
+vllm serve Qwen/Qwen3-8B --tensor-parallel-size 4
+```
+The above command will use tensor parallelism on 4 GPUs.
+You should change the number of GPUs according to your demand.
+
+### Basic Usage
+
+Then, you can use the [create chat interface](https://platform.openai.com/docs/api-reference/chat/completions/create) to communicate with Qwen:
+
+::::{tab-set}
+
+:::{tab-item} curl
+```shell
+curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
+  "model": "Qwen/Qwen3-8B",
+  "messages": [
+    {"role": "user", "content": "Give me a short introduction to large language models."}
+  ],
+  "temperature": 0.6,
+  "top_p": 0.95,
+  "top_k": 20,
+  "max_tokens": 32768
+}'
+```
+:::
+
+:::{tab-item} Python
+You can use the API client with the `openai` Python SDK as shown below:
+
+```python
+from openai import OpenAI
+# Set OpenAI's API key and API base to use vLLM's API server.
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:8000/v1"
+
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3-8B",
+    messages=[
+        {"role": "user", "content": "Give me a short introduction to large language models."},
+    ],
+    max_tokens=32768,
+    temperature=0.6,
+    top_p=0.95,
+    extra_body={
+        "top_k": 20,
+    },
+)
+print("Chat response:", chat_response)
+```
+::::
+
+:::{tip}
+`vllm` will use the sampling parameters from the `generation_config.json` in the model files.
+
+While the default sampling parameters would work most of the time for thinking mode,
+it is recommended to adjust the sampling parameters according to your application, 
+and always pass the sampling parameters to the API.
+:::
+
+
+### Thinking & Non-Thinking Modes
+
+Qwen3 models will think before respond.
+This behavior could be controlled by either the hard switch, which could disable thinking completely, or the soft switch, where the model follows the instruction of the user on whether it should think.
+
+The hard switch is available in vLLM through the following configuration to the API call.
+To disable thinking, use
+
+::::{tab-set}
+
+:::{tab-item} curl
+```shell
+curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
+  "model": "Qwen/Qwen3-8B",
+  "messages": [
+    {"role": "user", "content": "Give me a short introduction to large language models."}
+  ],
+  "temperature": 0.7,
+  "top_p": 0.8,
+  "top_k": 20,
+  "max_tokens": 8192,
+  "presence_penalty": 1.5,
+  "chat_template_kwargs": {"enable_thinking": false}
+}'
+```
+:::
+
+:::{tab-item} Python
+You can use the API client with the `openai` Python SDK as shown below:
+
+```python
+from openai import OpenAI
+# Set OpenAI's API key and API base to use vLLM's API server.
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:8000/v1"
+
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3-8B",
+    messages=[
+        {"role": "user", "content": "Give me a short introduction to large language models."},
+    ],
+    max_tokens=8192,
+    temperature=0.7,
+    top_p=0.8,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20, 
+        "chat_template_kwargs": {"enable_thinking": False},
+    },
+)
+print("Chat response:", chat_response)
+```
+::::
+
+
+:::{note}
+Please note that passing `enable_thinking` is not OpenAI API compatible.
+The exact method may differ among frameworks.
+:::
+
+:::{tip}
+To completely disable thinking, you could use [a custom chat template](../../source/assets/qwen3_nonthinking.jinja) when starting the model:
+
+```shell
+vllm serve Qwen/Qwen3-8B --chat-template ./qwen3_nonthinking.jinja
+```
+
+The chat template prevents the model from generating thinking content, even if the user instructs the model to do so with `/think`.
+:::
+
+
+:::{tip}
+It is recommended to set sampling parameters differently for thinking and non-thinking modes.
+:::
+
+
+### Parsing Thinking Content
+
+vLLM supports parsing the thinking content from the model generation into structured messages:
+```shell
+vllm serve Qwen/Qwen3-8B --enable-reasoning --reasoning-parser deepseek_r1
+```
+
+Since vLLM 0.9.0, one can also use
+```shell
+vllm serve Qwen/Qwen3-8B --reasoning-parser qwen3
+```
+
+The response message will have a field named `reasoning_content` in addition to `content`, containing the thinking content generated by the model.
+
+:::{note}
+Please note that this feature is not OpenAI API compatible.
+:::
+
+:::{important}
+As of vLLM 0.8.5, `enable_thinking=False` is not compatible with this feature.
+If you need to pass `enable_thinking=False` to the API, you should disable parsing thinking content.
+This is resolved in vLLM 0.9.0 with the `qwen3` reasoning parser. 
+:::
+
+### Parsing Tool Calls
+
+vLLM supports parsing the tool calling content from the model generation into structured messages:
+```shell
+vllm serve Qwen/Qwen3-8B --enable-auto-tool-choice --tool-call-parser hermes
+```
+
+For more information, please refer to [our guide on Function Calling](../framework/function_call.md#vllm).
+
+### Structured/JSON Output
+
+vLLM supports structured/JSON output. 
+Please refer to [vLLM's documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#extra-parameters-for-chat-api) for the `guided_json` parameters.
+Besides, it is also recommended to instruct the model to generate the specific format in the system message or in your prompt.
+
+
+### Serving Quantized models
+
+Qwen3 comes with two types of pre-quantized models, FP8 and AWQ.
+
+The command serving those models are the same as the original models except for the name change:
+```shell
+# For FP8 quantized model
+vllm serve Qwen/Qwen3-8B-FP8
+
+# For AWQ quantized model
+vllm serve Qwen/Qwen3-8B-AWQ
+```
+
+:::{note}
+The FP8 models of Qwen3 are block-wise quant, which is supported on NVIDIA GPUs with compute capability > 8.9, that is, Ada Lovelace, Hopper, and later GPUs and runs as w8a8.
+
+Since vLLM v0.9.0, FP8 Marlin has supported block-wise quants (running as w8a16) and you can also run Qwen3 FP8 models on Ampere cards.
+:::
+
+:::{note}
+If you encountered the following error when deploying the FP8 models, it indicates that the tensor parallel size does not agree with the model weights:
+```
+File ".../vllm/vllm/model_executor/layers/quantization/fp8.py", line 477, in create_weights
+    raise ValueError(
+ValueError: The output_size of gate's and up's weight = 192 is not divisible by weight quantization block_n = 128.
+```
+
+We recommend lowering the degree of tensor parallel, e.g., `--tensor-parallel-size 4` or enabling expert parallel, e.g., `--tensor-parallel-size 8 --enable-expert-parallel`.
+:::
+
+### Context Length
+
+The context length for Qwen3 models in pretraining is up to 32,768 tokens.
+To handle context length substantially exceeding 32,768 tokens, RoPE scaling techniques should be applied.
+We have validated the performance of [YaRN](https://arxiv.org/abs/2309.00071), a technique for enhancing model length extrapolation, ensuring optimal performance on lengthy texts.
+
+vLLM supports YaRN, which can be configured as
+```shell
+vllm serve Qwen/Qwen3-8B --rope-scaling '{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}' --max-model-len 131072  
+```
+
+:::{note}
+vLLM implements 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. 
+:::
+
+:::{note}
+The default `max_position_embeddings` in `config.json` is set to 40,960, which used by vLLM, if `--max-model-len` is not specified.
+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 and leave adequate room for model thinking.
+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.
+:::
+
+## Python Library
+
+vLLM can also be directly used as a Python library, which is convenient for offline batch inference but lack some API-only features, such as parsing model generation to structure messages.
+
+The following shows the basic usage of vLLM as a library:
+
+```python
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+# Initialize the tokenizer
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-8B")
+
+# Configurae the sampling parameters (for thinking mode)
+sampling_params = SamplingParams(temperature=0.6, top_p=0.95, top_k=20, max_tokens=32768)
+
+# Initialize the vLLM engine
+llm = LLM(model="Qwen/Qwen3-8B")
+
+# Prepare the input to the model
+prompt = "Give me a short introduction to large language models."
+messages = [
+    {"role": "user", "content": prompt}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=True,  # Set to False to strictly disable thinking
+)
+
+# Generate outputs
+outputs = llm.generate([text], sampling_params)
+
+# Print the outputs.
+for output in outputs:
+    prompt = output.prompt
+    generated_text = output.outputs[0].text
+    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")
+```
+
+Since vLLM v0.9.0, you can also use the `LLM.chat` interface which includes support for `chat_template_kwargs`:
+
+```python
+from vllm import LLM, SamplingParams
+
+# Configurae the sampling parameters (for thinking mode)
+sampling_params = SamplingParams(temperature=0.6, top_p=0.95, top_k=20, max_tokens=32768)
+
+# Initialize the vLLM engine
+llm = LLM(model="Qwen/Qwen3-8B")
+
+# Prepare the input to the model
+prompt = "Give me a short introduction to large language models."
+messages = [
+    {"role": "user", "content": prompt}
+]
+
+# Generate outputs
+outputs = llm.chat(
+    [messages], 
+    sampling_params,
+    chat_template_kwargs={"enable_thinking": True},  # Set to False to strictly disable thinking
+)
+
+# Print the outputs.
+for output in outputs:
+    prompt = output.prompt
+    generated_text = output.outputs[0].text
+    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")
+```
+
+## FAQ
+
+You may encounter OOM issues that are pretty annoying.
+We recommend two arguments for you to make some fix.
+
+- The first one is `--max-model-len`.
+  Our provided default `max_position_embedding` is `40960` and thus the maximum length for the serving is also this value, leading to higher requirements of memory.
+  Reducing it to a proper length for yourself often helps with the OOM issue.
+- Another argument you can pay attention to is `--gpu-memory-utilization`.
+  vLLM will pre-allocate this much GPU memory.
+  By default, it is `0.9`.
+  This is also why you find a vLLM service always takes so much memory.
+  If you are in eager mode (by default it is not), you can level it up to tackle the OOM problem.
+  Otherwise, CUDA Graphs are used, which will use GPU memory not controlled by vLLM, and you should try lowering it.
+  If it doesn't work, you should try `--enforce-eager`, which may slow down inference, or reduce the `--max-model-len`.
+
+
+For more usage guide with vLLM, please see vLLM's [Qwen3 Usage Guide](https://github.com/vllm-project/vllm/issues/17327).

docs/source/framework/Langchain.rst

@@ -0,0 +1,278 @@
+Langchain
+==========================
+
+.. attention:: 
+    To be updated for Qwen3.
+
+This guide helps you build a question-answering application based 
+on a local knowledge base using ``Qwen2.5-7B-Instruct`` with ``langchain``.
+The goal is to establish a knowledge base Q&A solution.
+
+Basic Usage
+-----------
+
+The implementation process of this project includes 
+loading files -> reading text -> segmenting text -> vectorizing text -> vectorizing questions 
+-> matching the top k most similar text vectors with the question vectors -> 
+incorporating the matched text as context along with the question into the prompt -> 
+submitting to the Qwen2.5-7B-Instruct to generate an answer.
+Below is an example:
+
+.. code:: bash
+
+   pip install langchain==0.0.174
+   pip install faiss-gpu
+
+.. code:: python
+
+   from transformers import AutoModelForCausalLM, AutoTokenizer
+   from abc import ABC
+   from langchain.llms.base import LLM
+   from typing import Any, List, Mapping, Optional
+   from langchain.callbacks.manager import CallbackManagerForLLMRun
+   
+   model_name = "Qwen/Qwen2.5-7B-Instruct"
+
+   model = AutoModelForCausalLM.from_pretrained(
+       model_name,
+       torch_dtype="auto",
+       device_map="auto"
+   )
+   tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+   class Qwen(LLM, ABC):
+        max_token: int = 10000
+        temperature: float = 0.01
+        top_p = 0.9
+        history_len: int = 3
+
+        def __init__(self):
+            super().__init__()
+
+        @property
+        def _llm_type(self) -> str:
+            return "Qwen"
+
+        @property
+        def _history_len(self) -> int:
+            return self.history_len
+
+        def set_history_len(self, history_len: int = 10) -> None:
+            self.history_len = history_len
+
+        def _call(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+        ) -> str:
+            messages = [
+                {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
+                {"role": "user", "content": prompt}
+            ]
+            text = tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True
+            )
+            model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+            generated_ids = model.generate(
+                **model_inputs,
+                max_new_tokens=512
+            )
+            generated_ids = [
+                output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+            ]
+
+            response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+            return response
+        
+        @property
+        def _identifying_params(self) -> Mapping[str, Any]:
+            """Get the identifying parameters."""
+            return {"max_token": self.max_token,
+                    "temperature": self.temperature,
+                    "top_p": self.top_p,
+                    "history_len": self.history_len}
+
+After loading the Qwen2.5-7B-Instruct model, you should specify the txt file 
+for retrieval.
+
+.. code:: python
+
+    import os
+    import re
+    import torch
+    import argparse
+    from langchain.vectorstores import FAISS
+    from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+    from typing import List, Tuple
+    import numpy as np
+    from langchain.document_loaders import TextLoader
+    from langchain.text_splitter import CharacterTextSplitter
+    from langchain.docstore.document import Document
+    from langchain.prompts.prompt import PromptTemplate
+    from langchain.chains import RetrievalQA
+    
+    class ChineseTextSplitter(CharacterTextSplitter):
+        def __init__(self, pdf: bool = False, **kwargs):
+            super().__init__(**kwargs)
+            self.pdf = pdf
+
+        def split_text(self, text: str) -> List[str]:
+            if self.pdf:
+                text = re.sub(r"\n{3,}", "\n", text)
+                text = re.sub('\s', ' ', text)
+                text = text.replace("\n\n", "")
+            sent_sep_pattern = re.compile(
+                '([﹒﹔﹖﹗．。！？]["’”」』]{0,2}|(?=["‘“「『]{1,2}|$))') 
+            sent_list = []
+            for ele in sent_sep_pattern.split(text):
+                if sent_sep_pattern.match(ele) and sent_list:
+                    sent_list[-1] += ele
+                elif ele:
+                    sent_list.append(ele)
+            return sent_list
+
+
+    def load_file(filepath):
+        loader = TextLoader(filepath, autodetect_encoding=True)
+        textsplitter = ChineseTextSplitter(pdf=False)
+        docs = loader.load_and_split(textsplitter)
+        write_check_file(filepath, docs)
+        return docs
+
+
+    def write_check_file(filepath, docs):
+        folder_path = os.path.join(os.path.dirname(filepath), "tmp_files")
+        if not os.path.exists(folder_path):
+            os.makedirs(folder_path)
+        fp = os.path.join(folder_path, 'load_file.txt')
+        with open(fp, 'a+', encoding='utf-8') as fout:
+            fout.write("filepath=%s,len=%s" % (filepath, len(docs)))
+            fout.write('\n')
+            for i in docs:
+                fout.write(str(i))
+                fout.write('\n')
+            fout.close()
+
+            
+    def separate_list(ls: List[int]) -> List[List[int]]:
+        lists = []
+        ls1 = [ls[0]]
+        for i in range(1, len(ls)):
+            if ls[i - 1] + 1 == ls[i]:
+                ls1.append(ls[i])
+            else:
+                lists.append(ls1)
+                ls1 = [ls[i]]
+        lists.append(ls1)
+        return lists
+
+
+    class FAISSWrapper(FAISS):
+        chunk_size = 250
+        chunk_conent = True
+        score_threshold = 0
+        
+        def similarity_search_with_score_by_vector(
+                self, embedding: List[float], k: int = 4
+        ) -> List[Tuple[Document, float]]:
+            scores, indices = self.index.search(np.array([embedding], dtype=np.float32), k)
+            docs = []
+            id_set = set()
+            store_len = len(self.index_to_docstore_id)
+            for j, i in enumerate(indices[0]):
+                if i == -1 or 0 < self.score_threshold < scores[0][j]:
+                    # This happens when not enough docs are returned.
+                    continue
+                _id = self.index_to_docstore_id[i]
+                doc = self.docstore.search(_id)
+                if not self.chunk_conent:
+                    if not isinstance(doc, Document):
+                        raise ValueError(f"Could not find document for id {_id}, got {doc}")
+                    doc.metadata["score"] = int(scores[0][j])
+                    docs.append(doc)
+                    continue
+                id_set.add(i)
+                docs_len = len(doc.page_content)
+                for k in range(1, max(i, store_len - i)):
+                    break_flag = False
+                    for l in [i + k, i - k]:
+                        if 0 <= l < len(self.index_to_docstore_id):
+                            _id0 = self.index_to_docstore_id[l]
+                            doc0 = self.docstore.search(_id0)
+                            if docs_len + len(doc0.page_content) > self.chunk_size:
+                                break_flag = True
+                                break
+                            elif doc0.metadata["source"] == doc.metadata["source"]:
+                                docs_len += len(doc0.page_content)
+                                id_set.add(l)
+                    if break_flag:
+                        break
+            if not self.chunk_conent:
+                return docs
+            if len(id_set) == 0 and self.score_threshold > 0:
+                return []
+            id_list = sorted(list(id_set))
+            id_lists = separate_list(id_list)
+            for id_seq in id_lists:
+                for id in id_seq:
+                    if id == id_seq[0]:
+                        _id = self.index_to_docstore_id[id]
+                        doc = self.docstore.search(_id)
+                    else:
+                        _id0 = self.index_to_docstore_id[id]
+                        doc0 = self.docstore.search(_id0)
+                        doc.page_content += " " + doc0.page_content
+                if not isinstance(doc, Document):
+                    raise ValueError(f"Could not find document for id {_id}, got {doc}")
+                doc_score = min([scores[0][id] for id in [indices[0].tolist().index(i) for i in id_seq if i in indices[0]]])
+                doc.metadata["score"] = int(doc_score)
+                docs.append((doc, doc_score))
+            return docs
+
+
+    if __name__ == '__main__':
+        # load docs (pdf file or txt file)
+        filepath = 'your file path'
+        # Embedding model name
+        EMBEDDING_MODEL = 'text2vec'
+        PROMPT_TEMPLATE = """Known information:
+        {context_str} 
+        Based on the above known information, respond to the user's question concisely and professionally. If an answer cannot be derived from it, say 'The question cannot be answered with the given information' or 'Not enough relevant information has been provided,' and do not include fabricated details in the answer. Please respond in English. The question is {question}"""
+        # Embedding running device
+        EMBEDDING_DEVICE = "cuda"
+        # return top-k text chunk from vector store
+        VECTOR_SEARCH_TOP_K = 3
+        CHAIN_TYPE = 'stuff'
+        embedding_model_dict = {
+            "text2vec": "your text2vec model path",
+        }
+        llm = Qwen()
+        embeddings = HuggingFaceEmbeddings(model_name=embedding_model_dict[EMBEDDING_MODEL],model_kwargs={'device': EMBEDDING_DEVICE})
+        
+        docs = load_file(filepath)
+        
+        docsearch = FAISSWrapper.from_documents(docs, embeddings)
+        
+        prompt = PromptTemplate(
+            template=PROMPT_TEMPLATE, input_variables=["context_str", "question"]
+        )
+
+        chain_type_kwargs = {"prompt": prompt, "document_variable_name": "context_str"}
+        qa = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type=CHAIN_TYPE, 
+            retriever=docsearch.as_retriever(search_kwargs={"k": VECTOR_SEARCH_TOP_K}), 
+            chain_type_kwargs=chain_type_kwargs)
+        
+        query = "Give me a short introduction to large language models."  
+        print(qa.run(query))
+
+Next Step
+---------
+
+Now you can chat with Qwen2.5 use your own document. Continue
+to read the documentation and try to figure out more advanced usages of
+model retrieval!

docs/source/framework/LlamaIndex.rst

@@ -0,0 +1,141 @@
+LlamaIndex
+==========
+
+.. attention:: 
+    To be updated for Qwen3.
+
+To connect Qwen2.5 with external data, such as documents, web pages, etc., we offer a tutorial on `LlamaIndex <https://www.llamaindex.ai/>`__.
+This guide helps you quickly implement retrieval-augmented generation (RAG) using LlamaIndex with Qwen2.5.
+
+Preparation
+--------------------------------------
+
+To implement RAG, 
+we advise you to install the LlamaIndex-related packages first. 
+
+The following is a simple code snippet showing how to do this:
+
+.. code:: bash
+
+   pip install llama-index
+   pip install llama-index-llms-huggingface
+   pip install llama-index-readers-web
+
+Set Parameters
+--------------------------------------
+
+Now we can set up LLM, embedding model, and the related configurations.  
+Qwen2.5-Instruct supports conversations in multiple languages, including English and Chinese.
+You can use the ``bge-base-en-v1.5`` model to retrieve from English documents, and you can download the ``bge-base-zh-v1.5`` model to retrieve from Chinese documents. 
+You can also choose ``bge-large`` or ``bge-small`` as the embedding model or modify the context window size or text chunk size depending on your computing resources.
+Qwen2.5 model families support a maximum of 32K context window size (up to 128K for 7B, 14B, 32B, and 72B, requiring extra configuration)
+
+.. code:: python
+  
+    import torch
+    from llama_index.core import Settings
+    from llama_index.core.node_parser import SentenceSplitter
+    from llama_index.llms.huggingface import HuggingFaceLLM
+    from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+
+    # Set prompt template for generation (optional)
+    from llama_index.core import PromptTemplate
+  
+    def completion_to_prompt(completion):
+       return f"<|im_start|>system\n<|im_end|>\n<|im_start|>user\n{completion}<|im_end|>\n<|im_start|>assistant\n"
+    
+    def messages_to_prompt(messages):
+        prompt = ""
+        for message in messages:
+            if message.role == "system":
+                prompt += f"<|im_start|>system\n{message.content}<|im_end|>\n"
+            elif message.role == "user":
+                prompt += f"<|im_start|>user\n{message.content}<|im_end|>\n"
+            elif message.role == "assistant":
+                prompt += f"<|im_start|>assistant\n{message.content}<|im_end|>\n"
+    
+        if not prompt.startswith("<|im_start|>system"):
+            prompt = "<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n" + prompt
+    
+        prompt = prompt + "<|im_start|>assistant\n"
+    
+        return prompt
+    
+    # Set Qwen2.5 as the language model and set generation config
+    Settings.llm = HuggingFaceLLM(
+        model_name="Qwen/Qwen2.5-7B-Instruct",
+        tokenizer_name="Qwen/Qwen2.5-7B-Instruct",
+        context_window=30000,
+        max_new_tokens=2000,
+        generate_kwargs={"temperature": 0.7, "top_k": 50, "top_p": 0.95},
+        messages_to_prompt=messages_to_prompt,
+        completion_to_prompt=completion_to_prompt,
+        device_map="auto",
+    )
+
+    # Set embedding model                       
+    Settings.embed_model = HuggingFaceEmbedding(
+        model_name = "BAAI/bge-base-en-v1.5"
+    )
+
+    # Set the size of the text chunk for retrieval
+    Settings.transformations = [SentenceSplitter(chunk_size=1024)]
+
+Build Index
+--------------------------------------
+
+Now we can build index from documents or websites.
+
+The following code snippet demonstrates how to build an index for files (regardless of whether they are in PDF or TXT format) in a local folder named 'document'.                               
+
+.. code:: python
+    
+    from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+    
+    documents = SimpleDirectoryReader("./document").load_data()
+    index = VectorStoreIndex.from_documents(
+        documents,
+        embed_model=Settings.embed_model,
+        transformations=Settings.transformations
+    )
+
+The following code snippet demonstrates how to build an index for the content in a list of websites.                               
+                               
+.. code:: python
+                               
+    from llama_index.readers.web import SimpleWebPageReader
+    from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+    
+    documents = SimpleWebPageReader(html_to_text=True).load_data(
+        ["web_address_1","web_address_2",...]
+    )
+    index = VectorStoreIndex.from_documents(
+        documents,
+        embed_model=Settings.embed_model, 
+        transformations=Settings.transformations
+    )
+
+To save and load the index, you can use the following code snippet.                              
+
+.. code:: python
+
+    from llama_index.core import StorageContext, load_index_from_storage
+
+    # save index
+    storage_context = StorageContext.from_defaults(persist_dir="save")
+    
+    # load index
+    index = load_index_from_storage(storage_context)
+                            
+                               
+RAG
+-------------------
+
+Now you can perform queries, and Qwen2.5 will answer based on the content of the indexed documents.                               
+                               
+.. code:: python
+
+  query_engine = index.as_query_engine()
+  your_query = "<your query here>"                             
+  print(query_engine.query(your_query).response)
+

docs/source/framework/function_call.md

@@ -0,0 +1,606 @@
+---
+myst:
+  number_code_blocks: ["python3"]
+---
+
+# Function Calling
+
+
+## Preface
+
+Function calling with large language models is a huge and evolving topic.
+It is particularly important for AI applications: 
+- either for AI-native applications that strive to work around the shortcomings of current AI technology, 
+- or for existing applications that seeks the integration of AI technology to improve performance, user interaction and experience, or efficiency.
+
+We will talk about how Qwen3 can be used to support function calling and how it can be used to achieve your goals, from the inference usage for developing application to the inner workings for hardcore customizations. 
+In this guide, 
+- We will first demonstrate how to use function calling with Qwen3.
+- Then, we will introduce the technical details on functional calling with Qwen3, which are mainly about the templates.
+
+Before starting, there is one thing we have not yet introduced, that is ...
+
+## What is function calling?
+
+:::{Note}
+There is another term "tool use" that may be used to refer to the same concept.
+While some may argue that tools are a generalized form of functions, at present, their difference exists only technically as different I/O types of programming interfaces.
+:::
+
+Large language models (LLMs) are powerful things.
+However, sometimes LLMs by themselves are simply not capable enough.
+- On the one hand, LLMs have inherent modeling limitations. 
+  For one, they do not know things that are not in their training data, which include those happened after their training ended.
+  In addition, they learn things in the way of likelihood, which suggests that they may not be precise enough for tasks with fixed rule sets, e.g., mathematical computation.
+- On the other hand, it is not easy to use LLMs as a Plug-and-Play service programmatically with other things.
+  LLMs mostly talk in words that are open to interpretation and thus ambiguous, while other software or applications or systems talk in code and through programming interfaces that are pre-defined and fixed and structured.
+
+To this end, function calling establishes a common protocol that specifies how LLMs should interact with the other things.
+The procedure is mainly as follows:
+1. The application provides a set of functions and the instructions of the functions to an LLM.
+2. The LLM choose to or not to, or is forced to use one or many of the functions, in response to user queries.
+3. If the LLM chooses to use the functions, it states how the functions should be used based on the function instructions.
+4. The chosen functions are used as such by the application and the results are obtained, which are then given to the LLM if further interaction is needed.
+
+There are many ways for LLMs to understand and follow this protocol.
+As always, the key is prompt engineering or an internalized template known by the model.
+We recommend using Hermes-style tool use for Qwen3 to maximize function calling performance.
+
+## Inference with Function Calling
+
+As function calling is essentially implemented using prompt engineering, you could manually construct the model inputs for Qwen3 models.
+However, frameworks with function calling support can help you with all that laborious work.
+
+In the following, we will introduce the usage (via dedicated function calling chat template) with
+- **Qwen-Agent**,
+- **vLLM**.
+
+### The Example Case
+
+Let's also use an example to demonstrate the inference usage.
+We assume **Python 3.11** is used as the programming language.
+
+**Scenario**: Suppose we would like to ask the model about the temperature of a location.
+Normally, the model would reply that it cannot provide real-time information.
+But we have two tools that can be used to obtain the current temperature of and the temperature at a given date of a city respectively, and we would like the model to make use of them.
+
+To set up the example case, you can use the following code:
+
+:::{dropdown} Preparation Code
+:name: prepcode
+
+```python
+import json
+
+def get_current_temperature(location: str, unit: str = "celsius"):
+    """Get current temperature at a location.
+
+    Args:
+        location: The location to get the temperature for, in the format "City, State, Country".
+        unit: The unit to return the temperature in. Defaults to "celsius". (choices: ["celsius", "fahrenheit"])
+
+    Returns:
+        the temperature, the location, and the unit in a dict
+    """
+    return {
+        "temperature": 26.1,
+        "location": location,
+        "unit": unit,
+    }
+
+
+def get_temperature_date(location: str, date: str, unit: str = "celsius"):
+    """Get temperature at a location and date.
+
+    Args:
+        location: The location to get the temperature for, in the format "City, State, Country".
+        date: The date to get the temperature for, in the format "Year-Month-Day".
+        unit: The unit to return the temperature in. Defaults to "celsius". (choices: ["celsius", "fahrenheit"])
+
+    Returns:
+        the temperature, the location, the date and the unit in a dict
+    """
+    return {
+        "temperature": 25.9,
+        "location": location,
+        "date": date,
+        "unit": unit,
+    }
+
+
+def get_function_by_name(name):
+    if name == "get_current_temperature":
+        return get_current_temperature
+    if name == "get_temperature_date":
+        return get_temperature_date
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_current_temperature",
+            "description": "Get current temperature at a location.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": 'The location to get the temperature for, in the format "City, State, Country".',
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["celsius", "fahrenheit"],
+                        "description": 'The unit to return the temperature in. Defaults to "celsius".',
+                    },
+                },
+                "required": ["location"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_temperature_date",
+            "description": "Get temperature at a location and date.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": 'The location to get the temperature for, in the format "City, State, Country".',
+                    },
+                    "date": {
+                        "type": "string",
+                        "description": 'The date to get the temperature for, in the format "Year-Month-Day".',
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["celsius", "fahrenheit"],
+                        "description": 'The unit to return the temperature in. Defaults to "celsius".',
+                    },
+                },
+                "required": ["location", "date"],
+            },
+        },
+    },
+]
+MESSAGES = [
+    {"role": "user",  "content": "What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30."},
+]
+```
+:::
+
+In particular, the tools should be described using JSON Schema and the messages should contain as much available information as possible.
+You can find the explanations of the tools and messages below:
+
+:::{dropdown} Example Tools
+
+The tools should be described using the following JSON:
+```json
+[
+  {
+    "type": "function",
+    "function": {
+      "name": "get_current_temperature",
+      "description": "Get current temperature at a location.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "location": {
+            "type": "string",
+            "description": "The location to get the temperature for, in the format \"City, State, Country\"."
+          },
+          "unit": {
+            "type": "string",
+            "enum": [
+              "celsius",
+              "fahrenheit"
+            ],
+            "description": "The unit to return the temperature in. Defaults to \"celsius\"."
+          }
+        },
+        "required": [
+          "location"
+        ]
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "get_temperature_date",
+      "description": "Get temperature at a location and date.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "location": {
+            "type": "string",
+            "description": "The location to get the temperature for, in the format \"City, State, Country\"."
+          },
+          "date": {
+            "type": "string",
+            "description": "The date to get the temperature for, in the format \"Year-Month-Day\"."
+          },
+          "unit": {
+            "type": "string",
+            "enum": [
+              "celsius",
+              "fahrenheit"
+            ],
+            "description": "The unit to return the temperature in. Defaults to \"celsius\"."
+          }
+        },
+        "required": [
+          "location",
+          "date"
+        ]
+      }
+    }
+  }
+]
+```
+For each **tool**, it is a JSON object with two fields:
+- `type`: a string specifying the type of the tool, currently only `"function"` is valid
+- `function`: an object detailing the instructions to use the function
+
+For each **function**, it is a JSON object with three fields:
+- `name`: a string indicating the name of the function
+- `description`: a string describing what the function is used for
+- `parameters`: [a JSON Schema](https://json-schema.org/learn/getting-started-step-by-step) that specifies the parameters the function accepts. Please refer to the linked documentation for how to compose a JSON Schema. Notable fields include `type`, `required`, and `enum`.
+
+Most frameworks use the tool format and some may use the function format.
+Which one to use should be obvious according to the naming.
+:::
+
+
+:::{dropdown} Example Messages
+
+Our query is `What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30.`.
+
+```json
+[ 
+    {"role": "user",  "content": "What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30."}
+]
+```
+:::
+
+### Qwen-Agent
+
+[Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) is actually a Python Agent framework for developing AI applications.
+Although its intended use cases are higher-level than efficient inference, it does contain the **canonical implementation** of function calling for Qwen3.
+It provides the function calling ability for Qwen3 to an OpenAI-compatible API through templates that is transparent to users.
+
+It is worth noting that for reasoning models like Qwen3, it is *not recommended* to use tool call template based on stopwords, such as ReAct, because the model may output stopwords in the thought section, potentially leading to unexpected behavior in tool calls.
+
+Before starting, let's make sure the latest library is installed:
+```bash
+pip install -U qwen-agent
+```
+
+#### Preparing
+
+Qwen-Agent can wrap an OpenAI-compatible API that does not support function calling.
+You can serve such an API with most inference frameworks or obtain one from cloud providers like DashScope or Together.
+
+Assuming there is an OpenAI-compatible API at `http://localhost:8000/v1`, Qwen-Agent provides a shortcut function `get_chat_model` to obtain a model inference class with function calling support: 
+
+```python
+from qwen_agent.llm import get_chat_model
+
+llm = get_chat_model({
+    "model": "Qwen/Qwen3-8B",
+    "model_server": "http://localhost:8000/v1",
+    "api_key": "EMPTY",
+    "generate_cfg": {
+      "extra_body": {
+        "chat_template_kwargs": {"enable_thinking": False}  # default to True
+      }
+    }
+})
+```
+
+In the above, `model_server` is the `api_base` common used in other OpenAI-compatible API clients.
+It is advised to provide the `api_key` (but not via plaintext in the code), even if the API server does not check it, in which case, you can set it to anything.
+You can pass model parameters to the model by `generate_cfg`. Here we demonstrate how to control the think and no_think modes of Qwen3. 
+Different APIs may have different control methods.
+
+For model inputs, the common message structure for system, user, and assistant history should be used:
+
+```python
+messages = MESSAGES[:]
+```
+
+At the time, Qwen-Agent works with functions instead of tools.
+This requires a small change to our tool descriptions, that is, extracting the function fields:
+
+```python
+functions = [tool["function"] for tool in TOOLS]
+```
+
+#### Tool Calls and Tool Results
+
+To interact with the model, the `chat` method should be used:
+
+```python
+for responses in llm.chat(
+    messages=messages,
+    functions=functions,
+):
+    pass
+messages.extend(responses)
+```
+
+The `chat` method returns a generator of list, each of which may contain multiple messages.
+
+
+- The results of `no_think` mode:
+```python
+[
+    {"role": "assistant", "content": "", "function_call": {"name": "get_current_temperature", "arguments": "{\"location\": \"San Francisco, California, United States\", \"unit\": \"celsius\"}"}},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_temperature_date", "arguments": "{\"location\": \"San Francisco, California, United States\", \"date\": \"2024-10-01\", \"unit\": \"celsius\"}"}},
+]
+```
+
+- The results of `think` mode:
+```python
+[
+    {"role": "assistant", "content": "", "reasoning_content": "Okay, the user is asking for the current temperature in San Francisco and the temperature for tomorrow. Let me check the available tools.\n\nFirst, there's the get_current_temperature function. It requires the location and optionally the unit. Since the user didn't specify the unit, I'll default to celsius. The location should be \"San Francisco, State, Country\". Wait, the example format is \"City, State, Country\", but San Francisco is a city in California, USA. So the location parameter would be \"San Francisco, California, United States\".\n\nThen, for tomorrow's temperature, the user mentioned the current date is 2024-09-30, so tomorrow would be 2024-10-01. The get_temperature_date function requires location, date, and unit. Again, using the same location and default unit. I need to format the date as \"Year-Month-Day\", which is 2024-10-01.\n\nWait, the current date given is 2024-09-30. If today is September 30, then tomorrow is October 1st. So the date parameter for the second function call should be \"2024-10-01\".\n\nI should make two separate function calls: one for the current temperature and another for tomorrow's date. Let me structure the JSON for both tool calls accordingly."},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_current_temperature", "arguments": "{\"location\": \"San Francisco, California, United States\", \"unit\": \"celsius\"}"}},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_temperature_date", "arguments": "{\"location\": \"San Francisco, California, United States\", \"date\": \"2024-10-01\", \"unit\": \"celsius\"}"}},
+]
+```
+
+As we can see, Qwen-Agent attempts to parse the model generation in an easier to use structural format.
+The details related to function calls are placed in the `function_call` field of the messages:
+- `name`: a string representing the function to call
+- `arguments`: a JSON-formatted string representing the arguments the function should be called with
+
+In the thinking mode, it will first generate a thought and then generate the tool call(s).
+
+Then comes the critical part -- checking and applying the function call:
+```python3
+for message in responses:
+    if fn_call := message.get("function_call", None):
+        fn_name: str = fn_call['name']
+        fn_args: dict = json.loads(fn_call["arguments"])
+
+        fn_res: str = json.dumps(get_function_by_name(fn_name)(**fn_args))
+
+        messages.append({
+            "role": "function",
+            "name": fn_name,
+            "content": fn_res,
+        })
+```
+
+To get tool results: 
+- line 1: We should iterate the function calls in the order the model generates them.
+- line 2: We can check if a function call is needed as deemed by the model by checking the `function_call` field of the generated messages.
+- line 3-4: The related details including the name and the arguments of the function can also be found there, which are `name` and `arguments` respectively.
+- line 6: With the details, one should call the function and obtain the results.
+  Here, we assume there is a function named [`get_function_by_name`](#prepcode) to help us get the related function by its name.
+- line 8-12: With the result obtained, add the function result to the messages as `content` and with `role` as `"function"`.
+
+Now the messages are:
+
+- `no_think` mode:
+```python
+[
+    {"role": "user", "content": "What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30."},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_current_temperature", "arguments": "{\"location\": \"San Francisco, California, United States\", \"unit\": \"celsius\"}"}},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_temperature_date", "arguments": "{\"location\": \"San Francisco, California, United States\", \"date\": \"2024-10-01\", \"unit\": \"celsius\"}"}},
+    {"role": "function", "name": "get_current_temperature", "content": '{"temperature": 26.1, "location": "San Francisco, California, United States", "unit": "celsius"}'},
+    {"role": "function", "name": "get_temperature_date", "content": '{"temperature": 25.9, "location": "San Francisco, California, United States", "date": "2024-10-01", "unit": "celsius"}'},
+]
+```
+
+- `think` mode:
+```python
+[
+    {"role": "user", "content": "What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30."},
+    {"role": "assistant", "content": "", "reasoning_content": "Okay, the user is asking for the current temperature in San Francisco and the temperature for tomorrow. Let me check the available tools.\n\nFirst, there's the get_current_temperature function. It requires the location and optionally the unit. Since the user didn't specify the unit, I'll default to celsius. The location should be \"San Francisco, State, Country\". Wait, the example format is \"City, State, Country\", but San Francisco is a city in California, USA. So the location parameter would be \"San Francisco, California, United States\".\n\nThen, for tomorrow's temperature, the user mentioned the current date is 2024-09-30, so tomorrow would be 2024-10-01. The get_temperature_date function requires location, date, and unit. Again, using the same location and default unit. I need to format the date as \"Year-Month-Day\", which is 2024-10-01.\n\nWait, the current date given is 2024-09-30. If today is September 30, then tomorrow is October 1st. So the date parameter for the second function call should be \"2024-10-01\".\n\nI should make two separate function calls: one for the current temperature and another for tomorrow's date. Let me structure the JSON for both tool calls accordingly."},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_current_temperature", "arguments": "{\"location\": \"San Francisco, California, United States\", \"unit\": \"celsius\"}"}},
+    {"role": "assistant", "content": "", "function_call": {"name": "get_temperature_date", "arguments": "{\"location\": \"San Francisco, California, United States\", \"date\": \"2024-10-01\", \"unit\": \"celsius\"}"}},
+    {"role": "function", "name": "get_current_temperature", "content": '{"temperature": 26.1, "location": "San Francisco, California, United States", "unit": "celsius"}'},
+    {"role": "function", "name": "get_temperature_date", "content": '{"temperature": 25.9, "location": "San Francisco, California, United States", "date": "2024-10-01", "unit": "celsius"}'},
+]
+```
+
+#### Final Response
+
+Finally, run the model again to get the final model results:
+
+```python
+for responses in llm.chat(messages=messages, functions=functions):
+    pass
+messages.extend(responses)
+```
+
+The final response should be like
+
+- `no_think` mode:
+```python
+[
+    {"role": "assistant", "content": "The current temperature in San Francisco, CA, USA is **26.1°C**.  \n\nFor tomorrow (2024-10-01), the temperature is projected to be **25.9°C**.  \n\nThere is a slight decrease in temperature expected from today to tomorrow."}
+]
+```
+
+- `think` mode:
+```python
+[
+    {"role": "assistant", "content": "", "reasoning_content": "Okay, the user asked for the current temperature in San Francisco and tomorrow's temperature. I called the get_current_temperature function for now and get_temperature_date for tomorrow. The responses came back with 26.1°C today and 25.9°C tomorrow. Let me present this info clearly.\n\nFirst, confirm the location to make sure there's no confusion. The current temp is 26.1°C, so I'll state that. Then, tomorrow's date is 2024-10-01, which is October 1st, so I'll mention the date in a user-friendly way. The temp drops slightly to 25.9°C. I should note the unit is Celsius as per the default. Keep the answer concise but informative. Maybe add a brief note about the slight decrease. Make sure the dates are correctly formatted and the temperatures are accurate based on the data provided."}, 
+    {"role": "assistant", "content": "The current temperature in San Francisco, CA, USA is **26.1°C**.  \n\nFor tomorrow (2024-10-01), the temperature is projected to be **25.9°C**.  \n\nThere is a slight decrease in temperature expected from today to tomorrow."}
+]
+```
+
+
+(heading-target)=
+### vLLM
+
+vLLM is a fast and easy-to-use library for LLM inference and serving.
+It uses the tokenizer from `transformers` to format the input, so we should have no trouble preparing the input.
+In addition, vLLm also implements helper functions so that generated tool calls can be parsed automatically if the format is supported.
+
+- `vllm` >= v0.8.5. 
+
+For more information, check the [vLLM documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server.html#tool-calling-in-the-chat-completion-api).
+
+We will use the OpenAI-Compatible API by `vllm` with the API client from the `openai` Python library.
+
+#### Preparing
+
+For Qwen3, the chat template in tokenizer_config.json has already included support for the Hermes-style tool use.
+We simply need to start a OpenAI-compatible API with vLLM:
+
+```bash
+vllm serve Qwen/Qwen3-8B --enable-auto-tool-choice --tool-call-parser hermes --reasoning-parser deepseek_r1
+```
+
+The inputs are the same with those in [the preparation code](#prepcode):
+
+```python
+tools = TOOLS
+messages = MESSAGES
+```
+
+Let's also initialize the client:
+
+```python
+from openai import OpenAI
+
+openai_api_key = "EMPTY"
+openai_api_base = "http://localhost:8000/v1"
+
+client = OpenAI(
+    api_key=openai_api_key,
+    base_url=openai_api_base,
+)
+
+model_name = "Qwen/Qwen3-8B"
+```
+
+#### Tool Calls and Tool Results
+
+We can use the create chat completions endpoint to query the model. 
+Here is an example of the `no_think` mode:
+
+```python
+response = client.chat.completions.create(
+    model=model_name,
+    messages=messages,
+    tools=tools,
+    temperature=0.7,
+    top_p=0.8,
+    max_tokens=512,
+    extra_body={
+        "repetition_penalty": 1.05,
+        "chat_template_kwargs": {"enable_thinking": False}  # default to True
+    },
+)
+```
+
+vLLM should be able to parse the tool calls for us, and the main fields in the response (`response.choices[0]`) should be like
+```python
+Choice(
+    finish_reason='tool_calls', 
+    index=0, 
+    logprobs=None, 
+    message=ChatCompletionMessage(
+        content=None, 
+        role='assistant', 
+        function_call=None, 
+        tool_calls=[
+            ChatCompletionMessageToolCall(
+                id='chatcmpl-tool-924d705adb044ff88e0ef3afdd155f15', 
+                function=Function(arguments='{"location": "San Francisco, CA, USA"}', name='get_current_temperature'), 
+                type='function',
+            ), 
+            ChatCompletionMessageToolCall(
+                id='chatcmpl-tool-7e30313081944b11b6e5ebfd02e8e501', 
+                function=Function(arguments='{"location": "San Francisco, CA, USA", "date": "2024-10-01"}', name='get_temperature_date'), 
+                type='function',
+            ),
+        ],
+    ), 
+    stop_reason=None,
+)
+```
+
+Note that the function arguments are JSON-formatted strings, which Qwen-Agent follows.
+
+As before, chances are that there are corner cases where tool calls are generated but they are malformed and cannot be parsed.
+For production code, we should try parsing by ourselves.
+
+Then, we can obtain the tool results and add them to the messages as shown below:
+
+```python
+messages.append(response.choices[0].message.model_dump())
+
+if tool_calls := messages[-1].get("tool_calls", None):
+    for tool_call in tool_calls:
+        call_id: str = tool_call["id"]
+        if fn_call := tool_call.get("function"):
+            fn_name: str = fn_call["name"]
+            fn_args: dict = json.loads(fn_call["arguments"])
+        
+            fn_res: str = json.dumps(get_function_by_name(fn_name)(**fn_args))
+
+            messages.append({
+                "role": "tool",
+                "content": fn_res,
+                "tool_call_id": call_id,
+            })
+```
+
+It should be noted that the OpenAI API uses `tool_call_id` to identify the relation between tool results and tool calls.
+
+The messages are now like
+```python
+[
+    {'role': 'user', 'content': "What's the temperature in San Francisco now? How about tomorrow? Current Date: 2024-09-30."},
+    {'content': None, 'role': 'assistant', 'function_call': None, 'tool_calls': [
+        {'id': 'chatcmpl-tool-924d705adb044ff88e0ef3afdd155f15', 'function': {'arguments': '{"location": "San Francisco, CA, USA"}', 'name': 'get_current_temperature'}, 'type': 'function'},
+        {'id': 'chatcmpl-tool-7e30313081944b11b6e5ebfd02e8e501', 'function': {'arguments': '{"location": "San Francisco, CA, USA", "date": "2024-10-01"}', 'name': 'get_temperature_date'}, 'type': 'function'},
+    ]},
+    {'role': 'tool', 'content': '{"temperature": 26.1, "location": "San Francisco, CA, USA", "unit": "celsius"}', 'tool_call_id': 'chatcmpl-tool-924d705adb044ff88e0ef3afdd155f15'},
+    {'role': 'tool', 'content': '{"temperature": 25.9, "location": "San Francisco, CA, USA", "date": "2024-10-01", "unit": "celsius"}', 'tool_call_id': 'chatcmpl-tool-7e30313081944b11b6e5ebfd02e8e501'},
+]
+```
+
+#### Final Response
+
+Let's call the endpoint again to seed the tool results and get response:
+```python
+response = client.chat.completions.create(
+    model=model_name,
+    messages=messages,
+    tools=tools,
+    temperature=0.7,
+    top_p=0.8,
+    max_tokens=512,
+    extra_body={
+        "repetition_penalty": 1.05,
+    },
+)
+
+messages.append(response.choices[0].message.model_dump())
+```
+
+The final response (`response.choices[0].message.content`) should be like
+```text
+The current temperature in San Francisco is approximately 26.1°C. For tomorrow, the forecasted temperature is around 25.9°C.
+```
+
+
+## Finally
+
+In whichever way you choose to use function calling with Qwen3, keep in mind that the limitation and the perks of prompt engineering applies:
+- It is not guaranteed that the model generation will always follow the protocol even with proper prompting or templates.
+  Especially, for the templates that are more complex and relies more on the model itself to think and stay on track than the ones that are simpler and relies on the template and the use of control or special tokens.
+  The latter one, of course, requires some kind of training.
+  In production code, be prepared that if it breaks, countermeasures or rectifications are in place.
+- If in certain scenarios, the generation is not up to expectation, you can refine the template to add more instructions or constraints.
+  While the templates mentioned here are general enough, they may not be the best or the most specific or the most concise for your use cases.
+  The ultimate solution is fine-tuning using your own data.
+
+Have fun prompting!

docs/source/framework/qwen_agent.rst

@@ -0,0 +1,113 @@
+Qwen-Agent
+==========
+
+`Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ is a framework for
+developing LLM applications based on the instruction following, tool
+usage, planning, and memory capabilities of Qwen.
+
+This is a simple tutorial on using Qwen-Agent to quickly experience the
+agentic capabilities of Qwen3. For more detailed information, please
+refer to `Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__
+repository.
+
+Installation
+------------
+
+-  Install the stable version from PyPI:
+
+.. code:: bash
+
+   pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"
+   # Or use `pip install -U qwen-agent` for the minimal requirements.
+   # The optional requirements, specified in double brackets, are:
+   #   [gui] for Gradio-based GUI support;
+   #   [rag] for RAG support;
+   #   [code_interpreter] for Code Interpreter support;
+   #   [mcp] for MCP support.
+
+Developing Your Own Agent
+-------------------------
+
+Qwen3 excels in tool calling capabilities. Qwen-Agent encapsulates
+tool-calling templates and tool-calling parsers internally, greatly
+reducing coding complexity.
+
+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.
+
+.. code:: python
+
+   import os
+   from qwen_agent.agents import Assistant
+
+   # Define LLM
+   llm_cfg = {
+       # Use a custom endpoint compatible with OpenAI API by vLLM/SGLang:
+       'model': 'Qwen/Qwen3-32B',
+       'model_server': 'http://localhost:8000/v1',  # api_base
+       'api_key': 'EMPTY',
+
+       # 'generate_cfg': {
+       #     # When using vLLM/SGLang OAI API, pass the parameter of whether to enable thinking mode in this way
+       #     'extra_body': {
+       #         'chat_template_kwargs': {'enable_thinking': False}
+       #     },
+       #
+       #     # Add: When the 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
+       #     # This parameter will affect the parsing strategy of tool call
+       #     # 'thought_in_content': True,
+       # },
+   }
+   # llm_cfg = {
+   #         # Use the model service provided by DashScope:
+   #         'model': 'qwen3-235b-a22b',
+   #         'model_type': 'qwen_dashscope',
+   #
+   #         # 'generate_cfg': {
+   #         #     # When using the Dash Scope API, pass the parameter of whether to enable thinking mode in this way
+   #         #     'enable_thinking': False,
+   #         # },
+   # }
+   # llm_cfg = {
+   #     # Use the OpenAI-compatible model service provided by DashScope:
+   #     'model': 'qwen3-235b-a22b',
+   #     'model_server': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+   #     'api_key': os.getenv('DASHSCOPE_API_KEY'),
+   #
+   #     # 'generate_cfg': {
+   #     #     # When using Dash Scope OAI API, pass the parameter of whether to enable thinking mode in this way
+   #     #     'extra_body': {
+   #     #         'enable_thinking': False
+   #     #     },
+   #     # },
+   # }
+
+   # 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)
+
+   # 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)
+
+For more detailed examples and MCP cookbooks, please refer to
+`Qwen-Agent <https://github.com/QwenLM/Qwen-Agent>`__ repository.

docs/source/getting_started/concepts.md

@@ -0,0 +1,208 @@
+# Key Concepts
+
+## Qwen
+
+Qwen (Chinese: 通义千问; pinyin: _Tongyi Qianwen_) is the large language model and large multimodal model series of the Qwen Team, Alibaba Group. 
+Qwen is capable of natural language understanding, text generation, vision understanding, audio understanding, tool use, role play, playing as AI agent, etc. 
+Both language models and multimodal models are pre-trained on large-scale multilingual and multimodal data and post-trained on quality data for aligning to human preferences.
+
+There is the proprietary/closed source version and the open-weight version. You can learn more about the proprietary models at Alibaba Cloud Model Studio ([China Site](https://help.aliyun.com/zh/model-studio/getting-started/models#9f8890ce29g5u) \[zh\], [International Site](https://www.alibabacloud.com/en/product/modelstudio)).
+
+In this document, our focus is Qwen, the language models.
+
+## Qwen3
+
+Qwen3 is the newest edition of the Qwen language models, featuring balanced model sizes, enhanced capbilities, hybrid thinking modes, and more language support:
+- The mixture-of-experts (MoE) models are reintroduced with the Qwen3-30B-A3B and Qwen3-235B-A22B. The largest dense models are now Qwen3-32B.
+- Hybrid thinking mode is designed so that thinking and non-thinking (instruct) can be achieved without changing models, simplifying deployment and making alternating thinking and non-thinking in a single chat possible.
+- With 119 languages (and dialects), Qwen3's extensive multilingual capability opens up new possibilities for international applications.
+- Qwen3 models are optimized for coding and agentic capabilities, with strengthened support of Model Context Protocol (MCP) as well.
+
+## Naming
+
+Starting with Qwen3, the models are named using the scheme `Qwen3[-size][-type][-date]`:
+- `size`: the notation of the structure and the parameter counts. Dense models use the total saved parameters, e.g., `4B` and `32B`, while MoE models use the total saved parameters and the activated parameters for each token with a prepended `A`, e.g., `30B-A3B` and `235B-A22B`.
+- `type`: there are currently 4 types:
+    - `-Instruct`: the instruction following models that follow the predefined chat template, used for conducting tasks in conversations, downstream fine-tuning, etc.
+    - `-Thinking`: the thinking models that follow the predefined chat template and use chain-of-thoughts (CoT) to think deeply about the questions, used for solving complex problems.
+    - `-Base`: the pre-trained models that do not know the predefined chat template, used for in-context learning, downstream fine-tuning, etc.
+    - No type: the models with hybrid thinking modes.
+- `date`: the released date in yearmonth format, e.g., `2507`.
+
+
+## Tokens & Tokenization
+
+Tokens represent the fundamental units that models process and generate. 
+They can represent texts in human languages (regular tokens) or represent specific functionality like keywords in programming languages (control tokens [^special]).
+Typically, a tokenizer is used to split text into regular tokens, which can be words, subwords, or characters depending on the specific tokenization scheme employed, and furnish the token sequence with control tokens as needed.
+The vocabulary size, or the total number of unique tokens a model recognizes, significantly impacts its performance and versatility. 
+Larger language models often use sophisticated tokenization methods to handle the vast diversity of human language while keeping the vocabulary size manageable.
+Qwen use a relatively large vocabulary of 151,646 tokens in total.
+
+[^special]: Control tokens can be called special tokens. However, the meaning of special tokens need to be interpreted based on the contexts: special tokens may contain extra regular tokens.
+
+
+### Byte-level Byte Pair Encoding
+
+Qwen adopts a subword tokenization method called Byte Pair Encoding (BPE), which attempts to learn the composition of tokens that can represent the text with the fewest tokens. 
+For example, the string ` tokenization` is decomposed as ` token` and `ization` (note that the space is part of the token).
+Especially, the tokenization of Qwen ensures that there is no unknown words and all texts can be transformed to token sequences.
+
+There are 151,643 tokens as a result of BPE in the vocabulary of Qwen, which is a large vocabulary efficient for diverse languages.
+As a rule of thumb, 1 token is 3~4 characters for English texts and 1.5~1.8 characters for Chinese texts. 
+
+### Control Tokens
+
+Control tokens are special tokens inserted into the sequence that signifies meta information.
+For example, in pre-training, multiple documents may be packed into a single sequence.
+For Qwen, the control token `<|endoftext|>` is inserted after each document to signify that the document has ended and a new document will proceed.
+Common control tokens and their status with respect to Qwen can be found in the following table:
+
+| Type | Qwen (training) | Note | 
+| :-- | :-- | :-- |
+| eod token | `<\|endoftext\|>` | end of document, which are inserted between documents inside a packed training sequence |
+| bot token | `<\|im_start\|>` | start of each turn, which is prepended to each turn |
+| eot token | `<\|im_end\|>` | end of each turn, which is appended to each turn |
+| unk token | no unk token | BBPE ensures no unknown tokens for Qwen. |
+| pad token | no pad token | Qwen does not make use of padded sequence in training. One could use any special token together with the attention masks returned by the tokenizer. It is commonly set the same as eod for Qwen. |
+| bos token | no bos token | Qwen does not prepend a fixed token to each packed training sequence.[^boseos] |
+| eos token | no eos token | Qwen does not append a fixed token to each packed training sequence. However, as most frameworks do not have the concept of eot and use eos instead for stopping criteria in inference, eos token is set to eot for Qwen.[^boseos] |
+
+[^boseos]: bos token should not be set to `<\|im_start\|>` or you may see double bot tokens for the first turn in fine-tuning. eos token set to `<\|im_end\|>` is fine, because double eot tokens for the last turn are less harmful in fine-tuning.
+
+
+## Chat Template
+
+Chat templates provide a structured format for conversational interactions, where predefined placeholders or prompts are used to elicit responses from the model that adhere to a desired dialogue flow or context.
+Different models may use different kinds of chat template to format the conversations. 
+It is crucial to use the designated one to ensure the precise control over the LLM's generation process.
+
+Qwen uses the following format (ChatML[^chatml]), making use of control tokens to format each turn in the conversations
+```text
+<|im_start|>{{role}}
+{{content}}<|im_end|>
+```
+The user input takes the role of `user` and the model generation takes the role of `assistant`. 
+Qwen also supports the meta message that instruct the model to perform specific actions or generate text with certain characteristics, such as altering tone, style, or content, which takes the role of `system`.
+Starting with Qwen3, no default system messages are used.
+
+The following is a full example:
+```text
+<|im_start|>system
+You are a cat.<|im_end|>
+<|im_start|>user
+hello<|im_end|>
+<|im_start|>assistant
+*Meow~* Hello there! The sun is shining so brightly today, and I'm feeling extra fluffy. Did you bring me a treat? 🐾<|im_end|>
+<|im_start|>user
+Explain large language models like I'm 5.<|im_end|>
+<|im_start|>assistant
+*Paws at a toy, then looks up with curious eyes*  
+
+Hey there! 🐾 Imagine you have a super-smart robot friend who loves to talk and play. This robot has *gigantic* brainpower (like a million puzzle pieces all stuck together!) and knows *everything* about stories, animals, and even how to make up new words.  
+
+When you ask it a question, like “What’s a rainbow?” it uses its brain to find the answer and then *tells you* it in a way that makes sense. It can even help you write a story or solve a puzzle!  
+
+But here’s the magic: it’s not just a robot—it’s like a *super-duper* smart helper that learns more every day. It’s like having a friend who’s always curious and wants to help you explore the world! 🌟  
+
+*Meow~* Want to ask it something fun? 😺<|im_end|><|endoftext|>
+```
+
+[^chatml]: For historical reference only, ChatML is first described by the OpenAI Python SDK. The last available version is [this](https://github.com/openai/openai-python/blob/v0.28.1/chatml.md). Please also be aware that that document lists use cases intended for OpenAI models. For Qwen2.5 models, please only use as in our guide.
+
+### Tool Calling
+
+Qwen3 supports tool calling or function calling and uses a template akin to [Hermes](https://github.com/NousResearch/Hermes-Function-Calling#prompt-format-for-function-calling).
+
+The template is as follows:
+```text
+<|im_start|>system
+# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
+{{JSON Schema of function 1}}
+{{JSON Schema of function 2}}
+</tools>
+
+For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
+<tool_call>
+{"name": <function-name>, "arguments": <args-json-object>}
+</tool_call><|im_end|>
+<|im_start|>user
+{{user content}}<|im_end|>
+<|im_start|>assistant
+<tool_call>
+{{tool call 1}}
+</tool_call>
+<tool_call>
+{{tool call 2}}
+</tool_call><|im_end|>
+<|im_start|>user
+<tool_response>
+{{tool result 1}}
+</tool_response>
+<tool_response>
+{{tool result 2}}
+</tool_response><|im_end|>
+<|im_start|>assistant
+{{assistant content}}<|im_end|>
+```
+
+It should be noted that
+- The models support parallel tool calling and mulit-turn/multi-step tool calling.
+- There may be additional content in assistant messages containing tool calls.
+- The arguments field in the generated tool calls should be of type object instead of type string.
+- Tool results are treated as special user messages.
+
+In general, we recommend using the tokenizer to format the tool calls or let Qwen-Agent handle the formatting.
+
+### Thinking
+
+Qwen3 supports thinking mode and uses a structured format for thinking content, which uses the `<think>` and `</think>` tokens to separate the thinking content from the regular response.
+The template for the final round is as follows:
+
+```text
+<|im_start|>user
+{{user content}}<|im_end|>
+<|im_start|>assistant
+<think>
+{{thinking content}}
+</think>
+
+{{assistant content}}<|im_end|>
+```
+
+The thinking block should only be included in the final round except for multi-step tool calls.
+
+
+## Causal Language Models
+
+Causal language models, also known as autoregressive language models or decoder-only language models, are a type of machine learning model designed to predict the next token in a sequence based on the preceding tokens. 
+In other words, they generate text one token at a time, using the previously generated tokens as context. 
+The "causal" aspect refers to the fact that the model only considers the past context (the already generated tokens) when predicting the next token, not any future tokens.
+
+Causal language models are widely used for various natural language processing tasks involving text completion and generation. 
+They have been particularly successful in generating coherent and contextually relevant text, making them a cornerstone of modern natural language understanding and generation systems.
+
+Qwen models are causal language models suitable for text completion.
+
+### Context Length
+
+As Qwen models are causal language models, in theory there is only one length limit of the entire sequence.
+However, since there is often packing in training and each sequence may contain multiple individual pieces of texts. 
+**How long the model can generate or complete ultimately depends on the use case and in that case how long each document (for pre-training) or each turn (for post-training) is in training.**
+
+For Qwen3, the packed sequence length in pre-training is 32,768 tokens and may be extended to 131,072 tokens if mentioned in the modelcards.
+The maximum length of the assistant message is 38,912 tokens for thinking modes and 16,384 tokens for non-thinking modes.
+
+For Qwen3-2507, the packed sequence length in pre-training is 262,144 tokens and may be extended to 1M tokens.
+The maximum length of the assistant message is 81,920 tokens for thinking models and 16,384 tokens for instruct models.
+
+:::{tip}
+In our testing, we find that the post-trained models could generate coherent content that is far longer than what is trained on, e.g., from 16,384 tokens to 32,768 tokens, especially for coding and similar tasks that have "clear rules".
+
+In general, we advise that one should evaluate the quality of the generated content of different lengths before determining the optimal generation length.
+:::

docs/source/getting_started/quantization_benchmark.rst

@@ -0,0 +1,52 @@
+Performance of Quantized Models
+==================================
+
+.. attention:: 
+    To be updated for Qwen3.
+
+This section reports the generation performance of quantized
+models (including GPTQ and AWQ) of the Qwen2 series. Specifically, we
+report:
+
+* MMLU (Accuracy)
+* C-Eval (Accuracy)
+* IFEval (Strict Prompt-Level Accuracy)
+
+We use greedy decoding in evaluating all models.
+
++---------------------+--------------+---------+-------+--------+--------+
+|                     | Quantization | Average | MMLU  | C-Eval | IFEval |
++=====================+==============+=========+=======+========+========+
+| Qwen2-72B-Instruct  | BF16         | 81.3    | 82.3  | 83.8   | 77.6   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int8    | 80.7    | 81.3  | 83.4   | 77.5   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int4    | 81.2    | 80.8  | 83.9   | 78.9   |
++                     +--------------+---------+-------+--------+--------+
+|                     | AWQ          | 80.4    | 80.5  | 83.9   | 76.9   |
++---------------------+--------------+---------+-------+--------+--------+
+| Qwen2-7B-Instruct   | BF16         | 66.9    | 70.5  | 77.2   | 53.1   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int8    | 66.2    | 69.1  | 76.7   | 52.9   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int4    | 64.1    | 67.8  | 75.2   | 49.4   |
++                     +--------------+---------+-------+--------+--------+
+|                     | AWQ          | 64.1    | 67.4  | 73.6   | 51.4   |
++---------------------+--------------+---------+-------+--------+--------+
+| Qwen2-1.5B-Instruct | BF16         | 48.4    | 52.4  | 63.8   | 29.0   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int8    | 48.1    | 53.0  | 62.5   | 28.8   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int4    | 45.0    | 50.7  | 57.4   | 27.0   |
++                     +--------------+---------+-------+--------+--------+
+|                     | AWQ          | 46.5    | 51.6  | 58.1   | 29.9   |
++---------------------+--------------+---------+-------+--------+--------+
+| Qwen2-0.5B-Instruct | BF16         | 34.4    | 37.9  | 45.2   | 20.0   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int8    | 32.6    | 35.6  | 43.9   | 18.1   |
++                     +--------------+---------+-------+--------+--------+
+|                     | GPTQ-Int4    | 29.7    | 33.0  | 39.2   | 16.8   |
++                     +--------------+---------+-------+--------+--------+
+|                     | AWQ          | 31.1    | 34.4  | 42.1   | 16.7   |
++---------------------+--------------+---------+-------+--------+--------+
+