ms-vite-plugin 1.4.10 → 1.4.11

package/docs/apipython/appleocr.md

@@ -125,6 +125,31 @@ chinese_results = appleocr.recognize("screen", 0, 0, 1920, 1080, ["zh-Hans", "en
 print(f"中英文识别结果: {chinese_results}")
 ```
 
+#### `recognizeAbs` - 执行 OCR 识别，并将结果坐标映射为原图/全屏绝对坐标
+
+参数与 `recognize` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
+
+```python
+def recognizeAbs(
+    input: str,
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    languages: Optional[List[str]] = None
+) -> List[OCRResult]
+```
+
+**示例:**
+
+```python
+from kuaijs import appleocr, action
+
+abs_results = appleocr.recognizeAbs("screen", 100, 100, 500, 300)
+if abs_results:
+    action.click(abs_results[0]["centerX"], abs_results[0]["centerY"])
+```
+
 ### 数字识别
 
 #### recognizeNumbers
@@ -174,6 +199,30 @@ for i, result in enumerate(number_results):
     print(f"位置: ({result.centerX}, {result.centerY})")
 ```
 
+#### `recognizeNumbersAbs` - 执行数字 OCR 识别，并将结果坐标映射为原图/全屏绝对坐标
+
+参数与 `recognizeNumbers` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
+
+```python
+def recognizeNumbersAbs(
+    input: str,
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0
+) -> List[OCRResult]
+```
+
+**示例:**
+
+```python
+from kuaijs import appleocr, action
+
+abs_number_results = appleocr.recognizeNumbersAbs("screen", 100, 100, 500, 300)
+if abs_number_results:
+    action.click(abs_number_results[0]["centerX"], abs_number_results[0]["centerY"])
+```
+
 ### 文本查找
 
 #### findText
@@ -224,3 +273,29 @@ for i, result in enumerate(text_results):
     print(f"位置: ({result.x}, {result.y}) - ({result.ex}, {result.ey})")
     print(f"中心点: ({result.centerX}, {result.centerY})")
 ```
+
+#### `findTextAbs` - 查找目标文本，并将结果坐标映射为原图/全屏绝对坐标
+
+参数与 `findText` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
+
+```python
+def findTextAbs(
+    input: str,
+    texts: List[str],
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    languages: Optional[List[str]] = None
+) -> List[OCRResult]
+```
+
+**示例:**
+
+```python
+from kuaijs import appleocr, action
+
+abs_hits = appleocr.findTextAbs("screen", ["确定"], 100, 100, 500, 400)
+if abs_hits:
+    action.click(abs_hits[0]["centerX"], abs_hits[0]["centerY"])
+```

package/docs/apipython/g.md

@@ -153,6 +153,59 @@ if g.getCpuAutoThrottle():
     print("CPU 自动限流已开启")
 ```
 
+#### `setCpuThrottleDelay` - 设置 CPU 限流延迟
+
+设置 CPU 限流单次 sleep 延迟范围（毫秒）。默认 `min_ms=3`、`max_ms=30`。仅在 CPU 自动限流开启且触发限流时生效。
+
+```python
+def setCpuThrottleDelay(min_ms: int, max_ms: int) -> dict
+```
+
+**参数:**
+
+| 参数名    | 类型  | 是否必填 | 默认值 | 描述                               |
+| --------- | ----- | -------- | ------ | ---------------------------------- |
+| `min_ms`  | `int` | 是       | -      | 最低延迟（毫秒）                   |
+| `max_ms`  | `int` | 是       | -      | 最高延迟（毫秒）；小于 min_ms 时自动对齐 |
+
+**返回值:**
+
+| 类型   | 描述               |
+| ------ | ------------------ |
+| `dict` | `{"minMs": int, "maxMs": int}`，实际生效的延迟范围 |
+
+**示例:**
+
+```python
+from kuaijs import g
+
+delay = g.setCpuThrottleDelay(3, 30)
+print(f"CPU 限流延迟: {delay['minMs']}~{delay['maxMs']}ms")
+```
+
+#### `getCpuThrottleDelay` - 获取 CPU 限流延迟
+
+获取 CPU 限流延迟范围（毫秒）。
+
+```python
+def getCpuThrottleDelay() -> dict
+```
+
+**返回值:**
+
+| 类型   | 描述               |
+| ------ | ------------------ |
+| `dict` | `{"minMs": int, "maxMs": int}`，当前最低与最高延迟 |
+
+**示例:**
+
+```python
+from kuaijs import g
+
+delay = g.getCpuThrottleDelay()
+print(f"CPU 限流延迟: {delay['minMs']}~{delay['maxMs']}ms")
+```
+
 #### `restartScript` - 重启脚本
 
 ```python

package/docs/apipython/node.md

@@ -46,6 +46,7 @@ class NodeInfo:
 
 class NodeSelectorOptions(TypedDict, total=False):
     maxDepth: int  # 最大层级深度，默认 50
+    mode: int  # 抓取模式：模式 1、模式 2，默认模式 1
 ```
 
 ## 节点选择器 (NodeSelector)
@@ -67,6 +68,7 @@ def createNodeSelector(params: Optional[NodeSelectorOptions] = None) -> NodeSele
 | 参数名     | 类型 | 是否必填 | 默认值 | 描述                  |
 | ---------- | ---- | -------- | ------ | --------------------- |
 | `maxDepth` | int  | 否       | 50     | 最大层级深度，默认 50 |
+| `mode` | int  | 否       | 1      | 抓取模式。模式 1、模式 2，默认模式 1 |
 
 **返回值：** `NodeSelector`
 
@@ -77,7 +79,8 @@ from kuaijs import node
 
 # 创建选择器
 selector = node.createNodeSelector({
-    "maxDepth": 20  # 最大20层深度
+    "maxDepth": 20,  # 最大20层深度
+    "mode": 1  # 默认模式 1
 })
 ```
 

package/docs/apipython/overview.md

@@ -5,7 +5,7 @@
 - 导入方式：
 
 ```python
-from kuaijs import action, hid, image, appleocr, paddleocr, yolo, system, device, file, mysql, netcard, ime, media, hotupdate, tomatoocr, tts, ui, utils, node, pip, logger
+from kuaijs import action, hid, image, appleocr, paddleocr, yolo, yolocls, system, device, file, mysql, netcard, ime, media, hotupdate, tomatoocr, tts, ui, utils, node, pip, logger
 ```
 
 ## 下载资源

package/docs/apipython/paddleocr.md

@@ -43,7 +43,7 @@ class OCRResult(TypedDict):
 初始化 PP-OCRv5 模型，这是使用 OCR 功能的前提。
 
 ```python
-def loadV5(maxSideLen: int = 640) -> bool
+def loadV5(maxSideLen: int = 640, useGpu: bool = False) -> bool
 ```
 
 **参数：**
@@ -51,12 +51,15 @@ def loadV5(maxSideLen: int = 640) -> bool
 | 参数名       | 类型 | 是否必填 | 默认值 | 描述                             |
 | ------------ | ---- | -------- | ------ | -------------------------------- |
 | `maxSideLen` | int  | 否       | 640    | 输入图像的最大边长，默认值为 640 |
+| `useGpu`     | bool | 否       | False  | 是否启用 GPU 加速                |
 
 **返回值：**
 
-| 类型   | 描述             |
-| ------ | ---------------- |
-| `bool` | 是否成功加载模型 |
+| 类型   | 描述                                                |
+| ------ | --------------------------------------------------- |
+| `bool` | 加载成功或模型已加载返回 `True`，否则返回 `False` |
+
+重复调用 `loadV5` 时，如果模型已经加载，会直接返回 `True`，不会重新加载或应用新的参数。需要更换加载参数时，先调用 `free()` 释放模型。
 
 **示例：**
 
@@ -134,6 +137,29 @@ else:
     print(f"网络图片识别结果数量: {len(url_results)}")
 ```
 
+#### `recognizeAbs` - 执行 OCR 识别，并将结果坐标映射为原图/全屏绝对坐标
+
+参数与 `recognize` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
+
+```python
+def recognizeAbs(
+    input: str,
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    confidenceThreshold: float = 0.6
+) -> List[OCRResult]
+```
+
+**示例：**
+
+```python
+abs_results = paddleocr.recognizeAbs("screen", 100, 100, 500, 300)
+if abs_results:
+    print(f"绝对坐标中心点: ({abs_results[0].centerX}, {abs_results[0].centerY})")
+```
+
 #### `findText` - 在识别结果中查找目标文本并返回对应子串坐标
 
 在 OCR 识别结果中查找指定文本，返回匹配文本的坐标和置信度等信息。
@@ -190,6 +216,30 @@ else:
     print(f"区域命中数量: {len(region_hits)}")
 ```
 
+#### `findTextAbs` - 查找目标文本，并将结果坐标映射为原图/全屏绝对坐标
+
+参数与 `findText` 相同。传入裁剪区域时，返回坐标可直接用于全屏点击。
+
+```python
+def findTextAbs(
+    input: str,
+    targetTexts: List[str],
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    confidenceThreshold: float = 0.6
+) -> List[OCRResult]
+```
+
+**示例：**
+
+```python
+abs_hits = paddleocr.findTextAbs("screen", ["确定"], 100, 100, 500, 400, 0.6)
+if abs_hits:
+    print(f"绝对坐标中心点: ({abs_hits[0].centerX}, {abs_hits[0].centerY})")
+```
+
 ### 资源管理
 
 #### `free` - 释放 OCR 模型占用的内存资源

package/docs/apipython/yolo.md

@@ -65,7 +65,7 @@ class YoloResult(TypedDict):
 加载模型是使用目标检测功能的前提。
 
 ```python
-def load(paramPath: str, binPath: str, nc: int, version: int = 11) -> Optional[str]
+def load(paramPath: str, binPath: str, nc: int = 0, version: int = 11, useGpu: bool = False) -> Optional[str]
 ```
 
 **参数:**
@@ -74,8 +74,9 @@ def load(paramPath: str, binPath: str, nc: int, version: int = 11) -> Optional[s
 | ----------- | ---- | -------- | ------ | ------------------------------------------- |
 | `paramPath` | str  | 是       | -      | NCNN 模型的 param 文件绝对路径              |
 | `binPath`   | str  | 是       | -      | NCNN 模型的 bin 文件绝对路径                |
-| `nc`        | int  | 是       | -      | 模型的标签数量（在标签集 data.yaml 中查看） |
+| `nc`        | int  | 否       | 0      | 模型的标签数量；传 `0` 或省略时根据模型输出自动推断，显式传入但不匹配时检测返回空列表 |
 | `version`   | int  | 否       | 11     | YOLO 模型版本号（仅支持 8/11/26）           |
+| `useGpu`    | bool | 否       | False  | 是否启用 GPU 加速                           |
 
 **返回值:**
 
@@ -92,8 +93,9 @@ from kuaijs import yolo
 model_id = yolo.load(
     "yolov8n_ncnn_model/model.ncnn.param",
     "yolov8n_ncnn_model/model.ncnn.bin",
-    80,
+    0,
     8,
+    False,
 )
 ```
 
@@ -102,7 +104,7 @@ model_id = yolo.load(
 加载模型是使用目标检测功能的前提。
 
 ```python
-def loadV11(paramPath: str, binPath: str, nc: int) -> Optional[str]
+def loadV11(paramPath: str, binPath: str, nc: int = 0, useGpu: bool = False) -> Optional[str]
 ```
 
 **参数:**
@@ -111,7 +113,8 @@ def loadV11(paramPath: str, binPath: str, nc: int) -> Optional[str]
 | ----------- | ---- | -------- | ------ | ------------------------------------------- |
 | `paramPath` | str  | 是       | -      | NCNN 模型的 param 文件绝对路径              |
 | `binPath`   | str  | 是       | -      | NCNN 模型的 bin 文件绝对路径                |
-| `nc`        | int  | 是       | -      | 模型的标签数量（在标签集 data.yaml 中查看） |
+| `nc`        | int  | 否       | 0      | 模型的标签数量；传 `0` 或省略时根据模型输出自动推断，显式传入但不匹配时检测返回空列表 |
+| `useGpu`    | bool | 否       | False  | 是否启用 GPU 加速                           |
 
 **返回值:**
 
@@ -129,7 +132,8 @@ from kuaijs import yolo
 model_id = yolo.loadV11(
     "yolo11n_ncnn_model/model.ncnn.param",
     "yolo11n_ncnn_model/model.ncnn.bin",
-    80 # COCO 数据集有 80 个类别
+    0, # 自动根据模型输出推断类别数量
+    False,
 )
 
 if model_id:
@@ -176,7 +180,7 @@ def detect(
 from kuaijs import yolo
 
 # 首先加载模型
-mid = yolo.loadV11("yolo11n_ncnn_model/model.ncnn.param", "yolo11n_ncnn_model/model.ncnn.bin", 80)
+mid = yolo.loadV11("yolo11n_ncnn_model/model.ncnn.param", "yolo11n_ncnn_model/model.ncnn.bin", 0)
 
 if not mid:
     print("模型加载失败")
@@ -227,6 +231,32 @@ else:
     print(f"网络图片检测结果: {len(url_results)} 个物体")
 ```
 
+#### detectAbs - 对指定区域执行目标检测，并将结果坐标映射为原图/全屏绝对坐标
+
+```python
+def detectAbs(
+    modelId: str,
+    img: str,
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    targetSize: int = 640,
+    threshold: float = 0.4,
+    nmsThreshold: float = 0.5
+) -> List[YoloResult]
+```
+
+**示例:**
+
+```python
+from kuaijs import yolo, action
+
+abs_results = yolo.detectAbs(mid, "screen", 100, 100, 500, 400, 640, 0.4, 0.5)
+if abs_results:
+    action.click(abs_results[0]["centerX"], abs_results[0]["centerY"])
+```
+
 ### 资源管理
 
 #### free - 释放指定模型

package/docs/apipython/yolocls.md

@@ -0,0 +1,269 @@
+# YOLO 图像分类模块 (yolocls)
+
+YOLO 图像分类模块基于 YOLOv8-cls / YOLO11-cls / YOLO26-cls 分类模型和 NCNN 框架，提供整图分类、区域分类和模型资源管理能力。
+
+## 功能概览
+
+- **模型管理**: 加载和释放 YOLOv8-cls / YOLO11-cls / YOLO26-cls NCNN 模型
+- **图像分类**: 对屏幕截图、图片文件、HTTP 图片或图片 ID 执行整图分类
+- **区域分类**: 先裁剪指定区域，再对裁剪结果执行分类
+- **结果处理**: 返回 Ultralytics `Probs` 风格的完整概率、top1、top5 和对应置信度
+- **资源控制**: 支持释放单个模型或释放全部已加载模型
+
+## 适用场景
+
+- 判断当前屏幕或图片属于哪个业务类别
+- 对截图中的固定区域进行状态识别
+- 对自定义 YOLO-cls 模型导出的 NCNN 模型执行端侧推理
+
+## 数据结构
+
+### YoloClsProbs
+
+YOLO 分类概率结果字典，字段命名与 Ultralytics `Probs` 保持一致。
+
+```python
+from typing import List, Optional, TypedDict
+
+class YoloClsProbs(TypedDict):
+    data: List[float]         # 所有类别概率，下标即类别 ID
+    top1: Optional[int]       # 概率最高的类别 ID
+    top5: List[int]           # 概率最高的 5 个类别 ID
+    top1conf: Optional[float] # top1 对应的概率
+    top5conf: List[float]     # top5 对应的概率
+```
+
+**字段说明:**
+
+| 字段名     | 类型                  | 描述                                                       |
+| ---------- | --------------------- | ---------------------------------------------------------- |
+| `data`     | `List[float]`         | 所有类别概率数组，下标即类别 ID                            |
+| `top1`     | `Optional[int]`       | 概率最高的类别 ID；分类失败时为 `None`                     |
+| `top5`     | `List[int]`           | 概率最高的 5 个类别 ID，按概率从高到低排序                 |
+| `top1conf` | `Optional[float]`     | `top1` 对应的概率；分类失败时为 `None`                     |
+| `top5conf` | `List[float]`         | `top5` 对应的概率，顺序与 `top5` 一致                      |
+
+**结果说明:**
+
+- `top1` 等于 `top5[0]`，`top1conf` 等于 `data[top1]`。
+- 当模型类别数少于 5 时，`top5` 和 `top5conf` 的长度会小于 5。
+- 分类失败时返回空结果：`data`、`top5`、`top5conf` 为空列表，`top1` 和 `top1conf` 为 `None`。
+
+## API 参考
+
+### 模型管理
+
+#### load - 加载 YOLO 分类模型（支持 YOLOv8-cls / YOLO11-cls / YOLO26-cls）
+
+加载模型是使用图像分类能力的前提。支持 Ultralytics 官方 YOLOv8-cls、YOLO11-cls、YOLO26-cls 导出的 NCNN 分类模型，常见模型名使用 `-cls` 后缀，例如 `yolov8n-cls`、`yolo11n-cls`、`yolo26n-cls`。
+
+```python
+def load(
+    paramPath: str,
+    binPath: str,
+    nc: int = 0,
+    useGpu: bool = False
+) -> Optional[str]
+```
+
+**参数:**
+
+| 参数名      | 类型 | 是否必填 | 默认值 | 描述                                      |
+| ----------- | ---- | -------- | ------ | ----------------------------------------- |
+| `paramPath` | str  | 是       | -      | NCNN 模型的 param 文件路径                |
+| `binPath`   | str  | 是       | -      | NCNN 模型的 bin 文件路径                  |
+| `nc`        | int  | 否       | 0      | 模型类别数量；传 `0` 或省略时按模型输出自动推断，显式传入但不匹配时分类返回空结果 |
+| `useGpu`    | bool | 否       | False  | 是否使用 GPU 推理                         |
+
+**返回值:**
+
+| 类型          | 描述                                 |
+| ------------- | ------------------------------------ |
+| `str \| None` | 加载成功返回模型 ID，失败返回 `None` |
+
+**示例:**
+
+```python
+from kuaijs import yolocls
+
+# 模型文件通常放在 res 目录
+model_id = yolocls.load(
+    "yolo11n_cls_ncnn_model/model.ncnn.param",
+    "yolo11n_cls_ncnn_model/model.ncnn.bin",
+    1000, # ImageNet 分类模型通常为 1000 类
+    False,
+)
+
+if model_id:
+    print(f"YOLO 分类模型加载成功，ID: {model_id}")
+else:
+    print("YOLO 分类模型加载失败，请检查模型文件路径和格式")
+```
+
+### 图像分类
+
+#### classify - 对输入图像执行分类
+
+对整张输入图像执行分类，返回完整概率数组和 top1/top5 结果。
+
+```python
+def classify(
+    modelId: str,
+    img: str,
+    targetSize: int = 224
+) -> YoloClsProbs
+```
+
+**参数:**
+
+| 参数名       | 类型 | 是否必填 | 默认值 | 描述                                                                                                                                      |
+| ------------ | ---- | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `modelId`    | str  | 是       | -      | 模型 ID（通过 `load` 获取）                                                                                                               |
+| `img`        | str  | 是       | -      | 图像输入源：<br>- `"screen"` - 使用当前屏幕截图<br>- `str` - 图片文件路径或 HTTP 图片地址<br>- `imageId` - 图片 ID（通过 image 模块获取） |
+| `targetSize` | int  | 否       | 224    | 分类输入大小，应与模型训练或导出时的输入尺寸一致                                                                                          |
+
+**返回值:**
+
+| 类型           | 描述                                                |
+| -------------- | --------------------------------------------------- |
+| `YoloClsProbs` | Ultralytics `Probs` 风格分类结果，包含 top1/top5 等 |
+
+**示例:**
+
+```python
+from kuaijs import yolocls
+
+model_id = yolocls.load(
+    "yolo11n_cls_ncnn_model/model.ncnn.param",
+    "yolo11n_cls_ncnn_model/model.ncnn.bin",
+    1000,
+    False,
+)
+
+if not model_id:
+    print("模型加载失败")
+else:
+    probs = yolocls.classify(
+        model_id,
+        "screen", # 使用当前屏幕
+        224       # 分类模型常用输入尺寸
+    )
+
+    if probs["top1"] is not None:
+        print(f"top1 类别ID: {probs['top1']}")
+        print(f"top1 置信度: {round(probs['top1conf'] * 100, 2)}%")
+    else:
+        print("分类失败或无有效结果")
+
+    for i, class_id in enumerate(probs["top5"]):
+        conf = probs["top5conf"][i]
+        print(f"top{i + 1}: 类别ID={class_id}, 置信度={round(conf, 4)}")
+
+    # 如需读取某个类别的原始概率，可直接访问 data[class_id]
+    class_id = 0
+    if len(probs["data"]) > class_id:
+        print(f"类别 {class_id} 概率: {round(probs['data'][class_id], 4)}")
+
+    yolocls.free(model_id)
+```
+
+#### classifyRegion - 对指定区域执行分类
+
+先从输入图像中裁剪指定区域，再对裁剪结果执行分类。适合只关心屏幕某个固定区域状态的场景。
+
+```python
+def classifyRegion(
+    modelId: str,
+    img: str,
+    x: int = 0,
+    y: int = 0,
+    ex: int = 0,
+    ey: int = 0,
+    targetSize: int = 224
+) -> YoloClsProbs
+```
+
+**参数:**
+
+| 参数名       | 类型 | 是否必填 | 默认值 | 描述                                                                                                                                      |
+| ------------ | ---- | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `modelId`    | str  | 是       | -      | 模型 ID（通过 `load` 获取）                                                                                                               |
+| `img`        | str  | 是       | -      | 图像输入源：<br>- `"screen"` - 使用当前屏幕截图<br>- `str` - 图片文件路径或 HTTP 图片地址<br>- `imageId` - 图片 ID（通过 image 模块获取） |
+| `x`          | int  | 否       | 0      | 裁剪区域左上角 x 坐标                                                                                                                     |
+| `y`          | int  | 否       | 0      | 裁剪区域左上角 y 坐标                                                                                                                     |
+| `ex`         | int  | 否       | 0      | 裁剪区域右下角 x 坐标                                                                                                                     |
+| `ey`         | int  | 否       | 0      | 裁剪区域右下角 y 坐标                                                                                                                     |
+| `targetSize` | int  | 否       | 224    | 分类输入大小，应与模型训练或导出时的输入尺寸一致                                                                                          |
+
+**返回值:**
+
+| 类型           | 描述                                                |
+| -------------- | --------------------------------------------------- |
+| `YoloClsProbs` | Ultralytics `Probs` 风格分类结果，包含 top1/top5 等 |
+
+**示例:**
+
+```python
+region_probs = yolocls.classifyRegion(
+    model_id,
+    "screen",
+    100,
+    100,
+    500,
+    400,
+    224,
+)
+
+if region_probs["top1"] is not None:
+    print(
+        f"区域分类 top1={region_probs['top1']}, "
+        f"置信度={round(region_probs['top1conf'], 4)}"
+    )
+```
+
+### 资源管理
+
+#### free - 释放指定模型
+
+释放指定分类模型占用的资源。
+
+```python
+def free(modelId: str) -> None
+```
+
+**参数:**
+
+| 参数名    | 类型 | 是否必填 | 默认值 | 描述            |
+| --------- | ---- | -------- | ------ | --------------- |
+| `modelId` | str  | 是       | -      | 要释放的模型 ID |
+
+**示例:**
+
+```python
+if model_id:
+    yolocls.free(model_id)
+    print(f"YOLO 分类模型 {model_id} 资源已释放")
+```
+
+#### freeAll - 释放所有模型
+
+释放所有已加载的 YOLO 分类模型资源。
+
+```python
+def freeAll() -> None
+```
+
+**示例:**
+
+```python
+yolocls.freeAll()
+print("所有 YOLO 分类模型资源已释放")
+```
+
+## 使用注意事项
+
+- `targetSize` 默认值为 224，常见 YOLO-cls 模型使用该尺寸；自定义模型请填写训练或导出时使用的输入尺寸。
+- `nc` 传 `0` 或省略时会根据模型输出自动推断类别数量；显式传入但和模型输出不匹配时返回空结果。
+- `classifyRegion` 中 `x/y/ex/ey` 全部为 `0` 时表示不裁剪，直接对整张图分类。
+- 裁剪区域必须位于图像范围内，并且 `ex > x`、`ey > y`。
+- 分类结果中的类别 ID 需要结合训练时的类别列表解释；本模块只返回类别 ID 和概率。