> ## Documentation Index
> Fetch the complete documentation index at: https://dragonwingdocs.qualcomm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# qtimltflite

> 用于 GStreamer AI 与多媒体流水线的 TensorFlow Lite 推理元素。

# 概述

**qtimltflite** 是一个 GStreamer 推理元素，可在 AI 和多媒体流水线中执行 **TensorFlow Lite** 模型。该元素完全以**张量模式**运行：它在 sink pad 上接收输入张量，并根据模型的输入和输出规范在 source pad 上生成输出张量。

该元素仅限于**模型执行**。它不执行预处理、张量重塑、批处理、布局转换或特定于模型的后处理。这些功能应由流水线中的相邻元素处理。因此，上游元素必须提供已经符合模型要求的张量，而下游元素必须解释推理生成的输出张量。

**qtimltflite** 通过委托（delegate）支持多种 TensorFlow Lite 执行后端，包括 \*\*CPU、GPU 和外部委托（external delegate）\*\*配置。这使得相同的流水线结构可以部署到不同的硬件目标，并针对不同的性能、延迟和功耗需求进行优化。该元素面向实时和嵌入式 AI 流水线，其中推理是更大的模块化处理流程中的一个阶段。

### 主要职责

**qtimltflite** 负责：

* 加载并执行 TensorFlow Lite 模型
* 接收来自上游元素的预格式化输入张量
* 生成与模型输出签名匹配的输出张量
* 与相邻元素协商张量数据类型和维度
* 传播下游元素所需的张量元数据

在实际使用中，**qtimltflite** 充当流水线中的推理阶段，而张量准备和结果解释则由外部处理。

<img src="https://mintlify.s3.us-west-1.amazonaws.com/qualcomm-prod/zh/SDKs/IMSDK/plugin-reference/images/qtimltflite1.png" alt="" />

## 示例流水线

<Steps>
  <Step title="下载所需文件">
    | 文件            | 下载                                                                                                                           | 保存为                         |
    | ------------- | ---------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
    | YOLOX W8A8 模型 | [Qualcomm AI Hub — YOLOX](https://aihub.qualcomm.com/iot/models/yolox)                                                       | `yolox_w8a8.tflite`         |
    | 检测标签          | <a href="/SDKs/IMSDK/labels/yolov8.json" download="yolov8.json">yolov8.json</a>                                              | `yolov8.json`               |
    | 示例视频          | <a href="https://github.com/qualcomm/sample-apps-for-qualcomm-linux/raw/refs/heads/main/artifacts/videos/video.mp4">输入视频</a> | `Draw_1080p_180s_30FPS.mp4` |

    <Note>
      如果下载的任何文件是 `.zip` 压缩包，请在主机上先解压再复制：
      `unzip filename.zip`
    </Note>
  </Step>

  <Step title="将文件复制到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Replace $HOME to the appropriate device path before running the commands.
      # For QLI:    /root
      # For Ubuntu: /home/ubuntu
      # Modify this based on your platform and ensure files are copied to the correct location on the device.
      # Run from your host machine — replace <user> and <device-ip>

      ssh <user>@<device-ip> "mkdir -p $HOME/{models,labels,media,media/output}"
      scp yolox_w8a8.tflite           <user>@<device-ip>:$HOME/models/
      scp yolov8.json                  <user>@<device-ip>:$HOME/labels/
      scp Draw_1080p_180s_30FPS.mp4    <user>@<device-ip>:$HOME/media/
      ```
    </CodeGroup>
  </Step>

  <Step title="连接到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip>
      ```
    </CodeGroup>
  </Step>

  <Step title="设置环境变量">
    在设备上运行以下命令

    ```bash theme={null}
    export MODEL_NAME=yolox_w8a8.tflite
    export LABELS_NAME=yolov8.json
    export SRC_VIDEO_NAME=Draw_1080p_180s_30FPS.mp4
    ```
  </Step>

  <Step title="运行流水线">
    ```bash theme={null}
    gst-launch-1.0 -e --gst-debug=2 \
    filesrc location=$HOME/media/$SRC_VIDEO_NAME ! qtdemux ! h264parse ! \
    v4l2h264dec capture-io-mode=4 output-io-mode=4 ! video/x-raw,format=NV12 ! queue ! \
    tee name=t ! qtimetamux name=obj_mux ! qtivoverlay ! waylandsink fullscreen=true sync=true \
    t. ! queue ! qtimlvconverter ! queue ! \
    qtimltflite model=$HOME/models/$MODEL_NAME delegate=external external-delegate-path=libQnnTFLiteDelegate.so external-delegate-options="QNNExternalDelegate,backend_type=htp,log_level=(string)1;" ! queue ! \
    qtimlpostprocess module=yolov8 labels=$HOME/labels/$LABELS_NAME ! text/x-raw ! queue ! obj_mux.
    ```
  </Step>
</Steps>

# 层次结构

[GObject](https://docs.gtk.org/gobject/)<br />
   <Icon icon="arrow-turn-down-right" iconType="solid" />[GstObject](https://gstreamer.freedesktop.org/documentation/gstreamer/gstobject.html?gi-language=c)<br />
      <Icon icon="arrow-turn-down-right" iconType="solid" />[GstElement](https://gstreamer.freedesktop.org/documentation/gstreamer/gstelement.html?gi-language=c)<br />
         <Icon icon="arrow-turn-down-right" iconType="solid" />[GstBaseTransform](https://gstreamer.freedesktop.org/documentation/base/gstbasetransform.html?gi-language=c)<br />
            <Icon icon="arrow-turn-down-right" iconType="solid" />qtimltflite

# Pad 模板

### sink

| 能力                       |                                                                                          |
| ------------------------ | ---------------------------------------------------------------------------------------- |
| `neural-network/tensors` | `format: { INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64, FLOAT16, FLOAT32 }` |
| 可用性：*Always*             |                                                                                          |
| 方向：*sink*                |                                                                                          |

### src

| 能力                       |                                                                                          |
| ------------------------ | ---------------------------------------------------------------------------------------- |
| `neural-network/tensors` | `format: { INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64, FLOAT16, FLOAT32 }` |
| 可用性：*Always*             |                                                                                          |
| 方向：*source*              |                                                                                          |

# 元素属性

| 属性                          | 描述                                                                                                                                                                                                                                                                                                                                                                                                               |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model`                     | TensorFlow Lite 模型文件的路径。该属性为必填项，且必须引用有效的 `.tflite` 模型。<br /><br />`Type: String`<br />`Default: NULL`<br />`Flags: readable/writable`                                                                                                                                                                                                                                                                            |
| `delegate`                  | 选择用于推理的执行后端。<br /><br />`Type: Enum `<br />`Default: 0, "none"`<br />`Range:`<br />    `(0): none - Default TensorFlow Lite CPU execution`<br />    `(5): gpu - TensorFlow Lite GPU delegate`<br />    `(6): xnnpack - Optimized CPU execution through XNNPACK`<br />    `(7): external - External delegate loaded through external-delegate-path and external-delegate-options`<br />`Flags: readable/writable` |
| `external-delegate-path`    | 外部委托共享库的绝对路径。仅在 `delegate=external` 时使用。<br /><br />`Type: String`<br />`Default: NULL`<br />`Flags: readable/writable`                                                                                                                                                                                                                                                                                          |
| `external-delegate-options` | 传递给外部委托的委托特定初始化选项。仅在 `delegate=external` 时使用。<br /><br />`Type: String`<br />`Default: NULL`<br />`Flags: readable/writable`                                                                                                                                                                                                                                                                                     |
| `priority`                  | 选择受支持委托的执行偏好，通常在延迟与精度之间存在权衡时使用。<br /><br />`Type: Enum `<br />`Default: 0, "min-latency"`<br />`Range:`<br />    `(0): min-latency - Reduce latency at the cost of precision`<br />    `(1): max-precision - Increase precision at the cost of higher latency`<br />`Flags: readable/writable`                                                                                                                   |
| `threads`                   | 分配给 TensorFlow Lite 解释器的线程数。主要影响基于 CPU 的执行，包括 XNNPACK。<br /><br />`Type: Unsigned Integer`<br />`Default: 1`<br />`Range: 1 - 4`<br />`Flags: readable/writable`                                                                                                                                                                                                                                                 |

# 输入与输出行为

### 输入张量

**qtimltflite** 暴露单个 sink pad，但同时支持单输入和多输入模型。对于多输入模型，所有所需张量以张量集的形式通过同一个 sink pad 传递。

输入张量必须在到达 `qtimltflite` 之前完全准备好。预期的张量布局、形状、数据类型和批量大小由以下因素决定：

* TensorFlow Lite 模型输入签名
* 与上游元素的 caps 协商

典型的上游元素包括：

* [`qtimlvconverter`](qtimlvconverter)：用于缩放、颜色转换、归一化和量化
* [`qtibatch`](qtibatch)：用于批量构建

`qtimltflite` 不会修改、重塑、批处理或重新解释传入的张量。它按接收到的原样将其传递给 TensorFlow Lite 运行时。

### 输出张量

`qtimltflite` 暴露单个 source pad，并根据模型输出签名生成输出张量。单个 source pad 并不限制元素只能输出单个张量。完全支持具有多个输出张量的模型，所有输出会在同一个 pad 上一起发出。

该元素支持：

* 单输出和多输出模型
* 任意张量秩，包括批量维度和深度维度
* 量化和浮点输出

输出张量通常由下游后处理元素消费，这些元素解码特定于模型的结果，例如分类分数、检测框、分割掩码、关键点或其他结构化输出。

# 量化与反量化

`qtimltflite` 可以选择性地将量化输出张量（例如 `UINT8` 或 `INT8`）反量化为 `FLOAT32`。此转换使用存储在 TensorFlow Lite 模型元数据中的量化参数。

### 条件性输出反量化

仅当下游路径需要 `FLOAT32` 张量时才执行反量化。实际上，当下游 caps 协商表明需要浮点输出时，此功能才会启用。

应用反量化时，`qtimltflite` 会：

* 读取张量的 `scale`
* 读取张量的 `zero_point`
* 应用标准的 TensorFlow Lite 反量化公式：

```text theme={null}
output_float = scale × (quantized_value - zero_point)
```

* 生成供下游处理的 `FLOAT32` 张量

### 何时跳过反量化

以下情况不执行反量化：

* 下游元素仅接受量化张量类型
* 没有下游元素协商 `FLOAT32`
* 模型输出张量不包含有效的量化元数据

在这些情况下，输出张量以其原始量化表示形式向下游转发。

这种行为使得同一条下游处理路径在适用时既能支持量化模型也能支持浮点模型，同时避免不必要的转换。

# 支持的数据类型

`qtimltflite` 支持 TensorFlow Lite 运行时和所选执行后端提供的张量数据类型，具体取决于与相邻元素的 caps 协商。

常用的数据类型包括：

* `UINT8`
* `INT8`
* `INT32`
* `FLOAT16`
* `FLOAT32`

除了运行时、所选委托以及协商的流水线 caps 所要求的限制之外，该元素不会施加额外的数据类型限制。

# 批量与深度模型支持

`qtimltflite` 支持具有批量和多维张量输入输出的模型，包括带有显式批量和深度维度的张量。

示例包括：

* 批量张量：`N × H × W × C`
* 多维张量：`N × D × H × W × C`

该元素对这些维度进行透明处理，并根据协商的形状将张量传递给 TensorFlow Lite。它不会在内部构建批量、重塑张量或重新解释张量维度。

批量构建必须由上游元素（例如 [`qtibatch`](qtibatch)）处理。

这种行为使推理在单帧、批量和更高维度的工作流中保持可预测。

# 委托（Delegate）

TensorFlow Lite \*\*委托（delegate）\*\*定义了运行模型所使用的执行后端。委托使 qtimltflite 能够将推理从默认的 TensorFlow Lite CPU 解释器卸载到经过优化的后端，例如 GPU、优化的 CPU 运行时或 NPU。

`qtimltflite` 支持多种委托选项。通过 `delegate` 属性选择委托，它控制 TensorFlow Lite 在推理期间如何分派模型操作。

### 内置委托选项

### none

在默认的 TensorFlow Lite CPU 解释器上运行模型。

* **后端**：CPU
* **使用场景**：参考执行、调试或没有加速的系统

### gpu

通过 TensorFlow Lite GPU 委托运行受支持的操作。

* **后端**：GPU
* **使用场景**：受益于 GPU 并行性的浮点模型/工作负载

### xnnpack

通过 XNNPACK 优化的 CPU 后端运行推理。

* **后端**：优化的 CPU
* **使用场景**：为受支持的浮点和量化模型提升 CPU 性能

### 外部委托支持

外部委托用于在 Qualcomm 的 NPU 上加速模型。

选择外部委托时，`qtimltflite` 使用以下属性在运行时加载并配置委托：

* `external-delegate-path`
  * 外部委托共享库的路径。
* `external-delegate-options`
  * 传递给外部委托的委托特定初始化选项。

初始化完成后，受支持的模型操作将被卸载到外部委托实现的 NPU 后端。

# 运行时内存行为与 GAP 处理

`qtimltflite` 在 TensorFlow Lite 运行时的内存模型内运行。尽管周围的流水线可能对张量缓冲区使用零拷贝传输，但 TensorFlow Lite 执行要求输入和输出张量位于运行时管理的内存中。

### TensorFlow Lite 内存模型

TensorFlow Lite 使用内部内存竞技场（memory arena）来分配：

* 输入张量
* 中间激活张量
* 输出张量

### GAP 缓冲区处理

`qtimltflite` 支持 GAP 感知，能够正确处理标记了 `GST_BUFFER_FLAG_GAP` 的输入缓冲区。

当收到 GAP 缓冲区时，元素跳过推理并将缓冲区向下游转发。这在保持时序和同步的同时，明确表明该时间戳没有可用的有效推理输入。

GAP 缓冲区常见于条件式 AI 流水线，例如级联工作流，其中只有当前面的阶段产生有效的感兴趣区域时，后续推理阶段才会运行。

# 用法

### 实时摄像头流上的单阶段 AI 推理

本示例演示了使用单个 `qtimltflite` 实例，在实时摄像头流上进行实时推理。推理结果作为 `MLMeta` 附加到每个 `GstBuffer`，使下游元素可以直接从帧中访问同步的元数据。叠加阶段随后使用此元数据在显示或进一步处理之前渲染边界框、标签或关键点等注释。

<Steps>
  <Step title="下载所需文件">
    | 文件            | 下载                                                                              | 保存为                 |
    | ------------- | ------------------------------------------------------------------------------- | ------------------- |
    | YOLOX W8A8 模型 | [Qualcomm AI Hub — YOLOX](https://aihub.qualcomm.com/iot/models/yolox)          | `yolox_w8a8.tflite` |
    | 检测标签          | <a href="/SDKs/IMSDK/labels/yolov8.json" download="yolov8.json">yolov8.json</a> | `yolov8.json`       |

    <Note>
      如果下载的任何文件是 `.zip` 压缩包，请在主机上先解压再复制：
      `unzip filename.zip`
    </Note>
  </Step>

  <Step title="将文件复制到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Replace $HOME to the appropriate device path before running the commands.
      # For QLI:    /root
      # For Ubuntu: /home/ubuntu
      # Modify this based on your platform and ensure files are copied to the correct location on the device.
      # Run from your host machine — replace <user> and <device-ip>

      ssh <user>@<device-ip> "mkdir -p $HOME/{models,labels}"
      scp yolox_w8a8.tflite    <user>@<device-ip>:$HOME/models/
      scp yolov8.json          <user>@<device-ip>:$HOME/labels/
      ```
    </CodeGroup>
  </Step>

  <Step title="连接到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip>
      ```
    </CodeGroup>
  </Step>

  <Step title="设置环境变量">
    在设备上运行以下命令

    ```bash theme={null}
    export MODEL_NAME=yolox_w8a8.tflite
    export LABELS_NAME=yolov8.json
    ```
  </Step>

  <Step title="运行流水线">
    ```bash Run the pipeline theme={null}
    gst-launch-1.0 -e --gst-debug=2 \
    qticamsrc name=camsrc ! video/x-raw,format=NV12,width=1920,height=1080,framerate=30/1 ! queue ! \
    tee name=t ! qtimetamux name=obj_mux ! qtivoverlay ! waylandsink fullscreen=true sync=true \
    t. ! queue ! qtimlvconverter ! queue ! \
    qtimltflite model=$HOME/models/$MODEL_NAME delegate=external external-delegate-path=libQnnTFLiteDelegate.so external-delegate-options="QNNExternalDelegate,backend_type=htp,log_level=(string)1;" ! queue ! \
    qtimlpostprocess module=yolov8 labels=$HOME/labels/$LABELS_NAME settings="{\"confidence\": 51.0}" ! text/x-raw ! queue ! obj_mux.
    ```
  </Step>
</Steps>

<img src="https://mintlify.s3.us-west-1.amazonaws.com/qualcomm-prod/zh/SDKs/IMSDK/plugin-reference/images/qtimltflite4.png" alt="" />

### 实时摄像头流上的两阶段级联（Daisy Chain）AI 推理

本示例演示了使用两个 qtimltflite 实例的两阶段 TensorFlow Lite 推理工作流。第一个模型在经过配置为全帧输入的 [`qtimlvconverter`](qtimlvconverter) 预处理后的完整视频帧上运行。推理结果（例如检测到的目标）被附加到对应的视频缓冲区并向下游传播。第二个模型针对第一阶段检测到的每个目标各运行一次。第二个配置为基于 ROI 处理的 [`qtimlvconverter`](qtimlvconverter) 从输入帧中裁剪每个检测到的区域，并将其准备为第二个 `qtimltflite` 实例的输入。

<img src="https://mintlify.s3.us-west-1.amazonaws.com/qualcomm-prod/zh/SDKs/IMSDK/plugin-reference/images/qtimltflite2.png" alt="" />

<Steps>
  <Step title="下载所需文件">
    | 文件                | 下载                                                                                       | 保存为                        |
    | ----------------- | ---------------------------------------------------------------------------------------- | -------------------------- |
    | 检测模型（YOLOX）       | [Qualcomm AI Hub — YOLOX](https://aihub.qualcomm.com/iot/models/yolox)                   | `yolox_w8a8.tflite`        |
    | 检测标签              | <a href="/SDKs/IMSDK/labels/yolov8.json" download="yolov8.json">yolov8.json</a>          | `yolov8.json`              |
    | 分类模型（InceptionV3） | [Qualcomm AI Hub — InceptionV3](https://aihub.qualcomm.com/iot/models/inception_v3)      | `inception_v3_w8a8.tflite` |
    | 分类标签              | <a href="/SDKs/IMSDK/labels/mobilenet.json" download="mobilenet.json">mobilenet.json</a> | `mobilenet.json`           |

    <Note>
      如果下载的任何文件是 `.zip` 压缩包，请在主机上先解压再复制：
      `unzip filename.zip`
    </Note>
  </Step>

  <Step title="将文件复制到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip> "mkdir -p $HOME/{models,labels}"
      scp yolox_w8a8.tflite            <user>@<device-ip>:$HOME/models/
      scp yolov8.json                  <user>@<device-ip>:$HOME/labels/
      scp inception_v3_w8a8.tflite     <user>@<device-ip>:$HOME/models/
      scp mobilenet.json               <user>@<device-ip>:$HOME/labels/
      ```
    </CodeGroup>
  </Step>

  <Step title="连接到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip>
      ```
    </CodeGroup>
  </Step>

  <Step title="设置环境变量">
    在设备上运行以下命令

    ```bash theme={null}
    export MODEL_NAME_1=yolox_w8a8.tflite
    export LABELS_NAME_1=yolov8.json
    export MODEL_NAME_2=inception_v3_w8a8.tflite
    export LABELS_NAME_2=mobilenet.json
    ```
  </Step>

  <Step title="运行流水线">
    ```bash Run the pipeline theme={null}
    gst-launch-1.0 -e --gst-debug=2 \
      qtimlvconverter name=stage_01_preproc \
      qtimltflite name=stage_01_inference delegate=external external-delegate-path=libQnnTFLiteDelegate.so \
      external-delegate-options="QNNExternalDelegate,backend_type=htp,log_level=(string)1;" \
      model=$HOME/models/$MODEL_NAME_1 \
      qtimlpostprocess name=stage_01_postproc module=yolov8 labels=$HOME/labels/$LABELS_NAME_1 \
      settings="{\"confidence\": 51.0}" \
      qtimetamux name=metamux_1 \
      qtivoverlay name=main_overlay \
      qtimlvconverter name=stage_02_preproc \
      qtimltflite name=stage_02_inference delegate=external external-delegate-path=libQnnTFLiteDelegate.so \
      external-delegate-options="QNNExternalDelegate,backend_type=htp,log_level=(string)1;" \
      model=$HOME/models/$MODEL_NAME_2 \
      qtimlpostprocess name=stage_02_postproc module=mobilenet labels=$HOME/labels/$LABELS_NAME_2 \
      settings="{\"confidence\": 51.0}" \
      qtimetamux name=metamux_2 \
      qtivoverlay name=cls_overlay \
      qticamsrc name=camsrc ! video/x-raw,format=NV12,width=1920,height=1080,framerate=30/1 ! queue ! \
      tee name=t_split_1 \
      t_split_1. ! queue ! metamux_1. \
      t_split_1. ! queue ! stage_01_preproc. stage_01_preproc. ! queue ! stage_01_inference. stage_01_inference. ! queue ! \
      stage_01_postproc. stage_01_postproc. ! text/x-raw ! queue ! metamux_1. \
      metamux_1. ! queue ! tee name=t_split_2 \
      t_split_2. ! queue ! metamux_2. \
      t_split_2. ! queue ! stage_02_preproc. stage_02_preproc. ! queue ! stage_02_inference. stage_02_inference. ! queue ! \
      stage_02_postproc. stage_02_postproc. ! text/x-raw ! queue ! metamux_2. \
      metamux_2. ! queue ! cls_overlay. cls_overlay. ! queue ! waylandsink sync=true fullscreen=true
    ```
  </Step>
</Steps>

### 实时摄像头流上的四阶段级联（Daisy Chain）AI 推理

本示例演示了一个面向实时手势识别用例的多阶段推理工作流，由四个通过四个 qtimltflite 实例执行的 TensorFlow Lite 模型构建。

* **阶段 1** 执行全帧手掌检测。输入视频帧经过预处理、推理和后处理，生成描述检测到的手掌的元数据。
* **阶段 2** 执行按 ROI 的手部关键点推理。第一阶段检测到的区域被裁剪并批量处理。使用两条后处理路径：一条生成可视化元数据，另一条为下一阶段重新格式化输出张量。
* **阶段 3** 以纯张量模式链接两个模型，不进行额外的预处理或后处理。第一个模型消费上一阶段生成的多个张量，其输出直接传递给第二个模型。
* **阶段 4** 执行最终的手势分类，并将模型输出转换为供下游使用的元数据。

<img src="https://mintlify.s3.us-west-1.amazonaws.com/qualcomm-prod/zh/SDKs/IMSDK/plugin-reference/images/qtimltflite3.png" alt="" />

<Steps>
  <Step title="下载所需文件">
    从 Google MediaPipe 下载手势识别器模型：

    ```bash theme={null}
    # Download the gesture recognizer task
    wget https://storage.googleapis.com/mediapipe-models/gesture_recognizer/gesture_recognizer/float16/latest/gesture_recognizer.task 

    # Extract the .task file
    unzip gesture_recognizer.task
    # This gives you two more task files: hand_landmarker.task and hand_gesture_recognizer.task

    # Extract hand_landmarker.task
    unzip hand_landmarker.task
    # This gives you hand_detector.tflite and hand_landmarks_detector.tflite

    # Extract hand_gesture_recognizer.task
    unzip hand_gesture_recognizer.task
    # This gives you gesture_embedder.tflite and canned_gesture_classifier.tflite
    ```

    <Note>这些是 FLOAT 精度模型。</Note>

    | 文件      | 下载                                                                                                                   | 保存为                                |
    | ------- | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
    | 手掌检测模型  | 参见上面的下载步骤                                                                                                            | `hand_detector.tflite`             |
    | 手掌检测标签  | <a href="/SDKs/IMSDK/labels/palmd_labels.json" download="palmd_labels.json">palmd\_labels.json</a>                   | `palmd_labels.json`                |
    | 手掌检测设置  | <a href="/SDKs/IMSDK/labels/palmd_settings.json" download="palmd_settings.json">palmd\_settings.json</a>             | `palmd_settings.json`              |
    | 手部关键点模型 | 参见上面的下载步骤                                                                                                            | `hand_landmarks_detector.tflite`   |
    | 手部关键点标签 | <a href="/SDKs/IMSDK/labels/hlandmark_labels.json" download="hlandmark_labels.json">hlandmark\_labels.json</a>       | `hlandmark_labels.json`            |
    | 手部关键点设置 | <a href="/SDKs/IMSDK/labels/hlandmark_settings.json" download="hlandmark_settings.json">hlandmark\_settings.json</a> | `hlandmark_settings.json`          |
    | 手势嵌入模型  | 参见上面的下载步骤                                                                                                            | `gesture_embedder.tflite`          |
    | 手势分类模型  | 参见上面的下载步骤                                                                                                            | `canned_gesture_classifier.tflite` |
    | 手势标签    | <a href="/SDKs/IMSDK/labels/gesture_labels.json" download="gesture_labels.json">gesture\_labels.json</a>             | `gesture_labels.json`              |
  </Step>

  <Step title="将文件复制到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip> "mkdir -p $HOME/{models,labels}"
      scp hand_detector.tflite               <user>@<device-ip>:$HOME/models/
      scp palmd_labels.json                  <user>@<device-ip>:$HOME/labels/
      scp palmd_settings.json                <user>@<device-ip>:$HOME/labels/
      scp hand_landmarks_detector.tflite     <user>@<device-ip>:$HOME/models/
      scp hlandmark_labels.json              <user>@<device-ip>:$HOME/labels/
      scp hlandmark_settings.json            <user>@<device-ip>:$HOME/labels/
      scp gesture_embedder.tflite            <user>@<device-ip>:$HOME/models/
      scp canned_gesture_classifier.tflite   <user>@<device-ip>:$HOME/models/
      scp gesture_labels.json                <user>@<device-ip>:$HOME/labels/
      ```
    </CodeGroup>
  </Step>

  <Step title="连接到设备">
    <CodeGroup>
      ```bash SCP (SSH) theme={null}
      # Run from your host machine — replace <user> and <device-ip>
      ssh <user>@<device-ip>
      ```
    </CodeGroup>
  </Step>

  <Step title="设置环境变量">
    在设备上运行以下命令

    ```bash theme={null}
    export MODEL_NAME_1=hand_detector.tflite
    export LABELS_NAME_1=palmd_labels.json
    export LABELS_NAME_2=palmd_settings.json
    export MODEL_NAME_2=hand_landmarks_detector.tflite
    export LABELS_NAME_3=hlandmark_labels.json
    export LABELS_NAME_4=hlandmark_settings.json
    export MODEL_NAME_3=gesture_embedder.tflite
    export MODEL_NAME_4=canned_gesture_classifier.tflite
    export LABELS_NAME_5=gesture_labels.json
    ```
  </Step>

  <Step title="运行流水线">
    ```bash Run the pipeline theme={null}
    gst-launch-1.0 -e --gst-debug=2 \
    qtimlvconverter name=stage_01_preproc \
    qtimltflite name=stage_01_inference delegate=gpu model=$HOME/models/$MODEL_NAME_1 \
    qtimlpostprocess name=stage_01_postproc results=1 module=palmd labels=$HOME/labels/$LABELS_NAME_1 settings=$HOME/labels/$LABELS_NAME_2 \
    qtimlvconverter name=stage_02_preproc mode=roi-batch-non-cumulative \
    qtimltflite name=stage_02_inference delegate=gpu model=$HOME/models/$MODEL_NAME_2 \
    qtimlpostprocess name=stage_02_1_postproc results=6 module=hlandmark labels=/$HOME/labels/$LABELS_NAME_3 settings=$HOME/labels/$LABELS_NAME_4 \
    qtimlpostprocess name=stage_02_2_postproc results=6 module=tensor \
    qtimltflite name=stage_03_1_inference delegate=gpu model=$HOME/models/$MODEL_NAME_3 \
    qtimltflite name=stage_03_2_inference delegate=gpu model=$HOME/models/$MODEL_NAME_4 \
    qtimlpostprocess name=stage_03_postproc results=8 module=mobilenet labels=$HOME/labels/$LABELS_NAME_5 \
    qticamsrc ! video/x-raw,format=NV12,width=1920,height=1080,framerate=30/1 ! queue ! tee name=t_split_1 \
    t_split_1. ! queue ! qtimetamux name=metamux_1 ! queue ! qtimetatransform module=roi-palmd ! queue ! tee name=t_split_2 \
    t_split_1. ! queue ! stage_01_preproc. stage_01_preproc. ! queue ! stage_01_inference. stage_01_inference. ! queue ! stage_01_postproc. stage_01_postproc. ! text/x-raw ! queue ! metamux_1. \
    t_split_2. ! queue ! qtimetamux name=metamux_2 ! queue ! qtivoverlay ! waylandsink fullscreen=true sync=false \
    t_split_2. ! queue ! stage_02_preproc. stage_02_preproc. ! queue ! stage_02_inference. stage_02_inference. ! queue ! tee name=t_split_3 \
    t_split_3. ! queue ! stage_02_1_postproc. stage_02_1_postproc. ! text/x-raw ! metamux_2. \
    t_split_3. ! queue ! stage_02_2_postproc. stage_02_2_postproc. ! queue ! stage_03_1_inference. stage_03_1_inference. ! stage_03_2_inference. stage_03_2_inference. ! stage_03_postproc. stage_03_postproc. ! text/x-raw ! metamux_2.
    ```
  </Step>
</Steps>