ms-swift 4.4.2__tar.gz → 4.5.0.dev0__tar.gz

{ms_swift-4.4.2/ms_swift.egg-info → ms_swift-4.5.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ms_swift
-Version: 4.4.2
+Version: 4.5.0.dev0
 Summary: Swift: Scalable lightWeight Infrastructure for Fine-Tuning
 Home-page: https://github.com/modelscope/ms-swift
 Author: DAMO ModelScope teams
@@ -169,7 +169,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 📝 Introduction
-🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
+🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Kimi-K3, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
 
 🍔 In addition, ms-swift integrates the latest training technologies, including Megatron parallelism techniques such as TP, PP, CP, EP to accelerate training, as well as numerous GRPO algorithm family reinforcement learning algorithms including: GRPO, DAPO, GSPO, SAPO, CISPO, RLOO, Reinforce++, etc. to enhance model intelligence. ms-swift supports a wide range of training tasks, including preference learning algorithms such as DPO, KTO, RM, CPO, SimPO, ORPO, as well as Embedding, Reranker, and sequence classification tasks. ms-swift provides full-pipeline support for large model training, including acceleration for inference, evaluation, and deployment modules using vLLM, SGLang, and LMDeploy, as well as model quantization using GPTQ, AWQ, BNB, and FP8 technologies.
 
@@ -195,6 +195,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 🎉 News
+- 🎁 2026.07.22: Support inference for the moonshotai multimodal model [Kimi-K3](https://modelscope.cn/models/moonshotai/Kimi-K3), including the XTML chat template, thinking channel (`reasoning_effort`) and tool calling (`--agent_template kimi_k3`).
 - 🎁 2026.06.10: Megatron-Ray now supports GRPO and GKD training. See [docs](./docs/source_en/Instruction/Ray.md) and [examples](examples/ray).
 - 🎁 2026.03.03: **ms-swift v4.0** major version is officially released. For release notes, please refer to [here](https://github.com/modelscope/ms-swift/releases/tag/v4.0.0). You can provide your suggestions to us in [this issue](https://github.com/modelscope/ms-swift/issues/7250). Thank you for your support.
 - 🎁 2025.11.14: Megatron GRPO is now available!  Check out the [docs](./docs/source_en/Megatron-SWIFT/GRPO.md) and [examples](examples/megatron/grpo).
@@ -438,7 +439,7 @@ Supported Training Methods:
 | [PPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/ppo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ❌                                                            |
 | [DPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/dpo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/dpo) |
 | [KTO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/kto.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/kto.sh) |
-| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
+| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [CPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/cpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [SimPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/simpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [ORPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/orpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/README.md

@@ -51,7 +51,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 📝 Introduction
-🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
+🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Kimi-K3, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
 
 🍔 In addition, ms-swift integrates the latest training technologies, including Megatron parallelism techniques such as TP, PP, CP, EP to accelerate training, as well as numerous GRPO algorithm family reinforcement learning algorithms including: GRPO, DAPO, GSPO, SAPO, CISPO, RLOO, Reinforce++, etc. to enhance model intelligence. ms-swift supports a wide range of training tasks, including preference learning algorithms such as DPO, KTO, RM, CPO, SimPO, ORPO, as well as Embedding, Reranker, and sequence classification tasks. ms-swift provides full-pipeline support for large model training, including acceleration for inference, evaluation, and deployment modules using vLLM, SGLang, and LMDeploy, as well as model quantization using GPTQ, AWQ, BNB, and FP8 technologies.
 
@@ -77,6 +77,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 🎉 News
+- 🎁 2026.07.22: Support inference for the moonshotai multimodal model [Kimi-K3](https://modelscope.cn/models/moonshotai/Kimi-K3), including the XTML chat template, thinking channel (`reasoning_effort`) and tool calling (`--agent_template kimi_k3`).
 - 🎁 2026.06.10: Megatron-Ray now supports GRPO and GKD training. See [docs](./docs/source_en/Instruction/Ray.md) and [examples](examples/ray).
 - 🎁 2026.03.03: **ms-swift v4.0** major version is officially released. For release notes, please refer to [here](https://github.com/modelscope/ms-swift/releases/tag/v4.0.0). You can provide your suggestions to us in [this issue](https://github.com/modelscope/ms-swift/issues/7250). Thank you for your support.
 - 🎁 2025.11.14: Megatron GRPO is now available!  Check out the [docs](./docs/source_en/Megatron-SWIFT/GRPO.md) and [examples](examples/megatron/grpo).
@@ -320,7 +321,7 @@ Supported Training Methods:
 | [PPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/ppo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ❌                                                            |
 | [DPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/dpo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/dpo) |
 | [KTO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/kto.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/kto.sh) |
-| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
+| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [CPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/cpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [SimPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/simpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [ORPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/orpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0/ms_swift.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ms_swift
-Version: 4.4.2
+Version: 4.5.0.dev0
 Summary: Swift: Scalable lightWeight Infrastructure for Fine-Tuning
 Home-page: https://github.com/modelscope/ms-swift
 Author: DAMO ModelScope teams
@@ -169,7 +169,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 📝 Introduction
-🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
+🍲 **ms-swift** is a large model and multimodal large model fine-tuning and deployment framework provided by the ModelScope community. It now supports training (pre-training, fine-tuning, human alignment), inference, evaluation, quantization, and deployment for 600+ text-only large models and 400+ multimodal large models. Large models include: Qwen3, Qwen3.5, InternLM3, GLM4.5, Mistral, DeepSeek-R1, Llama4, etc. Multimodal large models include: Qwen3-VL, Qwen3-Omni, Kimi-K3, Llava, InternVL3.5, MiniCPM-V-4, Ovis2.5, GLM4.5-V, DeepSeek-VL2, etc.
 
 🍔 In addition, ms-swift integrates the latest training technologies, including Megatron parallelism techniques such as TP, PP, CP, EP to accelerate training, as well as numerous GRPO algorithm family reinforcement learning algorithms including: GRPO, DAPO, GSPO, SAPO, CISPO, RLOO, Reinforce++, etc. to enhance model intelligence. ms-swift supports a wide range of training tasks, including preference learning algorithms such as DPO, KTO, RM, CPO, SimPO, ORPO, as well as Embedding, Reranker, and sequence classification tasks. ms-swift provides full-pipeline support for large model training, including acceleration for inference, evaluation, and deployment modules using vLLM, SGLang, and LMDeploy, as well as model quantization using GPTQ, AWQ, BNB, and FP8 technologies.
 
@@ -195,6 +195,7 @@ You can contact us and communicate with us by adding our group:
 
 
 ## 🎉 News
+- 🎁 2026.07.22: Support inference for the moonshotai multimodal model [Kimi-K3](https://modelscope.cn/models/moonshotai/Kimi-K3), including the XTML chat template, thinking channel (`reasoning_effort`) and tool calling (`--agent_template kimi_k3`).
 - 🎁 2026.06.10: Megatron-Ray now supports GRPO and GKD training. See [docs](./docs/source_en/Instruction/Ray.md) and [examples](examples/ray).
 - 🎁 2026.03.03: **ms-swift v4.0** major version is officially released. For release notes, please refer to [here](https://github.com/modelscope/ms-swift/releases/tag/v4.0.0). You can provide your suggestions to us in [this issue](https://github.com/modelscope/ms-swift/issues/7250). Thank you for your support.
 - 🎁 2025.11.14: Megatron GRPO is now available!  Check out the [docs](./docs/source_en/Megatron-SWIFT/GRPO.md) and [examples](examples/megatron/grpo).
@@ -438,7 +439,7 @@ Supported Training Methods:
 | [PPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/ppo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ❌                                                            |
 | [DPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/dpo) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/dpo) |
 | [KTO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/kto.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | [✅](https://github.com/modelscope/ms-swift/blob/main/examples/train/multimodal/rlhf/kto.sh) |
-| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
+| [Reward Model](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/rm) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [CPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/cpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [SimPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/simpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |
 | [ORPO](https://github.com/modelscope/ms-swift/blob/main/examples/train/rlhf/orpo.sh) | ✅                                                            | ✅    | ✅                                                            | ✅                                                            | ✅                                                            | ✅                                                            |

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/ms_swift.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ swift/agent_template/glm4.py
 swift/agent_template/hermes.py
 swift/agent_template/hy_v3.py
 swift/agent_template/kimi_k25.py
+swift/agent_template/kimi_k3.py
 swift/agent_template/llama.py
 swift/agent_template/mapping.py
 swift/agent_template/minicpm5.py
@@ -256,6 +257,7 @@ swift/model/npu_patch/mindspeed.py
 swift/model/npu_patch/model.py
 swift/model/npu_patch/utils.py
 swift/model/npu_patch/vllm_ascend.py
+swift/model/npu_patch/vllm_ascend_lora.py
 swift/model/npu_patch/vllm_ascend_memory.py
 swift/model/npu_patch/vllm_ascend_moe.py
 swift/optimizers/__init__.py

ms_swift-4.5.0.dev0/swift/agent_template/kimi_k3.py

@@ -0,0 +1,151 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+import json
+import re
+from typing import List, Optional, Tuple, Union
+
+from swift.infer_engine import Function
+from swift.template import Prompt
+from .base import BaseAgentTemplate
+
+
+class KimiK3AgentTemplate(BaseAgentTemplate):
+    """Agent template for Kimi K3 models (XTML format).
+
+    Aligned with `encoding_k3.py` in the model repo:
+    - Tools are declared in a separate system message with `type="tool-declare"`,
+      carrying the deep-sorted JSONSchema in a compact ```json block.
+    - Tool calls follow the closed response channel:
+      <|close|>response<|sep|><|open|>tools<|sep|>
+      <|open|>call tool="{name}" index="{i}"<|sep|>
+      <|open|>argument key="{key}" type="{type}"<|sep|>{value}<|close|>argument<|sep|>
+      <|close|>call<|sep|><|close|>tools<|sep|>
+    - Tool response:
+      <|open|>message role="tool" tool="{name}" index="{i}"<|sep|>{content}<|close|>message<|sep|><|end_of_msg|>
+    """
+
+    @staticmethod
+    def _deep_sort(obj):
+        if isinstance(obj, dict):
+            return {k: KimiK3AgentTemplate._deep_sort(v) for k, v in sorted(obj.items())}
+        if isinstance(obj, list):
+            return [KimiK3AgentTemplate._deep_sort(item) for item in obj]
+        return obj
+
+    @staticmethod
+    def _escape_attr(value) -> str:
+        return str(value).replace('&', '&amp;').replace('"', '&quot;')
+
+    @staticmethod
+    def _unescape_attr(value: str) -> str:
+        return value.replace('&quot;', '"').replace('&amp;', '&')
+
+    @staticmethod
+    def _xtml_type(value) -> str:
+        if isinstance(value, bool):
+            return 'boolean'
+        if value is None:
+            return 'null'
+        if isinstance(value, (int, float)):
+            return 'number'
+        if isinstance(value, str):
+            return 'string'
+        if isinstance(value, dict):
+            return 'object'
+        return 'array'
+
+    @staticmethod
+    def _xtml_value(value) -> str:
+        if isinstance(value, str):
+            return value
+        return json.dumps(value, ensure_ascii=False)
+
+    def get_toolcall(self, response: str) -> List[Function]:
+        call_pattern = r'<\|open\|>call tool="(.*?)"(?: index="\d+")?<\|sep\|>(.*?)<\|close\|>call<\|sep\|>'
+        arg_pattern = r'<\|open\|>argument key="(.*?)" type="(.*?)"<\|sep\|>(.*?)<\|close\|>argument<\|sep\|>'
+        json_pattern = r'<\|open\|>json type="object"<\|sep\|>(.*?)<\|close\|>json<\|sep\|>'
+        functions = []
+        for name, body in re.findall(call_pattern, response, re.DOTALL):
+            name = self._unescape_attr(name)
+            json_match = re.search(json_pattern, body, re.DOTALL)
+            if json_match:
+                arguments = self._parse_json(json_match.group(1))
+                if arguments is None:
+                    arguments = json_match.group(1)
+            else:
+                arguments = {}
+                for key, arg_type, value in re.findall(arg_pattern, body, re.DOTALL):
+                    key = self._unescape_attr(key)
+                    if arg_type == 'string':
+                        arguments[key] = value
+                    elif arg_type == 'null':
+                        arguments[key] = None
+                    else:
+                        parsed = self._parse_json(value)
+                        arguments[key] = value if parsed is None else parsed
+            functions.append(Function(name=name, arguments=arguments))
+        if len(functions) == 0:
+            # compat react_en
+            return super().get_toolcall(response)
+        return functions
+
+    def _format_tools(self, tools: List[Union[str, dict]], system: Optional[str] = None, user_message=None) -> str:
+        tools = self._deep_sort([self.wrap_tool(tool) for tool in tools])
+        tools_json = json.dumps(tools, ensure_ascii=False, separators=(',', ':'))
+        tool_content = ('# Tools\nHere are the available tools, described in JSONSchema.\n\n'
+                        f'```json\n{tools_json}\n```')
+        # Hijack the `<|open|>message {{SYSTEM}}<|close|>message<|sep|><|end_of_msg|>` system
+        # prefix so the tool-declare message is rendered before the plain system message.
+        res = f'role="system" type="tool-declare"<|sep|>{tool_content}'
+        if system:
+            res += f'<|close|>message<|sep|><|end_of_msg|><|open|>message role="system"<|sep|>{system}'
+        return res
+
+    def _format_tool_calls(self, tool_call_messages) -> str:
+        calls = []
+        for index, message in enumerate(tool_call_messages, start=1):
+            tool_call = self._parse_tool_call(message['content'])
+            name, arguments = tool_call['name'], tool_call['arguments']
+            call = [f'<|open|>call tool="{self._escape_attr(name)}" index="{index}"<|sep|>']
+            if isinstance(arguments, dict):
+                for key, value in arguments.items():
+                    call.append(f'<|open|>argument key="{self._escape_attr(key)}" '
+                                f'type="{self._xtml_type(value)}"<|sep|>'
+                                f'{self._xtml_value(value)}<|close|>argument<|sep|>')
+            else:
+                # non-object arguments fall back to a raw json block
+                json_block = arguments if isinstance(arguments, str) else json.dumps(arguments, ensure_ascii=False)
+                call.append(f'<|open|>json type="object"<|sep|>{json_block}<|close|>json<|sep|>')
+            call.append('<|close|>call<|sep|>')
+            calls.append(''.join(call))
+        return f'<|open|>tools<|sep|>{"".join(calls)}<|close|>tools<|sep|>'
+
+    def _add_tool_call_prefix(self, tool_content: str, pre_message=None) -> str:
+        # Without a preceding assistant text message (whose converted content already ends
+        # with `<|close|>response<|sep|>`), the empty response channel must be closed here.
+        if pre_message is None or pre_message['role'] != 'assistant':
+            tool_content = '<|close|>response<|sep|>' + tool_content
+        return tool_content
+
+    def _format_tool_responses(
+        self,
+        assistant_content,
+        tool_messages,
+    ) -> Tuple[str, 'Prompt']:
+        contents = assistant_content if isinstance(assistant_content, list) else [assistant_content]
+        joined = ''.join(c for c in contents if isinstance(c, str))
+        with_action = self.keyword.action in joined and self.keyword.action_input in joined
+        if with_action:
+            return super()._format_tool_responses(assistant_content, tool_messages)
+        # `tool`/`index` attributes are resolved from the preceding assistant tool calls,
+        # in call order (aligned with the `tool_index` enumeration in encoding_k3.py).
+        names = re.findall(r'<\|open\|>call tool="(.*?)" index="\d+"<\|sep\|>', joined)
+        res = ['<|close|>message<|sep|><|end_of_msg|>']
+        for index, tool_message in enumerate(tool_messages, start=1):
+            if index <= len(names):
+                name = self._unescape_attr(names[index - 1])
+            else:
+                name = tool_message.get('tool') or tool_message.get('name') or ''
+            res.append(f'<|open|>message role="tool" tool="{self._escape_attr(name)}" index="{index}"<|sep|>'
+                       f'{tool_message["content"]}<|close|>message<|sep|><|end_of_msg|>')
+        res.append('<|open|>message role="assistant"<|sep|>')
+        return assistant_content, res

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/agent_template/mapping.py

@@ -7,6 +7,7 @@ from .glm4 import (ChatGLM4AgentTemplate, GLM4_5AgentTemplate, GLM4_7AgentTempla
                    GLM5_1AgentTemplate)
 from .hermes import HermesAgentTemplate, HunyuanHermesAgentTemplate
 from .hy_v3 import HyV3AgentTemplate, HyV3PreviewAgentTemplate
+from .kimi_k3 import KimiK3AgentTemplate
 from .kimi_k25 import KimiK25AgentTemplate
 from .llama import Llama3AgentTemplate, Llama4AgentTemplate
 from .minicpm5 import MiniCPM5AgentTemplate
@@ -57,5 +58,6 @@ agent_template_map = {
     'mistral': MistralAgentTemplate,
     'youtu': YoutuAgentTemplate,
     'kimi_k25': KimiK25AgentTemplate,
+    'kimi_k3': KimiK3AgentTemplate,
     'minicpm5': MiniCPM5AgentTemplate,
 }

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/arguments/rlhf_args.py

@@ -568,6 +568,103 @@ class RLHFArguments(TeacherModelArguments, GRPOArguments, PPOArguments, RewardMo
             raise NotImplementedError('Currently, async_generate is not supported with multi-turn functionality.')
 
         self._check_opd_rl()
+        self._check_rlsd()
+        self._check_sdar()
+
+    def _check_rlsd(self):
+        """Validate RLSD (Self-Distilled RLVR) advantage reweighting parameters.
+
+        RLSD reweights the per-sequence GRPO advantage per token using the teacher-vs-student
+        logprob gap. It relies on an OPSD teacher forward driven by a per-sample ``teacher_prompt``
+        column (privileged context, e.g. question + reference solution / GT answer). It also needs
+        an environment reward (``reward_funcs``) because the reweight direction uses ``sign(A)``.
+
+        Two teacher modes are supported (mirroring the reference's ``freeze_teacher_model`` flag):
+
+        * **Dynamic self-distillation** (no ``--teacher_model``, default): teacher = current policy
+          evaluated on the privileged prompt (paper's same-model, two-contexts Δ_t; equivalent to
+          the reference's ``freeze_teacher_model=false``).
+        * **Frozen local teacher** (``--teacher_model <ckpt>``): a separate model scores the
+          privileged prompt under ``no_grad`` and is never in the optimizer, so it stays frozen
+          throughout training. Point ``--teacher_model`` at the initial policy checkpoint to
+          reproduce the reference's ``freeze_teacher_model=true`` (frozen θ₀ anchor).
+        """
+        if self.advantage_reweight != 'rlsd':
+            return
+        if not (0.0 <= self.rlsd_lambda <= 1.0):
+            raise ValueError(f'rlsd_lambda must be in [0, 1], got {self.rlsd_lambda}.')
+        if self.rlsd_reweight_clip_range < 0:
+            raise ValueError(f'rlsd_reweight_clip_range (eps_w) must be >= 0, got {self.rlsd_reweight_clip_range}.')
+        if not self.reward_funcs:
+            raise ValueError('advantage_reweight=rlsd requires reward_funcs: the reweight direction uses '
+                             'sign(A) of the GRPO advantage, which needs an environment reward.')
+        if self.use_liger_kernel:
+            raise ValueError('advantage_reweight=rlsd is not compatible with use_liger_kernel '
+                             '(the fused loss path bypasses the per-token RLSD reweight).')
+        if self.loss_type in ['real', 'fipo']:
+            raise ValueError(f'advantage_reweight=rlsd does not support loss_type={self.loss_type!r} '
+                             '(it reduces the advantage to a per-sequence scalar).')
+        if self.off_policy_sequence_mask_delta is not None:
+            raise ValueError('advantage_reweight=rlsd does not support off_policy_sequence_mask_delta.')
+        # Local frozen teacher (--teacher_model) is allowed: it drives the OPSD teacher forward on
+        # the privileged prompt via the same code path as OPD-RL, and use_rlsd bypasses OPD-RL's
+        # additive term (grpo_trainer.py:266) so there is no double-count. The API-teacher path
+        # (--teacher_model_server) scores tokens over a remote inference call whose tokenizer
+        # alignment with the student is not guaranteed, so keep it gated for RLSD's per-token reweight.
+        if self.teacher_model_server is not None:
+            raise ValueError('advantage_reweight=rlsd does not support --teacher_model_server (remote API '
+                             'teacher). Use --teacher_model <local ckpt> for a frozen local teacher, or omit '
+                             'both to use dynamic self-distillation (teacher = current policy).')
+        if self.beta not in (0, 0.0):
+            logger.warning(f'advantage_reweight=rlsd: the reference RLSD config disables KL (beta=0), '
+                           f'but beta={self.beta}. Consider setting --beta 0.')
+        if self.teacher_model is not None:
+            logger.info(f'advantage_reweight=rlsd: frozen-teacher mode — --teacher_model={self.teacher_model!r} scores '
+                        f'the `teacher_prompt` column under no_grad and stays frozen throughout training (matches the '
+                        f'RLSD reference freeze_teacher_model=true when this checkpoint is the initial policy).')
+        else:
+            logger.info('advantage_reweight=rlsd: dynamic self-distillation mode — expecting a `teacher_prompt` '
+                        'column in the dataset; teacher = current policy on the privileged prompt.')
+
+    def _check_sdar(self):
+        """Validate SDAR (Self-Distilled Agentic RL) confidence-gated distillation parameters.
+
+        SDAR adds a confidence-gated teacher distillation auxiliary loss to the GRPO policy loss:
+        ``loss = policy_loss + sdar_loss_coef * token-mean(sigmoid(gate_beta*Δ) * Δ)`` with
+        ``Δ = logP_T - logP_S``. It reuses the OPSD teacher forward driven by a per-sample
+        ``teacher_prompt`` column (privileged / skill-augmented context). Unlike RLSD it does NOT
+        modify the advantage, and the reference keeps a small KL (so KL is not forced off).
+
+        Two teacher modes are supported (mirroring the reference's self-distillation setup):
+
+        * **Dynamic self-distillation** (no ``--teacher_model``, default): teacher = current policy
+          on the privileged ``teacher_prompt`` (the reference ALFWorld/Search/WebShop setting).
+        * **Frozen local teacher** (``--teacher_model <ckpt>``): a separate model scores the
+          privileged prompt under ``no_grad`` and stays frozen throughout training.
+        """
+        if self.sdar_loss_coef <= 0:
+            return
+        if self.sdar_gate_beta <= 0:
+            raise ValueError(f'sdar_gate_beta must be > 0, got {self.sdar_gate_beta}.')
+        if self.use_liger_kernel:
+            raise ValueError('sdar_loss_coef>0 is not compatible with use_liger_kernel (the fused Liger '
+                             'loss path bypasses the per-token loss where the SDAR term is added).')
+        if self.advantage_reweight == 'rlsd':
+            raise ValueError('sdar_loss_coef>0 cannot be combined with advantage_reweight=rlsd: SDAR adds a '
+                             'confidence-gated distillation loss while RLSD reweights the advantage — pick one '
+                             'teacher-distillation mechanism.')
+        if self.teacher_model_server is not None:
+            raise ValueError('sdar_loss_coef>0 does not support --teacher_model_server (remote API teacher). '
+                             'Use --teacher_model <local ckpt> for a frozen local teacher, or omit both to use '
+                             'dynamic self-distillation (teacher = current policy on the `teacher_prompt`).')
+        if self.teacher_model is not None:
+            logger.info(f'SDAR (sdar_loss_coef={self.sdar_loss_coef}): frozen-teacher mode — '
+                        f'--teacher_model={self.teacher_model!r} scores the `teacher_prompt` column under no_grad '
+                        f'and stays frozen throughout training.')
+        else:
+            logger.info(f'SDAR (sdar_loss_coef={self.sdar_loss_coef}): dynamic self-distillation mode — expecting '
+                        'a `teacher_prompt` column in the dataset; teacher = current policy on the privileged '
+                        'prompt. Without teacher logps the SDAR loss is skipped (behaves as plain GRPO).')
 
     def _check_opd_rl(self):
         """Fail-fast OPD-RL (teacher distillation on GRPO) parameter compatibility.

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/infer_engine/protocol.py

@@ -191,6 +191,7 @@ class RequestConfig:
     temperature: Optional[float] = None
     top_k: Optional[int] = None
     top_p: Optional[float] = None
+    min_p: Optional[float] = None
     repetition_penalty: Optional[float] = None
     num_beams: int = 1
     stop: Optional[List[str]] = field(default_factory=list)

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/infer_engine/vllm_engine.py

@@ -515,7 +515,7 @@ class VllmEngine(InferEngine):
 
     def _prepare_generation_config(self, request_config: RequestConfig) -> SamplingParams:
         kwargs = {'max_tokens': request_config.max_tokens}
-        for key in ['temperature', 'top_k', 'top_p', 'repetition_penalty']:
+        for key in ['temperature', 'top_k', 'top_p', 'min_p', 'repetition_penalty']:
             new_value = getattr(request_config, key)
             if new_value is None:
                 kwargs[key] = getattr(self.generation_config, key)

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/megatron/__init__.py

@@ -4,6 +4,8 @@ try:
     from transformers.utils import is_torch_npu_available
 
     if is_torch_npu_available():
+        from swift.model.npu_patch.mindspeed import prepare_mindspeed_gdn_import
+        prepare_mindspeed_gdn_import()
         # Enable Megatron on Ascend NPU
         import mindspeed.megatron_adaptor  # F401
     from .init import init_megatron_env

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/megatron/arguments/megatron_args.py

@@ -585,6 +585,10 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
     ddp_timeout: int = 18000000
     ddp_backend: Literal['nccl', 'gloo'] = 'nccl'
     use_distributed_optimizer: bool = True
+    # megatron-fsdp
+    use_megatron_fsdp: bool = False
+    data_parallel_sharding_strategy: Literal['no_shard', 'optim', 'optim_grads',
+                                             'optim_grads_params'] = 'optim_grads_params'
     tensor_model_parallel_size: int = 1
     pipeline_model_parallel_size: int = 1
     decoder_first_pipeline_num_layers: Optional[int] = None
@@ -668,7 +672,8 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
     mtp_decoder_input_detach: bool = False
     mtp_shared_weights: bool = False
 
-    # mcore-bridge
+    # mcore-bridge / megatron-bridge
+    bridge_backend: Literal['mcore-bridge', 'megatron-bridge'] = 'mcore-bridge'
     model: Optional[str] = None
     model_type: Optional[str] = None
     save_safetensors: bool = True
@@ -729,7 +734,7 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
             with open(args_path, 'r', encoding='utf-8') as f:
                 old_args = json.load(f)
             keys = list(f.name for f in fields(MegatronTunerMixin))
-            keys += ['mcore_model', 'task_type', 'num_labels']
+            keys += ['mcore_model', 'task_type', 'num_labels', 'bridge_backend']
             for key in keys:
                 old_value = old_args.get(key)
                 if old_value is not None:
@@ -765,13 +770,30 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
                 raise ValueError('`tuner_type="lora_llm"` is not supported when `language_model_only=True`. '
                                  'Please use `tuner_type="lora"` instead.')
 
+    def _check_bridge_backend(self):
+        """Validate bridge_backend and associated constraints."""
+        if self.bridge_backend == 'megatron-bridge':
+            try:
+                import megatron.bridge
+            except ImportError:
+                raise ImportError('bridge_backend="megatron-bridge" requires the `megatron-bridge` package. '
+                                  'Install it via `pip install megatron-bridge` or use bridge_backend="mcore-bridge".')
+            if self.tuner_type != 'full':
+                raise ValueError('LoRA training is not yet supported with bridge_backend="megatron-bridge". '
+                                 'Please use bridge_backend="mcore-bridge" for LoRA, or set tuner_type="full".')
+        else:
+            require_version('mcore-bridge>=1.5.0', 'Please install mcore-bridge via `pip install mcore-bridge -U`')
+            from swift.megatron.init import _patch_mcore_bridge
+            _patch_mcore_bridge()
+            self._check_mcore_bridge()
+
     def __post_init__(self):
         if self.tuner_type != 'full':
             require_version('peft>=0.15', 'Please install peft>=0.15 to use LoRA in Megatron-SWIFT.')
         RLHFMegatronArgumentsMixin.__post_init__(self)
         MegatronTunerMixin.__post_init__(self)
         os.environ.setdefault('CUDA_DEVICE_MAX_CONNECTIONS', '1')
-        self._check_mcore_bridge()
+        self._check_bridge_backend()
         if self.recompute_granularity == 'none':
             self.recompute_granularity = None
         if self.recompute_granularity == 'selective' and self.recompute_method is not None:
@@ -792,9 +814,18 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
         self.model_type = self.model_info.model_type
         self.model_dir = self.model_info.model_dir
         self.is_multimodal = self.model_meta.is_multimodal
-        self.megatron_model_meta = get_model_meta(self._get_mcore_model_type(self.model_meta))
-        if self.megatron_model_meta is None:
-            raise ValueError(f'Model: {self.model} is not supported.')
+        if self.bridge_backend == 'megatron-bridge':
+            self.megatron_model_meta = None
+            if self.is_multimodal:
+                raise ValueError('Multimodal training is not yet supported with bridge_backend="megatron-bridge". '
+                                 'Please use bridge_backend="mcore-bridge" for multimodal models.')
+            if self.task_type not in (None, 'causal_lm'):
+                raise ValueError(f'task_type={self.task_type!r} is not yet supported with '
+                                 f'bridge_backend="megatron-bridge".')
+        else:
+            self.megatron_model_meta = get_model_meta(self._get_mcore_model_type(self.model_meta))
+            if self.megatron_model_meta is None:
+                raise ValueError(f'Model: {self.model} is not supported.')
         self._init_teacher_model()
         if self.apply_wd_to_qk_layernorm and self.model_type not in {'qwen3_next', 'qwen3_5', 'qwen3_5_moe'}:
             raise ValueError('apply_wd_to_qk_layernorm is only supported for qwen3_next, qwen3_5 and qwen3_5_moe')
@@ -866,9 +897,26 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
             raise ValueError('Tensor parallel communication/GEMM overlap can happen only when '
                              'sequence parallelism is enabled')
 
+        self._check_megatron_fsdp()
         self._init_distributed()
         self._check_muon()
 
+    def _check_megatron_fsdp(self):
+        if not self.use_megatron_fsdp:
+            return
+        # Megatron-FSDP is only compatible with the distributed optimizer.
+        if not self.use_distributed_optimizer:
+            logger.info('Megatron-FSDP is only compatible with use_distributed_optimizer=True; setting it to True.')
+            self.use_distributed_optimizer = True
+        # Only sgd/adam are supported by Megatron-FSDP.
+        if self.optimizer not in ('sgd', 'adam'):
+            raise ValueError(f'Megatron-FSDP does not support the "{self.optimizer}" optimizer yet.')
+        # FSDP requires CUDA_DEVICE_MAX_CONNECTIONS > 1 (or unset). SWIFT sets it to '1' by default,
+        # so override it here before distributed initialization.
+        if os.environ.get('CUDA_DEVICE_MAX_CONNECTIONS') == '1':
+            raise ValueError('Megatron-FSDP requires `CUDA_DEVICE_MAX_CONNECTIONS > 1`, '
+                             'for example you can set `CUDA_DEVICE_MAX_CONNECTIONS=32`')
+
     def _init_attention_backend(self):
         if self.attention_backend.startswith('flash_'):
             from transformer_engine.pytorch.attention.dot_product_attention.utils import FlashAttentionUtils as fa_utils
@@ -939,9 +987,12 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
             self.teacher_model, model_type=self.teacher_model_type, use_hf=self.use_hf, hub_token=self.hub_token)
         self.teacher_model_type = self.teacher_model_info.model_type
         self.teacher_model_dir = self.teacher_model_info.model_dir
-        self.teacher_megatron_model_meta = get_model_meta(self._get_mcore_model_type(self.teacher_model_meta))
-        if self.teacher_megatron_model_meta is None:
-            raise ValueError(f'Model: {self.teacher_model} is not supported.')
+        if self.bridge_backend == 'megatron-bridge':
+            self.teacher_megatron_model_meta = None
+        else:
+            self.teacher_megatron_model_meta = get_model_meta(self._get_mcore_model_type(self.teacher_model_meta))
+            if self.teacher_megatron_model_meta is None:
+                raise ValueError(f'Model: {self.teacher_model} is not supported.')
 
     def _init_vpp_size(self):
         if self.pipeline_model_parallel_layout is not None:
@@ -1024,6 +1075,8 @@ class MegatronArguments(RLHFMegatronArgumentsMixin, MegatronTunerMixin):
             self.eval_iters = 0
 
     def _init_multimodal_full(self):
+        if not self.is_multimodal:
+            return
         visual_cls = self.megatron_model_meta.visual_cls
         if self.tuner_type == 'full' and self.is_multimodal and visual_cls is not None and not self.language_model_only:
             vision_tower = [f'visual.{vit}' for vit in getattr(visual_cls, '_vision_tower', [])]

{ms_swift-4.4.2 → ms_swift-4.5.0.dev0}/swift/megatron/init.py

@@ -9,7 +9,6 @@ from copy import copy, deepcopy
 from tqdm import tqdm
 from transformers.modeling_utils import custom_object_save
 from transformers.utils import is_torch_npu_available
-from transformers.utils.versions import require_version
 
 from swift.model import get_model_processor, save_checkpoint
 from swift.utils import (HfConfigFactory, disable_safe_ddp_context_use_barrier, get_logger, get_modules_to_not_convert,
@@ -115,7 +114,6 @@ def _patch_unified_memory():
 
 
 def _patch_mcore_bridge():
-    require_version('mcore-bridge>=1.5.0', 'please install mcore-bridge via `pip install mcore-bridge -U`')
     import mcore_bridge
     from mcore_bridge import GPTBridge
     logger.info(f'mcore_bridge.__version__: {mcore_bridge.__version__}')
@@ -207,7 +205,6 @@ def init_megatron_env():
     os.environ.pop('VLLM_USE_MODELSCOPE', None)
     logging_level = logging.root.level
     _patch_unified_memory()
-    _patch_mcore_bridge()
     if is_torch_npu_available():
         from swift.model.npu_patcher import patch_mindspeed_fla_gdn_implementation
         patch_mindspeed_fla_gdn_implementation()