# Qwen3-2507：本地运行指南

Qwen 在 2507（2025 年 7 月）发布了他们的更新，适用于 [Qwen3](https://unsloth.ai/docs/zh/mo-xing/tutorials/qwen3-how-to-run-and-fine-tune) 4B、30B 和 235B 模型，引入了“思考（thinking）”和“非思考（non-thinking）”两种变体。非思考型 '**Qwen3-30B-A3B-Instruct-2507**' 和 '**Qwen3-235B-A22B-Instruct-2507'** 具有 256K 的上下文窗口、改进的指令跟随能力、多语言能力和对齐。

思考型模型 '**Qwen3-30B-A3B-Thinking-2507**' 和 '**Qwen3-235B-A22B-Thinking-2507**' 在推理方面表现出色，235B 在逻辑、数学、科学、编码和高级学术任务中达到了最先进的结果（SOTA）。

[Unsloth](https://github.com/unslothai/unsloth) 现在也支持微调和 [强化学习（RL）](https://unsloth.ai/docs/zh/kai-shi-shi-yong/reinforcement-learning-rl-guide) Qwen3-2507 模型的——速度提升 2 倍，显存减少 70%，上下文长度延长 8 倍

<a href="#run-qwen3-30b-a3b-2507-tutorials" class="button secondary">运行 30B-A3B</a><a href="#run-qwen3-235b-a22b-2507-tutorials" class="button secondary">运行 235B-A22B</a><a href="#fine-tuning-qwen3-2507-with-unsloth" class="button secondary">微调 Qwen3-2507</a>

**Unsloth** [**Dynamic 2.0**](https://unsloth.ai/docs/zh/ji-chu/unsloth-dynamic-2.0-ggufs) **GGUFs：**

| 模型                       | 可用于运行的 GGUF：                                                                                                                                                          |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Qwen3-**4B-2507**        | [指令（Instruct）](https://huggingface.co/unsloth/Qwen3-4B-Instruct-2507-GGUF) • [思考（Thinking）](https://huggingface.co/unsloth/Qwen3-4B-Thinking-2507-GGUF)               |
| Qwen3-**30B-A3B**-2507   | [指令（Instruct）](#llama.cpp-run-qwen3-30b-a3b-instruct-2507-tutorial) • [思考（Thinking）](https://huggingface.co/unsloth/Qwen3-30B-A3B-Thinking-2507-GGUF)                 |
| Qwen3-**235B-A22B**-2507 | [指令（Instruct）](https://huggingface.co/unsloth/Qwen3-235B-A22B-Instruct-2507-GGUF) • [思考（Thinking）](https://huggingface.co/unsloth/Qwen3-235B-A22B-Thinking-2507-GGUF) |

## ⚙️ 最佳实践

{% hint style="success" %}
思考模型和 Instruct（指令）模型的设置不同。\
思考模型使用 temperature = 0.6，而指令模型使用 temperature = 0.7\
思考模型使用 top\_p = 0.95，而指令模型使用 top\_p = 0.8
{% endhint %}

为获得最佳性能，Qwen 建议以下设置：

| 指令模型设置：                                                        | 思考模型设置：                                                         |
| -------------------------------------------------------------- | --------------------------------------------------------------- |
| <mark style="background-color:blue;">`温度 = 0.7`</mark>         | <mark style="background-color:blue;">`Temperature = 0.6`</mark> |
| `Min_P = 0.00` （llama.cpp 的默认值为 0.1）                           | `Min_P = 0.00` （llama.cpp 的默认值为 0.1）                            |
| `Top_P = 0.80`                                                 | `Top_P = 0.95`                                                  |
| `TopK = 20`                                                    | `TopK = 20`                                                     |
| `presence_penalty = 0.0 到 2.0` （llama.cpp 默认将其关闭，但为减少重复可以使用此项） | `presence_penalty = 0.0 到 2.0` （llama.cpp 默认将其关闭，但为减少重复可以使用此项）  |

**适当的输出长度**: 对于大多数查询，思考变体请使用输出长度为 `32,768` 对于大多数查询的令牌数，这是足够的。

适用于思考（thinking 包含 `<think></think>`) 和指令的聊天模板如下：

```
<|im_start|>user
嗨！<|im_end|>
<|im_start|>assistant
1+1 等于多少？<|im_end|>
<|im_start|>user
2<|im_end|>
<|im_start|>assistant
```

## 📖 运行 Qwen3-30B-A3B-2507 教程

下面是关于该 [思考（Thinking）](#thinking-qwen3-30b-a3b-thinking-2507) 和 [指令（Instruct）](#instruct-qwen3-30b-a3b-instruct-2507) 模型版本的指南。

### 指令：Qwen3-30B-A3B-Instruct-2507

鉴于这是一个非思考模型，无需设置 `thinking=False` 并且模型不会生成 `<think> </think>` 块。

#### ⚙️ 最佳实践

为实现最佳性能，Qwen 建议以下设置：

* 我们建议使用 `temperature=0.7, top_p=0.8, top_k=20, 和 min_p=0.0` `presence_penalty` 如果框架支持，为减少无限重复建议在 0 到 2 之间设置。
* **`temperature = 0.7`**
* `top_k = 20`
* `min_p = 0.00` （llama.cpp 的默认值为 0.1）
* **`top_p = 0.80`**
* `presence_penalty = 0.0 到 2.0` （llama.cpp 的默认会将其关闭，但为减少重复你可以使用此项）例如可以尝试 1.0。
* 本地原生支持最多 `262,144` 上下文，但你可以将其设置为 `32,768` tokens 以减少内存占用

#### 🦙 Ollama：运行 Qwen3-30B-A3B-Instruct-2507 教程

1. 安装 `ollama` 如果你还没有这样做！你只能运行最大到 32B 的模型。

```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```

2. 运行模型！注意如果失败，您可以在另一个终端中调用 `ollama serve`我们在 Hugging Face 上传中包含了所有修复和建议参数（如 temperature 等），位于 `params` 中！

```bash
ollama run hf.co/unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF:UD-Q4_K_XL
```

#### :sparkles: Llama.cpp：运行 Qwen3-30B-A3B-Instruct-2507 教程

1. 获取最新的 `llama.cpp` 在 [此处的 GitHub](https://github.com/ggml-org/llama.cpp)。您也可以按照下面的构建说明进行。若 `-DGGML_CUDA=ON` 更改为 `-DGGML_CUDA=OFF` 如果您没有 GPU 或仅想要在 CPU 上进行推理。 **对于 Apple Mac / Metal 设备**，设置 `-DGGML_CUDA=OFF` 然后照常继续 - Metal 支持默认启用。

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. 您可以直接通过 HuggingFace 拉取：

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF:Q4_K_XL \
       --jinja -ngl 99 --ctx-size 32768 \
       --temp 0.7 --min-p 0.0 --top-p 0.80 --top-k 20 --presence-penalty 1.0
   ```
3. 通过以下方式下载模型（在安装 `pip install huggingface_hub hf_transfer` ）。你可以选择 UD\_Q4\_K\_XL 或其他量化版本。

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF",
    local_dir = "unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"],
)
```

### 思考：Qwen3-30B-A3B-Thinking-2507

该模型仅原生支持思考模式和 256K 的上下文窗口。默认的聊天模板会自动添加 `<think>` ，因此你可能在输出中只看到一个闭合的 `</think>` 标签。

#### ⚙️ 最佳实践

为实现最佳性能，Qwen 建议以下设置：

* 我们建议使用 `temperature=0.6, top_p=0.95, top_k=20, 和 min_p=0.0` `presence_penalty` 如果框架支持，为减少无限重复建议在 0 到 2 之间设置。
* **`temperature = 0.6`**
* `top_k = 20`
* `min_p = 0.00` （llama.cpp 的默认值为 0.1）
* **`top_p = 0.95`**
* `presence_penalty = 0.0 到 2.0` （llama.cpp 的默认会将其关闭，但为减少重复你可以使用此项）例如可以尝试 1.0。
* 本地原生支持最多 `262,144` 上下文，但你可以将其设置为 `32,768` tokens 以减少内存占用

#### 🦙 Ollama：运行 Qwen3-30B-A3B-Instruct-2507 教程

1. 安装 `ollama` 如果你还没有这样做！你只能运行最大到 32B 的模型。要运行完整的 235B-A22B 模型， [请参阅这里](#run-qwen3-235b-a22b-instruct-2507).

```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```

2. 运行模型！注意如果失败，您可以在另一个终端中调用 `ollama serve`我们在 Hugging Face 上传中包含了所有修复和建议参数（如 temperature 等），位于 `params` 中！

```bash
ollama run hf.co/unsloth/Qwen3-30B-A3B-Thinking-2507-GGUF:UD-Q4_K_XL
```

#### :sparkles: Llama.cpp：运行 Qwen3-30B-A3B-Instruct-2507 教程

1. 获取最新的 `llama.cpp` 在 [此处的 GitHub](https://github.com/ggml-org/llama.cpp)。您也可以按照下面的构建说明进行。若 `-DGGML_CUDA=ON` 更改为 `-DGGML_CUDA=OFF` 如果您没有 GPU 或仅想要在 CPU 上进行推理。 **对于 Apple Mac / Metal 设备**，设置 `-DGGML_CUDA=OFF` 然后照常继续 - Metal 支持默认启用。

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. 你可以直接通过 Hugging Face 拉取：

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/Qwen3-30B-A3B-Thinking-2507-GGUF:Q4_K_XL \
       --jinja -ngl 99 --ctx-size 32768 \
       --temp 0.6 --min-p 0.0 --top-p 0.95 --top-k 20 --presence-penalty 1.0
   ```
3. 通过以下方式下载模型（在安装 `pip install huggingface_hub hf_transfer` ）。你可以选择 UD\_Q4\_K\_XL 或其他量化版本。

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Qwen3-30B-A3B-Thinking-2507-GGUF",
    local_dir = "unsloth/Qwen3-30B-A3B-Thinking-2507-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"],
)
```

## 📖 运行 **Qwen3-235B-A22B-2507** 教程

下面是关于该 [思考（Thinking）](#run-qwen3-235b-a22b-thinking-via-llama.cpp) 和 [指令（Instruct）](#run-qwen3-235b-a22b-instruct-via-llama.cpp) 模型版本的指南。

### 思考：Qwen3-**235B-A22B**-Thinking-2507

该模型仅原生支持思考模式和 256K 的上下文窗口。默认的聊天模板会自动添加 `<think>` ，因此你可能在输出中只看到一个闭合的 `</think>` 标签。

#### :gear: 最佳实践

为获得最佳性能，Qwen 建议对思考模型使用以下设置：

* **`temperature = 0.6`**
* `top_k = 20`
* `min_p = 0.00` （llama.cpp 的默认值为 0.1）
* `top_p = 0.95`
* `presence_penalty = 0.0 到 2.0` （llama.cpp 的默认会将其关闭，但为减少重复你可以使用此项）例如可以尝试 1.0。
* **适当的输出长度**: 对于大多数查询，思考变体请使用输出长度为 `32,768` 对于大多数查询的令牌数，这是足够的。

#### :sparkles:通过 llama.cpp 运行 Qwen3-235B-A22B-Thinking：

对于 Qwen3-235B-A22B，我们将专门使用 Llama.cpp 以优化推理并提供大量选项。

{% hint style="success" %}
如果你想要一个 **全精度未量化版本**，请使用我们的 `Q8_K_XL、Q8_0` 或 `BF16` 版本！
{% endhint %}

1. 获取最新的 `llama.cpp` 在 [此处的 GitHub](https://github.com/ggml-org/llama.cpp)。您也可以按照下面的构建说明进行。若 `-DGGML_CUDA=ON` 更改为 `-DGGML_CUDA=OFF` 如果您没有 GPU 或仅想要在 CPU 上进行推理。 **对于 Apple Mac / Metal 设备**，设置 `-DGGML_CUDA=OFF` 然后照常继续 - Metal 支持默认启用。

   ```bash
   apt-get update
   apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
   git clone https://github.com/ggml-org/llama.cpp
   cmake llama.cpp -B llama.cpp/build \
       -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
   cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
   cp llama.cpp/build/bin/llama-* llama.cpp
   ```
2. 你可以直接使用 llama.cpp 下载模型，但我通常建议使用 `huggingface_hub` 要直接使用 llama.cpp，请执行：

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/Qwen3-235B-A22B-Thinking-2507-GGUF:Q2_K_XL \
       --ctx-size 16384 \
       --n-gpu-layers 99 \
       -ot ".ffn_.*_exps.=CPU" \
       --temp 0.6 \
       --min-p 0.0 \
       --top-p 0.95 \
       --top-k 20 \
       --presence-penalty 1.0
   ```
3. 通过以下方式下载模型（在安装 `pip install huggingface_hub hf_transfer` ）。你可以选择 UD-Q2\_K\_XL 或其他量化版本。

   ```python
   # !pip install huggingface_hub hf_transfer
   import os
   os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # 有时会有限速，因此设为 0 以禁用
   from huggingface_hub import snapshot_download
   snapshot_download(
       repo_id = "unsloth/Qwen3-235B-A22B-Thinking-2507-GGUF",
       local_dir = "unsloth/Qwen3-235B-A22B-Thinking-2507-GGUF",
       allow_patterns = ["*UD-Q2_K_XL*"],
   )
   ```
4. 运行模型并尝试任意提示。
5. 编辑 `--threads -1` 用于设置 CPU 线程数， `--ctx-size` 262114 作为上下文长度， `--n-gpu-layers 99` 用于指定将多少层卸载到 GPU。若 GPU 出现内存不足，请尝试调整它。若仅使用 CPU 推理，请移除此项。

{% hint style="success" %}
使用 `-ot ".ffn_.*_exps.=CPU"` 将所有 MoE 层卸载到 CPU！这实际上允许您将所有非 MoE 层放在一块 GPU 上，从而提高生成速度。如果您有更多 GPU 容量，可以自定义正则表达式以卸载更多层。
{% endhint %}

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Qwen3-235B-A22B-Thinking-2507-GGUF/UD-Q2_K_XL/Qwen3-235B-A22B-Thinking-2507-UD-Q2_K_XL-00001-of-00002.gguf \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --seed 3407 \
    --temp 0.6 \
    --min-p 0.0 \
    --top-p 0.95 \
    --top-k 20
    --presence-penalty 1.0
```

{% endcode %}

### 指令：Qwen3-**235B-A22B**-Instruct-2507

鉴于这是一个非思考模型，无需设置 `thinking=False` 并且模型不会生成 `<think> </think>` 块。

#### ⚙️ 最佳实践

为获得最佳性能，我们建议以下设置：

**1. 采样参数**：我们建议使用 `temperature=0.7、top_p=0.8、top_k=20 和 min_p=0.` `presence_penalty` 如果框架支持，为减少无限重复建议在 0 到 2 之间设置。

2\. **适当的输出长度**：我们建议将输出长度设置为 `16,384` 对于大多数查询的令牌数，这对于指令模型来说是足够的。

3\. **标准化输出格式：** 我们建议在基准测试时使用提示语来标准化模型输出。

* **数学问题**：包括 `请逐步推理，并将你的最终答案放在 \boxed{} 中。` 在提示中。
* **多项选择题**：在提示中添加以下 JSON 结构以标准化响应："请在 \`answer\` 字段中仅显示你选择的字母，例如，\`\\"answer\\": \\"C\\"。

#### :sparkles:通过 llama.cpp 运行 Qwen3-235B-A22B-Instruct：

对于 Qwen3-235B-A22B，我们将专门使用 Llama.cpp 以优化推理并提供大量选项。

{% hint style="info" %}
如果你想要一个 **全精度未量化版本**，请使用我们的 `Q8_K_XL、Q8_0` 或 `BF16` 版本！
{% endhint %}

1. 在此处获取最新的 llama.cpp： [GitHub](https://github.com/ggml-org/llama.cpp) 你可以遵循下面的构建说明。更改 `-DGGML_CUDA=ON` 更改为 `-DGGML_CUDA=OFF` 如果您没有 GPU 或仅想要在 CPU 上进行推理。 **对于 Apple Mac / Metal 设备**，设置 `-DGGML_CUDA=OFF` 然后照常继续 - Metal 支持默认启用。

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

2\. 你可以直接使用 llama.cpp 下载模型，但我通常建议使用 `huggingface_hub` 要直接使用 llama.cpp，请执行：\\

```bash
./llama.cpp/llama-cli \
    -hf unsloth/Qwen3-235B-A22B-Instruct-2507-GGUF:Q2_K_XL \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --temp 0.7 \
    --min-p 0.0 \
    --top-p 0.8 \
    --top-k 20 \
    --repeat-penalty 1.0
```

3\. 通过（在安装之后）下载模型 `pip install huggingface_hub hf_transfer` ）。你可以选择 UD-Q2\_K\_XL 或其他量化版本。

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # 有时会有限速，因此设为 0 以禁用
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/Qwen3-235B-A22B-Instruct-2507-GGUF",
    local_dir = "unsloth/Qwen3-235B-A22B-Instruct-2507-GGUF",
    allow_patterns = ["*UD-Q2_K_XL*"],
)
```

4\. 运行模型并尝试任意提示。5. 编辑 `--threads -1` 用于设置 CPU 线程数， `--ctx-size` 262114 作为上下文长度， `--n-gpu-layers 99` 用于指定将多少层卸载到 GPU。若 GPU 出现内存不足，请尝试调整它。若仅使用 CPU 推理，请移除此项。

{% hint style="success" %}
使用 `-ot ".ffn_.*_exps.=CPU"` 将所有 MoE 层卸载到 CPU！这实际上允许您将所有非 MoE 层放在一块 GPU 上，从而提高生成速度。如果您有更多 GPU 容量，可以自定义正则表达式以卸载更多层。
{% endhint %}

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/Qwen3-235B-A22B-Instruct-2507-GGUF/UD-Q2_K_XL/Qwen3-235B-A22B-Instruct-2507-UD-Q2_K_XL-00001-of-00002.gguf \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --temp 0.7 \
    --min-p 0.0 \
    --top-p 0.8 \
    --top-k 20
```

{% endcode %}

### 🛠️ 提升生成速度 <a href="#improving-generation-speed" id="improving-generation-speed"></a>

如果你有更多显存，可以尝试卸载更多 MoE 层，或将整个层本身卸载（offload）。

通常， `-ot ".ffn_.*_exps.=CPU"` 会将所有 MoE 层卸载到 CPU！这实际上允许你将所有非 MoE 层放在一块 GPU 上，从而提高生成速度。如果你有更多 GPU 容量，可以自定义正则表达式以适配更多层。

如果你有稍多的 GPU 内存，尝试 `-ot ".ffn_(up|down)_exps.=CPU"` 这会卸载上投影和下投影的 MoE 层。

尝试 `-ot ".ffn_(up)_exps.=CPU"` 如果你有更多的 GPU 内存。这只会卸载上投影的 MoE 层。

你也可以自定义正则表达式，例如 `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` 表示从第 6 层起卸载 gate、up 和 down 的 MoE 层。

最新的 [llama.cpp 版本](https://github.com/ggml-org/llama.cpp/pull/14363) 还引入了高吞吐量模式。使用 `llama-parallel`。在此处阅读更多内容 [这里](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel)。你也可以 **例如将 KV 缓存量化为 4 bit** 以减少 VRAM / RAM 的移动，这也可以使生成过程更快。 [下一节](#how-to-fit-long-context-256k-to-1m) 讨论了 KV 缓存量化。

### 📐 如何适配长上下文 <a href="#how-to-fit-long-context-256k-to-1m" id="how-to-fit-long-context-256k-to-1m"></a>

要适配更长的上下文，你可以使用 **KV 缓存量化** 将 K 和 V 缓存量化到更低位数。这也可以由于减少 RAM / VRAM 数据移动而提高生成速度。K 量化的可用选项（默认是 `f16`）包括下列项。

`--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1`

你应当使用那些 `_1` 变体以获得稍高的准确性，尽管速度会略慢。例如 `q4_1, q5_1` 因此尝试使用 `--cache-type-k q4_1`

你也可以对 V 缓存进行量化，但你需要 **在编译 llama.cpp 时启用 Flash Attention 支持** 通过 `-DGGML_CUDA_FA_ALL_QUANTS=ON`，并使用 `--flash-attn` 来启用它。安装 Flash Attention 之后，你就可以使用 `--cache-type-v q4_1`

## 🦥 使用 Unsloth 对 Qwen3-2507 进行微调

Unsloth 提供了 [Qwen3](https://unsloth.ai/docs/zh/mo-xing/tutorials/qwen3-how-to-run-and-fine-tune/..#fine-tuning-qwen3-with-unsloth) 并使 Qwen3-2507 微调速度提升 2 倍，显存减少 70%，并支持 8 倍更长的上下文长度。因为 Qwen3-2507 仅以 30B 变体发布，这意味着使用 QLoRA（4 位）微调该模型大约需要一块 40GB 的 A100 GPU。

对于笔记本，由于模型无法适应 Colab 免费的 16GB GPU，你需要使用 40GB 的 A100。你可以使用我们的对话（Conversational）笔记本，但将数据集替换为你自己的任意数据集。这次你无需在数据集中合并推理，因为该模型没有推理能力。

* [Qwen3（14B）推理 + 对话 笔记本](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb)

如果你使用的是旧版本 Unsloth 和/或在本地进行微调，请安装最新版本的 Unsloth：

```bash
pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo
```

### Qwen3-2507 MOE 模型微调

微调支持包括 MOE 模型：30B-A3B 和 235B-A22B。Qwen3-30B-A3B 在配合 Unsloth 时可在 30GB 显存上运行。关于微调 MoE——微调路由层可能不是个好主意，所以我们默认将其禁用。

**Qwen3-2507-4B 的笔记本：** [思考（Thinking）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-Thinking.ipynb) 和 [指令（Instruct）](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-Instruct.ipynb)

30B-A3B 可放入 30GB 显存，但你可能缺少 RAM 或磁盘空间，因为必须下载完整的 16 位模型并在运行时转换为 4 位以用于 QLoRA 微调。这是因为无法直接导入 4 位 BnB MOE 模型的问题。此问题仅影响 MOE 模型。

{% hint style="warning" %}
如果你要微调 MOE 模型，请使用 `FastModel` 而不是 `FastLanguageModel`
{% endhint %}

```python
from unsloth import FastModel
import torch
model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Qwen3-30B-A3B-Instruct-2507",
    max_seq_length = 2048，# 可为长上下文选择任意值！
    load_in_4bit = True，# 使用 4 位量化以减少内存
    load_in_8bit = False, # [新！] 精度略好，使用 2 倍内存
    full_finetuning = False, # [新！] 我们现在有全量微调！
    # token = "hf_...", # 如果使用受限模型则使用
)
```

<figure><img src="https://2657992854-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-be34c101c627020c7a6cfb6cd249f2462587d235%2Fqwen33%20mascot.png?alt=media" alt=""><figcaption></figcaption></figure>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/zh/mo-xing/tutorials/qwen3-how-to-run-and-fine-tune/qwen3-2507.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.