# External Cannbot Ops Pypto Intent Understand

> PyPTO 算子需求意图理解。将用户的自然语言算子描述转化为结构化需求文档。当用户描述要开发、实现、创建某个算子时触发，例如：'开发一个 sinh 算子'、'实现 GELU'、'参考 PyTorch 的 F.scaled_dot_product_attention'、'根据论文实现算子'、'创建自定义算子'

- Skill: `ascend-ai-coding/external-cannbot-ops-pypto-intent-understand` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add ascend-ai-coding/external-cannbot-ops-pypto-intent-understand`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ascend-ai-coding/external-cannbot-ops-pypto-intent-understand/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: UNKNOWN
- Author: ascend-ai-coding (https://skillmd.com/u/ascend-ai-coding)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ascend-ai-coding/external-cannbot-ops-pypto-intent-understand

---


# PyPTO 算子需求意图理解

将用户的自然语言描述转化为**结构化、完备**的 PyPTO 算子开发需求文档（SPEC.md）。

## 核心原则

> 严格遵循以下核心原则，确保需求理解准确完整

### 原则 1：基于事实，不猜测

- ✅ 明确标注信息来源和置信度（✓ 高 / ⚠ 中 / ❓ 低）
- ✅ 不确定时主动询问，而非自行推断
- ❌ 禁止凭空猜测公式、规格或参数含义

### 原则 2：功能优先级明确

- ✅ 对所有功能（包括可选参数）标注优先级（P0/P1/P2/P3）
- ✅ P0 和 P1 功能必须在第一个版本实现
- ✅ 明确标注哪些功能暂不支持及原因

### 原则 3：可选参数深度分析

- ✅ 从代码位置、计算逻辑、实现复杂度、依赖关系四个维度分析可选参数
- ✅ 明确参数间的约束和互斥关系
- ❌ 禁止遗漏常用可选参数的分析

### 原则 4：信息完整性

- ✅ 必须信息（算子名称、公式、输入输出规格、动态轴）不可缺失
- ✅ 复杂算子必须提供算法描述
- ✅ 建议提供典型配置，便于后续 golden 生成和设计方案

### 原则 5：至少确认一次

- ✅ 除非用户强烈要求无需确认，否则至少确认一次
- ✅ 最多 2 次确认，整体确认而非逐项确认

### 原则 6：默认值必须显式披露

- ✅ 允许使用默认值的字段，必须在确认环节展示
- ✅ 默认值只能补齐非阻塞信息，不得静默替代关键需求
- ❌ 禁止用户未感知的默认值注入

## 核心工作流

```
阶段 1: 快速解析 → 阶段 2: 可视化确认 → 阶段 3: 可选补充 → 输出文件
```

当用户的首次输入已包含全部必须信息（算子名称、公式/算法、输入输出规格），可将阶段 1 和阶段 2 合并为一步：直接展示数据流图 + 规格确认清单，等待用户确认后生成文件。不需要机械地走完每个阶段。

---

## 阶段 1：快速解析

### 接收用户输入

用户可以用任意方式描述算子需求。接收后立即进行输入分类。

### 输入分类

先判断输入属于以下 4 类中的哪一类：

1. **标准参考类**
   - 适用：常见算子、框架 API 参考、可搜索到标准定义的算子
   - 识别特征：用户直接给出算子名，或明确说“参考 PyTorch/NumPy/TensorFlow/JAX 的 ...”

2. **外部材料类**
   - 适用：论文/文档链接、代码片段参考
   - 识别特征：输入包含 URL、论文链接、文档片段、函数定义、import 语句或明显代码语法

3. **自定义描述类**
   - 适用：自定义算子、无标准定义、无法定位可信外部资料的算子
   - 识别特征：名称明显是自定义，或搜索无法定位可信定义

4. **直接规格类**
   - 适用：用户首次输入已经包含算子名称、公式/算法、输入输出规格等关键信息
   - 识别特征：无需依赖外部资料即可直接进入规格确认

### 复杂度判定与关键特性识别

完成输入分类后，判断是否属于复杂算子并识别关键特性。

**复杂算子判定标准**：
- 涉及多步骤、分块、循环、在线更新、状态维护或多个子算子组合
- 标记后追加以下要求：
  - 必须提供算法描述或可恢复算法描述的材料
  - 必须展示分解后的计算图
  - 必须提高确认强度，确保流程理解无歧义

**关键特性识别**（复杂算子必须执行）：
复杂算子通常包含可独立配置的关键特性，这些特性会显著影响实现复杂度和性能。必须主动识别并拆解，让用户确认。

**常见关键特性清单**：

| 特性类别 | 典型特性 | 适用算子类型 | 影响范围 |
|----------|----------|--------------|----------|
| **数值稳定性** | safe_softmax, logsumexp, numerical_stable | Softmax/归一化/指数运算 | 计算精度、溢出处理 |
| **分块策略** | tiling_strategy, block_size | 大规模矩阵/注意力/卷积 | 内存布局、循环结构 |
| **Mask 机制** | causal_mask, padding_mask, custom_mask, sliding_window | 注意力/序列处理 | 数据流、内存访问、边界处理 |
| **在线算法** | online_softmax, online_reduction, streaming_update | Reduction/Softmax | 计算顺序、中间状态 |
| **量化支持** | int8_quant, fp8_quant, blockwise_quant, dequantize | 量化算子 | 数据类型、缩放因子 |
| **融合模式** | bias_add, residual_add, activation_fused | 通用 | 算子边界、中间结果复用 |
| **动态 Shape** | variable_length, ragged_tensor, dynamic_axis | 序列处理/变长输入 | 内存分配、循环展开 |
| **并行策略** | split_k, split_n, parallel_reduction | 矩阵乘法/Reduction | 并行度、同步开销 |
| **内存优化** | in_place, workspace_reuse, page_attention | 通用 | 内存占用、数据依赖、内存优化 |
| **边界处理** | padding_mode, boundary_condition, edge_handling | 卷积/池化/插值 | 边界精度、计算逻辑 |
| **精度控制** | mixed_precision, accumulator_dtype, rounding_mode | 通用 | 计算精度、数值范围 |
| **随机性** | deterministic, seed_control, dropout_rate | Dropout/随机采样 | 可复现性、随机数生成 |
| **稀疏性** | sparse_pattern, masked_compute, structured_sparsity | 稀疏算子 | 数据布局、计算跳过 |

**特性识别流程**：
1. 从用户描述中提取已提及的特性
2. 从参考材料（论文/文档/代码）中识别隐含特性
3. 生成特性清单，标注置信度和来源
4. 在确认环节让用户逐一确认或修改

### 各类输入的详细处理

#### 类别 1：标准参考类（通常为 ✓ 高置信度）

优先从已有知识或可信参考中恢复标准定义。

已知的常见算子包括：

| 类别 | 算子列表 |
|------|----------|
| 激活函数 | relu, gelu, silu, swish, mish, sigmoid, tanh, softmax, hardswish, hardsigmoid |
| 数学运算 | sin, cos, sinh, cosh, tanh, exp, log, log2, log10, sqrt, rsqrt, pow, abs, sign |
| 归一化 | layer_norm, rms_norm, batch_norm, instance_norm, group_norm |
| 注意力 | scaled_dot_product_attention, multi_head_attention |
| 矩阵运算 | matmul, addmm, bmm, linear, einsum |
| Reduction | sum, mean, max, min, amax, amin, argmax, argmin, prod |
| 逐元素 | add, sub, mul, div, maximum, minimum, clamp |

**处理方式**：
1. 从自身知识库或可信参考中获取公式和标准规格
2. 标记为 ✓ 高置信度，展示并建议确认
3. 若属于多步骤/复杂算子（如 Flash Attention、Scan），追加算法描述要求

**交互示例**：
```text
用户: 开发一个 GELU 算子

助手: 我知道 GELU 算子：

      GELU(x) = x * Φ(x)
            ≈ x * 0.5 * (1 + tanh(√(2/π) * (x + 0.044715*x³)))

      标准规格：
      - 输入: x [...], float32
      - 输出: y [...], float32 (shape与输入相同)

      ✓ 算子名称: gelu
      ✓ 公式: GELU(x) = x * Φ(x)
      ⚠ 有两个版本：
         1. 精确版 (使用erf)
         2. 近似版 (使用tanh)
      ❓ 你需要哪个版本？
```

#### 类别 2：外部材料类（通常为 ⚠ 中置信度）

**识别特征**：输入包含 URL、论文链接、文档片段、代码片段或函数定义。

**处理方式**：
1. 若是论文/文档链接，使用 WebFetch 获取内容并提取规格信息
2. 若是代码片段，分析代码结构，提取输入输出与计算逻辑
3. 统一标记为 ⚠ 中置信度
4. **必须**让用户确认提取结果是否正确

**降级策略**（WebFetch 不可用时）：
1. 基于 AI 自身知识库中的标准定义生成规格信息
2. 置信度降为 ⚠ 中（来源：AI 知识库推断，非原始材料）
3. 在 SPEC.md 中标注"⚠ 原始材料无法获取，基于标准参考生成，建议人工确认"
4. 向用户说明降级原因并展示推断依据

**交互示例**：
```text
用户: 参考 PyTorch 的 F.scaled_dot_product_attention

助手: 我提取到以下规格信息：

      公式: Attention(Q,K,V) = softmax(QK^T/√d) @ V

      标准规格：
      - Q: [batch, num_heads, seq_len, head_dim]
      - K: [batch, num_heads, seq_len, head_dim]
      - V: [batch, num_heads, seq_len, head_dim]
      - Output: [batch, num_heads, seq_len, head_dim]

      可选参数：
      - attn_mask: 注意力掩码
      - dropout_p: dropout 概率
      - is_causal: 是否因果注意力
      - scale: 缩放因子（默认 1/√d）

      ❓ 你需要支持哪些可选参数？
      ❓ 输入的dtype是什么？(float32/bfloat16)
```

#### 类别 3：自定义描述类（通常为 ❓ 需完整描述）

**识别特征**：名称明显是自定义（如 my_op, custom_fusion）、无法定位可信标准定义、或用户明确说是自定义。

**处理方式**：
1. 明确告知这是自定义算子
2. 引导用户提供必须信息（数学公式、输入输出规格）
3. 提供多种输入方式：公式描述、伪代码、NumPy/PyTorch 代码、流程图描述

```text
助手: 我没有找到 "my_fusion_op" 的标准定义，这似乎是一个自定义算子。

      请提供以下信息：

      必须提供：
      1. 数学公式（例如: y = f(x) = ... 或用文字描述计算逻辑）
      2. 输入输出规格（输入: x [shape] dtype / 输出: y [shape] dtype）

      你可以用以下任一方式提供：
      - 公式描述: "y = relu(x) * sigmoid(gate), x和gate都是[b,s,d]的float32"
      - 伪代码: h1 = relu(x); h2 = sigmoid(gate); y = h1 * h2
      - NumPy/PyTorch 代码: def my_op(x, gate): return torch.relu(x) * torch.sigmoid(gate)
```

#### 类别 4：直接规格类（信息完整度决定置信度）

**识别特征**：用户首次输入已经包含算子名称、公式/算法、输入输出规格等关键信息。

**处理方式**：
1. 直接整理已有信息，生成结构化规格草稿
2. 若信息完整且一致，可直接进入可视化确认
3. 若信息存在空缺，仅补问缺失项，不重复追问已有信息

### 置信度标记规范

| 标记 | 置信度 | 信息来源 | 处理方式 |
|------|--------|----------|----------|
| ✓ | 高 | 自身知识库/框架知识 | 展示并建议确认 |
| ⚠ | 中 | WebSearch/WebFetch/代码分析 | **必须**让用户确认 |
| ❓ | 低 | 推断/猜测 | 主动询问用户 |

---

## 阶段 2：可视化确认

这是**最关键的一步**，确保理解与用户意图对齐。

### 展示内容

按以下顺序展示：

#### 0. 关键特性拆解（复杂算子专属）

对于复杂算子，在展示数据流图之前，**必须**先展示识别出的关键特性清单：

```
🔍 识别到的关键特性:

| 特性 | 是否需要 | 置信度 | 来源 | 实现说明 | 优先级 |
|------|----------|--------|----------|--------|
| causal_mask | ✓ 需要 | ✓ 高 | 用户描述 | 需要上三角 mask 逻辑 | P0 |
| online_softmax | ✓ 需要 | ⚠ 中 | 论文推断 | 需要分块 + 数值稳定更新 | P0 |
| multi_query_attention | ✗ 不需要 | ❓ 低 | 默认假设 | - | - |
| paged_attention | ? 待确认 | ❓ 低 | 网络搜索 | 需要KV cache管理 | P1 |
| dropout | ? 待确认 | ❓ 低 | 框架默认 | 需要随机数生成 | P2 |

❓ 请确认以上特性是否符合你的需求：
  - 需要调整哪些特性的"是否需要"状态？
  - 是否有遗漏的特性？
```

**特性确认交互**：
- 使用 `AskUserQuestion` 让用户确认特性清单
- 提供选项：全部确认 / 修改特性 / 添加新特性 / 我不确定，帮我解释
- 若用户不确定，提供每个特性的简要说明和典型使用场景

#### 1. ASCII 数据流图

根据算子类型选择合适的数据流图模板：

**简单 Element-wise 算子**（单输入，shape 不变）：
```
    输入 x                      输出 y
┌────────────────┐         ┌────────────────┐
│  [b, s, n, d]  │ ──────▶ │  [b, s, n, d]  │
│   float32      │  sinh   │   float32      │
└────────────────┘         └────────────────┘

公式: y = sinh(x) = (e^x - e^(-x)) / 2
动态轴: b, s
```

**多输入 Matmul 类算子**：
```
    输入 a           输入 b           输入 c (可选)
┌──────────┐    ┌──────────┐    ┌──────────┐
│  [m, k]  │    │  [n, k]  │    │  [m, n]  │
└────┬─────┘    └────┬─────┘    └────┬─────┘
     │               │               │
     │    ┌──────────┘               │
     ▼    ▼                          │
  ┌────────────┐                     │
  │  a @ b^T   │                     │
  └─────┬──────┘                     │
        │                            │
        ▼                            ▼
     ┌──────────────────────────────────┐
     │              +                   │
     └───────────────┬──────────────────┘
                   ▼
             ┌──────────┐
             │ 输出 y   │
             │  [m, n]  │
             └──────────┘
```

**其他算子**：参考上述模板，按实际数据流绘制。组合算子展示子算子的分解与合并关系。

#### 2. 规格确认清单

对于简单算子（公式足以描述）：
```
✅ 必须信息:
  [✓] 算子名称: {operator_name}
  [✓] 数学公式: {formula}
  [✓] 输入: {input_name}[{shape}] {dtype}, 动态轴: {dynamic_axes}
  [✓] 输出: {output_name}[{shape}] {dtype}, 动态轴: {dynamic_axes}

⚙️ 自动推断（使用默认值，可修改）:
  • 支持数据类型: float32 (atol=0.001, rtol=0.001)
  • 性能目标: 无特殊要求
  • 边界处理: 正常计算
```

对于复杂算子（公式无法完整表述计算流程），增加算法部分和关键特性部分：
```
✅ 必须信息:
  [✓] 算子名称: {operator_name}
  [✓] 数学公式: {formula}
  [✓] 关键特性:
      ┌─────────────────────┬────────┬──────────────────────────┐
      │ 特性                │ 状态   │ 实现说明                 │
      ├─────────────────────┼────────┼──────────────────────────┤
      │ causal_mask         │ ✓ 需要 │ 上三角 mask 逻辑         │
      │ online_softmax      │ ✓ 需要 │ 分块 + 数值稳定更新      │
      │ paged_attention     │ ✗ 不需 │ -                        │
      │ dropout             │ ✗ 不需 │ -                        │
      └─────────────────────┴────────┴──────────────────────────┘
  [✓] 算法描述:
      Algorithm: {algorithm_name}
      ────────────────────────────
      {带编号的伪代码步骤}
  [✓] 输入: ...
  [✓] 输出: ...
```

**何时需要算法描述**：当计算涉及分块、循环、在线更新、状态维护等流程性逻辑时，公式只能描述数学语义但无法描述实现策略。此时需要算法描述来说明"怎么算"。典型例子：Flash Attention 的分块计算 + Online Softmax、Scan 类算子的递推过程。

**算法描述格式**：使用带编号的伪代码步骤，清晰展示循环结构、分块策略、状态更新等流程。示例：

```
Algorithm: Flash Attention (Forward)
────────────────────────────────────
输入: Q, K, V ∈ R^{N×d}, 分块大小 Br, Bc
输出: O ∈ R^{N×d}

1. 将 Q 分为 Tr = ⌈N/Br⌉ 块, K/V 分为 Tc = ⌈N/Bc⌉ 块
2. 初始化 O = 0, l = 0, m = -∞
3. for j = 1 to Tc:                          // 外层循环: K/V 块
     3.1 从 HBM 加载 K_j, V_j 到 SRAM
     3.2 for i = 1 to Tr:                    // 内层循环: Q 块
           3.2.1 从 HBM 加载 Q_i, O_i, l_i, m_i 到 SRAM
           3.2.2 S_ij = Q_i @ K_j^T  ∈ R^{Br×Bc}
           3.2.3 m̃_ij = rowmax(S_ij)
           3.2.4 P̃_ij = exp(S_ij - m̃_ij)
           3.2.5 l̃_ij = rowsum(P̃_ij)
           3.2.6 m_new = max(m_i, m̃_ij)
           3.2.7 l_new = exp(m_i - m_new) * l_i + exp(m̃_ij - m_new) * l̃_ij
           3.2.8 O_i ← diag(l_new)^{-1} * (diag(l_i) * exp(m_i - m_new) * O_i
                        + exp(m̃_ij - m_new) * P̃_ij @ V_j)
           3.2.9 写回 O_i, l_new, m_new 到 HBM
4. return O
```

#### 3. 操作选项

使用 `AskUserQuestion` 工具向用户提供以下选择：
- **修改某项** — 修改以上任何信息
- **添加更多细节** — 进入阶段 3
- **确认无误，继续** — 跳过阶段 3 直接生成文件

### 确认策略

- **高置信度 (✓)**：展示但不强制确认，用户可以直接继续
- **中置信度 (⚠)**：**必须**确认 1 次
- **确认次数**：最多 2 次（分类确认（仅中置信度时）+ 最终确认）
- **确认方式**：整体确认，不逐项确认
- **多步骤/复杂算子**：分解展示，整体确认

---

## 阶段 3：可选补充

如果用户选择"添加更多细节"，通过 `AskUserQuestion` 展示以下可选配置项：

1. **动态轴范围** — 动态轴的取值范围（默认: 无限制）
2. **性能目标** — 是否有特殊性能指标要求（默认: 无特殊要求）
3. **边界条件处理** — 零值/极值/NaN/Inf 的处理方式（默认: 正常计算）
4. **参考实现** — PyTorch/NumPy 参考实现链接或代码
5. **应用场景与典型配置** — 目标模型、使用位置、典型配置表格（强烈建议提供）

   典型配置用于后续 golden 验证和设计方案生成，采用 7 列格式：

   | 配置名称 | 类型 | 优先级 | 参数 | 输入 Shape | 输出 Shape | 说明 |
   |----------|------|--------|------|------------|------------|------|
   | 性能_P0 | 性能 | P0 | {关键参数} | {各输入shape} | {输出shape} | 核心性能场景 |
   | 功能_P0 | 功能 | P0 | {关键参数} | {各输入shape} | {输出shape} | 核心功能验证 |

   **引导流程**：若用户选择提供应用场景，主动询问是否提供典型配置。若用户不提供典型配置，根据动态轴范围推荐默认配置供确认。

用户可以只填写关心的项，其余使用默认值。

---

## 输出文件生成

用户确认后，生成 SPEC.md 文件：

### SPEC.md 模板

模板文件位于: [templates/spec-template.md](templates/spec-template.md)

使用时需替换以下占位符:
- `{operator_name}` — 算子名称
- `{category}` — 算子分类 (element-wise / reduction / matmul / attention / custom)
- `{formula}` — 数学公式
- `{description}` — 功能描述
- front matter 结构化字段：
  - `{axes_list}` / `{axes_ranges}` / `{shape_constraints}`
  - `{performance_target}`
  - `{atol}` / `{rtol}`
  - 约定：`axes_list` 必须是 YAML 可解析列表（例如 `['N']` 或 `['N','M']`）
- `{feature_name}`, `{need_or_not}`, `{confidence}`, `{impl_note}`, `{priority}` — 关键特性表格行（复杂算子必须）
- `{algorithm_name}` / `{带编号的伪代码步骤}` — 算法描述（可选，复杂算子需要）
- `{ASCII数据流图}` — 数据流图
- `{name}`, `{shape}`, `{dtype}`, `{dynamic_axes}`, `{description}` — 输入输出规格
- `{atol}`, `{rtol}` — 精度要求
- `{axes_list}`, `{axes_meanings}`, `{axes_ranges}` — 动态轴说明
- `{zero_handling}`, `{inf_handling}`, `{nan_handling}` — 边界条件处理
- `{performance_target}` — 性能目标
- `{reference_impl}`, `{paper}`, `{similar_ops}` — 参考信息
- `{model}`, `{layer}` — 应用场景
- `{config_name}`, `{type}`, `{priority}`, `{params}`, `{input_shapes}`, `{output_shapes}`, `{config_desc}` — 典型配置表格行
- `{timestamp}` — 生成时间

---

## 文件冲突处理

如果目标路径下 `SPEC.md` 已存在，**必须**通过 `AskUserQuestion` 询问用户：

```
⚠ 文件已存在:
  - SPEC.md 路径

请选择:
  1. 覆盖 — 用新生成的内容替换已有文件
  2. 取消 — 不生成文件，保留现有内容
```

---

## 字段定义与默认值

### 必须字段（无默认值，用户必须提供）

| 字段 | 类型 | 说明 |
|------|------|------|
| 算子名称 | string | 唯一标识符，小写字母开头，只能包含小写字母、数字和下划线 |
| 数学公式 | string | 核心计算逻辑，所有算子都需要 |

### 条件必须字段（特定场景下必须提供）

| 字段 | 类型 | 何时必须 |
|------|------|----------|
| 算法描述 | string | 当公式无法完整表述计算流程时（涉及分块、循环、在线更新、状态维护等流程性逻辑） |

公式描述"算什么"，算法描述"怎么算"。大多数需要算法的算子同时也有公式。简单算子（如 `y = sinh(x)`）只需公式；复杂算子（如 Flash Attention）两者兼有。

### 建议字段（有默认值）

| 字段 | 默认值 | 说明 |
|------|--------|------|
| 输入 shape | 构建典型值 | 输入张量形状 |
| 输入 dtype | float32 | 输入数据类型 |
| 输出 shape | 根据输入推导 | 输出张量形状 |
| 输出 dtype | 与输入相同 | 输出数据类型 |
| 动态轴 | batch、seq | 支持动态 shape |
| 性能目标 | 首跑精度成功性能的 2 倍 | 性能优化指导 |
| 精度要求 | atol=0.001, rtol=0.001 | 默认精度标准 |

### 可选字段（有合理默认值，可完全跳过）

| 字段 | 默认值 | 用途 |
|------|--------|------|
| 可选参数 | 自动推导 | 功能完整 |
| 动态轴范围 | [1, INT32_MAX] | 性能优化 |
| 边界条件处理 | 正常计算 (zero/inf/nan 均为 normal) | 特殊值处理 |
| 参考实现 | 无 | 框架/论文/代码参考 |
| 应用场景 | 建议提供典型配置（7 列表格） | 模型/层/典型配置表格，便于后续 golden 生成和设计方案 |

### 默认值披露规则

当以下信息未提供且允许使用默认值时，必须在确认环节明确展示，不得静默补全：

- dtype 默认值
- atol / rtol 默认值
- 动态轴范围默认值
- 性能目标默认值

展示格式建议：

```md
⚙️ 将使用以下默认值（如不修改，将直接写入 SPEC.md）：
- dtype: float32
- atol/rtol: 0.001 / 0.001
- 动态轴范围: [1, INT32_MAX]
- 性能目标: 首跑精度成功性能的 2 倍
```

**⚠️ 默认值持久化要求**：确认环节中展示的所有默认值，必须写入生成的 SPEC.md 中对应字段（如 `default_params` frontmatter 字段、精度要求 section 等），不得仅展示而不持久化。

---

## 可选参数深度分析

当算子涉及可选参数时（如框架 API 参考场景），需从以下四个维度进行深度分析：

| 维度 | 说明 | 示例 |
|-----|------|------|
| 代码位置 | 参数在计算流程的哪个阶段使用 | 输入预处理/核心计算/输出后处理 |
| 计算逻辑 | 参数如何影响计算 | 条件分支/数值缩放/数据选择 |
| 实现复杂度 | PyPTO 是否支持 | 低(直接支持)/中(需要特殊处理)/高(不支持) |
| 依赖关系 | 是否依赖其他参数 | 独立/依赖参数X/与参数Y互斥 |

**分析方法**：
1. **定位代码位置**：在参考实现中搜索参数名，找到使用位置
2. **理解计算逻辑**：分析参数如何影响计算流程
3. **评估实现复杂度**：判断 PyPTO API 是否支持，实现难度如何
4. **确定依赖关系**：分析参数间的约束和互斥关系

---

## 功能优先级体系

根据功能的重要性确定实现优先级：

| 优先级 | 定义 | 说明 |
|--------|------|------|
| **P0（必须）** | 核心功能 | 没有就无法工作，所有场景都需要 |
| **P1（重要）** | 常用功能 | 影响大多数使用场景，**必须在第一个版本实现** |
| **P2（可选）** | 特殊场景功能 | 根据需求决定是否实现 |
| **P3（暂缓）** | 不支持或成本过高 | PyPTO 不支持或实现成本过高，暂不实现 |

**重要原则**：
- **P0 和 P1 功能必须在第一个版本实现**
- 只有 P2/P3 功能可以延后
- 在规格确认清单中标注各功能的优先级

**示例**：
```
✅ 必须信息:
  [✓] 算子名称: scaled_dot_product_attention
  [✓] 数学公式: Attention(Q,K,V) = softmax(QK^T/√d) @ V
  [✓] 输入: Q, K, V [b, h, s, d] float32 (P0)
  [✓] 可选参数:
      - attn_mask: 注意力掩码 (P2)
      - dropout_p: dropout 概率 (P3)
      - is_causal: 因果注意力 (P1)
      - scale: 缩放因子 (P1)
```

---

## 需求理解 Checklist

- [ ] 当前需求信息完整度已评估（高 / 中 / 低）
- [ ] 默认值使用情况已显式展示
- [ ] 算子名称已确认，符合命名规范（见"字段定义"§算子名称）
- [ ] 数学公式已确认，清晰描述核心计算逻辑
- [ ] 复杂算子已识别关键特性并让用户确认（见"复杂度判定与关键特性识别"）
- [ ] 复杂算子已提供算法描述（见"阶段 2"§何时需要算法描述）
- [ ] 所有关键特性已标注实现状态（✓ 需要 / ✗ 不需要 / ? 待确认）和优先级
- [ ] 所有信息已标注置信度（✓ 高 / ⚠ 中 / ❓ 低）
- [ ] 输入输出 shape、dtype、动态轴已明确
- [ ] 可选参数已列出并标注优先级（P0-P3），P0/P1 已完成四维度分析
- [ ] P0 和 P1 功能无遗漏（见"功能优先级体系"）
- [ ] 精度要求、边界条件、动态轴范围已明确或使用默认值
- [ ] 性能目标、参考实现、应用场景、典型配置已询问
- [ ] 中置信度信息已确认 1 次，确认次数未超过 2 次